@wardby/cli 0.7.0 → 0.8.0

package/dist/core/merge-order-check.js

@@ -1,4 +1,4 @@
-import { CODING_CODE_PROVIDER, normalizeGitHubRepository } from "../coding/protocol.js";
+import { codeProviderOf, normalizeHostedRepository, pullRequestWebUrl } from "../coding/code-host.js";
 import { logger } from "./logger.js";
 import { maybeMarkReady } from "./mark-ready.js";
 import { collectRelatedPullRequests, runTreeRoot } from "./related-pull-requests.js";
@@ -31,18 +31,31 @@ export function mergeOrderVerdict(self, set) {
         return { status: "in_progress", waitingFor };
     return { status: "success", dependencies };
 }
-const prUrl = (repository, number) => `https://github.com/${repository}/pull/${number}`;
-/** `repository#number` as a link: never a title or any other free text from the host. */
-const prLink = (m) => `[${m.repository}#${m.number}](${prUrl(m.repository, m.number)})`;
+/** `repository#number`, as a link when the host has one: never a title or any other free text from the host. */
+const prLink = (m) => {
+    const label = `${m.repository}#${m.number}`;
+    const url = pullRequestWebUrl(codeProviderOf(m.repository), m.repository, m.number);
+    return url ? `[${label}](${url})` : label;
+};
 const keyOf = (repository, number) => `${repository}#${number}`;
 function safeRepository(value) {
     try {
-        return normalizeGitHubRepository(value);
+        return normalizeHostedRepository(value);
     }
     catch {
         return undefined;
     }
 }
+const canPostCheck = (host) => host?.upsertNamedCheck !== undefined && host.pullRequestOrigin !== undefined;
+/** The host that can post this repository's merge order check, if any. */
+function checkHost(hosts, repository) {
+    const host = hosts?.[codeProviderOf(repository)];
+    return canPostCheck(host) ? host : undefined;
+}
+/** Whether any configured host can post the check; none means nothing to read or sync. */
+function anyCheckHost(hosts) {
+    return Object.values(hosts ?? {}).some(canPostCheck);
+}
 function originState(origin) {
     if (origin.merged)
         return "merged";
@@ -109,8 +122,7 @@ export function mergeOrderCheckInput(self, verdict, steps, headSha, leadRunning
  */
 export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
     const log = deps.log ?? moduleLog;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
+    if (!anyCheckHost(deps.hosts))
         return;
     try {
         const group = await collectRelatedPullRequests(deps.db, seedRunId);
@@ -154,9 +166,15 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
                 continue;
             }
             try {
-                const origin = reused && key === keyOf(reused, opts.origin.number)
-                    ? await opts.origin.read()
-                    : await host.pullRequestOrigin(pr.repository, pr.number);
+                let origin;
+                // Reading only needs the read: a host that can't post checks still reports its pull requests.
+                const memberHost = deps.hosts?.[codeProviderOf(pr.repository)];
+                if (reused && key === keyOf(reused, opts.origin.number))
+                    origin = await opts.origin.read();
+                else if (memberHost?.pullRequestOrigin)
+                    origin = await memberHost.pullRequestOrigin(pr.repository, pr.number);
+                else
+                    throw new Error("no_host_for_repository");
                 let headSha;
                 if (origin.markerRunId) {
                     const opener = await deps.db.codingRun.findUnique({
@@ -186,9 +204,12 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
             const verdict = mergeOrderVerdict(self, set);
             if (verdict.status === "skip")
                 continue;
+            const selfHost = checkHost(deps.hosts, self.repository);
+            if (!selfHost)
+                continue;
             const input = mergeOrderCheckInput(self, verdict, steps, target.headSha, leadRunning);
             try {
-                await host.upsertNamedCheck(self.repository, input);
+                await selfHost.upsertNamedCheck(self.repository, input);
                 log.info({ seedRunId, repository: self.repository, number: self.number, status: verdict.status }, "merge order check posted");
             }
             catch (err) {
@@ -197,7 +218,7 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
             }
             if (input.status === "completed" && input.conclusion === "success") {
                 // The last earlier step merged: the pull request may now be ready for review (#287).
-                await maybeMarkReady({ db: deps.db, hosts: deps.hosts, log: deps.log }, self.repository, self.number);
+                await maybeMarkReady({ db: deps.db, hosts: deps.hosts, log: deps.log }, self.repository, self.number, codeProviderOf(self.repository));
             }
         }
     }
@@ -212,8 +233,7 @@ export async function syncMergeOrderChecks(deps, seedRunId, opts = {}) {
 export async function syncMergeOrderChecksAfterRun(deps, run) {
     if (run.parentRunId !== null)
         return;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
+    if (!anyCheckHost(deps.hosts))
         return;
     try {
         if (!(await deps.db.run.findFirst({ where: { parentRunId: run.id }, select: { id: true } })))
@@ -250,12 +270,12 @@ async function orderedSeeds(db, repository, number) {
  */
 export async function syncMergeOrderChecksForPullRequest(deps, pr, opts = {}) {
     const log = deps.log ?? moduleLog;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
-        return;
     const repository = safeRepository(pr.repository);
     if (!repository || !Number.isSafeInteger(pr.number) || pr.number <= 0)
         return;
+    // This pull request's own host need not post checks: its siblings' checks may depend on it.
+    if (!anyCheckHost(deps.hosts))
+        return;
     let roots;
     try {
         roots = [];
@@ -297,8 +317,7 @@ export function resetMergeOrderSweepForTests() {
  */
 export async function sweepMergeOrderChecks(deps, now = new Date()) {
     const log = deps.log ?? moduleLog;
-    const host = deps.hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.upsertNamedCheck || !host.pullRequestOrigin)
+    if (!anyCheckHost(deps.hosts))
         return 0;
     if (now.getTime() - lastSweepAt < MERGE_ORDER_SWEEP_INTERVAL_MS)
         return 0;

package/dist/core/notification-dispatcher.js

@@ -34,6 +34,7 @@
  */
 import { Prisma } from "#prisma";
 import { ChatError, } from "../providers/chat/types.js";
+import { pullRequestWebUrl } from "../coding/code-host.js";
 import { tryAcquireLease } from "./lease.js";
 import { logger } from "./logger.js";
 import { broadcasts, nextStatus, renderEvent, renderParent, senderName, } from "./notification-templates.js";
@@ -82,7 +83,7 @@ async function subjectOf(db, d) {
         return { label: ev.workItemKey, title: item?.title ?? null, url: item?.url ?? null };
     }
     if (ev.repository && ev.prNumber != null) {
-        const url = ev.codeProvider === "github" ? `https://github.com/${ev.repository}/pull/${ev.prNumber}` : null;
+        const url = pullRequestWebUrl(ev.codeProvider ?? "", ev.repository, ev.prNumber);
         return { label: `${ev.repository}#${ev.prNumber}`, title: null, url };
     }
     if (ev.runId)

package/dist/core/related-pull-requests.js

@@ -23,7 +23,7 @@
  * brings every later follow-up tree that continued one of its pull requests.
  */
 import { Prisma } from "#prisma";
-import { CODING_CODE_PROVIDER, normalizeGitHubRepository } from "../coding/protocol.js";
+import { codeProviderOf, normalizeHostedRepository, pullRequestWebUrl } from "../coding/code-host.js";
 import { issueReference, } from "../providers/issue-tracker/types.js";
 import { renderRelatedSection } from "../providers/vcs/github.js";
 import { pullRequestOutcome } from "./host-status.js";
@@ -91,7 +91,7 @@ export async function runTreeRoot(db, markerRunId, repository) {
 }
 function safeRepository(value) {
     try {
-        return normalizeGitHubRepository(value);
+        return normalizeHostedRepository(value);
     }
     catch {
         return undefined;
@@ -222,7 +222,8 @@ onlyIssueKey) {
     if (issueFilter.size > 0) {
         const recorded = await db.issuePullRequest.findMany({
             where: {
-                codeProvider: CODING_CODE_PROVIDER,
+                // A local repository has no pull requests to record: everything here is on a code host.
+                codeProvider: { not: "local" },
                 OR: [...issueFilter.values()].map((i) => ({ issueProvider: i.provider, issueKey: i.key })),
             },
             select: { repository: true, number: true, createdAt: true, openedByRunId: true, state: true },
@@ -269,6 +270,7 @@ onlyIssueKey) {
         ...(roots.size > 0 ? { roots: [...roots].map(([id, root]) => ({ id, ...root })) } : {}),
     };
 }
+const canEditRelatedSection = (host) => host?.replaceRelatedSection !== undefined && host.pullRequestOrigin !== undefined;
 function issueFor(group, trackers) {
     if (!group.issue)
         return undefined;
@@ -283,8 +285,12 @@ function issueFor(group, trackers) {
  * deployment recorded in that repository, are edited.
  */
 export async function updateRelatedPullRequests(db, run, hosts, trackers) {
-    const host = hosts?.[CODING_CODE_PROVIDER];
-    if (!host?.replaceRelatedSection || !host.pullRequestOrigin)
+    // A request's pull requests may span hosts: each is read and written through its own.
+    const editorFor = (repository) => {
+        const host = hosts?.[codeProviderOf(repository)];
+        return canEditRelatedSection(host) ? host : undefined;
+    };
+    if (!Object.values(hosts ?? {}).some(canEditRelatedSection))
         return;
     try {
         // A run that delegated nothing has no request set of its own.
@@ -306,6 +312,10 @@ export async function updateRelatedPullRequests(db, run, hosts, trackers) {
                 continue;
             }
             try {
+                // Reading only needs the read: a host that can't edit the section still reports its pull requests.
+                const host = hosts?.[codeProviderOf(pr.repository)];
+                if (!host?.pullRequestOrigin)
+                    throw new Error("no_host_for_repository");
                 const origin = await host.pullRequestOrigin(pr.repository, pr.number);
                 const state = origin.merged
                     ? "merged"
@@ -358,6 +368,9 @@ export async function updateRelatedPullRequests(db, run, hosts, trackers) {
             });
             if (!block)
                 continue;
+            const host = editorFor(target.repository);
+            if (!host)
+                continue;
             try {
                 const outcome = await host.replaceRelatedSection(target.repository, target.number, {
                     expectedMarkerRunId: target.markerRunId,
@@ -381,7 +394,7 @@ const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
 export const SIBLING_GUIDANCE = "Continue the pull request you were asked about, and a listed open one only when the change requires it. " +
     "Never open a new pull request in a repository that already has an open pull request listed here. Merged or " +
     "closed pull requests are not listed: a change there needs a new pull request.";
-const HINT_REPOSITORY = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+const HINT_REPOSITORY = /^(?:[a-z][a-z0-9-]{1,30}:)?[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
 /**
  * The continuation hint for a ticket (a GitHub or Jira issue) that already has
  * open wardby pull requests: one sentence per pull request (up to
@@ -396,9 +409,12 @@ export function openPullRequestHints(prs) {
         Number.isSafeInteger(p.number) &&
         p.number > 0)
         .slice(0, MAX_SIBLING_HINTS)
-        .map((p) => `This issue already has an open pull request wardby opened: ${p.repository}#${p.number} ` +
-        `(https://github.com/${p.repository}/pull/${p.number}). ` +
-        `To revise it, delegate with continuePriorRun set to exactly "${p.openedByRunId}".`);
+        .map((p) => {
+        const url = pullRequestWebUrl(codeProviderOf(p.repository), p.repository, p.number);
+        return (`This issue already has an open pull request wardby opened: ${p.repository}#${p.number}` +
+            `${url ? ` (${url})` : ""}. ` +
+            `To revise it, delegate with continuePriorRun set to exactly "${p.openedByRunId}".`);
+    });
     return lines.length > 0 ? [...lines, SIBLING_GUIDANCE].join("\n\n") : "";
 }
 /**
@@ -436,7 +452,7 @@ export async function openSiblings(db, seedRunId, exclude) {
 export async function openSiblingsForIssue(db, issue) {
     try {
         const newest = await db.issuePullRequest.findMany({
-            where: { issueProvider: issue.provider, issueKey: issue.key, codeProvider: CODING_CODE_PROVIDER },
+            where: { issueProvider: issue.provider, issueKey: issue.key, codeProvider: { not: "local" } },
             orderBy: { createdAt: "desc" },
             take: 1,
             select: { openedByRunId: true },

package/dist/core/review-fix.js

@@ -182,7 +182,7 @@ export async function startReviewFixAfterReview(runId, deps) {
         const check = await deps.db.runHostCheck.findUnique({ where: { runId } });
         if (!check || check.verdict !== "CHANGES_REQUESTED" || check.prNumber === null || !check.reviewBody)
             return;
-        if (check.provider !== "github")
+        if (check.provider === "local")
             return;
         const result = await startReviewFixRound({
             provider: check.provider,
@@ -256,7 +256,7 @@ async function reReview(runId, deps) {
     if (root.parentRunId)
         return skip("not_fix_round");
     const status = root.hostStatus;
-    if (!status || status.provider !== "github")
+    if (!status || status.provider === "local")
         return skip("not_fix_round");
     const provider = status.provider;
     const { repository, number: prNumber } = status;

package/dist/core/review-host-tools.js

@@ -14,6 +14,7 @@ import { MAX_PATCH_CURSOR_CHARS } from "../providers/review-host/patch-pages.js"
 import { escapeHtmlComments } from "../providers/review-host/review-format.js";
 import { REVIEW_HOST_PROVIDERS, PatchCursorError, ReviewHostError, } from "../providers/review-host/types.js";
 import { isLocalRepository, normalizeGitHubRepository, normalizeLocalRepository } from "../coding/protocol.js";
+import { codeProviderOf, normalizeHostedRepository } from "../coding/code-host.js";
 import { ciForAgent } from "./ci-context.js";
 import { logger } from "./logger.js";
 import { collectRelatedPullRequests } from "./related-pull-requests.js";
@@ -221,11 +222,12 @@ function normalizeFor(provider, value) {
             return normalizeGitHubRepository(value);
         if (provider === "local")
             return normalizeLocalRepository(value);
+        const repository = normalizeHostedRepository(value);
+        return codeProviderOf(repository) === provider ? repository : null;
     }
     catch {
         return null;
     }
-    return null;
 }
 export function resolveLink(links, repositoryArg) {
     const raw = repositoryArg.trim();

package/dist/core/runner.d.ts

@@ -36,6 +36,42 @@ import { ReviewReadLedger } from "./review-reads.js";
 import { type RepoAccessGate } from "./repo-access.js";
 import { type BudgetEventView } from "./budget-events.js";
 export declare const runnerLog: import("pino").Logger<never, boolean>;
+/**
+ * Sub-agent dispatch uses one synthetic tool per declared child, named by the
+ * boundName it's attached
+ * under. The parent's tool call blocks until the child run reaches a
+ * terminal state, and its result comes back as this tool call's result.
+ * A run delegates at most maxDelegationsPerRun times (default one: a
+ * classifier deciding plan-vs-implement commits to exactly one child) and to
+ * each child at most once. With Agent.parallelDelegations, the delegate_to_*
+ * calls of one turn run at the same time (NativeEngine.runToolCalls); their
+ * admission (the checks below plus the child row) is still one at a time,
+ * through the run's delegation gate, and a child refused for budget while a
+ * sibling runs waits for that sibling to finish (delegation-siblings.ts).
+ *
+ * Two execution paths depending on the child's `kind`:
+ * - `native`: calls `executeRun` directly, bypassing any `Executor` — the
+ *   created Run row is never marked `executionManaged`, so the reconciler
+ *   leaves it alone even if it runs long, the same way an attended
+ *   `wardby run` foreground execution does. Fast, in-process, no durability
+ *   machinery needed for a native turn loop.
+ * - `coding`: a coding-kind child needs a real Docker container (Codex),
+ *   which `executeRun` explicitly refuses to drive itself. Goes through
+ *   `dispatchRun` (the same persistence path webhooks/trigger_agent use)
+ *   with `awaitExecution: true`, so the already-existing `RoutingExecutor`
+ *   sends it to the container backend and this call blocks until it's
+ *   terminal — reusing proven infrastructure rather than re-implementing
+ *   container dispatch. Marked `executionManaged: true` here (unlike the
+ *   native path) since a long-running container crash mid-dispatch is
+ *   exactly the case the reconciler exists for. Under the coding
+ *   concurrency cap `Executor.start` can resolve with the child merely
+ *   queued (still pending), so the call then polls the child row until it
+ *   is terminal — see `waitForCodingChild`.
+ *
+ * The `delegate_to_` prefix lives in core/tool-names.ts, which reserves it
+ * so no user tool can be created under a name this dispatch would shadow.
+ */
+export declare function delegateToolDef(boundName: string, parallel: boolean, repositories?: readonly string[]): LoadedTool;
 declare const DelegateArgs: z.ZodObject<{
     task: z.ZodString;
     datastoreRef: z.ZodOptional<z.ZodObject<{
@@ -45,6 +81,7 @@ declare const DelegateArgs: z.ZodObject<{
     grantParentMemoryKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
     continuePriorRun: z.ZodOptional<z.ZodString>;
     mergeOrder: z.ZodOptional<z.ZodNumber>;
+    repository: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 /** A delegate_to_* call's arguments, or the tool result refusing them. */
 export declare function parseDelegateArgs(argsJson: string): {
@@ -52,18 +89,6 @@ export declare function parseDelegateArgs(argsJson: string): {
 } | {
     refusal: string;
 };
-/**
- * At most `limit` dispatches per run (default one: a classifier deciding plan-vs-implement
- * commits to exactly one child), and never the same child twice, so a retry can't leave two
- * children racing on the same task. A delegation waiting for budget holds its place.
- */
-export declare function delegationLimitRefusal(input: {
-    priorChildAgentIds: readonly string[];
-    waitingChildAgentIds: readonly string[];
-    childAgentId: string;
-    boundName: string;
-    limit: number;
-}): string | null;
 declare const DELEGATION_CHILD_SELECT: {
     readonly id: true;
     readonly kind: true;
@@ -75,6 +100,8 @@ declare const DELEGATION_CHILD_SELECT: {
         readonly select: {
             readonly allowWebhookTaskOverride: true;
             readonly timeoutSec: true;
+            readonly repository: true;
+            readonly baseRef: true;
         };
     };
 };
@@ -105,7 +132,7 @@ export declare function nativeChildResult(run: Pick<Run, "status" | "finalText"
  * also satisfies `dispatch.ts`'s `DispatchDb`, needed for dispatching a
  * coding-kind sub-agent from inside a running native turn loop.
  */
-export type RunnerDb = Pick<PrismaClient, "agent" | "run" | "agentTool" | "agentSecret" | "agentDatastore" | "budgetGroup" | "agentSubAgent" | "resourceGrant" | "codingRun" | "registryFetch" | "registryAuditRecord" | "task" | "webhook" | "$transaction" | "$queryRaw" | "agentRepository" | "runModelUsage" | "runHostCheck" | "runBudgetEvent" | "runHostStatus" | "hostIdentity" | "agentIssueProject" | "issuePullRequest" | "runIssueStatus" | "issueFingerprint" | "workItem" | "deferredReview" | "runAttribution">;
+export type RunnerDb = Pick<PrismaClient, "agent" | "run" | "agentTool" | "agentSecret" | "agentMcpServer" | "secret" | "agentDatastore" | "budgetGroup" | "agentSubAgent" | "resourceGrant" | "codingRun" | "registryFetch" | "registryAuditRecord" | "task" | "webhook" | "$transaction" | "$queryRaw" | "agentRepository" | "runModelUsage" | "runHostCheck" | "runBudgetEvent" | "runHostStatus" | "hostIdentity" | "agentIssueProject" | "issuePullRequest" | "runIssueStatus" | "issueFingerprint" | "workItem" | "deferredReview" | "runAttribution">;
 /** The providers a native run needs; `executor`, `reviewHosts` and `issueTrackers` are optional capabilities. */
 export type NativeRunProviders = Pick<ProviderRegistry, "llm" | "engine" | "datastore" | "secrets" | "memory"> & {
     executor?: ProviderRegistry["executor"];
@@ -262,8 +289,6 @@ export interface LoadNativeRunOptions {
  * order diverges from the record.
  */
 export declare function loadNativeRun(options: LoadNativeRunOptions): Promise<{
-    repositoryLinks: RepositoryLink[];
-    issueProjectLinks: IssueProjectLink[];
     agent: {
         untrustedContext?: string | undefined;
         effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
@@ -275,6 +300,7 @@ export declare function loadNativeRun(options: LoadNativeRunOptions): Promise<{
     tools: LoadedTool[];
     toolsByName: {
         [k: string]: {
+            timeoutMs?: number | undefined;
             code: string;
             paramsZod: string;
             allowedSecrets: string[];
@@ -283,6 +309,9 @@ export declare function loadNativeRun(options: LoadNativeRunOptions): Promise<{
             allowedSharedDatastorePrefixes: Record<string, string[]>;
         };
     };
+    mcpTools?: import("./mcp-tools.js").McpToolPin[] | undefined;
+    repositoryLinks: RepositoryLink[];
+    issueProjectLinks: IssueProjectLink[];
     parallelDelegations?: boolean | undefined;
     maxDelegationsPerRun?: number | undefined;
     agentId: string;
@@ -311,6 +340,8 @@ export interface NativeRunToolsOptions {
     issueTrackers: IssueTrackerRegistry | undefined;
     /** What earlier requests of this run read (a sandbox run's gateway restores it per request); fresh otherwise. */
     reviewReads?: ReviewReadLedger;
+    /** A sandboxed run's session deadline (the gateway's); an MCP tool call never runs past it. */
+    deadlineAt?: Date;
 }
 /** An attached user tool as the load step pinned it: its code, schema, and consented capabilities. */
 export type LoadedUserTool = LoadedNativeRun["toolsByName"][string];
@@ -336,6 +367,7 @@ export declare function readRedactionValues(accessor: SecretsAccessor, names: re
  */
 export declare function createNativeRunTools(options: NativeRunToolsOptions): {
     toolsByName: Map<string, {
+        timeoutMs?: number | undefined;
         code: string;
         paramsZod: string;
         allowedSecrets: string[];
@@ -348,6 +380,13 @@ export declare function createNativeRunTools(options: NativeRunToolsOptions): {
     readableSecretValues: (name: string) => Promise<string[]>;
     runUserTool: (name: string, argsJson: string) => Promise<string>;
     runSandboxTool: (name: string, argsJson: string, callId?: string) => Promise<string>;
+    toolTimeoutMs: (name: string) => number | undefined;
+    watchStop: () => {
+        signal: AbortSignal;
+        done: () => void;
+    };
+    /** Every secret value of the agent's attached MCP servers (never handed to a worker; redaction only). */
+    mcpSecretValues: () => Promise<string[]>;
 };
 /**
  * Live progress for observers (MCP get_run, the viewer). Absolute totals, so a DBOS replay
@@ -374,6 +413,17 @@ export declare function finishNativeRun(ctx: NativeRunFinishContext, model: stri
 export declare function failNativeRun(ctx: NativeRunFinishContext, err: unknown): Promise<Run>;
 /** The terminal write for a run that cannot continue (it ends `lost` with `reason`), then the same settle path. */
 export declare function loseNativeRun(ctx: NativeRunFinishContext, reason: string): Promise<Run>;
+/** How often a user tool call in progress checks whether its run was stopped. */
+export declare const TOOL_STOP_POLL_MS = 2000;
+/**
+ * Aborts `signal` once the run is no longer drivable (stop_run, a cancelled task, a parent's
+ * stop). Polls every `intervalMs`, starting one interval in, so a quick call reads nothing; a
+ * failed read changes nothing and the next tick reads again. `done()` stops the polling.
+ */
+export declare function watchRunStop(db: RunnerDb, runId: string, intervalMs?: number): {
+    signal: AbortSignal;
+    done: () => void;
+};
 /** Where a run stands for the native gateway: still drivable, cancelled (its task), or otherwise ended. */
 export declare function runDrivability(db: RunnerDb, runId: string): Promise<RunDrivability>;
 /**
@@ -383,7 +433,7 @@ export declare function runDrivability(db: RunnerDb, runId: string): Promise<Run
  */
 export declare function sandboxWorkerInput(runId: string, loaded: LoadedNativeRun, tools: Pick<ReturnType<typeof createNativeRunTools>, "builtinHandler" | "toolsByName">): WorkerInput;
 /** What the durable delegation needs from the gateway ledger (src/native-worker/ledger.ts). */
-export type DelegationLedger = Pick<PrismaGatewayLedger, "claim" | "recordResult" | "setDelegation" | "delegation" | "waitingChildAgentIds">;
+export type DelegationLedger = Pick<PrismaGatewayLedger, "claim" | "recordResult" | "setDelegation" | "delegation" | "waitingDelegations">;
 export interface DurableDelegationContext {
     runId: string;
     existingRun: Run;