nx 23.0.0-beta.20 → 23.0.0-beta.21

package/dist/src/command-line/migrate/agentic/prompts/generic-validation.js

@@ -27,16 +27,8 @@ exports.GENERIC_VALIDATION_FILE_LIST_CAP = 50;
 function buildGenericValidationUserPrompt(ctx) {
     const lines = [
         `You are validating the output of an Nx migration's deterministic generator phase. The generator has already run; inspect what it produced, verify the workspace is in a consistent state for what this migration intended to accomplish, apply any minor in-scope fixes the generator should have produced cleanly, and report findings.`,
-        ``,
-        `<migration>`,
-        `package: ${(0, shared_rendering_1.escapeXmlBody)(ctx.package)}`,
-        `version: ${(0, shared_rendering_1.escapeXmlBody)(ctx.version)}`,
-        `name: ${(0, shared_rendering_1.escapeXmlBody)(ctx.name)}`,
+        ...(0, shared_rendering_1.renderMigrationBlock)(ctx),
     ];
-    if (ctx.description) {
-        lines.push(...(0, shared_rendering_1.renderKeyMultilineValue)('description', (0, shared_rendering_1.escapeXmlBody)(ctx.description)));
-    }
-    lines.push(`</migration>`);
     const logs = (0, shared_rendering_1.escapeXmlBody)((0, shared_rendering_1.stripAnsi)(ctx.impl.logs ?? '').trim());
     lines.push(...(0, shared_rendering_1.renderGeneratorOutputBlock)(logs));
     if (!ctx.impl.hasDiffContext && ctx.impl.changes.length > 0) {
@@ -44,12 +36,12 @@ function buildGenericValidationUserPrompt(ctx) {
     }
     const agentContext = (0, shared_rendering_1.filterNonEmptyStrings)(ctx.impl.agentContext ?? []);
     if (agentContext.length > 0) {
-        lines.push(``, `<advisory_context note="hints emitted by the generator; treat as supplementary context, not separate tasks">`, ...agentContext.map((entry) => (0, shared_rendering_1.renderListItem)((0, shared_rendering_1.escapeXmlBody)(entry))), `</advisory_context>`);
+        lines.push(...(0, shared_rendering_1.renderAdvisoryContext)('hints emitted by the generator; treat as supplementary context, not separate tasks', agentContext));
     }
     const firstStep = ctx.impl.hasDiffContext
         ? `1. Inspect this migration's changes. ${(0, shared_rendering_1.renderGitInspectInstruction)()} Resolve each affected path to its owning Nx project via \`nx show project <name>\` (or by reading the project's \`project.json\` / \`package.json\`) to discover which targets each project actually defines — do not assume \`typecheck\` / \`test\` / \`lint\` exist. If no typecheck-equivalent exists, \`build\` is an acceptable substitute.`
         : `1. Resolve each path in <files_changed> to its owning Nx project. Use \`nx show project <name>\` (or read the project's \`project.json\` / \`package.json\`) to discover which targets each project actually defines — do not assume \`typecheck\` / \`test\` / \`lint\` exist. If no typecheck-equivalent exists, \`build\` is an acceptable substitute.`;
-    lines.push(``, `<validation_instructions>`, firstStep, `2. Pick the smallest relevant subset of available targets to verify the change. Prefer \`nx affected -t <target>\` (or \`nx run <project>:<target>\` for a single project). When many small projects are affected, you may use \`nx run-many -t <target> -p <project1>,<project2>\` with the project list derived from the changed files. Unscoped \`nx run-many\` (no \`-p\`) is forbidden.`, `3. If a verification surfaces an issue the migration should have produced cleanly (e.g. a missing import, a type annotation the generator's template missed), you may apply a minor in-scope fix. The boundary is "what this migration intended to accomplish" — do not refactor, do not modify functionality unrelated to the migration, do not extend the migration's scope, do not touch code the migration was not concerned with. If you are unsure whether a fix is in scope, report it in \`summary\` instead of applying.`, `4. Apply every fix you can within scope, then write your handoff. On \`status: "success"\`, summarize what you verified and any fixes you applied. On \`status: "failed"\`, enumerate the unresolved findings in \`summary\` so the user can address them; no commit will be created from a failed run, so the generator's changes and your partial fixes will sit uncommitted in the working tree for the user to review.`, `</validation_instructions>`, ``, `Once you finish, write your handoff JSON to:`, `<handoff_path>`, (0, shared_rendering_1.escapeXmlBody)(ctx.handoffFileAbsolutePath), `</handoff_path>`);
+    lines.push(``, `<validation_instructions>`, firstStep, `2. Pick the smallest relevant subset of available targets to verify the change. Prefer \`nx affected -t <target>\` (or \`nx run <project>:<target>\` for a single project). When many small projects are affected, you may use \`nx run-many -t <target> -p <project1>,<project2>\` with the project list derived from the changed files. Unscoped \`nx run-many\` (no \`-p\`) is forbidden.`, `3. If a verification surfaces an issue the migration should have produced cleanly (e.g. a missing import, a type annotation the generator's template missed), you may apply a minor in-scope fix. The boundary is "what this migration intended to accomplish" — do not refactor, do not modify functionality unrelated to the migration, do not extend the migration's scope, do not touch code the migration was not concerned with. If you are unsure whether a fix is in scope, report it in \`summary\` instead of applying.`, `4. Apply every fix you can within scope, then write your handoff. On \`status: "success"\`, summarize what you verified and any fixes you applied. On \`status: "failed"\`, enumerate the unresolved findings in \`summary\` so the user can address them; no commit will be created from a failed run, so the generator's changes and your partial fixes will sit uncommitted in the working tree for the user to review.`, `</validation_instructions>`, ``, `Once you finish, write your handoff JSON to:`, ...(0, shared_rendering_1.renderHandoffPathFooter)(ctx.handoffFileAbsolutePath));
     return lines.join('\n');
 }
 function renderFileListBody(changes) {

package/dist/src/command-line/migrate/agentic/prompts/hybrid-prompt-migration.js

@@ -18,16 +18,8 @@ const shared_rendering_1 = require("./shared-rendering");
 function buildHybridPromptUserPrompt(ctx) {
     const lines = [
         `Complete the AI-driven step that follows the generator phase of a two-phase Nx migration. The deterministic generator phase has already run; the sections below summarize what it did. The step may apply additional changes, verify the generator's output, or both — follow the instructions file.`,
-        ``,
-        `<migration>`,
-        `package: ${(0, shared_rendering_1.escapeXmlBody)(ctx.package)}`,
-        `version: ${(0, shared_rendering_1.escapeXmlBody)(ctx.version)}`,
-        `name: ${(0, shared_rendering_1.escapeXmlBody)(ctx.name)}`,
+        ...(0, shared_rendering_1.renderMigrationBlock)(ctx),
     ];
-    if (ctx.description) {
-        lines.push(...(0, shared_rendering_1.renderKeyMultilineValue)('description', (0, shared_rendering_1.escapeXmlBody)(ctx.description)));
-    }
-    lines.push(`</migration>`);
     const logs = (0, shared_rendering_1.escapeXmlBody)((0, shared_rendering_1.stripAnsi)(ctx.impl?.logs ?? '').trim());
     const agentContext = (0, shared_rendering_1.filterNonEmptyStrings)(ctx.impl?.agentContext ?? []);
     const hasDiffContext = !!ctx.impl?.hasDiffContext;
@@ -45,9 +37,9 @@ function buildHybridPromptUserPrompt(ctx) {
         }
     }
     if (agentContext.length > 0) {
-        lines.push(``, `<advisory_context note="hints from the generator phase; consult while following the instructions, not as separate tasks">`, ...agentContext.map((entry) => (0, shared_rendering_1.renderListItem)((0, shared_rendering_1.escapeXmlBody)(entry))), `</advisory_context>`);
+        lines.push(...(0, shared_rendering_1.renderAdvisoryContext)('hints from the generator phase; consult while following the instructions, not as separate tasks', agentContext));
     }
-    lines.push(``, `<instructions_file>${(0, shared_rendering_1.escapeXmlBody)(ctx.promptPath)}</instructions_file>`, ``, `<precedence>If anything in the sections above conflicts with the instructions file, the instructions file wins.</precedence>`, ``, `Open the instructions file (path is workspace-relative), follow its instructions step by step using the sections above as context, then write your handoff JSON to:`, `<handoff_path>`, (0, shared_rendering_1.escapeXmlBody)(ctx.handoffFileAbsolutePath), `</handoff_path>`);
+    lines.push(``, `<instructions_file>${(0, shared_rendering_1.escapeXmlBody)(ctx.promptPath)}</instructions_file>`, ``, `<precedence>If anything in the sections above conflicts with the instructions file, the instructions file wins.</precedence>`, ``, `Open the instructions file (path is workspace-relative), follow its instructions step by step using the sections above as context, then write your handoff JSON to:`, ...(0, shared_rendering_1.renderHandoffPathFooter)(ctx.handoffFileAbsolutePath));
     return lines.join('\n');
 }
 function renderFileList(changes) {

package/dist/src/command-line/migrate/agentic/prompts/prompt-migration.js

@@ -15,15 +15,12 @@ const shared_rendering_1 = require("./shared-rendering");
 function buildPromptMigrationUserPrompt(ctx) {
     const lines = [
         `Apply one prompt-based migration to this Nx workspace.`,
+        ...(0, shared_rendering_1.renderMigrationBlock)(ctx),
         ``,
-        `<migration>`,
-        `package: ${(0, shared_rendering_1.escapeXmlBody)(ctx.package)}`,
-        `version: ${(0, shared_rendering_1.escapeXmlBody)(ctx.version)}`,
-        `name: ${(0, shared_rendering_1.escapeXmlBody)(ctx.name)}`,
+        `<instructions_file>${(0, shared_rendering_1.escapeXmlBody)(ctx.promptPath)}</instructions_file>`,
+        ``,
+        `Open the instructions file (path is workspace-relative), follow its instructions step by step, then write your handoff JSON to:`,
+        ...(0, shared_rendering_1.renderHandoffPathFooter)(ctx.handoffFileAbsolutePath),
     ];
-    if (ctx.description) {
-        lines.push(...(0, shared_rendering_1.renderKeyMultilineValue)('description', (0, shared_rendering_1.escapeXmlBody)(ctx.description)));
-    }
-    lines.push(`</migration>`, ``, `<instructions_file>${(0, shared_rendering_1.escapeXmlBody)(ctx.promptPath)}</instructions_file>`, ``, `Open the instructions file (path is workspace-relative), follow its instructions step by step, then write your handoff JSON to:`, `<handoff_path>`, (0, shared_rendering_1.escapeXmlBody)(ctx.handoffFileAbsolutePath), `</handoff_path>`);
     return lines.join('\n');
 }

package/dist/src/command-line/migrate/agentic/prompts/shared-rendering.d.ts

@@ -7,3 +7,12 @@ export declare function filterNonEmptyStrings(entries: unknown[]): string[];
 export declare function escapeXmlBody(value: string): string;
 export declare function renderGitInspectInstruction(): string;
 export declare function renderGeneratorOutputBlock(logs: string): string[];
+export interface MigrationBlockContext {
+    package: string;
+    name: string;
+    version: string;
+    description?: string;
+}
+export declare function renderMigrationBlock(ctx: MigrationBlockContext): string[];
+export declare function renderHandoffPathFooter(handoffFileAbsolutePath: string): string[];
+export declare function renderAdvisoryContext(note: string, entries: string[]): string[];

package/dist/src/command-line/migrate/agentic/prompts/shared-rendering.js

@@ -8,6 +8,9 @@ exports.filterNonEmptyStrings = filterNonEmptyStrings;
 exports.escapeXmlBody = escapeXmlBody;
 exports.renderGitInspectInstruction = renderGitInspectInstruction;
 exports.renderGeneratorOutputBlock = renderGeneratorOutputBlock;
+exports.renderMigrationBlock = renderMigrationBlock;
+exports.renderHandoffPathFooter = renderHandoffPathFooter;
+exports.renderAdvisoryContext = renderAdvisoryContext;
 function renderFileEntry(change) {
     return `[${change.type}] ${change.path}`;
 }
@@ -85,3 +88,43 @@ function renderGeneratorOutputBlock(logs) {
         `</generator_output>`,
     ];
 }
+// Identical `<migration>` block used by prompt-migration, hybrid, and
+// generic-validation builders. Leading blank included so callers can spread
+// directly after a lead sentence. Centralized so the schema and the
+// `escapeXmlBody` contract on values stay in lock-step.
+function renderMigrationBlock(ctx) {
+    const lines = [
+        ``,
+        `<migration>`,
+        `package: ${escapeXmlBody(ctx.package)}`,
+        `version: ${escapeXmlBody(ctx.version)}`,
+        `name: ${escapeXmlBody(ctx.name)}`,
+    ];
+    if (ctx.description) {
+        lines.push(...renderKeyMultilineValue('description', escapeXmlBody(ctx.description)));
+    }
+    lines.push(`</migration>`);
+    return lines;
+}
+// `<handoff_path>` footer that follows the "write your handoff JSON to:"
+// sentence. No leading blank — the block is part of that sentence's structure,
+// not a separate section.
+function renderHandoffPathFooter(handoffFileAbsolutePath) {
+    return [
+        `<handoff_path>`,
+        escapeXmlBody(handoffFileAbsolutePath),
+        `</handoff_path>`,
+    ];
+}
+// Advisory hints from the generator phase. The `note` attribute varies between
+// callers (hybrid vs generic-validation lead-in differs), so it's parameterized
+// rather than hardcoded. Entries are escaped here so callers can pass raw
+// strings.
+function renderAdvisoryContext(note, entries) {
+    return [
+        ``,
+        `<advisory_context note="${note}">`,
+        ...entries.map((entry) => renderListItem(escapeXmlBody(entry))),
+        `</advisory_context>`,
+    ];
+}

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

@@ -27,6 +27,9 @@ async function runAgentic(args) {
         windowsHide: true,
     });
     let child;
+    // Local alias so `@nx/workspace-require-windows-hide` recognizes the
+    // options arg as a tracked Identifier rather than giving up on a
+    // member-expression skip — keeps the lint rule strict on other call sites.
     const spawnOptions = adapted.options;
     try {
         child = (0, child_process_1.spawn)(adapted.binary, adapted.args, spawnOptions);

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

@@ -41,19 +41,82 @@ export declare function logAgenticSuccessOutcome(label: string, sha: string | nu
  * landed multiple migrations' contributions.
  */
 export type MigrationOutcomeKind = 'applied' | 'no-changes' | 'deferred';
-export interface MigrationOutcome {
+/**
+ * The state of a migration's commit attempt. Tagged union so consumers don't
+ * have to re-derive legal combinations from nullable fields.
+ *
+ * - `none`     — no commit was attempted (`--no-create-commits` or no diff to
+ *                commit).
+ * - `landed`   — a commit was actually created. `sha: null` only when
+ *                `git rev-parse HEAD` failed transiently right after the
+ *                commit landed; by contract the diff did clear.
+ * - `failed`   — commit was attempted and errored (signing, hook rejection,
+ *                lock, install error mid-attempt, etc.). The diff stays in
+ *                the working tree until a later migration's commit absorbs
+ *                it (then transitions to `absorbed`) or until the run ends
+ *                (then surfaces as retained state).
+ * - `absorbed` — own commit failed but a later migration's commit absorbed
+ *                this diff via `git add -A`. `into.sha: null` means that
+ *                absorbing commit itself hit a HEAD-resolve race; the recap
+ *                renders an anchor without a sha.
+ */
+export type CommitState = {
+    kind: 'none';
+} | {
+    kind: 'landed';
+    sha: string | null;
+} | {
+    kind: 'failed';
+} | {
+    kind: 'absorbed';
+    into: {
+        name: string;
+        sha: string | null;
+    };
+};
+/**
+ * Per-migration record produced by the executor loop. `status: 'completed'`
+ * carries the kind (applied / no-changes / deferred); `status: 'aborted'`
+ * means the migration threw before completing — the executor's catch block
+ * records it so the recap can list it under retained-state alongside any
+ * other migrations whose commits never landed.
+ */
+export type MigrationOutcome = {
     migration: {
         package: string;
         name: string;
     };
-    outcome: MigrationOutcomeKind;
-    committedSha: string | null;
-    commitFailed?: boolean;
-    committedAsPartOf?: {
+    status: 'completed';
+    kind: MigrationOutcomeKind;
+    commit: CommitState;
+} | {
+    migration: {
+        package: string;
         name: string;
-        sha: string | null;
     };
-}
+    status: 'aborted';
+    commit: CommitState;
+};
+/**
+ * Counts the migrations whose own commit actually landed — including the
+ * HEAD-resolve-race case (`commit: { kind: 'landed', sha: null }`). Used by
+ * the end-of-run "<K> commits created" tally and by the success-path
+ * accounting in `executeMigrations`. Counts landed-commit *records* rather
+ * than distinct shas; absorbed predecessors (`kind: 'absorbed'`) are not
+ * counted because the absorbing commit's record already contributes one.
+ */
+export declare function countLandedCommits(outcomes: ReadonlyArray<MigrationOutcome>): number;
+/**
+ * Migrations whose own commit attempt failed and whose diff was never
+ * absorbed by a later commit. Surfaces what the user has to commit or
+ * revert after the run. Filters on `commit.kind === 'failed'` exactly —
+ * `'absorbed'` means the diff cleared into a later commit, `'none'` means
+ * no commit was attempted (intentional `--no-create-commits` or no-op).
+ */
+export declare function retainedMigrations(outcomes: ReadonlyArray<MigrationOutcome>): Array<{
+    package: string;
+    name: string;
+}>;
 /**
  * Logs a structured recap when a migration throws mid-loop. Inserted between
  * the "Failed to run X" error block and the re-throw so the user (or AI agent
@@ -71,10 +134,6 @@ export declare function logFailureRecap(opts: {
     migrationIndex: number;
     totalMigrations: number;
     outcomes: ReadonlyArray<MigrationOutcome>;
-    pendingMigrations?: ReadonlyArray<{
-        package: string;
-        name: string;
-    }>;
     migrationEmittedNextSteps: string[];
     insideAgent: boolean;
 }): void;

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

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetSgrAfterAgent = resetSgrAfterAgent;
 exports.logMigrationBoundary = logMigrationBoundary;
 exports.logAgenticSuccessOutcome = logAgenticSuccessOutcome;
+exports.countLandedCommits = countLandedCommits;
+exports.retainedMigrations = retainedMigrations;
 exports.logFailureRecap = logFailureRecap;
 exports.buildTallyBodyLine = buildTallyBodyLine;
 exports.buildRetainedAtSuccessBody = buildRetainedAtSuccessBody;
@@ -47,6 +49,29 @@ function logAgenticSuccessOutcome(label, sha, summary) {
     const shaPart = sha ? ` (${sha})` : '';
     logger_1.logger.info(`${pc.green('✓')} ${label}${shaPart}: ${summary}`);
 }
+/**
+ * Counts the migrations whose own commit actually landed — including the
+ * HEAD-resolve-race case (`commit: { kind: 'landed', sha: null }`). Used by
+ * the end-of-run "<K> commits created" tally and by the success-path
+ * accounting in `executeMigrations`. Counts landed-commit *records* rather
+ * than distinct shas; absorbed predecessors (`kind: 'absorbed'`) are not
+ * counted because the absorbing commit's record already contributes one.
+ */
+function countLandedCommits(outcomes) {
+    return outcomes.filter((o) => o.commit.kind === 'landed').length;
+}
+/**
+ * Migrations whose own commit attempt failed and whose diff was never
+ * absorbed by a later commit. Surfaces what the user has to commit or
+ * revert after the run. Filters on `commit.kind === 'failed'` exactly —
+ * `'absorbed'` means the diff cleared into a later commit, `'none'` means
+ * no commit was attempted (intentional `--no-create-commits` or no-op).
+ */
+function retainedMigrations(outcomes) {
+    return outcomes
+        .filter((o) => o.commit.kind === 'failed')
+        .map((o) => ({ package: o.migration.package, name: o.migration.name }));
+}
 /**
  * Logs a structured recap when a migration throws mid-loop. Inserted between
  * the "Failed to run X" error block and the re-throw so the user (or AI agent
@@ -61,62 +86,54 @@ function logAgenticSuccessOutcome(label, sha, summary) {
  * the earlier sha.
  */
 function logFailureRecap(opts) {
-    const { migrationIndex, totalMigrations, outcomes, pendingMigrations = [], migrationEmittedNextSteps, insideAgent, } = opts;
-    const appliedCount = outcomes.filter((o) => o.outcome === 'applied' || o.outcome === 'no-changes').length;
-    const deferredCount = outcomes.filter((o) => o.outcome === 'deferred').length;
+    const { migrationIndex, totalMigrations, outcomes, migrationEmittedNextSteps, insideAgent, } = opts;
+    const appliedCount = outcomes.filter((o) => o.status === 'completed' &&
+        (o.kind === 'applied' || o.kind === 'no-changes')).length;
+    const deferredCount = outcomes.filter((o) => o.status === 'completed' && o.kind === 'deferred').length;
     const notAttempted = totalMigrations - migrationIndex;
-    // Walk back to the most recent record whose work is anchored to a sha —
-    // either its own commit, or a later commit that absorbed it. Both
-    // `applied` AND `deferred` outcomes can carry a successful commit
-    // (hybrid-without-agentic produces `deferred` with a sha from its
-    // deterministic half). Skipped and uncommitted records don't anchor.
+    // Walk back to the most recent completed record whose work is anchored to
+    // a sha — either its own commit (`landed`), or a later commit that
+    // absorbed it (`absorbed`). Both `applied` AND `deferred` outcomes can
+    // carry a successful commit (hybrid-without-agentic produces `deferred`
+    // with a sha from its deterministic half). Skipped and uncommitted
+    // records don't anchor.
     let lastApplied;
     for (let i = outcomes.length - 1; i >= 0; i--) {
         const o = outcomes[i];
-        if ((o.outcome === 'applied' || o.outcome === 'deferred') &&
-            (o.committedSha || o.committedAsPartOf)) {
+        if (o.status !== 'completed')
+            continue;
+        if ((o.kind === 'applied' || o.kind === 'deferred') &&
+            (o.commit.kind === 'landed' || o.commit.kind === 'absorbed')) {
             lastApplied = o;
             break;
         }
     }
     // Migrations whose own commit attempt errored AND whose diff was never
     // absorbed by a later commit. Surfaces what the user has to inspect or
-    // clean up in the working tree.
-    //
-    // Two sources, merged and deduped:
-    //   - Outcomes with `commitFailed: true && !committedAsPartOf`.
-    //   - `pendingMigrations` entries — covers the in-flight migration whose
-    //     install threw before its outcome could be pushed, AND any prior
-    //     failed-commit migration that's still pending at recap time.
-    //
-    // Filtering on `commitFailed` (rather than on missing sha) avoids
-    // mislabeling intentional-no-commit cases: `--no-create-commits` runs
-    // and no-op steps both yield `committedSha: null` without a failure.
-    const seenKeys = new Set();
+    // clean up in the working tree. Single iteration over `outcomes` —
+    // `outcomes` is the sole source of truth (including the in-flight
+    // migration recorded by the executor's catch block), so no dedupe is
+    // needed. `kind: 'failed'` excludes `kind: 'none'` (intentional no-commit:
+    // `--no-create-commits` runs and no-op steps).
     const uncommittedAtFailure = [];
     for (const o of outcomes) {
-        if (o.commitFailed !== true || o.committedAsPartOf)
-            continue;
-        const key = `${o.migration.package}:${o.migration.name}`;
-        if (seenKeys.has(key))
+        if (o.commit.kind !== 'failed')
             continue;
-        seenKeys.add(key);
         uncommittedAtFailure.push({ migration: o.migration });
     }
-    for (const p of pendingMigrations) {
-        const key = `${p.package}:${p.name}`;
-        if (seenKeys.has(key))
-            continue;
-        seenKeys.add(key);
-        uncommittedAtFailure.push({ migration: p });
-    }
     logger_1.logger.info('');
     logger_1.logger.info(`Run halted at migration ${migrationIndex} of ${totalMigrations}.`);
     if (appliedCount === 0 && deferredCount === 0) {
         logger_1.logger.info(`0 migrations completed. ${notAttempted} not attempted.`);
     }
     else {
-        const anchorSha = lastApplied?.committedSha ?? lastApplied?.committedAsPartOf?.sha;
+        const anchorSha = lastApplied === undefined
+            ? undefined
+            : lastApplied.commit.kind === 'landed'
+                ? lastApplied.commit.sha
+                : lastApplied.commit.kind === 'absorbed'
+                    ? lastApplied.commit.into.sha
+                    : undefined;
         // When the anchoring commit hit a HEAD-resolve race, the sha is null;
         // render the migration name alone (without "→ null") so the recap
         // never displays the literal word "null" to the user.