@wardby/cli 0.3.0 → 0.4.1

package/dist/mcp/tools/agents.js

@@ -9,8 +9,12 @@ import { Prisma } from "#prisma";
 import { z } from "zod";
 import { CodingProfilePatchSchema, CodingProfileSchema } from "../../coding/profile.js";
 import { codingProviderSupportsModel } from "../../coding/provider.js";
+import { assertAgentModelAvailable } from "../../core/run-pricing.js";
+import { ModelUnavailableError } from "../../providers/llm/catalog-types.js";
+import { currentModelCatalog } from "../../providers/llm/catalog-store.js";
 import { validateCronExpression } from "../../core/cron.js";
 import { modelSupportedEfforts } from "../../providers/llm/routing.js";
+import { PROJECT_KEY } from "../../providers/issue-tracker/types.js";
 import { LLM_EFFORT_LEVELS, isLlmEffort } from "../../providers/llm/types.js";
 import { requireReadableBudgetGroup } from "../auth/ownership.js";
 import { agentAccessResolver, agentNotFound, assertAgentAccess, readableAgentsWhere, requireAgentAccess, } from "../auth/access.js";
@@ -57,7 +61,23 @@ const agentFields = {
     budgetGroupId: z.string().min(1).max(128),
     memoryEnabled: z.boolean(),
     effort: z.enum(LLM_EFFORT_LEVELS),
+    defectProjectKey: z.string().regex(PROJECT_KEY, "must be an upper-case Jira project key"),
+    defectIssueType: z.string().trim().min(1).max(100),
 };
+/** Self-defect config is both-or-neither; on update, both null clears it. */
+function refineDefectPair(value, ctx) {
+    const key = value.defectProjectKey;
+    const type = value.defectIssueType;
+    if ((key === undefined) !== (type === undefined) || (key === null) !== (type === null)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["defectProjectKey"],
+            message: "defectProjectKey and defectIssueType must be set together (or both null to clear on update)",
+        });
+    }
+}
+const DEFECT_DESCRIPTION = "Self-defects (optional, both or neither with defectIssueType): the Jira project key wardby files this agent's own failures into. " +
+    "Filing needs a write link (link_issue_project) to that project whose creatableIssueTypes includes defectIssueType; it is checked at filing time and fails closed.";
 const CreateAgentSchema = z
     .object({
     name: agentFields.name,
@@ -72,11 +92,14 @@ const CreateAgentSchema = z
     budgetGroupId: agentFields.budgetGroupId.optional(),
     memoryEnabled: agentFields.memoryEnabled.default(false),
     effort: agentFields.effort.optional(),
+    defectProjectKey: agentFields.defectProjectKey.optional(),
+    defectIssueType: agentFields.defectIssueType.optional(),
     codingProfile: CodingProfileSchema.optional(),
     repositoryAdminOverride: z.boolean().optional(),
 })
     .strict()
     .superRefine((value, ctx) => {
+    refineDefectPair(value, ctx);
     if (value.kind === "coding" && !value.codingProfile) {
         ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["codingProfile"], message: "is required for coding agents" });
     }
@@ -87,8 +110,11 @@ const CreateAgentSchema = z
             message: "is only valid for coding agents",
         });
     }
+    // A model the catalog doesn't offer is left to the handler, which reports
+    // model_unavailable with its reason instead of a provider mismatch.
     if (value.kind === "coding" &&
         value.codingProfile &&
+        currentModelCatalog().get(value.model) !== undefined &&
         !codingProviderSupportsModel(value.codingProfile.provider, value.model)) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
@@ -120,13 +146,16 @@ const UpdateAgentSchema = z
     budgetGroupId: agentFields.budgetGroupId.nullable().optional(),
     memoryEnabled: agentFields.memoryEnabled.optional(),
     effort: agentFields.effort.nullable().optional(),
+    defectProjectKey: agentFields.defectProjectKey.nullable().optional(),
+    defectIssueType: agentFields.defectIssueType.nullable().optional(),
     codingProfile: CodingProfilePatchSchema.extend({
         /** Not a stored profile field: sets CodingAgentProfile.debugTraceUntil = now + minutes (null clears). */
         debugTraceMinutes: z.number().int().min(1).max(MAX_DEBUG_TRACE_MINUTES).nullable().optional(),
     }).optional(),
     repositoryAdminOverride: z.boolean().optional(),
 })
-    .strict();
+    .strict()
+    .superRefine(refineDefectPair);
 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.",
@@ -231,6 +260,25 @@ function validateEffort(kind, model, effort) {
                 : "It accepts no effort setting; leave effort unset (or null)."));
     }
 }
+/**
+ * A model being set (create, or update with `model`) must be runnable here:
+ * in the catalog and enabled; for a native agent, its provider must also be
+ * configured on the native router. A coding agent is checked against the
+ * catalog only: its runs go through the coding proxy, whose credentials
+ * (CODING_*_CREDENTIAL_REF) are not the native router's. An existing agent's
+ * unchanged model is not re-checked: if an admin later disabled it, the agent
+ * fails at its next run, not at an unrelated edit.
+ */
+function requireModelAvailable(ctx, model, kind) {
+    try {
+        assertAgentModelAvailable(model, kind === "native" ? ctx.providers.llm : undefined);
+    }
+    catch (err) {
+        if (err instanceof ModelUnavailableError)
+            throw new McpError(400, err.message);
+        throw err;
+    }
+}
 function storedProfile(profile) {
     return CodingProfileSchema.parse({
         provider: profile.provider,
@@ -284,6 +332,8 @@ export function registerAgentTools(mcp) {
                     enum: [...LLM_EFFORT_LEVELS],
                     description: "Reasoning effort for native agents. Unset uses the provider default.",
                 },
+                defectProjectKey: { type: "string", pattern: PROJECT_KEY.source, description: DEFECT_DESCRIPTION },
+                defectIssueType: { type: "string", minLength: 1, maxLength: 100, description: DEFECT_DESCRIPTION },
                 codingProfile: { ...profileJsonSchema, required: ["repository"] },
                 repositoryAdminOverride: REPOSITORY_ADMIN_OVERRIDE,
             },
@@ -299,6 +349,7 @@ export function registerAgentTools(mcp) {
                     Object.keys(packages.packagePolicy ?? {}).length > 0))
                 requirePackageApproval(ctx);
             validateSchedule(args.schedule, args.timezone ?? "UTC");
+            requireModelAvailable(ctx, args.model, args.kind);
             validateEffort(args.kind, args.model, args.effort);
             if (args.codingProfile)
                 await requireCatalogServiceNames(ctx.db, args.codingProfile.services);
@@ -356,6 +407,17 @@ export function registerAgentTools(mcp) {
                     enum: [...LLM_EFFORT_LEVELS, null],
                     description: "Reasoning effort for native agents. Null clears it back to the provider default.",
                 },
+                defectProjectKey: {
+                    type: ["string", "null"],
+                    pattern: PROJECT_KEY.source,
+                    description: `${DEFECT_DESCRIPTION} Null (together with defectIssueType) clears it.`,
+                },
+                defectIssueType: {
+                    type: ["string", "null"],
+                    minLength: 1,
+                    maxLength: 100,
+                    description: `${DEFECT_DESCRIPTION} Null (together with defectProjectKey) clears it.`,
+                },
                 codingProfile: {
                     ...profileJsonSchema,
                     properties: {
@@ -474,7 +536,13 @@ export function registerAgentTools(mcp) {
                 if (nextKind === "native" && args.codingProfile) {
                     throw new McpError(400, "A coding profile is only valid for coding agents.");
                 }
-                validateEffort(nextKind, args.model ?? existing.model, args.effort !== undefined ? args.effort : existing.effort);
+                if (args.model !== undefined)
+                    requireModelAvailable(ctx, args.model, nextKind);
+                // Only re-checked when the model, effort or kind changes: an agent whose
+                // model was since disabled can still take unrelated edits.
+                if (args.model !== undefined || args.effort !== undefined || nextKind !== existing.kind) {
+                    validateEffort(nextKind, args.model ?? existing.model, args.effort !== undefined ? args.effort : existing.effort);
+                }
                 let nextProfile = null;
                 if (nextKind === "coding") {
                     const attachedTools = await tx.agentTool.count({ where: { agentId: args.id } });
@@ -490,7 +558,10 @@ export function registerAgentTools(mcp) {
                     if (args.codingProfile?.services !== undefined)
                         await requireCatalogServiceNames(tx, nextProfile.services);
                     const nextModel = args.model ?? existing.model;
-                    if (!codingProviderSupportsModel(nextProfile.provider, nextModel)) {
+                    const pairingChanges = args.model !== undefined ||
+                        existing.kind !== "coding" ||
+                        existing.codingProfile?.provider !== nextProfile.provider;
+                    if (pairingChanges && !codingProviderSupportsModel(nextProfile.provider, nextModel)) {
                         throw new McpError(400, `Model "${nextModel}" is not supported by coding provider "${nextProfile.provider}".`);
                     }
                 }

package/dist/mcp/tools/cost-report.d.ts

@@ -0,0 +1,8 @@
+import type { WardbyMcpServer } from "../server.js";
+/**
+ * Cost rolled up by issue, parent (epic, as of each run's dispatch), scope
+ * (project/team), agent, model, or run. Same visibility as list_runs/get_run:
+ * the agents the caller owns (Agent.ownerId), plus runs the caller
+ * triggered. USD only; tokens by priced kind.
+ */
+export declare function registerCostReportTools(mcp: WardbyMcpServer): void;

package/dist/mcp/tools/cost-report.js

@@ -0,0 +1,60 @@
+import { McpError } from "../errors.js";
+import { agentAccessResolver, readableAgentsWhere } from "../auth/access.js";
+import { costReport, CostReportInputError, parseCostReportQuery } from "../../core/cost-report.js";
+import { textResult } from "./text-result.js";
+/**
+ * Cost rolled up by issue, parent (epic, as of each run's dispatch), scope
+ * (project/team), agent, model, or run. Same visibility as list_runs/get_run:
+ * the agents the caller owns (Agent.ownerId), plus runs the caller
+ * triggered. USD only; tokens by priced kind.
+ */
+export function registerCostReportTools(mcp) {
+    mcp.registerTool({
+        name: "cost_report",
+        scope: "agents:read",
+        description: "Agent spend (USD) and tokens by kind, grouped by issue, parent (epic), scope (project/team), agent, model, or run, " +
+            "over a time window (default: last 30 days). Combine filters with groupBy to drill down, e.g. groupBy=issue with parentKey. " +
+            "Totals always sum each run's full cost over attributed runs, whatever the grouping; with groupBy=model, rows come from " +
+            "per-model usage and can add up to less than the total when some runs have no per-model record. " +
+            "`unattributed` covers visible runs in the window that have no issue; only agentId narrows it " +
+            "(provider/scope/parent/issue filters do not).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                groupBy: { type: "string", enum: ["issue", "parent", "scope", "agent", "model", "run"] },
+                from: { type: "string", description: "ISO date (inclusive)" },
+                to: { type: "string", description: "ISO date (exclusive)" },
+                provider: { type: "string" },
+                scopeKey: { type: "string" },
+                parentKey: { type: "string" },
+                issueKey: { type: "string" },
+                agentId: { type: "string" },
+                limit: { type: "number" },
+            },
+        },
+        handler: async (args, ctx) => {
+            let query;
+            try {
+                query = parseCostReportQuery(args);
+            }
+            catch (err) {
+                if (err instanceof CostReportInputError)
+                    throw new McpError(400, err.message);
+                throw err;
+            }
+            let visibility = null;
+            if (!ctx.operator) {
+                const resolve = await agentAccessResolver(ctx);
+                const agents = await ctx.db.agent.findMany({
+                    where: await readableAgentsWhere(ctx),
+                    select: { id: true, ownerId: true },
+                });
+                visibility = {
+                    ownedAgentIds: agents.filter((a) => resolve(a) === "owner").map((a) => a.id),
+                    principalId: ctx.principal.id,
+                };
+            }
+            return textResult(await costReport(ctx.db, query, visibility));
+        },
+    });
+}

package/dist/mcp/tools/issue-projects.d.ts

@@ -0,0 +1,2 @@
+import type { WardbyMcpServer } from "../server.js";
+export declare function registerIssueProjectTools(mcp: WardbyMcpServer): void;

package/dist/mcp/tools/issue-projects.js

@@ -0,0 +1,238 @@
+/**
+ * AgentIssueProject CRUD — which Jira projects a native agent may act on,
+ * and which issue events trigger it. Linking is admin-approved: wardby cannot
+ * verify an agent owner's own Jira access (the integration is one service
+ * account, no per-user OAuth), so link/unlink need agents:admin with the
+ * admin role, and the approver is stamped on the link. Triggers that carry
+ * text from a person (mention/assigned) are gated by trustedAccountIds.
+ * See docs/private/2026-09-30-jira-issue-tracker-design.md.
+ */
+import { requireAgentAccess } from "../auth/access.js";
+import { requireScope } from "../auth/resource-server.js";
+import { McpError } from "../errors.js";
+import { ISSUE_TRACKER_PROVIDERS, PROJECT_KEY } from "../../providers/issue-tracker/types.js";
+import { textResult } from "./text-result.js";
+const PROVIDERS = [...ISSUE_TRACKER_PROVIDERS];
+const TRIGGERS = ["created", "transitioned", "labeled", "assigned", "mention"];
+const ACCOUNT_ID = /^[A-Za-z0-9:_-]{1,128}$/;
+const WRITABLE_FIELD = /^(labels|components|priority|customfield_\d{1,10})$/;
+/** Trimmed names, 1-100 characters each, de-duplicated case-insensitively (first spelling kept). */
+function nameList(field, raw) {
+    const seen = new Set();
+    const names = [];
+    for (const entry of raw ?? []) {
+        const name = entry.trim();
+        if (name.length === 0 || name.length > 100)
+            throw new McpError(400, `invalid ${field} entry (1-100 characters)`);
+        if (!seen.has(name.toLowerCase())) {
+            seen.add(name.toLowerCase());
+            names.push(name);
+        }
+    }
+    return names;
+}
+/** An optional single status name, trimmed, 1-100 characters; undefined/absent means none. */
+function optionalStatus(field, raw) {
+    if (raw === undefined)
+        return null;
+    const name = raw.trim();
+    if (name.length === 0 || name.length > 100)
+        throw new McpError(400, `invalid ${field} (1-100 characters)`);
+    return name;
+}
+function normalizeProjectKey(projectKey) {
+    const key = projectKey.trim().toUpperCase();
+    if (!PROJECT_KEY.test(key))
+        throw new McpError(400, `invalid projectKey "${projectKey}"`);
+    return key;
+}
+export function registerIssueProjectTools(mcp) {
+    mcp.registerTool({
+        name: "link_issue_project",
+        scope: "agents:write",
+        description: "Links a native agent to a Jira project, with its access and issue-event triggers. A wardby admin approves Jira links " +
+            "(agents:admin with the admin role); the agent acts as the deployment's Jira service account, not as any person. " +
+            "triggers (write access only): created, transitioned (needs triggerStatuses), labeled (needs triggerLabels), assigned and " +
+            "mention (each needs trustedAccountIds). trustedAccountIds are Jira accountIds (from a Jira profile URL or jira_get_issue " +
+            "output) whose mentions/assignments may trigger the agent; triggered text from anyone else is treated as untrusted. " +
+            "jqlFilter optionally narrows which issues trigger; commentVisibilityRole restricts the agent's comments to a project role. " +
+            "Re-linking a project replaces its access, triggers, and filters (an omitted field is cleared, not kept) — always send " +
+            "the full desired state. " +
+            "allowedTransitions (write access only): the target status names jira_transition may move issues to (matched by target " +
+            "status name, case-insensitive). writableFields (write access only): the field ids jira_update_fields may change " +
+            "(labels, components, priority, or customfield_NNNNN). Both allowlists fail closed: empty or omitted means the agent " +
+            "cannot transition issues or edit fields at all. " +
+            'allowedLinkTypes (write access only): the issue link type names jira_link_issues may create (e.g. "Duplicate", ' +
+            "case-insensitive, at most 20); linking also needs write access to both issues' projects, each allowlisting the type. " +
+            "It fails closed too: empty or omitted means the agent cannot link issues. Issue properties (jira_set_property) are " +
+            "not allowlisted: any write link may set them. " +
+            "onPullRequestOpened / onPullRequestMerged (write access only, optional): the status name to move the issue to when a " +
+            "pull request wardby opened for it opens or merges. These are control-plane moves, not model actions, and are not gated " +
+            "by allowedTransitions; the name is matched in the Jira service account's language, and omitting one means no move. " +
+            "creatableIssueTypes (write access only): the issue type names (case-insensitive, at most 20) the agent may create issues " +
+            "of in this project; it fails closed too: empty or omitted means the agent cannot create issues here. " +
+            "maxNewIssuesPerRun (write access only, optional integer 1-1000): the most issues one run may create in this project; " +
+            "omitted means no cap. The cap is best-effort across resumed or concurrent attempts of the same run.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                agentId: { type: "string" },
+                provider: { type: "string", enum: PROVIDERS },
+                projectKey: { type: "string", minLength: 1, maxLength: 255 },
+                access: { type: "string", enum: ["read", "write"] },
+                triggers: { type: "array", items: { type: "string", enum: [...TRIGGERS] }, uniqueItems: true },
+                triggerStatuses: { type: "array", items: { type: "string", minLength: 1, maxLength: 100 }, maxItems: 50 },
+                triggerLabels: { type: "array", items: { type: "string", minLength: 1, maxLength: 255 }, maxItems: 50 },
+                jqlFilter: { type: "string", minLength: 1, maxLength: 1000 },
+                trustedAccountIds: {
+                    type: "array",
+                    items: { type: "string", pattern: ACCOUNT_ID.source },
+                    maxItems: 50,
+                },
+                commentVisibilityRole: { type: "string", minLength: 1, maxLength: 100 },
+                allowedTransitions: { type: "array", items: { type: "string", minLength: 1, maxLength: 100 }, maxItems: 50 },
+                writableFields: { type: "array", items: { type: "string", pattern: WRITABLE_FIELD.source }, maxItems: 50 },
+                allowedLinkTypes: { type: "array", items: { type: "string", minLength: 1, maxLength: 100 }, maxItems: 20 },
+                onPullRequestOpened: { type: "string", minLength: 1, maxLength: 100 },
+                onPullRequestMerged: { type: "string", minLength: 1, maxLength: 100 },
+                creatableIssueTypes: { type: "array", items: { type: "string", minLength: 1, maxLength: 100 }, maxItems: 20 },
+                maxNewIssuesPerRun: { type: "integer", minimum: 1, maximum: 1000 },
+            },
+            required: ["agentId", "projectKey", "access"],
+        },
+        handler: async (args, ctx) => {
+            requireScope(ctx, ctx.canonicalUri, "agents:admin");
+            const agent = await ctx.db.agent.findUnique({ where: { id: args.agentId } });
+            if (!agent)
+                throw new McpError(404, `Agent "${args.agentId}" not found.`);
+            if (agent.kind !== "native")
+                throw new McpError(400, "Issue-project links are for native agents only.");
+            if (agent.ownerId === null) {
+                throw new McpError(400, `Agent "${agent.id}" has no owner; assign one with make_owner before linking.`);
+            }
+            const provider = args.provider ?? "jira";
+            const projectKey = normalizeProjectKey(args.projectKey);
+            const triggers = [...new Set(args.triggers ?? [])];
+            const triggerStatuses = args.triggerStatuses ?? [];
+            const triggerLabels = args.triggerLabels ?? [];
+            const trustedAccountIds = [...new Set(args.trustedAccountIds ?? [])];
+            if (trustedAccountIds.some((id) => !ACCOUNT_ID.test(id))) {
+                throw new McpError(400, "invalid trustedAccountIds entry (letters, digits, ':', '_', '-'; up to 128 characters)");
+            }
+            const allowedTransitions = nameList("allowedTransitions", args.allowedTransitions);
+            const allowedLinkTypes = nameList("allowedLinkTypes", args.allowedLinkTypes);
+            if (allowedLinkTypes.length > 20)
+                throw new McpError(400, "allowedLinkTypes takes at most 20 entries");
+            const creatableIssueTypes = nameList("creatableIssueTypes", args.creatableIssueTypes);
+            if (creatableIssueTypes.length > 20)
+                throw new McpError(400, "creatableIssueTypes takes at most 20 entries");
+            const maxNewIssuesPerRun = args.maxNewIssuesPerRun ?? null;
+            if (maxNewIssuesPerRun !== null &&
+                (!Number.isInteger(maxNewIssuesPerRun) || maxNewIssuesPerRun < 1 || maxNewIssuesPerRun > 1000)) {
+                throw new McpError(400, "maxNewIssuesPerRun must be an integer from 1 to 1000");
+            }
+            if ((creatableIssueTypes.length > 0 || maxNewIssuesPerRun !== null) && args.access !== "write") {
+                throw new McpError(400, "creatableIssueTypes and maxNewIssuesPerRun need write access.");
+            }
+            const writableFields = [...new Set(args.writableFields ?? [])];
+            if (writableFields.some((f) => !WRITABLE_FIELD.test(f))) {
+                throw new McpError(400, "invalid writableFields entry (labels, components, priority, or customfield_NNNNN)");
+            }
+            const onPullRequestOpened = optionalStatus("onPullRequestOpened", args.onPullRequestOpened);
+            const onPullRequestMerged = optionalStatus("onPullRequestMerged", args.onPullRequestMerged);
+            if ((onPullRequestOpened !== null || onPullRequestMerged !== null) && args.access !== "write") {
+                throw new McpError(400, "onPullRequestOpened and onPullRequestMerged need write access.");
+            }
+            if ((allowedTransitions.length > 0 || writableFields.length > 0 || allowedLinkTypes.length > 0) &&
+                args.access !== "write") {
+                throw new McpError(400, "allowedTransitions, writableFields, and allowedLinkTypes need write access.");
+            }
+            if (triggers.length > 0 && args.access !== "write")
+                throw new McpError(400, "Event triggers need write access.");
+            if (triggers.includes("transitioned") && triggerStatuses.length === 0) {
+                throw new McpError(400, "The transitioned trigger needs a non-empty triggerStatuses.");
+            }
+            if (triggers.includes("labeled") && triggerLabels.length === 0) {
+                throw new McpError(400, "The labeled trigger needs a non-empty triggerLabels.");
+            }
+            if ((triggers.includes("mention") || triggers.includes("assigned")) && trustedAccountIds.length === 0) {
+                throw new McpError(400, "The mention and assigned triggers need a non-empty trustedAccountIds.");
+            }
+            if (!ctx.providers.issueTrackers?.[provider]) {
+                throw new McpError(503, "Jira is not configured on this deployment (see docs/jira-agents.md).");
+            }
+            const fields = {
+                access: args.access,
+                triggers,
+                triggerStatuses,
+                triggerLabels,
+                jqlFilter: args.jqlFilter ?? null,
+                trustedAccountIds,
+                commentVisibilityRole: args.commentVisibilityRole ?? null,
+                allowedTransitions,
+                writableFields,
+                allowedLinkTypes,
+                onPullRequestOpened,
+                onPullRequestMerged,
+                creatableIssueTypes,
+                maxNewIssuesPerRun,
+                authorizedById: ctx.principal.id,
+                authorizedAt: new Date(),
+            };
+            const link = await ctx.db.agentIssueProject.upsert({
+                where: { agentId_provider_projectKey: { agentId: args.agentId, provider, projectKey } },
+                create: { agentId: args.agentId, provider, projectKey, ...fields },
+                update: fields,
+            });
+            return textResult({ linked: true, link });
+        },
+    });
+    mcp.registerTool({
+        name: "unlink_issue_project",
+        scope: "agents:write",
+        description: "Removes a native agent's link to a Jira project. Admin only (agents:admin with the admin role).",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                agentId: { type: "string" },
+                provider: { type: "string", enum: PROVIDERS },
+                projectKey: { type: "string", minLength: 1, maxLength: 255 },
+            },
+            required: ["agentId", "projectKey"],
+        },
+        handler: async (args, ctx) => {
+            requireScope(ctx, ctx.canonicalUri, "agents:admin");
+            const agent = await ctx.db.agent.findUnique({ where: { id: args.agentId } });
+            if (!agent)
+                throw new McpError(404, `Agent "${args.agentId}" not found.`);
+            const { count } = await ctx.db.agentIssueProject.deleteMany({
+                where: {
+                    agentId: args.agentId,
+                    provider: args.provider ?? "jira",
+                    projectKey: normalizeProjectKey(args.projectKey),
+                },
+            });
+            return textResult({ unlinked: count > 0 });
+        },
+    });
+    mcp.registerTool({
+        name: "list_issue_projects",
+        scope: "agents:read",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { agentId: { type: "string" } },
+            required: ["agentId"],
+        },
+        handler: async (args, ctx) => {
+            await requireAgentAccess(ctx, args.agentId, "read");
+            const links = await ctx.db.agentIssueProject.findMany({
+                where: { agentId: args.agentId },
+                orderBy: { createdAt: "asc" },
+            });
+            return textResult({ issueProjects: links });
+        },
+    });
+}

package/dist/mcp/tools/model-catalog.d.ts

@@ -0,0 +1,22 @@
+import { McpError } from "../errors.js";
+import type { WardbyMcpServer } from "../server.js";
+export interface ModelCatalogToolDeps {
+    /** Rebuilds the process's installed CatalogStore after a write; omitted in contexts with no store. */
+    refresh?: () => Promise<void>;
+}
+/**
+ * The post-write ownership-race error: our own row for `inputProvider` was
+ * written, but a refresh right after showed `nowOwner` winning the merge
+ * instead (the first-claim-wins rule — see `ownerOf` in catalog.ts). Named
+ * after the thing that actually fixes it (reset_model, which clears every
+ * row for the id, `nowOwner`'s included) rather than telling the caller to
+ * "retry set_model", which would just hit the pre-write conflict check again
+ * (or, if the race repeats, loop). Exported so its exact wording can be unit
+ * tested directly — forcing the genuine two-process write race that triggers
+ * this through the public tool-call surface isn't practical: it requires a
+ * competing write to land in the narrow window between this handler's own
+ * pre-write ownership check and its own write, which a single-process test
+ * harness has no way to inject mid-call.
+ */
+export declare function raceLostError(modelId: string, inputProvider: string, nowOwner: string): McpError;
+export declare function registerModelCatalogTools(mcp: WardbyMcpServer, deps?: ModelCatalogToolDeps): void;