firedrill-run 2.2.5 → 3.0.0

package/dist/cli/src/simulation-run.js

@@ -0,0 +1,1058 @@
+import { workspaceLink } from './browser-links.js';
+import { createHash } from 'node:crypto';
+import { createInterface } from 'node:readline/promises';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { api } from './auth.js';
+import { CliError } from './http.js';
+import { selectMany, selectOne, terminalText } from './prompts.js';
+import { executionPermission, localPermissionPage, savedLocalPermission } from './runner-grants.js';
+import { withRunnerPresence } from './runner-identity.js';
+import { retainLocalValidation } from './runner-evidence.js';
+import { retainLocalTrial } from './runner-trial-journal.js';
+import { continueIntent, createIntent, inspectIntent, intentPage, optionalIntent, withdrawIntent } from './simulation-intents.js';
+import { preparation } from './world-agent.js';
+import { selectedWorld } from './world-access.js';
+import { identifier } from './world-contracts.js';
+import { isNativeSetupReceipt, planMatchesRequest, planningDriverMatches, planningDefaultsMatch } from '../../contracts/planning-contracts.js';
+import { executionScheduleText } from '../../contracts/agent-execution-contracts.js';
+import { datasetReads } from './dataset-reads.js';
+import { localAssignmentsPage, readLocalClaim } from './runner-claim-reads.js';
+import { retainedLocalClaim } from './runner-ownership.js';
+import { executionProposal, executionProposalText, executableProposal, proposalBasis } from './execution-proposals.js';
+import { executionPlanMatches } from '../../contracts/director-execution.js';
+import { continuityRequirementsMatch } from '../../contracts/continuity-requirements.js';
+import { applicationCheckpointMatches } from '../../contracts/application-state-contracts.js';
+import { resourcePageMatches } from '../../contracts/world-lifetime-contracts.js';
+import { coordinatedCheckpointMatches, coordinatedCheckpointDetailMatches } from '../../contracts/coordinated-checkpoint-contracts.js';
+import { creditAmount } from './credit-format.js';
+import { nativeMetadataCanonical } from '../../contracts/local-value-source-contracts.js';
+import { localSetupRequired, setupLocalExecution } from './local-execution-setup.js';
+import { reviewDriverInput } from './driver-review.js';
+const terminal = (state) => ['completed', 'failed', 'canceled'].includes(state);
+const interactive = (options) => !options.json && !!process.stdin.isTTY && !!process.stderr.isTTY;
+const auth = (context, signal) => ({ actor: context.owner, workspace: context.workspace, signal });
+async function readSetup(context, signal) {
+    const value = await api(`${context.prefix}/simulation-plan`, auth(context, signal));
+    if (!planningDriverMatches(value))
+        throw new CliError('agent_execution_identity_changed', 'The prepared input adapter could not be confirmed. Read simulation setup again.');
+    if (!planningDefaultsMatch(value))
+        throw new CliError('simulation_plan_unconfirmed', 'Simulation settings could not be confirmed. Read simulation setup again.');
+    return value;
+}
+const reportLink = (context, id) => workspaceLink(context.workspace, `/campaigns/${identifier(id)}`);
+async function contextFor(options) {
+    return selectedWorld({ workspace: options.workspace, world: options.world, expectedOwner: options.expectedOwner, interactive: interactive(options),
+        openBrowser: options.openBrowser, signal: options.signal });
+}
+async function confirmation(options, label, detail) {
+    if (options.run)
+        return;
+    if (!interactive(options))
+        throw new CliError('simulation_confirmation_required', 'Use --run to approve the reviewed operation in a non-interactive command.', 2);
+    if (!await selectOne(label, [{ value: true, label: 'Continue', detail }, { value: false, label: 'Cancel' }], options.signal)) {
+        throw new CliError('canceled', 'No new execution was admitted.', 130);
+    }
+}
+export async function startingData(context, setup, options) {
+    if (setup.agent_comparison) {
+        const retained = setup.agent_comparison.starting_data;
+        if (options.dataset !== undefined && identifier(options.dataset) !== retained?.dataset_id) {
+            throw new CliError('agent_comparison_starting_data_changed', 'Keep the original starting data for both sides of this comparison.', 2);
+        }
+        if (retained && setup.real_connections_count !== 0)
+            throw new CliError('agent_comparison_starting_data_changed', 'This comparison retains synthetic starting data. Review simulated connections instead of using real accounts.', 2);
+        return retained ? { id: identifier(retained.dataset_id), edit_count: retained.edit_count } : null;
+    }
+    if (setup.real_connections_count !== 0) {
+        if (options.dataset !== undefined)
+            throw new CliError('world_dataset_unavailable', 'Saved starting data requires simulated connections and no frozen comparison.', 2);
+        return null;
+    }
+    if (options.dataset !== undefined) {
+        const id = identifier(options.dataset);
+        const row = await datasetReads(context.prefix, context, options.signal).detail(id);
+        if (row.kind !== 'world' || !row.can_start_session)
+            throw new CliError('world_dataset_unavailable', 'Choose an available saved version for this prepared world.', 2);
+        return row;
+    }
+    if (!interactive(options))
+        return null;
+    let page = 1;
+    while (true) {
+        const result = await datasetReads(context.prefix, context, options.signal).page({ startable: true, page });
+        if (page === 1 && result.count === 0)
+            return null;
+        const choices = [{ value: 'prepared', label: 'Prepared data', detail: 'Use the world’s original starting data.' },
+            ...result.results.filter(row => row.kind === 'world' && row.can_start_session).map(row => ({ value: identifier(row.id), label: row.name,
+                detail: `Version ${row.version} · ${row.edit_count} saved edits` }))];
+        if (page > 1)
+            choices.push({ value: 'previous', label: 'Previous page', detail: '' });
+        if (result.next)
+            choices.push({ value: 'next', label: 'Next page', detail: '' });
+        const answer = await selectOne('Starting data', choices, options.signal);
+        if (answer === 'prepared')
+            return null;
+        if (answer === 'previous') {
+            page--;
+            continue;
+        }
+        if (answer === 'next') {
+            page++;
+            continue;
+        }
+        const row = result.results.find(one => one.id === answer && one.kind === 'world' && one.can_start_session);
+        if (!row)
+            throw new CliError('world_dataset_selection_changed', 'The starting-data selection changed. No simulation was started.');
+        return row;
+    }
+}
+async function numberOption(value, fallback, maximum, label, options) {
+    if (!Number.isSafeInteger(maximum) || maximum < 1 || !Number.isSafeInteger(fallback) || fallback < 1)
+        throw new CliError('simulation_capacity_unavailable', 'Simulation planning capacity is unavailable.');
+    let answer = value;
+    if (answer === undefined && interactive(options)) {
+        const prompt = createInterface({ input: process.stdin, output: process.stderr, terminal: false });
+        try {
+            answer = (await prompt.question(`${label} [${fallback}]: `, { signal: options.signal })).trim();
+        }
+        finally {
+            prompt.close();
+        }
+    }
+    if (answer === undefined || answer === '')
+        answer = String(fallback);
+    if (!/^[1-9][0-9]*$/.test(answer) || !Number.isSafeInteger(Number(answer)) || Number(answer) > maximum) {
+        throw new CliError('simulation_capacity_required', `Use ${label.toLowerCase()} between 1 and ${maximum}.`, 2);
+    }
+    return Number(answer);
+}
+async function applicationStartingState(context, setup, options, dataset, selected, proposal) {
+    const requested = options.applicationCheckpoint !== undefined || options.coordinatedCheckpoint !== undefined;
+    const hasApprovals = options.acknowledgeFreshWorldState || options.shareApplicationCheckpointWithDevice
+        || options.acknowledgeSupportedCheckpointScope || options.shareCoordinatedCheckpointWithDevice;
+    if (setup.real_connections_count !== 0 || setup.agent_comparison || dataset || proposal) {
+        if (requested || hasApprovals)
+            throw new CliError('application_continuation_combination_unavailable', 'Choose application continuation in an ordinary simulation plan with simulated connections and no separate dataset or comparison.', 2);
+        return null;
+    }
+    let kind = options.coordinatedCheckpoint !== undefined ? 'coordinated' : 'application';
+    let checkpoint = null;
+    if (!requested && interactive(options)) {
+        const choice = await selectOne('Starting state', [
+            { value: 'fresh', label: 'Prepared world and new agent process' },
+            { value: 'coordinated', label: 'Saved world and agent state', detail: 'Only supported stores and source-defined application state.' },
+            { value: 'application', label: 'Saved application state, fresh synthetic services' }
+        ], options.signal);
+        if (choice === 'fresh') {
+            if (hasApprovals)
+                throw new CliError('application_checkpoint_required', 'Saved-state approvals require a selected checkpoint.', 2);
+            return null;
+        }
+        kind = choice;
+    }
+    const route = kind === 'coordinated' ? 'coordinated-checkpoints' : 'application-checkpoints';
+    if (requested) {
+        const id = identifier((options.coordinatedCheckpoint ?? options.applicationCheckpoint));
+        checkpoint = await api(`${context.prefix}/${route}/${id}`, auth(context, options.signal));
+        if (!(kind === 'coordinated' ? coordinatedCheckpointDetailMatches(checkpoint, context.world, { id })
+            : applicationCheckpointMatches(checkpoint, context.world, { id })) || !checkpoint.available)
+            throw new CliError('application_checkpoint_unavailable', 'Choose a retained application checkpoint from this world.', 2);
+    }
+    else if (interactive(options)) {
+        let page = 1;
+        while (true) {
+            const value = await api(`${context.prefix}/${route}?state=retained&page=${page}`, auth(context, options.signal));
+            if (!resourcePageMatches(value, page, row => (kind === 'coordinated' ? coordinatedCheckpointMatches(row, context.world)
+                : applicationCheckpointMatches(row, context.world)) && row.state === 'retained'))
+                throw new CliError('application_checkpoint_unconfirmed', 'The saved application state list could not be confirmed.');
+            if (!value.count && page === 1)
+                break;
+            const choices = [{ value: 'fresh', label: 'No application checkpoint', detail: 'Start from the prepared source and world.' },
+                ...value.results.filter(row => row.available).map(row => ({ value: row.id, label: row.name, detail: 'components' in row
+                        ? row.components.map(one => one.name).join(', ') : `${row.application_component_count} application components and supported synthetic service data` }))];
+            if (page > 1)
+                choices.push({ value: 'previous', label: 'Previous page', detail: '' });
+            if (value.next)
+                choices.push({ value: 'next', label: 'Next page', detail: '' });
+            const answer = await selectOne('Saved application state (optional)', choices, options.signal);
+            if (answer === 'fresh')
+                break;
+            if (answer === 'previous') {
+                page--;
+                continue;
+            }
+            if (answer === 'next') {
+                page++;
+                continue;
+            }
+            checkpoint = value.results.find(row => row.id === answer && row.available) ?? null;
+            if (!checkpoint)
+                throw new CliError('application_checkpoint_unconfirmed', 'Choose the saved application state again.');
+            break;
+        }
+    }
+    if (!checkpoint) {
+        if (hasApprovals)
+            throw new CliError('application_checkpoint_required', 'Application-state approvals require a selected checkpoint.', 2);
+        return null;
+    }
+    if (kind === 'coordinated' ? options.acknowledgeFreshWorldState || options.shareApplicationCheckpointWithDevice
+        : options.acknowledgeSupportedCheckpointScope || options.shareCoordinatedCheckpointWithDevice)
+        throw new CliError('application_checkpoint_consent_invalid', 'Use only the selected checkpoint type’s scope and device-download approvals.', 2);
+    let acknowledged = (kind === 'coordinated' ? options.acknowledgeSupportedCheckpointScope : options.acknowledgeFreshWorldState) === true;
+    if (!acknowledged && interactive(options))
+        acknowledged = await selectOne(kind === 'coordinated' ? 'Supported saved world and agent state' : 'Application state with fresh synthetic services', [
+            { value: false, label: 'Cancel' }, { value: true, label: 'Continue in a new process',
+                detail: kind === 'coordinated' ? 'Each drill starts from supported captured application and synthetic service data. External accounts, live processes and elapsed wall time are not restored.'
+                    : 'Each drill starts with this source-supported application state. Synthetic services start from prepared data; the previous world and process memory are not restored.' }
+        ], options.signal);
+    if (!acknowledged)
+        throw new CliError('application_continuation_acknowledgement_required', `Review saved-state coverage or use ${kind === 'coordinated' ? '--acknowledge-supported-checkpoint-scope' : '--acknowledge-fresh-world-state'} in automation.`, 2);
+    let share = (kind === 'coordinated' ? options.shareCoordinatedCheckpointWithDevice : options.shareApplicationCheckpointWithDevice) === true;
+    if (selected.location === 'local') {
+        if (!share && interactive(options))
+            share = await selectOne('Download saved application state to this device?', [
+                { value: false, label: 'Cancel' }, { value: true, label: 'Download for these drills', detail: 'Private runner cache is outside your project. Device copies and backups cannot be erased remotely.' }
+            ], options.signal);
+        if (!share)
+            throw new CliError('local_application_checkpoint_consent_required', `Approve the download or use ${kind === 'coordinated' ? '--share-coordinated-checkpoint-with-device' : '--share-application-checkpoint-with-device'}.`, 2);
+    }
+    else if (share)
+        throw new CliError('local_application_checkpoint_consent_invalid', 'A device download is only available with local execution.', 2);
+    return { kind, checkpoint, acknowledged, share };
+}
+const LEGACY_LAUNCH_RETIRED = 'Starting work from the older world commands is retired in this release, managed or on this device; retained history, reports, cancellation, cleanup and original-request recovery stay available. Use firedrill plan, apply and run for new simulations. Nothing was sent.';
+/**
+ * Where an original launch from the older world commands would run. This
+ * release starts none of them, managed or on this device (FIR-504: root's
+ * `managed_target_launch` and `legacy_local_execution` gates are off), so every
+ * caller is refused here, before any permission, grant, container or cloud
+ * request. `simulation resume` watches without calling this.
+ */
+export async function execution(context, purpose, options, output) {
+    throw new CliError('legacy_launch_retired', LEGACY_LAUNCH_RETIRED, 2);
+}
+async function scenarios(context, setup, options) {
+    if (options.all && options.scenarios?.length)
+        throw new CliError('scenario_selection_invalid', 'Choose --all-scenarios or explicit --scenario IDs.', 2);
+    if (options.scenarios?.length)
+        return { mode: 'ids', query: '', ids: [...new Set(options.scenarios.map(identifier))].sort(), excluded: [] };
+    let all = options.all;
+    if (!all) {
+        if (!interactive(options))
+            throw new CliError('scenario_selection_required', 'Use --all-scenarios or one or more --scenario <id> options.', 2);
+        all = await selectOne('Scenarios', [{ value: true, label: 'All current scenarios' }, { value: false, label: 'Choose scenarios' }], options.signal);
+    }
+    if (all)
+        return { mode: 'all_matching', query: '', ids: [], excluded: [] };
+    const selected = new Set();
+    let page = 1;
+    while (true) {
+        const result = await api(`${context.prefix}/scenarios?page=${page}&selection_revision=${encodeURIComponent(setup.selection_revision)}`, auth(context, options.signal));
+        if (result.selection_revision !== setup.selection_revision)
+            throw new CliError('scenario_selection_changed', 'The scenario list changed. Review the plan again.');
+        const checked = await selectMany('Scenarios', result.results.map(row => ({ value: identifier(row.id), label: row.name })), options.signal, [...selected]);
+        for (const row of result.results)
+            selected.delete(row.id);
+        for (const id of checked)
+            selected.add(id);
+        const action = await selectOne(`${selected.size} selected`, [{ value: 'done', label: 'Continue' },
+            ...(result.next ? [{ value: 'next', label: 'Next page' }] : []), ...(page > 1 ? [{ value: 'previous', label: 'Previous page' }] : [])], options.signal);
+        if (action === 'next') {
+            page++;
+            continue;
+        }
+        if (action === 'previous') {
+            page--;
+            continue;
+        }
+        if (!selected.size)
+            throw new CliError('scenario_selection_required', 'Select at least one scenario.', 2);
+        return { mode: 'ids', query: '', ids: [...selected].sort(), excluded: [] };
+    }
+}
+async function validateWorld(context, selected, options, output, proposal) {
+    const world = await preparation(context, options.signal);
+    if (proposal)
+        proposalBasis(await executionProposal(context, proposal.id, options.signal), world);
+    if (!Number.isSafeInteger(world.real_connections_count) || world.real_connections_count < 0) {
+        throw new CliError('startup_connections_unavailable', 'Reopen this world to review its current connection choices. No validation was queued.');
+    }
+    const real = world.real_connections_count > 0;
+    if (real) {
+        let effects = options.acknowledgeExternalEffects === true, startup = options.approveRealStartup === true;
+        if (interactive(options)) {
+            if (!effects)
+                effects = await selectOne('Real-account access', [
+                    { value: false, label: 'Cancel' }, { value: true, label: 'Allow the reviewed real-account operations',
+                        detail: 'External reads and changes may occur. Stopping or resetting the world cannot undo them.' }
+                ], options.signal);
+            if (effects && !startup)
+                startup = await selectOne('Calls during startup', [
+                    { value: false, label: 'Cancel' }, { value: true, label: 'Allow calls while the original agent starts',
+                        detail: 'Start one instance. Do not run scenario setup, operation probes or reset checks.' }
+                ], options.signal);
+        }
+        if (!effects || !startup)
+            throw new CliError('real_startup_consent_required', 'Real-account startup needs --acknowledge-external-effects and --approve-real-startup, or explicit interactive approval. No validation was queued.', 2);
+    }
+    else if (options.approveRealStartup || options.acknowledgeExternalEffects) {
+        throw new CliError('real_startup_consent_invalid', 'This world has no real connection selected. Omit real-account startup approvals.', 2);
+    }
+    await confirmation(options, 'Validate startup?', 'Start the original agent and check this world’s supported connections. Target-provider model use is billed separately.');
+    if (selected.location === 'local')
+        await executionPermission(context, selected.request, selected.device, 'validation', options.signal);
+    const body = { configuration_revision: world.basis.config_revision,
+        ...(real ? { validation_scope: 'target_startup_only', acknowledge_external_effects: true, acknowledge_startup_calls: true,
+            world_revision: world.basis.world_revision, source_id: world.basis.source_id, source_revision: world.agent.revision, startup_actor_id: context.owner } : {}),
+        execution_location: selected.location, ...(selected.location === 'local' ? { local_grant_id: selected.grant.id } : {}) };
+    const original = proposal ? await optionalIntent(context, proposal.validation_request_key) : null;
+    if (original && (original.kind !== 'validation' || original.body.configuration_revision !== body.configuration_revision
+        || original.body.execution_location !== body.execution_location || original.body.local_grant_id !== body.local_grant_id
+        || original.body.validation_scope !== body.validation_scope))
+        throw new CliError('execution_proposal_changed', 'The original validation request has different inputs. It was not replaced.');
+    if (proposal)
+        proposalBasis(await executionProposal(context, proposal.id, options.signal), await preparation(context, options.signal));
+    const saved = await createIntent(context, 'validation', original?.body ?? body, options.signal, output, proposal?.validation_request_key);
+    if (!isNativeSetupReceipt(saved.receipt) || saved.receipt.state !== 'accepted' || !saved.receipt.resource_available || !saved.receipt.resource_id) {
+        throw new CliError('validation_acceptance_unconfirmed', `Inspect setup request ${saved.intent.key}. No replacement validation was created.`);
+    }
+    return observeValidation(context, saved.receipt.resource_id, selected, options, output, proposal?.id);
+}
+async function observeValidation(context, jobId, selected, options, output, proposalId) {
+    const read = async () => {
+        const original = proposalId ? (await executionProposal(context, proposalId, options.signal)).validation : null;
+        if (proposalId && (!original || original.id !== jobId))
+            throw new CliError('validation_pointer_changed', 'The original proposed validation could not be confirmed. No replacement was started.');
+        const current = (await api(`${context.prefix}/validation`, auth(context, options.signal))).validation;
+        if (original && current?.id !== original.id) {
+            output('validation_original', original, `Original validation ${original.id}: ${original.state}. Another validation is now selected.`);
+            throw new CliError('validation_pointer_changed', 'The original status is retained, but current-world diagnostics belong to another job. No validation was repeated.');
+        }
+        return current;
+    };
+    const initial = await read();
+    if (!initial || initial.id !== jobId || initial.execution_location !== selected.location)
+        throw new CliError('validation_pointer_changed', 'The original validation could not be confirmed. No replacement was started.');
+    if (selected.location === 'local' && (initial.local_grant_id !== selected.grant.id || initial.local_device_key !== selected.device)) {
+        throw new CliError('validation_permission_changed', 'Use the original validation’s device and local permission. No replacement was selected.');
+    }
+    if (selected.location === 'local') {
+        const original = await retainedLocalClaim(context, selected.device, jobId);
+        if (original && !terminal(initial.state) && (original.stage === 'work_dispatched' || original.stage === 'not_dispatched'
+            || initial.state !== 'queued')) {
+            if (original.stage === 'work_dispatched' && !original.lease)
+                throw new CliError('local_owner_identity_changed', 'The original dispatched operation identity is unavailable. Preserve its ownership journal; no replacement callback or target was started.');
+            const scope = `--workspace ${context.workspace}`;
+            const commands = original.stage === 'not_dispatched'
+                ? [`firedrill runner abandon ${selected.device} ${jobId} --world ${context.world} ${scope}`]
+                : original.stage === 'work_dispatched' && original.lease
+                    ? [`firedrill runner evidence sync ${original.lease} ${scope}`, `firedrill runner completion sync ${original.lease} ${scope}`]
+                    : [`firedrill runner abandon ${selected.device} ${jobId} --world ${context.world} ${scope}`];
+            output('local_validation_recovery', { job_id: jobId, operation_id: original.lease, ownership_stage: original.stage,
+                execution_repeated: false, recovery_commands: commands }, `Original local validation ${jobId}: ${initial.state}. No execution callback was repeated.\n`
+                + (original.stage === 'work_dispatched'
+                    ? 'Keep the original runner active. If it was interrupted, the existing commands below recover retained evidence and closing facts only. They do not restart its target.'
+                    : original.stage === 'not_dispatched' ? 'This original claim was abandoned before launch. Reconcile its original closing receipt.'
+                        : 'This job already has an original claim. Keep its original runner active if it is still running; otherwise close the unstarted claim with the abandon command below. Starting it again is retired in this release.')
+                + '\n' + commands.join('\n')
+                + (original.stage === 'work_dispatched' && original.lease
+                    ? `\nIf the original runner was interrupted and cleanup is still required, review firedrill runner cleanup ${original.lease} ${scope} before completion sync. Do not clean up an active runner.` : ''));
+            throw new CliError('local_execution_recovery_required', 'Use the original local recovery handoff above, then reopen this proposal to observe its retained result. No target was restarted.', 2);
+        }
+    }
+    if (selected.location === 'local' && initial.state === 'queued') {
+        output('local_validation_assigned', { job_id: jobId, device_key: selected.device }, 'Running the saved validation on this device.');
+        await withRunnerPresence(context, selected.device, options.signal, output, active => retainLocalValidation(context, selected.device, jobId, selected.request, active));
+    }
+    let previous = '';
+    while (true) {
+        const value = await read();
+        // Another tab may replace the current pointer only after terminal work.
+        // Never attribute that other job's readiness to this exact setup request.
+        if (!value || value.id !== jobId)
+            throw new CliError('validation_pointer_changed', 'Inspect the original setup request. Another validation is now selected.');
+        const summary = `${value.state}:${value.phase}`;
+        if (summary !== previous) {
+            output('validation_progress', value, `Validation: ${value.state.replaceAll('_', ' ')} (${value.phase.replaceAll('_', ' ')}).`);
+            previous = summary;
+        }
+        if (terminal(value.state)) {
+            if (value.state === 'completed' && value.current && value.scope === 'target_startup_only' && value.target_startup_observed) {
+                output('startup_observed', value, 'Original agent startup observed. Scenario checks were not run.'
+                    + (value.execution_ready ? '' : '\n' + (value.readiness_issues.map(row => row.message).join(' ') || 'Simulation execution is not ready.')));
+                return value;
+            }
+            if (!value.current || !value.execution_ready) {
+                const detail = value.current ? value.failure?.diagnostics : null;
+                const message = [value.failure?.message ?? (value.readiness_issues.map(row => row.message).join(' ') || 'Review this world’s execution requirements before running simulations.'),
+                    ...(detail ? [`During: ${detail.phase}`, ...(detail.process ? [`Process: ${detail.process}`] : []),
+                        ...(detail.signals.length ? [`Output reported: ${detail.signals.join(', ')}`] : []), detail.next_step] : [])];
+                throw new CliError('world_execution_not_ready', message.map(line => terminalText(line)).join('\n'));
+            }
+            output('validation_finished', value, 'Startup validation completed. This is execution readiness, not a behavior assessment.');
+            return value;
+        }
+        await sleep(1500, undefined, { signal: options.signal });
+    }
+}
+async function campaign(context, id, signal) {
+    const value = await api(`/api/workspaces/${context.workspace}/campaigns/${identifier(id)}`, auth(context, signal));
+    if (value.id !== id || value.world_id !== context.world || !['local', 'managed'].includes(value.execution_location))
+        throw new CliError('campaign_identity_changed', 'The saved simulation does not belong to this world.');
+    return value;
+}
+async function quoteFor(context, plan, selected, signal) {
+    const value = await api(`${context.prefix}/simulation-plans/${identifier(plan.id)}/quote`, auth(context, signal));
+    if (value.plan_id !== plan.id || value.execution_location !== selected.location || typeof value.funded !== 'boolean' || typeof value.funding_held !== 'boolean'
+        || !['planned_trials', 'available_units', 'reserved_units', 'admitted_concurrency_ceiling'].every(key => Number.isSafeInteger(value[key]) && Number(value[key]) >= 0)
+        || value.planned_trials < 1 || !value.readiness || typeof value.readiness.ready !== 'boolean'
+        || !value.credits || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(value.credits.quote_id)
+        || !['credit_scale', 'estimated_units', 'maximum_units', 'available_units', 'reserved_units'].every(key => Number.isSafeInteger(value.credits[key]) && Number(value.credits[key]) >= 0)
+        || value.credits.credit_scale < 1 || !/^10*$/.test(String(value.credits.credit_scale)) || value.credits.maximum_units < value.credits.estimated_units
+        || !Number.isFinite(Date.parse(value.credits.expires_at)) || Date.parse(value.credits.expires_at) <= Date.now()) {
+        throw new CliError('simulation_quote_unavailable', 'The exact simulation quote could not be confirmed. No campaign was admitted.');
+    }
+    return value;
+}
+async function localCampaignRecovery(context, campaignId, selected, active, page, signal, output) {
+    let rows;
+    try {
+        rows = await localAssignmentsPage(context, selected.device, { available: false, world: context.world, campaign: campaignId, page }, signal);
+    }
+    catch (error) {
+        // A page can disappear after retention changes. Start a new bounded sweep;
+        // an absent page is not permission to replay a claim or start a replacement.
+        if (page > 1 && error instanceof CliError && error.httpStatus === 404)
+            return 1;
+        throw error;
+    }
+    for (const row of rows.results) {
+        if (row.world_id !== context.world || row.device_key !== selected.device || row.grant_id !== selected.grant
+            || row.purpose !== 'trial' || selected.nativeSession && row.native_session_id !== selected.nativeSession)
+            throw new CliError('local_assignment_changed', 'An original local assignment does not match this simulation permission. No recovery action was sent.');
+        if (!row.claim || active.has(row.job_id) || terminal(row.job_state) && row.claim.cleanup_recorded)
+            continue;
+        const original = await retainedLocalClaim(context, selected.device, row.job_id);
+        const saved = await readLocalClaim(context, selected.device, row.job_id, row.claim.request_key, signal);
+        const claim = saved.claim;
+        if (!claim || claim.id !== row.claim.id || saved.payload_digest !== row.payload_digest
+            || saved.grant_id !== selected.grant || saved.world_id !== context.world || saved.purpose !== 'trial'
+            || saved.native_session_id !== row.native_session_id)
+            throw new CliError('local_owner_identity_changed', 'The original local ownership changed during inspection. Read its saved claim; no execution was repeated.');
+        if (terminal(saved.job_state) && claim.cleanup_recorded)
+            continue;
+        if (original && (original.request !== claim.request_key || original.grant !== saved.grant_id
+            || original.proof.payload.native_session_id !== saved.native_session_id
+            || original.proof.payload.payload_digest !== saved.payload_digest
+            || createHash('sha256').update(nativeMetadataCanonical(original.proof.payload)).digest('hex') !== claim.request_digest
+            || selected.request && original.grantRequest !== selected.request
+            || original.lease !== null && original.lease !== claim.id
+            || original.attempt !== null && original.attempt !== claim.attempt_id))
+            throw new CliError('local_owner_identity_changed', 'The private ownership journal differs from this original claim. Preserve it for inspection; no execution was repeated.');
+        const scope = `--workspace ${context.workspace}`;
+        const status = `firedrill runner claim status ${selected.device} ${row.job_id} ${claim.request_key} ${scope}`;
+        const commands = [status];
+        let cleanupCommand = null;
+        let detail = 'Keep the original runner active if it is still running. This terminal has no original ownership journal, so recover from the original terminal. Do not create a replacement claim.';
+        if (original?.stage === 'work_dispatched') {
+            if (!original.lease || !original.attempt)
+                throw new CliError('local_owner_identity_changed', 'The dispatched operation identity is unavailable. Preserve the original journals; no target was restarted.');
+            commands.push(`firedrill runner evidence sync ${original.lease} ${scope}`, `firedrill runner completion sync ${original.lease} ${scope}`);
+            cleanupCommand = `firedrill runner cleanup ${original.lease} ${scope}`;
+            detail = 'This job already handed off to its original container. If that runner is active, leave it running. If it was interrupted, recover its saved evidence and closing facts; do not rerun the target.';
+        }
+        else if (original && claim.attempt_id) {
+            const unstarted = original.stage !== 'not_dispatched' && claim.state === 'claimed'
+                && !terminal(saved.job_state) && Date.parse(claim.expires_at) > Date.parse(saved.server_time);
+            // Resuming pre-launch ownership is retired with legacy local execution (FIR-504); only closing it remains.
+            commands.push(`firedrill runner abandon ${selected.device} ${row.job_id} --world ${context.world} ${scope}`);
+            detail = unstarted ? 'This original claim has not handed off to a container in its retained ownership journal. Keep its original runner active if it is still running; otherwise close it with the abandon command below. Starting it again is retired in this release.'
+                : 'This original claim cannot launch new work. Use its existing abandon command to reconcile unstarted ownership. That command refuses a retained container; it does not delete an unknown resource.';
+        }
+        output('local_simulation_recovery', { campaign_id: campaignId, job_id: row.job_id, claim_request_key: claim.request_key,
+            operation_id: original?.lease ?? null, ownership_stage: original?.stage ?? null, claim_state: claim.state,
+            execution_repeated: false, recovery_commands: commands, cleanup_after_runner_stopped: cleanupCommand,
+            report_url: reportLink(context, campaignId) }, `Original local drill ${row.job_id}: ${saved.job_state}. No execution callback was repeated.\n${detail}\n`
+            + commands.join('\n') + (cleanupCommand ? `\nOnly after the original runner has stopped, if cleanup is still needed, review ${cleanupCommand} before completion sync. Do not clean up an active runner.` : '')
+            + `\nSimulation report: ${reportLink(context, campaignId)}`);
+        throw new CliError('local_execution_recovery_required', 'Use the original local recovery handoff above, then continue this saved simulation. No claim, target or cleanup was repeated.', 2);
+    }
+    return rows.next ? page + 1 : 1;
+}
+async function watch(context, id, selected, parallel, options, output) {
+    const attempted = new Set(), active = new Map();
+    let failure, previous = '', recoveryPage = 1;
+    const work = async (signal) => {
+        let completed;
+        try {
+            while (true) {
+                const value = await campaign(context, id, signal);
+                if (value.execution_location !== selected.location)
+                    throw new CliError('campaign_location_changed', 'The retained simulation uses a different execution location.');
+                const summary = JSON.stringify({ state: value.state, trials: value.trial_states, invocations: value.observed_invocations, active: active.size });
+                if (summary !== previous) {
+                    output('campaign_progress', { ...value, local_assignments_active: active.size }, `${value.state.replaceAll('_', ' ')}: ${Object.entries(value.trial_states).map(([state, count]) => `${count} ${state.replaceAll('_', ' ')}`).join(', ') || 'allocating drills'}.\n`
+                        + `${value.observed_invocations} retained target-invocation observations${selected.location === 'local' ? `; ${active.size} local assignments active` : ''}.`);
+                    previous = summary;
+                }
+                if (failure)
+                    throw failure;
+                if (selected.location === 'local')
+                    recoveryPage = await localCampaignRecovery(context, id, { device: selected.device, grant: selected.grant.id, request: selected.request,
+                        nativeSession: selected.grant.document.native_session_id }, active, recoveryPage, signal, output);
+                if (terminal(value.state)) {
+                    completed = value;
+                    break;
+                }
+                if (!value.cancel_requested && selected.location === 'local' && active.size < parallel) {
+                    const rows = await localAssignmentsPage(context, selected.device, { available: true, world: context.world, campaign: id }, signal);
+                    for (const row of rows.results) {
+                        if (active.size >= parallel)
+                            break;
+                        if (attempted.has(row.job_id))
+                            continue;
+                        identifier(row.job_id);
+                        if (row.world_id !== context.world || row.device_key !== selected.device || row.grant_id !== selected.grant.id || row.purpose !== 'trial')
+                            throw new CliError('local_assignment_changed', 'A local assignment does not match this simulation permission.');
+                        attempted.add(row.job_id);
+                        const running = retainLocalTrial(context, selected.device, row.job_id, selected.request, signal, output)
+                            .then(result => { output('local_trial_retained', { job_id: row.job_id, result }, `Saved drill ${row.job_id}: evidence handoff returned.`); })
+                            .catch(error => { failure ??= error; })
+                            .finally(() => active.delete(row.job_id));
+                        active.set(row.job_id, running);
+                    }
+                }
+                await sleep(1500, undefined, { signal });
+            }
+        }
+        finally {
+            // Every already-started callback owns its cleanup/closing. Never abandon
+            // those promises or replay one after an uncertain claim or connection.
+            await Promise.all(active.values());
+        }
+        // The cloud campaign can finish while the last local callback still owns
+        // evidence sync or cleanup. Do not hide that callback's later failure behind
+        // an earlier return from the terminal-state observation.
+        if (failure)
+            throw failure;
+        if (!completed)
+            throw new CliError('campaign_observation_unavailable', 'The final simulation status was not observed. Inspect its saved report; no drill was restarted.');
+        return completed;
+    };
+    return selected.location === 'local' ? withRunnerPresence(context, selected.device, options.signal, output, work) : work(options.signal);
+}
+export async function simulationCommand(action, options, output) {
+    const context = await contextFor(options);
+    const proposal = options.proposal ? await executionProposal(context, options.proposal, options.signal) : undefined;
+    if (proposal && (options.applicationCheckpoint !== undefined || options.coordinatedCheckpoint !== undefined || options.acknowledgeFreshWorldState
+        || options.shareApplicationCheckpointWithDevice || options.acknowledgeSupportedCheckpointScope || options.shareCoordinatedCheckpointWithDevice))
+        throw new CliError('execution_proposal_selection_changed', 'Keep the proposal starting state unchanged. Use ordinary simulation setup to choose an application checkpoint.', 2);
+    if (proposal) {
+        if (proposal.action !== (action === 'run' ? 'simulate' : 'validate'))
+            throw new CliError('execution_proposal_action_changed', 'Use the command matching the proposed action. No work was started.', 2);
+        output('execution_proposal', proposal, executionProposalText(proposal));
+        // Structured automation first gets a read-only review. --run never supplies
+        // location, real-effect, capture, evidence or funding permission by itself.
+        if (!interactive(options) && !options.run)
+            return;
+        if (proposal.campaign) {
+            await resumeSimulation(proposal.campaign.id, { ...options, proposal: undefined }, output);
+            return;
+        }
+        if (action === 'validate' && proposal.validation && terminal(proposal.validation.state)) {
+            const value = proposal.validation;
+            output('validation_finished', value, `Original startup validation ${value.state}. ${value.current ? 'Current inputs.' : 'Inputs have since changed.'} `
+                + 'This retained job status is not a readiness or behavior assessment.');
+            const status = (await api(`${context.prefix}/validation`, auth(context, options.signal))).validation;
+            if (status?.id === value.id)
+                output('validation_result', status, `${status.execution_ready ? 'Execution readiness recorded.' : 'Execution readiness not confirmed.'}`
+                    + (status.failure ? `\n${status.failure.message}` : ''));
+            if (value.state !== 'completed')
+                throw new CliError('world_execution_not_ready', status?.id === value.id ? status.failure?.message ?? 'The original validation did not complete.' : 'The original validation did not complete. No replacement was started.');
+            return;
+        }
+        if (!proposal.validation)
+            executableProposal(proposal);
+        const location = proposal.plan?.execution.location ?? proposal.validation?.execution_location ?? proposal.location;
+        if (location !== 'choose' && (location === 'managed' && (options.local || options.grant || options.device) || location === 'local' && options.managed)) {
+            throw new CliError('execution_proposal_location_changed', 'Keep this proposal’s reviewed execution location. A different location needs a new proposal.', 2);
+        }
+        if (proposal.plan) {
+            if (options.repetitions !== undefined && Number(options.repetitions) !== proposal.repetitions
+                || options.parallel !== undefined && Number(options.parallel) !== proposal.parallelism
+                || options.seconds !== undefined && Number(options.seconds) !== proposal.trial_seconds
+                || options.scenarios?.length || options.all)
+                throw new CliError('execution_proposal_selection_changed', 'The proposal keeps its exact saved selection and limits. Omit selection overrides.', 2);
+        }
+        else if (action === 'run') {
+            const sameIds = (values) => [...new Set(values.map(identifier))].sort().join(',');
+            if (options.repetitions !== undefined && Number(options.repetitions) !== proposal.repetitions
+                || options.parallel !== undefined && Number(options.parallel) !== proposal.parallelism
+                || options.seconds !== undefined && Number(options.seconds) !== proposal.trial_seconds
+                || options.all && proposal.selector.mode !== 'all_matching'
+                || options.scenarios?.length && (proposal.selector.mode !== 'ids' || sameIds(options.scenarios) !== sameIds(proposal.selector.ids))) {
+                throw new CliError('execution_proposal_selection_changed', 'Keep the proposed scenarios and limits. Different choices need a new proposal.', 2);
+            }
+            options = { ...options, all: proposal.selector.mode === 'all_matching', scenarios: proposal.selector.mode === 'ids' ? proposal.selector.ids : undefined,
+                repetitions: String(proposal.repetitions), parallel: String(proposal.parallelism), seconds: String(proposal.trial_seconds) };
+        }
+        // A model's suggested location is not the user's execution choice. Only
+        // already-saved work supplies an immutable location during recovery.
+        if (proposal.plan || proposal.validation)
+            options = { ...options,
+                ...(location === 'managed' ? { managed: true } : location === 'local' ? { local: true } : {}) };
+    }
+    const selected = await execution(context, action === 'validate' ? 'validation' : 'trial', options, output);
+    if (proposal && proposal.location !== 'choose' && selected.location !== proposal.location) {
+        throw new CliError('execution_proposal_location_changed', 'The chosen location differs from the proposal. No work was started.', 2);
+    }
+    if (proposal?.validation && action === 'validate') {
+        await confirmation(options, 'Observe original startup validation?', 'Accepted work is not restarted. Only a still-unclaimed original local assignment can start.');
+        await observeValidation(context, proposal.validation.id, selected, options, output, proposal.id);
+        return;
+    }
+    if (action === 'validate') {
+        await validateWorld(context, selected, options, output, proposal);
+        return;
+    }
+    let setup = await readSetup(context, options.signal);
+    if (proposal) {
+        proposalBasis(proposal, await preparation(context, options.signal), setup);
+        if (proposal.plan) {
+            await admitPlan(context, proposal.plan, selected, options, output, proposal);
+            return;
+        }
+        const original = await optionalIntent(context, proposal.plan_request_key);
+        if (original) {
+            const body = original.body;
+            if (original.kind !== 'plan' || body.world_revision !== proposal.world_revision || body.configuration_revision !== proposal.configuration_revision
+                || body.selection_revision !== proposal.selection_revision || body.evaluation_revision !== proposal.evaluation_revision
+                || body.previous_plan_id !== proposal.previous_plan_id || body.repetitions !== proposal.repetitions
+                || body.parallelism !== proposal.parallelism || body.trial_seconds !== proposal.trial_seconds
+                || body.selector.mode !== proposal.selector.mode || body.selector.query !== '' || (body.selector.excluded?.length ?? 0) !== 0
+                || [...new Set(body.selector.ids ?? [])].sort().join(',') !== [...new Set(proposal.selector.ids)].sort().join(',')
+                || body.execution?.location !== selected.location || selected.location === 'local'
+                && (body.execution?.location !== 'local' || body.execution.grant_id !== selected.grant.id)) {
+                throw new CliError('execution_proposal_changed', 'The original saved plan request has different inputs. It was not replaced.');
+            }
+            output('execution_plan_request', { request_key: original.key, body }, 'Recovering the original reviewed plan, with its exact saved evidence and connection choices.');
+            await confirmation(options, 'Continue the original plan request?', 'The saved request body and approvals stay unchanged. No new plan key is created.');
+            const saved = await createIntent(context, 'plan', original.body, options.signal, output, proposal.plan_request_key);
+            if (!isNativeSetupReceipt(saved.receipt) || saved.receipt.state !== 'accepted' || !saved.receipt.resource_available || !saved.receipt.plan
+                || !planMatchesRequest(saved.receipt.plan, body) || !executionPlanMatches(proposal, saved.receipt.plan)) {
+                throw new CliError('simulation_plan_unconfirmed', `Inspect original setup request ${original.key}. No campaign was admitted.`);
+            }
+            await admitPlan(context, saved.receipt.plan, selected, options, output, proposal);
+            return;
+        }
+    }
+    if (setup.agent_comparison && (!setup.agent_comparison.current || options.scenarios?.length)) {
+        throw new CliError('agent_comparison_selection_changed', 'Review this comparison and keep its complete frozen scenario selection. No startup check or plan was created.', 2);
+    }
+    if (setup.agent_comparison?.starting_data) {
+        if (setup.real_connections_count !== 0 || options.dataset !== undefined && identifier(options.dataset) !== setup.agent_comparison.starting_data.dataset_id) {
+            throw new CliError('agent_comparison_starting_data_changed', 'Keep the original starting data and simulated connections for both comparison sides. No startup check or plan was created.', 2);
+        }
+        const initial = setup;
+        const startup = await api(`${context.prefix}/validation${selected.location === 'local' ? '?trial_grant_id=' + selected.grant.id : ''}`, auth(context, options.signal));
+        const value = startup.validation;
+        if (value?.active)
+            throw new CliError('validation_in_progress', 'Startup checks are already active for this comparison world. Inspect that original job; no duplicate was queued.', 2);
+        if (!value?.current || value.state !== 'completed' || value.scope !== 'native_runtime_and_scenario_preconditions'
+            || !value.execution_ready || value.execution_location !== selected.location
+            || selected.location === 'local' && startup.selected_execution_compatible !== true) {
+            let approve = options.validate === true;
+            if (!approve && interactive(options))
+                approve = await selectOne('Validate this comparison world first?', [
+                    { value: true, label: 'Review and run startup checks', detail: 'Starting-data edits are applied and recorded separately in each drill.' },
+                    { value: false, label: 'Exit without saving a plan' }
+                ], options.signal);
+            if (!approve)
+                throw new CliError('comparison_validation_required', 'Validate this world in the selected execution location first, or use --validate. No plan was saved.', 2);
+            await validateWorld(context, selected, options, output, proposal);
+            setup = await readSetup(context, options.signal);
+            if (setup.agent_comparison?.id !== initial.agent_comparison.id || setup.plan?.id !== initial.plan?.id
+                || setup.world_revision !== initial.world_revision || setup.configuration_revision !== initial.configuration_revision
+                || setup.selection_revision !== initial.selection_revision || setup.evaluation_revision !== initial.evaluation_revision) {
+                throw new CliError('agent_comparison_selection_changed', 'Comparison inputs changed during startup checks. Review the current setup; no plan was saved.', 2);
+            }
+        }
+    }
+    const frozen = setup.agent_comparison;
+    if (frozen && (!frozen.current || options.scenarios?.length))
+        throw new CliError('agent_comparison_selection_changed', 'This comparison requires its complete frozen selection. Review the original comparison if it is no longer current.', 2);
+    const selector = frozen ? { mode: 'all_matching', query: '', ids: [], excluded: [] } : await scenarios(context, setup, options);
+    const parallelCapacity = Math.min(setup.capacity.max_parallelism, selected.location === 'local' ? selected.grant.document.limits.parallelism : setup.capacity.max_parallelism);
+    if (frozen && (frozen.repetitions > setup.capacity.max_repetitions || frozen.parallelism > parallelCapacity || frozen.trial_seconds > setup.capacity.max_trial_seconds
+        || options.repetitions !== undefined && Number(options.repetitions) !== frozen.repetitions
+        || options.parallel !== undefined && Number(options.parallel) !== frozen.parallelism || options.seconds !== undefined && Number(options.seconds) !== frozen.trial_seconds)) {
+        throw new CliError('agent_comparison_settings_changed', 'Keep the original comparison settings. Choose compatible execution permission or review a new comparison instead of silently lowering the settings.', 2);
+    }
+    const repetitions = frozen?.repetitions ?? await numberOption(options.repetitions, setup.defaults.repetitions, setup.capacity.max_repetitions, 'Runs per scenario', options);
+    const parallelism = frozen?.parallelism ?? await numberOption(options.parallel, setup.defaults.parallelism, parallelCapacity, 'Parallel drills', options);
+    const continuity = await api(context.prefix + '/continuous-requirements', {
+        ...auth(context, options.signal), method: 'POST', body: { selector, world_revision: setup.world_revision, selection_revision: setup.selection_revision }
+    });
+    if (!continuityRequirementsMatch(continuity, context.world, setup.world_revision, setup.selection_revision))
+        throw new CliError('continuous_plan_changed', 'The selected scenario duration could not be confirmed. Review setup again.');
+    if (continuity.minimum_trial_seconds > setup.capacity.max_trial_seconds)
+        throw new CliError('continuous_capacity_required', 'This selection needs more time than the current drill capacity. Choose a shorter scenario or contact support.', 2);
+    const seconds = frozen?.trial_seconds ?? await numberOption(options.seconds, setup.plan?.current ? setup.defaults.trial_seconds : Math.max(setup.defaults.trial_seconds, continuity.minimum_trial_seconds), setup.capacity.max_trial_seconds, 'Seconds per drill', options);
+    if (seconds < continuity.minimum_trial_seconds)
+        throw new CliError('continuous_duration_required', `This selection needs at least ${continuity.minimum_trial_seconds} seconds per drill. Review its actual-time schedule.`, 2);
+    if (frozen)
+        output('comparison_scope', frozen, `${frozen.side === 'control' ? 'Control' : 'Candidate'} comparison: ${frozen.scenario_count} frozen scenarios, ${repetitions} repetitions. Criteria and world definitions are retained from the original report.`);
+    let assess = options.assess === true;
+    if (!assess && setup.automatic_criteria_count && interactive(options))
+        assess = await selectOne('Saved evaluation criteria', [
+            { value: true, label: 'Assess this simulation', detail: 'Use selected evidence and policy passages for AI scoring and cited explanations after each drill and at declared memory checkpoints.' },
+            { value: false, label: 'Run without automatic assessment' }
+        ], options.signal);
+    if (frozen?.run_saved_criteria && setup.automatic_criteria_count && !assess)
+        throw new CliError('assessment_consent_required', 'This comparison retains its assessment criteria. Approve evidence sharing with --assess or cancel; it will not run with weaker criteria.', 2);
+    let driverInput = options.approveAgentInput === true;
+    if (setup.execution_driver?.requires_input) {
+        if (setup.real_connections_count > 0)
+            throw new CliError('agent_driver_action_denied', 'This agent input adapter requires simulated connections.', 2);
+        await reviewDriverInput(context, setup, options, output);
+        const timing = executionScheduleText(setup.execution_driver);
+        if (timing)
+            output('execution_timing', { kind: setup.execution_driver.kind,
+                scheduled_after_ms: setup.execution_driver.scheduled_after_ms }, timing);
+        if (!driverInput && interactive(options))
+            driverInput = await selectOne('Agent interaction', [
+                { value: false, label: 'Cancel' }, { value: true, label: 'Use the prepared input adapter',
+                    detail: `Reviewed ${setup.execution_driver.kind.replaceAll('_', ' ')} recipe ${setup.execution_driver.revision}. Simulated users can interact only with the isolated agent and its approved dependencies.${timing ? ` ${timing}` : ''}` }
+            ], options.signal);
+        if (!driverInput)
+            throw new CliError('agent_driver_input_required', `Review input with firedrill driver review --world ${context.world} --workspace ${context.workspace}. Automation requires explicit --approve-agent-input.`, 2);
+    }
+    else if (driverInput)
+        throw new CliError('agent_execution_identity_changed', 'No non-chat input adapter is selected. Remove --approve-agent-input.', 2);
+    const desktopInputRequired = setup.execution_driver?.kind === 'desktop';
+    if (desktopInputRequired && !setup.desktop_capture_available)
+        throw new CliError('desktop_capture_unavailable', 'The prepared desktop input adapter needs private screen capture. Review this world’s desktop setup before planning.', 2);
+    let recordBrowser = options.recordBrowser === true;
+    if (recordBrowser && desktopInputRequired)
+        throw new CliError('simulation_capture_policy_invalid', 'This input adapter requires desktop capture. Omit --record-browser and review --record-desktop with --acknowledge-desktop-screen-content.', 2);
+    if (typeof setup.mask_browser_form_values !== 'boolean')
+        throw new CliError('simulation_capture_policy_changed', 'The browser capture preference could not be confirmed. Refresh simulation setup before saving.', 2);
+    if (recordBrowser && !setup.browser_capture_available)
+        throw new CliError('browser_capture_unavailable', 'Browser captures need a prepared browser entry point with simulated connections.', 2);
+    if (!desktopInputRequired && !recordBrowser && setup.browser_capture_available && interactive(options))
+        recordBrowser = await selectOne('Browser evidence', [
+            { value: false, label: 'Do not save browser captures' },
+            { value: true, label: 'Save private browser captures', detail: `${setup.mask_browser_form_values ? 'Form values will be masked.' : 'Form values may be visible.'} Passwords and marked-private content stay masked. Other visible text may be retained. Captures are not sent to the evaluator.` }
+        ], options.signal);
+    let recordVoice = options.recordVoice === true;
+    if (recordVoice && !setup.voice_capture_available)
+        throw new CliError('voice_capture_unavailable', 'Audio recording needs a prepared voice session with simulated connections.', 2);
+    if (!recordVoice && setup.voice_capture_available && interactive(options))
+        recordVoice = await selectOne('Audio evidence', [
+            { value: false, label: 'Do not save audio recordings' },
+            { value: true, label: 'Save private conversation audio', detail: 'Audio is not automatically redacted. Recordings follow workspace retention and are not sent to the evaluator.' }
+        ], options.signal);
+    let recordDesktop = options.recordDesktop === true;
+    let screenAcknowledged = options.acknowledgeDesktopScreenContent === true;
+    if (recordDesktop && !setup.desktop_capture_available)
+        throw new CliError('desktop_capture_unavailable', 'Desktop captures need a prepared private desktop with simulated connections.', 2);
+    if (recordBrowser && recordDesktop)
+        throw new CliError('simulation_capture_policy_invalid', 'Choose --record-browser or --record-desktop, not both.', 2);
+    if (!recordDesktop && !recordBrowser && setup.desktop_capture_available && interactive(options))
+        recordDesktop = await selectOne('Desktop evidence', [
+            { value: false, label: desktopInputRequired ? 'Cancel desktop simulation' : 'Do not save desktop captures' },
+            { value: true, label: 'Save private desktop captures', detail: `${desktopInputRequired ? 'Required to see and operate this desktop. ' : ''}Declared pixel regions are masked. Text screening can miss sensitive content and does not hide form values automatically.` }
+        ], options.signal);
+    if (recordDesktop && !screenAcknowledged && interactive(options)) {
+        screenAcknowledged = await selectOne('Screen content', [
+            { value: false, label: desktopInputRequired ? 'Cancel desktop simulation' : 'Continue without desktop recording' },
+            { value: true, label: 'I understand visible screen content may be retained', detail: 'Captures follow workspace retention and are not sent to the evaluator.' }
+        ], options.signal);
+        if (!screenAcknowledged)
+            recordDesktop = false;
+    }
+    if (desktopInputRequired && (!recordDesktop || !screenAcknowledged)) {
+        output('desktop_capture_consent_required', { world_id: context.world, driver_contract_sha256: setup.execution_driver.contract_sha256,
+            required_input: [...(!recordDesktop ? ['record_desktop'] : []), ...(!screenAcknowledged ? ['acknowledge_desktop_screen_content'] : [])],
+            required_flags: [...(!recordDesktop ? ['--record-desktop'] : []), ...(!screenAcknowledged ? ['--acknowledge-desktop-screen-content'] : [])] }, 'This desktop input adapter needs explicitly approved private screen capture and acknowledgement of visible screen content.');
+        throw new CliError('desktop_capture_consent_required', 'Review --record-desktop and --acknowledge-desktop-screen-content before creating this desktop plan. No screen-recording consent was added automatically.', 2);
+    }
+    if (recordDesktop && !screenAcknowledged)
+        throw new CliError('desktop_capture_consent_required', 'Desktop recording requires --acknowledge-desktop-screen-content, or omit --record-desktop.', 2);
+    if (!recordDesktop && screenAcknowledged)
+        throw new CliError('desktop_capture_consent_invalid', 'Use --acknowledge-desktop-screen-content only with --record-desktop.', 2);
+    if (!Number.isSafeInteger(setup.real_connections_count) || setup.real_connections_count < 0)
+        throw new CliError('simulation_setup_changed', 'The connection selection could not be confirmed. Reopen simulation setup.');
+    let externalEffects;
+    if (setup.real_connections_count > 0) {
+        let effects = options.approveRealSimulation === true, shared = options.acknowledgeSharedState === true;
+        if (!effects && interactive(options))
+            effects = await selectOne('Real-account simulation', [
+                { value: false, label: 'Cancel' }, { value: true, label: 'Approve the selected real-account operations',
+                    detail: `${setup.real_connections_count} real connections. Agent startup, readiness and scenario execution may affect actual accounts. ${repetitions} repetitions, up to ${parallelism} concurrent, ${seconds}s per drill.` }
+            ], options.signal);
+        if (!shared && effects && interactive(options))
+            shared = await selectOne('External account state', [
+                { value: false, label: 'Cancel' }, { value: true, label: 'Continue with shared account state',
+                    detail: 'Actual accounts are shared across drills and are not reset. Simulations may influence one another. An uncertain real write requires review, not automatic replay.' }
+            ], options.signal);
+        if (!effects || !shared)
+            throw new CliError('real_simulation_consent_required', 'Review real-account effects and shared state. Automation requires --approve-real-simulation --acknowledge-shared-state; startup approval and --run do not grant this permission.', 2);
+        externalEffects = { actor_id: context.owner, acknowledge_effects: true, acknowledge_shared_state: true };
+    }
+    else if (options.approveRealSimulation || options.acknowledgeSharedState) {
+        throw new CliError('real_simulation_selection_changed', 'This configuration has no real-account connections. Remove the real-simulation approval options and review the selection.', 2);
+    }
+    if (options.applicationCheckpoint !== undefined && options.coordinatedCheckpoint !== undefined)
+        throw new CliError('application_continuation_combination_unavailable', 'Choose one saved application or coordinated checkpoint, not both.', 2);
+    if ((options.applicationCheckpoint !== undefined || options.coordinatedCheckpoint !== undefined) && options.dataset !== undefined)
+        throw new CliError('application_continuation_combination_unavailable', 'Choose an application checkpoint or a separate starting dataset, not both.', 2);
+    const dataset = options.applicationCheckpoint !== undefined || options.coordinatedCheckpoint !== undefined ? null : await startingData(context, setup, options);
+    const application = await applicationStartingState(context, setup, options, dataset, selected, proposal);
+    let shareDatasetWithDevice = options.shareDatasetWithDevice === true;
+    if (dataset && selected.location === 'local') {
+        if (!shareDatasetWithDevice && interactive(options))
+            shareDatasetWithDevice = await selectOne('Download starting data to this device?', [
+                { value: false, label: 'Cancel' }, { value: true, label: 'Download the selected data for these drills',
+                    detail: 'Use a private runner cache outside your project. Firedrill cannot remotely erase device copies or backups.' }
+            ], options.signal);
+        if (!shareDatasetWithDevice)
+            throw new CliError('local_dataset_consent_required', 'Approve the selected starting-data download interactively or use --share-dataset-with-device. No simulation was admitted.', 2);
+    }
+    else if (shareDatasetWithDevice) {
+        throw new CliError('local_dataset_consent_invalid', 'Use --share-dataset-with-device only with saved starting data and local execution.', 2);
+    }
+    if (dataset)
+        output('simulation_starting_data', { id: dataset.id, edit_count: dataset.edit_count }, `${dataset.edit_count} saved edits selected for each independent drill. Application will be recorded separately from its score.`);
+    const body = { previous_plan_id: setup.plan?.id ?? null, world_revision: setup.world_revision,
+        configuration_revision: setup.configuration_revision, selection_revision: setup.selection_revision, evaluation_revision: setup.evaluation_revision,
+        share_evaluation_evidence: assess, share_evaluation_explanation: assess, run_saved_criteria: frozen?.run_saved_criteria ?? assess, selector, repetitions, parallelism, trial_seconds: seconds, record_browser: recordBrowser, record_voice: recordVoice,
+        record_desktop: recordDesktop, acknowledge_desktop_screen_content: screenAcknowledged,
+        driver_input_authorized: driverInput,
+        driver_contract_sha256: driverInput ? setup.execution_driver.contract_sha256 : null,
+        mask_browser_form_values: setup.mask_browser_form_values,
+        execution: selected.location === 'local' ? { location: 'local', grant_id: selected.grant.id } : { location: 'managed' }, dataset_id: dataset?.id ?? null,
+        share_dataset_with_device: shareDatasetWithDevice,
+        application_checkpoint_id: application?.kind === 'application' ? application.checkpoint.id : null,
+        acknowledge_fresh_world_state: application?.kind === 'application' && application.acknowledged,
+        share_application_checkpoint_with_device: application?.kind === 'application' && application.share,
+        coordinated_checkpoint_id: application?.kind === 'coordinated' ? application.checkpoint.id : null,
+        acknowledge_supported_checkpoint_scope: application?.kind === 'coordinated' && application.acknowledged,
+        share_coordinated_checkpoint_with_device: application?.kind === 'coordinated' && application.share,
+        ...(externalEffects ? { external_effects: externalEffects } : {}) };
+    if (proposal)
+        proposalBasis(await executionProposal(context, proposal.id, options.signal), await preparation(context, options.signal), await readSetup(context, options.signal));
+    const saved = await createIntent(context, 'plan', body, options.signal, output, proposal?.plan_request_key);
+    if (!isNativeSetupReceipt(saved.receipt))
+        throw new CliError('simulation_plan_unconfirmed', `Inspect setup request ${saved.intent.key}. No campaign was started.`);
+    const plan = saved.receipt.plan;
+    if (saved.receipt.state !== 'accepted' || !saved.receipt.resource_available || !plan?.current || !plan.id
+        || !planMatchesRequest(plan, body)
+        || plan.dataset_id !== (dataset?.id ?? null) || shareDatasetWithDevice && !plan.dataset_download_approved_for_actor
+        || !/^[a-f0-9]{64}$/.test(plan.recipe_sha256)) {
+        throw new CliError('simulation_plan_unconfirmed', `Inspect setup request ${saved.intent.key}. No campaign was started.`);
+    }
+    await admitPlan(context, plan, selected, options, output, proposal);
+}
+async function admitPlan(context, plan, selected, options, output, proposal) {
+    if (!plan.current || plan.execution.location !== selected.location
+        || selected.location === 'local' && (plan.execution.location !== 'local' || plan.execution.grant_id !== selected.grant.id)
+        || plan.mode === 'external_shared' && !plan.real_access_approved_for_actor
+        || plan.dataset_id && selected.location === 'local' && !plan.dataset_download_approved_for_actor
+        || plan.application_checkpoint_id && (!plan.acknowledge_fresh_world_state || !plan.application_continuation
+            || plan.dataset_id || plan.mode === 'external_shared'
+            || selected.location === 'local' && !plan.application_checkpoint_download_approved_for_actor)
+        || plan.coordinated_checkpoint_id && (!plan.acknowledge_supported_checkpoint_scope || !plan.application_continuation
+            || plan.application_continuation.dependencies !== 'coordinated_native_checkpoint' || plan.dataset_id || plan.mode === 'external_shared'
+            || selected.location === 'local' && !plan.coordinated_checkpoint_download_approved_for_actor)
+        || plan.record_desktop !== plan.acknowledge_desktop_screen_content
+        || options.dataset !== undefined && options.dataset !== plan.dataset_id
+        || options.applicationCheckpoint !== undefined && identifier(options.applicationCheckpoint) !== plan.application_checkpoint_id
+        || options.coordinatedCheckpoint !== undefined && identifier(options.coordinatedCheckpoint) !== plan.coordinated_checkpoint_id
+        || options.acknowledgeFreshWorldState && !plan.application_checkpoint_id
+        || options.shareApplicationCheckpointWithDevice && (!plan.application_checkpoint_id || selected.location !== 'local')
+        || options.acknowledgeSupportedCheckpointScope && !plan.coordinated_checkpoint_id
+        || options.shareCoordinatedCheckpointWithDevice && (!plan.coordinated_checkpoint_id || selected.location !== 'local')
+        || options.assess === true && !plan.run_saved_criteria || options.recordBrowser === true && !plan.record_browser
+        || options.recordVoice === true && !plan.record_voice || options.recordDesktop === true && !plan.record_desktop
+        || options.acknowledgeDesktopScreenContent === true && !plan.record_desktop
+        || (options.approveRealSimulation || options.acknowledgeSharedState) && plan.mode !== 'external_shared'
+        || options.shareDatasetWithDevice === true && (!plan.dataset_id || selected.location !== 'local')) {
+        throw new CliError('simulation_plan_changed', 'The original plan or its location, capture, evidence, dataset or real-account approval could not be confirmed. It was not replaced.', 2);
+    }
+    output('simulation_plan_review', plan, `${plan.planned_trials} planned drills. ${plan.execution.location} execution. `
+        + `${plan.run_saved_criteria ? 'Saved criteria enabled' : 'No automatic saved-criteria assessment'}. `
+        + `Browser captures: ${plan.record_browser ? 'yes' : 'no'}; audio: ${plan.record_voice ? 'yes' : 'no'}; desktop: ${plan.record_desktop ? 'yes' : 'no'}.`
+        + (plan.mode === 'external_shared' ? '\nReviewed real-account effects use shared state and cannot be reset.' : '')
+        + (plan.dataset_id ? `\nStarting data: ${plan.dataset_id}${selected.location === 'local' ? ', download approved for this actor' : ''}.` : '')
+        + (plan.application_continuation ? `\nApplication continuation: ${plan.application_continuation.components.map(one => terminalText(one.name)).join(', ')}. `
+            + (plan.application_continuation.dependencies === 'coordinated_native_checkpoint' ? 'Captured supported native state is restored in a new process. Wall time continues.'
+                : 'A new process and fresh prepared synthetic services are used for each drill.') : ''));
+    let quote = await quoteFor(context, plan, selected, options.signal);
+    if (!quote.readiness.ready) {
+        if (plan.dataset_id || plan.application_checkpoint_id || plan.coordinated_checkpoint_id)
+            throw new CliError('starting_data_plan_needs_review', `Plan saved, but startup evidence or execution permission needs review. ${quote.readiness.message ?? ''} Review starting data and save a current plan before running. No new validation or campaign was queued.`, 2);
+        let validate = options.validate === true;
+        if (!validate && interactive(options))
+            validate = await selectOne('Startup validation is required', [
+                { value: true, label: 'Validate before running', detail: quote.readiness.message ?? undefined },
+                { value: false, label: 'Keep the saved plan and exit' }
+            ], options.signal);
+        if (!validate)
+            throw new CliError('world_execution_not_ready', 'Plan saved. Run firedrill validate or approve --validate before starting this simulation.', 2);
+        const current = proposal ? await executionProposal(context, proposal.id, options.signal) : undefined;
+        if (current?.validation)
+            await observeValidation(context, current.validation.id, selected, options, output, current.id);
+        else
+            await validateWorld(context, selected, options, output, current);
+        quote = await quoteFor(context, plan, selected, options.signal);
+    }
+    if (quote.plan_id !== plan.id || quote.execution_location !== selected.location || !quote.readiness.ready)
+        throw new CliError('simulation_not_ready', quote.readiness.message ?? 'Review the saved plan before running.');
+    const credits = (units) => creditAmount(units, quote.credits.credit_scale);
+    output('simulation_quote', quote, `${quote.planned_trials} drills; up to ${quote.admitted_concurrency_ceiling} concurrent.\n`
+        + `Estimated ${credits(quote.credits.estimated_units)} credits; maximum ${credits(quote.credits.maximum_units)}. Target model use is separate.`);
+    if (quote.funding_held)
+        throw new CliError('billing_adjustment_pending', 'A payment adjustment needs review before new simulations can start. Existing reports remain available. No campaign was admitted.');
+    if (!quote.funded)
+        throw new CliError('simulation_balance_insufficient', 'Open Billing to add credits or apply an event code. No campaign was admitted.');
+    if (quote.admitted_concurrency_ceiling < 1)
+        throw new CliError('simulation_capacity_pending', 'Execution capacity is not available for this plan yet. No campaign was admitted.');
+    await confirmation(options, 'Run this simulation?', `Reserve ${credits(quote.credits.estimated_units)} estimated credits now, with a maximum authorized budget of ${credits(quote.credits.maximum_units)} credits for these drills.`);
+    if (proposal) {
+        const current = await executionProposal(context, proposal.id, options.signal);
+        if (current.campaign) {
+            await resumeSimulation(current.campaign.id, { ...options, proposal: undefined }, output);
+            return;
+        }
+        proposalBasis(current, await preparation(context, options.signal), await readSetup(context, options.signal));
+        if (!current.plan || current.plan.id !== plan.id || current.plan.recipe_sha256 !== plan.recipe_sha256 || !executionPlanMatches(current, plan)) {
+            throw new CliError('simulation_plan_changed', 'The original proposal’s saved plan changed. No campaign was admitted.');
+        }
+    }
+    if (Date.parse(quote.credits.expires_at) <= Date.now())
+        throw new CliError('credit_quote_expired', 'Review the current simulation budget again. No simulation started.');
+    const admitted = await createIntent(context, 'admission', { plan_id: plan.id, recipe_sha256: plan.recipe_sha256, usage_quote_id: quote.credits.quote_id }, options.signal, output, proposal?.admission_request_key);
+    if (isNativeSetupReceipt(admitted.receipt) || admitted.receipt.state !== 'admitted' || !admitted.receipt.campaign_id)
+        throw new CliError('campaign_acceptance_unconfirmed', `Inspect setup request ${admitted.intent.key}. No replacement campaign was started.`);
+    const id = identifier(admitted.receipt.campaign_id);
+    output('campaign_admitted', { campaign_id: id, report_url: reportLink(context, id) }, `Simulation saved. Report: ${reportLink(context, id)}\nCtrl+C stops this terminal, not the saved campaign.`);
+    const result = await watch(context, id, selected, Math.min(plan.parallelism, quote.admitted_concurrency_ceiling), options, output);
+    output('campaign_finished', { ...result, report_url: reportLink(context, id) }, `Simulation ${result.state}. Report: ${reportLink(context, id)}`);
+}
+export async function simulationRequest(action, key, options, output) {
+    const context = await contextFor(options);
+    if (action === 'list') {
+        let after = options.after;
+        while (true) {
+            const page = await intentPage(context, after, options.signal);
+            output('simulation_requests', { ...page, results: page.results.map(row => ({ request_key: row.intent.key,
+                    kind: row.intent.kind, created_at: row.intent.created_at, receipt: row.receipt })) }, (page.results.map(row => `${row.intent.key}  ${row.intent.kind}  ${row.receipt.state}`).join('\n') || 'No saved setup requests on this page.')
+                + (page.next_after ? `\nMore requests: firedrill simulation requests --world ${context.world} --workspace ${context.workspace} --after ${page.next_after}` : ''));
+            if (!page.next_after || !interactive(options) || !await selectOne('Saved setup requests', [
+                { value: true, label: 'Next page' }, { value: false, label: 'Done' },
+            ], options.signal))
+                break;
+            after = page.next_after;
+        }
+        return;
+    }
+    if (!key)
+        throw new CliError('setup_request_required', 'Choose the original setup request ID.', 2);
+    let result;
+    if (action === 'continue') {
+        result = await inspectIntent(context, identifier(key), options.signal);
+        if (['not_received', 'pending'].includes(result.receipt.state)) {
+            // Resending would start legacy validation, planning or admission, which this release retires (FIR-504;
+            // root's managed_target_launch gate is off). Reading and withdrawing the original stay available.
+            const scope = `--world ${context.world} --workspace ${context.workspace}`;
+            throw new CliError('legacy_launch_retired', `Original setup ${result.intent.key}: ${result.receipt.state}. Sending it again is retired in this release.\n`
+                + `Read it: firedrill simulation request status ${result.intent.key} ${scope}\nWithdraw it: firedrill simulation request withdraw ${result.intent.key} ${scope}\n`
+                + 'New simulations use firedrill plan, apply and run. Nothing was sent.', 2);
+        }
+    }
+    else
+        result = action === 'withdraw' ? await withdrawIntent(context, identifier(key), options.signal) : await inspectIntent(context, identifier(key), options.signal);
+    const setup = isNativeSetupReceipt(result.receipt) ? result.receipt : null;
+    const admission = !isNativeSetupReceipt(result.receipt) ? result.receipt : null;
+    output('simulation_request_receipt', { request_key: result.intent.key, kind: result.intent.kind, ...result.receipt }, `Setup ${result.intent.key}: ${result.receipt.state}.`
+        + (['accepted', 'admitted'].includes(result.receipt.state) ? ' Accepted work was not canceled or restarted.' : '')
+        + (result.receipt.state === 'not_received' ? ' This is not proof that the original request cannot still arrive.' : '')
+        + (setup?.resource_id ? `\n${result.intent.kind === 'validation' ? 'Validation job' : 'Plan'}: ${setup.resource_id}` : '')
+        + (admission?.campaign_id ? `\nReport: ${reportLink(context, admission.campaign_id)}` : ''));
+}
+/**
+ * Watch an original simulation without starting anything (FIR-504). Root's
+ * launch gates are off in this release, so never-claimed legacy drills stay
+ * unclaimed: no permission is selected, no assignment is claimed and no runner
+ * presence is opened. Original local claims are handed to their existing
+ * recovery commands, exactly as before; `simulation cancel` stops the rest.
+ */
+export async function resumeSimulation(id, options, output) {
+    id = identifier(id);
+    const context = await contextFor(options);
+    let current = await campaign(context, id, options.signal);
+    if (terminal(current.state)) {
+        output('campaign_finished', { ...current, report_url: reportLink(context, id) }, `Simulation ${current.state}. Report: ${reportLink(context, id)}`);
+        return;
+    }
+    if (current.execution_location === 'local' && options.managed || current.execution_location === 'managed' && (options.local || options.device || options.grant)) {
+        throw new CliError('campaign_location_changed', 'Continue in this simulation’s original execution location. No work was relocated.');
+    }
+    const location = current.execution_location;
+    const original = location === 'local' ? current.local_execution : null;
+    if (location === 'local') {
+        if (!original)
+            throw new CliError('campaign_permission_changed', 'The original local execution permission is unavailable. No replacement was selected.');
+        identifier(original.grant_id);
+        identifier(original.device_key);
+        if (options.device && identifier(options.device) !== original.device_key)
+            throw new CliError('campaign_permission_changed', 'Use the original device saved with this simulation. No replacement was selected.');
+    }
+    const scope = `--world ${context.world} --workspace ${context.workspace}`;
+    const cancel = `firedrill simulation cancel ${id} ${scope}`;
+    output('campaign_watch_only', { campaign_id: id, execution_location: location, new_work_started: false, execution_repeated: false,
+        cancel_command: cancel, report_url: reportLink(context, id) }, 'Watching the original simulation only. Starting work from the older world commands is retired in this release, so never-claimed drills are not started and nothing is replayed.\n'
+        + `Stop it: ${cancel}\nNew simulations use firedrill plan, apply and run.`);
+    let previous = '', recoveryPage = 1;
+    while (true) {
+        const summary = JSON.stringify({ state: current.state, trials: current.trial_states, invocations: current.observed_invocations });
+        if (summary !== previous) {
+            output('campaign_progress', current, `${current.state.replaceAll('_', ' ')}: ${Object.entries(current.trial_states).map(([state, count]) => `${count} ${state.replaceAll('_', ' ')}`).join(', ') || 'allocating drills'}.\n`
+                + `${current.observed_invocations} retained target-invocation observations.`);
+            previous = summary;
+        }
+        if (terminal(current.state))
+            break;
+        if (original) {
+            // Scoped GETs only: an original claim is handed to its existing recovery commands; nothing is claimed here.
+            // Expired permission is not a reason to hide original ownership or select a replacement.
+            try {
+                recoveryPage = await localCampaignRecovery(context, id, { device: original.device_key, grant: original.grant_id }, new Map(), recoveryPage, options.signal, output);
+                if (recoveryPage === 1 && !current.cancel_requested) {
+                    const unclaimed = await localAssignmentsPage(context, original.device_key, { available: true, world: context.world, campaign: id }, options.signal);
+                    if (unclaimed.results.length) {
+                        output('campaign_unstarted_retained', { campaign_id: id, execution_repeated: false, new_work_started: false,
+                            cancel_command: cancel, report_url: reportLink(context, id) }, `This simulation still has drills that never started. Starting them is retired in this release, so it will not finish on its own.\nStop it: ${cancel}\nSimulation report: ${reportLink(context, id)}`);
+                        throw new CliError('legacy_launch_retired', `Cancel the original simulation with ${cancel}, or leave it as retained history. New simulations use firedrill plan, apply and run. Nothing was started.`, 2);
+                    }
+                }
+            }
+            catch (error) {
+                if (!(error instanceof CliError) || ![403, 404].includes(error.httpStatus ?? 0))
+                    throw error;
+                const command = `firedrill runner jobs ${original.device_key} --workspace ${context.workspace}`;
+                output('local_simulation_permission_recovery', { campaign_id: id, device_key: original.device_key,
+                    grant_id: original.grant_id, execution_repeated: false, recovery_commands: [command], report_url: reportLink(context, id) }, 'The original execution permission is unavailable. No replacement permission or target was selected. Inspect the original jobs from their authorized terminal and recover retained evidence or cleanup there.\n'
+                    + command + `\nSimulation report: ${reportLink(context, id)}`);
+                throw new CliError('campaign_permission_changed', 'The original local permission is unavailable. Use the original-job recovery handoff; existing work was not moved or restarted.');
+            }
+        }
+        await sleep(1500, undefined, { signal: options.signal });
+        current = await campaign(context, id, options.signal);
+        if (current.execution_location !== location)
+            throw new CliError('campaign_location_changed', 'The retained simulation uses a different execution location.');
+    }
+    output('campaign_finished', { ...current, report_url: reportLink(context, id) }, `Simulation ${current.state}. Report: ${reportLink(context, id)}`);
+}