@beignet/cli 0.0.47 → 0.0.49

package/src/make/inbox.ts

@@ -226,7 +226,7 @@ export async function makeInbox(
  */
 export function makeInboxNextStepLines(): string[] {
   return [
-    "Run beignet db generate and beignet db migrate so inbox_notifications exists.",
+    "Run beignet db generate, beignet db migrate, and beignet db status so inbox_notifications exists and is verified.",
     'Add an in-app channel to any feature notification: import { defineInboxNotificationChannel } from "@/features/inbox/channel" and add inApp: defineInboxNotificationChannel(({ payload }) => ({ userId: payload.userId, type: "your-type", title: "Something happened" })) to its channels.',
     "Render the unread badge from features/inbox/components/unread-badge.tsx next to your Inbox nav link for a live unread count.",
     "Run your app's test, lint, and typecheck commands, then beignet lint and beignet doctor.",
@@ -518,9 +518,9 @@ export const inboxNotificationSchema = z.object({
 });
 
 export const listInboxQuerySchema = z.object({
-\tlimit: z.coerce.number().int().min(1).max(50).default(20),
+\tlimit: z.number().int().min(1).max(50).default(20),
 \tcursor: z.string().min(1).optional(),
-\tunread: z.coerce.boolean().default(false),
+\tunread: z.boolean().default(false),
 });
 
 export const listInboxOutputSchema = z.object({
@@ -659,7 +659,7 @@ export function inboxContractsFile(config: ResolvedBeignetConfig): string {
   );
   const errorsModule = aliasModule(resourceSharedErrorsPath(config));
 
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import {
 \tinboxNotificationSchema,
 \tlistInboxOutputSchema,
@@ -674,7 +674,14 @@ const inbox = defineContractGroup().namespace("inbox").prefix("/api/inbox");
 
 export const listInbox = inbox
 \t.get("/")
-\t.query(listInboxQuerySchema)
+\t.query(
+\t\tlistInboxQuerySchema,
+\t\tdefineQueryTransport({
+\t\t\tlimit: query.integer(),
+\t\t\tcursor: query.string(),
+\t\t\tunread: query.boolean(),
+\t\t}),
+\t)
 \t.meta({ auth: "required" })
 \t.errors({ Unauthorized: errors.Unauthorized })
 \t.responses({

package/src/make/payments.ts

@@ -209,7 +209,7 @@ export function makePaymentsNextStepLines(
   return [
     "The free plan works out of the box; billing accounts without an active subscription resolve to it automatically.",
     "Set BILLING_PRO_PRICE_ID in .env.local to the provider price ID for your pro plan.",
-    "Run beignet db generate and beignet db migrate so billing_accounts exists before handling webhooks.",
+    "Run beignet db generate, beignet db migrate, and beignet db status so billing_accounts exists and is verified before handling webhooks.",
     'Gate paid actions once usage passes FREE_PLAN_LIMITS: await requireEntitlement(ctx, { entitlement: "todos.create", subject: { type: "tenant", id: tenantId } });',
     ...(hasPlanUi
       ? [
@@ -862,7 +862,7 @@ export function isBillingAccountActive(
 export function billingContractsFile(
   idempotencyScope: "actor" | "actor-tenant" = "actor",
 ): string {
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport } from "@beignet/core/contracts";
 import { z } from "zod";
 import {
 \tbillingStatusOutputSchema,
@@ -882,7 +882,7 @@ const checkoutBilling = billing.headers(checkoutHeadersSchema);
 
 export const getBillingStatus = billing
 \t.get("/")
-\t.query(z.object({}))
+\t.query(z.object({}), defineQueryTransport({}))
 \t.meta({ auth: "required" })
 \t.errors({ Unauthorized: errors.Unauthorized })
 \t.responses({

package/src/make/tenancy.ts

@@ -249,7 +249,7 @@ export async function makeTenancy(
  */
 export function makeTenancyNextStepLines(): string[] {
   return [
-    "Run beignet db generate and beignet db migrate so the workspaces, workspace_members, and workspace_invites tables exist.",
+    "Run beignet db generate, beignet db migrate, and beignet db status so the workspaces, workspace_members, and workspace_invites tables exist and are verified.",
     "Requests resolve the active workspace from memberships and the beignet-workspace cookie; users without a workspace have no tenant, so point them at Settings > Workspace to create one.",
     "Run the db:seed script for a demo workspace with a sign-in-able demo admin (demo-admin@example.com).",
     "Invite emails send through the in-memory mailer in development; swap server/providers.ts to a real mail provider such as @beignet/provider-mail-resend for delivery.",

package/src/make.ts

@@ -2,6 +2,8 @@ import { randomBytes } from "node:crypto";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
+import { analyzePortWiringFiles } from "./analysis/port-wiring.js";
+import { listProjectFiles } from "./analysis/workspace.js";
 import type { MakeFeatureAddon, MakeFeatureRecipe } from "./choices.js";
 import {
   type BeignetConfig,
@@ -1084,6 +1086,10 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   await assertFeatureArtifactApp(targetDir, config, "job");
   await assertServerRuntimeApp(targetDir, config, "job");
   await updateOutboxPortWiring(targetDir, config, { dryRun: true });
+  const jobDispatcherPlan = await planInlineJobDispatcherWiring(
+    targetDir,
+    config,
+  );
   const outboxDrainPlan = await planOutboxDrainWiring(targetDir, config, {
     force: Boolean(options.force),
   });
@@ -1114,6 +1120,9 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   await applyOutboxDrainWiring(result, targetDir, outboxDrainPlan, {
     dryRun: Boolean(options.dryRun),
   });
+  await applyInlineJobDispatcherWiring(result, targetDir, jobDispatcherPlan, {
+    dryRun: Boolean(options.dryRun),
+  });
   await applyOutboxPortWiring(result, targetDir, config, {
     dryRun: Boolean(options.dryRun),
   });
@@ -1124,6 +1133,201 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   return result;
 }
 
+type InlineJobDispatcherWiringPlan = {
+  changes: { path: string; before: string; after: string }[];
+};
+
+async function planInlineJobDispatcherWiring(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<InlineJobDispatcherWiringPlan> {
+  const portsFile = config.paths.ports;
+  const portWiringFile = config.paths.portWiring;
+  const providersFile = providersFilePath(config);
+  const ports = await readFile(path.join(targetDir, portsFile), "utf8");
+  const portWiring = await readFile(
+    path.join(targetDir, portWiringFile),
+    "utf8",
+  );
+  const analysis = await analyzePortWiringFiles({
+    targetDir,
+    files: await listProjectFiles(targetDir),
+    config,
+  });
+  const declaresJobs = analysis.declared.has("jobs");
+  const wiresJobs = analysis.bound.has("jobs") || analysis.deferred.has("jobs");
+
+  if (declaresJobs && wiresJobs) {
+    return { changes: [] };
+  }
+  if (!declaresJobs && analysis.declarationIndeterminate) {
+    throw new Error(
+      `Could not prove whether AppPorts in ${portsFile} declares the jobs port. Preserve the app's custom port type and add jobs: JobDispatcherPort manually before running make job.`,
+    );
+  }
+  if (!wiresJobs && analysis.indeterminate) {
+    throw new Error(
+      `Could not prove how the jobs port is wired in ${portWiringFile}. Preserve the app's custom dispatcher by binding or deferring "jobs" in a statically inspectable definePorts(...) object before running make job.`,
+    );
+  }
+
+  let nextPorts = ports;
+  if (!declaresJobs && !analysis.appPortsInferredFromWiring) {
+    nextPorts = addNamedTypeImport(
+      nextPorts,
+      "JobDispatcherPort",
+      "@beignet/core/ports",
+    );
+    nextPorts = insertTypeProperty(
+      nextPorts,
+      "AppPorts",
+      "jobs: JobDispatcherPort;",
+      `Could not find AppPorts in ${portsFile}. Add jobs: JobDispatcherPort manually and wire a dispatcher, or restore the generated ports file before running make job.`,
+    );
+  }
+
+  if (wiresJobs) {
+    return {
+      changes:
+        ports === nextPorts
+          ? []
+          : [{ path: portsFile, before: ports, after: nextPorts }],
+    };
+  }
+
+  const nextPortWiring = appendDeferredPortKey(portWiring, "jobs");
+  if (nextPortWiring === portWiring) {
+    throw new Error(
+      `Could not find the deferred port list in ${portWiringFile}. Add "jobs" manually and wire a dispatcher, or restore the generated port wiring file before running make job.`,
+    );
+  }
+
+  const providersPath = path.join(targetDir, providersFile);
+  const providers = await readOptionalFile(providersPath);
+  if (providers === undefined) {
+    throw new Error(
+      `Could not find ${providersFile}. Register an inline or provider-backed jobs dispatcher manually, or restore the generated providers file before running make job.`,
+    );
+  }
+  let nextProviders = addNamedImport(
+    providers,
+    "createInlineJobDispatcher",
+    "@beignet/core/jobs",
+  );
+  nextProviders = addNamedImport(
+    nextProviders,
+    "createProvider",
+    "@beignet/core/providers",
+  );
+  nextProviders = addNamedTypeImport(
+    nextProviders,
+    "AppContext",
+    aliasModule(config.paths.appContext),
+  );
+  nextProviders = addNamedTypeImport(
+    nextProviders,
+    "AppPorts",
+    aliasModule(config.paths.ports),
+  );
+  nextProviders = addNamedTypeImport(
+    nextProviders,
+    "AppServiceContextInput",
+    aliasModule(path.join(path.dirname(config.paths.server), "context.ts")),
+  );
+
+  const providerName = "inlineJobsProvider";
+  const generatedProviderMarker = "// beignet:generated-inline-jobs-provider";
+  const providersSourceFile = ts.createSourceFile(
+    providersFile,
+    nextProviders,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const providerDeclaration = providersSourceFile.statements
+    .filter(ts.isVariableStatement)
+    .flatMap((statement) => [...statement.declarationList.declarations])
+    .find(
+      (declaration) =>
+        ts.isIdentifier(declaration.name) &&
+        declaration.name.text === providerName,
+    );
+  const providerDeclarationExists = providerDeclaration !== undefined;
+  const providerIsGenerated = providerDeclaration
+    ? nextProviders
+        .slice(0, providerDeclaration.getStart(providersSourceFile))
+        .trimEnd()
+        .endsWith(generatedProviderMarker)
+    : false;
+  if (providerDeclarationExists && !providerIsGenerated) {
+    throw new Error(
+      `Could not install the generated inline jobs dispatcher because ${providerName} already exists in ${providersFile}. Rename the app-owned declaration or wire its jobs port explicitly before running make job.`,
+    );
+  }
+  if (!providerDeclarationExists) {
+    const definition = `// beignet:generated-inline-jobs-provider
+const ${providerName} = createProvider<
+	{},
+	AppContext,
+	AppServiceContextInput
+>()({
+	name: "inline-jobs",
+	setup({ createServiceContext }): { ports: Pick<AppPorts, "jobs"> } {
+		return {
+			ports: {
+				jobs: createInlineJobDispatcher<AppContext>({
+					ctx: () => createServiceContext(undefined),
+				}),
+			},
+		};
+	},
+});
+`;
+    const inserted = nextProviders.replace(
+      /\nexport const providers = \[/,
+      `\n${definition}\nexport const providers = [`,
+    );
+    if (inserted === nextProviders) {
+      throw new Error(
+        `Could not find the exported providers array in ${providersFile}. Register an inline or provider-backed jobs dispatcher manually, or restore the generated providers file before running make job.`,
+      );
+    }
+    nextProviders = inserted;
+  }
+  const appended = appendToNamedArray(nextProviders, "providers", providerName);
+  if (appended.kind === "missing") {
+    throw new Error(
+      `Could not find the exported providers array in ${providersFile}. Register ${providerName} manually, or restore the generated providers file before running make job.`,
+    );
+  }
+  if (appended.kind === "updated") nextProviders = appended.source;
+
+  return {
+    changes: [
+      { path: portsFile, before: ports, after: nextPorts },
+      { path: portWiringFile, before: portWiring, after: nextPortWiring },
+      { path: providersFile, before: providers, after: nextProviders },
+    ].filter((change) => change.before !== change.after),
+  };
+}
+
+async function applyInlineJobDispatcherWiring(
+  result: MakeResult,
+  targetDir: string,
+  plan: InlineJobDispatcherWiringPlan,
+  options: { dryRun: boolean },
+): Promise<void> {
+  for (const change of plan.changes) {
+    if (!options.dryRun) {
+      await writeFile(path.join(targetDir, change.path), change.after);
+    }
+    if (!result.updatedFiles.includes(change.path)) {
+      result.updatedFiles.push(change.path);
+    }
+    if (!result.files.includes(change.path)) result.files.push(change.path);
+  }
+}
+
 export async function makeTask(
   options: MakeTaskOptions,
 ): Promise<MakeTaskResult> {
@@ -3983,8 +4187,8 @@ export function decode${names.singularPascal}Cursor(cursor: string): ${names.sin
 
 export const List${names.pluralPascal}InputSchema = z
 	.object({
-		limit: z.coerce.number().int().min(1).max(100).default(20),
-		cursor: z.string().nullable().default(null),
+		limit: z.number().int().min(1).max(100).default(20),
+		cursor: z.string().optional().transform((value) => value ?? null),
 		name: z.string().trim().min(1).max(120).optional(),
 		sortBy: ${names.singularPascal}SortBySchema.default("createdAt"),
 		sortDirection: ${names.singularPascal}SortDirectionSchema.default("desc"),
@@ -4840,7 +5044,7 @@ function contractFile(
   mode: ResourceGenerationMode,
   options: ResourceGenerationOptions,
 ): string {
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import { z } from "zod";
 ${mode === "resource" ? `import { errors } from "${aliasModule(resourceSharedErrorsPath(config))}";\n` : ""}import {
 	Create${names.singularPascal}InputSchema,
@@ -4863,7 +5067,16 @@ const ${names.pluralCamel} = defineContractGroup()
 
 export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
-	.query(List${names.pluralPascal}InputSchema)
+	.query(
+		List${names.pluralPascal}InputSchema,
+		defineQueryTransport({
+			limit: query.integer(),
+			cursor: query.string(),
+			name: query.string(),
+			sortBy: query.string(),
+			sortDirection: query.string(),
+		}),
+	)
 	.responses({
 		200: List${names.pluralPascal}OutputSchema,
 	});
@@ -4908,7 +5121,7 @@ ${options.authorization ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization:
 }
 
 function standaloneContractFile(names: ResourceNames): string {
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import { z } from "zod";
 
 const ErrorResponseSchema = z.object({
@@ -4932,8 +5145,12 @@ export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
 	.query(
 		z.object({
-			limit: z.coerce.number().int().min(1).max(100).default(20),
-			offset: z.coerce.number().int().min(0).default(0),
+			limit: z.number().int().min(1).max(100).default(20),
+			offset: z.number().int().min(0).default(0),
+		}),
+		defineQueryTransport({
+			limit: query.integer(),
+			offset: query.integer(),
 		}),
 	)
 	.responses({
@@ -6038,7 +6255,7 @@ ${options.authorization ? `\t\t\t\tgate: initialPorts.gate,\n` : ""}
 		);
 		const secondPage = await tester.run(
 			list${names.pluralPascal}UseCase,
-			{ limit: 2, cursor: firstPage.page.nextCursor },
+			{ limit: 2, cursor: firstPage.page.nextCursor! },
 			{ ctx },
 		);
 		const nameAscendingPage = await tester.run(

package/src/mcp.ts

@@ -1,11 +1,8 @@
 import { open, realpath } from "node:fs/promises";
 import path from "node:path";
-import {
-  McpServer,
-  ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { z } from "zod/v4";
 import { mapApp, projectAppMap } from "./app-map.js";
 import { appMapNodeKinds } from "./app-map-schema.js";
 import { checkApp } from "./check.js";
@@ -23,6 +20,7 @@ import {
   defaultDatabaseCommandMaxOutputBytes,
   defaultDatabaseCommandTimeoutMs,
   runDatabaseCommand,
+  runDatabaseStatus,
   syncDatabaseSchema,
 } from "./db.js";
 import { explainApp, explainTargetKinds } from "./explain.js";
@@ -639,7 +637,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     "check",
     {
       description:
-        "Run the full Beignet app validation loop: Beignet lint, strict doctor, and the app's lint, typecheck, and test scripts. Returns the same versioned JSON as beignet check --json, including every step, bounded failure output, durations, and overall ok status. Does not apply Beignet fixes, but app-owned scripts run with their normal side effects.",
+        "Run the full Beignet app validation loop: Beignet lint, strict doctor, optional disconnected or connected preflight, and the app's lint, typecheck, and test scripts. Returns the same versioned JSON as beignet check --json, including every step, bounded failure output, durations, and overall ok status. Does not apply Beignet fixes, but app-owned scripts run with their normal side effects.",
       inputSchema: {
         preflight: z
           .boolean()
@@ -647,6 +645,21 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
           .describe(
             "Include the environment preflight check before app package scripts. Defaults to false.",
           ),
+        preflightConnect: z
+          .boolean()
+          .optional()
+          .describe(
+            "Include connected preflight with migration status and dependency health checks. Implies preflight and defaults to false.",
+          ),
+        connectTimeoutMs: z
+          .number()
+          .int()
+          .min(1)
+          .max(60 * 60 * 1_000)
+          .optional()
+          .describe(
+            "Maximum duration for migration status and each dependency health check in milliseconds. Defaults to 5000.",
+          ),
         timeoutMs: z
           .number()
           .int()
@@ -664,14 +677,16 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         jsonResult(
           await checkApp({
             cwd,
             preflight: input.preflight ?? false,
+            preflightConnect: input.preflightConnect ?? false,
+            connectTimeoutMs: input.connectTimeoutMs,
             scriptTimeoutMs: input.timeoutMs ?? defaultMcpCheckTimeoutMs,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
           }),
         ),
       ),
@@ -709,7 +724,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         jsonResult(
           await runDatabaseCommand({
@@ -717,7 +732,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
             cwd,
             captureOutput: true,
             maxOutputBytes: defaultDatabaseCommandMaxOutputBytes,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultDatabaseCommandTimeoutMs,
             dryRun: input.dryRun,
           }),
@@ -725,6 +740,43 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
       ),
   );
 
+  server.registerTool(
+    "db_status",
+    {
+      description:
+        "Inspect app-owned database migrations and return exactly the versioned beignet db status --json result. Exit state distinguishes current, pending, and failed inspection without mutating the database. Output is bounded, the complete child process tree is cancelled with the MCP request, and execution stops after the configured timeout.",
+      inputSchema: {
+        timeoutMs: z
+          .number()
+          .int()
+          .min(1_000)
+          .max(60 * 60 * 1_000)
+          .optional()
+          .describe(
+            "Maximum status duration in milliseconds. Defaults to 600000 (10 minutes).",
+          ),
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+      },
+    },
+    async (input, ctx) =>
+      safeToolResult(async () =>
+        jsonResult(
+          await runDatabaseStatus({
+            cwd,
+            captureOutput: true,
+            maxOutputBytes: defaultDatabaseCommandMaxOutputBytes,
+            signal: ctx.mcpReq.signal,
+            timeoutMs: input.timeoutMs ?? defaultDatabaseCommandTimeoutMs,
+          }),
+        ),
+      ),
+  );
+
   server.registerTool(
     "db_schema_sync",
     {
@@ -763,7 +815,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: false,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         jsonResult(
           await syncDatabaseSchema({
@@ -772,7 +824,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
             tables: input.tables,
             output: input.output,
             dryRun: input.dryRun,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
           }),
         ),
       ),
@@ -791,7 +843,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         operationalJsonResult(
           await runIsolatedOperationalCommand({
@@ -803,7 +855,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
               tenant: input.tenant,
               modulePath: input.module,
             },
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         ),
@@ -823,7 +875,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         operationalJsonResult(
           await runIsolatedOperationalCommand({
@@ -839,7 +891,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
               source: input.source,
               modulePath: input.module,
             },
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         ),
@@ -859,7 +911,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         operationalJsonResult(
           await runIsolatedOperationalCommand({
@@ -879,7 +931,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
                     id: input.id,
                     modulePath: input.module,
                   },
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         ),
@@ -899,7 +951,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () => {
         const request =
           input.operation === "drain"
@@ -936,7 +988,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
           await runIsolatedOperationalCommand({
             cwd,
             request,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         );