@wardby/cli 0.4.1 → 0.5.1

package/dist/import/neutral-schema.d.ts

@@ -110,13 +110,13 @@ export declare const NeutralAgentSchema: z.ZodObject<{
     name: string;
     model: string;
     budgetUsd: string;
+    maxTurns: number;
     provider: "openai" | "bedrock";
     kind: "native";
     systemPrompt: string;
     schedule: string | null;
     timezone: string;
     scheduleEnabled: boolean;
-    maxTurns: number;
     memoryEnabled: boolean;
     region: string | null;
     ownerEmail: string | null;
@@ -129,10 +129,10 @@ export declare const NeutralAgentSchema: z.ZodObject<{
     name: string;
     model: string;
     budgetUsd: string;
+    maxTurns: number;
     provider: "openai" | "bedrock";
     systemPrompt: string;
     scheduleEnabled: boolean;
-    maxTurns: number;
     kind?: "native" | undefined;
     schedule?: string | null | undefined;
     timezone?: string | undefined;

package/dist/mcp/auth/access.d.ts

@@ -40,6 +40,7 @@ export declare function requireAgentAccess(ctx: McpRequestContext, id: string, r
         name: string;
         model: string;
         budgetUsd: import("@prisma/client-runtime-utils").Decimal;
+        maxTurns: number;
         createdAt: Date;
         updatedAt: Date;
         kind: import("#prisma").AgentKind;
@@ -50,7 +51,8 @@ export declare function requireAgentAccess(ctx: McpRequestContext, id: string, r
         timezone: string;
         scheduleEnabled: boolean;
         lastScheduledAt: Date | null;
-        maxTurns: number;
+        maxDelegationsPerRun: number;
+        parallelDelegations: boolean;
         defectProjectKey: string | null;
         defectIssueType: string | null;
         budgetGroupId: string | null;

package/dist/mcp/auth/host-account-cli.js

@@ -6,7 +6,7 @@
  * principal (link_host_account refuses one already linked elsewhere).
  */
 import { parseArgs } from "node:util";
-import { REVIEW_HOST_PROVIDERS } from "../../providers/review-host/types.js";
+import { HOST_ACCOUNT_PROVIDERS } from "../../providers/review-host/types.js";
 const USAGE = "Use auth host-account list [--subject <s>] | host-account unlink --subject <s> [--provider github].";
 export async function hostAccountCommand(args, db, output = console.log) {
     const [action, ...rest] = args;
@@ -19,7 +19,7 @@ export async function hostAccountCommand(args, db, output = console.log) {
         options: { subject: { type: "string" }, provider: { type: "string" } },
     });
     const provider = values.provider ?? "github";
-    if (!REVIEW_HOST_PROVIDERS.includes(provider))
+    if (!HOST_ACCOUNT_PROVIDERS.includes(provider))
         throw new Error(`Unknown provider "${provider}".`);
     if (action === "list") {
         const rows = await db.hostIdentity.findMany({

package/dist/mcp/auth/repo-authorization.d.ts

@@ -1,10 +1,3 @@
-/**
- * Set-time repository authorization for the MCP tools that give an agent
- * authority over a repository (link_repository; create_agent/update_agent's
- * codingProfile.repository). Returns the stamp to store on the granting row,
- * or throws an actionable McpError. See core/repo-access.ts for the use-time
- * side and the rules; the host call happens here, before any transaction.
- */
 import { type AuthorizedVia, type RepoAccessKind } from "../../core/repo-access.js";
 import type { McpRequestContext } from "../context.js";
 export interface RepositoryAuthorization {
@@ -12,6 +5,12 @@ export interface RepositoryAuthorization {
     authorizedById: string;
     authorizedAt: Date;
 }
+/**
+ * The canonical (realpath-based) name of a `local:` repository inside the
+ * current trusted roots; a 400 whose message carries the error code otherwise.
+ * Agents store this, never the caller's spelling.
+ */
+export declare function canonicalLocalRepository(repository: string): Promise<string>;
 export declare function authorizeRepositoryForSet(ctx: McpRequestContext, input: {
     /** The agent's owner. The caller is always the owner here (or creating the agent). */
     ownerId: string | null;

package/dist/mcp/auth/repo-authorization.js

@@ -5,9 +5,25 @@
  * or throws an actionable McpError. See core/repo-access.ts for the use-time
  * side and the rules; the host call happens here, before any transaction.
  */
+import { LocalRepoError, isLocalRepository, loadLocalRepoRoots, resolveLocalRepository, } from "../../coding/local-repo.js";
 import { requiredLevel } from "../../core/repo-access.js";
 import { McpError } from "../errors.js";
 import { requireScope } from "./resource-server.js";
+/**
+ * The canonical (realpath-based) name of a `local:` repository inside the
+ * current trusted roots; a 400 whose message carries the error code otherwise.
+ * Agents store this, never the caller's spelling.
+ */
+export async function canonicalLocalRepository(repository) {
+    try {
+        return (await resolveLocalRepository(repository, loadLocalRepoRoots(process.env).roots)).repository;
+    }
+    catch (err) {
+        if (err instanceof LocalRepoError)
+            throw new McpError(400, err.message);
+        throw new McpError(400, `local_repo_not_found: ${err.message}`);
+    }
+}
 export async function authorizeRepositoryForSet(ctx, input) {
     if (!input.ownerId) {
         throw new McpError(400, "owner_required: agents without an owner can't be given a repository, because an owner-less agent has no owner " +
@@ -18,6 +34,11 @@ export async function authorizeRepositoryForSet(ctx, input) {
         authorizedById: ctx.principal.id,
         authorizedAt: new Date(),
     });
+    if (isLocalRepository(input.repository)) {
+        // Trusted roots decide, never a host identity or an admin override.
+        await canonicalLocalRepository(input.repository);
+        return stamp("local_root");
+    }
     if (input.adminOverride) {
         // Role-gated: the scope alone never suffices (resource-server.ts).
         requireScope(ctx, ctx.canonicalUri, "agents:admin");

package/dist/mcp/index.js

@@ -38,6 +38,7 @@ import { ROLE_NAMES, SCOPES_SUPPORTED, authenticate } from "./auth/resource-serv
 import { canonicalUrl } from "./transport/http-limits.js";
 import { createViewerApi } from "../viewer/http.js";
 import { createViewerEventBus } from "../viewer/event-bus.js";
+import { buildInfraInfo } from "../viewer/infra.js";
 import { registerAgentTools } from "./tools/agents.js";
 import { registerServiceTools } from "./tools/services.js";
 import { registerBudgetGroupTools } from "./tools/budget-groups.js";
@@ -135,7 +136,7 @@ export function buildMcpProviders() {
     const secrets = buildSecretCipher(providerConfig);
     const datastore = new PostgresDatastore(prisma, secrets);
     const memory = new PostgresAgentMemory(prisma);
-    const reviewHosts = buildReviewHosts();
+    const reviewHosts = buildReviewHosts(process.env, prisma);
     const issueTrackers = buildIssueTrackers();
     const hostUserAuthorizers = buildHostUserAuthorizers();
     // One gate (and one cache) for the whole process: set-time checks in the
@@ -317,6 +318,8 @@ export async function startMcp(options = {}) {
             bus: viewerBus,
             authenticate: (authorization) => authenticate({ authorization }, { authProvider, db: prisma, providers, canonicalUri: canonicalHref }),
             canonicalUri: canonicalHref,
+            infra: buildInfraInfo(),
+            issueSites: jiraConfig ? { jira: jiraConfig.siteUrl } : {},
         })
         : undefined;
     const http = await startHttpServer({

package/dist/mcp/tools/agents.js

@@ -8,6 +8,7 @@
 import { Prisma } from "#prisma";
 import { z } from "zod";
 import { CodingProfilePatchSchema, CodingProfileSchema } from "../../coding/profile.js";
+import { DEFAULT_CLAUDE_MAX_TURNS, MAX_CODING_TURNS, isLocalRepository } from "../../coding/protocol.js";
 import { codingProviderSupportsModel } from "../../coding/provider.js";
 import { assertAgentModelAvailable } from "../../core/run-pricing.js";
 import { ModelUnavailableError } from "../../providers/llm/catalog-types.js";
@@ -22,7 +23,7 @@ import { EVERYONE_KEY, atLeast, canDelegate, deleteGrantsFor, effectiveAccess }
 import { projectTool } from "./tools.js";
 import { requireAnyScope, requireScope } from "../auth/resource-server.js";
 import { logger } from "../../core/logger.js";
-import { authorizeRepositoryForSet } from "../auth/repo-authorization.js";
+import { authorizeRepositoryForSet, canonicalLocalRepository, } from "../auth/repo-authorization.js";
 import { McpError } from "../errors.js";
 import { textResult } from "./text-result.js";
 // workerImageRef is the BYO-arbitrary-image escape hatch (see
@@ -48,12 +49,19 @@ const MAX_AGENT_NAME_CHARS = 200;
 const MAX_SYSTEM_PROMPT_CHARS = 64 * 1024;
 const MAX_MODEL_CHARS = 128;
 const MAX_BUDGET_USD = 1_000_000;
+/** Upper bound on Agent.maxDelegationsPerRun: a lead fanning out to one builder per repository. */
+const MAX_DELEGATIONS_PER_RUN = 20;
+const PARALLEL_DELEGATIONS_DESCRIPTION = "Native agents with sub-agents: when true, the delegate_to_* calls the agent makes in one model turn run at the same time " +
+    "instead of one after another (other tool calls still run in order). The run tree still shares one budget, so later " +
+    "sub-agents get what earlier ones leave. Coding sub-agents still queue for CODING_MAX_CONCURRENT slots. Default false.";
 const agentFields = {
     name: z.string().trim().min(1).max(MAX_AGENT_NAME_CHARS),
     systemPrompt: z.string().min(1).max(MAX_SYSTEM_PROMPT_CHARS),
     model: z.string().trim().min(1).max(MAX_MODEL_CHARS),
     budgetUsd: z.number().finite().positive().max(MAX_BUDGET_USD),
     maxTurns: z.number().int().min(1).max(100),
+    maxDelegationsPerRun: z.number().int().min(1).max(MAX_DELEGATIONS_PER_RUN),
+    parallelDelegations: z.boolean(),
     schedule: z.string().trim().min(1).max(256),
     timezone: z.string().trim().min(1).max(128),
     scheduleEnabled: z.boolean(),
@@ -85,6 +93,8 @@ const CreateAgentSchema = z
     model: agentFields.model,
     budgetUsd: agentFields.budgetUsd,
     maxTurns: agentFields.maxTurns.optional(),
+    maxDelegationsPerRun: agentFields.maxDelegationsPerRun.optional(),
+    parallelDelegations: agentFields.parallelDelegations.optional(),
     schedule: agentFields.schedule.optional(),
     timezone: agentFields.timezone.optional(),
     scheduleEnabled: agentFields.scheduleEnabled.optional(),
@@ -139,6 +149,8 @@ const UpdateAgentSchema = z
     model: agentFields.model.optional(),
     budgetUsd: agentFields.budgetUsd.optional(),
     maxTurns: agentFields.maxTurns.optional(),
+    maxDelegationsPerRun: agentFields.maxDelegationsPerRun.optional(),
+    parallelDelegations: agentFields.parallelDelegations.optional(),
     schedule: agentFields.schedule.nullable().optional(),
     timezone: agentFields.timezone.optional(),
     scheduleEnabled: agentFields.scheduleEnabled.optional(),
@@ -160,6 +172,13 @@ const REPOSITORY_ADMIN_OVERRIDE = {
     type: "boolean",
     description: "Admins only (agents:admin with the admin role): approve codingProfile.repository without checking GitHub access, recorded as an admin approval. On an agent the admin doesn't own, only codingProfile.repository may change.",
 };
+/** A `local:` repository is stored as its canonical (realpath) name, and refused outside the trusted roots. */
+async function withCanonicalRepository(args) {
+    const repository = args.codingProfile?.repository;
+    if (repository === undefined || !isLocalRepository(repository))
+        return args;
+    return { ...args, codingProfile: { ...args.codingProfile, repository: await canonicalLocalRepository(repository) } };
+}
 /** The profile columns a repository authorization is stamped into. */
 function profileStamp(authorization) {
     return {
@@ -175,7 +194,7 @@ const profileJsonSchema = {
         provider: { type: "string", enum: ["codex", "claude-code"] },
         repository: {
             type: "string",
-            description: "owner/name on GitHub. Your linked GitHub account (link_host_account) must have write access to it, unless a wardby admin approves it (repositoryAdminOverride). Re-checked on every run.",
+            description: "owner/name on GitHub, or local:/absolute/path for a git folder inside the server's LOCAL_REPO_ROOTS (stored by its real path; no GitHub access needed). For GitHub, your linked GitHub account (link_host_account) must have write access to it, unless a wardby admin approves it (repositoryAdminOverride). Re-checked on every run.",
         },
         baseRef: { type: "string" },
         defaultTask: { type: ["string", "null"] },
@@ -198,6 +217,12 @@ const profileJsonSchema = {
             maximum: 32768,
             description: "Workspace disk size in MiB. Null uses the deployment default (CODING_DISK_MB), capped by the operator's CODING_MAX_DISK_MB.",
         },
+        maxTurns: {
+            type: ["integer", "null"],
+            minimum: 1,
+            maximum: MAX_CODING_TURNS,
+            description: `Claude Code runs only: the most agent turns (model calls) a run may take before it stops with coding_turn_limit. Null uses the worker default (${DEFAULT_CLAUDE_MAX_TURNS}). The run's budget and timeout still apply. Codex runs have no turn limit.`,
+        },
         packageAllowlist: {
             type: "object",
             description: "Approved top-level packages per ecosystem (npm, pypi). Needs packages:approve or agents:admin.",
@@ -293,6 +318,7 @@ function storedProfile(profile) {
         toolchainVersion: profile.toolchainVersion,
         workerImageRef: profile.workerImageRef,
         workspaceDiskMb: profile.workspaceDiskMb,
+        maxTurns: profile.maxTurns,
         packageAllowlist: profile.packageAllowlist,
         packagePolicy: profile.packagePolicy,
         services: profile.services,
@@ -321,6 +347,14 @@ export function registerAgentTools(mcp) {
                 model: { type: "string" },
                 budgetUsd: { type: "number" },
                 maxTurns: { type: "integer" },
+                maxDelegationsPerRun: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: MAX_DELEGATIONS_PER_RUN,
+                    description: "Native agents with sub-agents: how many delegate_to_* calls one run may make, each to a different sub-agent " +
+                        "(one after another, or together with parallelDelegations). Default 1: route to exactly one.",
+                },
+                parallelDelegations: { type: "boolean", description: PARALLEL_DELEGATIONS_DESCRIPTION },
                 schedule: { type: "string" },
                 timezone: { type: "string" },
                 scheduleEnabled: { type: "boolean" },
@@ -340,7 +374,7 @@ export function registerAgentTools(mcp) {
             required: ["name", "systemPrompt", "model", "budgetUsd"],
         },
         handler: async (rawArgs, ctx) => {
-            const args = parseCreateAgent(rawArgs);
+            const args = await withCanonicalRepository(parseCreateAgent(rawArgs));
             if (args.codingProfile?.workerImageRef != null)
                 requireWorkerImageRefScope(ctx);
             const packages = args.codingProfile;
@@ -396,6 +430,14 @@ export function registerAgentTools(mcp) {
                 model: { type: "string" },
                 budgetUsd: { type: "number" },
                 maxTurns: { type: "integer" },
+                maxDelegationsPerRun: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: MAX_DELEGATIONS_PER_RUN,
+                    description: "Native agents with sub-agents: how many delegate_to_* calls one run may make, each to a different sub-agent " +
+                        "(one after another, or together with parallelDelegations). Default 1: route to exactly one.",
+                },
+                parallelDelegations: { type: "boolean", description: PARALLEL_DELEGATIONS_DESCRIPTION },
                 schedule: { type: ["string", "null"] },
                 timezone: { type: "string" },
                 scheduleEnabled: { type: "boolean" },
@@ -435,7 +477,7 @@ export function registerAgentTools(mcp) {
             required: ["id"],
         },
         handler: async (rawArgs, ctx) => {
-            const args = parseUpdateAgent(rawArgs);
+            const args = await withCanonicalRepository(parseUpdateAgent(rawArgs));
             if (args.codingProfile?.workerImageRef !== undefined)
                 requireWorkerImageRefScope(ctx);
             const debugTraceMinutes = args.codingProfile?.debugTraceMinutes;

package/dist/mcp/tools/host-accounts.js

@@ -6,12 +6,12 @@
  * the caller; an operator can list and unlink anyone's with
  * `wardby auth host-account`.
  */
-import { REVIEW_HOST_PROVIDERS } from "../../providers/review-host/types.js";
+import { HOST_ACCOUNT_PROVIDERS } from "../../providers/review-host/types.js";
 import { confirmHostIdentityLink, HostLinkError, startHostIdentityLink, userCallbackPath, } from "../../core/host-identity-links.js";
 import { McpError } from "../errors.js";
 import { canonicalUrl } from "../transport/http-limits.js";
 import { textResult } from "./text-result.js";
-const PROVIDER_PROP = { type: "string", enum: [...REVIEW_HOST_PROVIDERS] };
+const PROVIDER_PROP = { type: "string", enum: [...HOST_ACCOUNT_PROVIDERS] };
 function asMcpError(err) {
     return err instanceof HostLinkError ? new McpError(err.status, err.message) : err;
 }

package/dist/mcp/tools/repositories.js

@@ -12,17 +12,19 @@
  * See docs/private/2026-09-26-repo-access-authorization-spec-and-plan.md.
  */
 import { Prisma } from "#prisma";
-import { normalizeGitHubRepository } from "../../coding/protocol.js";
+import { isLocalRepository, normalizeGitHubRepository, normalizeLocalRepository } from "../../coding/protocol.js";
 import { requireAgentAccess, requireBindingOwner } from "../auth/access.js";
-import { authorizeRepositoryForSet } from "../auth/repo-authorization.js";
+import { authorizeRepositoryForSet, canonicalLocalRepository } from "../auth/repo-authorization.js";
 import { requireScope } from "../auth/resource-server.js";
 import { McpError } from "../errors.js";
 import { textResult } from "./text-result.js";
-const PROVIDERS = ["github"];
-const TRIGGERS = ["pull_request", "mention", "push"];
+const PROVIDERS = ["github", "local"];
+const TRIGGERS = ["pull_request", "mention", "push", "review_fix"];
 const CHECK_NAME = /^[A-Za-z0-9][A-Za-z0-9 ._/()-]{0,99}$/;
 function normalizeRepository(provider, repository) {
     try {
+        if (provider === "local")
+            return normalizeLocalRepository(repository);
         if (provider === "github")
             return normalizeGitHubRepository(repository);
     }
@@ -40,6 +42,9 @@ async function assertNoConflicts(tx, args) {
     if (args.triggers.includes("mention") && others.some((o) => o.triggers.includes("mention"))) {
         throw new McpError(409, `Another agent already handles @-mentions on ${args.repository}.`);
     }
+    if (args.triggers.includes("review_fix") && others.some((o) => o.triggers.includes("review_fix"))) {
+        throw new McpError(409, `Another agent already handles automatic review fixes on ${args.repository}.`);
+    }
     // Against every other link, whatever its triggers: a check name identifies
     // one agent's verdict on the repository (also a unique index).
     if (args.checkName !== null && others.some((o) => o.checkName === args.checkName)) {
@@ -54,11 +59,18 @@ export function registerRepositoryTools(mcp) {
         name: "link_repository",
         scope: "agents:write",
         description: "Links a native agent you own to a repository on a code-review host, with its access, event triggers, and checkName. " +
-            "Triggers: pull_request (review each PR push), mention (answer @mentions), push (start on merges to the default branch). " +
+            "Triggers: pull_request (review each PR push), mention (answer @mentions), push (start on merges to the default branch), " +
+            "review_fix (automatic review fix rounds). The review_fix trigger makes this agent the one wardby starts, automatically " +
+            "and without a human comment, when wardby's own review check requests changes on a pull request a wardby coding run " +
+            "opened (capped by reviewFixMaxRounds, default 2). " +
             "Your linked GitHub account (link_host_account) must have write access to the repository for a write link, or read for a " +
             "read link; a wardby admin may instead approve it with adminOverride. checkName is only allowed (and required) with the " +
-            "pull_request trigger, and is unique per repository. Re-linking an already-linked repository replaces its access, " +
-            "triggers, and checkName (an omitted field is cleared, not kept) and re-checks access — always send the full desired state.",
+            "pull_request trigger, and is unique per repository. waitForCi (only with the pull_request trigger) holds this agent's " +
+            "review on a pushed head until that head's own CI finishes, instead of racing it; APPROVE is refused while CI on the " +
+            "head is failing or still running. Re-linking an already-linked repository replaces its access, triggers, checkName, " +
+            "reviewFixMaxRounds, and waitForCi (an omitted field is cleared, not kept) and re-checks access — always send the full " +
+            "desired state. A local repository (local:/abs/path, inside the server's trusted roots) takes no triggers or checkName: " +
+            "it supports manual reviews only (trigger_agent with review).",
         inputSchema: {
             type: "object",
             additionalProperties: false,
@@ -69,6 +81,17 @@ export function registerRepositoryTools(mcp) {
                 access: { type: "string", enum: ["read", "write"] },
                 triggers: { type: "array", items: { type: "string", enum: [...TRIGGERS] }, uniqueItems: true },
                 checkName: { type: "string", minLength: 1, maxLength: 100 },
+                reviewFixMaxRounds: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: 10,
+                    description: "Only with the review_fix trigger: automatic fix rounds per pull request before wardby stops (default 2).",
+                },
+                waitForCi: {
+                    type: "boolean",
+                    description: "Only with the pull_request trigger: hold this agent's review on a pushed head until that head's own CI " +
+                        "finishes, instead of racing it (default false).",
+                },
                 adminOverride: {
                     type: "boolean",
                     description: "Admins only (agents:admin with the admin role): approve this link without checking GitHub access, recorded as an admin approval. Allowed on any agent that has an owner, not only the admin's own.",
@@ -94,9 +117,20 @@ export function registerRepositoryTools(mcp) {
             if (agent.kind !== "native") {
                 throw new McpError(400, "Repository links are for native agents only; coding agents use codingProfile.repository.");
             }
-            const provider = args.provider ?? "github";
-            const repository = normalizeRepository(provider, args.repository);
+            const provider = args.provider ?? (isLocalRepository(args.repository) ? "local" : "github");
+            if ((provider === "local") !== isLocalRepository(args.repository)) {
+                throw new McpError(400, `invalid repository "${args.repository}" for provider ${provider}`);
+            }
+            const repository = provider === "local"
+                ? await canonicalLocalRepository(args.repository)
+                : normalizeRepository(provider, args.repository);
             const triggers = [...new Set(args.triggers ?? [])];
+            if (provider === "local") {
+                if (triggers.length > 0)
+                    throw new McpError(400, "local repositories support manual review only");
+                // A check is only published for a dispatched host PR; a local link has none.
+                args = { ...args, checkName: undefined };
+            }
             if (triggers.length > 0 && args.access !== "write")
                 throw new McpError(400, "Event triggers need write access.");
             const checkName = args.checkName ?? null;
@@ -108,6 +142,18 @@ export function registerRepositoryTools(mcp) {
             }
             if (checkName !== null && !CHECK_NAME.test(checkName))
                 throw new McpError(400, "invalid checkName");
+            const reviewFixMaxRounds = args.reviewFixMaxRounds ?? null;
+            if (reviewFixMaxRounds !== null && !triggers.includes("review_fix")) {
+                throw new McpError(400, "reviewFixMaxRounds needs the review_fix trigger.");
+            }
+            if (reviewFixMaxRounds !== null &&
+                (!Number.isInteger(reviewFixMaxRounds) || reviewFixMaxRounds < 1 || reviewFixMaxRounds > 10)) {
+                throw new McpError(400, "reviewFixMaxRounds must be an integer from 1 to 10.");
+            }
+            const waitForCi = args.waitForCi ?? false;
+            if (waitForCi && !triggers.includes("pull_request")) {
+                throw new McpError(400, "waitForCi needs the pull_request trigger.");
+            }
             // The host call happens before, and outside, the serializable transaction.
             const authorization = await authorizeRepositoryForSet(ctx, {
                 ownerId: agent.ownerId,
@@ -120,7 +166,14 @@ export function registerRepositoryTools(mcp) {
             try {
                 link = await ctx.db.$transaction(async (tx) => {
                     await assertNoConflicts(tx, { agentId: args.agentId, provider, repository, triggers, checkName });
-                    const fields = { access: args.access, triggers, checkName, ...authorization };
+                    const fields = {
+                        access: args.access,
+                        triggers,
+                        checkName,
+                        reviewFixMaxRounds,
+                        waitForCi,
+                        ...authorization,
+                    };
                     return tx.agentRepository.upsert({
                         where: { agentId_provider_repository: { agentId: args.agentId, provider, repository } },
                         create: { agentId: args.agentId, provider, repository, ...fields },
@@ -153,8 +206,14 @@ export function registerRepositoryTools(mcp) {
         handler: async (args, ctx) => {
             const { agent } = await requireAgentAccess(ctx, args.agentId, "read");
             requireBindingOwner(ctx, agent);
-            const provider = args.provider ?? "github";
-            const repository = normalizeRepository(provider, args.repository);
+            const provider = args.provider ?? (isLocalRepository(args.repository) ? "local" : "github");
+            let repository;
+            if (provider === "local") {
+                // The roots may have narrowed since linking; a link must stay removable.
+                repository = await canonicalLocalRepository(args.repository).catch(() => normalizeRepository(provider, args.repository));
+            }
+            else
+                repository = normalizeRepository(provider, args.repository);
             const { count } = await ctx.db.agentRepository.deleteMany({
                 where: { agentId: args.agentId, provider, repository },
             });

package/dist/mcp/tools/runs.js

@@ -71,8 +71,14 @@ export function registerRunTools(mcp) {
                     diagnosticId: true,
                     debugTrace: true,
                     services: true,
+                    resultBranch: true,
+                    baseSha: true,
                 },
             });
+            const localPr = await ctx.db.localPullRequest.findUnique({
+                where: { runId: run.id },
+                include: { reviews: { orderBy: { createdAt: "asc" } } },
+            });
             const codingResult = publicCodingRunResult(codingRun?.result);
             // A pending coding run with queuedAt is waiting for a concurrency slot
             // (CODING_MAX_CONCURRENT), not stuck.
@@ -108,6 +114,23 @@ export function registerRunTools(mcp) {
                 // An admin turned on the debug trace: the worker's full trace is in its pod log.
                 ...(codingRun?.debugTrace ? { debugTrace: true } : {}),
                 ...(services.length > 0 ? { services } : {}),
+                ...(codingRun?.resultBranch ? { resultBranch: codingRun.resultBranch } : {}),
+                ...(codingRun?.baseSha ? { baseSha: codingRun.baseSha } : {}),
+                ...(localPr
+                    ? {
+                        review: {
+                            number: localPr.number,
+                            branch: localPr.branch,
+                            base: localPr.base,
+                            reviews: localPr.reviews.map((r) => ({
+                                verdict: r.verdict,
+                                summary: r.summary,
+                                body: r.body,
+                                comments: r.comments,
+                            })),
+                        },
+                    }
+                    : {}),
                 ...(codingRun ? { packages, packageRefusals, packagePlan } : {}),
             });
         },