@wardby/cli 0.1.0

package/dist/mcp/tasks/manager.js

@@ -0,0 +1,103 @@
+import { INTERNAL_ERROR } from "@modelcontextprotocol/server";
+import { publicCodingRunResult } from "../../coding/protocol.js";
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+export function createTaskResult(row, ttlMs) {
+    return {
+        resultType: "task",
+        taskId: row.id,
+        status: "working",
+        createdAt: row.createdAt.toISOString(),
+        lastUpdatedAt: row.updatedAt.toISOString(),
+        ttlMs,
+        pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+    };
+}
+/** Starts a run-backed task: persists the Task row BEFORE returning, so a client's first tasks/get always finds it. */
+export async function createRunTask(runId, principalId, db, ttlMs) {
+    const row = await db.task.create({
+        data: {
+            kind: "run",
+            runId,
+            principalId,
+            status: "working",
+            ttlAt: new Date(Date.now() + ttlMs),
+        },
+    });
+    return createTaskResult(row, ttlMs);
+}
+function mapTerminalRunStatus(status, run) {
+    const usage = { tokensIn: run.tokensIn, tokensOut: run.tokensOut, costUsd: Number(run.costUsd) };
+    const codingResult = publicCodingRunResult(run.codingRun?.result);
+    if (codingResult)
+        return { status: "completed", result: codingResult };
+    switch (status) {
+        case "succeeded":
+            return { status: "completed", result: { finalText: run.finalText ?? "", usage } };
+        case "budget_exhausted":
+            // A successful terminal, not an error — the run did what the budget allowed.
+            return { status: "completed", result: { summary: run.finalText ?? "", usage, budgetExhausted: true } };
+        case "refused":
+            return {
+                status: "completed",
+                result: { refusalReason: run.error ?? "", usage: { tokensIn: 0, tokensOut: 0, costUsd: 0 } },
+            };
+        case "failed":
+        case "lost":
+            return { status: "failed", error: { code: INTERNAL_ERROR, message: run.error ?? `Run ${status}.` } };
+    }
+}
+/** Reads a task's current state, deriving a run task's status from the live Run.status. */
+export async function getTask(taskId, db) {
+    const task = await db.task.findUniqueOrThrow({ where: { id: taskId } });
+    const base = {
+        resultType: "complete",
+        taskId: task.id,
+        createdAt: task.createdAt.toISOString(),
+        lastUpdatedAt: task.updatedAt.toISOString(),
+        ttlMs: task.ttlAt.getTime() - Date.now(),
+        pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+    };
+    if (task.status === "cancelled") {
+        return { ...base, status: "cancelled" };
+    }
+    if (!task.runId) {
+        throw new Error(`Task "${taskId}" has kind "${task.kind}" with no runId — only kind:"run" tasks are supported.`);
+    }
+    const run = await db.run.findUniqueOrThrow({
+        where: { id: task.runId },
+        include: { codingRun: { select: { result: true } } },
+    });
+    switch (run.status) {
+        case "pending":
+        case "running":
+            return { ...base, status: "working", statusMessage: `cost so far: $${Number(run.costUsd).toFixed(6)}` };
+        case "cancelled":
+            return { ...base, status: "cancelled" };
+        case "succeeded":
+        case "budget_exhausted":
+        case "refused":
+        case "failed":
+        case "lost": {
+            const mapped = mapTerminalRunStatus(run.status, run);
+            return { ...base, ...mapped };
+        }
+    }
+}
+/**
+ * Cooperatively stops a task's underlying run (best-effort — cancellation
+ * is eventually consistent). A no-op when the run has already reached a
+ * terminal status on its own; the stop hook is never called for a run
+ * that's already finished.
+ */
+export async function cancelTask(taskId, db, stopRun) {
+    const task = await db.task.findUniqueOrThrow({ where: { id: taskId } });
+    if (task.status === "cancelled" || !task.runId)
+        return;
+    const run = await db.run.findUniqueOrThrow({ where: { id: task.runId } });
+    if (run.status !== "pending" && run.status !== "running") {
+        // Already terminal — nothing to cancel.
+        return;
+    }
+    await stopRun(task.runId);
+    await db.task.update({ where: { id: taskId }, data: { status: "cancelled" } });
+}

package/dist/mcp/tools/agents.d.ts

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

package/dist/mcp/tools/agents.js

@@ -0,0 +1,375 @@
+/** Agent CRUD with scope checks in server.ts and ownership checks here. */
+import { Prisma } from "@prisma/client";
+import { z } from "zod";
+import { CodingProfilePatchSchema, CodingProfileSchema } from "../../coding/profile.js";
+import { codingProviderSupportsModel } from "../../coding/provider.js";
+import { validateCronExpression } from "../../core/cron.js";
+import { assertCanMutate, canRead, requireOwnedAgent, requireReadableBudgetGroup, visibleToPrincipal, } from "../auth/ownership.js";
+import { requireScope } from "../auth/resource-server.js";
+import { McpError } from "../errors.js";
+import { textResult } from "./text-result.js";
+// workerImageRef is the BYO-arbitrary-image escape hatch (see
+// resolveCodingWorkerImage in container.ts) — setting or changing it
+// requires a step-up beyond agents:write, the same pattern make_owner below
+// uses for its own sensitive, ownership-bypassing mutation.
+function requireWorkerImageRefScope(ctx) {
+    requireScope(ctx, ctx.canonicalUri, "agents:admin");
+}
+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;
+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),
+    schedule: z.string().trim().min(1).max(256),
+    timezone: z.string().trim().min(1).max(128),
+    scheduleEnabled: z.boolean(),
+    kind: z.enum(["native", "coding"]),
+    budgetGroupId: z.string().min(1).max(128),
+    memoryEnabled: z.boolean(),
+};
+const CreateAgentSchema = z
+    .object({
+    name: agentFields.name,
+    systemPrompt: agentFields.systemPrompt,
+    model: agentFields.model,
+    budgetUsd: agentFields.budgetUsd,
+    maxTurns: agentFields.maxTurns.optional(),
+    schedule: agentFields.schedule.optional(),
+    timezone: agentFields.timezone.optional(),
+    scheduleEnabled: agentFields.scheduleEnabled.optional(),
+    kind: agentFields.kind.default("native"),
+    budgetGroupId: agentFields.budgetGroupId.optional(),
+    memoryEnabled: agentFields.memoryEnabled.default(false),
+    codingProfile: CodingProfileSchema.optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.kind === "coding" && !value.codingProfile) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["codingProfile"], message: "is required for coding agents" });
+    }
+    if (value.kind === "native" && value.codingProfile) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["codingProfile"],
+            message: "is only valid for coding agents",
+        });
+    }
+    if (value.kind === "coding" &&
+        value.codingProfile &&
+        !codingProviderSupportsModel(value.codingProfile.provider, value.model)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["model"],
+            message: `is not supported by coding provider "${value.codingProfile.provider}"`,
+        });
+    }
+    const enabledSchedule = value.schedule && value.scheduleEnabled !== false;
+    if (value.kind === "coding" && enabledSchedule && !value.codingProfile?.defaultTask) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["codingProfile", "defaultTask"],
+            message: "is required for an enabled schedule",
+        });
+    }
+});
+const UpdateAgentSchema = z
+    .object({
+    id: z.string().min(1).max(128),
+    name: agentFields.name.optional(),
+    systemPrompt: agentFields.systemPrompt.optional(),
+    model: agentFields.model.optional(),
+    budgetUsd: agentFields.budgetUsd.optional(),
+    maxTurns: agentFields.maxTurns.optional(),
+    schedule: agentFields.schedule.nullable().optional(),
+    timezone: agentFields.timezone.optional(),
+    scheduleEnabled: agentFields.scheduleEnabled.optional(),
+    kind: agentFields.kind.optional(),
+    budgetGroupId: agentFields.budgetGroupId.nullable().optional(),
+    memoryEnabled: agentFields.memoryEnabled.optional(),
+    codingProfile: CodingProfilePatchSchema.optional(),
+})
+    .strict();
+const profileJsonSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        provider: { type: "string", enum: ["codex", "claude-code"] },
+        repository: { type: "string" },
+        baseRef: { type: "string" },
+        defaultTask: { type: ["string", "null"] },
+        allowWebhookTaskOverride: { type: "boolean" },
+        timeoutSec: { type: "integer", minimum: 60, maximum: 7200 },
+        allowedEgress: { type: "array", maxItems: 64, items: { type: "string" } },
+        protectedPaths: { type: "array", minItems: 1, maxItems: 128, items: { type: "string" } },
+        toolchain: { type: "string", enum: ["node", "node-python"] },
+        toolchainVersion: { type: ["string", "null"] },
+        workerImageRef: { type: ["string", "null"] },
+        workspaceDiskMb: {
+            type: ["integer", "null"],
+            minimum: 64,
+            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.",
+        },
+    },
+};
+function invalidArguments(label, error) {
+    const details = error.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; ");
+    return new McpError(400, `Invalid ${label}: ${details}`);
+}
+function parseCreateAgent(args) {
+    const result = CreateAgentSchema.safeParse(args);
+    if (!result.success)
+        throw invalidArguments("create_agent arguments", result.error);
+    return result.data;
+}
+function parseUpdateAgent(args) {
+    const result = UpdateAgentSchema.safeParse(args);
+    if (!result.success)
+        throw invalidArguments("update_agent arguments", result.error);
+    return result.data;
+}
+function validateSchedule(schedule, timezone) {
+    if (!schedule)
+        return;
+    try {
+        validateCronExpression(schedule, timezone);
+    }
+    catch (error) {
+        throw new McpError(400, `Invalid schedule/timezone: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function storedProfile(profile) {
+    return CodingProfileSchema.parse({
+        provider: profile.provider,
+        repository: profile.repository,
+        baseRef: profile.baseRef,
+        defaultTask: profile.defaultTask,
+        allowWebhookTaskOverride: profile.allowWebhookTaskOverride,
+        timeoutSec: profile.timeoutSec,
+        allowedEgress: profile.allowedEgress,
+        protectedPaths: profile.protectedPaths,
+        toolchain: profile.toolchain,
+        toolchainVersion: profile.toolchainVersion,
+        workerImageRef: profile.workerImageRef,
+        workspaceDiskMb: profile.workspaceDiskMb,
+    });
+}
+export function registerAgentTools(mcp) {
+    mcp.registerTool({
+        name: "create_agent",
+        scope: "agents:write",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                name: { type: "string" },
+                systemPrompt: { type: "string" },
+                model: { type: "string" },
+                budgetUsd: { type: "number" },
+                maxTurns: { type: "integer" },
+                schedule: { type: "string" },
+                timezone: { type: "string" },
+                scheduleEnabled: { type: "boolean" },
+                kind: { type: "string", enum: ["native", "coding"] },
+                budgetGroupId: { type: "string" },
+                memoryEnabled: { type: "boolean" },
+                codingProfile: { ...profileJsonSchema, required: ["repository"] },
+            },
+            required: ["name", "systemPrompt", "model", "budgetUsd"],
+        },
+        handler: async (rawArgs, ctx) => {
+            const args = parseCreateAgent(rawArgs);
+            if (args.codingProfile?.workerImageRef != null)
+                requireWorkerImageRefScope(ctx);
+            validateSchedule(args.schedule, args.timezone ?? "UTC");
+            if (args.budgetGroupId) {
+                await requireReadableBudgetGroup(ctx.db, args.budgetGroupId, ctx.principal.id);
+            }
+            const { codingProfile, ...agentData } = args;
+            const agent = await ctx.db.agent.create({
+                data: {
+                    ...agentData,
+                    ownerId: ctx.principal.id,
+                    ...(codingProfile ? { codingProfile: { create: codingProfile } } : {}),
+                },
+                include: { codingProfile: true },
+            });
+            return textResult(agent);
+        },
+    });
+    mcp.registerTool({
+        name: "update_agent",
+        scope: "agents:write",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                id: { type: "string" },
+                name: { type: "string" },
+                systemPrompt: { type: "string" },
+                model: { type: "string" },
+                budgetUsd: { type: "number" },
+                maxTurns: { type: "integer" },
+                schedule: { type: ["string", "null"] },
+                timezone: { type: "string" },
+                scheduleEnabled: { type: "boolean" },
+                kind: { type: "string", enum: ["native", "coding"] },
+                budgetGroupId: { type: ["string", "null"] },
+                memoryEnabled: { type: "boolean" },
+                codingProfile: profileJsonSchema,
+            },
+            required: ["id"],
+        },
+        handler: async (rawArgs, ctx) => {
+            const args = parseUpdateAgent(rawArgs);
+            if (args.codingProfile?.workerImageRef !== undefined)
+                requireWorkerImageRefScope(ctx);
+            const agent = await ctx.db.$transaction(async (tx) => {
+                const existing = await tx.agent.findUnique({ where: { id: args.id }, include: { codingProfile: true } });
+                if (!existing)
+                    throw new McpError(404, `Agent "${args.id}" not found.`);
+                assertCanMutate(existing.ownerId, ctx.principal.id, `Agent "${args.id}" is not owned by the caller.`);
+                if (args.budgetGroupId) {
+                    await requireReadableBudgetGroup(ctx.db, args.budgetGroupId, ctx.principal.id);
+                }
+                const nextKind = args.kind ?? existing.kind;
+                if (nextKind === "native" && args.codingProfile) {
+                    throw new McpError(400, "A coding profile is only valid for coding agents.");
+                }
+                let nextProfile = null;
+                if (nextKind === "coding") {
+                    const attachedTools = await tx.agentTool.count({ where: { agentId: args.id } });
+                    if (attachedTools > 0) {
+                        throw new McpError(400, "Detach all native sandbox tools before changing an agent to coding.");
+                    }
+                    const currentProfile = existing.codingProfile ? storedProfile(existing.codingProfile) : undefined;
+                    const profileResult = CodingProfileSchema.safeParse({ ...currentProfile, ...args.codingProfile });
+                    if (!profileResult.success)
+                        throw invalidArguments("coding profile", profileResult.error);
+                    nextProfile = profileResult.data;
+                    const nextModel = args.model ?? existing.model;
+                    if (!codingProviderSupportsModel(nextProfile.provider, nextModel)) {
+                        throw new McpError(400, `Model "${nextModel}" is not supported by coding provider "${nextProfile.provider}".`);
+                    }
+                }
+                const nextSchedule = args.schedule !== undefined ? args.schedule : existing.schedule;
+                const nextTimezone = args.timezone ?? existing.timezone;
+                const nextScheduleEnabled = args.scheduleEnabled ?? existing.scheduleEnabled;
+                validateSchedule(nextSchedule, nextTimezone);
+                if (nextKind === "coding" && nextSchedule && nextScheduleEnabled && !nextProfile?.defaultTask) {
+                    throw new McpError(400, "A default task is required for an enabled coding-agent schedule.");
+                }
+                const { id, codingProfile: _profilePatch, ...updates } = args;
+                const profileMutation = nextKind === "native"
+                    ? existing.codingProfile
+                        ? { delete: true }
+                        : undefined
+                    : existing.codingProfile
+                        ? { update: nextProfile }
+                        : { create: nextProfile };
+                return tx.agent.update({
+                    where: { id },
+                    data: {
+                        ...updates,
+                        ...(profileMutation ? { codingProfile: profileMutation } : {}),
+                    },
+                    include: { codingProfile: true },
+                });
+            }, { isolationLevel: Prisma.TransactionIsolationLevel.Serializable });
+            return textResult(agent);
+        },
+    });
+    mcp.registerTool({
+        name: "list_agents",
+        scope: "agents:read",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        handler: async (_args, ctx) => {
+            const agents = await ctx.db.agent.findMany({
+                where: visibleToPrincipal(ctx.principal.id),
+                include: { codingProfile: true },
+            });
+            return textResult(agents);
+        },
+    });
+    mcp.registerTool({
+        name: "get_agent",
+        scope: "agents:read",
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+            additionalProperties: false,
+        },
+        handler: async (args, ctx) => {
+            const agent = await ctx.db.agent.findUnique({
+                where: { id: args.id },
+                include: { tools: { include: { tool: true } }, codingProfile: true },
+            });
+            if (!agent || !canRead(agent.ownerId, ctx.principal.id)) {
+                throw new McpError(404, `Agent "${args.id}" not found.`);
+            }
+            return textResult(agent);
+        },
+    });
+    mcp.registerTool({
+        name: "delete_agent",
+        scope: "agents:write",
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+            additionalProperties: false,
+        },
+        handler: async (args, ctx) => {
+            await requireOwnedAgent(ctx.db, args.id, ctx.principal.id);
+            try {
+                await ctx.db.agent.delete({ where: { id: args.id } });
+            }
+            catch (err) {
+                // Run.agentId has no onDelete rule, so Postgres refuses to delete an
+                // agent that has ever run. That is deliberate - runs are the cost and
+                // budget history - so say so instead of surfacing the FK violation.
+                if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2003") {
+                    throw new McpError(409, "Agent has run history, which is kept for cost and budget accounting, so it cannot be deleted. " +
+                        "Use disable_schedule to stop it running.");
+                }
+                throw err;
+            }
+            return textResult({ deleted: args.id });
+        },
+    });
+    // Deliberately bypasses ownership entirely (no assertCanMutate/
+    // requireOwnedAgent call) — that's the point of this tool vs. the
+    // self-service null-owner-is-public-mutable rule everything else here
+    // follows. Gated on agents:admin, a step up from agents:write, so an
+    // ordinary caller can never reach it regardless of what they own.
+    // ownerId: null releases the agent back to public, same as any agent
+    // that was never assigned an owner.
+    mcp.registerTool({
+        name: "make_owner",
+        scope: "agents:admin",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { agentId: { type: "string" }, ownerId: { type: ["string", "null"] } },
+            required: ["agentId", "ownerId"],
+        },
+        handler: async (args, ctx) => {
+            const agent = await ctx.db.agent.findUnique({ where: { id: args.agentId } });
+            if (!agent)
+                throw new McpError(404, `Agent "${args.agentId}" not found.`);
+            if (args.ownerId !== null) {
+                const principal = await ctx.db.principal.findUnique({ where: { id: args.ownerId } });
+                if (!principal)
+                    throw new McpError(400, `Principal "${args.ownerId}" not found.`);
+            }
+            const updated = await ctx.db.agent.update({ where: { id: args.agentId }, data: { ownerId: args.ownerId } });
+            return textResult(updated);
+        },
+    });
+}

package/dist/mcp/tools/budget-groups.d.ts

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

package/dist/mcp/tools/budget-groups.js

@@ -0,0 +1,136 @@
+/** BudgetGroup CRUD with scope checks in server.ts and ownership checks here. */
+import { z } from "zod";
+import { computeGroupSpend } from "../../core/budget-groups.js";
+import { canRead, requireOwnedBudgetGroup, visibleToPrincipal } from "../auth/ownership.js";
+import { McpError } from "../errors.js";
+import { textResult } from "./text-result.js";
+const MAX_GROUP_NAME_CHARS = 200;
+const MAX_BUDGET_USD = 1_000_000;
+const capField = z.number().finite().positive().max(MAX_BUDGET_USD);
+const CreateBudgetGroupSchema = z
+    .object({
+    name: z.string().trim().min(1).max(MAX_GROUP_NAME_CHARS),
+    dailyBudgetUsd: capField.optional(),
+    weeklyBudgetUsd: capField.optional(),
+    monthlyBudgetUsd: capField.optional(),
+    warnThresholdRatio: z.number().finite().gt(0).lte(1).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.dailyBudgetUsd === undefined &&
+        value.weeklyBudgetUsd === undefined &&
+        value.monthlyBudgetUsd === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["dailyBudgetUsd"],
+            message: "at least one of dailyBudgetUsd/weeklyBudgetUsd/monthlyBudgetUsd is required",
+        });
+    }
+});
+const UpdateBudgetGroupSchema = z
+    .object({
+    id: z.string().min(1).max(128),
+    name: z.string().trim().min(1).max(MAX_GROUP_NAME_CHARS).optional(),
+    dailyBudgetUsd: capField.nullable().optional(),
+    weeklyBudgetUsd: capField.nullable().optional(),
+    monthlyBudgetUsd: capField.nullable().optional(),
+    warnThresholdRatio: z.number().finite().gt(0).lte(1).optional(),
+})
+    .strict();
+function invalidArguments(label, error) {
+    const details = error.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; ");
+    return new McpError(400, `Invalid ${label}: ${details}`);
+}
+const capSchemaProps = {
+    dailyBudgetUsd: { type: ["number", "null"] },
+    weeklyBudgetUsd: { type: ["number", "null"] },
+    monthlyBudgetUsd: { type: ["number", "null"] },
+    warnThresholdRatio: { type: "number" },
+};
+export function registerBudgetGroupTools(mcp) {
+    mcp.registerTool({
+        name: "create_budget_group",
+        scope: "budget_groups:write",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { name: { type: "string" }, ...capSchemaProps },
+            required: ["name"],
+        },
+        handler: async (rawArgs, ctx) => {
+            const result = CreateBudgetGroupSchema.safeParse(rawArgs);
+            if (!result.success)
+                throw invalidArguments("create_budget_group arguments", result.error);
+            const group = await ctx.db.budgetGroup.create({
+                data: { ...result.data, ownerId: ctx.principal.id },
+            });
+            return textResult(group);
+        },
+    });
+    mcp.registerTool({
+        name: "update_budget_group",
+        scope: "budget_groups:write",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { id: { type: "string" }, name: { type: "string" }, ...capSchemaProps },
+            required: ["id"],
+        },
+        handler: async (rawArgs, ctx) => {
+            const result = UpdateBudgetGroupSchema.safeParse(rawArgs);
+            if (!result.success)
+                throw invalidArguments("update_budget_group arguments", result.error);
+            const { id, ...updates } = result.data;
+            await requireOwnedBudgetGroup(ctx.db, id, ctx.principal.id);
+            const group = await ctx.db.budgetGroup.update({ where: { id }, data: updates });
+            return textResult(group);
+        },
+    });
+    mcp.registerTool({
+        name: "list_budget_groups",
+        scope: "agents:read",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        handler: async (_args, ctx) => {
+            const groups = await ctx.db.budgetGroup.findMany({ where: visibleToPrincipal(ctx.principal.id) });
+            return textResult(groups);
+        },
+    });
+    mcp.registerTool({
+        name: "get_budget_group",
+        scope: "agents:read",
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+            additionalProperties: false,
+        },
+        handler: async (args, ctx) => {
+            const group = await ctx.db.budgetGroup.findUnique({
+                where: { id: args.id },
+                include: { agents: { select: { id: true, name: true } } },
+            });
+            if (!group || !canRead(group.ownerId, ctx.principal.id)) {
+                throw new McpError(404, `Budget group "${args.id}" not found.`);
+            }
+            const spend = await computeGroupSpend(ctx.db, group, group.agents.map((a) => a.id), new Date());
+            return textResult({ ...group, spend });
+        },
+    });
+    mcp.registerTool({
+        name: "delete_budget_group",
+        scope: "budget_groups:write",
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+            additionalProperties: false,
+        },
+        handler: async (args, ctx) => {
+            await requireOwnedBudgetGroup(ctx.db, args.id, ctx.principal.id);
+            // Agent.budgetGroupId -> BudgetGroup is ON DELETE SET NULL: member
+            // agents are ungrouped automatically, never blocked or cascaded.
+            await ctx.db.budgetGroup.delete({ where: { id: args.id } });
+            return textResult({ deleted: args.id });
+        },
+    });
+}

package/dist/mcp/tools/datastore.d.ts

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