@beignet/cli 0.0.41 → 0.0.43

package/src/lib.ts

@@ -27,7 +27,25 @@ export {
 } from "./app-map.js";
 export type { CreateOptions } from "./create.js";
 export { createProject } from "./create.js";
-export { runDatabaseCommand } from "./db.js";
+export type {
+  DatabaseCommand,
+  DatabaseSchemaDialect,
+  DatabaseSchemaTable,
+  RunDatabaseCommandOptions,
+  RunDatabaseCommandResult,
+  SyncDatabaseSchemaOptions,
+  SyncDatabaseSchemaResult,
+} from "./db.js";
+export { runDatabaseCommand, syncDatabaseSchema } from "./db.js";
+export type {
+  DoctorFixApplyResult,
+  DoctorFixFileChange,
+  DoctorFixOperation,
+  DoctorFixOperationId,
+  DoctorFixPlan,
+  InspectFix,
+} from "./doctor-fixes.js";
+export { doctorFixOperationIds } from "./doctor-fixes.js";
 export type {
   ExplainAppOptions,
   ExplainAppResult,
@@ -46,12 +64,21 @@ export {
   formatExplain,
 } from "./explain.js";
 export { main } from "./index.js";
+export type {
+  ApplyDoctorFixPlanOptions,
+  DoctorFixInspectionResult,
+  DoctorFixPlanResult,
+} from "./inspect.js";
 export {
   applyDoctorFixes,
+  applyDoctorFixPlan,
   formatDoctor,
+  formatDoctorFixPlan,
+  formatDoctorFixPlanGithub,
   formatDoctorGithub,
   formatRoutes,
   inspectApp,
+  planDoctorFixes,
 } from "./inspect.js";
 export { formatLint, formatLintGithub, lintApp } from "./lint.js";
 export type { MakeFeatureAddon, MakeFeatureRecipe } from "./make.js";

package/src/make/inbox.ts

@@ -1437,17 +1437,17 @@ export const inboxNotifications = ${dialect.tableFunction}(
 \t\treadAt: ${column("read_at")},
 \t\tcreatedAt: ${column("created_at")}.notNull(),
 \t},
-\t(table) => ({
-\t\tunreadIdx: index("inbox_notifications_unread_idx").on(
+\t(table) => [
+\t\tindex("inbox_notifications_unread_idx").on(
 \t\t\ttable.userId,
 \t\t\ttable.readAt,
 \t\t),
-\t\tcursorIdx: index("inbox_notifications_cursor_idx").on(
+\t\tindex("inbox_notifications_cursor_idx").on(
 \t\t\ttable.userId,
 \t\t\ttable.createdAt,
 \t\t\ttable.id,
 \t\t),
-\t}),
+\t],
 );
 `;
 }

package/src/make/payments.ts

@@ -680,11 +680,11 @@ export const createCheckoutSessionInputSchema = z.object({
 
 export const createCheckoutSessionOutputSchema = z.object({
 \tsessionId: z.string(),
-\turl: z.string().url(),
+\turl: z.url(),
 });
 
 export const createBillingPortalSessionOutputSchema = z.object({
-\turl: z.string().url(),
+\turl: z.url(),
 });
 
 export const billingStatusOutputSchema = z.object({
@@ -1800,14 +1800,14 @@ export const billingAccounts = ${dialect.tableFunction}(
 \t\tlastEventId: ${idColumn("last_event_id")},
 \t\tupdatedAt: ${idColumn("updated_at")}.notNull(),
 \t},
-\t(table) => ({
-\t\tproviderCustomerUnique: uniqueIndex(
+\t(table) => [
+\t\tuniqueIndex(
 \t\t\t"billing_accounts_provider_customer_unique",
 \t\t).on(table.provider, table.customerId),
-\t\tproviderSubscriptionUnique: uniqueIndex(
+\t\tuniqueIndex(
 \t\t\t"billing_accounts_provider_subscription_unique",
 \t\t).on(table.provider, table.subscriptionId),
-\t}),
+\t],
 );
 `;
 }

package/src/make/shared.ts

@@ -18,7 +18,7 @@ import {
 import {
   currentGeneratedPackageScripts,
   externalVersions,
-  legacyGeneratedPackageScripts,
+  isLegacyGeneratedPackageScript,
 } from "../templates/shared.js";
 
 export type MakeResult = {
@@ -1096,7 +1096,7 @@ export async function updatePackageScripts(
   for (const [name, command] of Object.entries(scripts)) {
     if (
       !packageJson.scripts[name] ||
-      packageJson.scripts[name] === legacyGeneratedPackageScripts[name]
+      isLegacyGeneratedPackageScript(name, packageJson.scripts[name])
     ) {
       packageJson.scripts[name] = command;
     }
@@ -1162,7 +1162,7 @@ function updateGeneratedPackageScripts(scripts: Record<string, string>): void {
     currentGeneratedPackageScripts,
   )) {
     if (
-      scripts[name] === legacyGeneratedPackageScripts[name] ||
+      isLegacyGeneratedPackageScript(name, scripts[name]) ||
       (name === "test" && !scripts[name])
     ) {
       scripts[name] = command;

package/src/make/tenancy.ts

@@ -952,7 +952,7 @@ export const workspaceMemberWithUserSchema = workspaceMemberSchema.extend({
 export const workspaceInviteSchema = z.object({
 \tid: z.string().min(1),
 \tworkspaceId: z.string().min(1),
-\temail: z.string().email(),
+\temail: z.email(),
 \trole: workspaceRoleSchema,
 \ttoken: z.string().min(1),
 \tinvitedByUserId: z.string().min(1),
@@ -1019,7 +1019,7 @@ export const listInvitesOutputSchema = z.object({
 });
 
 export const createInviteInputSchema = z.object({
-\temail: z.string().email(),
+\temail: z.email(),
 \trole: workspaceRoleSchema.default("member"),
 });
 
@@ -2005,7 +2005,7 @@ const invitePayloadSchema = z.object({
 \tinviteId: z.string().min(1),
 \tworkspaceId: z.string().min(1),
 \tworkspaceName: z.string().min(1),
-\temail: z.string().email(),
+\temail: z.email(),
 \trole: z.enum(["admin", "member"]),
 \ttoken: z.string().min(1),
 \tinvitedByName: z.string().optional(),
@@ -3242,9 +3242,7 @@ export const workspaces = ${dialect.tableFunction}(
 \t\tcreatedAt: ${column("created_at")}.notNull(),
 \t\tupdatedAt: ${column("updated_at")}.notNull(),
 \t},
-\t(table) => ({
-\t\tslugUnique: uniqueIndex("workspaces_slug_unique").on(table.slug),
-\t}),
+\t(table) => [uniqueIndex("workspaces_slug_unique").on(table.slug)],
 );
 
 export const workspaceMembers = ${dialect.tableFunction}(
@@ -3256,12 +3254,12 @@ export const workspaceMembers = ${dialect.tableFunction}(
 \t\trole: ${column("role")}.$type<WorkspaceRole>().notNull(),
 \t\tjoinedAt: ${column("joined_at")}.notNull(),
 \t},
-\t(table) => ({
-\t\tworkspaceUserUnique: uniqueIndex(
+\t(table) => [
+\t\tuniqueIndex(
 \t\t\t"workspace_members_workspace_user_unique",
 \t\t).on(table.workspaceId, table.userId),
-\t\tuserIdx: index("workspace_members_user_idx").on(table.userId),
-\t}),
+\t\tindex("workspace_members_user_idx").on(table.userId),
+\t],
 );
 
 export const workspaceInvites = ${dialect.tableFunction}(
@@ -3278,15 +3276,15 @@ export const workspaceInvites = ${dialect.tableFunction}(
 \t\tacceptedAt: ${column("accepted_at")},
 \t\tcreatedAt: ${column("created_at")}.notNull(),
 \t},
-\t(table) => ({
-\t\ttokenUnique: uniqueIndex("workspace_invites_token_unique").on(
+\t(table) => [
+\t\tuniqueIndex("workspace_invites_token_unique").on(
 \t\t\ttable.token,
 \t\t),
-\t\tworkspaceStatusIdx: index("workspace_invites_workspace_status_idx").on(
+\t\tindex("workspace_invites_workspace_status_idx").on(
 \t\t\ttable.workspaceId,
 \t\t\ttable.status,
 \t\t),
-\t}),
+\t],
 );
 `;
 }

package/src/make.ts

@@ -1575,7 +1575,8 @@ const cronSecretEnvEntry = `\t\tCRON_SECRET: z.string().min(1).optional(),`;
 
 // The literal APP_URL line every generated lib/env.ts ships with. CRON_SECRET
 // slots in directly below it, matching the documented env shape.
-const cronSecretEnvAnchor = `\t\tAPP_URL: z.string().url().default("http://localhost:3000"),`;
+const cronSecretEnvAnchor = `\t\tAPP_URL: z.url().default("http://localhost:3000"),`;
+const legacyCronSecretEnvAnchor = `\t\tAPP_URL: z.string().url().default("http://localhost:3000"),`;
 
 type CronSecretWiringPlan = {
   files: Array<GeneratedFile & { result: "created" | "updated" }>;
@@ -1596,10 +1597,15 @@ async function planCronSecretWiring(
       `Could not find the generated env file ${cronSecretEnvFile}. ${manualInstruction}`,
     );
   }
+  const envAnchor = envSource.includes(cronSecretEnvAnchor)
+    ? cronSecretEnvAnchor
+    : envSource.includes(legacyCronSecretEnvAnchor)
+      ? legacyCronSecretEnvAnchor
+      : undefined;
 
   if (/\bCRON_SECRET\b/.test(envSource)) {
     plan.skippedFiles.push(cronSecretEnvFile);
-  } else if (!envSource.includes(cronSecretEnvAnchor)) {
+  } else if (envAnchor === undefined) {
     throw new Error(
       `Could not find the generated APP_URL server entry in ${cronSecretEnvFile}. ${manualInstruction}`,
     );
@@ -1607,8 +1613,8 @@ async function planCronSecretWiring(
     plan.files.push({
       path: cronSecretEnvFile,
       content: envSource.replace(
-        cronSecretEnvAnchor,
-        `${cronSecretEnvAnchor}\n${cronSecretEnvEntry}`,
+        envAnchor,
+        `${envAnchor}\n${cronSecretEnvEntry}`,
       ),
       result: "updated",
     });
@@ -2218,6 +2224,10 @@ export async function makeUpload(
       dryRun: true,
     },
   );
+  // Validate central registration before generating feature files or applying
+  // provider wiring. Customized routes require an explicit manual edit rather
+  // than a successful-looking partial generation.
+  await updateUploadRoute(targetDir, names, config, { dryRun: true });
 
   const result = await makeFeatureArtifact({
     targetDir,
@@ -3716,7 +3726,9 @@ async function updateUploadRoute(
 
   const registry = defineUploadsInitializerInfo(next, "uploadRegistry");
   if (!registry) {
-    return "skipped";
+    throw new Error(
+      `Cannot register ${registryName} in ${file}: expected an uploadRegistry initialized with defineUploads({ ... }). Restore that registry shape or add ${registryKey}: ${registryName} manually before rerunning beignet make upload.`,
+    );
   }
   if (!new RegExp(`\\b${registryKey}\\s*:`).test(registry.text)) {
     next = `${next.slice(0, registry.end)}\t${registryKey}: ${registryName},\n${next.slice(
@@ -3912,7 +3924,7 @@ function schemasFile(
   return `import { z } from "zod";
 
 export const ${names.singularPascal}Schema = z.object({
-	id: z.string().uuid(),
+	id: z.uuid(),
 ${options.tenantScoped ? `\ttenantId: z.string().min(1),\n` : ""}	name: z.string().min(1),
 	version: z.number().int().min(1),
 	createdAt: z.string().datetime(),
@@ -3926,7 +3938,7 @@ const ${names.singularPascal}CursorPayloadSchema = z.object({
 	sortBy: ${names.singularPascal}SortBySchema,
 	sortDirection: ${names.singularPascal}SortDirectionSchema,
 	sortValue: z.string(),
-	id: z.string().uuid(),
+	id: z.uuid(),
 });
 
 export type ${names.singularPascal}SortBy = z.infer<
@@ -4019,7 +4031,7 @@ ${
   mode === "resource"
     ? `
 export const ${names.singularPascal}IdInputSchema = z.object({
-	id: z.string().uuid(),
+	id: z.uuid(),
 });
 
 export const Update${names.singularPascal}BodySchema = z.object({
@@ -4479,16 +4491,16 @@ export const outboxMessages = mysqlTable(
 \t\tcreatedAt: varchar("created_at", { length: 32 }).notNull(),
 \t\tupdatedAt: varchar("updated_at", { length: 32 }).notNull(),
 \t},
-\t(table) => ({
-\t\tavailableIdx: index("outbox_messages_available_idx").on(
+\t(table) => [
+\t\tindex("outbox_messages_available_idx").on(
 \t\t\ttable.status,
 \t\t\ttable.availableAt,
 \t\t),
-\t\tlockedIdx: index("outbox_messages_locked_idx").on(
+\t\tindex("outbox_messages_locked_idx").on(
 \t\t\ttable.status,
 \t\t\ttable.lockedUntil,
 \t\t),
-\t}),
+\t],
 );
 `;
   }
@@ -4515,16 +4527,16 @@ export const outboxMessages = ${dialect.tableFunction}(
 \t\tcreatedAt: text("created_at").notNull(),
 \t\tupdatedAt: text("updated_at").notNull(),
 \t},
-\t(table) => ({
-\t\tavailableIdx: index("outbox_messages_available_idx").on(
+\t(table) => [
+\t\tindex("outbox_messages_available_idx").on(
 \t\t\ttable.status,
 \t\t\ttable.availableAt,
 \t\t),
-\t\tlockedIdx: index("outbox_messages_locked_idx").on(
+\t\tindex("outbox_messages_locked_idx").on(
 \t\t\ttable.status,
 \t\t\ttable.lockedUntil,
 \t\t),
-\t}),
+\t],
 );
 `;
 }
@@ -4912,7 +4924,7 @@ const ${names.pluralCamel} = defineContractGroup()
 	});
 
 export const ${names.singularCamel}Schema = z.object({
-	id: z.string().uuid(),
+	id: z.uuid(),
 	name: z.string().min(1),
 });
 
@@ -5121,19 +5133,19 @@ import { z } from "zod";
 
 export const ${names.singularPascal}Created = defineEvent("${names.pluralCamel}.created", {
 	payload: z.object({
-		id: z.string().uuid(),
+		id: z.uuid(),
 	}),
 });
 
 export const ${names.singularPascal}Updated = defineEvent("${names.pluralCamel}.updated", {
 	payload: z.object({
-		id: z.string().uuid(),
+		id: z.uuid(),
 	}),
 });
 
 export const ${names.singularPascal}Deleted = defineEvent("${names.pluralCamel}.deleted", {
 	payload: z.object({
-		id: z.string().uuid(),
+		id: z.uuid(),
 	}),
 });
 
@@ -5209,7 +5221,7 @@ function eventFile(names: EventNames): string {
 import { z } from "zod";
 
 export const ${names.payloadSchemaName} = z.object({
-\tid: z.string().uuid(),
+\tid: z.uuid(),
 });
 
 export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
@@ -5226,7 +5238,7 @@ import { z } from "zod";
 import { defineJob } from "${aliasModule(config.paths.jobsBuilder)}";
 
 export const ${names.payloadSchemaName} = z.object({
-\tid: z.string().uuid(),
+\tid: z.uuid(),
 });
 
 export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
@@ -5317,9 +5329,9 @@ import { z } from "zod";
 import { defineNotification } from "${aliasModule(config.paths.notificationsBuilder)}";
 
 export const ${names.payloadSchemaName} = z.object({
-\tid: z.string().uuid(),
+\tid: z.uuid(),
 \tsubject: z.string(),
-\trecipientEmail: z.string().email(),
+\trecipientEmail: z.email(),
 });
 
 export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;

package/src/mcp.ts

@@ -5,9 +5,28 @@ import { z } from "zod";
 import { mapApp, projectAppMap } from "./app-map.js";
 import { appMapNodeKinds } from "./app-map-schema.js";
 import { checkApp } from "./check.js";
-import { type ProviderPresetName, providerPresetChoices } from "./choices.js";
+import {
+  databaseCommandChoices,
+  databaseSchemaDialectChoices,
+  databaseSchemaTableChoices,
+  doctorFixOperationIds,
+  type ProviderPresetName,
+  providerPresetChoices,
+} from "./choices.js";
+import {
+  defaultDatabaseCommandMaxOutputBytes,
+  defaultDatabaseCommandTimeoutMs,
+  runDatabaseCommand,
+  syncDatabaseSchema,
+} from "./db.js";
 import { explainApp, explainTargetKinds } from "./explain.js";
-import { applyDoctorFixes, inspectApp } from "./inspect.js";
+import {
+  applyDoctorFixesWithResult,
+  applyDoctorFixPlan,
+  createDoctorFixInspectionResult,
+  inspectApp,
+  planDoctorFixes,
+} from "./inspect.js";
 import { lintApp } from "./lint.js";
 import {
   type MakeResourceResult,
@@ -379,14 +398,14 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     "explain",
     {
       description:
-        "Explain one mapped Beignet feature, route, provider, or diagnostic using deterministic source evidence. Returns relationships, relevant conventions, findings, suggested files, and follow-up commands without changing the app.",
+        "Explain one mapped Beignet concept or diagnostic using deterministic source evidence. Supports every app-map node kind and returns relationships, relevant conventions, findings, suggested files, and follow-up commands without changing the app.",
       inputSchema: {
         kind: z.enum(explainTargetKinds).describe("Mapped concept to explain."),
         target: z
           .string()
           .min(1)
           .describe(
-            "Feature name, METHOD /path route, provider package or port name, or diagnostic code.",
+            "Stable ID, runtime name, declaration name, source selector, applicable concept alias, or diagnostic code.",
           ),
       },
       annotations: { readOnlyHint: true },
@@ -441,6 +460,107 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
       ),
   );
 
+  server.registerTool(
+    "db",
+    {
+      description:
+        "Run one app-owned database lifecycle command and return exactly the versioned beignet db <command> --json result. Supports generate, migrate, seed, and reset; captures a bounded output tail, stops after the configured timeout, and cancels the complete child process tree with the MCP request. Dry runs validate prerequisites and report the command without executing it.",
+      inputSchema: {
+        command: z
+          .enum(databaseCommandChoices)
+          .describe("Database lifecycle command to run."),
+        dryRun: z
+          .boolean()
+          .optional()
+          .describe(
+            "Validate prerequisites and report the app-owned script without executing it. This does not simulate SQL or data changes.",
+          ),
+        timeoutMs: z
+          .number()
+          .int()
+          .min(1_000)
+          .max(60 * 60 * 1_000)
+          .optional()
+          .describe(
+            "Maximum command duration in milliseconds. Defaults to 600000 (10 minutes).",
+          ),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+    },
+    async (input, extra) =>
+      safeToolResult(async () =>
+        jsonResult(
+          await runDatabaseCommand({
+            command: input.command,
+            cwd,
+            captureOutput: true,
+            maxOutputBytes: defaultDatabaseCommandMaxOutputBytes,
+            signal: extra.signal,
+            timeoutMs: input.timeoutMs ?? defaultDatabaseCommandTimeoutMs,
+            dryRun: input.dryRun,
+          }),
+        ),
+      ),
+  );
+
+  server.registerTool(
+    "db_schema_sync",
+    {
+      description:
+        "Idempotently sync app-owned Drizzle schema re-exports for Beignet provider tables and return exactly the versioned beignet db schema sync --json result. Supports dry-run planning and never generates or applies SQL migrations.",
+      inputSchema: {
+        dialect: z
+          .enum(databaseSchemaDialectChoices)
+          .optional()
+          .describe(
+            "Drizzle dialect. Inferred from registered providers or drizzle.config.* when omitted.",
+          ),
+        tables: z
+          .array(z.enum(databaseSchemaTableChoices))
+          .min(1)
+          .optional()
+          .describe(
+            "Beignet provider tables to re-export. Defaults to audit, idempotency, and outbox.",
+          ),
+        output: z
+          .string()
+          .min(1)
+          .optional()
+          .describe(
+            "App-relative schema output. Defaults to infra/db/schema/beignet.ts.",
+          ),
+        dryRun: z
+          .boolean()
+          .optional()
+          .describe("Preview schema source changes without writing files."),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (input, extra) =>
+      safeToolResult(async () =>
+        jsonResult(
+          await syncDatabaseSchema({
+            cwd,
+            dialect: input.dialect,
+            tables: input.tables,
+            output: input.output,
+            dryRun: input.dryRun,
+            signal: extra.signal,
+          }),
+        ),
+      ),
+  );
+
   server.registerTool(
     "routes",
     {
@@ -469,7 +589,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     "doctor",
     {
       description:
-        "Check app wiring and Beignet conventions, returning diagnostics, the detected convention, and applied fixes as JSON. Strict mode (the default) is the CI bar and includes CI-oriented warnings. Read-only; use doctor_fix to repair registration drift.",
+        "Check app wiring and Beignet conventions, returning diagnostics and the detected convention as JSON. Strict mode (the default) is the CI bar and includes CI-oriented warnings. Read-only; use doctor_fix_plan before a guarded doctor_fix repair.",
       inputSchema: {
         strict: z
           .boolean()
@@ -489,28 +609,82 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
       }),
   );
 
+  server.registerTool(
+    "doctor_fix_plan",
+    {
+      description:
+        "Plan every currently available low-risk doctor repair without changing files. Returns stable operation IDs, exact unified patches, file hashes, and a plan ID for guarded doctor_fix application.",
+      inputSchema: {
+        strict: z
+          .boolean()
+          .optional()
+          .describe("Include CI-oriented warnings. Defaults to true."),
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (input) =>
+      safeToolResult(async () => {
+        return jsonResult(
+          await planDoctorFixes({ cwd, strict: input.strict ?? true }),
+        );
+      }),
+  );
+
   server.registerTool(
     "doctor_fix",
     {
       description:
-        "Apply low-risk doctor fixes, then re-check the app. Repairs route-group, schedule, task, outbox, and listener registration drift. Returns applied fixes and remaining diagnostics as JSON.",
+        "Apply low-risk doctor repairs, then re-check the app. With no planId, preserves the legacy apply-all behavior. Pass the planId returned by doctor_fix_plan for stale-file protection, optionally with fixIds to select repair operations.",
       inputSchema: {
         strict: z
           .boolean()
           .optional()
           .describe("Include CI-oriented warnings. Defaults to true."),
+        planId: z
+          .string()
+          .min(1)
+          .optional()
+          .describe("Plan ID returned by doctor_fix_plan."),
+        fixIds: z
+          .array(z.enum(doctorFixOperationIds))
+          .min(1)
+          .optional()
+          .describe("Repair operation IDs to apply. Requires planId."),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
       },
     },
     async (input) =>
       safeToolResult(async () => {
         const strict = input.strict ?? true;
-        const fixes = await applyDoctorFixes({ cwd, strict });
-        const result = await inspectApp({ cwd, strict });
-        return jsonResult({
-          diagnostics: result.diagnostics,
-          convention: result.convention,
-          fixes,
-        });
+        if (input.fixIds && !input.planId) {
+          throw new Error(
+            "doctor_fix fixIds require planId from doctor_fix_plan.",
+          );
+        }
+        const applied = input.planId
+          ? await applyDoctorFixPlan({
+              cwd,
+              strict,
+              planId: input.planId,
+              ...(input.fixIds ? { fixIds: input.fixIds } : {}),
+            })
+          : await applyDoctorFixesWithResult({ cwd, strict });
+        return jsonResult(
+          createDoctorFixInspectionResult(
+            await inspectApp({ cwd, strict }),
+            applied,
+          ),
+        );
       }),
   );