nx 23.3.0-beta.7 → 23.3.0-beta.9

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

@@ -710,13 +710,24 @@ async function parseTargetPackageAndVersion(args) {
 async function parseMigrationsOptions(options, fetch) {
     // A run recorded or reconciled via `--run-id` is driven by the outer agent;
     // spawning another agent from it would double-drive the run. Only the
-    // explicit "on" values conflict; the nx.json default is ignored for
-    // `--run-id` invocations instead.
+    // explicit "on" values conflict; the nx.json default is not applied to
+    // those invocations instead. The `--run-migrations` shape is the
+    // exception: there `--run-id` names the run a continue re-enters, or the
+    // one a `--start-fresh` replaces.
     if (options.runId !== undefined &&
         options.agentic !== undefined &&
-        options.agentic !== false) {
+        options.agentic !== false &&
+        options.runMigrations === undefined) {
         throw new Error(`Error: '--agentic' cannot be combined with '--run-id'.`);
     }
+    if (options.startFresh === true) {
+        if (options.runMigrations === undefined) {
+            throw new Error(`Error: '--start-fresh' requires '--run-migrations'.`);
+        }
+        if (options.runId === undefined) {
+            throw new Error(`Error: '--start-fresh' requires '--run-id=<id>' naming the run to replace; the report prints it.`);
+        }
+    }
     if (options.runMigration !== undefined) {
         if (options.runMigration === '') {
             throw new Error(`Error: '--run-migration' requires a migration id, e.g. '--run-migration=@nx/js:my-migration'.`);
@@ -755,8 +766,16 @@ async function parseMigrationsOptions(options, fetch) {
         if (options.runId === '') {
             throw new Error(`Error: '--run-id' requires the id of the migrate run to record into.`);
         }
-        if (options.runMigrations !== undefined) {
-            throw new Error(`Error: '--run-id' (reconcile an orchestrated run) cannot be combined with '--run-migrations' (run the whole migrations file).`);
+        // With `--run-migrations`, `--run-id` continues the named run, which needs
+        // `--agentic`; a start-fresh names the run it replaces instead.
+        if (options.runMigrations !== undefined &&
+            options.startFresh !== true &&
+            (options.agentic === undefined || options.agentic === false)) {
+            throw new Error(`Error: '--run-id' (reconcile an orchestrated run) cannot be combined with '--run-migrations' (run the whole migrations file). To continue the run, pass '--agentic' (or '--agentic=<agent>') as well.`);
+        }
+        if (options.runMigrations !== undefined &&
+            options.stepAction !== undefined) {
+            throw new Error(`Error: '--step-action' cannot be combined with '--run-migrations'.`);
         }
         // A bare '--run-id' reconciles the run it names. Ungated, unlike init:
         // the id has to name a run directory that exists, and only a gated init
@@ -766,13 +785,15 @@ async function parseMigrationsOptions(options, fetch) {
         if (options.stepAction !== undefined && !(0, step_actions_1.isStepAction)(options.stepAction)) {
             throw new Error(`Error: '--step-action' must be one of ${step_actions_1.STEP_ACTIONS.join(', ')}.`);
         }
-        return {
-            type: 'orchestratorReconcile',
-            runId: options.runId,
-            ...(options.stepAction !== undefined
-                ? { stepAction: options.stepAction }
-                : {}),
-        };
+        if (options.runMigrations === undefined) {
+            return {
+                type: 'orchestratorReconcile',
+                runId: options.runId,
+                ...(options.stepAction !== undefined
+                    ? { stepAction: options.stepAction }
+                    : {}),
+            };
+        }
     }
     if (options.stepAction !== undefined) {
         throw new Error(`Error: '--step-action' requires '--run-id'.`);
@@ -794,6 +815,8 @@ async function parseMigrationsOptions(options, fetch) {
             agentic: options.agentic,
             validate: options.validate,
             interactive: options.interactive,
+            ...(options.runId !== undefined ? { runId: options.runId } : {}),
+            ...(options.startFresh === true ? { startFresh: true } : {}),
         };
     }
     assertOptionalIncludeFlagCompatibility(options);
@@ -2093,6 +2116,9 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
         retainedAtSuccess: (0, migrate_output_1.retainedMigrations)(outcomes).map((p) => `${p.package}: ${p.name}`),
     };
 }
+function orchestratorFlagNeedsOrchestrator(flag) {
+    return `'${flag}' acts on an orchestrated migrate run (NX_MIGRATE_ORCHESTRATOR=true with an enabled agent), and this invocation is not orchestrated.`;
+}
 // nx is located at spawn time, after the gated pre-install, so the child runs
 // the bytes that install put in place.
 function handOffToLocalNx(args) {
@@ -2107,30 +2133,75 @@ function handOffToLocalNx(args) {
     return exitCode !== 0 ? exitCode : undefined;
 }
 async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall = false) {
+    // Both flags act on an orchestrated run: refuse them where none can run
+    // (an explicit --agentic=false outside an agent cannot reach one either),
+    // before the install and before --if-exists could return silently.
+    const orchestratorFlag = opts.startFresh === true
+        ? '--start-fresh'
+        : opts.runId !== undefined
+            ? '--run-id'
+            : undefined;
+    if (orchestratorFlag !== undefined &&
+        (process.env.NX_MIGRATE_ORCHESTRATOR !== 'true' ||
+            (opts.agentic === false && !(0, inception_1.isInsideAgent)()))) {
+        throw new Error(orchestratorFlagNeedsOrchestrator(orchestratorFlag));
+    }
+    const isContinue = opts.runId !== undefined && opts.startFresh !== true;
+    let continued;
+    if (isContinue) {
+        // Before the install: a concurrent start-fresh must not delete the run
+        // this command is about to continue.
+        const { holdRunToContinue } = require('./run');
+        continued = holdRunToContinue(root, opts.runId);
+    }
+    else if (opts.startFresh === true) {
+        // Before the install too: with no active run there is nothing to replace.
+        const { activeRunToReplace } = require('./run');
+        activeRunToReplace(root, opts.runId);
+    }
     if (!shouldSkipInstall && !process.env.NX_MIGRATE_SKIP_INSTALL) {
         await (0, execute_migration_1.runInstall)();
     }
     if (!__dirname.startsWith(workspace_root_1.workspaceRoot)) {
         // we are running from a temp installation with nx latest, switch to running
         // from local installation
+        if (isContinue) {
+            // The child holds the run itself and refuses while this process does.
+            const { releaseRunToHandOff } = require('./run');
+            releaseRunToHandOff(root, opts.runId);
+        }
         return handOffToLocalNx(args);
     }
-    const migrationsExists = (0, fileutils_1.fileExists)(opts.runMigrations);
-    if (opts.ifExists && !migrationsExists) {
-        output_1.output.log({
-            title: `Migrations file '${opts.runMigrations}' doesn't exist`,
-        });
-        return;
+    let migrationsJson;
+    if (isContinue) {
+        // A continue runs the plan the run recorded, not whatever the workspace's
+        // migrations file holds now (it may be gone, or belong to another plan).
+        const { latestRound, runDir } = require('./run');
+        const round = latestRound(continued);
+        if (!round) {
+            throw new Error(`Migrate run '${opts.runId}' records no plan.`);
+        }
+        migrationsJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(runDir(root, opts.runId), round.planSnapshot));
     }
-    else if (!opts.ifExists && !migrationsExists) {
-        throw new Error(`File '${opts.runMigrations}' doesn't exist, can't run migrations. Use flag --if-exists to run migrations only if the file exists`);
+    else {
+        const migrationsExists = (0, fileutils_1.fileExists)(opts.runMigrations);
+        if (opts.ifExists && !migrationsExists) {
+            output_1.output.log({
+                title: `Migrations file '${opts.runMigrations}' doesn't exist`,
+            });
+            return;
+        }
+        else if (!opts.ifExists && !migrationsExists) {
+            throw new Error(`File '${opts.runMigrations}' doesn't exist, can't run migrations. Use flag --if-exists to run migrations only if the file exists`);
+        }
+        migrationsJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, opts.runMigrations));
     }
-    const migrationsJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, opts.runMigrations));
     const migrations = migrationsJson.migrations;
     // Defer the nx package lookup until an orchestrated branch needs this payload.
     const orchestratorInitInput = (createCommits) => ({
         root,
         migrationsJson,
+        migrationsPath: opts.runMigrations,
         createCommits,
         commitPrefix,
         // The flag only, never NX_MIGRATE_SKIP_INSTALL: the wrapper's local
@@ -2142,10 +2213,11 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
         validate: opts.validate,
     });
     // An outer agent drives the loop, so hand off to the orchestrator instead of
-    // the classic loop: init either starts a fresh run or resumes an already-
-    // active one. `--run-id` reconciles are dispatched separately and never
-    // reach here.
+    // the classic loop: init starts a fresh run or reports an already-active
+    // one; `--run-id` continues that run. Bare `--run-id` reconciles are
+    // dispatched separately and never reach here.
     if (process.env.NX_MIGRATE_ORCHESTRATOR === 'true' && (0, inception_1.isInsideAgent)()) {
+        const { runOrchestratorInit, runOrchestratorResume } = require('./run');
         // Orchestrated runs are agent-driven, so commits default on exactly as they
         // do under `--agentic=enabled`; the orchestrator replaces `resolveAgentic`.
         const { effective: effectiveCreateCommits, warning: createCommitsWarning, error: createCommitsError, } = (0, migrate_commits_1.resolveCreateCommits)({
@@ -2160,28 +2232,49 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
         if (createCommitsWarning) {
             output_1.output.warn({ title: createCommitsWarning });
         }
+        if (isContinue) {
+            runOrchestratorResume({
+                root,
+                runId: opts.runId,
+                policy: {
+                    createCommits: effectiveCreateCommits,
+                    skipInstall: shouldSkipInstall,
+                },
+            });
+            return;
+        }
         // The run commits on the user's behalf across many invocations and the
         // agent driving it cannot answer a terminal prompt, so a commit policy the
         // user never asked for stops the run on the default branch before any of
         // them. `--create-commits` or nx.json `migrate.createCommits` is that ask.
-        if (effectiveCreateCommits && shouldCreateCommits === undefined) {
+        // Asked by init only once it is about to start a run: an active run is
+        // reported instead, and keeps its own policy.
+        const refuseCommitsOnDefaultBranch = async () => {
+            if (!effectiveCreateCommits || shouldCreateCommits !== undefined) {
+                return true;
+            }
             const defaultBranch = (0, migrate_commits_1.currentBranchIfDefault)(root);
-            if (defaultBranch) {
-                output_1.output.log({
-                    title: `Not starting the run: you are on the default branch '${defaultBranch}' and nx migrate would create a commit for each migration on it.`,
-                    bodyLines: [
-                        'Ask the user how to proceed, then either:',
-                        '- re-run with --create-commits to commit on this branch for this run,',
-                        '- set "migrate": { "createCommits": true } in nx.json to always allow it, then re-run,',
-                        '- or switch to another branch and re-run.',
-                    ],
-                });
-                return;
+            if (!defaultBranch) {
+                return true;
             }
-        }
+            output_1.output.log({
+                title: `Not starting the run: you are on the default branch '${defaultBranch}' and nx migrate would create a commit for each migration on it.`,
+                bodyLines: [
+                    'Ask the user how to proceed, then either:',
+                    '- re-run with --create-commits to commit on this branch for this run,',
+                    '- set "migrate": { "createCommits": true } in nx.json to always allow it, then re-run,',
+                    '- or switch to another branch and re-run.',
+                ],
+            });
+            return false;
+        };
         const init = orchestratorInitInput(effectiveCreateCommits);
-        const { runOrchestratorInit } = require('./run');
-        await runOrchestratorInit(init);
+        await runOrchestratorInit({
+            ...init,
+            onExistingRun: opts.startFresh === true ? 'start-fresh' : 'report',
+            ...(opts.startFresh === true ? { replaceRunId: opts.runId } : {}),
+            confirmStart: refuseCommitsOnDefaultBranch,
+        });
         return;
     }
     (0, migrate_analytics_1.reportMigrateRunStart)({
@@ -2213,11 +2306,12 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
     if (createCommitsWarning) {
         output_1.output.warn({ title: createCommitsWarning });
     }
-    if (effectiveCreateCommits &&
-        (0, safe_prompt_1.canPrompt)(opts.interactive) &&
-        !(await (0, migrate_commits_1.confirmMigrationCommitsOnDefaultBranch)(root, 'running migrations'))) {
-        return;
-    }
+    // Asked only for a run this invocation starts: the master session hands it
+    // to init, which asks once it is about to start one; a continued run keeps
+    // the policy it was started with.
+    const confirmNewRunCommits = async () => !effectiveCreateCommits ||
+        !(0, safe_prompt_1.canPrompt)(opts.interactive) ||
+        (0, migrate_commits_1.confirmMigrationCommitsOnDefaultBranch)(root, 'running migrations');
     // Dark: with the env var set, the agent drives the whole run through the
     // orchestrator from one session instead of being spawned per step. Not
     // under WASM, where the broker has no native lock to detect a dead parent.
@@ -2226,7 +2320,20 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
         !native_1.IS_WASM) {
         const init = orchestratorInitInput(effectiveCreateCommits);
         const { runMasterSession } = require('./agentic/master/run-master-session');
-        return await runMasterSession({ ...init, agent: agentic.selectedAgent });
+        return await runMasterSession({
+            ...init,
+            agent: agentic.selectedAgent,
+            interactive: opts.interactive,
+            runId: opts.runId,
+            startFresh: opts.startFresh,
+            confirmStart: confirmNewRunCommits,
+        });
+    }
+    if (orchestratorFlag !== undefined) {
+        throw new Error(orchestratorFlagNeedsOrchestrator(orchestratorFlag));
+    }
+    if (!(await confirmNewRunCommits())) {
+        return;
     }
     const shouldRunValidation = resolveShouldRunValidation({
         validate: opts.validate,

package/dist/src/command-line/migrate/resolve-package-version.js

@@ -15,6 +15,7 @@ const policy_1 = require("../../utils/min-release-age/policy");
 const pnpm_exclude_writer_1 = require("../../utils/min-release-age/pnpm-exclude-writer");
 const resolve_1 = require("../../utils/min-release-age/resolve");
 const safe_prompt_1 = require("./safe-prompt");
+const text_1 = require("./text");
 /**
  * Whether nx migrate should resolve versions via the npm registry (fast) rather
  * than via a real package-manager install. Precedence, highest first:
@@ -195,7 +196,7 @@ async function handleViolation(packageName, error, policy) {
     // sorted newest-first, so the resolver's pick is the last entry. Mirror the
     // loose path: prompt for, exclude, and return that one version.
     const resolved = error.blocked[error.blocked.length - 1];
-    const blockedLine = `  ${packageName}@${resolved.version} (published ${formatPublishAge(resolved.publishedAt)})`;
+    const blockedLine = `  ${packageName}@${resolved.version} (published ${(0, text_1.formatAge)(resolved.publishedAt)})`;
     // pnpm prompts once for the whole run; remember an approval for later picks.
     if (!strictApprovalGranted) {
         const approved = await (0, safe_prompt_1.migrateConfirm)({
@@ -225,21 +226,3 @@ async function handleViolation(packageName, error, policy) {
     ]);
     return resolved.version;
 }
-// Renders a registry ISO publish timestamp as a human age for the strict prompt
-// (e.g. "6 hours ago"), falling back to the raw value when it is not parseable.
-function formatPublishAge(publishedAt) {
-    const elapsedMs = Date.now() - Date.parse(publishedAt);
-    if (!Number.isFinite(elapsedMs) || elapsedMs < 0) {
-        return publishedAt;
-    }
-    const minutes = Math.floor(elapsedMs / 60_000);
-    if (minutes < 60) {
-        return `${minutes} minute${minutes === 1 ? '' : 's'} ago`;
-    }
-    const hours = Math.floor(elapsedMs / 3_600_000);
-    if (hours < 48) {
-        return `${hours} hour${hours === 1 ? '' : 's'} ago`;
-    }
-    const days = Math.floor(elapsedMs / 86_400_000);
-    return `${days} day${days === 1 ? '' : 's'} ago`;
-}

package/dist/src/command-line/migrate/run/broker.d.ts

@@ -1,14 +1,16 @@
 import { type DeferredOutputRecord } from '../deferred-output';
 import { type CommitResult } from '../migrate-commits';
+import { type GiveUpOutcome } from './give-up';
 import { type MigrateRunPolicy, type MigrateRunState, type MigrateStep, type MigrateTreeOperation } from './run-state';
 export declare const BROKER_ENV_VAR = "NX_MIGRATE_BROKER";
-export type BrokerRequestKind = 'commit' | 'install' | 'fold-install' | 'action-install' | 'reset';
+export type BrokerRequestKind = 'commit' | 'install' | 'fold-install' | 'action-install' | 'reset' | 'give-up';
 export type InstallSeam = 'install' | 'fold-install' | 'action-install';
 export interface BrokerRequest {
     kind: BrokerRequestKind;
     stepId: string;
     attempt: number;
     invocation?: string;
+    commitAs?: 'adopt';
 }
 export type BrokerResult = {
     kind: 'commit';
@@ -26,6 +28,10 @@ export type BrokerResult = {
 } | {
     kind: 'reset';
     error?: string;
+} | {
+    kind: 'give-up';
+    outcome: GiveUpOutcome;
+    output: DeferredOutputRecord[];
 } | {
     kind: 'stale';
 };
@@ -95,7 +101,7 @@ export declare function brokerDir(runDirPath: string): string;
  * collected, printed here. The absorbed step ids come from whichever side
  * ran the commit, so the ledger entry names what its `git add -A` took.
  */
-export declare function commitStepTree(dir: string, step: MigrateStep, absorbedStepIds: string[], commitInProcess: () => Promise<CommitResult>, scope: TreeScope): Promise<BrokeredCommit>;
+export declare function commitStepTree(dir: string, step: MigrateStep, absorbedStepIds: string[], commitInProcess: () => Promise<CommitResult>, scope: TreeScope, commitAs?: 'adopt'): Promise<BrokeredCommit>;
 /**
  * The same for a step that owes only its install: no commit is due, or the
  * commit waits for a fold.
@@ -107,6 +113,12 @@ export declare function installStepTree(dir: string, step: MigrateStep, seam: In
  * against the state it reads then; a reset that could not run throws.
  */
 export declare function resetStepTree(dir: string, step: MigrateStep, resetInProcess: () => void, scope: TreeScope): Promise<void>;
+/**
+ * The same for giving a failed or died step up while the run commits. Unlike
+ * the seams above, the operation settles the step itself, under the
+ * reservation it runs with, so the caller writes no transition of its own.
+ */
+export declare function giveUpStepTree(root: string, dir: string, step: MigrateStep, skipInstall: boolean, reconcileCommand: string, scope: TreeScope): Promise<GiveUpOutcome>;
 /**
  * The parent side. Holds one exclusive lock for the session's lifetime so a
  * waiting step can tell a slow parent from a dead one, answers each request

package/dist/src/command-line/migrate/run/broker.js

@@ -18,6 +18,7 @@ exports.brokerDir = brokerDir;
 exports.commitStepTree = commitStepTree;
 exports.installStepTree = installStepTree;
 exports.resetStepTree = resetStepTree;
+exports.giveUpStepTree = giveUpStepTree;
 const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -29,6 +30,7 @@ const deferred_output_1 = require("../deferred-output");
 const execute_migration_1 = require("../execute-migration");
 const migrate_commits_1 = require("../migrate-commits");
 const atomic_write_1 = require("./atomic-write");
+const give_up_1 = require("./give-up");
 const run_state_1 = require("./run-state");
 const state_lock_1 = require("./state-lock");
 const state_machine_1 = require("./state-machine");
@@ -72,7 +74,7 @@ function acquireTreeOperation(dir, request, owner = (0, crypto_1.randomBytes)(4)
         if (held)
             throw new TreeBusyError(treeBusyMessage(held));
         marks =
-            request.kind === 'commit' &&
+            (request.kind === 'commit' || request.kind === 'give-up') &&
                 fresh.steps.find((s) => s.id === request.stepId)?.commitStarted !== true;
         return {
             ...(marks ? (0, state_machine_1.markCommitStarted)(fresh, request.stepId) : fresh),
@@ -115,9 +117,23 @@ function treeBusyMessage(held) {
     return `The working tree is held by process ${held.pid} for ${treeOperationLabel(held)}; run the reconcile again once it finishes.`;
 }
 function treeOperationLabel(held) {
-    return held.kind === 'checkpoint'
-        ? 'the checkpoint commit'
-        : `the ${held.kind === 'commit' || held.kind === 'reset' ? held.kind : 'install'} of step '${held.stepId}'`;
+    switch (held.kind) {
+        case 'checkpoint':
+            return 'the checkpoint commit';
+        case 'commit':
+        case 'give-up':
+            return `the commit of step '${held.stepId}'`;
+        case 'reset':
+            return `the reset of step '${held.stepId}'`;
+        case 'install':
+        case 'fold-install':
+        case 'action-install':
+            return `the install of step '${held.stepId}'`;
+        default: {
+            const exhaustive = held.kind;
+            throw new Error(`Unhandled tree operation '${exhaustive}'.`);
+        }
+    }
 }
 function atSeam(state, request) {
     if (request.kind === 'checkpoint') {
@@ -131,16 +147,21 @@ function atSeam(state, request) {
         isAtSeam(state.steps.find((s) => s.id === request.stepId), request));
 }
 const SEAM_STATUSES = {
-    commit: new Set(['running', 'awaiting-prompt-outcome', 'died']),
+    commit: new Set(['running', 'awaiting-prompt-outcome', 'failed', 'died']),
     install: new Set(['running']),
     'fold-install': new Set(['awaiting-prompt-outcome']),
     'action-install': new Set(['failed', 'died']),
     reset: new Set(['failed', 'died']),
+    'give-up': new Set(['failed', 'died']),
 };
 function isAtSeam(step, request) {
-    return (step !== undefined &&
-        step.attempt === request.attempt &&
-        SEAM_STATUSES[request.kind].has(step.status));
+    if (step === undefined || step.attempt !== request.attempt)
+        return false;
+    // A failed step commits only through its adopt.
+    if (request.kind === 'commit' && step.status === 'failed') {
+        return request.commitAs === 'adopt';
+    }
+    return SEAM_STATUSES[request.kind].has(step.status);
 }
 function brokerDir(runDirPath) {
     return (0, path_1.join)(runDirPath, BROKER_DIR_NAME);
@@ -167,18 +188,19 @@ function readRequestFile(filePath) {
  * collected, printed here. The absorbed step ids come from whichever side
  * ran the commit, so the ledger entry names what its `git add -A` took.
  */
-async function commitStepTree(dir, step, absorbedStepIds, commitInProcess, scope) {
+async function commitStepTree(dir, step, absorbedStepIds, commitInProcess, scope, commitAs) {
     const request = {
         kind: 'commit',
         stepId: step.id,
         attempt: step.attempt,
+        ...(commitAs !== undefined ? { commitAs } : {}),
     };
     const nonce = process.env[exports.BROKER_ENV_VAR];
     if (!nonce) {
         const lease = acquireTreeOperation(dir, request);
         scope.lease = lease;
         const result = await commitInProcess();
-        if (gitRan(result))
+        if ((0, state_machine_1.gitRan)(result))
             lease.markedStepId = undefined;
         return { result, absorbedStepIds, recorded: false };
     }
@@ -192,24 +214,6 @@ async function commitStepTree(dir, step, absorbedStepIds, commitInProcess, scope
         recorded: true,
     };
 }
-// Whether git may have written history for this result. A landed commit's
-// mark is the ledger entry's to clear, and a failure reported once git ran
-// (a hook's output overflowing the subprocess buffer after the commit) cannot
-// vouch that nothing landed, so only the other results release the mark.
-function gitRan(result) {
-    switch (result.status) {
-        case 'committed':
-        case 'failed':
-            return true;
-        case 'no-changes':
-        case 'disabled':
-            return false;
-        default: {
-            const exhaustive = result;
-            throw new Error(`Unhandled commit result: ${JSON.stringify(exhaustive)}`);
-        }
-    }
-}
 /**
  * The same for a step that owes only its install: no commit is due, or the
  * commit waits for a fold.
@@ -252,8 +256,38 @@ async function resetStepTree(dir, step, resetInProcess, scope) {
         throw new Error(`Unexpected '${answer.kind}' answer to a reset request.`);
     }
 }
+/**
+ * The same for giving a failed or died step up while the run commits. Unlike
+ * the seams above, the operation settles the step itself, under the
+ * reservation it runs with, so the caller writes no transition of its own.
+ */
+async function giveUpStepTree(root, dir, step, skipInstall, reconcileCommand, scope) {
+    const request = {
+        kind: 'give-up',
+        stepId: step.id,
+        attempt: step.attempt,
+    };
+    const nonce = process.env[exports.BROKER_ENV_VAR];
+    if (!nonce) {
+        const lease = acquireTreeOperation(dir, request);
+        scope.lease = lease;
+        return (0, give_up_1.giveUpWithCommit)({
+            root,
+            dir,
+            step,
+            lease,
+            skipInstall,
+            reconcileCommand,
+        });
+    }
+    const answer = await ask(dir, nonce, request);
+    if (answer.kind !== 'give-up') {
+        throw new Error(`Unexpected '${answer.kind}' answer to a give-up request.`);
+    }
+    return answer.outcome;
+}
 async function ask(dir, nonce, request) {
-    const id = `${nonce}-${request.stepId}-${request.attempt}-${request.kind}${request.invocation ? `-${request.invocation}` : ''}`;
+    const id = `${nonce}-${request.stepId}-${request.attempt}-${request.kind}${request.invocation ? `-${request.invocation}` : ''}${request.commitAs !== undefined ? `-${request.commitAs}` : ''}`;
     const path = resultPath(dir, id);
     // A repeat reads the first answer, whatever became of the session since.
     if ((0, fs_1.existsSync)(path)) {
@@ -320,6 +354,9 @@ function settle(result) {
             if (result.error !== undefined)
                 throw new Error(result.error);
             return result;
+        case 'give-up':
+            (0, deferred_output_1.replayDeferredOutput)(result.output);
+            return result;
         case 'stale':
             throw new BrokerStaleRequestError(`The request for this step no longer matches its attempt; nothing was installed or committed.`);
         default: {
@@ -388,12 +425,12 @@ class MigrateCommitBroker {
             try {
                 if (lease)
                     this.inFlight = request;
-                result = lease ? await this.answer(request) : { kind: 'stale' };
+                result = lease ? await this.answer(request, lease) : { kind: 'stale' };
                 // Recorded by the process that ran the commit, before the answer: the
                 // step reading it can die with the commit already in history. A failed
                 // record throws and ends the session rather than losing the entry.
                 if (result.kind === 'commit') {
-                    if (gitRan(result.result))
+                    if ((0, state_machine_1.gitRan)(result.result))
                         lease.markedStepId = undefined;
                     this.record(request, result);
                 }
@@ -424,15 +461,39 @@ class MigrateCommitBroker {
             };
         });
     }
-    async answer(request) {
+    async answer(request, lease) {
         const state = (0, run_state_1.readRunState)(this.dir);
         const step = state.steps.find((s) => s.id === request.stepId);
         if (!Object.hasOwn(SEAM_STATUSES, request.kind) ||
             !isAtSeam(step, request) ||
-            ((request.kind === 'commit' || request.kind === 'reset') &&
-                !this.policy.createCommits)) {
+            ((request.kind === 'commit' ||
+                request.kind === 'reset' ||
+                request.kind === 'give-up') &&
+                !this.policy.createCommits) ||
+            (request.commitAs !== undefined && request.commitAs !== 'adopt')) {
             return { kind: 'stale' };
         }
+        if (request.kind === 'give-up') {
+            const output = new deferred_output_1.DeferredOutputCollector();
+            const outcome = await (0, give_up_1.giveUpWithCommit)({
+                root: this.root,
+                dir: this.dir,
+                step,
+                lease,
+                skipInstall: this.policy.skipInstall,
+                reconcileCommand: this.reconcileCommand,
+                output,
+            });
+            // Raw package-manager output only for a failed install, as for a commit.
+            return {
+                kind: 'give-up',
+                outcome,
+                output: output.render(outcome.kind === 'given-up' &&
+                    outcome.commit.status === 'install-failed'
+                    ? 'keep'
+                    : 'drop'),
+            };
+        }
         if (request.kind === 'reset') {
             try {
                 (0, clean_retry_1.resetForCleanRetry)(this.root, this.dir, step.id);