@pushpalsdev/cli 1.0.53 → 1.0.55

package/package.json

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

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

@@ -64,6 +64,11 @@ interface ValidationExecutionResult {
   elapsedMs: number;
 }
 
+interface ValidationBlocker {
+  category: "repo" | "environment";
+  detail: string;
+}
+
 interface DeterministicQualityResult {
   ok: boolean;
   skipped: boolean;
@@ -71,6 +76,7 @@ interface DeterministicQualityResult {
   changedPaths: string[];
   changedTestPaths: string[];
   validationRuns: ValidationExecutionResult[];
+  blocker: ValidationBlocker | null;
 }
 
 interface CriticReview {
@@ -198,6 +204,30 @@ export function buildQualityGateRevisionIssues(
   return [...new Set(merged)];
 }
 
+const TEST_ASSERTION_BALANCE_ISSUE =
+  "Changed test files do not show both positive and negative assertion coverage (expected both).";
+
+export function relaxAdvisoryQualityIssues(
+  qualityIssues: string[],
+  validationRuns: Array<{ ok: boolean }>,
+  critic: CriticReview | null,
+  qualityCriticMinScore: number,
+): string[] {
+  const normalizedQualityIssues = qualityIssues
+    .map((entry) => String(entry ?? "").trim())
+    .filter(Boolean);
+  if (normalizedQualityIssues.length === 0) return [];
+
+  const hasPassingValidation = validationRuns.some((run) => Boolean(run?.ok));
+  const criticPasses = !critic || critic.score >= qualityCriticMinScore;
+  if (!hasPassingValidation || !criticPasses) {
+    return normalizedQualityIssues;
+  }
+
+  const relaxed = normalizedQualityIssues.filter((issue) => issue !== TEST_ASSERTION_BALANCE_ISSUE);
+  return relaxed;
+}
+
 export function resolveReviewFixCompletionBranch(
   value: unknown,
   fallbackBranch: string,
@@ -323,7 +353,7 @@ export function deriveQualityGatePolicy(
       return {
         mode: "merge_conflict",
         maxAutoRevisions: baseMaxAutoRevisions,
-        softPassOnExhausted: false,
+        softPassOnExhausted: baseSoftPassOnExhausted,
         criticMinScore: baseCriticMinScore,
       };
     }
@@ -341,7 +371,7 @@ export function deriveQualityGatePolicy(
   return {
     mode: "review_fix",
     maxAutoRevisions: Math.max(baseMaxAutoRevisions, 2),
-    softPassOnExhausted: false,
+    softPassOnExhausted: baseSoftPassOnExhausted,
     criticMinScore: tightenedCriticMinScore,
   };
 }
@@ -533,6 +563,60 @@ async function runValidationCommand(
   };
 }
 
+function extractPreparedMergeConflictPaths(params: Record<string, unknown>): string[] {
+  const reviewAgent =
+    params.reviewAgent && typeof params.reviewAgent === "object" && !Array.isArray(params.reviewAgent)
+      ? (params.reviewAgent as Record<string, unknown>)
+      : null;
+  const preparedPaths = Array.isArray(reviewAgent?.preparedConflictPaths)
+    ? reviewAgent.preparedConflictPaths
+    : [];
+  return preparedPaths
+    .map((entry) => String(entry ?? "").trim().replace(/\\/g, "/"))
+    .filter(Boolean);
+}
+
+function detectValidationBlocker(runs: ValidationExecutionResult[]): ValidationBlocker | null {
+  const combined = runs
+    .flatMap((run) => [run.stdout, run.stderr])
+    .filter(Boolean)
+    .join("\n")
+    .toLowerCase();
+  if (!combined) return null;
+
+  if (
+    combined.includes("cannot find module") ||
+    combined.includes("module not found") ||
+    combined.includes("failed to resolve import") ||
+    combined.includes("could not resolve") ||
+    combined.includes("no such file or directory") ||
+    combined.includes("package not found")
+  ) {
+    return {
+      category: "repo",
+      detail:
+        "Validation is blocked by missing repo dependencies or imported files. Fix the repository test/runtime setup before retrying this job.",
+    };
+  }
+
+  if (
+    combined.includes("read-only file system") ||
+    combined.includes("permission denied") ||
+    combined.includes("network access") ||
+    combined.includes("connection refused") ||
+    combined.includes("getaddrinfo") ||
+    combined.includes("eacces")
+  ) {
+    return {
+      category: "environment",
+      detail:
+        "Validation is blocked by sandbox environment restrictions (filesystem, permissions, or network). Retry only after the worker environment is fixed.",
+    };
+  }
+
+  return null;
+}
+
 function stripAnsiControlSequences(value: string): string {
   return value.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "");
 }
@@ -722,7 +806,7 @@ function isTestFocusedTask(
 
 function hasBalancedPositiveNegativeAssertions(paths: string[], repo: string): boolean {
   const negativeSignal =
-    /\b(invalid|negative|error|throw|reject|null|undefined|non[- ]?existent|toThrow|toBeNull|toBeUndefined|<\s*0|<=\s*0)\b/i;
+    /(\.not\b|\b(invalid|negative|error|throw|reject|null|undefined|non[- ]?existent|toThrow|toBeNull|toBeUndefined|without|missing|absent|unchanged|same|remains?|stays?|prevent|avoid|zero|none)\b|<\s*0|<=\s*0)/i;
   let positiveAssertions = 0;
   let negativeAssertions = 0;
 
@@ -762,12 +846,18 @@ async function runDeterministicQualityGate(
       changedPaths: [],
       changedTestPaths: [],
       validationRuns: [],
+      blocker: null,
     };
   }
 
   const statusResult = await git(repo, ["status", "--porcelain"]);
   const changedPaths = statusResult.ok ? parseChangedPathsFromStatus(statusResult.stdout) : [];
-  const changedTestPaths = changedPaths.filter((path) => isLikelyTestPath(path));
+  const preparedMergeConflictPaths = extractPreparedMergeConflictPaths(params);
+  const changedTestPaths = Array.from(
+    new Set(
+      [...changedPaths, ...preparedMergeConflictPaths].filter((path) => isLikelyTestPath(path)),
+    ),
+  );
   const issues: string[] = [];
   if (changedTestPaths.length === 0) {
     issues.push("No relevant test file was modified for this test-focused task.");
@@ -848,14 +938,16 @@ async function runDeterministicQualityGate(
       issues.push("Validation steps did not execute a recognizable test command.");
     }
   }
+  const blocker = detectValidationBlocker(validationRuns);
 
   return {
-    ok: issues.length === 0,
+    ok: issues.length === 0 && blocker === null,
     skipped: false,
     issues,
     changedPaths,
     changedTestPaths,
     validationRuns,
+    blocker,
   };
 }
 
@@ -3491,12 +3583,12 @@ export async function executeJob(
         : qualityCriticMinScore.toFixed(1);
     onLog?.(
       "stdout",
-      `[QualityGate] review_fix override active: prior_score=${priorScore}, target_threshold=${threshold}, soft_pass_on_exhausted=false.`,
+      `[QualityGate] review_fix policy active: prior_score=${priorScore}, target_threshold=${threshold}, soft_pass_on_exhausted=${qualitySoftPassOnExhausted ? "true" : "false"}; repo/environment blockers still fail hard.`,
     );
   } else if (qualityGatePolicy.mode === "merge_conflict") {
     onLog?.(
       "stdout",
-      "[QualityGate] merge_conflict override active: soft_pass_on_exhausted=false until the sandbox rebase is fully completed.",
+      `[QualityGate] merge_conflict policy active: soft_pass_on_exhausted=${qualitySoftPassOnExhausted ? "true" : "false"}; unfinished rebases and repo/environment blockers still fail hard.`,
     );
   }
 
@@ -3567,7 +3659,20 @@ 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 effectiveQualityIssues = relaxAdvisoryQualityIssues(
+      quality.issues,
+      quality.validationRuns,
+      critic,
+      qualityCriticMinScore,
+    );
+    if (effectiveQualityIssues.length !== quality.issues.length) {
+      onLog?.(
+        "stdout",
+        "[QualityGate] Assertion-balance heuristic downgraded to advisory because validation passed and critic score met threshold.",
+      );
+    }
+    const deterministicRequiresRevision =
+      effectiveQualityIssues.length > 0 || quality.blocker !== null;
     const criticRequiresRevision = Boolean(critic && critic.score < qualityCriticMinScore);
 
     if (!deterministicRequiresRevision && !criticRequiresRevision) {
@@ -3580,8 +3685,29 @@ export async function executeJob(
       return result;
     }
 
-    const issues = buildQualityGateRevisionIssues(quality.issues, critic, qualityCriticMinScore);
+    const issues = buildQualityGateRevisionIssues(
+      effectiveQualityIssues,
+      critic,
+      qualityCriticMinScore,
+    );
     const issueSummary = issues.map((entry) => toSingleLine(entry, 180)).join(" | ");
+    if (quality.blocker) {
+      const blockerSummary = `Quality gate blocked by ${quality.blocker.category} issue: ${quality.blocker.detail}`;
+      onLog?.("stderr", `[QualityGate] ${blockerSummary}`);
+      return {
+        ok: false,
+        summary: blockerSummary,
+        stdout: result.stdout,
+        stderr: truncate(
+          [
+            result.stderr ?? "",
+            ...quality.validationRuns.flatMap((run) => [run.stdout, run.stderr]).filter(Boolean),
+          ].join("\n"),
+          outputPolicyForRuntime(runtimeConfig),
+        ),
+        exitCode: 4,
+      };
+    }
     if (revisionAttempt >= qualityMaxAutoRevisions) {
       if (qualitySoftPassOnExhausted) {
         const diagnostics = truncate(