nx 24.0.0-beta.0 → 24.0.0-beta.1

package/dist/nx-cloud-internals.d.ts

@@ -1 +1,2 @@
 export { importUltracacheConfigurations, openUltracacheConfigurations, } from './src/ultracache/store';
+export declare const TASK_GRAPH_FORMAT = 2;

package/dist/nx-cloud-internals.js

@@ -3,7 +3,13 @@
 // a public API. The client probes these exports to tell what this nx supports,
 // so keep them stable.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openUltracacheConfigurations = exports.importUltracacheConfigurations = void 0;
+exports.TASK_GRAPH_FORMAT = exports.openUltracacheConfigurations = exports.importUltracacheConfigurations = void 0;
 var store_1 = require("./src/ultracache/store");
 Object.defineProperty(exports, "importUltracacheConfigurations", { enumerable: true, get: function () { return store_1.importUltracacheConfigurations; } });
 Object.defineProperty(exports, "openUltracacheConfigurations", { enumerable: true, get: function () { return store_1.openUltracacheConfigurations; } });
+// Nx Cloud reads it to pick the task-graph shape it hands this nx. Bump it when
+// the shape changes in a way Cloud must handle.
+//   1: `dependencies` and `continuousDependencies` edges are task ids (implied
+//      when the export is absent)
+//   2: edges are objects (`{ id, waitFor?, inputs? }`)
+exports.TASK_GRAPH_FORMAT = 2;

package/dist/src/command-line/migrate/agentic/close-agent-session.d.ts

@@ -18,4 +18,4 @@ export declare function waitForExit(child: ChildProcess): Promise<ExitInfo>;
  * orphan the agent. `taskkill` failures are swallowed.
  */
 export declare function closeAgentSession(child: ChildProcess, exitPromise: Promise<ExitInfo>, gracefulExitMs: number, forceKillWaitMs: number): Promise<void>;
-export declare function raceWithTimeout(promise: Promise<unknown>, timeoutMs: number): Promise<void>;
+export declare function raceWithTimeout(promise: Promise<unknown>, timeoutMs: number): Promise<boolean>;

package/dist/src/command-line/migrate/agentic/close-agent-session.js

@@ -109,13 +109,14 @@ async function forceKillWindowsTree(child, exitPromise, forceKillWaitMs) {
     }
     await raceWithTimeout(exitPromise, forceKillWaitMs);
 }
+// True when `promise` resolves before the timeout.
 async function raceWithTimeout(promise, timeoutMs) {
     let timer;
     try {
-        await Promise.race([
-            promise,
+        return await Promise.race([
+            promise.then(() => true),
             new Promise((resolve) => {
-                timer = setTimeout(resolve, timeoutMs);
+                timer = setTimeout(() => resolve(false), timeoutMs);
             }),
         ]);
     }

package/dist/src/command-line/migrate/agentic/master/spawn-master.js

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spawnMasterSession = spawnMasterSession;
 const child_process_1 = require("child_process");
+const events_1 = require("events");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const exit_codes_1 = require("../../../../utils/exit-codes");
 const logger_1 = require("../../../../utils/logger");
 const output_1 = require("../../../../utils/output");
+const spawn_without_terminal_1 = require("../../../../utils/spawn-without-terminal");
 const migrate_output_1 = require("../../migrate-output");
 const run_1 = require("../../run");
 const close_agent_session_1 = require("../close-agent-session");
@@ -13,6 +16,12 @@ const handoff_1 = require("../handoff");
 const terminal_repair_1 = require("../terminal-repair");
 const windows_cmd_1 = require("../windows-cmd");
 const invocations_1 = require("./invocations");
+// How long a second Ctrl+C waits for the killed operation to settle before nx
+// stops waiting on it: only a process that left its group can hold it open.
+const OPERATION_KILL_WAIT_MS = 2_000;
+// SIGINTs this close together are one Ctrl+C: `npx` and the package managers
+// pass on to nx the SIGINT the terminal already sent it.
+const SAME_PRESS_MS = 500;
 // The wrapper's local re-exec sets the first two for its own hop and the user
 // sets the third to reach this path; inherited, they would change install or
 // routing behavior for every `nx migrate` the agent runs. CI exports the last
@@ -80,9 +89,26 @@ async function spawnMasterSession(input) {
         broker?.close();
         return { kind: 'spawn-failed', error: toError(error) };
     }
-    // Ctrl+C belongs to the agent from the moment it exists.
-    const swallowSigint = () => { };
-    process.on('SIGINT', swallowSigint);
+    // Ctrl+C belongs to the agent from the moment it exists. The operations the
+    // broker runs have no terminal, so nx passes on what would have reached them
+    // through it, and ends them when it goes away itself.
+    const ctrlC = new events_1.EventEmitter();
+    let lastPressAt = -Infinity;
+    const forwardSigint = () => {
+        const now = Date.now();
+        if (now - lastPressAt < SAME_PRESS_MS)
+            return;
+        lastPressAt = now;
+        (0, spawn_without_terminal_1.signalCommandsWithoutTerminal)('SIGINT');
+        ctrlC.emit('press');
+    };
+    const exitOnSignal = (signal) => {
+        (0, spawn_without_terminal_1.signalCommandsWithoutTerminal)(signal);
+        process.exit((0, exit_codes_1.signalToCode)(signal));
+    };
+    process.on('SIGINT', forwardSigint);
+    process.on('SIGHUP', exitOnSignal);
+    process.on('SIGTERM', exitOnSignal);
     const sentinelWatch = new AbortController();
     let brokerFailure;
     // Settles when the poll aborts and the request in flight is answered, or
@@ -133,17 +159,33 @@ async function spawnMasterSession(input) {
     finally {
         sentinelWatch.abort();
         // With the agent gone, the terminal is restored before the wait: an
-        // agent that left it raw would keep a Ctrl+C from reaching the operation
-        // in flight as a signal.
+        // agent that left it raw would keep a Ctrl+C from reaching nx as a signal.
         const exited = child.exitCode !== null || child.signalCode !== null;
+        let stoppedWaiting = false;
         if (started && exited) {
             restoreTerminal();
-            warnOperationInFlight(broker);
+            const inFlight = warnOperationInFlight(broker);
+            if (inFlight && (await interruptedTwice(brokerDone, ctrlC))) {
+                (0, spawn_without_terminal_1.signalCommandsWithoutTerminal)('SIGKILL');
+                if (!(await (0, close_agent_session_1.raceWithTimeout)(brokerDone, OPERATION_KILL_WAIT_MS))) {
+                    stoppedWaiting = true;
+                    output_1.output.warn({
+                        title: `Stopped waiting for ${(0, run_1.treeOperationLabel)(inFlight.request, inFlight.stepName)}.`,
+                        bodyLines: [
+                            'A process it started may still be running. Resume the run once it has exited.',
+                        ],
+                    });
+                }
+            }
         }
-        // The request in flight settles before the lock is released.
-        await brokerDone;
+        // The request in flight settles before the lock is released, unless nx
+        // stopped waiting on it above.
+        if (!stoppedWaiting)
+            await brokerDone;
         broker.close();
-        process.removeListener('SIGINT', swallowSigint);
+        process.removeListener('SIGINT', forwardSigint);
+        process.removeListener('SIGHUP', exitOnSignal);
+        process.removeListener('SIGTERM', exitOnSignal);
         if (started && !exited)
             restoreTerminal();
     }
@@ -155,15 +197,34 @@ function restoreTerminal() {
     (0, terminal_repair_1.restoreTermiosAfterAgent)();
     (0, migrate_output_1.resetSgrAfterAgent)();
 }
-// With the agent gone a Ctrl+C reaches the operation's child process, and
-// nothing else tells the user one is still running.
+// With the agent gone nothing else tells the user an operation still runs.
 function warnOperationInFlight(broker) {
-    const request = broker.requestInFlight;
-    if (!request)
-        return;
+    const inFlight = broker.requestInFlight;
+    if (!inFlight)
+        return null;
     output_1.output.warn({
-        title: `Still running ${(0, run_1.treeOperationLabel)(request)} for this migrate run. Press Ctrl+C to end it; the run can be resumed afterwards.`,
+        title: `Still running ${(0, run_1.treeOperationLabel)(inFlight.request, inFlight.stepName)} for this migrate run (${(0, run_1.formatElapsed)(Date.now() - inFlight.startedAt)} so far).${(0, run_1.commitsStep)(inFlight.request.kind) ? ` ${run_1.COMMIT_INSTALLS_FIRST}` : ''} Press Ctrl+C to end it, and again to stop everything it started. The run can be resumed afterwards.`,
+    });
+    return inFlight;
+}
+// The first Ctrl+C reaches the operation as usual; the second ends whatever
+// outlived it.
+async function interruptedTwice(done, ctrlC) {
+    let countPress;
+    const secondPress = new Promise((resolve) => {
+        let presses = 0;
+        countPress = () => {
+            if (++presses === 2)
+                resolve(true);
+        };
     });
+    ctrlC.on('press', countPress);
+    try {
+        return await Promise.race([done.then(() => false), secondPress]);
+    }
+    finally {
+        ctrlC.removeListener('press', countPress);
+    }
 }
 async function serviceBrokerUntilAborted(broker, intervalMs, signal) {
     while (!signal.aborted) {

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

@@ -9,8 +9,8 @@ interface PackageMigrationConfig extends NxMigrationsConfiguration {
 export declare function readPackageMigrationConfig(packageName: string, dir: string): PackageMigrationConfig;
 /**
  * With a `sink`, stdin is ignored and stdout and stderr are collected for a
- * caller sharing the terminal. On POSIX the child stays in nx's process
- * group. Without a sink, the install owns the terminal.
+ * caller sharing the terminal, and the install runs without the terminal (see
+ * `spawnWithoutTerminal`). Without a sink, the install owns the terminal.
  */
 export declare function runInstall(nxWorkspaceRoot?: string, phase?: MigrationInstallPhase, rerunCommand?: string, sink?: MigrateOutputSink): Promise<void>;
 export type MigrationInstallPhase = 'pre-migration' | 'post-migration';

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

@@ -33,6 +33,7 @@ const package_manager_1 = require("../../utils/package-manager");
 const fs_1 = require("fs");
 const installation_directory_1 = require("../../utils/installation-directory");
 const shell_quoting_1 = require("../../utils/shell-quoting");
+const spawn_without_terminal_1 = require("../../utils/spawn-without-terminal");
 const project_graph_1 = require("../../project-graph/project-graph");
 const version_utils_1 = require("./version-utils");
 const deferred_output_1 = require("./deferred-output");
@@ -64,8 +65,8 @@ function readPackageMigrationConfig(packageName, dir) {
 }
 /**
  * With a `sink`, stdin is ignored and stdout and stderr are collected for a
- * caller sharing the terminal. On POSIX the child stays in nx's process
- * group. Without a sink, the install owns the terminal.
+ * caller sharing the terminal, and the install runs without the terminal (see
+ * `spawnWithoutTerminal`). Without a sink, the install owns the terminal.
  */
 function runInstall(nxWorkspaceRoot, phase = 'pre-migration', rerunCommand, sink) {
     const cwd = nxWorkspaceRoot ?? process.cwd();
@@ -81,14 +82,21 @@ function runInstall(nxWorkspaceRoot, phase = 'pre-migration', rerunCommand, sink
         // Without a sink it is mirrored live and other package managers inherit
         // stderr directly, since their output is not inspected.
         const shouldCaptureStderr = packageManager === 'npm';
-        const child = (0, child_process_1.spawn)(installCommand, {
-            shell: true,
-            stdio: sink
-                ? ['ignore', 'pipe', 'pipe']
-                : ['inherit', 'inherit', shouldCaptureStderr ? 'pipe' : 'inherit'],
-            windowsHide: true,
-            cwd,
-        });
+        const child = sink
+            ? (0, spawn_without_terminal_1.spawnWithoutTerminal)(installCommand, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd,
+            })
+            : (0, child_process_1.spawn)(installCommand, {
+                shell: true,
+                stdio: [
+                    'inherit',
+                    'inherit',
+                    shouldCaptureStderr ? 'pipe' : 'inherit',
+                ],
+                windowsHide: true,
+                cwd,
+            });
         // Decoded per stream: a chunk boundary can split a multi-byte character,
         // and a sequence still incomplete at the end is what `end()` returns.
         const stdoutText = new string_decoder_1.StringDecoder('utf8');

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

@@ -31,13 +31,16 @@ export type CommitResult = {
  * The default `failureGuidance` describes the classic loop's absorb-and-recap
  * behavior; a caller with no later commit or recap to absorb the diff (the
  * standalone single-migration worker) passes its own.
+ *
+ * A `sink` collects the output for a caller sharing the terminal with an
+ * agent, and the commit then runs without the terminal.
  */
 export declare function commitMigrationIfRequested(root: string, migration: {
     name: string;
 }, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged: () => Promise<void>, pendingMigrations?: ReadonlyArray<{
     package: string;
     name: string;
-}>, failureGuidance?: string, out?: MigrateOutputSink): Promise<CommitResult>;
+}>, failureGuidance?: string, sink?: MigrateOutputSink): Promise<CommitResult>;
 /**
  * Commits any pre-existing working-tree state into a dedicated "checkpoint"
  * commit before the first migration runs. Without this, the first migration's

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

@@ -20,6 +20,9 @@ const deferred_output_1 = require("./deferred-output");
 // ignore rule that normally hides it goes missing mid-run (a checkout, a
 // .gitignore edit, or the migration's own changes).
 const MIGRATE_COMMIT_EXCLUDES = [types_1.MIGRATE_RUNS_RELATIVE_DIR];
+// Without it the agent continues as the absorb guidance says, and a cause that
+// fails every commit leaves the whole run uncommitted.
+const AGENT_SESSION_COMMIT_FAILURE = "Commits in this session cannot ask for input, such as a signing passphrase or a hook's prompt, so later commits may fail the same way until the cause is fixed. Before the next step, tell the user what failed and ask whether to fix the cause first or to continue as is. Either way nx tries every later commit, and the first one that lands includes these changes.";
 /**
  * `pendingMigrations` are listed in the commit body so a `git log -p` reader
  * can see which earlier migrations' diffs this commit absorbed (their own
@@ -28,10 +31,14 @@ const MIGRATE_COMMIT_EXCLUDES = [types_1.MIGRATE_RUNS_RELATIVE_DIR];
  * The default `failureGuidance` describes the classic loop's absorb-and-recap
  * behavior; a caller with no later commit or recap to absorb the diff (the
  * standalone single-migration worker) passes its own.
+ *
+ * A `sink` collects the output for a caller sharing the terminal with an
+ * agent, and the commit then runs without the terminal.
  */
-async function commitMigrationIfRequested(root, migration, shouldCreateCommits, commitPrefix, installDepsIfChanged, pendingMigrations = [], failureGuidance = 'Any uncommitted changes will be included in the next successful commit, which will reference this migration; if they remain uncommitted, the end-of-run output will list this migration so you can commit or revert them manually.', out = deferred_output_1.terminalOutput) {
+async function commitMigrationIfRequested(root, migration, shouldCreateCommits, commitPrefix, installDepsIfChanged, pendingMigrations = [], failureGuidance = 'Any uncommitted changes will be included in the next successful commit, which will reference this migration; if they remain uncommitted, the end-of-run output will list this migration so you can commit or revert them manually.', sink) {
     if (!shouldCreateCommits)
         return { status: 'disabled' };
+    const out = sink ?? deferred_output_1.terminalOutput;
     await installDepsIfChanged();
     // Generator may have only touched gitignored paths or the excluded scratch
     // dir, or the prompt half made no change: log neutrally, not as an error.
@@ -42,7 +49,7 @@ async function commitMigrationIfRequested(root, migration, shouldCreateCommits,
     }
     const commitMessage = buildCommitMessage(`${commitPrefix}${migration.name}`, pendingMigrations);
     try {
-        const sha = await (0, git_utils_1.tryCommitChangesAsync)(commitMessage, root, MIGRATE_COMMIT_EXCLUDES);
+        const sha = await (0, git_utils_1.tryCommitChangesAsync)(commitMessage, root, MIGRATE_COMMIT_EXCLUDES, { withoutTerminal: sink !== undefined });
         if (sha)
             return { status: 'committed', sha };
         // null = commit landed but `git rev-parse HEAD` failed (see
@@ -52,7 +59,7 @@ async function commitMigrationIfRequested(root, migration, shouldCreateCommits,
     }
     catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        out.line('red', `The commit for ${migration.name} failed:\n${reason}\nCheck \`git status\` and \`git log\`; the commit may have landed despite this error. ${failureGuidance}`);
+        out.line('red', `The commit for ${migration.name} failed:\n${reason}\nCheck \`git status\` and \`git log\`; the commit may have landed despite this error. ${failureGuidance}${sink ? ` ${AGENT_SESSION_COMMIT_FAILURE}` : ''}`);
         return { status: 'failed', reason };
     }
 }

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

@@ -37,6 +37,7 @@ const package_manager_1 = require("../../utils/package-manager");
 const errors_1 = require("../../utils/min-release-age/errors");
 const resolve_package_version_1 = require("./resolve-package-version");
 const handle_errors_1 = require("../../utils/handle-errors");
+const exit_codes_1 = require("../../utils/exit-codes");
 const connect_to_nx_cloud_1 = require("../nx-cloud/connect/connect-to-nx-cloud");
 const output_1 = require("../../utils/output");
 const fs_1 = require("fs");
@@ -68,6 +69,7 @@ Object.defineProperty(exports, "normalizeVersion", { enumerable: true, get: func
 const execute_migration_1 = require("./execute-migration");
 const step_actions_1 = require("./step-actions");
 const sort_migrations_1 = require("./sort-migrations");
+const text_1 = require("./text");
 const inception_1 = require("./agentic/inception");
 const version_skew_guard_1 = require("./version-skew-guard");
 const versions_1 = require("../../utils/versions");
@@ -88,20 +90,27 @@ function formatCommandFailure(command, error) {
             .trim();
     return [`Command failed: ${command}`, ...(details ? [details] : [])].join('\n');
 }
+// Ctrl+C is left to the child. Killed by it, this process would hand the
+// terminal back to the shell while the child still runs.
 function runOrReturnExitCode(run) {
+    const leaveSigintToChild = () => { };
+    process.on('SIGINT', leaveSigintToChild);
     try {
         run();
         return 0;
     }
     catch (e) {
-        if (typeof e === 'object' &&
-            e !== null &&
-            'status' in e &&
-            typeof e.status === 'number') {
+        if (typeof e !== 'object' || e === null)
+            throw e;
+        if ('signal' in e && e.signal === 'SIGINT')
+            (0, exit_codes_1.exitAsInterrupted)();
+        if ('status' in e && typeof e.status === 'number')
             return e.status;
-        }
         throw e;
     }
+    finally {
+        process.removeListener('SIGINT', leaveSigintToChild);
+    }
 }
 function cleanSemver(version) {
     return (0, semver_1.clean)(version) ?? (0, semver_1.coerce)(version);
@@ -2161,7 +2170,35 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
         activeRunToReplace(root, opts.runId);
     }
     if (!shouldSkipInstall && !process.env.NX_MIGRATE_SKIP_INSTALL) {
-        await (0, execute_migration_1.runInstall)();
+        // The run must resume while the cause of a step's failed install persists.
+        const failedInstallSteps = continued?.steps.filter((s) => s.installFailed === true) ?? [];
+        if (failedInstallSteps.length > 0) {
+            const { pmInstallCommand, stepLabel, TERMINAL_STEP_STATUSES } = require('./run');
+            // A settled step keeps its mark, but no step action can retry it.
+            const settled = failedInstallSteps.filter((s) => TERMINAL_STEP_STATUSES.has(s.status));
+            const retryable = failedInstallSteps.filter((s) => !settled.includes(s));
+            const notCompleted = (steps) => `The dependency install of ${steps
+                .map(stepLabel)
+                .join(', ')} did not complete earlier in this run.`;
+            output_1.output.warn({
+                title: 'Skipping the dependency install',
+                bodyLines: [
+                    ...(retryable.length > 0
+                        ? [
+                            `${notCompleted(retryable)} Retrying that step installs again; any other choice leaves the install to you.`,
+                        ]
+                        : []),
+                    ...(settled.length > 0
+                        ? [
+                            `${notCompleted(settled)} Run \`${pmInstallCommand(root)}\` once the cause of the failed install is fixed.`,
+                        ]
+                        : []),
+                ].map(text_1.singleLine),
+            });
+        }
+        else {
+            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

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

@@ -16,6 +16,7 @@ export interface AgentMessage {
 export declare function safeLines(lines: readonly string[]): string[];
 export declare function logToAgent(message: AgentMessage): void;
 export declare function warnToAgent(message: AgentMessage): void;
+export declare function logLineToAgent(line: string): void;
 export declare function emitStepBlock(runId: string, stepId: string, action: string, payload: object): void;
 export declare function emitPromptBlock(migrationId: string, payload: object): void;
 export declare function emitStepPromptBlock(stepId: string, payload: object): void;

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

@@ -13,10 +13,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.safeLines = safeLines;
 exports.logToAgent = logToAgent;
 exports.warnToAgent = warnToAgent;
+exports.logLineToAgent = logLineToAgent;
 exports.emitStepBlock = emitStepBlock;
 exports.emitPromptBlock = emitPromptBlock;
 exports.emitStepPromptBlock = emitStepPromptBlock;
 exports.emitRunbookBlock = emitRunbookBlock;
+const logger_1 = require("../../../utils/logger");
 const output_1 = require("../../../utils/output");
 const print_dropped_agent_context_1 = require("../agentic/print-dropped-agent-context");
 const text_1 = require("../text");
@@ -40,6 +42,9 @@ function logToAgent(message) {
 function warnToAgent(message) {
     output_1.output.warn(safe(message));
 }
+function logLineToAgent(line) {
+    logger_1.logger.info((0, text_1.singleLine)(line));
+}
 /**
  * Serializes a block payload. `<` becomes its JSON unicode escape so a raw one
  * in a value cannot forge the closing tag, and the result stays valid JSON for

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

@@ -91,8 +91,8 @@ export declare function acquireTreeOperation(dir: string, request: TreeOperation
 export declare function releaseTreeOperation(dir: string, owner: string, markedStepId?: string): void;
 /** The reservation a live process other than `owner` holds, if any. */
 export declare function liveTreeOperation(state: MigrateRunState, owner?: string): MigrateTreeOperation | undefined;
-export declare function treeBusyMessage(held: MigrateTreeOperation): string;
-export declare function treeOperationLabel(held: Pick<MigrateTreeOperation, 'kind' | 'stepId'>): string;
+export declare function treeBusyMessage(held: MigrateTreeOperation, stepName?: string): string;
+export declare function treeOperationLabel(held: Pick<MigrateTreeOperation, 'kind' | 'stepId'>, stepName?: string): string;
 export declare function brokerDir(runDirPath: string): string;
 /**
  * Runs the step's install and commit where they can land: in this process
@@ -119,6 +119,15 @@ export declare function resetStepTree(dir: string, step: MigrateStep, resetInPro
  * 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>;
+export declare const COMMIT_INSTALLS_FIRST = "A commit first installs any dependency changes.";
+export declare function commitsStep(kind: MigrateTreeOperation['kind']): boolean;
+export declare function sessionOperationWayOut(operation: string): string;
+export declare function formatElapsed(ms: number): string;
+export interface InFlightOperation {
+    request: BrokerRequest;
+    startedAt: number;
+    stepName: string;
+}
 /**
  * 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
@@ -138,13 +147,13 @@ export declare class MigrateCommitBroker {
     private inFlight;
     private readonly lock;
     constructor(root: string, dir: string, reconcileCommand: string, policy: MigrateRunPolicy);
-    /** The request whose operation this process is running right now. */
-    get requestInFlight(): BrokerRequest | null;
+    /** The request whose operation this process is running right now, and since when. */
+    get requestInFlight(): InFlightOperation | null;
     /** Answers this session's unanswered requests, one at a time. */
     service(): Promise<void>;
     private record;
     private answer;
-    /** Releases the lock; call after the last `service` settled. */
+    /** Releases the lock; call after the last `service` settled, or once giving up on it. */
     close(): void;
     private notADirectory;
 }