@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

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

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyNxJsonMigrateDefaults = applyNxJsonMigrateDefaults;
-exports.assertCommitPrefixHasCommits = assertCommitPrefixHasCommits;
-const cli_args_1 = require("./agentic/cli-args");
-const command_object_1 = require("./command-object");
-const MULTI_MAJOR_MODE_ENV = 'NX_MULTI_MAJOR_MODE';
-/**
- * Overlays `nx.json` `migrate` defaults onto the raw CLI args: a CLI flag wins,
- * then `nx.json`, then the built-in default. Returns a new args object; the
- * input is not mutated.
- *
- * Phase-aware so each option is only filled where it is consumed, and so a
- * config value never trips the mutually-exclusive-flag guards in
- * `parseMigrationsOptions`: `include` and `multiMajorMode` in the generate
- * phase only; `createCommits` / `commitPrefix` and `agentic` / `validate` when
- * running the whole migrations file or a standalone single migration. A
- * `--run-id` invocation takes none of them: a recorded run takes its commit
- * config from run.json and is driven by the outer agent.
- *
- * `include` is carried as `includeFromConfig` so it is never mistaken for an
- * explicit `--include`: `resolveInclude` applies it only when the resolved
- * target supports optional updates.
- */
-function applyNxJsonMigrateDefaults(args, migrateConfig, env = process.env) {
-    if (!migrateConfig) {
-        return args;
-    }
-    const merged = { ...args };
-    // `--run-migrations` with no value is normalized to '' by yargs, so a defined
-    // (even empty-string) value means we're in the run-migrations phase.
-    const isRunMigrations = merged.runMigrations !== undefined;
-    // A bare `--run-id` (orchestrated reconcile) must never take the
-    // generate-options overlay, which would leak `include` etc. from nx.json.
-    const isSingleMigration = merged.runMigration !== undefined || merged.runId !== undefined;
-    // Both overlays are for an invocation that decides these options for
-    // itself, which a `--run-id` invocation never does: the recorded worker and
-    // the reconcile both read the commit config from run.json, and overlaying
-    // `agentic` would trip the `--agentic`/`--run-id` parse conflict.
-    if ((isRunMigrations || isSingleMigration) && merged.runId === undefined) {
-        if (merged.createCommits === undefined &&
-            migrateConfig.createCommits !== undefined) {
-            assertType(migrateConfig.createCommits, 'boolean', 'createCommits');
-            merged.createCommits = migrateConfig.createCommits;
-        }
-        // `commitPrefix` carries a yargs default, so the default value is
-        // indistinguishable from "not provided" - treat it as not provided so
-        // nx.json can override it.
-        if ((merged.commitPrefix === undefined ||
-            merged.commitPrefix === command_object_1.DEFAULT_MIGRATION_COMMIT_PREFIX) &&
-            migrateConfig.commitPrefix !== undefined) {
-            assertType(migrateConfig.commitPrefix, 'string', 'commitPrefix');
-            merged.commitPrefix = migrateConfig.commitPrefix;
-        }
-        if (merged.agentic === undefined && migrateConfig.agentic !== undefined) {
-            assertValidAgentic(migrateConfig.agentic);
-            merged.agentic = (0, cli_args_1.coerceAgenticArg)(migrateConfig.agentic);
-        }
-        if (merged.validate === undefined && migrateConfig.validate !== undefined) {
-            assertType(migrateConfig.validate, 'boolean', 'validate');
-            merged.validate = migrateConfig.validate;
-        }
-    }
-    if (!isRunMigrations && !isSingleMigration) {
-        if (merged.include === undefined && migrateConfig.include !== undefined) {
-            assertOneOf(migrateConfig.include, command_object_1.MIGRATE_INCLUDE_VALUES, 'include');
-            merged.includeFromConfig = migrateConfig.include;
-        }
-        // The NX_MULTI_MAJOR_MODE env var is an established per-invocation override,
-        // so it takes precedence over nx.json (CLI flag > env > nx.json > default).
-        if (merged.multiMajorMode === undefined &&
-            !env[MULTI_MAJOR_MODE_ENV] &&
-            migrateConfig.multiMajorMode !== undefined) {
-            assertOneOf(migrateConfig.multiMajorMode, command_object_1.MULTI_MAJOR_MODES, 'multiMajorMode');
-            merged.multiMajorMode = migrateConfig.multiMajorMode;
-        }
-    }
-    return merged;
-}
-function assertOneOf(value, allowed, field) {
-    if (!allowed.includes(value)) {
-        throw new Error(`Error: Invalid nx.json migrate.${field} "${value}". Allowed: ${allowed.join(', ')}.`);
-    }
-}
-function assertType(value, type, field) {
-    if (typeof value !== type) {
-        throw new Error(`Error: Invalid nx.json migrate.${field} ${JSON.stringify(value)}. Expected a ${type}.`);
-    }
-}
-function assertValidAgentic(agentic) {
-    if (typeof agentic === 'boolean') {
-        return;
-    }
-    if (typeof agentic !== 'string' ||
-        !cli_args_1.AGENT_IDS.includes(agentic)) {
-        throw new Error(`Error: Invalid nx.json migrate.agentic "${agentic}". Allowed: ${cli_args_1.AGENT_IDS.join(', ')}, true, false.`);
-    }
-}
-/**
- * The single authority for the "a custom commit prefix needs commits enabled"
- * invariant. Run it against the final merged args (after
- * `applyNxJsonMigrateDefaults`): the yargs `.check()` only sees the CLI args,
- * but nx.json may enable commits via `createCommits` or `agentic`. The CLI
- * `.check()` only fast-fails the unrescuable explicit `--no-create-commits`
- * case; everything else is decided here.
- */
-function assertCommitPrefixHasCommits(merged) {
-    const { createCommits, commitPrefix, agentic } = merged;
-    if ((0, command_object_1.customCommitPrefixHasNoEffect)({ createCommits, commitPrefix, agentic })) {
-        throw new Error('Error: A custom migrate commit prefix requires commits to be enabled. Set `migrate.createCommits` to `true` in nx.json or pass `--create-commits`.');
-    }
-}

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

@@ -1,218 +0,0 @@
-/**
- * Pure presentation helpers for the migrate run phase (`--run-migrations` and
- * the single-migration worker). Shared glyph vocabulary:
- *   `→` start, `✓` success, `✗` failure, `↷` skipped, `ℹ` info, `─` boundary
- *
- * Inputs are typed structurally (e.g. `{ name: string }[]`) so this module
- * stays decoupled from the migration executor in migrate.ts.
- */
-/**
- * Some agent TUIs (codex, opencode) don't fully reset their cursor / SGR state
- * when they exit, which corrupts subsequent orchestrator output. Emit an SGR
- * reset + newline so our log lines land on a clean row instead of being
- * overlaid by leftover status bars.
- */
-export declare function resetSgrAfterAgent(): void;
-/**
- * Per-migration boundary header. Anchors the orchestrator log at the start of
- * each migration with the migration index and identity.
- */
-export declare function logMigrationBoundary(index: number, total: number, pkg: string, name: string): void;
-/**
- * Logs the outcome line that closes an agentic phase. Vocabulary:
- *   ✓ <label>[ (<sha>)]: <summary>
- */
-export declare function logAgenticSuccessOutcome(label: string, sha: string | null, summary: string): void;
-/**
- * Logs the skip line for a migration that waived its AI step through
- * `skipAgentic`, plus a verbose note for any `agentContext` the waiver
- * dropped. A hybrid waives its paired prompt; a generator-only migration
- * waives the validation pass, so callers must reach here only once they know
- * one was on the table. Under `inside-agent` only a hybrid can, so the
- * hand-off dropped alongside is always a prompt's; a waived generator-only
- * migration keeps its own. The note is author-facing, hence `--verbose`.
- */
-export declare function logWaivedAgenticStep(migration: {
-    package: string;
-    name: string;
-    prompt?: string;
-    implementation?: string;
-    factory?: string;
-}, agentContext: string[]): void;
-/**
- * Per-migration outcome record consumed by the failure recap. One entry is
- * appended per iteration that returned without throwing; the failing migration
- * has no record.
- *
- * - `applied`: ran fully to completion, including any agentic step.
- * - `no-changes`: generator ran but produced no diff (counts as applied work).
- * - `deferred`: prompt half was not applied (agent disabled or inside-agent
- *   mode hands it off). For hybrid migrations the deterministic half still ran.
- *
- * `committedAsPartOf` is set when this migration's own commit attempt failed
- * but its diff was later absorbed into a successor migration's commit (which
- * stages the working tree's accumulated state via `git add -A`). The recap
- * uses this to anchor "last applied" honestly when the last-named commit
- * landed multiple migrations' contributions.
- */
-export type MigrationOutcomeKind = 'applied' | 'no-changes' | 'deferred';
-/**
- * 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.
- *
- * `waivedAgenticStep` is set when the migration returned `skipAgentic: true`
- * and something was actually waived: a hybrid's prompt, which is owed in every
- * agentic mode, or a generator-only migration's validation step, only when it
- * would have run. Recorded here rather than counted in the executor so the
- * success tally and the failure recap derive the same number from the same
- * records instead of threading a counter through both.
- */
-export type MigrationOutcome = {
-    migration: {
-        package: string;
-        name: string;
-    };
-    status: 'completed';
-    kind: MigrationOutcomeKind;
-    commit: CommitState;
-    waivedAgenticStep?: boolean;
-} | {
-    migration: {
-        package: string;
-        name: string;
-    };
-    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;
-/**
- * Counts the migrations that waived the AI step they would otherwise have
- * run. Shared by the success tally and the failure recap so the two can't
- * report different numbers.
- */
-export declare function countWaivedAgenticSteps(outcomes: ReadonlyArray<MigrationOutcome>): number;
-/**
- * The recap phrase for waived AI steps. "not needed" rather than
- * "skipped"/"deferred", which both recaps reserve for work the user still
- * owes.
- */
-export declare function formatWaivedAgenticSteps(count: number): string;
-/**
- * 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
- * driving the run) can see what completed before the failure without scrolling
- * back through the per-migration log to count shas.
- *
- * Counts-based rather than full migration lists so a 24-migration run that
- * fails at #12 doesn't dump 24 names into the recap — readers scroll up to
- * see specifics in the per-migration log. The "last applied" anchor pairs the
- * most recent fully-applied migration with the sha its commit actually
- * produced, so a skipped/deferred step trailing an applied one can't borrow
- * the earlier sha.
- */
-export declare function logFailureRecap(opts: {
-    migrationIndex: number;
-    totalMigrations: number;
-    outcomes: ReadonlyArray<MigrationOutcome>;
-    migrationEmittedNextSteps: string[];
-    insideAgent: boolean;
-}): void;
-/**
- * Builds the tally body line shown under the top end-of-run NX block. Returns
- * `null` when there is nothing meaningful to tally (e.g. an empty
- * migrations.json), so the caller can omit the body entirely instead of
- * emitting a misleading `0 prompt migrations skipped.` line.
- *
- * Rule (kept coherent across every scenario):
- * - When at least one migration was applied: `<N> migrations applied, <K> commits created[, <D> prompt migrations <skipped|deferred>][, <W> AI steps not needed]`.
- *   The `<K> commits created` part stays even at 0 — it tells the reader work
- *   was applied but not committed (the J4/J8 information made explicit).
- * - When zero migrations were applied but some prompt halves were
- *   skipped/deferred: `<D> prompt migrations <skipped|deferred>` only. Waiving
- *   never adds to `skippedPromptsCount`, so `appliedCount` is non-zero whenever
- *   `waivedAgenticStepsCount` is, and this branch can't be reached with one.
- * - When zero of either: no body line.
- */
-export declare function buildTallyBodyLine(opts: {
-    appliedCount: number;
-    committedShasCount: number;
-    skippedPromptsCount: number;
-    waivedAgenticStepsCount: number;
-    insideAgent: boolean;
-}): string | null;
-/**
- * Body lines for the end-of-run retained-state warning. Fires on the success
- * path — the run completed but one or more migrations' own commits failed
- * and were never absorbed.
- */
-export declare function buildRetainedAtSuccessBody(retainedNames: ReadonlyArray<string>): string[];
-/**
- * Builds the body lines for the inside-agent directive block. Sub-sections
- * drop independently when empty. Returns an empty array when the block has
- * nothing actionable (no deferred prompts AND no migration-emitted notes) —
- * the caller skips emitting the block entirely in that case.
- */
-export declare function buildDirectiveBlockBodyLines(opts: {
-    skippedPrompts: ReadonlyArray<{
-        prompt?: string;
-        name: string;
-        implementation?: string;
-        factory?: string;
-    }>;
-    migrationEmittedNextSteps: string[];
-}): string[];

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

@@ -1,302 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetSgrAfterAgent = resetSgrAfterAgent;
-exports.logMigrationBoundary = logMigrationBoundary;
-exports.logAgenticSuccessOutcome = logAgenticSuccessOutcome;
-exports.logWaivedAgenticStep = logWaivedAgenticStep;
-exports.countLandedCommits = countLandedCommits;
-exports.countWaivedAgenticSteps = countWaivedAgenticSteps;
-exports.formatWaivedAgenticSteps = formatWaivedAgenticSteps;
-exports.retainedMigrations = retainedMigrations;
-exports.logFailureRecap = logFailureRecap;
-exports.buildTallyBodyLine = buildTallyBodyLine;
-exports.buildRetainedAtSuccessBody = buildRetainedAtSuccessBody;
-exports.buildDirectiveBlockBodyLines = buildDirectiveBlockBodyLines;
-const tslib_1 = require("tslib");
-const pc = tslib_1.__importStar(require("picocolors"));
-const logger_1 = require("../../utils/logger");
-const migration_shape_1 = require("./migration-shape");
-/**
- * Pure presentation helpers for the migrate run phase (`--run-migrations` and
- * the single-migration worker). Shared glyph vocabulary:
- *   `→` start, `✓` success, `✗` failure, `↷` skipped, `ℹ` info, `─` boundary
- *
- * Inputs are typed structurally (e.g. `{ name: string }[]`) so this module
- * stays decoupled from the migration executor in migrate.ts.
- */
-/**
- * Some agent TUIs (codex, opencode) don't fully reset their cursor / SGR state
- * when they exit, which corrupts subsequent orchestrator output. Emit an SGR
- * reset + newline so our log lines land on a clean row instead of being
- * overlaid by leftover status bars.
- */
-function resetSgrAfterAgent() {
-    process.stdout.write('\x1b[0m\n');
-}
-/**
- * Per-migration boundary header. Anchors the orchestrator log at the start of
- * each migration with the migration index and identity.
- */
-function logMigrationBoundary(index, total, pkg, name) {
-    const label = `── Migration ${index} of ${total} · ${pkg}:${name} `;
-    const targetWidth = 73;
-    const dashes = Math.max(3, targetWidth - label.length);
-    logger_1.logger.info(`${label}${'─'.repeat(dashes)}`);
-}
-/**
- * Logs the outcome line that closes an agentic phase. Vocabulary:
- *   ✓ <label>[ (<sha>)]: <summary>
- */
-function logAgenticSuccessOutcome(label, sha, summary) {
-    const shaPart = sha ? ` (${sha})` : '';
-    logger_1.logger.info(`${pc.green('✓')} ${label}${shaPart}: ${summary}`);
-}
-/**
- * Logs the skip line for a migration that waived its AI step through
- * `skipAgentic`, plus a verbose note for any `agentContext` the waiver
- * dropped. A hybrid waives its paired prompt; a generator-only migration
- * waives the validation pass, so callers must reach here only once they know
- * one was on the table. Under `inside-agent` only a hybrid can, so the
- * hand-off dropped alongside is always a prompt's; a waived generator-only
- * migration keeps its own. The note is author-facing, hence `--verbose`.
- */
-function logWaivedAgenticStep(migration, agentContext) {
-    logger_1.logger.info(pc.dim((0, migration_shape_1.isHybridMigration)(migration)
-        ? '↷ Prompt phase skipped. The migration reported nothing left for the AI step to do.'
-        : '↷ Validation skipped. The migration reported its changes need no AI review.'));
-    if (agentContext.length === 0)
-        return;
-    logger_1.logger.verbose(`${migration.package}: ${migration.name} returned skipAgentic: true alongside agentContext, which was dropped. agentContext exists to feed the AI step this migration waived.`);
-}
-/**
- * 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;
-}
-/**
- * Counts the migrations that waived the AI step they would otherwise have
- * run. Shared by the success tally and the failure recap so the two can't
- * report different numbers.
- */
-function countWaivedAgenticSteps(outcomes) {
-    return outcomes.filter((o) => o.status === 'completed' && o.waivedAgenticStep === true).length;
-}
-/**
- * The recap phrase for waived AI steps. "not needed" rather than
- * "skipped"/"deferred", which both recaps reserve for work the user still
- * owes.
- */
-function formatWaivedAgenticSteps(count) {
-    return `${count} AI step${count === 1 ? '' : 's'} not needed`;
-}
-/**
- * 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
- * driving the run) can see what completed before the failure without scrolling
- * back through the per-migration log to count shas.
- *
- * Counts-based rather than full migration lists so a 24-migration run that
- * fails at #12 doesn't dump 24 names into the recap — readers scroll up to
- * see specifics in the per-migration log. The "last applied" anchor pairs the
- * most recent fully-applied migration with the sha its commit actually
- * produced, so a skipped/deferred step trailing an applied one can't borrow
- * the earlier sha.
- */
-function logFailureRecap(opts) {
-    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 waivedAgenticCount = countWaivedAgenticSteps(outcomes);
-    const notAttempted = totalMigrations - migrationIndex;
-    // 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.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. 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.commit.kind !== 'failed')
-            continue;
-        uncommittedAtFailure.push({ migration: o.migration });
-    }
-    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 === 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.
-        const anchor = lastApplied
-            ? anchorSha
-                ? ` (last: ${lastApplied.migration.name} → ${anchorSha})`
-                : ` (last: ${lastApplied.migration.name})`
-            : '';
-        const parts = [`${appliedCount} applied${anchor}`];
-        if (deferredCount > 0) {
-            parts.push(`${deferredCount} deferred`);
-        }
-        if (waivedAgenticCount > 0) {
-            parts.push(formatWaivedAgenticSteps(waivedAgenticCount));
-        }
-        logger_1.logger.info(`${parts.join(', ')}. ${notAttempted} not attempted.`);
-        logger_1.logger.info(`See the per-migration log above for full details.`);
-    }
-    if (uncommittedAtFailure.length > 0) {
-        logger_1.logger.info('');
-        logger_1.logger.info(`Working-tree state retained from ${uncommittedAtFailure.length} migration${uncommittedAtFailure.length === 1 ? '' : 's'} whose commits could not be created:`);
-        for (const o of uncommittedAtFailure) {
-            logger_1.logger.info(`  - ${o.migration.package}: ${o.migration.name}`);
-        }
-        logger_1.logger.info('');
-        logger_1.logger.info('Inspect with `git status` / `git diff` and either commit them manually or revert before re-running.');
-    }
-    if (migrationEmittedNextSteps.length > 0) {
-        logger_1.logger.info('');
-        logger_1.logger.info(`Notes from migrations that completed before the failure:`);
-        for (const step of migrationEmittedNextSteps) {
-            logger_1.logger.info(`  - ${step}`);
-        }
-    }
-    logger_1.logger.info('');
-    if (insideAgent) {
-        logger_1.logger.info(`Report the failure and the recap above to the user. They'll need to fix the failing migration and re-run \`nx migrate --run-migrations\` themselves.`);
-    }
-    else {
-        logger_1.logger.info(`Fix the failing migration and re-run \`nx migrate --run-migrations\` to resume.`);
-    }
-    logger_1.logger.info('');
-}
-/**
- * Builds the tally body line shown under the top end-of-run NX block. Returns
- * `null` when there is nothing meaningful to tally (e.g. an empty
- * migrations.json), so the caller can omit the body entirely instead of
- * emitting a misleading `0 prompt migrations skipped.` line.
- *
- * Rule (kept coherent across every scenario):
- * - When at least one migration was applied: `<N> migrations applied, <K> commits created[, <D> prompt migrations <skipped|deferred>][, <W> AI steps not needed]`.
- *   The `<K> commits created` part stays even at 0 — it tells the reader work
- *   was applied but not committed (the J4/J8 information made explicit).
- * - When zero migrations were applied but some prompt halves were
- *   skipped/deferred: `<D> prompt migrations <skipped|deferred>` only. Waiving
- *   never adds to `skippedPromptsCount`, so `appliedCount` is non-zero whenever
- *   `waivedAgenticStepsCount` is, and this branch can't be reached with one.
- * - When zero of either: no body line.
- */
-function buildTallyBodyLine(opts) {
-    const { appliedCount, committedShasCount, skippedPromptsCount, waivedAgenticStepsCount, insideAgent, } = opts;
-    const skipVerb = insideAgent ? 'deferred' : 'skipped';
-    if (appliedCount === 0) {
-        if (skippedPromptsCount === 0)
-            return null;
-        return `${skippedPromptsCount} prompt migration${skippedPromptsCount === 1 ? '' : 's'} ${skipVerb}.`;
-    }
-    const parts = [
-        `${appliedCount} migration${appliedCount === 1 ? '' : 's'} applied`,
-        `${committedShasCount} commit${committedShasCount === 1 ? '' : 's'} created`,
-    ];
-    if (skippedPromptsCount > 0) {
-        parts.push(`${skippedPromptsCount} prompt migration${skippedPromptsCount === 1 ? '' : 's'} ${skipVerb}`);
-    }
-    if (waivedAgenticStepsCount > 0) {
-        parts.push(formatWaivedAgenticSteps(waivedAgenticStepsCount));
-    }
-    return `${parts.join(', ')}.`;
-}
-/**
- * Body lines for the end-of-run retained-state warning. Fires on the success
- * path — the run completed but one or more migrations' own commits failed
- * and were never absorbed.
- */
-function buildRetainedAtSuccessBody(retainedNames) {
-    return [
-        ...retainedNames.map((name) => `  - ${name}`),
-        '',
-        'Their changes are in the working tree. Inspect with `git status` / `git diff` and either commit them manually or revert.',
-    ];
-}
-/**
- * Builds the body lines for the inside-agent directive block. Sub-sections
- * drop independently when empty. Returns an empty array when the block has
- * nothing actionable (no deferred prompts AND no migration-emitted notes) —
- * the caller skips emitting the block entirely in that case.
- */
-function buildDirectiveBlockBodyLines(opts) {
-    const { skippedPrompts, migrationEmittedNextSteps } = opts;
-    const hasDeferred = skippedPrompts.length > 0;
-    const hasNotes = migrationEmittedNextSteps.length > 0;
-    if (!hasDeferred && !hasNotes)
-        return [];
-    const lines = [];
-    if (hasDeferred) {
-        lines.push('Apply the deferred prompts below, in order:');
-        skippedPrompts.forEach((m, i) => {
-            const kindHint = (0, migration_shape_1.isHybridMigration)(m)
-                ? ' — hybrid prompt phase'
-                : ' — prompt-only migration';
-            lines.push(`  ${i + 1}. ${m.prompt}`);
-            lines.push(`       (${m.name}${kindHint})`);
-        });
-    }
-    if (hasNotes) {
-        if (hasDeferred)
-            lines.push('');
-        lines.push(hasDeferred
-            ? 'Then relay these migration-emitted notes to the user:'
-            : 'Relay these migration-emitted notes to the user:');
-        for (const step of migrationEmittedNextSteps) {
-            lines.push(`  - ${step}`);
-        }
-    }
-    lines.push('');
-    lines.push(hasDeferred && hasNotes
-        ? 'Finally, summarize what was done across the run and commit the changes per workspace conventions.'
-        : 'Then summarize what was done across the run and commit the changes per workspace conventions.');
-    return lines;
-}