@beignet/cli 0.0.31 → 0.0.33

package/src/index.ts

@@ -15,12 +15,13 @@ import {
 } from "@stricli/core";
 import {
   type CompletionShell,
+  type CreateIntegrationName,
   completionShellChoices,
+  createIntegrationChoices,
   type DatabaseName,
   databaseChoices,
   databaseStartCommand,
   type IntegrationName,
-  integrationChoices,
   type MakeFeatureAddon,
   type MakeFeatureRecipe,
   makeFeatureAddonChoices,
@@ -29,6 +30,7 @@ import {
   type ProviderPresetName,
   packageManagerChoices,
   providerPresetChoices,
+  splitCreateIntegrations,
   type TemplateName,
   templateChoices,
 } from "./choices.js";
@@ -54,7 +56,7 @@ type CreateFlags = {
   api?: boolean;
   db?: DatabaseName;
   packageManager?: PackageManager;
-  integrations?: readonly IntegrationName[];
+  integrations?: readonly CreateIntegrationName[];
   yes?: boolean;
   force?: boolean;
   dryRun?: boolean;
@@ -108,6 +110,16 @@ type LintFlags = {
 type CheckFlags = {
   json?: boolean;
   fix?: boolean;
+  preflight?: boolean;
+  cwd?: string;
+};
+
+type PreflightFlags = {
+  json?: boolean;
+  envFile?: string;
+  envModule?: string;
+  connect?: boolean;
+  serverModule?: string;
   cwd?: string;
 };
 
@@ -131,7 +143,7 @@ const databaseSchemaTableChoices = [
   "outbox",
 ] as const satisfies readonly DatabaseSchemaTable[];
 
-type DbSchemaGenerateFlags = DbFlags & {
+type DbSchemaSyncFlags = DbFlags & {
   dialect?: DatabaseSchemaDialect;
   tables?: readonly DatabaseSchemaTable[];
   output?: string;
@@ -150,6 +162,60 @@ type OutboxDrainFlags = {
   batchSize?: number;
 };
 
+type OutboxMessageStatus = "pending" | "claimed" | "delivered" | "deadLettered";
+
+type OutboxMessageKind = "event" | "job";
+
+const outboxMessageStatusChoices = [
+  "pending",
+  "claimed",
+  "delivered",
+  "deadLettered",
+] as const satisfies readonly OutboxMessageStatus[];
+
+const outboxMessageKindChoices = [
+  "event",
+  "job",
+] as const satisfies readonly OutboxMessageKind[];
+
+type OutboxListFlags = {
+  json?: boolean;
+  module?: string;
+  status?: OutboxMessageStatus;
+  kind?: OutboxMessageKind;
+  name?: string;
+  limit?: number;
+};
+
+type OutboxShowFlags = {
+  json?: boolean;
+  module?: string;
+};
+
+type OutboxRequeueFlags = {
+  json?: boolean;
+  module?: string;
+  availableAt?: Date;
+  resetAttempts?: boolean;
+};
+
+type OutboxPurgeFlags = {
+  json?: boolean;
+  module?: string;
+  before?: Date;
+  all?: boolean;
+  limit?: number;
+  dryRun?: boolean;
+};
+
+type OutboxPruneFlags = {
+  json?: boolean;
+  module?: string;
+  before?: Date;
+  limit?: number;
+  dryRun?: boolean;
+};
+
 type ScheduleRunFlags = {
   json?: boolean;
   module?: string;
@@ -203,6 +269,13 @@ const parsePositiveInteger = (input: string): number => {
   }
   return value;
 };
+const parseDate = (input: string): Date => {
+  const value = new Date(input);
+  if (Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid date.");
+  }
+  return value;
+};
 
 const forceFlag = {
   kind: "boolean",
@@ -218,6 +291,13 @@ const dryRunFlag = {
   brief: "Preview generated changes without writing files.",
 } as const;
 
+const operationDryRunFlag = {
+  kind: "boolean",
+  optional: true,
+  withNegated: false,
+  brief: "Report matching records without deleting them.",
+} as const;
+
 const jsonFlag = {
   kind: "boolean",
   optional: true,
@@ -233,6 +313,14 @@ const parsedStringFlag = (brief: string) =>
     brief,
   }) as const;
 
+const parsedDateFlag = (brief: string) =>
+  ({
+    kind: "parsed",
+    parse: parseDate,
+    optional: true,
+    brief,
+  }) as const;
+
 const cwdFlag = parsedStringFlag(
   "App directory to inspect. Defaults to the current working directory.",
 );
@@ -278,14 +366,14 @@ const dbFlagParameters = {
   dryRun: dryRunFlag,
 } satisfies FlagParametersForType<DbFlags, CliContext>;
 
-const dbSchemaGenerateFlagParameters = {
+const dbSchemaSyncFlagParameters = {
   ...dbFlagParameters,
   dialect: {
     kind: "enum",
     values: databaseSchemaDialectChoices,
     optional: true,
     brief:
-      "Drizzle dialect to generate for. Inferred from server/providers.ts when omitted.",
+      "Drizzle dialect to sync. Inferred from server/providers.ts when omitted.",
   },
   tables: {
     kind: "enum",
@@ -293,12 +381,12 @@ const dbSchemaGenerateFlagParameters = {
     optional: true,
     variadic: ",",
     brief:
-      "Provider tables to generate as a comma-separated list. Defaults to audit,idempotency,outbox.",
+      "Provider tables to sync as a comma-separated list. Defaults to audit,idempotency,outbox.",
   },
   output: parsedStringFlag(
-    "Generated schema file. Defaults to infra/db/schema/beignet.ts.",
+    "Synced schema file. Defaults to infra/db/schema/beignet.ts.",
   ),
-} satisfies FlagParametersForType<DbSchemaGenerateFlags, CliContext>;
+} satisfies FlagParametersForType<DbSchemaSyncFlags, CliContext>;
 
 const taskRunFlagParameters = {
   json: jsonFlag,
@@ -324,6 +412,95 @@ const outboxDrainFlagParameters = {
   },
 } satisfies FlagParametersForType<OutboxDrainFlags, CliContext>;
 
+const outboxListFlagParameters = {
+  json: jsonFlag,
+  module: parsedStringFlag(
+    "Outbox registry module. Defaults to server/outbox.ts.",
+  ),
+  status: {
+    kind: "enum",
+    values: outboxMessageStatusChoices,
+    optional: true,
+    brief: "Filter by outbox message status.",
+  },
+  kind: {
+    kind: "enum",
+    values: outboxMessageKindChoices,
+    optional: true,
+    brief: "Filter by outbox message kind.",
+  },
+  name: parsedStringFlag("Filter by event or job name."),
+  limit: {
+    kind: "parsed",
+    parse: parsePositiveInteger,
+    optional: true,
+    brief: "Maximum messages to return. Defaults to 50.",
+  },
+} satisfies FlagParametersForType<OutboxListFlags, CliContext>;
+
+const outboxShowFlagParameters = {
+  json: jsonFlag,
+  module: parsedStringFlag(
+    "Outbox registry module. Defaults to server/outbox.ts.",
+  ),
+} satisfies FlagParametersForType<OutboxShowFlags, CliContext>;
+
+const outboxRequeueFlagParameters = {
+  json: jsonFlag,
+  module: parsedStringFlag(
+    "Outbox registry module. Defaults to server/outbox.ts.",
+  ),
+  availableAt: parsedDateFlag(
+    "Earliest timestamp the requeued message may be claimed. Defaults to now.",
+  ),
+  resetAttempts: {
+    kind: "boolean",
+    optional: true,
+    withNegated: false,
+    brief: "Reset attempts to zero before requeueing.",
+  },
+} satisfies FlagParametersForType<OutboxRequeueFlags, CliContext>;
+
+const outboxPurgeFlagParameters = {
+  json: jsonFlag,
+  module: parsedStringFlag(
+    "Outbox registry module. Defaults to server/outbox.ts.",
+  ),
+  before: parsedDateFlag(
+    "Only purge dead-lettered messages last updated before this timestamp.",
+  ),
+  all: {
+    kind: "boolean",
+    optional: true,
+    withNegated: false,
+    brief: "Purge every dead-lettered message when --before is omitted.",
+  },
+  limit: {
+    kind: "parsed",
+    parse: parsePositiveInteger,
+    optional: true,
+    brief: "Maximum messages to purge.",
+  },
+  dryRun: operationDryRunFlag,
+} satisfies FlagParametersForType<OutboxPurgeFlags, CliContext>;
+
+const outboxPruneFlagParameters = {
+  json: jsonFlag,
+  module: parsedStringFlag(
+    "Outbox registry module. Defaults to server/outbox.ts.",
+  ),
+  before: parsedDateFlag(
+    "Prune delivered messages delivered before this timestamp.",
+  ),
+  limit: {
+    kind: "parsed",
+    parse: parsePositiveInteger,
+    optional: true,
+    brief: "Maximum messages to prune.",
+  },
+  dryRun: operationDryRunFlag,
+} satisfies FlagParametersForType<OutboxPruneFlags, CliContext>;
+
 const scheduleRunFlagParameters = {
   json: jsonFlag,
   module: parsedStringFlag(
@@ -353,6 +530,17 @@ const namePositional = {
   ],
 } as const;
 
+const idPositional = {
+  kind: "tuple",
+  parameters: [
+    {
+      parse: parseString,
+      placeholder: "id",
+      brief: "Outbox message ID.",
+    },
+  ],
+} as const;
+
 const providerPresetPositional = {
   kind: "tuple",
   parameters: [
@@ -400,7 +588,11 @@ and a shadcn UI shell. Pass --api for an API-only scaffold without the
 UI shell, and --db to choose the database.
 
 Available databases: ${databaseChoices.join(", ")}
-Available integrations: ${integrationChoices.join(", ")}
+Available integrations: ${createIntegrationChoices.join(", ")}
+
+--integrations accepts the starter template integrations plus the full
+beignet providers add preset catalog; presets are applied to the scaffold
+with the same machinery as beignet providers add.
 
 Running create on an interactive terminal without selection flags opens a
 prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
@@ -433,10 +625,11 @@ prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
       },
       integrations: {
         kind: "enum",
-        values: integrationChoices,
+        values: createIntegrationChoices,
         optional: true,
         variadic: ",",
-        brief: "Add first-party integrations as a comma-separated list.",
+        brief:
+          "Add first-party integrations or provider presets as a comma-separated list.",
       },
       yes: {
         kind: "boolean",
@@ -504,7 +697,18 @@ prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
 
       const api = selections.api ?? false;
       const database = selections.db ?? "sqlite";
-      const integrations = uniqueValues([...(selections.integrations ?? [])]);
+      const { integrations, presets } = splitCreateIntegrations(
+        uniqueValues([...(selections.integrations ?? [])]),
+      );
+
+      let presetsNeedEnv = false;
+      if (presets.length > 0) {
+        const { assertCompatibleCreatePresets, providerPresetNeedsEnv } =
+          await import("./provider-add.js");
+        assertCompatibleCreatePresets(presets, integrations);
+        presetsNeedEnv = presets.some(providerPresetNeedsEnv);
+      }
+
       const result = await createProject({
         name: selections.directory,
         template: flags.template,
@@ -516,11 +720,24 @@ prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
         dryRun: Boolean(flags.dryRun),
       });
 
+      if (!flags.dryRun && presets.length > 0) {
+        const { addProviderPreset } = await import("./provider-add.js");
+        for (const preset of presets) {
+          await addProviderPreset({ name: preset, cwd: result.targetDir });
+        }
+      }
+
       writeOutput(
         this,
         flags.json
-          ? JSON.stringify(result, null, 2)
-          : nextSteps(result, { api, integrations, database }),
+          ? JSON.stringify({ ...result, providerPresets: presets }, null, 2)
+          : nextSteps(result, {
+              api,
+              integrations,
+              database,
+              presets,
+              presetsNeedEnv,
+            }),
       );
     };
   },
@@ -622,6 +839,12 @@ const checkCommand = buildCommand<CheckFlags, [], CliContext>({
         withNegated: false,
         brief: "Apply low-risk doctor fixes before checking.",
       },
+      preflight: {
+        kind: "boolean",
+        optional: true,
+        withNegated: false,
+        brief: "Append a beignet preflight step after doctor.",
+      },
       cwd: cwdFlag,
     } satisfies FlagParametersForType<CheckFlags, CliContext>,
   },
@@ -635,6 +858,7 @@ const checkCommand = buildCommand<CheckFlags, [], CliContext>({
       const result = await checkApp({
         cwd: flags.cwd,
         fix: flags.fix,
+        preflight: flags.preflight,
         color,
         ...(flags.json
           ? {}
@@ -656,6 +880,64 @@ const checkCommand = buildCommand<CheckFlags, [], CliContext>({
   },
 });
 
+const preflightCommand = buildCommand<PreflightFlags, [], CliContext>({
+  docs: {
+    brief: "Validate the deploy environment before shipping.",
+    fullDescription:
+      "Runtime production gate, unlike the static doctor checks: reads the actual environment the process runs with, verifies every env var installed provider manifests mark as required, flags values still matching .env.example or common placeholders on secret-like keys, and validates the app env schema by importing lib/env.ts. Run it in the deploy pipeline where production configuration is present. Exits 1 on any error finding.",
+  },
+  parameters: {
+    flags: {
+      json: jsonFlag,
+      envFile: parsedStringFlag(
+        "Dotenv-style file merged under the environment (existing env keys win) for local rehearsal.",
+      ),
+      envModule: parsedStringFlag(
+        "App env module validated by importing it. Defaults to lib/env.ts.",
+      ),
+      connect: {
+        kind: "boolean",
+        optional: true,
+        withNegated: false,
+        brief:
+          "Boot the app server and run every port's checkHealth(). Needs network and real credentials.",
+      },
+      serverModule: parsedStringFlag(
+        "Module exporting getServer, used by --connect. Defaults to server/index.ts.",
+      ),
+      cwd: cwdFlag,
+    } satisfies FlagParametersForType<PreflightFlags, CliContext>,
+  },
+  loader: async () => {
+    const { formatPreflight, runPreflight } = await import("./preflight.js");
+    const path = await import("node:path");
+
+    return async function runPreflightCommand(
+      this: CliContext,
+      flags: PreflightFlags,
+    ) {
+      const cwd = path.resolve(flags.cwd ?? process.cwd());
+      const result = await runPreflight({
+        cwd,
+        envFile: flags.envFile,
+        envModule: flags.envModule,
+        connect: flags.connect,
+        serverModule: flags.serverModule,
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify({ schemaVersion: 1, cwd, ...result }, null, 2)
+          : formatPreflight(result, cwd),
+      );
+      if (result.findings.some((finding) => finding.severity === "error")) {
+        this.process.exitCode = 1;
+      }
+    };
+  },
+});
+
 const lintCommand = buildCommand<LintFlags, [], CliContext>({
   docs: {
     brief: "Check Beignet dependency direction conventions.",
@@ -819,27 +1101,23 @@ function databaseCommand(command: DatabaseCommandName) {
   });
 }
 
-const dbSchemaGenerateCommand = buildCommand<
-  DbSchemaGenerateFlags,
-  [],
-  CliContext
->({
+const dbSchemaSyncCommand = buildCommand<DbSchemaSyncFlags, [], CliContext>({
   docs: {
-    brief: "Generate provider-owned Drizzle schema exports.",
+    brief: "Sync app-owned re-exports of Beignet provider tables.",
     fullDescription:
-      "Writes an app-owned schema file that re-exports Beignet provider tables, then updates the schema index. Run beignet db generate afterward to let the app's Drizzle Kit script create migrations.",
+      "Idempotently brings the app-owned schema file that re-exports Beignet provider tables in sync with the installed providers, then updates the schema index. Run beignet db generate afterward to let the app's Drizzle Kit script create migrations.",
   },
   parameters: {
-    flags: dbSchemaGenerateFlagParameters,
+    flags: dbSchemaSyncFlagParameters,
   },
   loader: async () => {
-    const { generateDatabaseSchema } = await import("./db.js");
+    const { syncDatabaseSchema } = await import("./db.js");
 
-    return async function runDbSchemaGenerate(
+    return async function runDbSchemaSync(
       this: CliContext,
-      flags: DbSchemaGenerateFlags,
+      flags: DbSchemaSyncFlags,
     ) {
-      const result = await generateDatabaseSchema({
+      const result = await syncDatabaseSchema({
         dialect: flags.dialect,
         tables: flags.tables,
         output: flags.output,
@@ -850,7 +1128,7 @@ const dbSchemaGenerateCommand = buildCommand<
         this,
         flags.json
           ? JSON.stringify(result, null, 2)
-          : databaseSchemaGenerateNextSteps(result),
+          : databaseSchemaSyncNextSteps(result),
       );
     };
   },
@@ -858,10 +1136,10 @@ const dbSchemaGenerateCommand = buildCommand<
 
 const dbSchemaRoutes = buildRouteMap({
   docs: {
-    brief: "Generate Beignet database schema helpers.",
+    brief: "Sync app-owned Beignet provider schema exports.",
   },
   routes: {
-    generate: dbSchemaGenerateCommand,
+    sync: dbSchemaSyncCommand,
   },
 });
 
@@ -946,12 +1224,178 @@ const outboxDrainCommand = buildCommand<OutboxDrainFlags, [], CliContext>({
   },
 });
 
+const outboxListCommand = buildCommand<OutboxListFlags, [], CliContext>({
+  docs: {
+    brief: "List outbox messages for operational inspection.",
+  },
+  parameters: {
+    flags: outboxListFlagParameters,
+  },
+  loader: async () => {
+    const { runOutboxList } = await import("./outbox.js");
+
+    return async function runList(this: CliContext, flags: OutboxListFlags) {
+      const result = await runOutboxList({
+        modulePath: flags.module,
+        status: flags.status,
+        kind: flags.kind,
+        name: flags.name,
+        limit: flags.limit,
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : outboxListNextSteps(result),
+      );
+    };
+  },
+});
+
+const outboxShowCommand = buildCommand<OutboxShowFlags, [string], CliContext>({
+  docs: {
+    brief: "Show one outbox message.",
+  },
+  parameters: {
+    flags: outboxShowFlagParameters,
+    positional: idPositional,
+  },
+  loader: async () => {
+    const { runOutboxShow } = await import("./outbox.js");
+
+    return async function runShow(
+      this: CliContext,
+      flags: OutboxShowFlags,
+      id: string,
+    ) {
+      const result = await runOutboxShow({
+        modulePath: flags.module,
+        id,
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : outboxShowNextSteps(result),
+      );
+    };
+  },
+});
+
+const outboxRequeueCommand = buildCommand<
+  OutboxRequeueFlags,
+  [string],
+  CliContext
+>({
+  docs: {
+    brief: "Return one dead-lettered outbox message to pending state.",
+  },
+  parameters: {
+    flags: outboxRequeueFlagParameters,
+    positional: idPositional,
+  },
+  loader: async () => {
+    const { runOutboxRequeue } = await import("./outbox.js");
+
+    return async function runRequeue(
+      this: CliContext,
+      flags: OutboxRequeueFlags,
+      id: string,
+    ) {
+      const result = await runOutboxRequeue({
+        modulePath: flags.module,
+        id,
+        availableAt: flags.availableAt,
+        resetAttempts: Boolean(flags.resetAttempts),
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : outboxRequeueNextSteps(result),
+      );
+    };
+  },
+});
+
+const outboxPurgeCommand = buildCommand<OutboxPurgeFlags, [], CliContext>({
+  docs: {
+    brief: "Delete dead-lettered outbox messages.",
+  },
+  parameters: {
+    flags: outboxPurgeFlagParameters,
+  },
+  loader: async () => {
+    const { runOutboxPurge } = await import("./outbox.js");
+
+    return async function runPurge(this: CliContext, flags: OutboxPurgeFlags) {
+      const result = await runOutboxPurge({
+        modulePath: flags.module,
+        before: flags.before,
+        all: Boolean(flags.all),
+        limit: flags.limit,
+        dryRun: Boolean(flags.dryRun),
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : outboxDeleteNextSteps(
+              "Purged dead-lettered outbox messages",
+              result,
+            ),
+      );
+    };
+  },
+});
+
+const outboxPruneCommand = buildCommand<OutboxPruneFlags, [], CliContext>({
+  docs: {
+    brief: "Delete delivered outbox messages older than a retention cutoff.",
+  },
+  parameters: {
+    flags: outboxPruneFlagParameters,
+  },
+  loader: async () => {
+    const { runOutboxPrune } = await import("./outbox.js");
+
+    return async function runPrune(this: CliContext, flags: OutboxPruneFlags) {
+      if (!flags.before) {
+        throw new Error("Pass --before <date> to prune delivered messages.");
+      }
+
+      const result = await runOutboxPrune({
+        modulePath: flags.module,
+        before: flags.before,
+        limit: flags.limit,
+        dryRun: Boolean(flags.dryRun),
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : outboxDeleteNextSteps("Pruned delivered outbox messages", result),
+      );
+    };
+  },
+});
+
 const outboxRoutes = buildRouteMap({
   docs: {
     brief: "Run Beignet outbox operations.",
   },
   routes: {
     drain: outboxDrainCommand,
+    list: outboxListCommand,
+    show: outboxShowCommand,
+    requeue: outboxRequeueCommand,
+    purge: outboxPurgeCommand,
+    prune: outboxPruneCommand,
   },
 });
 
@@ -1557,6 +2001,7 @@ Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     make: makeRoutes,
     mcp: mcpCommand,
     outbox: outboxRoutes,
+    preflight: preflightCommand,
     providers: providerRoutes,
     routes: routesCommand,
     schedule: scheduleRoutes,
@@ -1626,7 +2071,7 @@ type DatabaseCommandNextStepsResult = {
   dryRun: boolean;
 };
 
-type DatabaseSchemaGenerateNextStepsResult = {
+type DatabaseSchemaSyncNextStepsResult = {
   cwd: string;
   dialect: DatabaseSchemaDialect;
   tables: DatabaseSchemaTable[];
@@ -1655,6 +2100,37 @@ type OutboxDrainNextStepsResult = {
   };
 };
 
+type OutboxAdminMessage = {
+  id: string;
+  kind: string;
+  name: string;
+  status: string;
+  attempts: number;
+  maxAttempts: number;
+  availableAt: Date | string;
+  deliveredAt: Date | string | null;
+  updatedAt: Date | string;
+  lastError: { name?: string; message: string } | null;
+};
+
+type OutboxListNextStepsResult = {
+  durationMs: number;
+  messages: readonly OutboxAdminMessage[];
+  count: number;
+};
+
+type OutboxMessageNextStepsResult = {
+  durationMs: number;
+  message: OutboxAdminMessage;
+};
+
+type OutboxDeleteNextStepsResult = {
+  durationMs: number;
+  dryRun: boolean;
+  matched: number;
+  deleted: number;
+};
+
 type ScheduleRunNextStepsResult = {
   name: string;
   durationMs: number;
@@ -1691,6 +2167,69 @@ Result:
   deadLettered: ${result.result.deadLettered}`;
 }
 
+function formatOutboxDate(value: Date | string | null | undefined): string {
+  if (!value) return "none";
+  return value instanceof Date ? value.toISOString() : value;
+}
+
+function outboxMessageLine(message: OutboxAdminMessage): string {
+  return `${message.id}  ${message.status}  ${message.kind}  ${message.name}  attempts ${message.attempts}/${message.maxAttempts}  updated ${formatOutboxDate(message.updatedAt)}`;
+}
+
+function outboxListNextSteps(result: OutboxListNextStepsResult): string {
+  const messages =
+    result.messages.length === 0
+      ? "  none"
+      : result.messages
+          .map((message) => `  ${outboxMessageLine(message)}`)
+          .join("\n");
+
+  return `Listed ${result.messages.length} of ${result.count} matching outbox messages in ${result.durationMs}ms
+
+Messages:
+${messages}`;
+}
+
+function outboxShowNextSteps(result: OutboxMessageNextStepsResult): string {
+  const message = result.message;
+  const error = message.lastError
+    ? `${message.lastError.name ?? "Error"}: ${message.lastError.message}`
+    : "none";
+
+  return `Outbox message ${message.id} (${message.status}) in ${result.durationMs}ms
+
+Message:
+  kind: ${message.kind}
+  name: ${message.name}
+  attempts: ${message.attempts}/${message.maxAttempts}
+  availableAt: ${formatOutboxDate(message.availableAt)}
+  deliveredAt: ${formatOutboxDate(message.deliveredAt)}
+  updatedAt: ${formatOutboxDate(message.updatedAt)}
+  lastError: ${error}`;
+}
+
+function outboxRequeueNextSteps(result: OutboxMessageNextStepsResult): string {
+  return `Requeued outbox message ${result.message.id} in ${result.durationMs}ms
+
+Message:
+  status: ${result.message.status}
+  attempts: ${result.message.attempts}/${result.message.maxAttempts}
+  availableAt: ${formatOutboxDate(result.message.availableAt)}`;
+}
+
+function outboxDeleteNextSteps(
+  label: string,
+  result: OutboxDeleteNextStepsResult,
+): string {
+  const action = result.dryRun ? "Would delete" : "Deleted";
+
+  return `${label} in ${result.durationMs}ms
+
+Result:
+  matched: ${result.matched}
+  ${action}: ${result.deleted}`;
+}
+
 function scheduleRunNextSteps(result: ScheduleRunNextStepsResult): string {
   return `Ran schedule ${result.name} in ${result.durationMs}ms
 
@@ -1708,15 +2247,23 @@ function nextSteps(
     api?: boolean;
     integrations?: readonly IntegrationName[];
     database?: DatabaseName;
+    presets?: readonly ProviderPresetName[];
+    presetsNeedEnv?: boolean;
   } = {},
 ): string {
   if (result.dryRun) {
     const plannedFiles = result.files.map((file) => `  ${file}`).join("\n");
+    const plannedPresets =
+      options.presets && options.presets.length > 0
+        ? `\n\nProvider presets applied after scaffold (skipped in dry run):\n${options.presets
+            .map((preset) => `  ${preset}`)
+            .join("\n")}`
+        : "";
 
     return `Would create ${result.name} at ${result.targetDir}
 
 Planned files:
-${plannedFiles}`;
+${plannedFiles}${plannedPresets}`;
   }
 
   const pm = result.packageManager;
@@ -1725,9 +2272,17 @@ ${plannedFiles}`;
   const envRequiredIntegrations =
     options.integrations?.filter(isEnvRequiredProviderIntegration) ?? [];
   const envStep =
-    envRequiredIntegrations.length > 0
+    envRequiredIntegrations.length > 0 || options.presetsNeedEnv
       ? "  Fill .env.local for selected provider integrations before starting the app.\n"
       : "";
+  const presetSection =
+    options.presets && options.presets.length > 0
+      ? `\nProvider presets applied:\n${options.presets
+          .map((preset) => `  ${preset}`)
+          .join(
+            "\n",
+          )}\n  See docs/integrations.md for setup notes and follow-up steps.\n`
+      : "";
   const openStep = options.api
     ? "  open http://localhost:3000 for the API landing page"
     : "  open http://localhost:3000/sign-up";
@@ -1742,7 +2297,7 @@ ${plannedFiles}`;
     : "";
 
   return `Created ${result.name} at ${result.targetDir}
-
+${presetSection}
 Next steps:
   cd ${result.targetDir}
   ${pm} install
@@ -1858,15 +2413,15 @@ Command:
   ${command}`;
 }
 
-function databaseSchemaGenerateNextSteps(
-  result: DatabaseSchemaGenerateNextStepsResult,
+function databaseSchemaSyncNextSteps(
+  result: DatabaseSchemaSyncNextStepsResult,
 ): string {
   const { changedFiles, skippedFiles } = changedFileLines({
     createdFiles: result.createdFiles,
     updatedFiles: result.updatedFiles,
     skippedFiles: result.skippedFiles,
   });
-  const prefix = result.dryRun ? "Would generate" : "Generated";
+  const prefix = result.dryRun ? "Would sync" : "Synced";
   const tables = result.tables.join(", ");
 
   return `${prefix} Beignet ${result.dialect} database schema (${tables}) in ${result.cwd}
@@ -1984,7 +2539,7 @@ function makeOutboxNextSteps(result: MakeNextStepsResult): string {
 function makeListenerNextSteps(result: MakeNextStepsResult): string {
   return makeNextSteps(result, "listener", [
     "Replace the starter handler with the event reaction.",
-    "Register the listener collection from infrastructure startup.",
+    "Register the listener collection from server provider wiring.",
   ]);
 }