@prisma-next/cli 0.10.0-dev.9 → 0.11.0

package/src/commands/migration-log.ts

@@ -8,7 +8,7 @@ import { Command } from 'commander';
 import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import {
-  type CliStructuredError,
+  CliStructuredError,
   errorDatabaseConnectionRequired,
   errorDriverRequired,
   errorUnexpected,
@@ -26,9 +26,9 @@ import {
 } from '../utils/command-helpers';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 
 interface MigrationLogOptions extends CommonCommandOptions {
   readonly db?: string;
@@ -159,6 +159,7 @@ async function executeMigrationLogCommand(
       summary: `${entries.length} migration(s) applied`,
     });
   } catch (error) {
+    if (CliStructuredError.is(error)) return notOk(error);
     if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
     return notOk(
       errorUnexpected(error instanceof Error ? error.message : String(error), {
@@ -192,8 +193,8 @@ export function createMigrationLogCommand(): Command {
     .option('--db <url>', 'Database connection string')
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (options: MigrationLogOptions) => {
-      const flags = parseGlobalFlags(options);
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const flags = parseGlobalFlagsOrExit(options);
+      const ui = createTerminalUI(flags);
       const result = await executeMigrationLogCommand(options, flags, ui);
       const exitCode = handleResult(result, flags, ui, (logResult) => {
         if (flags.json) {

package/src/commands/migration-new.ts

@@ -49,9 +49,9 @@ import {
 import { formatStyledHeader } from '../utils/formatters/styled';
 import { assertFrameworkComponentsCompatible } from '../utils/framework-components';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { parseGlobalFlags } from '../utils/global-flags';
+import { parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI } from '../utils/terminal-ui';
 
 interface MigrationNewOptions extends CommonCommandOptions {
   readonly name?: string;
@@ -287,8 +287,8 @@ export function createMigrationNewCommand(): Command {
     .option('--from <hash>', 'Starting contract hash (default: latest migration target)')
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (options: MigrationNewOptions) => {
-      const flags = parseGlobalFlags(options);
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const flags = parseGlobalFlagsOrExit(options);
+      const ui = createTerminalUI(flags);
 
       if (!flags.json && !flags.quiet) {
         const header = formatStyledHeader({

package/src/commands/migration-plan.ts

@@ -51,9 +51,9 @@ import { toExtensionInputs } from '../utils/extension-pack-inputs';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import { assertFrameworkComponentsCompatible } from '../utils/framework-components';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 
 interface MigrationPlanOptions extends CommonCommandOptions {
   readonly config?: string;
@@ -551,10 +551,10 @@ export function createMigrationPlanCommand(): Command {
       'Starting contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path)',
     )
     .action(async (options: MigrationPlanOptions) => {
-      const flags = parseGlobalFlags(options);
+      const flags = parseGlobalFlagsOrExit(options);
       const startTime = Date.now();
 
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const ui = createTerminalUI(flags);
       const result = await executeMigrationPlanCommand(options, flags, ui, startTime);
 
       const exitCode = handleResult(result, flags, ui, (planResult) => {

package/src/commands/migration-show.ts

@@ -43,9 +43,9 @@ import { buildContractSpaceAggregate } from '../utils/contract-space-aggregate-l
 import { formatMigrationShowOutput } from '../utils/formatters/migrations';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 
 interface MigrationShowOptions extends CommonCommandOptions {
   readonly config?: string;
@@ -495,9 +495,9 @@ export function createMigrationShowCommand(): Command {
     )
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (target: string | undefined, options: MigrationShowOptions) => {
-      const flags = parseGlobalFlags(options);
+      const flags = parseGlobalFlagsOrExit(options);
 
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const ui = createTerminalUI(flags);
 
       const result = await executeMigrationShowCommand(target, options, flags, ui);
 

package/src/commands/migration-status.ts

@@ -30,7 +30,7 @@ import { Command } from 'commander';
 import { loadConfig } from '../config-loader';
 import { createControlClient } from '../control-api/client';
 import {
-  type CliStructuredError,
+  CliStructuredError,
   errorRuntime,
   errorUnexpected,
   mapMigrationToolsError,
@@ -65,10 +65,10 @@ import {
 } from '../utils/formatters/graph-render';
 import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
+import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import type { StatusDiagnostic, StatusRef } from '../utils/migration-types';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
 
 interface MigrationStatusOptions extends CommonCommandOptions {
   readonly db?: string;
@@ -540,6 +540,40 @@ async function loadContractRawSafely(config: {
   }
 }
 
+async function validateOnlineMarkerRead(
+  config: Awaited<ReturnType<typeof loadConfig>>,
+  dbConnection: unknown,
+): Promise<Result<void, CliStructuredError>> {
+  const driver = config.driver;
+  if (!driver) {
+    return ok(undefined);
+  }
+
+  const client = createControlClient({
+    family: config.family,
+    target: config.target,
+    adapter: config.adapter,
+    driver,
+    extensionPacks: config.extensionPacks ?? [],
+  });
+  try {
+    await client.connect(dbConnection);
+    await client.readMarker();
+    return ok(undefined);
+  } catch (error) {
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+    return notOk(
+      errorUnexpected(error instanceof Error ? error.message : String(error), {
+        why: `Failed to read database marker: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  } finally {
+    await client.close();
+  }
+}
+
 async function executeMigrationStatusCommand(
   options: MigrationStatusOptions,
   flags: GlobalFlags,
@@ -666,6 +700,12 @@ async function executeMigrationStatusCommand(
   }
 
   if (bundles.length === 0) {
+    if (dbConnection && hasDriver) {
+      const markerProbe = await validateOnlineMarkerRead(config, dbConnection);
+      if (!markerProbe.ok) {
+        return markerProbe;
+      }
+    }
     if (contractHash !== EMPTY_CONTRACT_HASH) {
       diagnostics.push({
         code: 'CONTRACT.AHEAD',
@@ -750,7 +790,10 @@ async function executeMigrationStatusCommand(
         // space has no marker", which is a different condition).
         allMarkers = null;
       }
-    } catch {
+    } catch (error) {
+      if (CliStructuredError.is(error)) {
+        return notOk(error);
+      }
       if (!flags.json && !flags.quiet) {
         ui.warn('Could not connect to database — showing offline status');
       }
@@ -1097,8 +1140,8 @@ export function createMigrationStatusCommand(): Command {
       'Origin contract reference; same grammar as --to. Supplying --from switches to offline path computation.',
     )
     .action(async (options: MigrationStatusOptions) => {
-      const flags = parseGlobalFlags(options);
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const flags = parseGlobalFlagsOrExit(options);
+      const ui = createTerminalUI(flags);
 
       const result = await executeMigrationStatusCommand(options, flags, ui);
 

package/src/commands/ref.ts

@@ -25,9 +25,9 @@ import {
   setCommandDescriptions,
 } from '../utils/command-helpers';
 import { formatCommandHelp } from '../utils/formatters/help';
-import { parseGlobalFlags } from '../utils/global-flags';
+import { parseGlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
+import { createTerminalUI } from '../utils/terminal-ui';
 
 interface RefSetResult {
   readonly ok: true;
@@ -145,8 +145,8 @@ function createRefSetCommand(): Command {
         hash: string,
         options: { config?: string; json?: string | boolean; quiet?: boolean },
       ) => {
-        const flags = parseGlobalFlags(options);
-        const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+        const flags = parseGlobalFlagsOrExit(options);
+        const ui = createTerminalUI(flags);
         const result = await executeRefSetCommand(name, hash, options);
         const exitCode = handleResult(result, flags, ui, (value) => {
           if (flags.json) {
@@ -172,8 +172,8 @@ function createRefDeleteCommand(): Command {
         name: string,
         options: { config?: string; json?: string | boolean; quiet?: boolean },
       ) => {
-        const flags = parseGlobalFlags(options);
-        const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+        const flags = parseGlobalFlagsOrExit(options);
+        const ui = createTerminalUI(flags);
         const result = await executeRefDeleteCommand(name, options);
         const exitCode = handleResult(result, flags, ui, (value) => {
           if (flags.json) {
@@ -194,8 +194,8 @@ function createRefListCommand(): Command {
   addGlobalOptions(command)
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (options: { config?: string; json?: string | boolean; quiet?: boolean }) => {
-      const flags = parseGlobalFlags(options);
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
+      const flags = parseGlobalFlagsOrExit(options);
+      const ui = createTerminalUI(flags);
       const result = await executeRefListCommand(options);
       const exitCode = handleResult(result, flags, ui, (value) => {
         if (flags.json) {

package/src/control-api/operations/apply-aggregate.ts

@@ -178,6 +178,7 @@ export async function applyAggregate<TFamilyId extends string, TTargetId extends
       meta: {
         ...(runnerResult.failure.meta ?? {}),
         failingSpace: runnerResult.failure.failingSpace,
+        runnerErrorCode: runnerResult.failure.code,
       },
     });
   }

package/src/utils/cli-errors.ts

@@ -16,9 +16,11 @@ import {
   errorDriverRequired,
   errorFamilyReadMarkerSqlRequired,
   errorFileNotFound,
+  errorInvalidOutputFormat,
   errorMigrationCliInvalidConfigArg,
   errorMigrationCliUnknownFlag,
   errorMigrationPlanningFailed,
+  errorOutputFormatMutex,
   errorQueryRunnerFactoryRequired,
   errorTargetMigrationNotSupported,
   errorUnexpected,
@@ -56,9 +58,11 @@ export {
   errorDriverRequired,
   errorFamilyReadMarkerSqlRequired,
   errorFileNotFound,
+  errorInvalidOutputFormat,
   errorMigrationCliInvalidConfigArg,
   errorMigrationCliUnknownFlag,
   errorMigrationPlanningFailed,
+  errorOutputFormatMutex,
   errorQueryRunnerFactoryRequired,
   errorTargetMigrationNotSupported,
   errorUnexpected,

package/src/utils/command-helpers.ts

@@ -365,7 +365,7 @@ export function sanitizeErrorMessage(message: string, connectionUrl?: string): s
 
 /**
  * Registers the global CLI options shared by every command:
- * --json, -q/--quiet, -v/--verbose, --trace, --color, --no-color,
+ * --format, --json, -q/--quiet, -v/--verbose, --trace, --color, --no-color,
  * --interactive, --no-interactive, -y/--yes.
  *
  * Also sets up the styled help formatter.
@@ -378,7 +378,11 @@ export function addGlobalOptions(command: Command): Command {
         return formatCommandHelp({ command: cmd, flags });
       },
     })
-    .option('--json', 'Output as JSON')
+    .option(
+      '--format <pretty|json>',
+      'Output format (default: pretty, or json when stdout is not a TTY)',
+    )
+    .option('--json', 'Output as JSON (alias for --format json)')
     .option('-q, --quiet', 'Quiet mode: errors only')
     .option('-v, --verbose', 'Verbose output: debug info, timings')
     .option('--trace', 'Trace output: deep internals, stack traces')

package/src/utils/global-flags.ts

@@ -1,9 +1,17 @@
+import { notOk } from '@prisma-next/utils/result';
+import { CliStructuredError, errorInvalidOutputFormat, errorOutputFormatMutex } from './cli-errors';
 import { isCI } from './is-ci';
+import { handleResult } from './result-handler';
+import { createTerminalUI } from './terminal-ui';
+
+export type OutputFormat = 'pretty' | 'json';
 
 export interface GlobalFlags {
+  readonly format: OutputFormat;
+  readonly explicitFormat: boolean;
   readonly json?: boolean;
   readonly quiet?: boolean;
-  readonly verbose?: number; // 0, 1, or 2
+  readonly verbose?: number;
   readonly color?: boolean;
   readonly interactive?: boolean;
   readonly yes?: boolean;
@@ -14,6 +22,7 @@ export interface GlobalFlags {
  * Extend this for command-specific options instead of duplicating these fields.
  */
 export interface CommonCommandOptions {
+  readonly format?: string;
   readonly json?: string | boolean;
   readonly quiet?: boolean;
   readonly q?: boolean;
@@ -28,33 +37,117 @@ export interface CommonCommandOptions {
   readonly y?: boolean;
 }
 
+function isJsonFlagSet(json: string | boolean | undefined): boolean {
+  return json === true;
+}
+
+interface ResolvedOutputFormat {
+  readonly format: OutputFormat;
+  readonly explicitFormat: boolean;
+}
+
+function resolveOutputFormat(options: CommonCommandOptions): ResolvedOutputFormat {
+  const formatOption = options.format;
+  const jsonFlag = isJsonFlagSet(options.json);
+
+  if (formatOption !== undefined) {
+    if (formatOption !== 'pretty' && formatOption !== 'json') {
+      throw errorInvalidOutputFormat(formatOption);
+    }
+    if (jsonFlag && formatOption === 'pretty') {
+      throw errorOutputFormatMutex();
+    }
+    return { format: formatOption, explicitFormat: true };
+  }
+
+  if (jsonFlag) {
+    return { format: 'json', explicitFormat: false };
+  }
+
+  if (!process.stdout.isTTY) {
+    return { format: 'json', explicitFormat: false };
+  }
+
+  return { format: 'pretty', explicitFormat: false };
+}
+
+function inferJsonModeForParseError(options: CommonCommandOptions): boolean {
+  if (options.format === 'json') {
+    return true;
+  }
+  if (isJsonFlagSet(options.json) && options.format !== 'pretty') {
+    return true;
+  }
+  if (options.format !== undefined) {
+    return false;
+  }
+  return !process.stdout.isTTY;
+}
+
+function emitGlobalFlagParseError(error: CliStructuredError, options: CommonCommandOptions): never {
+  const jsonMode = inferJsonModeForParseError(options);
+  const flags: GlobalFlags = {
+    format: jsonMode ? 'json' : 'pretty',
+    explicitFormat: false,
+    ...(jsonMode ? { json: true } : {}),
+    color: false,
+    verbose: 0,
+    interactive: false,
+  };
+  const ui = createTerminalUI(flags);
+  const exitCode = handleResult(notOk(error), flags, ui);
+  process.exit(exitCode);
+}
+
+/**
+ * Parses global flags from CLI options.
+ * Handles verbosity flags (-v, --trace), output format (--format, --json),
+ * quiet mode, color, interactivity (--interactive/--no-interactive), and
+ * auto-accept (-y/--yes).
+ *
+ * On invalid or conflicting format flags, prints a structured CLI error
+ * envelope and exits with code 2.
+ */
+export function parseGlobalFlagsOrExit(options: CommonCommandOptions): GlobalFlags {
+  try {
+    return parseGlobalFlags(options);
+  } catch (error) {
+    if (CliStructuredError.is(error)) {
+      emitGlobalFlagParseError(error, options);
+    }
+    throw error;
+  }
+}
+
 /**
  * Parses global flags from CLI options.
- * Handles verbosity flags (-v, --trace), JSON output, quiet mode, color,
- * interactivity (--interactive/--no-interactive), and auto-accept (-y/--yes).
+ * Handles verbosity flags (-v, --trace), output format (--format, --json),
+ * quiet mode, color, interactivity (--interactive/--no-interactive), and
+ * auto-accept (-y/--yes).
+ *
+ * Throws {@link CliStructuredError} for invalid or conflicting format flags.
  */
 export function parseGlobalFlags(options: CommonCommandOptions): GlobalFlags {
+  const { format, explicitFormat } = resolveOutputFormat(options);
   const flags: {
+    format: OutputFormat;
+    explicitFormat: boolean;
     json?: boolean;
     quiet?: boolean;
     verbose?: number;
     color?: boolean;
     interactive?: boolean;
     yes?: boolean;
-  } = {};
+  } = { format, explicitFormat };
 
-  // JSON output: explicit --json flag or auto-detect piped stdout (Unix convention)
-  if (options.json || !process.stdout.isTTY) {
+  if (format === 'json') {
     flags.json = true;
   }
 
-  // Quiet mode
   if (options.quiet || options.q) {
     flags.quiet = true;
   }
 
-  // Verbosity: -v = 1, --trace = 2
-  // Env toggles: PRISMA_NEXT_TRACE=1 ≅ --trace, PRISMA_NEXT_DEBUG=1 ≅ -v
   if (options.trace || process.env['PRISMA_NEXT_TRACE'] === '1') {
     flags.verbose = 2;
   } else if (options.verbose || options.v || process.env['PRISMA_NEXT_DEBUG'] === '1') {
@@ -63,8 +156,6 @@ export function parseGlobalFlags(options: CommonCommandOptions): GlobalFlags {
     flags.verbose = 0;
   }
 
-  // Color: respect NO_COLOR env var, --color/--no-color flags
-  // When JSON output is enabled, disable color to ensure clean JSON output
   if (process.env['NO_COLOR'] || flags.json) {
     flags.color = false;
   } else if (options['no-color']) {
@@ -72,14 +163,9 @@ export function parseGlobalFlags(options: CommonCommandOptions): GlobalFlags {
   } else if (options.color !== undefined) {
     flags.color = options.color;
   } else {
-    // Default: enable color if TTY and not in CI. Uses the consolidated
-    // `isCI()` helper (`./is-ci.ts`) — the single source of truth shared
-    // with telemetry-skip detection.
     flags.color = process.stdout.isTTY && !isCI();
   }
 
-  // Interactivity: --interactive/--no-interactive
-  // Default: interactive when stdout is a TTY
   if (options['no-interactive']) {
     flags.interactive = false;
   } else if (options.interactive !== undefined) {
@@ -88,7 +174,6 @@ export function parseGlobalFlags(options: CommonCommandOptions): GlobalFlags {
     flags.interactive = !!process.stdout.isTTY;
   }
 
-  // Auto-accept prompts: -y/--yes
   if (options.yes || options.y) {
     flags.yes = true;
   }

package/src/utils/telemetry.ts

@@ -8,16 +8,11 @@ import {
   type TelemetryRunOutcome,
   type UserConfig,
 } from '@prisma-next/cli-telemetry';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { Command } from 'commander';
 import { version as CLI_VERSION } from '../../package.json' with { type: 'json' };
-import { loadConfig } from '../config-loader';
 import { isCI } from './is-ci';
 
-interface TelemetryFields {
-  readonly databaseTarget: string | null;
-  readonly extensions: readonly string[];
-}
-
 type TelemetryGate =
   | { readonly enabled: true; readonly userConfig: UserConfig }
   | { readonly enabled: false; readonly outcome: TelemetryRunOutcome };
@@ -73,32 +68,6 @@ function resolveTelemetryGate(): TelemetryGate {
   return { enabled: true, userConfig };
 }
 
-/**
- * Best-effort extraction of `databaseTarget` and `extensions` from the
- * project config. Loads via the same `c12`-backed loader the action
- * handlers use so we honour the same lookup rules. Every failure mode
- * (no config file, malformed config, async load reject) collapses to
- * `(null, [])` because telemetry is non-blocking and may fire for
- * commands that legitimately don't have a config (e.g. `init`).
- */
-async function loadConfigForTelemetry(): Promise<TelemetryFields> {
-  try {
-    const config = await loadConfig();
-    const target = config.target as { readonly targetId?: unknown } | undefined;
-    const databaseTarget =
-      target !== undefined && typeof target.targetId === 'string' ? target.targetId : null;
-    const extensionPacks = (config.extensionPacks ?? []) as ReadonlyArray<{
-      readonly id?: unknown;
-    }>;
-    const extensions = extensionPacks
-      .map((pack) => pack.id)
-      .filter((id): id is string => typeof id === 'string');
-    return { databaseTarget, extensions };
-  } catch {
-    return { databaseTarget: null, extensions: [] };
-  }
-}
-
 /**
  * Path to the compiled sender script inside `@prisma-next/cli-telemetry`'s
  * `dist/`. Resolved off this module's `import.meta.url` via the package
@@ -109,40 +78,41 @@ function senderPath(): string {
   return fileURLToPath(new URL(import.meta.resolve('@prisma-next/cli-telemetry/sender')));
 }
 
-function fireTelemetryWithFields(
+function fireTelemetry(
   actionCommand: Command,
-  fields: TelemetryFields,
   userConfig: UserConfig,
+  overrides: { readonly databaseTarget?: string } = {},
 ): TelemetryRunOutcome {
   return runTelemetry({
     command: commanderSnapshotForTelemetry(actionCommand),
     version: CLI_VERSION,
-    databaseTarget: fields.databaseTarget,
-    extensions: fields.extensions,
     projectRoot: process.cwd(),
     senderPath: senderPath(),
     isCI: isCI(),
     env: process.env,
     userConfig,
+    ...ifDefined('databaseTarget', overrides.databaseTarget),
   });
 }
 
 /**
- * preAction-stage entry point: resolve env/CI/user-consent gates first,
- * then (only when enabled) load project config for database target and
- * extension metadata, then fork the detached sender. The early gate is
- * privacy- and UX-critical: config loading can execute user code and
- * must never happen before opt-out/default-off checks have resolved.
+ * preAction-stage entry point. Synchronous by construction: resolve
+ * env/CI/user-consent gates (cheap, all in-memory and a single tiny
+ * user-config read), then — only when enabled — `fork()` the detached
+ * sender script. The forked child loads `prisma-next.config.*` via
+ * c12 on its own (see `loadProjectConfig` in cli-telemetry); the
+ * parent does no project-config I/O on the command's hot path.
+ *
+ * Privacy invariant: gate resolution always happens before any project
+ * config touches disk. The child loading user TS code is acceptable
+ * only because it's gated behind the same resolved-enabled signal.
  */
-export async function fireTelemetryFromPreAction(
-  actionCommand: Command,
-): Promise<TelemetryRunOutcome> {
+export function fireTelemetryFromPreAction(actionCommand: Command): TelemetryRunOutcome {
   const gate = resolveTelemetryGate();
   if (!gate.enabled) {
     return gate.outcome;
   }
-  const fields = await loadConfigForTelemetry();
-  return fireTelemetryWithFields(actionCommand, fields, gate.userConfig);
+  return fireTelemetry(actionCommand, gate.userConfig);
 }
 
 /**
@@ -152,15 +122,20 @@ export async function fireTelemetryFromPreAction(
  * default-off. After consent is persisted, `runInit` calls this helper
  * exactly for that first affirmative answer; subsequent init runs skip
  * it because the prompt is not shown again.
+ *
+ * The child's c12 load would return `databaseTarget: null` for this
+ * specific invocation because `prisma-next.config.*` is not yet on
+ * disk (init writes it later in the same run). To preserve the
+ * prompt-chosen target in the first-init telemetry event, this
+ * helper forwards the value as a parent-side IPC override on
+ * `ParentToSenderPayload.databaseTarget` — the child consults the
+ * override first and falls back to its c12 result when absent.
  */
 export function fireTelemetryAfterInitConsent(
   actionCommand: Command,
   inputs: { readonly databaseTarget: string },
 ): TelemetryRunOutcome {
-  const userConfig = readUserConfig();
-  return fireTelemetryWithFields(
-    actionCommand,
-    { databaseTarget: inputs.databaseTarget, extensions: [] },
-    userConfig,
-  );
+  return fireTelemetry(actionCommand, readUserConfig(), {
+    databaseTarget: inputs.databaseTarget,
+  });
 }