@wardby/cli 0.5.2 → 0.6.0

package/dist/providers/engine/types.d.ts

@@ -48,6 +48,25 @@ export interface LoadedTool {
  * only on earlier step results and on `agent` fields fixed at run start.
  */
 export type StepRunner = <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+/**
+ * Part of the StepRunner contract: a step runner may throw this when another
+ * execution of the same run recorded the step first, so this attempt no
+ * longer owns the run. The attempt must stop without writing the run (the
+ * winner does that); engines and the runner rethrow it untouched.
+ */
+export declare class RunOwnershipLostError extends Error {
+    readonly step: string;
+    /**
+     * Usage the losing step's body reported before its result was discarded
+     * (an LLM turn's token counts and cost), when the step runner saw it. Not
+     * recorded on any run: the winner's result replaces it. Logged only.
+     */
+    readonly discardedUsage?: Readonly<Record<string, number>>;
+    constructor(step: string, options?: {
+        cause?: unknown;
+        discardedUsage?: Readonly<Record<string, number>>;
+    });
+}
 /** The no-checkpoint default: run the step body directly. */
 export declare const runStepInline: StepRunner;
 /**

package/dist/providers/engine/types.js

@@ -12,5 +12,27 @@
  * which engine is driving: an engine that calls a provider SDK directly
  * blinds the pre-flight refuse and mid-stream cutoff, and is not allowed.
  */
+/**
+ * Part of the StepRunner contract: a step runner may throw this when another
+ * execution of the same run recorded the step first, so this attempt no
+ * longer owns the run. The attempt must stop without writing the run (the
+ * winner does that); engines and the runner rethrow it untouched.
+ */
+export class RunOwnershipLostError extends Error {
+    step;
+    /**
+     * Usage the losing step's body reported before its result was discarded
+     * (an LLM turn's token counts and cost), when the step runner saw it. Not
+     * recorded on any run: the winner's result replaces it. Logged only.
+     */
+    discardedUsage;
+    constructor(step, options) {
+        super(`run_ownership_lost: another execution recorded step "${step}" first; this attempt stops.`, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "RunOwnershipLostError";
+        this.step = step;
+        if (options?.discardedUsage)
+            this.discardedUsage = options.discardedUsage;
+    }
+}
 /** The no-checkpoint default: run the step body directly. */
 export const runStepInline = (_name, fn) => fn();

package/dist/providers/executor/composition.d.ts

@@ -1,10 +1,25 @@
 import type { PrismaClient } from "#prisma";
 import { type ProviderConfig } from "../../config/providers.js";
+import { type Power } from "../../core/power.js";
+import { type ReReviewDeps } from "../../core/review-fix.js";
 import type { KubernetesApi } from "../jobs/kubernetes-api.js";
 import type { Executor } from "./types.js";
 import { type RepoAccessGate } from "../../core/repo-access.js";
+/**
+ * The coding-run terminal hook: a review-fix round's coding run that made no change re-reviews
+ * the PR once (core/review-fix.ts). Started in the background so the executor's terminal path
+ * (and the slot release after it) never waits on the host; idempotent, and never throws.
+ * `deps` is read only when a run finishes, after composition returned.
+ */
+export declare function reReviewOnCodingRunTerminal(deps: () => ReReviewDeps): (runId: string) => void;
 export interface ConfiguredExecutorOptions {
     native: Executor;
+    /**
+     * Runs native agents whose run snapshot says `sandbox`. Composed whether or
+     * not a coding job launcher is configured. Absent: sandbox runs go to
+     * `native`, whose runner refuses them (RoutingExecutor).
+     */
+    nativeSandbox?: Executor;
     db: PrismaClient;
     env?: NodeJS.ProcessEnv;
     providerConfig?: ProviderConfig;
@@ -12,6 +27,14 @@ export interface ConfiguredExecutorOptions {
     kubernetesApi?: KubernetesApi;
     /** Repository authorization for coding runs; built from the configured review hosts when absent. */
     repoAccess?: RepoAccessGate;
+    /**
+     * Low-power mode, built once by the composition root and shared. Used only by the Kubernetes
+     * launcher (wakes the coding proxy before a run); absent: `DISABLED_POWER`.
+     */
+    power?: Power;
 }
-/** Builds container execution only when Docker or Kubernetes is explicitly selected. */
+/**
+ * Builds container execution only when Docker or Kubernetes is explicitly
+ * selected, and native sandbox routing whenever a sandbox executor is given.
+ */
 export declare function buildConfiguredExecutor(options: ConfiguredExecutorOptions): Executor;

package/dist/providers/executor/composition.js

@@ -5,6 +5,8 @@ import { summarizeRegistryFetches } from "../../coding/registry/report.js";
 import { drainCodingQueue } from "../../core/coding-queue.js";
 import { prismaServiceStateReporter } from "../../core/coding-service-status.js";
 import { logger } from "../../core/logger.js";
+import { DISABLED_POWER } from "../../core/power.js";
+import { reReviewAfterNoChangeFix } from "../../core/review-fix.js";
 import { EnvironmentCredentialResolver } from "../coding-proxy/environment-credentials.js";
 import { CodingProxy } from "../coding-proxy/proxy.js";
 import { PrismaProxyLedger } from "../coding-proxy/prisma-ledger.js";
@@ -22,12 +24,33 @@ import { createRepoAccessGate } from "../../core/repo-access.js";
 import { buildIssueTrackers } from "../issue-tracker/index.js";
 import { buildReviewHosts } from "../review-host/index.js";
 const compositionLog = logger.child({ module: "executor-composition" });
-/** Builds container execution only when Docker or Kubernetes is explicitly selected. */
+/**
+ * The coding-run terminal hook: a review-fix round's coding run that made no change re-reviews
+ * the PR once (core/review-fix.ts). Started in the background so the executor's terminal path
+ * (and the slot release after it) never waits on the host; idempotent, and never throws.
+ * `deps` is read only when a run finishes, after composition returned.
+ */
+export function reReviewOnCodingRunTerminal(deps) {
+    return (runId) => {
+        void Promise.resolve()
+            .then(() => reReviewAfterNoChangeFix(runId, deps()))
+            .catch((err) => compositionLog.warn({ err, runId }, "no-change re-review hook failed"));
+    };
+}
+/**
+ * Builds container execution only when Docker or Kubernetes is explicitly
+ * selected, and native sandbox routing whenever a sandbox executor is given.
+ */
 export function buildConfiguredExecutor(options) {
     const env = options.env ?? process.env;
     const providerConfig = options.providerConfig ?? loadProviderConfig(env);
-    if (providerConfig.jobs !== "docker" && providerConfig.jobs !== "kubernetes")
-        return options.native;
+    if (providerConfig.jobs !== "docker" && providerConfig.jobs !== "kubernetes") {
+        if (!options.nativeSandbox)
+            return options.native;
+        // No coding launcher: coding runs reach the native executor, whose runner fails them with
+        // the "needs a container executor" explanation, exactly as without this wrapper.
+        return new RoutingExecutor(new PrismaExecutionKindResolver(options.db), options.native, options.native, options.nativeSandbox);
+    }
     const github = loadGitHubVcsConfig(env);
     const config = loadContainerExecutorConfig(env);
     // Each provider's images are optional, but a coding launcher with neither can run nothing.
@@ -80,6 +103,7 @@ export function buildConfiguredExecutor(options) {
             resolveCapability: (runId) => capabilities.get(runId),
             readyTimeoutMs: kubernetes.readyTimeoutMs,
             enforcementExecTimeoutMs: kubernetes.enforcementExecTimeoutMs,
+            power: options.power ?? DISABLED_POWER,
             preflight: async () => {
                 const { proxyIp } = await runKubernetesPreflight({
                     api,
@@ -112,7 +136,9 @@ export function buildConfiguredExecutor(options) {
     }
     const issueTrackers = buildIssueTrackers(env);
     const concurrency = loadCodingConcurrencyConfig(env);
-    // The release hook needs the composed RoutingExecutor, which only exists
+    const reviewHosts = buildReviewHosts(env, options.db);
+    const repoAccess = options.repoAccess ?? createRepoAccessGate({ db: options.db, hosts: reviewHosts });
+    // The release and terminal hooks need the composed RoutingExecutor, which only exists
     // after the ContainerExecutor it wraps is built. The closure reads
     // `composed` only when a run finishes, which is after this function returns.
     const coding = new ContainerExecutor({
@@ -131,12 +157,19 @@ export function buildConfiguredExecutor(options) {
         anthropicCredentialRef: config.anthropicCredentialRef,
         limits: { cpus: config.cpus, memoryMb: config.memoryMb, pids: config.pids, diskMb: config.diskMb },
         maxDiskMb: config.maxDiskMb,
-        repoAccess: options.repoAccess ?? createRepoAccessGate({ db: options.db, hosts: buildReviewHosts(env, options.db) }),
+        repoAccess,
         issueUrl: (provider, key) => (provider === "jira" ? issueTrackers.jira?.issueUrl(key) : undefined),
         registryReport: async (runId) => {
             const rows = await options.db.registryFetch.findMany({ where: { runId }, orderBy: { createdAt: "asc" } });
             return summarizeRegistryFetches(rows);
         },
+        onCodingRunTerminal: reReviewOnCodingRunTerminal(() => ({
+            db: options.db,
+            executor: composed,
+            hosts: reviewHosts,
+            repoAccess,
+            issueTrackers,
+        })),
         onSlotReleased: () => {
             void drainCodingQueue({
                 db: options.db,
@@ -150,6 +183,6 @@ export function buildConfiguredExecutor(options) {
             });
         },
     });
-    const composed = new RoutingExecutor(new PrismaExecutionKindResolver(options.db), options.native, coding);
+    const composed = new RoutingExecutor(new PrismaExecutionKindResolver(options.db), options.native, coding, options.nativeSandbox);
     return composed;
 }

package/dist/providers/executor/container.d.ts

@@ -44,6 +44,8 @@ export interface ContainerRunSnapshot {
     /** The issue that triggered this run (CodingRun.issueProvider/issueKey); null when none. */
     issueProvider?: string | null;
     issueKey?: string | null;
+    /** Step in the delegating agent's declared merge order (CodingRun.mergeOrder); null = no order. */
+    mergeOrder?: number | null;
     budgetUsd: number;
     /** The agent's own per-run budget; `budgetUsd` is less when its budget group had less left. */
     agentBudgetUsd?: number;
@@ -63,6 +65,10 @@ export interface ContainerRunSnapshot {
     debugTrace?: boolean;
     /** Claude Code turn limit, fixed at dispatch (CodingRun.maxTurns); null = the worker default. */
     maxTurns?: number | null;
+    /** Load the repo's agent skills, fixed at dispatch (CodingRun.repoSkills); absent on older snapshots = true. */
+    repoSkills?: boolean;
+    /** Claude Code loading mode, fixed at dispatch (CodingRun.claudeBareMode); absent on older snapshots = true. */
+    claudeBareMode?: boolean;
     /** Coding-run services resolved at dispatch (CodingRun.services); parsed with parseStoredServices. */
     services?: unknown;
     /** The terminal failure category, once the run has one (CodingRun.failureCategory). */
@@ -195,6 +201,15 @@ export interface ContainerExecutorOptions {
      * than on the next scheduler tick. Never called for a run that was queued.
      */
     onSlotReleased?: () => void;
+    /**
+     * Called with the run id at the end of each terminal finish of a collected
+     * job (succeeded, no change, budget, or failed), after the terminal write
+     * and cleanup. It may run more than once for one run (a replayed or
+     * duplicate finish), so it must be idempotent; a rejection or throw is
+     * logged and never reaches the terminal path. composition.ts wires the
+     * review-fix re-review here, so this executor imports no review logic.
+     */
+    onCodingRunTerminal?: (runId: string) => Promise<void> | void;
     /**
      * Loads this run's RegistryFetch ledger (composition.ts wires the Prisma
      * query) so finalizeChanges can surface installed/refused packages in the
@@ -278,6 +293,8 @@ export declare class ContainerExecutor implements Executor {
     private modelTerms;
     private preflight;
     private finishTerminal;
+    /** Runs the onCodingRunTerminal hook; nothing it does, throws, or rejects reaches the caller. */
+    private notifyTerminal;
     /** The package report is informational: any failure loading it (a
      *  rejection, a synchronous throw, or a malformed result) yields no
      *  package section rather than failing finalization. */
@@ -286,7 +303,11 @@ export declare class ContainerExecutor implements Executor {
     resolveCodingWorkerImage(selector: CodingImageSelector): string;
     /** Claude's tool-runner image for the agent's toolchain, at dispatch (Executor.resolveCodingToolImage); null for Codex. */
     resolveCodingToolImage(selector: CodingImageSelector): string | null;
-    /** The tool runner is what runs a Claude agent's commands, so it is what the toolchain selects. */
+    /**
+     * The tool runner is what runs a Claude agent's commands, so it is what the toolchain selects —
+     * unless the agent has a BYO workerImageRef, which replaces the tool runner directly (never the
+     * agent image; see resolveCodingWorkerImage).
+     */
     private claudeToolImage;
     /** Coding-run services: the repository's declaration at its base ref (Executor.readCodingServiceDeclaration). */
     readCodingServiceDeclaration(input: {
@@ -302,6 +323,8 @@ export declare class ContainerExecutor implements Executor {
     }): Promise<string | null>;
     /** The job launcher decides (Kubernetes and Docker start services for both providers). */
     supportsCodingServices(provider: CodingProvider): boolean;
+    /** Delegates to the job launcher's own warm-up (Executor.warmUp); a no-op for a launcher without one. */
+    warmUp(): Promise<void>;
     private requireCurrent;
     /**
      * False when the launcher reports this run's job would not fit the cluster right now; the run

package/dist/providers/executor/container.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
 import { withBaseCommit } from "../../coding/base-commit.js";
+import { buildClaudeContext, MAX_RECORDED_SKIPS } from "../../coding/claude-context.js";
 import { normalizeCollectExclusions } from "../../coding/collect-exclude.js";
 import { codingProviderForModelProvider } from "../../coding/provider.js";
 import { CodingProfileSchema } from "../../coding/profile.js";
@@ -19,7 +20,7 @@ import { logger } from "../../core/logger.js";
 import { requiredLevel } from "../../core/repo-access.js";
 import { ensurePrivateDirectory } from "../../core/private-directory.js";
 import { codingRunObserver } from "../../coding/observability.js";
-import { CODING_PROTOCOL_VERSION, CodingRunResultSchema, CodingTaskInputSchema, parseCodingAgentOutputJson, redactAndTruncate, } from "../../coding/protocol.js";
+import { CODING_PROTOCOL_VERSION, CodingRunResultSchema, CodingTaskInputSchema, MAX_CODING_INPUT_BYTES, parseCodingAgentOutputJson, redactAndTruncate, } from "../../coding/protocol.js";
 import { parseStoredEntry } from "../llm/catalog-types.js";
 import { resolveCodingEntry } from "../../core/run-pricing.js";
 import { CODING_PROXY_ALIAS, CODING_PROXY_PORT, isImmutableDockerImage } from "../jobs/docker-isolation.js";
@@ -28,6 +29,8 @@ import { ISSUE_KEY, ISSUE_TRACKER_NAMES } from "../issue-tracker/types.js";
 import { HEARTBEAT_TIMEOUT_MS } from "../../core/timing.js";
 import { collectRelatedPullRequests } from "../../core/related-pull-requests.js";
 const containerLog = logger.child({ module: "container-executor" });
+/** A logged context skip path is cut to this many characters: a refused import is reported as written. */
+const MAX_LOGGED_SKIP_PATH_CHARS = 256;
 /** The input path in a spec built only to ask the launcher about capacity; never written or read. */
 const CAPACITY_PROBE_INPUT = "/dev/null";
 const TERMINAL_STATUSES = new Set(["succeeded", "failed", "refused", "lost", "budget_exhausted", "cancelled"]);
@@ -109,6 +112,7 @@ export class PrismaContainerExecutionStore {
             rootCodingRunId: row.codingRun.rootCodingRunId,
             issueProvider: row.codingRun.issueProvider,
             issueKey: row.codingRun.issueKey,
+            mergeOrder: row.codingRun.mergeOrder,
             budgetUsd: Number(row.codingRun.budgetReservedUsd),
             agentBudgetUsd: Number(row.agent.budgetUsd),
             budgetGroupName: row.agent.budgetGroup?.name ?? null,
@@ -126,6 +130,8 @@ export class PrismaContainerExecutionStore {
             workspaceDiskMb: row.codingRun.workspaceDiskMb,
             debugTrace: row.codingRun.debugTrace,
             maxTurns: row.codingRun.maxTurns,
+            repoSkills: row.codingRun.repoSkills,
+            claudeBareMode: row.codingRun.claudeBareMode,
             services: row.codingRun.services,
             failureCategory: row.codingRun.failureCategory,
             profileRepository: row.agent.codingProfile?.repository ?? null,
@@ -141,6 +147,7 @@ export class PrismaContainerExecutionStore {
             repository: pr.repository,
             number: pr.number,
             ...(pr.state ? { state: pr.state } : {}),
+            ...(pr.mergeOrder !== undefined ? { mergeOrder: pr.mergeOrder } : {}),
         }));
     }
     async claimProvisioning(runId, claimId) {
@@ -545,7 +552,7 @@ export class ContainerExecutor {
                 spendEnabled = true;
                 sessionId = session.id;
                 this.options.capabilities.set(runId, session.capability);
-                const inputArtifact = await this.writeInput(run, deadlineAt, workspace.baseCommit);
+                const inputArtifact = await this.writeInput(run, deadlineAt, workspace);
                 const beforeLaunch = await this.requireCurrent(runId);
                 if (TERMINAL_STATUSES.has(beforeLaunch.status))
                     throw new Error("coding_run_no_longer_active");
@@ -715,7 +722,14 @@ export class ContainerExecutor {
             const { issue } = this.issueFor(run);
             return {
                 related: {
-                    entries: [...earlier, { repository: run.repository, self: true }],
+                    entries: [
+                        ...earlier,
+                        {
+                            repository: run.repository,
+                            self: true,
+                            ...(run.mergeOrder != null ? { mergeOrder: run.mergeOrder } : {}),
+                        },
+                    ],
                     ...(issue ? { issue } : {}),
                 },
             };
@@ -920,6 +934,19 @@ export class ContainerExecutor {
             }
             await rm(this.artifactPath(run.runId), { recursive: true, force: true }).catch(() => undefined);
             this.emit({ stage: "cleanup", runId: run.runId, jobId: handle.id, cleanupSucceeded: true });
+            await this.notifyTerminal(run.runId);
+        }
+    }
+    /** Runs the onCodingRunTerminal hook; nothing it does, throws, or rejects reaches the caller. */
+    async notifyTerminal(runId) {
+        const hook = this.options.onCodingRunTerminal;
+        if (!hook)
+            return;
+        try {
+            await hook(runId);
+        }
+        catch (err) {
+            containerLog.warn({ err, runId }, "coding run terminal hook failed");
         }
     }
     /** The package report is informational: any failure loading it (a
@@ -965,8 +992,10 @@ export class ContainerExecutor {
     }
     resolveCodingWorkerImage(selector) {
         if (selector.provider === "claude-code") {
+            // workerImageRef never replaces the Claude Code agent image (the container that holds the
+            // run's key); on a Claude Code agent it selects the tool runner (claudeToolImage).
             this.claudeToolImage(selector);
-            const image = selector.workerImageRef ?? this.options.claudeWorkerImage;
+            const image = this.options.claudeWorkerImage;
             if (!image)
                 throw new Error("coding_provider_not_configured:claude-code");
             if (!isImmutableDockerImage(image))
@@ -976,7 +1005,7 @@ export class ContainerExecutor {
         if (selector.provider !== "codex") {
             throw new Error(`coding_provider_unsupported:${String(selector.provider)}`);
         }
-        if (selector.workerImageRef) {
+        if (selector.workerImageRef !== null) {
             if (!isImmutableDockerImage(selector.workerImageRef))
                 throw new Error("coding_worker_image_invalid");
             return selector.workerImageRef;
@@ -997,10 +1026,20 @@ export class ContainerExecutor {
     resolveCodingToolImage(selector) {
         return selector.provider === "claude-code" ? this.claudeToolImage(selector) : null;
     }
-    /** The tool runner is what runs a Claude agent's commands, so it is what the toolchain selects. */
+    /**
+     * The tool runner is what runs a Claude agent's commands, so it is what the toolchain selects —
+     * unless the agent has a BYO workerImageRef, which replaces the tool runner directly (never the
+     * agent image; see resolveCodingWorkerImage).
+     */
     claudeToolImage(selector) {
         if (!this.options.claudeToolRunnerImage)
             throw new Error("coding_provider_not_configured:claude-code");
+        // An admin-set custom image (workerImageRef) is where this agent's commands run.
+        if (selector.workerImageRef !== null) {
+            if (!isImmutableDockerImage(selector.workerImageRef))
+                throw new Error("coding_worker_image_invalid");
+            return selector.workerImageRef;
+        }
         const image = selector.toolchain === "node" && selector.toolchainVersion === null
             ? this.options.claudeToolRunnerImage
             : selector.toolchainVersion !== null
@@ -1038,6 +1077,10 @@ export class ContainerExecutor {
     supportsCodingServices(provider) {
         return this.options.jobs.supportsServicesFor?.(provider) === true;
     }
+    /** Delegates to the job launcher's own warm-up (Executor.warmUp); a no-op for a launcher without one. */
+    async warmUp() {
+        await this.options.jobs.warmUp?.();
+    }
     async requireCurrent(runId) {
         const current = await this.options.store.load(runId);
         if (!current)
@@ -1099,7 +1142,7 @@ export class ContainerExecutor {
             return this.options.anthropicCredentialRef;
         throw new Error("coding_provider_not_configured:claude-code");
     }
-    async writeInput(run, deadlineAt, baseCommit) {
+    async writeInput(run, deadlineAt, workspace) {
         await ensurePrivateDirectory(this.artifactRoot);
         const rootReal = await realpath(this.artifactRoot);
         const directory = resolve(rootReal, run.runId);
@@ -1111,11 +1154,24 @@ export class ContainerExecutor {
         const destination = join(directory, "input.json");
         const temporary = join(directory, `.input-${randomUUID()}.tmp`);
         const services = parseStoredServices(run.services);
-        const task = withBaseCommit(run.task, baseCommit);
-        if (task === run.task && /^[0-9a-f]{40}$/.test(baseCommit)) {
+        const task = withBaseCommit(run.task, workspace.baseCommit);
+        if (task === run.task && /^[0-9a-f]{40}$/.test(workspace.baseCommit)) {
             containerLog.warn({ event: "coding.base_commit_omitted", runId: run.runId }, "the coding task left no room for the base commit line");
         }
-        const input = CodingTaskInputSchema.parse({
+        // A repository context read must never fail a run ("the run never fails because of context"):
+        // any fs error (an inaccessible workspace, EACCES, ...) is logged once and swallowed, leaving
+        // claudeContext null, exactly as if the run had nothing to load.
+        let claudeContext = null;
+        if (run.provider === "claude-code") {
+            try {
+                claudeContext = await buildClaudeContext(workspace.workspacePath, { skills: run.repoSkills !== false });
+            }
+            catch (error) {
+                const code = error?.code;
+                containerLog.warn({ event: "coding.claude_context_unavailable", runId: run.runId, ...(code ? { code } : {}) }, "repository context could not be read; continuing without it");
+            }
+        }
+        const build = (contextFiles) => CodingTaskInputSchema.parse({
             schemaVersion: CODING_PROTOCOL_VERSION,
             runId: run.runId,
             repository: run.repository,
@@ -1130,11 +1186,45 @@ export class ContainerExecutor {
             ...(run.debugTrace ? { debugTrace: true } : {}),
             // Only when the agent sets one: every other run's input stays exactly what older workers expect.
             ...(run.maxTurns ? { maxTurns: run.maxTurns } : {}),
+            // Only when off: every other run's input stays exactly what older workers expect.
+            ...(run.repoSkills === false ? { repoSkills: false } : {}),
+            // Only when off: every other run's input stays exactly what older workers expect.
+            ...(run.claudeBareMode === false ? { claudeBareMode: false } : {}),
             // Only when there are some: every other run's input stays exactly what older workers expect.
             ...(services.length > 0 ? { services: workerServices(services) } : {}),
+            // Only when there is something to load: every other run's input stays exactly what older workers expect.
+            ...(contextFiles.length > 0 ? { claudeContext: { files: contextFiles } } : {}),
         });
+        // The content limits bound bytes, but JSON escaping can grow them up to sixfold (a control
+        // character becomes \u00XX), so a hostile repository could still push input.json past
+        // MAX_CODING_INPUT_BYTES and fail the launch. Drop context files from the tail (skills, then the
+        // deepest imports; the root instructions go last) until the serialized input fits.
+        const contextFiles = [...(claudeContext?.files ?? [])];
+        const skipped = [...(claudeContext?.skipped ?? [])];
+        let skippedOverflow = claudeContext?.skippedOverflow ?? 0;
+        let serialized = JSON.stringify(build(contextFiles));
+        while (contextFiles.length > 0 && Buffer.byteLength(serialized) > MAX_CODING_INPUT_BYTES) {
+            const dropped = contextFiles.pop();
+            if (skipped.length < MAX_RECORDED_SKIPS)
+                skipped.push({ path: dropped.path, reason: "limit" });
+            else
+                skippedOverflow++;
+            serialized = JSON.stringify(build(contextFiles));
+        }
+        for (const skip of skipped) {
+            containerLog.warn({
+                event: "coding.claude_context_skipped",
+                runId: run.runId,
+                // A refused import is logged as written, which a repository can make arbitrarily long.
+                path: skip.path.slice(0, MAX_LOGGED_SKIP_PATH_CHARS),
+                reason: skip.reason,
+            }, "a repository context file was not loaded");
+        }
+        if (skippedOverflow > 0) {
+            containerLog.warn({ event: "coding.claude_context_skipped", runId: run.runId, overflow: skippedOverflow }, "further repository context files were not loaded");
+        }
         // The run directory is 0700; world-readable mode only crosses Docker's UID boundary.
-        await writeFile(temporary, JSON.stringify(input), { flag: "wx", mode: 0o444 });
+        await writeFile(temporary, serialized, { flag: "wx", mode: 0o444 });
         await rename(temporary, destination);
         return destination;
     }

package/dist/providers/executor/dbos.d.ts

@@ -11,14 +11,56 @@
  * The heartbeat is kept while the workflow runs here so the reconciler's
  * stale-heartbeat detection is unchanged; the reconciler consults
  * `recover()` (Task 6) before declaring a DBOS run lost.
+ *
+ * A stalled-but-alive owner can overlap an adopted attempt of the same run:
+ * whichever records a step second loses ownership, stops at that step
+ * without writing the run, and hands the SDK's conflict back so DBOS parks
+ * it as a duplicate execution (see dbosStep and runInsideWorkflow).
  */
+import pg from "pg";
 import type { PrismaClient } from "#prisma";
 import type { DbosConfig } from "../../config/providers.js";
+import { type StepRunner } from "../engine/types.js";
 import { type NativeRunProviders, type RunnerDb } from "../../core/runner.js";
+import { type DatabaseAuth, type PgAuthOptions } from "../../core/pg-auth.js";
 import type { Executor, ExecutionRecoveryResult, PersistedExecutionHandle } from "./types.js";
 export declare const DBOS_BACKEND = "dbos";
 type Providers = NativeRunProviders;
 type Db = RunnerDb & Pick<PrismaClient, "run">;
+/**
+ * DBOS.setConfig input. Under password auth this is exactly what launch() always passed, and DBOS
+ * opens its own pool from the URL. Under rds-iam DBOS gets a pool whose password is the IAM token;
+ * DBOS then runs its migrations, queries and LISTEN through that pool and never opens a URL
+ * connection (system_database.js: a custom pool skips database creation and is what every
+ * connection borrows from). The pool copies what DBOS would have set on its own: size, connect
+ * timeout and application_name. DBOS never ends a pool it was given — see endSystemPool().
+ */
+export declare function dbosLaunchConfig(config: DbosConfig, executorId: string, auth: DatabaseAuth, pgAuth?: PgAuthOptions): {
+    name: string;
+    systemDatabaseUrl: string;
+    systemDatabaseSchemaName: string;
+    executorID: string;
+    runAdminServer: false;
+    logLevel: "warn";
+    systemDatabasePool?: pg.Pool;
+};
+/**
+ * Bind the engine's step boundary to a DBOS checkpointed step. Never
+ * retried: a retry would re-spend.
+ *
+ * DBOS signals a cancelled workflow by throwing `DBOSWorkflowCancelledError`
+ * out of the next step boundary. Translated here into a `RunCancelledError`
+ * so executeRun's backstop records `cancelled` plus the operator's reason,
+ * rather than `failed` plus an SDK-internal message.
+ *
+ * DBOS signals that another execution of this workflow recorded the step
+ * first by throwing `DBOSWorkflowConflictError` after this attempt's step
+ * body already ran. Translated into a `RunOwnershipLostError` (carrying the
+ * discarded step's usage, if any, for the log) so executeRun's backstop stops
+ * this attempt without writing the run; runInsideWorkflow turns it back into
+ * the SDK error.
+ */
+export declare const dbosStep: StepRunner;
 export declare class DbosExecutor implements Executor {
     private readonly providers;
     private readonly config;