@wardby/cli 0.4.1 → 0.5.1

package/dist/mcp/tools/trigger.js

@@ -30,7 +30,10 @@
  */
 import { dispatchRun } from "../../core/dispatch.js";
 import { AttributionError, explicitAttribution, RESPONSE_PATH_SNAPSHOT_BUDGET, } from "../../core/attribution.js";
-import { CodingBaseRefSchema, CodingTaskOverrideSchema } from "../../coding/protocol.js";
+import { CodingBaseRefSchema, CodingTaskOverrideSchema, isLocalRepository } from "../../coding/protocol.js";
+import { loadLocalRepoRoots, resolveLocalRepository, LocalRepoError } from "../../coding/local-repo.js";
+import { localRepoWarnings } from "../../coding/local-repo-status.js";
+import { SHA, isSafeRefName, localGit } from "../../coding/local-git.js";
 import { z } from "zod";
 import { McpError } from "../errors.js";
 import { createTaskResult, getTask, cancelTask } from "../tasks/manager.js";
@@ -44,8 +47,68 @@ const TriggerAgentSchema = z
     task: CodingTaskOverrideSchema.optional(),
     baseRef: CodingBaseRefSchema.optional(),
     issue: z.unknown().optional(),
+    review: z
+        .object({
+        repository: z.string().optional(),
+        branch: z.string().min(1).max(250),
+        base: z.string().min(1).max(250).optional(),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
+/**
+ * Resolves a manual local review request to a canonical repository and the two
+ * commit SHAs. Roots are re-checked now (they can narrow after linking); every
+ * failure is a 400 whose message carries the code, before any row exists.
+ */
+async function resolveLocalReview(ctx, agentId, review) {
+    let repository = review.repository;
+    const links = await ctx.db.agentRepository.findMany({ where: { agentId, provider: "local" } });
+    if (repository === undefined) {
+        if (links.length !== 1)
+            throw new McpError(400, "pass review.repository");
+        repository = links[0].repository;
+    }
+    let resolved;
+    try {
+        resolved = await resolveLocalRepository(repository, loadLocalRepoRoots(process.env).roots);
+    }
+    catch (err) {
+        if (err instanceof LocalRepoError)
+            throw new McpError(400, err.message);
+        throw new McpError(400, `local_repo_not_found: ${err.message}`);
+    }
+    if (!links.some((l) => l.repository === resolved.repository)) {
+        throw new McpError(400, `Agent "${agentId}" is not linked to ${resolved.repository}; link it with link_repository first.`);
+    }
+    const dir = resolved.path;
+    let base = review.base;
+    if (base === undefined) {
+        try {
+            base = (await localGit(dir, ["symbolic-ref", "--short", "HEAD"])).trim();
+        }
+        catch {
+            throw new McpError(400, "local_ref_invalid: the repository's HEAD is not on a branch; pass review.base");
+        }
+    }
+    const sha = async (ref) => {
+        if (!(await isSafeRefName(dir, ref)))
+            throw new McpError(400, `local_ref_invalid: "${ref}" is not a valid branch name`);
+        try {
+            const out = (await localGit(dir, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`])).trim();
+            if (SHA.test(out))
+                return out;
+        }
+        catch {
+            // fall through
+        }
+        throw new McpError(400, `local_ref_not_found: "${ref}" does not name a commit in ${resolved.repository}`);
+    };
+    const headSha = await sha(review.branch);
+    await sha(base);
+    return { repository: resolved.repository, branch: review.branch, base, headSha };
+}
 function parseTriggerArgs(args) {
     const parsed = TriggerAgentSchema.safeParse(args);
     if (parsed.success)
@@ -87,6 +150,24 @@ export function registerTriggerTool(mcp) {
                 agentId: { type: "string" },
                 task: { type: "string" },
                 baseRef: { type: "string" },
+                review: {
+                    type: "object",
+                    additionalProperties: false,
+                    description: "Native review agents only, owner only: review a branch of a linked local repository (local:/abs/path). " +
+                        "The result appears in get_run as `review`.",
+                    properties: {
+                        repository: {
+                            type: "string",
+                            description: "The local repository (local:/abs/path). Default: the agent's only local link.",
+                        },
+                        branch: { type: "string", description: "The branch to review (resolved to its current commit)." },
+                        base: {
+                            type: "string",
+                            description: "The branch to review against. Default: the branch currently checked out in the repository.",
+                        },
+                    },
+                    required: ["branch"],
+                },
                 issue: {
                     type: "object",
                     description: "Count this run's cost toward an issue in a project the agent is linked to.",
@@ -99,9 +180,34 @@ export function registerTriggerTool(mcp) {
         handler: async (rawArgs, ctx) => {
             const args = parseTriggerArgs(rawArgs);
             const agent = await requireTriggerable(ctx, await ctx.db.agent.findUnique({ where: { id: args.agentId }, include: { codingProfile: true } }), args.agentId, args);
+            let review;
+            if (args.review !== undefined) {
+                if (agent.kind !== "native")
+                    throw new McpError(400, "review is only valid for native review agents.");
+                if (agent.ownerId === null || agent.ownerId !== ctx.principal.id) {
+                    throw new McpError(403, `Agent "${agent.id}": only its owner can start a manual review.`);
+                }
+                review = await resolveLocalReview(ctx, agent.id, args.review);
+            }
             if (agent.kind !== "coding" && (args.task !== undefined || args.baseRef !== undefined)) {
                 throw new McpError(400, "Task and baseRef overrides are only valid for coding agents.");
             }
+            // A local repository is re-checked against the roots as they are now
+            // (they can narrow after the agent was saved), before any run exists.
+            let warnings = [];
+            const repository = agent.kind === "coding" ? agent.codingProfile?.repository : undefined;
+            if (repository !== undefined && isLocalRepository(repository)) {
+                try {
+                    const resolved = await resolveLocalRepository(repository, loadLocalRepoRoots(process.env).roots);
+                    warnings = await localRepoWarnings(resolved.path);
+                }
+                catch (err) {
+                    if (err instanceof LocalRepoError)
+                        throw new McpError(400, err.message);
+                    throw err;
+                }
+            }
+            const withWarnings = (result) => (warnings.length > 0 ? { ...result, warnings } : result);
             // Refused before any run exists: an invalid or unlinked issue is never
             // silently dropped into an unattributed run.
             let attribution;
@@ -115,38 +221,61 @@ export function registerTriggerTool(mcp) {
                     throw err;
                 }
             }
-            const dispatched = await dispatchRun({
-                db: ctx.db,
-                executor: ctx.providers.executor,
-                selfDefects: { db: ctx.db, issueTrackers: ctx.providers.issueTrackers },
-                agentId: agent.id,
-                trigger: "manual",
-                codingTask: args.task,
-                codingBaseRef: args.baseRef,
-                attribution,
-                task: ctx.clientSupportsTasks ? { principalId: ctx.principal.id, ttlMs: DEFAULT_TASK_TTL_MS } : undefined,
-                triggeredById: ctx.principal.id,
-                // Re-checked through the transaction: a concurrent revoke or
-                // make_owner conflicts instead of racing the run in.
-                beforePersist: async (tx, current) => {
-                    await requireTriggerable(ctx, current, agent.id, args, tx);
-                    return true;
-                },
-            });
-            if (!dispatched)
-                throw new Error("Run dispatch was not claimed.");
+            // The pull request row is made first (its serial number is in the task
+            // text) and removed again if the run is not dispatched.
+            const pullRequest = review
+                ? await ctx.db.localPullRequest.create({
+                    data: { repository: review.repository, branch: review.branch, base: review.base },
+                })
+                : undefined;
+            let dispatched;
+            try {
+                dispatched = await dispatchRun({
+                    db: ctx.db,
+                    executor: ctx.providers.executor,
+                    selfDefects: { db: ctx.db, issueTrackers: ctx.providers.issueTrackers },
+                    agentId: agent.id,
+                    trigger: "manual",
+                    codingTask: args.task,
+                    codingBaseRef: args.baseRef,
+                    attribution,
+                    task: ctx.clientSupportsTasks ? { principalId: ctx.principal.id, ttlMs: DEFAULT_TASK_TTL_MS } : undefined,
+                    triggeredById: ctx.principal.id,
+                    ...(review && pullRequest
+                        ? {
+                            taskOverride: `Review pull request #${pullRequest.number} in ${review.repository} (head ${review.headSha}).`,
+                            afterPersist: async (tx, run) => {
+                                await tx.localPullRequest.update({ where: { id: pullRequest.id }, data: { runId: run.id } });
+                            },
+                        }
+                        : {}),
+                    // Re-checked through the transaction: a concurrent revoke or
+                    // make_owner conflicts instead of racing the run in.
+                    beforePersist: async (tx, current) => {
+                        await requireTriggerable(ctx, current, agent.id, args, tx);
+                        return true;
+                    },
+                });
+                if (!dispatched)
+                    throw new Error("Run dispatch was not claimed.");
+            }
+            catch (err) {
+                if (pullRequest)
+                    await ctx.db.localPullRequest.deleteMany({ where: { id: pullRequest.id } }).catch(() => { });
+                throw err;
+            }
             if (ctx.clientSupportsTasks) {
                 if (!dispatched.task)
                     throw new Error("Run task was not persisted.");
-                return textResult(createTaskResult(dispatched.task, DEFAULT_TASK_TTL_MS));
+                return textResult(withWarnings(createTaskResult(dispatched.task, DEFAULT_TASK_TTL_MS)));
             }
             // A run refused at dispatch (its budget group or run tree is spent), or
             // failed there (a coding agent's model is unavailable), is already
             // terminal: say so now rather than only through get_run.
             if (dispatched.run.status === "refused" || dispatched.run.status === "failed") {
-                return textResult({ runId: dispatched.run.id, status: dispatched.run.status, error: dispatched.run.error });
+                return textResult(withWarnings({ runId: dispatched.run.id, status: dispatched.run.status, error: dispatched.run.error }));
             }
-            return textResult({ runId: dispatched.run.id });
+            return textResult(withWarnings({ runId: dispatched.run.id }));
         },
     });
     // Neither handler sets `resultType` itself: it's wire-only protocol

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

@@ -69,6 +69,17 @@ export interface EngineRunContext {
     providers: Pick<ProviderRegistry, "llm">;
     /** Host bridge: validates params (Zod-in-sandbox) then runs the tool body in the WASM sandbox. Never throws — a tool/validation failure is a JSON error result string, fed back to the model as the tool's result. */
     runSandboxTool(name: string, argsJson: string): Promise<string>;
+    /**
+     * Consecutive tool calls of one model turn for which this returns true run
+     * at the same time as each other (a lead's delegate_to_* calls, when the
+     * agent opted in to parallelDelegations); every other call, including a
+     * lone eligible one, runs alone, in order. Calls are never reordered, and
+     * results still go back to the model in call order. Absent: every call runs
+     * one after another. Under a checkpointing `step`, an engine must start the
+     * concurrent steps in an order fixed by the turn's calls alone (see
+     * NativeEngine.runToolCalls).
+     */
+    runsConcurrently?: (toolName: string) => boolean;
     onText?: (delta: string) => void;
     /** Called after each model turn that completed without error; the engine awaits it. */
     onProgress?: (progress: EngineProgress) => Promise<void>;

package/dist/providers/executor/composition.js

@@ -12,7 +12,8 @@ import { DockerJobLauncher } from "../jobs/docker.js";
 import { ClientNodeKubernetesApi } from "../jobs/kubernetes-client.js";
 import { isRegistryDigest } from "../jobs/kubernetes-isolation.js";
 import { assertPlatformConfig, platformProfile } from "../jobs/kubernetes-platform.js";
-import { runKubernetesPreflight } from "../jobs/kubernetes-preflight.js";
+import { preflightCanaryImage, runKubernetesPreflight } from "../jobs/kubernetes-preflight.js";
+import { CODING_WORKER_IMAGES_REQUIRED } from "../../coding/docker-preflight.js";
 import { KubernetesJobLauncher } from "../jobs/kubernetes.js";
 import { buildVcsProvider } from "../vcs/index.js";
 import { ContainerExecutor, PrismaContainerExecutionStore, RunCapabilityVault } from "./container.js";
@@ -29,15 +30,18 @@ export function buildConfiguredExecutor(options) {
         return options.native;
     const github = loadGitHubVcsConfig(env);
     const config = loadContainerExecutorConfig(env);
-    if (!config.workerImage)
-        throw new Error(`CODING_WORKER_IMAGE is required when JOB_LAUNCHER=${providerConfig.jobs}.`);
+    // Each provider's images are optional, but a coding launcher with neither can run nothing.
+    const claudeConfigured = Boolean(config.claudeWorkerImage && config.claudeToolRunnerImage);
+    if (!config.workerImage && !claudeConfigured) {
+        throw new Error(`${CODING_WORKER_IMAGES_REQUIRED} when JOB_LAUNCHER=${providerConfig.jobs}.`);
+    }
     const proxyContainer = config.proxyContainer;
     if (providerConfig.jobs === "docker" && !proxyContainer) {
         throw new Error("CODING_PROXY_CONTAINER is required when JOB_LAUNCHER=docker.");
     }
     const workspaceRoot = resolve(github.workRoot ?? resolve(tmpdir(), "wardby-vcs"));
     const artifactRoot = resolve(config.artifactRoot ?? resolve(tmpdir(), "wardby-coding-artifacts"));
-    const vcs = buildVcsProvider(providerConfig, { ...github, workRoot: workspaceRoot });
+    const vcs = buildVcsProvider(providerConfig, { ...github, workRoot: workspaceRoot }, env);
     const capabilities = new RunCapabilityVault();
     const sessions = new CodingProxy({
         ledger: new PrismaProxyLedger(options.db),
@@ -46,7 +50,7 @@ export function buildConfiguredExecutor(options) {
     const onServiceState = prismaServiceStateReporter(options.db);
     let jobs;
     if (providerConfig.jobs === "kubernetes") {
-        if (!isRegistryDigest(config.workerImage)) {
+        if (config.workerImage !== undefined && !isRegistryDigest(config.workerImage)) {
             throw new Error("CODING_WORKER_IMAGE must be a registry digest (repo@sha256:...) when JOB_LAUNCHER=kubernetes.");
         }
         for (const image of [config.claudeWorkerImage, config.claudeToolRunnerImage]) {
@@ -66,7 +70,8 @@ export function buildConfiguredExecutor(options) {
             maxDiskMb: config.maxDiskMb,
         });
         const api = options.kubernetesApi ?? new ClientNodeKubernetesApi({ context: kubernetes.context });
-        const workerImage = config.workerImage;
+        // The canary needs some worker image to run node in; the Claude worker stands in on a Claude-only server.
+        const workerImage = preflightCanaryImage(config);
         jobs = new KubernetesJobLauncher({
             onServiceState,
             api,
@@ -126,7 +131,7 @@ 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) }),
+        repoAccess: options.repoAccess ?? createRepoAccessGate({ db: options.db, hosts: buildReviewHosts(env, options.db) }),
         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" } });

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

@@ -8,12 +8,20 @@ import type { ProxyModelTerms, ProxyProtocol } from "../coding-proxy/types.js";
 import type { JobHandle, JobResourceLimits, WorkspaceJobLauncher } from "../jobs/types.js";
 import type { VcsProvider } from "../vcs/types.js";
 import type { CodingImageSelector, ExecutionRecoveryResult, Executor, PersistedExecutionHandle } from "./types.js";
+import type { RelatedPullRequestEntry } from "../vcs/github.js";
 /**
  * Claude Code's commands run in its tool runner, which never reports back through the agent, so the
  * host rewrites registry-proxy download URLs in collected lockfiles itself (the Codex driver does it
  * in the worker). Best effort and symlink-safe (lockfiles.ts); a Codex workspace is left alone.
  */
 export declare function normalizeCollectedLockfiles(provider: string, workspacePath: string): Promise<string[]>;
+/** Columns on CodingRun recorded when a run completes, beyond its result JSON. */
+export interface CodingRunRecord {
+    /** The pushed branch of a run on a local repository. */
+    resultBranch?: string;
+    /** The commit the run started from. */
+    baseSha?: string;
+}
 export interface ContainerRunSnapshot {
     runId: string;
     status: string;
@@ -53,6 +61,8 @@ export interface ContainerRunSnapshot {
     workspaceDiskMb: number | null;
     /** Admin-requested debug trace, fixed at dispatch (CodingRun.debugTrace). */
     debugTrace?: boolean;
+    /** Claude Code turn limit, fixed at dispatch (CodingRun.maxTurns); null = the worker default. */
+    maxTurns?: number | null;
     /** Coding-run services resolved at dispatch (CodingRun.services); parsed with parseStoredServices. */
     services?: unknown;
     /** The terminal failure category, once the run has one (CodingRun.failureCategory). */
@@ -75,9 +85,21 @@ export type ProvisioningClaim = "claimed" | "unavailable" | "queued";
 export interface ContainerExecutionStore {
     load(runId: string): Promise<ContainerRunSnapshot | null>;
     claimProvisioning(runId: string, claimId: string): Promise<ProvisioningClaim>;
+    /**
+     * Puts a pending, unclaimed run in the coding queue (sets CodingRun.queuedAt if unset), for a run
+     * the cluster has no room for yet. drainCodingQueue retries it when a run ends and on each
+     * scheduler tick, until CODING_QUEUE_TIMEOUT_SEC.
+     */
+    markQueued?(runId: string): Promise<void>;
     persistHandle(runId: string, claimId: string, handle: JobHandle): Promise<void>;
     heartbeat(runId: string): Promise<void>;
-    complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult): Promise<void>;
+    /**
+     * The pull requests already opened for the same request as this run (same
+     * top-level run tree or tracked issue), in dispatch order, for the new PR's
+     * Related pull requests section. Optional: without it no section is written.
+     */
+    relatedPullRequests?(runId: string): Promise<RelatedPullRequestEntry[]>;
+    complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult, record?: CodingRunRecord): Promise<void>;
     terminate(runId: string, status: "failed" | "refused" | "lost" | "budget_exhausted" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
 }
 export interface CodingFailureAudit {
@@ -97,10 +119,12 @@ export declare class PrismaContainerExecutionStore implements ContainerExecution
     /** An empty registry (no Jira site configured) means no self-defect queries at all. */
     private get hasTrackers();
     load(runId: string): Promise<ContainerRunSnapshot | null>;
+    relatedPullRequests(runId: string): Promise<RelatedPullRequestEntry[]>;
     claimProvisioning(runId: string, claimId: string): Promise<ProvisioningClaim>;
+    markQueued(runId: string): Promise<void>;
     persistHandle(runId: string, claimId: string, handle: JobHandle): Promise<void>;
     heartbeat(runId: string): Promise<void>;
-    complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult): Promise<void>;
+    complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult, record?: CodingRunRecord): Promise<void>;
     terminate(runId: string, status: "failed" | "refused" | "lost" | "budget_exhausted" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
 }
 export interface CodingSessionController {
@@ -137,7 +161,12 @@ export interface ContainerExecutorOptions {
     sessions: CodingSessionController;
     capabilities: RunCapabilityVault;
     artifactRoot: string;
-    workerImage: string;
+    /**
+     * The Codex worker for the "node" toolchain (CODING_WORKER_IMAGE). Optional on a Claude-only
+     * deployment: a Codex run without an agent BYO image is then refused with
+     * coding_provider_not_configured:codex, as Claude Code is without its images.
+     */
+    workerImage?: string;
     /** Additional toolchains beyond the "node" baseline (workerImage). Keyed by toolchain, then version. */
     additionalWorkerImages?: Record<string, Record<string, string>>;
     credentialRef: string;
@@ -243,6 +272,8 @@ export declare class ContainerExecutor implements Executor {
     private authorizeRepository;
     /** The originating issue for the PR title/body: control-plane data from the CodingRun row, key re-validated. */
     private issueFor;
+    /** The new PR's Related pull requests input: earlier PRs of the same request, then this one. Never throws. */
+    private relatedFor;
     /** The run's stored model terms; a run from before the catalog resolves them from the current catalog. */
     private modelTerms;
     private preflight;
@@ -272,6 +303,12 @@ export declare class ContainerExecutor implements Executor {
     /** The job launcher decides (Kubernetes and Docker start services for both providers). */
     supportsCodingServices(provider: CodingProvider): boolean;
     private requireCurrent;
+    /**
+     * False when the launcher reports this run's job would not fit the cluster right now; the run
+     * is then queued and drainCodingQueue retries it. Launchers and stores without the hooks, and
+     * any error, answer true: the launch stays the authority.
+     */
+    private fitsCluster;
     private jobSpec;
     private credentialRef;
     private writeInput;