nx 23.2.0-beta.7 → 23.2.0-beta.9

package/dist/src/command-line/migrate/agentic/runner.js

@@ -41,10 +41,11 @@ async function runAgentic(args) {
         });
     }
     // Counts SIGINTs while the agent runs. Non-zero after exit means the
-    // user pressed Ctrl+C → skip the ambiguous abort/continue prompt, because
-    // enquirer misbehaves in the TTY state left by a SIGINT-killed child
-    // (ERR_USE_AFTER_CLOSE, setRawMode EIO) and the errors surface from async
-    // chains that `await` cannot catch.
+    // user pressed Ctrl+C → skip the ambiguous abort/continue prompt. Prompting
+    // in the TTY state left by a SIGINT-killed child misbehaved under enquirer
+    // (ERR_USE_AFTER_CLOSE, setRawMode EIO) from async chains `await` could not
+    // catch. Whether @clack/prompts shares that fault is unverified, so the skip
+    // stays; reproducing it needs a real terminal.
     let userInterruptCount = 0;
     const swallowSigint = () => {
         userInterruptCount++;
@@ -279,9 +280,10 @@ async function resolveFromHandoffOrPrompt(handoffFilePath, userInterrupted = fal
     };
     if (userInterrupted) {
         // User pressed Ctrl+C. Don't show the abort/continue prompt — they
-        // already told us what they want, and the TTY state after a
-        // SIGINT-killed child trips enquirer's setRawMode-EIO and
-        // ERR_USE_AFTER_CLOSE bugs. The orchestrator's standard failure
+        // already told us what they want. Prompting in the TTY state left by a
+        // SIGINT-killed child also tripped enquirer's setRawMode-EIO and
+        // ERR_USE_AFTER_CLOSE bugs; whether @clack/prompts shares that fault is
+        // unverified, so the skip stays. The orchestrator's standard failure
         // cascade surfaces the abort outcome.
         //
         // Forward the underlying cause as pre-rendered summary lines so the
@@ -357,13 +359,14 @@ function escapeCmdCommand(arg) {
 }
 async function promptAmbiguous(cause) {
     // stderr blank line so the spacer lands in the same stream as output.warn
-    // and the enquirer prompt — buffered stdout could otherwise reorder it
-    // and glue the prompt to the agent's trailing exit message.
+    // and the prompt — buffered stdout could otherwise reorder it and glue the
+    // prompt to the agent's trailing exit message.
     process.stderr.write('\n');
-    // Cause rendered ABOVE the prompt rather than inlined into prompt.message:
-    // enquirer's select redraw uses different math for clear (wrap-aware) vs
-    // restore (raw \n-split count), so a multi-line message can leave orphaned
-    // cells on arrow-key re-renders. Keeping message single-line sidesteps it.
+    // Cause rendered ABOVE the prompt rather than inlined into its message:
+    // enquirer's select redraw used different math for clear (wrap-aware) vs
+    // restore (raw \n-split count), so a multi-line message could leave orphaned
+    // cells on arrow-key re-renders. Kept single-line because that constraint is
+    // unverified under @clack/prompts, not because the cause still applies.
     const causeLines = describeAmbiguousCause(cause);
     if (causeLines.length > 0) {
         output_1.output.warn({
@@ -371,24 +374,21 @@ async function promptAmbiguous(cause) {
             bodyLines: causeLines,
         });
     }
-    // `migratePrompt` injects `options.cancel` so Ctrl+C and Esc exit cleanly
-    // via `process.exit(130)` before enquirer's broken cancel cleanup runs.
-    // Any other rejection we treat as abort.
+    // Cancelling exits 130 from inside the prompt; any other rejection is an
+    // abort.
     try {
-        const response = await (0, safe_prompt_1.migratePrompt)({
-            name: 'choice',
-            type: 'select',
+        const choice = await (0, safe_prompt_1.migrateChoice)({
             message: 'How should nx migrate proceed?',
             choices: [
-                { name: 'abort', message: 'Treat as failed — abort the run' },
+                { value: 'abort', label: 'Treat as failed — abort the run' },
                 {
-                    name: 'continue',
-                    message: 'Treat as completed — mark done and continue',
+                    value: 'continue',
+                    label: 'Treat as completed — mark done and continue',
                 },
             ],
         });
-        (0, migrate_analytics_1.reportMigratePrompt)('ambiguous_agent_outcome', response.choice);
-        return response.choice === 'continue'
+        (0, migrate_analytics_1.reportMigratePrompt)('ambiguous_agent_outcome', choice);
+        return choice === 'continue'
             ? { kind: 'ambiguous-continue' }
             : { kind: 'ambiguous-abort' };
     }

package/dist/src/command-line/migrate/agentic/select.js

@@ -2,11 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAgentic = resolveAgentic;
 exports.resolveShouldRunValidation = resolveShouldRunValidation;
-const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const jsonc_parser_1 = require("jsonc-parser");
 const path_1 = require("path");
-const pc = tslib_1.__importStar(require("picocolors"));
 const output_1 = require("../../../utils/output");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const migrate_analytics_1 = require("../migrate-analytics");
@@ -129,46 +127,40 @@ async function firePromptForAgentic(migrations, detected) {
     const pinChoice = multipleAgents
         ? [
             {
-                name: 'yes-pin',
-                message: 'Yes, always with the same agent',
-                description: rememberHint,
+                value: 'yes-pin',
+                label: 'Yes, always with the same agent',
+                hint: rememberHint,
             },
         ]
         : [];
     const choices = [
         {
-            name: 'yes-once',
-            message: 'Yes, just this time',
-            description: applyHint,
+            value: 'yes-once',
+            label: 'Yes, just this time',
+            hint: applyHint,
         },
         {
-            name: 'yes-flex',
-            message: multipleAgents
+            value: 'yes-flex',
+            label: multipleAgents
                 ? "Yes, always (I'll pick the agent each run)"
                 : 'Yes, always',
-            description: rememberHint,
+            hint: rememberHint,
         },
         ...pinChoice,
-        { name: 'no-once', message: 'No, just this time', description: skipHint },
-        { name: 'no-never', message: 'No, never', description: rememberHint },
+        { value: 'no-once', label: 'No, just this time', hint: skipHint },
+        { value: 'no-never', label: 'No, never', hint: rememberHint },
     ];
     // Blank line keeps the prompt from gluing to the previous `npm install`
     // output or any earlier orchestrator line.
     console.log();
-    // `as any`: `footer` and per-choice `description` aren't in enquirer's .d.ts.
-    const response = await (0, safe_prompt_1.migratePrompt)({
-        name: 'choice',
-        type: 'select',
+    // Each choice's hint renders beside it, so the description no longer needs a
+    // footer that tracks the cursor.
+    const choice = await (0, safe_prompt_1.migrateChoice)({
         message: 'Enable the agentic flow?',
         choices,
-        initial: 0,
-        footer: function () {
-            const focused = this.focused;
-            return focused?.description ? pc.dim(`  ${focused.description}`) : '';
-        },
     });
-    (0, migrate_analytics_1.reportMigratePrompt)('agentic', response.choice);
-    switch (response.choice) {
+    (0, migrate_analytics_1.reportMigratePrompt)('agentic', choice);
+    switch (choice) {
         case 'yes-once':
             return { enabled: true };
         case 'yes-flex':
@@ -250,12 +242,10 @@ async function selectAgent(detected, explicitId, isInteractive) {
     requireInteractiveOrAbort(isInteractive);
     // Blank line keeps the prompt from gluing to the preceding output.
     console.log();
-    const response = await (0, safe_prompt_1.migratePrompt)({
-        name: 'id',
-        type: 'select',
+    const id = await (0, safe_prompt_1.migrateChoice)({
         message: 'Multiple AI agents detected. Which one should Nx use?',
-        choices: detected.map((d) => ({ name: d.id, message: d.displayName })),
+        choices: detected.map((d) => ({ value: d.id, label: d.displayName })),
     });
-    (0, migrate_analytics_1.reportMigratePrompt)('agent_select', response.id);
-    return detected.find((d) => d.id === response.id);
+    (0, migrate_analytics_1.reportMigratePrompt)('agent_select', id);
+    return detected.find((d) => d.id === id);
 }

package/dist/src/command-line/migrate/agentic/types.d.ts

@@ -1,14 +1,23 @@
 import type { AgentId } from './cli-args';
 export type { AgentId };
 /**
- * Workspace-relative directory holding all migrate-run scratch (handoff
- * files). Shared by the run-dir layout in `handoff.ts` and the agent
- * permission rules in `definitions.ts` so the pre-authorized write scope
+ * Workspace-relative directory holding all migrate-run scratch: a run
+ * directory per run id. Shared by the run-dir layout in `handoff.ts` and the
+ * agent permission rules in `definitions.ts` so the pre-authorized write scope
  * can't drift from the actual layout. It lives here so `definitions.ts`,
  * loaded whenever the agentic flow is resolved, doesn't pull in the handoff
  * runtime for the path alone.
  */
 export declare const MIGRATE_RUNS_RELATIVE_DIR = ".nx/migrate-runs";
+/**
+ * The one subtree of a run directory an agent writes: its handoff files.
+ * Everything beside it is state Nx owns and reads back, the orchestrator's
+ * run state and plan snapshots included, so the pre-authorized write scope
+ * stops at this segment. Package names make up the rest of a handoff path,
+ * so without it they would occupy the run directory's top level and leave Nx
+ * no name it could add there safely.
+ */
+export declare const HANDOFFS_DIR_NAME = "handoffs";
 export declare function isHandoffGitignoreMigration(m: {
     package: string;
     name: string;
@@ -34,6 +43,13 @@ export interface InvocationContext {
     systemContext: string;
     userPrompt: string;
     workspaceRoot: string;
+    /**
+     * Name of the run directory under `MIGRATE_RUNS_RELATIVE_DIR` holding this
+     * invocation's handoff. A workspace can carry several run directories at
+     * once, so a definition that pre-authorizes the handoff write narrows it to
+     * this one: the others belong to runs this invocation is not executing.
+     */
+    runDirName: string;
 }
 /**
  * What an agent definition returns from `buildInteractive`. The runner combines

package/dist/src/command-line/migrate/agentic/types.js

@@ -1,16 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIGRATE_RUNS_RELATIVE_DIR = void 0;
+exports.HANDOFFS_DIR_NAME = exports.MIGRATE_RUNS_RELATIVE_DIR = void 0;
 exports.isHandoffGitignoreMigration = isHandoffGitignoreMigration;
 /**
- * Workspace-relative directory holding all migrate-run scratch (handoff
- * files). Shared by the run-dir layout in `handoff.ts` and the agent
- * permission rules in `definitions.ts` so the pre-authorized write scope
+ * Workspace-relative directory holding all migrate-run scratch: a run
+ * directory per run id. Shared by the run-dir layout in `handoff.ts` and the
+ * agent permission rules in `definitions.ts` so the pre-authorized write scope
  * can't drift from the actual layout. It lives here so `definitions.ts`,
  * loaded whenever the agentic flow is resolved, doesn't pull in the handoff
  * runtime for the path alone.
  */
 exports.MIGRATE_RUNS_RELATIVE_DIR = '.nx/migrate-runs';
+/**
+ * The one subtree of a run directory an agent writes: its handoff files.
+ * Everything beside it is state Nx owns and reads back, the orchestrator's
+ * run state and plan snapshots included, so the pre-authorized write scope
+ * stops at this segment. Package names make up the rest of a handoff path,
+ * so without it they would occupy the run directory's top level and leave Nx
+ * no name it could add there safely.
+ */
+exports.HANDOFFS_DIR_NAME = 'handoffs';
 /**
  * Composite identity of the v23 migration that adds `.nx/migrate-runs` to
  * `.gitignore`. Hard-coded because the agentic preflight is a deliberate

package/dist/src/command-line/migrate/command-object.d.ts

@@ -1,5 +1,6 @@
 import { CommandModule } from 'yargs';
 import type { AgenticArg } from './agentic/select';
+import { type StepAction } from './step-actions';
 export declare const yargsMigrateCommand: CommandModule;
 export declare const yargsInternalMigrateCommand: CommandModule;
 export declare const DEFAULT_MIGRATION_COMMIT_PREFIX = "chore: [nx migration] ";
@@ -18,6 +19,8 @@ export interface MigrateArgs {
     packageAndVersion?: string;
     runMigrations?: string;
     runMigration?: string;
+    runId?: string;
+    stepAction?: StepAction;
     include?: MigrateInclude;
     /**
      * nx.json `migrate.include` default. Consumed by `resolveInclude` only when the

package/dist/src/command-line/migrate/command-object.js

@@ -6,6 +6,7 @@ const handle_import_1 = require("../../utils/handle-import");
 const documentation_1 = require("../yargs-utils/documentation");
 const shared_options_1 = require("../yargs-utils/shared-options");
 const cli_args_1 = require("./agentic/cli-args");
+const step_actions_1 = require("./step-actions");
 exports.yargsMigrateCommand = {
     command: 'migrate [packageAndVersion]',
     describe: `Creates a migrations file or runs migrations from the migrations file.
@@ -56,6 +57,18 @@ function withMigrationOptions(yargs) {
         .option('runMigration', {
         describe: "Run a single migration from migrations.json by id. The id is '<package>:<name>'; a bare '<name>' is accepted when it matches exactly one migration. A name that contains ':' must use the full '<package>:<name>' form.",
         type: 'string',
+    })
+        .option('runId', {
+        // Hidden with the orchestrator itself.
+        describe: 'The orchestrated migrate run to record a single migration into, or to reconcile when given without --run-migration.',
+        type: 'string',
+        hidden: true,
+    })
+        .option('stepAction', {
+        describe: 'How an orchestrated reconcile resolves its single failed or died step.',
+        choices: step_actions_1.STEP_ACTIONS,
+        type: 'string',
+        hidden: true,
     })
         .option('ifExists', {
         describe: `Run migrations only if the migrations file exists, if not continues successfully.`,

package/dist/src/command-line/migrate/execute-migration.d.ts

@@ -28,8 +28,15 @@ export declare class ChangedDepInstaller {
     private readonly rerunCommand?;
     private initialDeps;
     private _skippedInstall;
+    private _installed;
     constructor(root: string, shouldSkipInstall?: boolean, rerunCommand?: string);
     get skippedInstall(): boolean;
+    /**
+     * Whether an install actually ran. Distinct from `!skippedInstall`, which is
+     * only about the skip-install flag: dependencies that never changed leave
+     * both false.
+     */
+    get installed(): boolean;
     installDepsIfChanged(): Promise<void>;
 }
 export declare function runNxOrAngularMigration(root: string, migration: {
@@ -45,6 +52,13 @@ export declare function runNxOrAngularMigration(root: string, migration: {
     logs: string;
     madeChanges: boolean;
 }>;
+/**
+ * The workspace's declared dependencies, serialized for equality comparison,
+ * or `null` when package.json could not be read or parsed. Callers that
+ * persist the value across processes need that distinction: an unreadable
+ * package.json is not an empty dependency set.
+ */
+export declare function readPackageJsonDeps(root: string): string | null;
 export declare function getStringifiedPackageJsonDeps(root: string): string;
 export declare function runNxMigration(root: string, collectionPath: string, collection: MigrationsJson, name: string, migrationVersion: string | undefined, captureGeneratorOutput: boolean): Promise<{
     changes: FileChange[];

package/dist/src/command-line/migrate/execute-migration.js

@@ -8,6 +8,7 @@ exports.formatSingleMigrationRerunCommand = formatSingleMigrationRerunCommand;
 exports.logNpmPeerDepsError = logNpmPeerDepsError;
 exports.logSkippedPostMigrationInstall = logSkippedPostMigrationInstall;
 exports.runNxOrAngularMigration = runNxOrAngularMigration;
+exports.readPackageJsonDeps = readPackageJsonDeps;
 exports.getStringifiedPackageJsonDeps = getStringifiedPackageJsonDeps;
 exports.runNxMigration = runNxMigration;
 exports.parseMigrationReturn = parseMigrationReturn;
@@ -25,6 +26,7 @@ const handle_import_1 = require("../../utils/handle-import");
 const tree_1 = require("../../generators/tree");
 const fileutils_1 = require("../../utils/fileutils");
 const logger_1 = require("../../utils/logger");
+const text_1 = require("./text");
 const package_json_1 = require("../../utils/package-json");
 const package_manager_1 = require("../../utils/package-manager");
 const output_1 = require("../../utils/output");
@@ -199,11 +201,20 @@ class ChangedDepInstaller {
         this.shouldSkipInstall = shouldSkipInstall;
         this.rerunCommand = rerunCommand;
         this._skippedInstall = false;
+        this._installed = false;
         this.initialDeps = getStringifiedPackageJsonDeps(root);
     }
     get skippedInstall() {
         return this._skippedInstall;
     }
+    /**
+     * Whether an install actually ran. Distinct from `!skippedInstall`, which is
+     * only about the skip-install flag: dependencies that never changed leave
+     * both false.
+     */
+    get installed() {
+        return this._installed;
+    }
     async installDepsIfChanged() {
         const currentDeps = getStringifiedPackageJsonDeps(this.root);
         if (this.initialDeps !== currentDeps) {
@@ -212,6 +223,7 @@ class ChangedDepInstaller {
             }
             else {
                 await runInstall(this.root, 'post-migration', this.rerunCommand);
+                this._installed = true;
             }
         }
         this.initialDeps = currentDeps;
@@ -235,9 +247,9 @@ async function runNxOrAngularMigration(root, migration, isVerbose, captureGenera
         ({ nextSteps, changes, agentContext, skipAgentic, logs } =
             await runNxMigration(root, collectionPath, collection, migration.name, migration.version, captureGeneratorOutput));
         madeChanges = changes.length > 0;
-        logger_1.logger.info(`Ran ${migration.name} from ${migration.package}`);
+        logger_1.logger.info((0, text_1.singleLine)(`Ran ${migration.name} from ${migration.package}`));
         if (migration.description) {
-            logger_1.logger.info(`  ${migration.description}`);
+            logger_1.logger.info((0, text_1.singleLine)(`  ${migration.description}`));
         }
         logger_1.logger.info('');
         if (!madeChanges) {
@@ -262,9 +274,9 @@ async function runNxOrAngularMigration(root, migration, isVerbose, captureGenera
         changes = ngResult.changes;
         madeChanges = ngResult.madeChanges;
         logs = ngResult.loggingQueue.join('\n');
-        logger_1.logger.info(`Ran ${migration.name} from ${migration.package}`);
+        logger_1.logger.info((0, text_1.singleLine)(`Ran ${migration.name} from ${migration.package}`));
         if (migration.description) {
-            logger_1.logger.info(`  ${migration.description}`);
+            logger_1.logger.info((0, text_1.singleLine)(`  ${migration.description}`));
         }
         logger_1.logger.info('');
         if (!madeChanges) {
@@ -279,22 +291,31 @@ async function runNxOrAngularMigration(root, migration, isVerbose, captureGenera
             };
         }
         logger_1.logger.info('Changes:');
-        ngResult.loggingQueue.forEach((log) => logger_1.logger.info('  ' + log));
+        ngResult.loggingQueue.forEach((log) => logger_1.logger.info((0, text_1.singleLine)('  ' + log)));
         logger_1.logger.info('');
     }
     return { changes, nextSteps, agentContext, skipAgentic, logs, madeChanges };
 }
-function getStringifiedPackageJsonDeps(root) {
+/**
+ * The workspace's declared dependencies, serialized for equality comparison,
+ * or `null` when package.json could not be read or parsed. Callers that
+ * persist the value across processes need that distinction: an unreadable
+ * package.json is not an empty dependency set.
+ */
+function readPackageJsonDeps(root) {
     try {
         const { dependencies, devDependencies } = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
         return JSON.stringify([dependencies, devDependencies]);
     }
     catch {
-        // We don't really care if the .nx/installation property changes,
-        // whenever nxw is invoked it will handle the dep updates.
-        return '';
+        return null;
     }
 }
+function getStringifiedPackageJsonDeps(root) {
+    // We don't really care if the .nx/installation property changes,
+    // whenever nxw is invoked it will handle the dep updates.
+    return readPackageJsonDeps(root) ?? '';
+}
 async function runNxMigration(root, collectionPath, collection, name, migrationVersion, captureGeneratorOutput) {
     const { path: implPath, fnSymbol } = getImplementationPath(collection, collectionPath, name, migrationVersion);
     const fn = require(implPath)[fnSymbol];

package/dist/src/command-line/migrate/migrate-analytics.d.ts

@@ -67,12 +67,40 @@ export declare function reportMigrateRunError(opts: {
     migrationCount?: number;
     error?: unknown;
 }): void;
+export declare function reportMigrateOrchestratorInit(opts: {
+    migrationCount: number;
+    createCommits: boolean;
+}): void;
+/**
+ * One event per orchestrator dispense. The `action` (dispense case) is a
+ * closed enum carried on a reused dimension, read conditioned on the event
+ * name (the same multiplexing pattern as {@link reportMigratePrompt});
+ * `attempt` rides the migration-count dimension.
+ */
+export declare function reportMigrateOrchestratorDispense(opts: {
+    action: string;
+    attempt: number;
+}): void;
+/**
+ * Terminal funnel event. The two step tallies and the total dispense count
+ * ride reused numeric dimensions, read conditioned on the event name.
+ */
+export declare function reportMigrateOrchestratorComplete(opts: {
+    completed: number;
+    skipped: number;
+    dispenseCount: number;
+}): void;
 /**
  * Counts invocations, not completions: emitted as soon as the migration id
  * resolves, while the worker can still stop before running anything.
+ *
+ * An invocation recorded into an orchestrated run (`--run-id`) gets its own
+ * event name. Every other one keeps the name `--run-migration` shipped with,
+ * so that series stays continuous for users who never enable the orchestrator.
  */
 export declare function reportMigrateSingleMigrationInvocation(opts: {
     migrationType: 'generator' | 'prompt' | 'hybrid';
+    orchestrated: boolean;
 }): void;
 export declare function computeMajorsCrossed(installed: string | null | undefined, target: string | null | undefined): number | undefined;
 export declare function safeReport(emit: () => void): void;

package/dist/src/command-line/migrate/migrate-analytics.js

@@ -11,6 +11,9 @@ exports.reportMigrateRunStart = reportMigrateRunStart;
 exports.hasMigrateRunStarted = hasMigrateRunStarted;
 exports.reportMigrateRunComplete = reportMigrateRunComplete;
 exports.reportMigrateRunError = reportMigrateRunError;
+exports.reportMigrateOrchestratorInit = reportMigrateOrchestratorInit;
+exports.reportMigrateOrchestratorDispense = reportMigrateOrchestratorDispense;
+exports.reportMigrateOrchestratorComplete = reportMigrateOrchestratorComplete;
 exports.reportMigrateSingleMigrationInvocation = reportMigrateSingleMigrationInvocation;
 exports.computeMajorsCrossed = computeMajorsCrossed;
 exports.safeReport = safeReport;
@@ -181,15 +184,62 @@ function reportMigrateRunError(opts) {
         });
     });
 }
+function reportMigrateOrchestratorInit(opts) {
+    safeReport(() => {
+        if (!analytics_1.customDimensions)
+            return;
+        (0, analytics_1.reportEvent)('migrate_orchestrator_init', {
+            [analytics_1.customDimensions.createCommits]: opts.createCommits,
+            [analytics_1.customDimensions.migrationCount]: opts.migrationCount,
+        });
+    });
+}
+/**
+ * One event per orchestrator dispense. The `action` (dispense case) is a
+ * closed enum carried on a reused dimension, read conditioned on the event
+ * name (the same multiplexing pattern as {@link reportMigratePrompt});
+ * `attempt` rides the migration-count dimension.
+ */
+function reportMigrateOrchestratorDispense(opts) {
+    safeReport(() => {
+        if (!analytics_1.customDimensions)
+            return;
+        (0, analytics_1.reportEvent)('migrate_orchestrator_dispense', {
+            [analytics_1.customDimensions.promptChoice]: opts.action,
+            [analytics_1.customDimensions.migrationCount]: opts.attempt,
+        });
+    });
+}
+/**
+ * Terminal funnel event. The two step tallies and the total dispense count
+ * ride reused numeric dimensions, read conditioned on the event name.
+ */
+function reportMigrateOrchestratorComplete(opts) {
+    safeReport(() => {
+        if (!analytics_1.customDimensions)
+            return;
+        (0, analytics_1.reportEvent)('migrate_orchestrator_complete', {
+            [analytics_1.customDimensions.appliedCount]: opts.completed,
+            [analytics_1.customDimensions.taskCount]: opts.skipped,
+            [analytics_1.customDimensions.migrationCount]: opts.dispenseCount,
+        });
+    });
+}
 /**
  * Counts invocations, not completions: emitted as soon as the migration id
  * resolves, while the worker can still stop before running anything.
+ *
+ * An invocation recorded into an orchestrated run (`--run-id`) gets its own
+ * event name. Every other one keeps the name `--run-migration` shipped with,
+ * so that series stays continuous for users who never enable the orchestrator.
  */
 function reportMigrateSingleMigrationInvocation(opts) {
     safeReport(() => {
         if (!analytics_1.customDimensions)
             return;
-        (0, analytics_1.reportEvent)('migrate_single_migration_invocation', {
+        (0, analytics_1.reportEvent)(opts.orchestrated
+            ? 'migrate_single_migration_recorded'
+            : 'migrate_single_migration_invocation', {
             [analytics_1.customDimensions.promptChoice]: opts.migrationType,
         });
     });

package/dist/src/command-line/migrate/migrate-commits.d.ts

@@ -55,7 +55,7 @@ export declare function commitCheckpointBeforeMigrations(root: string, commitPre
  */
 export declare function resolveCreateCommits(args: {
     createCommits: boolean | undefined;
-    agenticKind: ResolvedAgentic['kind'];
+    mode: ResolvedAgentic['kind'] | 'orchestrated';
     isGitRepo: boolean;
     commitPrefixIsCustom?: boolean;
 }): {
@@ -65,9 +65,15 @@ export declare function resolveCreateCommits(args: {
     error?: string;
 };
 /**
+ * Asks before a run starts committing on the workspace's default branch, and
+ * reports the decision when the answer is no. Returns whether to proceed.
+ *
  * Callers gate this on commits being effective and on prompting being
- * possible, so non-interactive runs (CI, `--no-interactive`) never reach here.
+ * possible, so non-interactive runs (CI, `--no-interactive`) never reach here;
+ * `confirmCommitsOnDefaultBranch` has no guard of its own and would block on a
+ * prompt nobody can answer.
  */
+export declare function confirmMigrationCommitsOnDefaultBranch(root: string, whatWouldRun: 'running migrations' | 'running the migration'): Promise<boolean>;
 export declare function confirmCommitsOnDefaultBranch(args: {
     currentBranch: string | null;
     defaultBranch: string | null;