@cat-factory/executor-harness 1.50.16 → 1.50.18

package/dist/agent-runner.js

@@ -319,21 +319,7 @@ export async function runClaudeCode(opts) {
             : join(homedir(), '.claude', 'skills');
         await writeNativeSkill(skillsRoot, opts.skill).catch(() => { });
     }
-    // Anthropic itself authenticates with the subscription OAuth token; a
-    // non-Anthropic Claude-Code vendor (GLM via Z.ai, Kimi via Moonshot, DeepSeek)
-    // points Claude Code at its Anthropic-compatible endpoint with an auth-token key.
-    // Ambient mode injects neither — the CLI uses the developer's logged-in `~/.claude`.
-    const env = opts.ambientAuth
-        ? {}
-        : {
-            CLAUDE_CONFIG_DIR: configHome,
-            ...(opts.subscriptionBaseUrl
-                ? {
-                    ANTHROPIC_BASE_URL: opts.subscriptionBaseUrl,
-                    ANTHROPIC_AUTH_TOKEN: opts.subscriptionToken,
-                }
-                : { CLAUDE_CODE_OAUTH_TOKEN: opts.subscriptionToken }),
-        };
+    const env = buildClaudeEnv(opts, configHome);
     // ADR 0026 D3 (path corrected by ADR 0027 Defect A): while the run is live, tail the CLI's
     // subagent `*.jsonl` transcripts so a parallel-subagent review keeps the inactivity
     // heartbeat alive (any new bytes ⇒ `onActivity`) and its otherwise-invisible token spend is
@@ -369,38 +355,7 @@ export async function runClaudeCode(opts) {
                 ...appendArgs,
             ],
         }, prompt, opts, env, opts.subscriptionToken ? secretsToRedact(opts.subscriptionToken) : [], onEvent);
-        // The parent's cumulative-usage fallback applies to the PARENT calls only (before the
-        // subagent calls, which carry their own per-turn tokens, are concatenated).
-        attributeCumulativeUsage(calls, usage);
-        // Final drain of any subagent transcript writes that landed after the last poll, then
-        // fold the subagents' usage + per-call telemetry into the run's outcome — their tokens
-        // never appear on the parent stream, so this is the only place they are accounted.
-        await subagents?.stop();
-        const subUsage = subagents?.usage() ?? { inputTokens: 0, outputTokens: 0 };
-        const subCalls = subagents?.calls() ?? [];
-        const mergedCalls = [...calls, ...subCalls];
-        // INVARIANT (do not "fix" this into a double count): the run total is the parent usage
-        // PLUS the subagent usage because the two are disjoint sources. The parent `usage` here
-        // is the terminal `result` event's cumulative, which covers ONLY the parent loop — the
-        // ADR 0026 incident is itself the proof: a heavily subagent-parallelised review reported
-        // ~0 tokens, i.e. the parent stream (and its `result` total) never included the subagent
-        // spend. The subagent tokens live exclusively in the per-session `subagents/*.jsonl`
-        // transcripts, which the watcher reads and nothing else does; it deliberately EXCLUDES the
-        // sibling parent session transcript (whose usage `result` already totals), so neither
-        // `calls` nor `usage` can already contain the subagent spend.
-        const mergedUsage = usage || subUsage.inputTokens || subUsage.outputTokens
-            ? {
-                inputTokens: (usage?.inputTokens ?? 0) + subUsage.inputTokens,
-                outputTokens: (usage?.outputTokens ?? 0) + subUsage.outputTokens,
-            }
-            : undefined;
-        return {
-            summary,
-            stats,
-            stderrTail,
-            ...(mergedUsage ? { usage: mergedUsage } : {}),
-            ...(mergedCalls.length ? { callMetrics: mergedCalls } : {}),
-        };
+        return await assembleClaudeOutcome({ summary, stats, stderrTail, calls, usage, subagents });
     }
     finally {
         await subagents?.stop();
@@ -417,6 +372,59 @@ export async function runClaudeCode(opts) {
         }
     }
 }
+/**
+ * Build the child-process env for the `claude` CLI: an isolated config home plus subscription
+ * auth (Anthropic OAuth token, or an Anthropic-compatible base URL + auth token for a
+ * non-Anthropic Claude-Code vendor like GLM/Kimi/DeepSeek), or an empty env in ambient mode
+ * (the developer's own logged-in `~/.claude` is used). Extracted from {@link runClaudeCode} to
+ * keep its cyclomatic complexity down; behaviour is a straight move of the original expression.
+ */
+function buildClaudeEnv(opts, configHome) {
+    if (opts.ambientAuth)
+        return {};
+    return {
+        CLAUDE_CONFIG_DIR: configHome,
+        ...(opts.subscriptionBaseUrl
+            ? {
+                ANTHROPIC_BASE_URL: opts.subscriptionBaseUrl,
+                ANTHROPIC_AUTH_TOKEN: opts.subscriptionToken,
+            }
+            : { CLAUDE_CODE_OAUTH_TOKEN: opts.subscriptionToken }),
+    };
+}
+/**
+ * Merge the parent-loop telemetry with the subagents' out-of-band usage + per-call metrics into
+ * the run outcome. INVARIANT (do not "fix" this into a double count): the run total is the parent
+ * usage PLUS the subagent usage because the two are disjoint sources — the parent `usage` (the
+ * terminal `result` event's cumulative) covers ONLY the parent loop, and the subagent tokens live
+ * exclusively in the per-session `subagents/*.jsonl` transcripts the watcher reads. Extracted from
+ * {@link runClaudeCode} verbatim to keep its cyclomatic complexity down.
+ */
+async function assembleClaudeOutcome(args) {
+    const { summary, stats, stderrTail, calls, usage, subagents } = args;
+    // The parent's cumulative-usage fallback applies to the PARENT calls only (before the
+    // subagent calls, which carry their own per-turn tokens, are concatenated).
+    attributeCumulativeUsage(calls, usage);
+    // Final drain of any subagent transcript writes that landed after the last poll, then
+    // fold the subagents' usage + per-call telemetry into the run's outcome.
+    await subagents?.stop();
+    const subUsage = subagents?.usage() ?? { inputTokens: 0, outputTokens: 0 };
+    const subCalls = subagents?.calls() ?? [];
+    const mergedCalls = [...calls, ...subCalls];
+    const mergedUsage = usage || subUsage.inputTokens || subUsage.outputTokens
+        ? {
+            inputTokens: (usage?.inputTokens ?? 0) + subUsage.inputTokens,
+            outputTokens: (usage?.outputTokens ?? 0) + subUsage.outputTokens,
+        }
+        : undefined;
+    return {
+        summary,
+        stats,
+        stderrTail,
+        ...(mergedUsage ? { usage: mergedUsage } : {}),
+        ...(mergedCalls.length ? { callMetrics: mergedCalls } : {}),
+    };
+}
 /** Map Claude Code's `TodoWrite` todos array onto subtask counts. */
 function todosToProgress(todos) {
     if (!Array.isArray(todos))

package/dist/agent.js

@@ -745,14 +745,12 @@ async function runCodingMode(job, opts) {
     return result;
 }
 /**
- * The ordinary single-repo coding flow: clone `branch` (or resume `newBranch`), run the agent,
- * commit + push to `pushBranch`, and open `pr` when one is set and the run produced changes. A
- * no-op is a failure for the implementer (`noChangesIsError` default) and a non-fatal no-op for
- * the in-place fixers (and for a seed-only kind like `repro-test`).
+ * Assemble the {@link runCodingAgent} spec for the ordinary single-repo coding flow. Extracted
+ * from {@link runSingleRepoCoding} so the many optional-field spreads don't inflate that
+ * function's cyclomatic complexity; the mapping is a straight field copy off `job`.
  */
-async function runSingleRepoCoding(job, opts) {
-    const pushBranch = job.pushBranch ?? job.newBranch ?? job.branch;
-    const { summary, stats, stderrTail, pushed, usage, callMetrics, validation, effortReport } = await runCodingAgent({
+function buildSingleRepoCodingSpec(job, pushBranch) {
+    return {
         kind: 'agent',
         jobId: job.jobId,
         repo: job.repo,
@@ -789,7 +787,17 @@ async function runSingleRepoCoding(job, opts) {
                 },
             }
             : {}),
-    }, opts);
+    };
+}
+/**
+ * The ordinary single-repo coding flow: clone `branch` (or resume `newBranch`), run the agent,
+ * commit + push to `pushBranch`, and open `pr` when one is set and the run produced changes. A
+ * no-op is a failure for the implementer (`noChangesIsError` default) and a non-fatal no-op for
+ * the in-place fixers (and for a seed-only kind like `repro-test`).
+ */
+async function runSingleRepoCoding(job, opts) {
+    const pushBranch = job.pushBranch ?? job.newBranch ?? job.branch;
+    const { summary, stats, stderrTail, pushed, usage, callMetrics, validation, effortReport } = await runCodingAgent(buildSingleRepoCodingSpec(job, pushBranch), opts);
     // Ralph loop: the harness-computed validation verdict, forwarded onto the coding result as
     // `ralphVerdict` so the backend's `toRunResult` lifts it onto `AgentRunResult.ralphVerdict`.
     const ralphVerdict = validation ? { ralphVerdict: validation } : {};

package/dist/job.js

@@ -555,6 +555,24 @@ function isReservedEnvName(key) {
     const lower = key.toLowerCase();
     return RESERVED_ENV_PREFIXES.some((p) => lower.startsWith(p));
 }
+/**
+ * Collect only string→string entries from a raw `env` bag. A non-string value is dropped so a
+ * malformed binding can't inject `[object Object]` (or undefined) as an upstream URL. Reserved
+ * names that would break the toolchain or enable injection (PATH, NODE_OPTIONS, LD_PRELOAD, …) are
+ * dropped too: they are spread over `process.env` at build time, so a binding named `PATH` would
+ * replace it with a URL and the build would no longer find its tools. Extracted from the infra
+ * parsers to keep their cyclomatic complexity down.
+ */
+function parseInfraEnv(raw) {
+    const env = {};
+    if (typeof raw === 'object' && raw !== null) {
+        for (const [key, val] of Object.entries(raw)) {
+            if (key && !isReservedEnvName(key) && typeof val === 'string')
+                env[key] = val;
+        }
+    }
+    return env;
+}
 /** Parse the frontend UI-test infra spec (`kind: 'frontend'`), tolerating missing knobs. */
 function parseFrontendInfraSpec(o) {
     const packageManager = o.packageManager === 'pnpm' || o.packageManager === 'npm' || o.packageManager === 'yarn'
@@ -562,18 +580,7 @@ function parseFrontendInfraSpec(o) {
         : undefined;
     const serveMode = o.serveMode === 'static' || o.serveMode === 'command' ? o.serveMode : undefined;
     const envInjection = o.envInjection === 'build' || o.envInjection === 'runtime' ? o.envInjection : undefined;
-    // Only string→string entries survive; a non-string value is dropped so a malformed
-    // binding can't inject `[object Object]` (or undefined) as an upstream URL. Reserved names
-    // that would break the toolchain or enable injection (PATH, NODE_OPTIONS, LD_PRELOAD, …) are
-    // dropped too: they are spread over `process.env` at build time, so a binding named `PATH`
-    // would replace it with a URL and the build would no longer find its tools.
-    const env = {};
-    if (typeof o.env === 'object' && o.env !== null) {
-        for (const [key, val] of Object.entries(o.env)) {
-            if (key && !isReservedEnvName(key) && typeof val === 'string')
-                env[key] = val;
-        }
-    }
+    const env = parseInfraEnv(o.env);
     const servePort = port(o.servePort);
     const wiremockPort = port(o.wiremockPort);
     // The app's monorepo subdirectory becomes the install/build/serve cwd, so it goes through the
@@ -732,11 +739,7 @@ function assembleAgentJob(o, mode, agentField, parts) {
         ghToken: str(o.ghToken, 'ghToken'),
         repo: parseRepoSpec(repo),
         branch: str(o.branch, 'branch'),
-        ...(typeof o.githubApiBase === 'string' ? { githubApiBase: o.githubApiBase } : {}),
-        ...(typeof o.webToolsGuidance === 'string' ? { webToolsGuidance: o.webToolsGuidance } : {}),
-        ...(o.webSearch === true ? { webSearch: true } : {}),
-        ...(o.full === true ? { full: true } : {}),
-        ...(typeof o.mergeBase === 'string' && o.mergeBase ? { mergeBase: o.mergeBase } : {}),
+        ...collectOptionalRequestFields(o),
         ...(bootstrap ? { bootstrap } : {}),
         ...(output ? { output } : {}),
         ...(contextFiles.length ? { contextFiles } : {}),
@@ -744,20 +747,35 @@ function assembleAgentJob(o, mode, agentField, parts) {
         ...(skill ? { skill } : {}),
         ...(testSecrets.length ? { testSecrets } : {}),
         ...(infra ? { infra } : {}),
-        ...(typeof o.newBranch === 'string' && o.newBranch ? { newBranch: o.newBranch } : {}),
-        ...(typeof o.pushBranch === 'string' && o.pushBranch ? { pushBranch: o.pushBranch } : {}),
-        ...(typeof o.commitMessage === 'string' && o.commitMessage
-            ? { commitMessage: o.commitMessage }
-            : {}),
         ...(pr ? { pr } : {}),
         ...(peerRepos.length ? { peerRepos } : {}),
         ...(referenceRepos.length ? { referenceRepos } : {}),
         ...(referenceBranches.length ? { referenceBranches } : {}),
         ...(reviewPrNumber !== undefined ? { reviewPrNumber } : {}),
+        ...(guardLimits ? { guardLimits } : {}),
+        ...(validation ? { validation } : {}),
+    };
+}
+/**
+ * The optional {@link AgentJob} fields read directly off the request `o` (booleans + trimmed
+ * strings). Extracted from {@link assembleAgentJob} to keep its cyclomatic complexity down; every
+ * key is unique so grouping the conditional spreads is behaviour-neutral (spread order is
+ * irrelevant with no colliding keys).
+ */
+function collectOptionalRequestFields(o) {
+    return {
+        ...(typeof o.githubApiBase === 'string' ? { githubApiBase: o.githubApiBase } : {}),
+        ...(typeof o.webToolsGuidance === 'string' ? { webToolsGuidance: o.webToolsGuidance } : {}),
+        ...(o.webSearch === true ? { webSearch: true } : {}),
+        ...(o.full === true ? { full: true } : {}),
+        ...(typeof o.mergeBase === 'string' && o.mergeBase ? { mergeBase: o.mergeBase } : {}),
+        ...(typeof o.newBranch === 'string' && o.newBranch ? { newBranch: o.newBranch } : {}),
+        ...(typeof o.pushBranch === 'string' && o.pushBranch ? { pushBranch: o.pushBranch } : {}),
+        ...(typeof o.commitMessage === 'string' && o.commitMessage
+            ? { commitMessage: o.commitMessage }
+            : {}),
         ...(o.noChangesIsError === false ? { noChangesIsError: false } : {}),
         ...(o.persistentCheckout === true ? { persistentCheckout: true } : {}),
         ...(o.streamFollowUps === true ? { streamFollowUps: true } : {}),
-        ...(guardLimits ? { guardLimits } : {}),
-        ...(validation ? { validation } : {}),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/executor-harness",
-  "version": "1.50.16",
+  "version": "1.50.18",
   "description": "Container payload: a thin TypeScript wrapper that runs the Pi coding agent against a cloned repo and opens a PR. Runs in the Cloudflare Container (and, in local native mode, as a host process); carries no secrets.",
   "repository": {
     "type": "git",
@@ -26,8 +26,8 @@
     "hono": "^4.12.30",
     "typescript": "7.0.2",
     "vitest": "^4.1.10",
-    "@cat-factory/server": "0.142.0",
-    "@cat-factory/spend": "0.12.74"
+    "@cat-factory/server": "0.143.1",
+    "@cat-factory/spend": "0.12.75"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/src/agent-runner.ts

@@ -424,21 +424,7 @@ export async function runClaudeCode(opts: SubscriptionRunOptions): Promise<PiRun
     await writeNativeSkill(skillsRoot, opts.skill).catch(() => {})
   }
 
-  // Anthropic itself authenticates with the subscription OAuth token; a
-  // non-Anthropic Claude-Code vendor (GLM via Z.ai, Kimi via Moonshot, DeepSeek)
-  // points Claude Code at its Anthropic-compatible endpoint with an auth-token key.
-  // Ambient mode injects neither — the CLI uses the developer's logged-in `~/.claude`.
-  const env: Record<string, string> = opts.ambientAuth
-    ? {}
-    : {
-        CLAUDE_CONFIG_DIR: configHome!,
-        ...(opts.subscriptionBaseUrl
-          ? {
-              ANTHROPIC_BASE_URL: opts.subscriptionBaseUrl,
-              ANTHROPIC_AUTH_TOKEN: opts.subscriptionToken!,
-            }
-          : { CLAUDE_CODE_OAUTH_TOKEN: opts.subscriptionToken! }),
-      }
+  const env = buildClaudeEnv(opts, configHome)
 
   // ADR 0026 D3 (path corrected by ADR 0027 Defect A): while the run is live, tail the CLI's
   // subagent `*.jsonl` transcripts so a parallel-subagent review keeps the inactivity
@@ -484,39 +470,7 @@ export async function runClaudeCode(opts: SubscriptionRunOptions): Promise<PiRun
       onEvent,
     )
 
-    // The parent's cumulative-usage fallback applies to the PARENT calls only (before the
-    // subagent calls, which carry their own per-turn tokens, are concatenated).
-    attributeCumulativeUsage(calls, usage)
-    // Final drain of any subagent transcript writes that landed after the last poll, then
-    // fold the subagents' usage + per-call telemetry into the run's outcome — their tokens
-    // never appear on the parent stream, so this is the only place they are accounted.
-    await subagents?.stop()
-    const subUsage = subagents?.usage() ?? { inputTokens: 0, outputTokens: 0 }
-    const subCalls = subagents?.calls() ?? []
-    const mergedCalls = [...calls, ...subCalls]
-    // INVARIANT (do not "fix" this into a double count): the run total is the parent usage
-    // PLUS the subagent usage because the two are disjoint sources. The parent `usage` here
-    // is the terminal `result` event's cumulative, which covers ONLY the parent loop — the
-    // ADR 0026 incident is itself the proof: a heavily subagent-parallelised review reported
-    // ~0 tokens, i.e. the parent stream (and its `result` total) never included the subagent
-    // spend. The subagent tokens live exclusively in the per-session `subagents/*.jsonl`
-    // transcripts, which the watcher reads and nothing else does; it deliberately EXCLUDES the
-    // sibling parent session transcript (whose usage `result` already totals), so neither
-    // `calls` nor `usage` can already contain the subagent spend.
-    const mergedUsage =
-      usage || subUsage.inputTokens || subUsage.outputTokens
-        ? {
-            inputTokens: (usage?.inputTokens ?? 0) + subUsage.inputTokens,
-            outputTokens: (usage?.outputTokens ?? 0) + subUsage.outputTokens,
-          }
-        : undefined
-    return {
-      summary,
-      stats,
-      stderrTail,
-      ...(mergedUsage ? { usage: mergedUsage } : {}),
-      ...(mergedCalls.length ? { callMetrics: mergedCalls } : {}),
-    }
+    return await assembleClaudeOutcome({ summary, stats, stderrTail, calls, usage, subagents })
   } finally {
     await subagents?.stop()
     if (configHome) {
@@ -533,6 +487,71 @@ export async function runClaudeCode(opts: SubscriptionRunOptions): Promise<PiRun
   }
 }
 
+/**
+ * Build the child-process env for the `claude` CLI: an isolated config home plus subscription
+ * auth (Anthropic OAuth token, or an Anthropic-compatible base URL + auth token for a
+ * non-Anthropic Claude-Code vendor like GLM/Kimi/DeepSeek), or an empty env in ambient mode
+ * (the developer's own logged-in `~/.claude` is used). Extracted from {@link runClaudeCode} to
+ * keep its cyclomatic complexity down; behaviour is a straight move of the original expression.
+ */
+function buildClaudeEnv(
+  opts: SubscriptionRunOptions,
+  configHome: string | undefined,
+): Record<string, string> {
+  if (opts.ambientAuth) return {}
+  return {
+    CLAUDE_CONFIG_DIR: configHome!,
+    ...(opts.subscriptionBaseUrl
+      ? {
+          ANTHROPIC_BASE_URL: opts.subscriptionBaseUrl,
+          ANTHROPIC_AUTH_TOKEN: opts.subscriptionToken!,
+        }
+      : { CLAUDE_CODE_OAUTH_TOKEN: opts.subscriptionToken! }),
+  }
+}
+
+/**
+ * Merge the parent-loop telemetry with the subagents' out-of-band usage + per-call metrics into
+ * the run outcome. INVARIANT (do not "fix" this into a double count): the run total is the parent
+ * usage PLUS the subagent usage because the two are disjoint sources — the parent `usage` (the
+ * terminal `result` event's cumulative) covers ONLY the parent loop, and the subagent tokens live
+ * exclusively in the per-session `subagents/*.jsonl` transcripts the watcher reads. Extracted from
+ * {@link runClaudeCode} verbatim to keep its cyclomatic complexity down.
+ */
+async function assembleClaudeOutcome(args: {
+  summary: string
+  stats: PiRunStats
+  stderrTail: string
+  calls: HarnessCallMetric[]
+  usage: { inputTokens: number; outputTokens: number } | undefined
+  subagents: ReturnType<typeof startSubagentWatcher> | undefined
+}): Promise<PiRunOutcome> {
+  const { summary, stats, stderrTail, calls, usage, subagents } = args
+  // The parent's cumulative-usage fallback applies to the PARENT calls only (before the
+  // subagent calls, which carry their own per-turn tokens, are concatenated).
+  attributeCumulativeUsage(calls, usage)
+  // Final drain of any subagent transcript writes that landed after the last poll, then
+  // fold the subagents' usage + per-call telemetry into the run's outcome.
+  await subagents?.stop()
+  const subUsage = subagents?.usage() ?? { inputTokens: 0, outputTokens: 0 }
+  const subCalls = subagents?.calls() ?? []
+  const mergedCalls = [...calls, ...subCalls]
+  const mergedUsage =
+    usage || subUsage.inputTokens || subUsage.outputTokens
+      ? {
+          inputTokens: (usage?.inputTokens ?? 0) + subUsage.inputTokens,
+          outputTokens: (usage?.outputTokens ?? 0) + subUsage.outputTokens,
+        }
+      : undefined
+  return {
+    summary,
+    stats,
+    stderrTail,
+    ...(mergedUsage ? { usage: mergedUsage } : {}),
+    ...(mergedCalls.length ? { callMetrics: mergedCalls } : {}),
+  }
+}
+
 /** Map Claude Code's `TodoWrite` todos array onto subtask counts. */
 function todosToProgress(todos: unknown): TodoProgress | undefined {
   if (!Array.isArray(todos)) return undefined

package/src/agent.ts

@@ -903,6 +903,55 @@ async function runCodingMode(job: AgentJob, opts: RunOptions): Promise<AgentResu
   return result
 }
 
+/**
+ * Assemble the {@link runCodingAgent} spec for the ordinary single-repo coding flow. Extracted
+ * from {@link runSingleRepoCoding} so the many optional-field spreads don't inflate that
+ * function's cyclomatic complexity; the mapping is a straight field copy off `job`.
+ */
+function buildSingleRepoCodingSpec(
+  job: AgentJob,
+  pushBranch: string,
+): Parameters<typeof runCodingAgent>[0] {
+  return {
+    kind: 'agent',
+    jobId: job.jobId,
+    repo: job.repo,
+    cloneBranch: job.branch,
+    ...(job.newBranch ? { newBranch: job.newBranch } : {}),
+    pushBranch,
+    ghToken: job.ghToken,
+    systemPrompt: job.systemPrompt,
+    userPrompt: job.userPrompt,
+    model: job.model,
+    harness: job.harness,
+    subscriptionToken: job.subscriptionToken,
+    subscriptionBaseUrl: job.subscriptionBaseUrl,
+    ambientAuth: job.ambientAuth,
+    proxyBaseUrl: job.proxyBaseUrl,
+    sessionToken: job.sessionToken,
+    commitMessage: job.commitMessage ?? job.pr?.title ?? 'Agent changes',
+    webToolsGuidance: job.webToolsGuidance,
+    webSearchProxy: job.webSearch,
+    guardLimits: job.guardLimits,
+    ...(job.persistentCheckout ? { persistentCheckout: true } : {}),
+    ...(job.streamFollowUps ? { streamFollowUps: true } : {}),
+    ...(job.referenceBranches?.length ? { referenceBranches: job.referenceBranches } : {}),
+    // Repo-sourced skill (slice 2): installed harness-aware by runAgentInWorkspace.
+    ...(job.skill ? { skill: job.skill } : {}),
+    // Ralph loop: run the completion command after the agent commits and report its verdict.
+    ...(job.validation
+      ? {
+          validation: {
+            command: job.validation.command,
+            ...(job.validation.iteration !== undefined
+              ? { iteration: job.validation.iteration }
+              : {}),
+          },
+        }
+      : {}),
+  }
+}
+
 /**
  * The ordinary single-repo coding flow: clone `branch` (or resume `newBranch`), run the agent,
  * commit + push to `pushBranch`, and open `pr` when one is set and the run produced changes. A
@@ -912,47 +961,7 @@ async function runCodingMode(job: AgentJob, opts: RunOptions): Promise<AgentResu
 async function runSingleRepoCoding(job: AgentJob, opts: RunOptions): Promise<AgentResult> {
   const pushBranch = job.pushBranch ?? job.newBranch ?? job.branch
   const { summary, stats, stderrTail, pushed, usage, callMetrics, validation, effortReport } =
-    await runCodingAgent(
-      {
-        kind: 'agent',
-        jobId: job.jobId,
-        repo: job.repo,
-        cloneBranch: job.branch,
-        ...(job.newBranch ? { newBranch: job.newBranch } : {}),
-        pushBranch,
-        ghToken: job.ghToken,
-        systemPrompt: job.systemPrompt,
-        userPrompt: job.userPrompt,
-        model: job.model,
-        harness: job.harness,
-        subscriptionToken: job.subscriptionToken,
-        subscriptionBaseUrl: job.subscriptionBaseUrl,
-        ambientAuth: job.ambientAuth,
-        proxyBaseUrl: job.proxyBaseUrl,
-        sessionToken: job.sessionToken,
-        commitMessage: job.commitMessage ?? job.pr?.title ?? 'Agent changes',
-        webToolsGuidance: job.webToolsGuidance,
-        webSearchProxy: job.webSearch,
-        guardLimits: job.guardLimits,
-        ...(job.persistentCheckout ? { persistentCheckout: true } : {}),
-        ...(job.streamFollowUps ? { streamFollowUps: true } : {}),
-        ...(job.referenceBranches?.length ? { referenceBranches: job.referenceBranches } : {}),
-        // Repo-sourced skill (slice 2): installed harness-aware by runAgentInWorkspace.
-        ...(job.skill ? { skill: job.skill } : {}),
-        // Ralph loop: run the completion command after the agent commits and report its verdict.
-        ...(job.validation
-          ? {
-              validation: {
-                command: job.validation.command,
-                ...(job.validation.iteration !== undefined
-                  ? { iteration: job.validation.iteration }
-                  : {}),
-              },
-            }
-          : {}),
-      },
-      opts,
-    )
+    await runCodingAgent(buildSingleRepoCodingSpec(job, pushBranch), opts)
   // Ralph loop: the harness-computed validation verdict, forwarded onto the coding result as
   // `ralphVerdict` so the backend's `toRunResult` lifts it onto `AgentRunResult.ralphVerdict`.
   const ralphVerdict = validation ? { ralphVerdict: validation } : {}

package/src/job.ts

@@ -1124,6 +1124,24 @@ function isReservedEnvName(key: string): boolean {
   return RESERVED_ENV_PREFIXES.some((p) => lower.startsWith(p))
 }
 
+/**
+ * Collect only string→string entries from a raw `env` bag. A non-string value is dropped so a
+ * malformed binding can't inject `[object Object]` (or undefined) as an upstream URL. Reserved
+ * names that would break the toolchain or enable injection (PATH, NODE_OPTIONS, LD_PRELOAD, …) are
+ * dropped too: they are spread over `process.env` at build time, so a binding named `PATH` would
+ * replace it with a URL and the build would no longer find its tools. Extracted from the infra
+ * parsers to keep their cyclomatic complexity down.
+ */
+function parseInfraEnv(raw: unknown): Record<string, string> {
+  const env: Record<string, string> = {}
+  if (typeof raw === 'object' && raw !== null) {
+    for (const [key, val] of Object.entries(raw as Record<string, unknown>)) {
+      if (key && !isReservedEnvName(key) && typeof val === 'string') env[key] = val
+    }
+  }
+  return env
+}
+
 /** Parse the frontend UI-test infra spec (`kind: 'frontend'`), tolerating missing knobs. */
 function parseFrontendInfraSpec(o: Record<string, unknown>): FrontendInfraSpec {
   const packageManager =
@@ -1133,17 +1151,7 @@ function parseFrontendInfraSpec(o: Record<string, unknown>): FrontendInfraSpec {
   const serveMode = o.serveMode === 'static' || o.serveMode === 'command' ? o.serveMode : undefined
   const envInjection =
     o.envInjection === 'build' || o.envInjection === 'runtime' ? o.envInjection : undefined
-  // Only string→string entries survive; a non-string value is dropped so a malformed
-  // binding can't inject `[object Object]` (or undefined) as an upstream URL. Reserved names
-  // that would break the toolchain or enable injection (PATH, NODE_OPTIONS, LD_PRELOAD, …) are
-  // dropped too: they are spread over `process.env` at build time, so a binding named `PATH`
-  // would replace it with a URL and the build would no longer find its tools.
-  const env: Record<string, string> = {}
-  if (typeof o.env === 'object' && o.env !== null) {
-    for (const [key, val] of Object.entries(o.env as Record<string, unknown>)) {
-      if (key && !isReservedEnvName(key) && typeof val === 'string') env[key] = val
-    }
-  }
+  const env = parseInfraEnv(o.env)
   const servePort = port(o.servePort)
   const wiremockPort = port(o.wiremockPort)
   // The app's monorepo subdirectory becomes the install/build/serve cwd, so it goes through the
@@ -1376,11 +1384,7 @@ function assembleAgentJob(
     ghToken: str(o.ghToken, 'ghToken'),
     repo: parseRepoSpec(repo),
     branch: str(o.branch, 'branch'),
-    ...(typeof o.githubApiBase === 'string' ? { githubApiBase: o.githubApiBase } : {}),
-    ...(typeof o.webToolsGuidance === 'string' ? { webToolsGuidance: o.webToolsGuidance } : {}),
-    ...(o.webSearch === true ? { webSearch: true } : {}),
-    ...(o.full === true ? { full: true } : {}),
-    ...(typeof o.mergeBase === 'string' && o.mergeBase ? { mergeBase: o.mergeBase } : {}),
+    ...collectOptionalRequestFields(o),
     ...(bootstrap ? { bootstrap } : {}),
     ...(output ? { output } : {}),
     ...(contextFiles.length ? { contextFiles } : {}),
@@ -1388,20 +1392,36 @@ function assembleAgentJob(
     ...(skill ? { skill } : {}),
     ...(testSecrets.length ? { testSecrets } : {}),
     ...(infra ? { infra } : {}),
-    ...(typeof o.newBranch === 'string' && o.newBranch ? { newBranch: o.newBranch } : {}),
-    ...(typeof o.pushBranch === 'string' && o.pushBranch ? { pushBranch: o.pushBranch } : {}),
-    ...(typeof o.commitMessage === 'string' && o.commitMessage
-      ? { commitMessage: o.commitMessage }
-      : {}),
     ...(pr ? { pr } : {}),
     ...(peerRepos.length ? { peerRepos } : {}),
     ...(referenceRepos.length ? { referenceRepos } : {}),
     ...(referenceBranches.length ? { referenceBranches } : {}),
     ...(reviewPrNumber !== undefined ? { reviewPrNumber } : {}),
+    ...(guardLimits ? { guardLimits } : {}),
+    ...(validation ? { validation } : {}),
+  }
+}
+
+/**
+ * The optional {@link AgentJob} fields read directly off the request `o` (booleans + trimmed
+ * strings). Extracted from {@link assembleAgentJob} to keep its cyclomatic complexity down; every
+ * key is unique so grouping the conditional spreads is behaviour-neutral (spread order is
+ * irrelevant with no colliding keys).
+ */
+function collectOptionalRequestFields(o: Record<string, unknown>): Partial<AgentJob> {
+  return {
+    ...(typeof o.githubApiBase === 'string' ? { githubApiBase: o.githubApiBase } : {}),
+    ...(typeof o.webToolsGuidance === 'string' ? { webToolsGuidance: o.webToolsGuidance } : {}),
+    ...(o.webSearch === true ? { webSearch: true } : {}),
+    ...(o.full === true ? { full: true } : {}),
+    ...(typeof o.mergeBase === 'string' && o.mergeBase ? { mergeBase: o.mergeBase } : {}),
+    ...(typeof o.newBranch === 'string' && o.newBranch ? { newBranch: o.newBranch } : {}),
+    ...(typeof o.pushBranch === 'string' && o.pushBranch ? { pushBranch: o.pushBranch } : {}),
+    ...(typeof o.commitMessage === 'string' && o.commitMessage
+      ? { commitMessage: o.commitMessage }
+      : {}),
     ...(o.noChangesIsError === false ? { noChangesIsError: false } : {}),
     ...(o.persistentCheckout === true ? { persistentCheckout: true } : {}),
     ...(o.streamFollowUps === true ? { streamFollowUps: true } : {}),
-    ...(guardLimits ? { guardLimits } : {}),
-    ...(validation ? { validation } : {}),
   }
 }