@wardby/cli 0.5.3 → 0.7.0

package/dist/core/dispatch.d.ts

@@ -1,7 +1,11 @@
 import type { Prisma, PrismaClient, Run, RunTrigger, Task } from "#prisma";
 import type { Executor } from "../providers/executor/types.js";
+import { type CodingProvider } from "../coding/provider.js";
+import { type DeclaredService } from "../coding/services/declaration.js";
+import { type ServiceResolution } from "../coding/services/resolve.js";
 import { type AttributionIntent } from "./attribution.js";
 import { type BudgetConstraint } from "./budget-groups.js";
+import { type KnowledgeNoteInput } from "../knowledge/note.js";
 import { type SelfDefectSink } from "./self-defects.js";
 export type DispatchDb = Pick<PrismaClient, "agent" | "run" | "runHostCheck" | "codingRun" | "task" | "webhook" | "budgetGroup" | "$transaction" | "$queryRaw">;
 export type DispatchTx = Pick<Prisma.TransactionClient, "agent" | "run" | "runHostCheck" | "runHostStatus" | "runIssueStatus" | "codingRun" | "codingService" | "task" | "webhook" | "budgetGroup" | "resourceGrant" | "workItem" | "localPullRequest" | "runAttribution" | "$queryRaw" | "$executeRawUnsafe">;
@@ -28,6 +32,17 @@ export interface DispatchRunOptions {
      * exclusive with `codingBaseRef`. Coding agents only.
      */
     continuesCodingRunId?: string;
+    /**
+     * The step in the delegating agent's declared merge order for this coding
+     * run (1 = merge first; equal numbers mean no order between them). Integer
+     * 1-99, validated by the caller (the delegate_to_* tool's mergeOrder
+     * argument); throws `Error("invalid_merge_order")` otherwise. Coding agents
+     * only; ignored for a native agent (no CodingRun to store it on). A
+     * continuation (`continuesCodingRunId`) that omits this inherits the pull
+     * request's effective value: the newest non-null `mergeOrder` among the
+     * root coding run and its continuations.
+     */
+    mergeOrder?: number;
     now?: Date;
     lockAgent?: boolean;
     task?: {
@@ -52,6 +67,12 @@ export interface DispatchRunOptions {
     triggeredById?: string | null;
     /** Sub-agent dispatch (see AgentSubAgent): links this run into a run tree. */
     parentRunId?: string;
+    /**
+     * The parent's delegation call (the model's tool-call id) that dispatches this sub-agent run.
+     * Unique per parent, so a re-executed delegate step finds the child its call created
+     * (findDelegationChild) instead of starting a second one.
+     */
+    parentCallId?: string;
     /**
      * Cost attribution for a run that starts a new attribution (issue event,
      * linked PR, explicit key), resolved before the call (attribution.ts
@@ -137,6 +158,19 @@ export declare function markRunFailedFromExecutorError(db: Pick<DispatchDb, "run
  * `run_tree_exhausted`, then a sentence for people.
  */
 export declare function budgetExhaustedError(constraint: BudgetConstraint): string;
+/**
+ * Serializes grouped coding dispatches (security review I1). Under
+ * Serializable, a row lock taken after the transaction's first read cannot
+ * queue anything: the snapshot is already fixed, so each waiter wakes up
+ * with a stale view and aborts. LOCK TABLE is the one statement that takes
+ * no snapshot, so as the transaction's first statement it makes a waiter's
+ * snapshot start only after the previous holder committed. SHARE ROW
+ * EXCLUSIVE conflicts with itself and with writes to BudgetGroup rows, but not
+ * with the ROW SHARE that foreign-key checks from Agent take, so attaching
+ * agents to groups is not blocked. It serializes grouped coding dispatches
+ * across all groups; each holds it only for one short transaction.
+ */
+export declare const GROUP_DISPATCH_LOCK_SQL = "LOCK TABLE \"BudgetGroup\" IN SHARE ROW EXCLUSIVE MODE";
 /**
  * Attempts for the persist transaction, and the jittered backoff between
  * them, for serialization failures, deadlocks and transactions that could
@@ -178,6 +212,25 @@ export type ContinuationCheck = {
  * run at all" (a user-facing refusal message, not a dispatch).
  */
 export declare function checkContinuation(reader: Pick<DispatchTx, "codingRun">, runId: string, repository: string, dispatchingOwnerId?: string | null): Promise<ContinuationCheck>;
+/** What dispatch learned about a coding run's .wardby/services.yaml before its transaction. */
+export type DeclarationOutcome = {
+    kind: "none";
+} | {
+    kind: "declared";
+    services: DeclaredService[];
+} | {
+    kind: "refused";
+    refusal: string;
+};
+/** The bundle index at a known base ref; also how a deferred coding run reads it when it starts. */
+export declare function readKnowledgeIndexAt(executor: Executor, repository: string, baseRef: string): Promise<KnowledgeNoteInput | undefined>;
+/** The declaration at a known base ref, parsed; also how a deferred coding run reads it when it starts. */
+export declare function readServiceDeclarationAt(executor: Executor, repository: string, baseRef: string): Promise<DeclarationOutcome>;
+/**
+ * Inside the transaction: the run's services, or the refusal that stops it. Takes only the
+ * catalog, so a deferred coding run's start resolves them the same way with a plain client.
+ */
+export declare function resolveDispatchServices(tx: Pick<Prisma.TransactionClient, "codingService">, outcome: DeclarationOutcome, allowed: unknown, executor: Executor, provider: CodingProvider, request: string, instructions: string | null): Promise<ServiceResolution>;
 /**
  * Persists every detached run input in one transaction, then invokes the
  * executor only after commit. A null result means the caller's transactional

package/dist/core/dispatch.js

@@ -1,5 +1,6 @@
 import { CODING_PROTOCOL_VERSION, CodingTaskInputSchema, normalizeGitHubRepository, normalizeGitRef, publicCodingRunResult, composeCodingTask, } from "../coding/protocol.js";
 import { assertCodingProvider, assertCodingProviderModel } from "../coding/provider.js";
+import { isPackageAuditActive } from "../coding/registry/audit-mode.js";
 import { ModelUnavailableError, entryOf } from "../providers/llm/catalog-types.js";
 import { parseAllowedServiceNames, workerServices } from "../coding/services/catalog.js";
 import { MAX_SERVICE_DECLARATION_BYTES, ServiceDeclarationError, parseServiceDeclaration, } from "../coding/services/declaration.js";
@@ -7,8 +8,8 @@ import { servicesInstructionNote } from "../coding/services/note.js";
 import { resolveRunServices } from "../coding/services/resolve.js";
 import { DECLARATION_UNAVAILABLE_SENTENCE, LAUNCHER_UNSUPPORTED_SENTENCE, invalidDeclarationSentence, serviceRefusal, } from "../coding/services/wording.js";
 import { attributeRun } from "./attribution.js";
-import { effectiveBudgetForRun, MIN_RESERVATION_USD } from "./budget-groups.js";
-import { DEFAULT_KNOWLEDGE_BUNDLE_PATH } from "../knowledge/concept.js";
+import { effectiveBudgetForRun, MIN_RESERVATION_USD, } from "./budget-groups.js";
+import { KNOWLEDGE_CONFIG_MAX_BYTES, KNOWLEDGE_CONFIG_PATH, resolveKnowledgeLocation } from "../knowledge/location.js";
 import { KNOWLEDGE_INDEX_READ_MAX_BYTES, knowledgeSection } from "../knowledge/note.js";
 import { logger } from "./logger.js";
 import { CodingModelProviderMismatchError, resolveCodingEntry } from "./run-pricing.js";
@@ -107,21 +108,45 @@ export function budgetExhaustedError(constraint) {
  * agents to groups is not blocked. It serializes grouped coding dispatches
  * across all groups; each holds it only for one short transaction.
  */
-const GROUP_DISPATCH_LOCK_SQL = 'LOCK TABLE "BudgetGroup" IN SHARE ROW EXCLUSIVE MODE';
+export const GROUP_DISPATCH_LOCK_SQL = 'LOCK TABLE "BudgetGroup" IN SHARE ROW EXCLUSIVE MODE';
+/** Rounded down to CodingRun's 6 decimal places. */
+function floorToMicroUsd(usd) {
+    return Math.floor(usd / MIN_RESERVATION_USD) * MIN_RESERVATION_USD;
+}
 /**
- * A coding run's budget reservation: the requested ceiling (override or the
+ * A coding run's budget reservation: the requested base (override or the
  * agent's budgetUsd) tightened by its budget group and run tree, where every
- * live in-flight run's unspent hold already counts as spent. Rounded down to
- * CodingRun.budgetReservedUsd's 6 decimal places; less than that is refused.
+ * live in-flight run's unspent hold already counts as spent. Only the base is
+ * reserved (CodingRun.budgetReservedUsd, and budgetBaseUsd beside it). The
+ * agent's allowedOverrunPercent raises the requested base to the run's limit
+ * (CodingRun.budgetLimitUsd), which is never reserved: the run may spend past
+ * its base only through top-ups its group and run tree have room for when it
+ * needs them (budget-topup.ts). Rounded down to 6 decimal places; a base less
+ * than that is refused.
  */
 async function reserveCodingBudget(tx, agent, now, options) {
+    const overrunPercent = agent.allowedOverrunPercent;
     const effective = await effectiveBudgetForRun(tx, agent, now, options.parentRunId);
     const requested = options.budgetUsdOverride ?? Number(agent.budgetUsd);
-    const budgetUsd = Math.floor(Math.min(requested, effective.effectiveBudgetUsd) / MIN_RESERVATION_USD) * MIN_RESERVATION_USD;
-    if (budgetUsd < MIN_RESERVATION_USD && effective.exhaustedBy) {
-        return { budgetUsd: 0, refusal: budgetExhaustedError(effective.exhaustedBy) };
+    const baseBudgetUsd = floorToMicroUsd(Math.min(requested, effective.effectiveBudgetUsd));
+    if (baseBudgetUsd < MIN_RESERVATION_USD && effective.exhaustedBy) {
+        return {
+            budgetUsd: 0,
+            baseBudgetUsd: 0,
+            limitUsd: null,
+            refusal: budgetExhaustedError(effective.exhaustedBy),
+            ...(effective.exhaustedDetail
+                ? { refusalDetail: { limit: effective.exhaustedBy, detail: effective.exhaustedDetail } }
+                : {}),
+        };
     }
-    return { budgetUsd };
+    const limitUsd = overrunPercent > 0 ? floorToMicroUsd((requested * (100 + overrunPercent)) / 100) : null;
+    return {
+        budgetUsd: baseBudgetUsd,
+        baseBudgetUsd,
+        limitUsd: limitUsd !== null && limitUsd > baseBudgetUsd ? limitUsd : null,
+        ...(effective.limitedBy ? { limitedBy: effective.limitedBy } : {}),
+    };
 }
 /**
  * Attempts for the persist transaction, and the jittered backoff between
@@ -227,8 +252,37 @@ ownerId) {
         headRef: root.headRef,
         continuationOf: { runId: root.runId },
         rootCodingRunId: root.runId,
+        mergeOrder: await effectiveMergeOrder(reader, root.runId),
     };
 }
+/**
+ * The pull request's current merge step: the newest non-null mergeOrder
+ * (by run start) among the root coding run and every continuation of it
+ * (CodingRun.rootCodingRunId, indexed), or null when none set one. A
+ * continuation that omits mergeOrder inherits this, so an earlier
+ * continuation's override is kept rather than reverting to the root's.
+ */
+async function effectiveMergeOrder(reader, rootRunId) {
+    const newest = await reader.codingRun.findFirst({
+        where: { OR: [{ runId: rootRunId }, { rootCodingRunId: rootRunId }], mergeOrder: { not: null } },
+        orderBy: [{ run: { startedAt: "desc" } }, { runId: "desc" }],
+        select: { mergeOrder: true },
+    });
+    return newest?.mergeOrder ?? null;
+}
+/**
+ * Resolves the CodingRun's mergeOrder: the caller's own value if given (an
+ * integer 1-99; anything else throws), else the inherited effective value
+ * (undefined for a fresh branch), else null (no order).
+ */
+function resolveMergeOrder(options, inherited) {
+    if (options.mergeOrder === undefined)
+        return inherited ?? null;
+    if (!Number.isInteger(options.mergeOrder) || options.mergeOrder < 1 || options.mergeOrder > 99) {
+        throw new Error("invalid_merge_order");
+    }
+    return options.mergeOrder;
+}
 /** Read failures that are the file's fault rather than the host's: reported as an invalid declaration. */
 const UNREADABLE_DECLARATION = {
     github_file_too_large: `it is larger than ${MAX_SERVICE_DECLARATION_BYTES} bytes`,
@@ -240,30 +294,49 @@ const UNREADABLE_DECLARATION = {
 };
 /**
  * The knowledge note's input (docs/knowledge.md): the repository's bundle
- * index at the run's base, read before the transaction like the services
+ * index at the run's base (in the folder .wardby/knowledge.yaml names, else
+ * docs/knowledge/), read before the transaction like the services
  * declaration. Any failure means no note, never a failed dispatch.
  */
 async function readKnowledgeIndex(options, profile, resolvedBranch, ownerId) {
-    const executor = options.executor;
-    if (!executor.readCodingRepositoryFile)
+    if (!options.executor.readCodingRepositoryFile)
         return undefined;
+    let baseRef;
     try {
         // Resolved here, inside the try: a branch problem is the transaction's to report, not the note's.
-        const branch = resolvedBranch ?? (await resolveCodingBranch(options.db, options, profile, ownerId));
-        const indexText = await executor.readCodingRepositoryFile({
-            repository: profile.repository,
-            baseRef: normalizeGitRef(branch.baseRef),
-            path: `${DEFAULT_KNOWLEDGE_BUNDLE_PATH}/index.md`,
+        baseRef = (resolvedBranch ?? (await resolveCodingBranch(options.db, options, profile, ownerId))).baseRef;
+    }
+    catch (err) {
+        dispatchLog.warn({ err, repository: profile.repository }, "knowledge index read failed; dispatching without it");
+        return undefined;
+    }
+    return readKnowledgeIndexAt(options.executor, profile.repository, baseRef);
+}
+/** The bundle index at a known base ref; also how a deferred coding run reads it when it starts. */
+export async function readKnowledgeIndexAt(executor, repository, baseRef) {
+    const readFile = executor.readCodingRepositoryFile?.bind(executor);
+    if (!readFile)
+        return undefined;
+    const ref = normalizeGitRef(baseRef);
+    // The repository may name its bundle folder in .wardby/knowledge.yaml; anything wrong with that file falls back to the default.
+    const { bundlePath, warning } = await resolveKnowledgeLocation(() => readFile({ repository, baseRef: ref, path: KNOWLEDGE_CONFIG_PATH, maxBytes: KNOWLEDGE_CONFIG_MAX_BYTES }));
+    if (warning)
+        dispatchLog.warn({ repository, baseRef: ref }, warning);
+    try {
+        const indexText = await readFile({
+            repository,
+            baseRef: ref,
+            path: `${bundlePath}/index.md`,
             maxBytes: KNOWLEDGE_INDEX_READ_MAX_BYTES,
         });
-        return indexText ? { bundlePath: DEFAULT_KNOWLEDGE_BUNDLE_PATH, indexText } : undefined;
+        return indexText ? { bundlePath, indexText } : undefined;
     }
     catch (err) {
         if (err instanceof Error && err.message in UNREADABLE_DECLARATION) {
-            dispatchLog.info({ repository: profile.repository, reason: err.message }, "knowledge index unreadable; dispatching without it");
+            dispatchLog.info({ repository, reason: err.message }, "knowledge index unreadable; dispatching without it");
             return undefined;
         }
-        dispatchLog.warn({ err, repository: profile.repository }, "knowledge index read failed; dispatching without it");
+        dispatchLog.warn({ err, repository }, "knowledge index read failed; dispatching without it");
         return undefined;
     }
 }
@@ -275,56 +348,54 @@ async function readKnowledgeIndex(options, profile, resolvedBranch, ownerId) {
  */
 async function readServiceDeclaration(options, profile, ownerId) {
     const branch = await resolveCodingBranch(options.db, options, profile, ownerId);
-    const read = { repository: profile.repository, profileBaseRef: profile.baseRef, branch };
-    const executor = options.executor;
+    return {
+        repository: profile.repository,
+        profileBaseRef: profile.baseRef,
+        branch,
+        outcome: await readServiceDeclarationAt(options.executor, profile.repository, branch.baseRef),
+    };
+}
+/** The declaration at a known base ref, parsed; also how a deferred coding run reads it when it starts. */
+export async function readServiceDeclarationAt(executor, repository, baseRef) {
     if (!executor.readCodingServiceDeclaration)
-        return { ...read, outcome: { kind: "none" } };
+        return { kind: "none" };
     let text;
     try {
-        text = await executor.readCodingServiceDeclaration({
-            repository: profile.repository,
-            baseRef: normalizeGitRef(branch.baseRef),
-        });
+        text = await executor.readCodingServiceDeclaration({ repository, baseRef: normalizeGitRef(baseRef) });
     }
     catch (err) {
         const reason = UNREADABLE_DECLARATION[err instanceof Error ? err.message : ""];
         if (reason) {
             return {
-                ...read,
-                outcome: {
-                    kind: "refused",
-                    refusal: serviceRefusal("service_declaration_invalid", invalidDeclarationSentence(reason)),
-                },
+                kind: "refused",
+                refusal: serviceRefusal("service_declaration_invalid", invalidDeclarationSentence(reason)),
             };
         }
-        dispatchLog.warn({ err, agentId: options.agentId }, "could not read the repository's service declaration");
+        dispatchLog.warn({ err, repository }, "could not read the repository's service declaration");
         return {
-            ...read,
-            outcome: {
-                kind: "refused",
-                refusal: serviceRefusal("service_declaration_unavailable", DECLARATION_UNAVAILABLE_SENTENCE),
-            },
+            kind: "refused",
+            refusal: serviceRefusal("service_declaration_unavailable", DECLARATION_UNAVAILABLE_SENTENCE),
         };
     }
     if (text === null)
-        return { ...read, outcome: { kind: "none" } };
+        return { kind: "none" };
     try {
-        return { ...read, outcome: { kind: "declared", services: parseServiceDeclaration(text) } };
+        return { kind: "declared", services: parseServiceDeclaration(text) };
     }
     catch (err) {
         if (!(err instanceof ServiceDeclarationError))
             throw err;
         return {
-            ...read,
-            outcome: {
-                kind: "refused",
-                refusal: serviceRefusal("service_declaration_invalid", invalidDeclarationSentence(err.reason)),
-            },
+            kind: "refused",
+            refusal: serviceRefusal("service_declaration_invalid", invalidDeclarationSentence(err.reason)),
         };
     }
 }
-/** Inside the transaction: the run's services, or the refusal that stops it. */
-async function resolveDispatchServices(tx, outcome, allowed, executor, provider, request, instructions) {
+/**
+ * Inside the transaction: the run's services, or the refusal that stops it. Takes only the
+ * catalog, so a deferred coding run's start resolves them the same way with a plain client.
+ */
+export async function resolveDispatchServices(tx, outcome, allowed, executor, provider, request, instructions) {
     if (outcome.kind === "refused")
         return { refusal: outcome.refusal };
     if (outcome.kind === "none" || outcome.services.length === 0)
@@ -356,15 +427,19 @@ export async function dispatchRun(options) {
         },
     });
     const lockGroups = preview?.kind === "coding" && preview.budgetGroupId != null;
+    // The native gateway's executor has no coding configuration: the run is recorded
+    // unresolved and the process that starts it reads and resolves (resolveDeferredCodingRun).
+    const deferCoding = options.executor.defersCodingResolution === true;
     // Only an agent allowed some service reads the repository's declaration; any
     // other coding agent never calls the host for it and gets no services.
-    const declarationRead = preview?.kind === "coding" &&
+    const declarationRead = !deferCoding &&
+        preview?.kind === "coding" &&
         preview.codingProfile &&
         parseAllowedServiceNames(preview.codingProfile.services).length > 0
         ? await readServiceDeclaration(options, preview.codingProfile, preview.ownerId ?? null)
         : undefined;
     // The knowledge note's input: the repository's bundle index at the run's base (a network call).
-    const knowledgeIndex = preview?.kind === "coding" && preview.codingProfile && options.executor.readCodingRepositoryFile
+    const knowledgeIndex = !deferCoding && preview?.kind === "coding" && preview.codingProfile && options.executor.readCodingRepositoryFile
         ? await readKnowledgeIndex(options, preview.codingProfile, declarationRead?.branch, preview.ownerId ?? null)
         : undefined;
     const persistOnce = () => options.db.$transaction(async (tx) => {
@@ -439,7 +514,10 @@ export async function dispatchRun(options) {
                 agentId: agent.id,
                 trigger: options.trigger ?? "manual",
                 executionManaged: true,
+                // Fixed for the run's life: the executor routes on this, never on the agent's current setting.
+                nativeExecutionMode: agent.kind === "native" ? agent.nativeExecutionMode : null,
                 parentRunId: options.parentRunId,
+                parentCallId: options.parentCallId,
                 grantedParentMemoryKeys: options.grantedParentMemoryKeys ?? [],
                 taskOverride: options.taskOverride,
                 triggeredById: options.triggeredById ?? null,
@@ -459,6 +537,13 @@ export async function dispatchRun(options) {
                     : {}),
             },
         });
+        if (refusal && codingBudget?.refusalDetail && refusal === codingBudget.refusal) {
+            const { limit, detail } = codingBudget.refusalDetail;
+            // Group and lead names are filled at read time.
+            await tx.runBudgetEvent.create({
+                data: { runId: run.id, kind: "refused", limit, details: { source: "dispatch", ...detail } },
+            });
+        }
         if (options.afterPersist)
             await options.afterPersist(tx, run);
         const attributed = await attributeRun(tx, run.id, {
@@ -473,13 +558,19 @@ export async function dispatchRun(options) {
             if (!request)
                 throw new Error(`Coding agent "${agent.id}" requires a task.`);
             // The worker sees only the task text, so the agent's own instructions, and the
-            // services note, ride in it.
-            const task = composeCodingTask(agent.systemPrompt, request, servicesInstructionNote(services), knowledgeIndex ? knowledgeSection(knowledgeIndex) : undefined);
+            // services note, ride in it. Deferred, the task is stored raw and composed when the
+            // run starts; composing here only checks its size, so it throws exactly as today.
+            if (deferCoding)
+                composeCodingTask(agent.systemPrompt, request);
+            const task = deferCoding
+                ? request
+                : composeCodingTask(agent.systemPrompt, request, servicesInstructionNote(services), knowledgeIndex ? knowledgeSection(knowledgeIndex) : undefined);
             const budgetUsd = codingBudget.budgetUsd;
             // Resolved once: before the transaction when the declaration was read from it.
             const branch = declarationRead?.branch ?? (await resolveCodingBranch(tx, options, agent.codingProfile, agent.ownerId));
-            const { baseRef, continuationOf, rootCodingRunId } = branch;
+            const { baseRef, continuationOf, rootCodingRunId, mergeOrder: inheritedMergeOrder } = branch;
             const headRef = branch.headRef ?? `wardby/run-${run.id}`;
+            const mergeOrder = resolveMergeOrder(options, inheritedMergeOrder);
             const input = CodingTaskInputSchema.parse({
                 schemaVersion: CODING_PROTOCOL_VERSION,
                 runId: run.id,
@@ -499,16 +590,22 @@ export async function dispatchRun(options) {
                 toolchainVersion: agent.codingProfile.toolchainVersion,
                 workerImageRef: agent.codingProfile.workerImageRef,
             };
-            const workerImage = options.executor.resolveCodingWorkerImage?.(imageSelector);
+            // Deferred, both stay null until the starting process resolves them.
+            const workerImage = deferCoding ? null : options.executor.resolveCodingWorkerImage?.(imageSelector);
             // Claude Code's commands run in its tool runner, so the toolchain picks that image too; fixed
             // here with the worker image so the run keeps both however the deployment changes later.
-            const toolImage = options.executor.resolveCodingToolImage?.(imageSelector) ?? null;
+            const toolImage = deferCoding ? null : (options.executor.resolveCodingToolImage?.(imageSelector) ?? null);
+            const traced = agent.codingProfile.debugTraceUntil != null &&
+                now.getTime() < agent.codingProfile.debugTraceUntil.getTime();
+            const { packageAuditMode, packageAuditUntil } = agent.codingProfile;
             await tx.codingRun.create({
                 data: {
                     runId: run.id,
+                    budgetLimitedBy: codingBudget.limitedBy ?? null,
                     issueProvider: attributed?.provider ?? null,
                     issueKey: attributed?.key ?? null,
                     task: input.task,
+                    request,
                     repository: input.repository,
                     baseRef: input.baseRef,
                     headRef: input.headRef,
@@ -522,12 +619,25 @@ export async function dispatchRun(options) {
                     workerImage,
                     toolImage,
                     budgetReservedUsd: budgetUsd,
+                    budgetBaseUsd: codingBudget.baseBudgetUsd,
+                    budgetLimitUsd: codingBudget.limitUsd,
                     rootCodingRunId,
+                    mergeOrder,
                     workspaceDiskMb: agent.codingProfile.workspaceDiskMb,
                     maxTurns: agent.codingProfile.maxTurns,
+                    maxOutputTokens: agent.codingProfile.maxOutputTokens,
+                    repoSkills: agent.codingProfile.repoSkills,
+                    claudeBareMode: agent.codingProfile.claudeBareMode,
+                    dependencyCache: agent.codingProfile.dependencyCache,
+                    sessionResume: agent.codingProfile.sessionResume,
                     // Fixed here so a run's tracing never changes mid-run.
-                    debugTrace: agent.codingProfile.debugTraceUntil != null &&
-                        now.getTime() < agent.codingProfile.debugTraceUntil.getTime(),
+                    debugTrace: traced,
+                    debugTraceMaxMb: traced ? agent.codingProfile.debugTraceMaxMb : null,
+                    // Fixed here too: a run keeps the mode its dispatch saw for its
+                    // whole life, however the window moves afterwards.
+                    packageAuditMode: isPackageAuditActive(packageAuditMode, packageAuditUntil, now)
+                        ? packageAuditMode
+                        : null,
                     services,
                 },
             });

package/dist/core/engine-native.js

@@ -6,7 +6,7 @@
  * lives behind a seam (a future LangGraph engine swaps in here) and why
  * the budget guardrail must stay above whichever engine is running.
  */
-import { runStepInline } from "../providers/engine/types.js";
+import { RunOwnershipLostError, runStepInline } from "../providers/engine/types.js";
 import { applyPreflightSafetyMargin, checkTokenCalibration, estimateInputCost, isOverBudget } from "./budget.js";
 import { logger } from "./logger.js";
 import { UNTRUSTED_CONTEXT_TAG, UNTRUSTED_TOOL_OUTPUT_TAG, wrapUntrusted } from "./untrusted-content.js";
@@ -178,7 +178,7 @@ export class NativeEngine {
      * once all have settled, the first rejection by call order is rethrown.
      */
     async runToolCalls(ctx, step, turn, toolCalls) {
-        const runCall = (index) => step(`turn:${turn}:tool:${index}`, () => ctx.runSandboxTool(toolCalls[index].name, toolCalls[index].argsJson));
+        const runCall = (index) => step(`turn:${turn}:tool:${index}`, () => ctx.runSandboxTool(toolCalls[index].name, toolCalls[index].argsJson, toolCalls[index].id));
         const concurrent = ctx.runsConcurrently;
         const results = new Array(toolCalls.length);
         let index = 0;
@@ -197,11 +197,15 @@ export class NativeEngine {
             engineLog.info({ turn, toolCallIds: batch.map((i) => toolCalls[i].id) }, "running tool calls concurrently");
             const settled = await Promise.allSettled(batch.map((i) => runCall(i)));
             const rejections = settled.filter((outcome) => outcome.status === "rejected");
-            for (const extra of rejections.slice(1)) {
-                engineLog.warn({ turn, err: extra.reason }, "concurrent tool call also failed");
+            // An ownership loss wins over an ordinary failure: this attempt no longer owns the run, so it
+            // must stop without a terminal write rather than fail the run for the attempt that does.
+            const thrown = rejections.find((r) => r.reason instanceof RunOwnershipLostError) ?? rejections[0];
+            for (const extra of rejections) {
+                if (extra !== thrown)
+                    engineLog.warn({ turn, err: extra.reason }, "concurrent tool call also failed");
             }
-            if (rejections.length > 0)
-                throw rejections[0].reason;
+            if (thrown)
+                throw thrown.reason;
             settled.forEach((outcome, position) => {
                 results[batch[position]] = outcome.value;
             });

package/dist/core/error-code.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The code a wardby error message leads with (`some_code` or `some_code: detail`), or undefined.
+ * Worker-safe: the native sandbox worker image ships this module.
+ */
+export declare function errorCodeOf(message: string | null | undefined): string | undefined;
+/** The code an unexpected error's message leads with, if it is code-shaped (has an underscore) and short enough. */
+export declare function causeCodeOf(err: unknown): string | undefined;
+/**
+ * The only codes that may be shown from an arbitrary error's text (to a worker, or to the model in a
+ * tool result): wardby's own codes that an unexpected error on those paths can lead with. Anything
+ * else, however code-shaped, could be a value from an error's text, so it never crosses.
+ * - coding_execution_not_configured, coding_profile_missing: a coding delegation reaching a process
+ *   that cannot start coding runs (core/deferred-coding.ts, providers/executor/routing.ts).
+ * - message_too_large, message_not_json, message_invalid, unsupported_protocol_version: the native
+ *   worker protocol's own ProtocolError codes (native-worker/protocol.ts).
+ * - invalid_merge_order: dispatchRun's refusal of a bad mergeOrder (core/dispatch.ts).
+ * - coding_worker_image_invalid: a coding worker image that is not pinned by digest
+ *   (providers/executor/container.ts).
+ * - native_sandbox_unavailable: createRun/the router refusing a sandbox-mode agent with no sandbox executor
+ *   (core/runner.ts).
+ * - run_tree_exhausted: dispatchRun refusing a run whose tree budget is spent (core/dispatch.ts).
+ * - secret_in_value, secret_check_unavailable: the datastore and memory write guard refusing a value
+ *   that holds an attached secret's value (core/secret-guard.ts); the code carries only the name of
+ *   the secret, never its value, across the gateway.
+ */
+export declare const GATEWAY_CAUSE_CODES: ReadonlySet<string>;
+/**
+ * The codes wardby itself writes as a failed coding or native child run's Run.error (read from the
+ * literals in core/dispatch.ts, core/coding-queue.ts, providers/executor/*, core/run-pricing.ts,
+ * providers/llm/catalog-types.ts and the native sandbox). A parent may be told which of these a
+ * child failed with; any other leading word is not shown. Includes GATEWAY_CAUSE_CODES, and the
+ * container executor's terminal codes: `coding_failure_<category>` for every category
+ * failureCategory files a failure under (providers/executor/container.ts), and
+ * `coding_provider_<class>` for every provider failure class (core/provider-wording.ts).
+ */
+export declare const CHILD_RUN_FAILURE_CODES: ReadonlySet<string>;
+/** The leading code of an arbitrary error or message, only when it is declared in `allowed`. */
+export declare function declaredCodeOf(err: unknown, allowed?: ReadonlySet<string>): string | undefined;