@pushpalsdev/cli 1.1.7 → 1.1.9

package/dist/pushpals-cli.js

@@ -1644,6 +1644,7 @@ var WINDOWS_TASKKILL_TIMEOUT_MS2 = 5000;
 var RUNTIME_BINARY_DOWNLOAD_ATTEMPTS = 3;
 var DEFAULT_STARTUP_GIT_PROBE_TIMEOUT_MS = 5000;
 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 EMBEDDED_RUNTIME_SAFETY_CAP_DISABLE_ENV = "PUSHPALS_DISABLE_EMBEDDED_SAFETY_CAPS";
@@ -1677,6 +1678,13 @@ function formatRuntimeStartupTimingSummary(input) {
   const detail = typeof input.detail === "string" && input.detail.trim() ? ` detail=${input.detail.trim()}` : "";
   return `[pushpals] startup timing summary: outcome=${input.outcome} ` + `total=${Math.max(0, Math.floor(input.totalDurationMs))}ms${detail}` + (phaseSummary ? ` ${phaseSummary}` : "");
 }
+function formatEmbeddedServiceLaunchDelayWarning(input) {
+  const durationMs = Math.max(0, Math.floor(Number(input.durationMs) || 0));
+  const serviceName = String(input.serviceName || "service");
+  const platform = String(input.platform ?? process.platform);
+  const windowsHint = platform === "win32" ? " On Windows, first-run standalone binaries can be delayed while security software scans them." : "";
+  return `[pushpals] Embedded ${serviceName} process launch took ${durationMs}ms; startup is continuing.` + windowsHint;
+}
 function describeWorkerExecutionReadiness(opts) {
   const onlineWorkers = Math.max(0, Math.floor(opts.onlineWorkers));
   const idleWorkers = Math.max(0, Math.floor(opts.idleWorkers));
@@ -4481,10 +4489,34 @@ async function autoStartRuntimeServices(opts) {
     };
   };
   const launchService = (name, command, launchOpts) => {
-    return serviceManager.startService(buildManagedServiceSpec(name, command, launchOpts));
+    const launchStartedAt = Date.now();
+    const service = serviceManager.startService(buildManagedServiceSpec(name, command, launchOpts));
+    const launchDurationMs = Date.now() - launchStartedAt;
+    if (launchDurationMs >= DEFAULT_EMBEDDED_SERVICE_LAUNCH_WARN_MS) {
+      const warning = formatEmbeddedServiceLaunchDelayWarning({
+        serviceName: name,
+        durationMs: launchDurationMs,
+        platform: process.platform
+      });
+      console.warn(warning);
+      appendRuntimeServicesLogLine(runtimeServicesLogPath, warning);
+    }
+    return service;
   };
   const replaceService = (name, command, launchOpts) => {
-    return serviceManager.replaceService(buildManagedServiceSpec(name, command, launchOpts));
+    const launchStartedAt = Date.now();
+    const service = serviceManager.replaceService(buildManagedServiceSpec(name, command, launchOpts));
+    const launchDurationMs = Date.now() - launchStartedAt;
+    if (launchDurationMs >= DEFAULT_EMBEDDED_SERVICE_LAUNCH_WARN_MS) {
+      const warning = formatEmbeddedServiceLaunchDelayWarning({
+        serviceName: name,
+        durationMs: launchDurationMs,
+        platform: process.platform
+      });
+      console.warn(warning);
+      appendRuntimeServicesLogLine(runtimeServicesLogPath, warning);
+    }
+    return service;
   };
   const sandboxPaths = buildWorkerpalSandboxPaths(runtimeRoot);
   const remoteBuddyFallbackBun = process.platform === "win32" ? resolveEmbeddedBunExecutableFromEnv(runtimeEnv, process.platform, process.execPath) : "";
@@ -5905,6 +5937,7 @@ export {
   formatTimestampedCliLine,
   formatSessionEventLine,
   formatRuntimeStartupTimingSummary,
+  formatEmbeddedServiceLaunchDelayWarning,
   formatEmbeddedRuntimeHealthLines2 as formatEmbeddedRuntimeHealthLines,
   extractRemoteBuddySessionConsumerHealth,
   extractRemoteBuddyAutonomousEngineState,

package/package.json

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

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

@@ -2245,11 +2245,14 @@ export function collectQualityGateValidationCommands(params: {
   planning: TaskExecutePlanning;
   changedTestPaths: string[];
   isTestTask: boolean;
+  repo?: string;
+  changedPaths?: string[];
 }): {
   commandsToRun: string[];
   requiredRunnableSteps: string[];
   plannerRunnableSteps: string[];
   fallbackValidationSteps: string[];
+  inferredRepoNativeValidationSteps: string[];
 } {
   const requiredRunnableSteps = runnableValidationCommandsFromSteps(
     params.planning.requiredValidationSteps,
@@ -2266,15 +2269,20 @@ export function collectQualityGateValidationCommands(params: {
           params.changedTestPaths,
         )
       : [];
+  const inferredRepoNativeValidationSteps = params.repo
+    ? inferRepoNativeValidationCommands(params.repo, params.changedPaths ?? [])
+    : [];
   const commandsToRun = dedupeValidationCommands(
     requiredRunnableSteps,
     plannerRunnableSteps.length > 0 ? plannerRunnableSteps : fallbackValidationSteps,
+    inferredRepoNativeValidationSteps,
   ).slice(0, 16);
   return {
     commandsToRun,
     requiredRunnableSteps,
     plannerRunnableSteps,
     fallbackValidationSteps,
+    inferredRepoNativeValidationSteps,
   };
 }
 
@@ -2416,6 +2424,114 @@ function hasBalancedPositiveNegativeAssertions(paths: string[], repo: string): b
   return positiveAssertions > 0 && negativeAssertions > 0;
 }
 
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value as Record<string, unknown>;
+}
+
+function changedPathMentionsGuidance(pathPattern: RegExp, guidance: string): boolean {
+  return pathPattern.test(guidance);
+}
+
+export function collectPrePublishHygieneIssues(params: {
+  repo: string;
+  changedPaths: string[];
+  instruction: string;
+  targetPath?: string;
+  planning: TaskExecutePlanning;
+  reviewAgent?: Record<string, unknown> | null;
+}): string[] {
+  const changedPaths = params.changedPaths.map((path) => path.replace(/\\/g, "/"));
+  const changedPathSet = new Set(changedPaths);
+  const guidance = [
+    params.instruction,
+    params.targetPath ?? "",
+    ...(params.planning.targetPaths ?? []),
+    ...(params.planning.scope.writeGlobs ?? []),
+    ...(params.planning.acceptanceCriteria ?? []),
+    ...(params.planning.validationSteps ?? []),
+    ...((params.reviewAgent?.reviewerFindings as string[] | undefined) ?? []),
+  ]
+    .join("\n")
+    .toLowerCase();
+  const issues: string[] = [];
+
+  if (
+    changedPathSet.has(".gitignore") &&
+    !changedPathMentionsGuidance(/\b(gitignore|ignore file|node_modules|dependency cache)\b/i, guidance)
+  ) {
+    issues.push(
+      "modified .gitignore without task or reviewer guidance requesting ignore-policy changes.",
+    );
+  }
+
+  if (changedPathSet.has("tests/reactNativeMock.ts")) {
+    const changedTestPaths = changedPaths.filter((path) => isAssertionCoverageTestPath(path));
+    const hasConsumerInChangedTests = changedTestPaths.some((rel) => {
+      try {
+        return /reactNativeMock/i.test(readFileSync(resolve(params.repo, rel), "utf8"));
+      } catch {
+        return false;
+      }
+    });
+    const explicitlyRequested = changedPathMentionsGuidance(/reactnativemock|react native mock/i, guidance);
+    if (!hasConsumerInChangedTests && !explicitlyRequested) {
+      issues.push(
+        "changed tests/reactNativeMock.ts without a changed test importing it or explicit reviewer guidance.",
+      );
+    }
+  }
+
+  if (changedPaths.some((path) => /(^|\/)node_modules(\/|$)/i.test(path))) {
+    issues.push("attempted to publish node_modules changes; dependency installs must not become PR content.");
+  }
+
+  return Array.from(new Set(issues));
+}
+
+export function inferRepoNativeValidationCommands(repo: string, changedPaths: string[]): string[] {
+  const packageJsonPath = resolve(repo, "package.json");
+  if (!existsSync(packageJsonPath)) return [];
+
+  let packageJson: {
+    scripts?: Record<string, unknown>;
+    dependencies?: Record<string, unknown>;
+    devDependencies?: Record<string, unknown>;
+  } = {};
+  try {
+    packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return [];
+  }
+
+  const scripts = packageJson.scripts ?? {};
+  const dependencies = {
+    ...(packageJson.dependencies ?? {}),
+    ...(packageJson.devDependencies ?? {}),
+  };
+  const normalizedPaths = changedPaths.map((path) => path.replace(/\\/g, "/"));
+  const hasNonDocChange = normalizedPaths.some((path) => !/\.(?:md|mdx|txt)$/i.test(path));
+  const hasTsChange = normalizedPaths.some((path) => /\.[cm]?tsx?$/i.test(path));
+  const commands: string[] = [];
+
+  if (hasTsChange) {
+    if (typeof scripts.typecheck === "string" && scripts.typecheck.trim()) {
+      commands.push("bun run typecheck");
+    } else if (
+      existsSync(resolve(repo, "tsconfig.json")) ||
+      Object.prototype.hasOwnProperty.call(dependencies, "typescript")
+    ) {
+      commands.push("bun x tsc --noEmit");
+    }
+  }
+
+  if (hasNonDocChange && typeof scripts.lint === "string" && scripts.lint.trim()) {
+    commands.push("bun run lint");
+  }
+
+  return dedupeValidationCommands(commands).slice(0, 4);
+}
+
 async function runDeterministicQualityGate(
   repo: string,
   params: Record<string, unknown>,
@@ -2485,6 +2601,16 @@ async function runDeterministicQualityGate(
     if (!statusResult.ok) {
       addScopeIssue("could not evaluate changed paths from git status.");
     }
+    for (const issue of collectPrePublishHygieneIssues({
+      repo,
+      changedPaths,
+      instruction,
+      targetPath,
+      planning,
+      reviewAgent: asRecord(params.reviewAgent ?? params.review_agent),
+    })) {
+      addScopeIssue(issue);
+    }
     for (const issue of collectWriteScopeIssuesFromChangedPaths(changedPaths, planning)) {
       addScopeIssue(issue);
     }
@@ -2525,6 +2651,8 @@ async function runDeterministicQualityGate(
     planning,
     changedTestPaths,
     isTestTask,
+    repo,
+    changedPaths,
   });
   const validationRuns: ValidationExecutionResult[] = [];
   const outputPolicy = outputPolicyForRuntime(runtimeConfig);
@@ -4478,54 +4606,104 @@ export async function resumePreparedMergeConflictRebase(
     };
   }
 
-  let rebaseContinue = await git(repo, ["-c", "core.editor=true", "rebase", "--continue"]);
-  let continueOutput = combinedGitOutput(rebaseContinue);
-  if (!rebaseContinue.ok && isRebaseEditorPromptOutput(continueOutput)) {
-    rebaseContinue = await git(repo, ["-c", "core.editor=true", "rebase", "--continue"]);
-    continueOutput = combinedGitOutput(rebaseContinue);
-  }
-  if (!rebaseContinue.ok) {
-    const continuingSequencer = await activeGitOperation(repo);
-    if (continuingSequencer === "rebase") {
-      const nextUnresolved = await git(repo, ["diff", "--name-only", "--diff-filter=U"]);
-      if (nextUnresolved.ok) {
-        const nextPaths = parseChangedPathsFromNameOnlyOutput(nextUnresolved.stdout);
-        if (nextPaths.length > 0) {
-          onLog?.(
-            "stdout",
-            `[MergeConflict] Rebase advanced into another conflicted commit with ${nextPaths.length} unresolved file(s); rerunning the resolver on updated sandbox state.`,
-          );
+  const maxContinuationPasses = Math.max(1, MAX_MERGE_CONFLICT_RESOLUTION_PASSES);
+  let lastContinueOutput = "";
+  for (let pass = 1; pass <= maxContinuationPasses; pass += 1) {
+    let rebaseContinue = await git(repo, ["-c", "core.editor=true", "rebase", "--continue"]);
+    let continueOutput = combinedGitOutput(rebaseContinue);
+    if (!rebaseContinue.ok && isRebaseEditorPromptOutput(continueOutput)) {
+      rebaseContinue = await git(repo, ["-c", "core.editor=true", "rebase", "--continue"]);
+      continueOutput = combinedGitOutput(rebaseContinue);
+    }
+    lastContinueOutput = continueOutput;
+
+    if (!rebaseContinue.ok) {
+      if (/no rebase in progress/i.test(continueOutput)) {
+        onLog?.(
+          "stdout",
+          "[MergeConflict] Prepared rebase was already complete after continuation.",
+        );
+        return { ok: true, resumed: true, sequencer: null };
+      }
+      if (/no changes - did you forget to use 'git add'|nothing to commit/i.test(continueOutput)) {
+        const rebaseSkip = await git(repo, ["rebase", "--skip"]);
+        const skipOutput = combinedGitOutput(rebaseSkip);
+        lastContinueOutput = skipOutput || continueOutput;
+        if (!rebaseSkip.ok && !isRebaseConflictOutput(skipOutput)) {
           return {
-            ok: true,
-            resumed: true,
-            sequencer: "rebase",
-            detail: `rebase advanced into another conflicted commit with ${nextPaths.length} unresolved file(s)`,
-            advancedToNextConflict: true,
+            ok: false,
+            error: `Failed to skip empty prepared merge-conflict rebase commit: ${skipOutput}`,
           };
         }
+      } else {
+        const continuingSequencer = await activeGitOperation(repo);
+        if (continuingSequencer === "rebase") {
+          const nextUnresolved = await git(repo, ["diff", "--name-only", "--diff-filter=U"]);
+          if (nextUnresolved.ok) {
+            const nextPaths = parseChangedPathsFromNameOnlyOutput(nextUnresolved.stdout);
+            if (nextPaths.length > 0) {
+              onLog?.(
+                "stdout",
+                `[MergeConflict] Rebase advanced into another conflicted commit with ${nextPaths.length} unresolved file(s); rerunning the resolver on updated sandbox state.`,
+              );
+              return {
+                ok: true,
+                resumed: true,
+                sequencer: "rebase",
+                detail: `rebase advanced into another conflicted commit with ${nextPaths.length} unresolved file(s)`,
+                advancedToNextConflict: true,
+              };
+            }
+          }
+        }
+        return {
+          ok: false,
+          error: `Failed to continue prepared merge-conflict rebase: ${continueOutput}`,
+        };
+      }
+    }
+
+    const remainingSequencer = await activeGitOperation(repo);
+    if (!remainingSequencer) {
+      onLog?.(
+        "stdout",
+        "[MergeConflict] Auto-continued the prepared rebase after the executor returned with no unresolved conflicts.",
+      );
+      return { ok: true, resumed: true, sequencer: null };
+    }
+    if (remainingSequencer !== "rebase") {
+      return { ok: true, resumed: true, sequencer: remainingSequencer };
+    }
+
+    const nextUnresolved = await git(repo, ["diff", "--name-only", "--diff-filter=U"]);
+    if (nextUnresolved.ok) {
+      const nextPaths = parseChangedPathsFromNameOnlyOutput(nextUnresolved.stdout);
+      if (nextPaths.length > 0) {
+        onLog?.(
+          "stdout",
+          `[MergeConflict] Rebase advanced into another conflicted commit with ${nextPaths.length} unresolved file(s); rerunning the resolver on updated sandbox state.`,
+        );
+        return {
+          ok: true,
+          resumed: true,
+          sequencer: "rebase",
+          detail: `rebase advanced into another conflicted commit with ${nextPaths.length} unresolved file(s)`,
+          advancedToNextConflict: true,
+        };
       }
     }
-    return {
-      ok: false,
-      error: `Failed to continue prepared merge-conflict rebase: ${continueOutput}`,
-    };
-  }
 
-  const remainingSequencer = await activeGitOperation(repo);
-  if (!remainingSequencer) {
     onLog?.(
       "stdout",
-      "[MergeConflict] Auto-continued the prepared rebase after the executor returned with no unresolved conflicts.",
+      `[MergeConflict] Rebase still active after continuation pass ${pass}/${maxContinuationPasses}; trying another non-interactive continue.`,
     );
   }
+
   return {
-    ok: true,
-    resumed: true,
-    sequencer: remainingSequencer,
-    detail:
-      remainingSequencer === "rebase"
-        ? "rebase advanced but another continuation step is still required"
-        : undefined,
+    ok: false,
+    error:
+      `Prepared merge-conflict rebase remained active after ${maxContinuationPasses} continuation pass(es).` +
+      (lastContinueOutput ? ` Last output: ${lastContinueOutput}` : ""),
   };
 }