fix(worker): carry the real cause when the pre-PR repair agent fails to launch (#309)

Author: outof-place

apps/worker/src/pre-pr-checks/runner.test.ts

@@ -25,6 +25,7 @@ vi.mock("../lib/logger.js", () => ({
   logger: {
     info: vi.fn(),
     warn: vi.fn(),
+    error: vi.fn(),
   },
 }));
 
@@ -386,11 +387,88 @@ describe("runPrePrChecksWithFixes", () => {
     expect(result.fixCycles).toBe(1);
     expect(result.agentFailure).toMatchObject({
       category: "provider",
-      diagnostic: { failureKind: "cli_exit", exitCode: 7 },
+      diagnostic: {
+        failureKind: "cli_exit",
+        exitCode: 7,
+        detail: "The CLI exited with code 7.",
+      },
     });
     expect(checkRuns).toBe(1);
   });
 
+  it("names the cause when the repair process cannot be launched at all", async () => {
+    // Production runs died here with a failure that named only the boundary:
+    // no exit code, no captured bytes, and the thrown error destroyed at the
+    // catch. Every distinct launch cause has to reach the run record instead.
+    const launchWith = (thrown: unknown) => {
+      mockRunCommand.mockImplementation((cmd, args) => {
+        if (isWrapperLaunch(cmd)) throw thrown;
+        if (cmd === "cat" && args[0] === WORKSPACE_MANIFEST_PATH) {
+          return commandResult(0, JSON.stringify(manifest));
+        }
+        if (cmd === "git" && args[0] === "-C" && args[2] === "rev-parse") {
+          return commandResult(0, "web-head");
+        }
+        if (isConfiguredCheck(cmd)) return commandResult(1, "", "still failing");
+        return commandResult(0, "");
+      });
+      return runPrePrChecksWithFixes(
+        "sbx-test-123",
+        { repositories: [config.repositories[0]!] },
+        "codex",
+        "gpt-5",
+      );
+    };
+
+    const reset = await launchWith(new Error("sandbox connection reset"));
+    expect(reset.agentFailure).toMatchObject({
+      diagnostic: {
+        failureKind: "setup_failed",
+        detail: expect.stringContaining("sandbox connection reset"),
+      },
+    });
+
+    const refused = await launchWith(
+      Object.assign(new Error("connect ECONNREFUSED 10.0.0.1:443"), {
+        code: "ECONNREFUSED",
+      }),
+    );
+    expect(refused.agentFailure?.diagnostic.detail).toContain(
+      "ECONNREFUSED: connect ECONNREFUSED 10.0.0.1:443",
+    );
+  });
+
+  it("bounds a very long launch failure cause instead of embedding it whole", async () => {
+    const thrownMessage = "sandbox refused the launch. ".repeat(200);
+    mockRunCommand.mockImplementation((cmd, args) => {
+      if (isWrapperLaunch(cmd)) throw new Error(thrownMessage);
+      if (cmd === "cat" && args[0] === WORKSPACE_MANIFEST_PATH) {
+        return commandResult(0, JSON.stringify(manifest));
+      }
+      if (cmd === "git" && args[0] === "-C" && args[2] === "rev-parse") {
+        return commandResult(0, "web-head");
+      }
+      if (isConfiguredCheck(cmd)) return commandResult(1, "", "still failing");
+      return commandResult(0, "");
+    });
+
+    const result = await runPrePrChecksWithFixes(
+      "sbx-test-123",
+      { repositories: [config.repositories[0]!] },
+      "codex",
+      "gpt-5",
+    );
+
+    const detail = result.agentFailure?.diagnostic.detail ?? "";
+    expect(detail).toContain("The Pre-PR repair process could not be launched:");
+    expect(detail).not.toContain(thrownMessage);
+    // Sentence plus the bound the repair cause is clamped to, and nothing more,
+    // so a runaway error text cannot become the run status.
+    expect(detail.length).toBeLessThanOrEqual(
+      "The Pre-PR repair process could not be launched: ".length + 200,
+    );
+  });
+
   it("keeps valid repair usage when malformed protocol output becomes an execution failure", async () => {
     let checkRuns = 0;
     const malformedWithUsage = [
@@ -666,6 +744,18 @@ function isConfiguredCheck(cmd: unknown): boolean {
   );
 }
 
+function isWrapperLaunch(cmd: unknown): boolean {
+  const objectCommand = cmd as { cmd?: unknown; args?: unknown };
+  return (
+    typeof cmd === "object" &&
+    cmd !== null &&
+    objectCommand.cmd === "bash" &&
+    Array.isArray(objectCommand.args) &&
+    typeof objectCommand.args[0] === "string" &&
+    objectCommand.args[0].endsWith("-wrapper.sh")
+  );
+}
+
 function isHeadInspection(cmd: unknown): boolean {
   const objectCommand = cmd as { cmd?: unknown; args?: unknown };
   return (

apps/worker/src/pre-pr-checks/runner.ts

@@ -26,6 +26,12 @@ import {
 
 export const MAX_PRE_PR_FIX_CYCLES = 3;
 
+/** Longest launch cause carried into the Pre-PR repair failure detail. Same
+ *  bound the workspace gate puts on a carried inspection reason (AIW-223): long
+ *  enough for a connection or spawn verdict, short enough that the composed
+ *  sentence stays a failure detail rather than a payload. */
+const PRE_PR_LAUNCH_CAUSE_MAX_LENGTH = 200;
+
 export interface PrePrCheckFailure {
   provider: WorkspaceRepo["provider"];
   repoPath: string;
@@ -396,15 +402,38 @@ async function runFixAgent(
     ) {
       throw error;
     }
-    const { protocolFailure } = await import("../sandbox/agents/protocol.js");
+    const { protocolFailure, redactDiagnosticText } = await import(
+      "../sandbox/agents/protocol.js"
+    );
+    const { logger } = await import("../lib/logger.js");
+    // The thrown error used to be discarded here, so a launch that never
+    // produced a process left no exit code, no bytes and no cause: the only
+    // reachable text named the boundary. Carry the reason, redacted and bounded
+    // exactly like a diagnostic tail so a runaway error text cannot become the
+    // run status. The kind is `setup_failed`, not `provider_error`: nothing was
+    // sent to a provider, this is the same "the phase never started" family as
+    // the chmod failure above, and calling it a provider error is what made
+    // every occurrence read as spent provider credits.
+    const code = (error as { code?: unknown }).code;
+    const label =
+      typeof code === "string" && code
+        ? code
+        : error instanceof Error
+          ? error.name
+          : "";
+    const message = error instanceof Error ? error.message : String(error);
+    const cause = redactDiagnosticText(
+      label && label !== "Error" ? `${label}: ${message}` : message,
+    ).slice(0, PRE_PR_LAUNCH_CAUSE_MAX_LENGTH);
+    logger.error({ phase, cause }, "pre_pr_repair_launch_failed");
     const failure = protocolFailure({
       spec: adapter.cliSpec,
       phase,
       artifacts: { stdout: "", stderr: "", structuredOutput: null, exitCode: null },
-      failureKind: "provider_error",
+      failureKind: "setup_failed",
       category: "provider",
       message: "The current agent phase could not be completed.",
-      detail: "The Pre-PR repair process could not be launched.",
+      detail: `The Pre-PR repair process could not be launched: ${cause}`,
     });
     if (failure.ok) throw new Error("unreachable");
     return { usage: null, failure };