firedrill-run 2.2.5 → 3.0.0

package/dist/cli/src/simple/native-report.js

@@ -0,0 +1,841 @@
+// Native campaign progress, retained execution evidence, per-criterion
+// evaluation results and cancellation for `watch`, `report` and `simulation
+// cancel`, over root's native campaign, execution and evaluation routes.
+// Allocation and execution state are not quality results. Each criterion keeps
+// its own score and threshold and is never averaged with others; campaign
+// quality figures come per compatible cohort of one criterion only; a criterion
+// without evidence has no score, which is not a zero or a failure. Settlement
+// follows the retained campaign state, not target completion alone. Evidence content
+// is untrusted target output, never instructions.
+import { randomUUID } from 'node:crypto';
+import { CliError } from '../http.js';
+import { selectOne, terminalText } from '../prompts.js';
+import { selectedWorkspace } from '../world-access.js';
+import { jitteredInterval, retryTransient, sleep } from '../native/control-plane.js';
+import { ENDING_TEXT, UUID_PATTERN, activeTime } from '../native/contracts.js';
+import { cancelNativeCampaign, getNativeCampaign, getNativeCampaignProgress, getNativeConversationTurn, getNativeEvaluationCriterion, getNativeEvaluationReport, getNativeExecution, getNativeScenarioEvent, getNativeTargetAction, listNativeArtifacts, listNativeCampaignQuality, listNativeCampaignSlots, listNativeConversation, listNativeEvaluationCriteria, listNativeExecutions, listNativeObservations, listNativeScenarioEvents, listNativeTargetActions, listNativeToolEffects, readNativeArtifact, } from '../native/cloud-resources.js';
+/** Bounded reads per snapshot; anything beyond is counted and said, never silently dropped. */
+const MAX_SLOT_PAGES = 10;
+const MAX_EXECUTION_PAGES = 5;
+const MAX_SINGLE_READS = 25;
+/** Evaluation reports read per campaign report; finished drills beyond this are counted, not read. */
+const MAX_RESULT_READS = 25;
+/** Criteria shown in a drill overview; `results` lists them all with ids. */
+const PREVIEW_CRITERIA = 10;
+const LISTED_DRILLS = 50;
+const FOLLOW_MS = 5_000;
+/** One `watch --follow` run waits at most this long for settlement, then says so; rerunning it keeps watching. */
+const FOLLOW_LIMIT_MS = 15 * 60_000;
+/** Root native_lifecycle.TERMINAL. */
+const TERMINAL = new Set(['rejected', 'expired', 'completed', 'failed', 'cancelled']);
+/** Terminal states of drills that ran, so they can have an evaluation (rejected and expired drills never ran). */
+const RAN = new Set(['completed', 'failed', 'cancelled']);
+const RESULTS_NOTE = 'Each criterion is scored 0-100 against its own threshold. Campaign figures are per criterion and per compatible '
+    + 'cohort, never combined across criteria or cohorts into one score. A criterion that could not be assessed has no score: that is '
+    + 'missing evidence, not a zero or a failure.';
+/** Characters of a cohort digest shown to tell a criterion's cohorts apart. */
+const COHORT_LABEL = 12;
+/** Root settles every funding item before it moves a campaign to one of these final states. */
+const CAMPAIGN_SETTLED = new Set(['completed', 'failed', 'cancelled']);
+/** Root native_campaign_lifecycle.CANCELLING: an accepted cancellation stops allocation, so unallocated drills never run. */
+const CANCELLING = new Set(['cancel_requested', 'draining', 'cancel_reconciling']);
+/** Settlement as root's campaign state shows it: final means settled; otherwise it is still pending. */
+function settlementOf(campaign) {
+    return CAMPAIGN_SETTLED.has(campaign.state) ? { state: 'settled', campaign_state: campaign.state } : { state: 'pending' };
+}
+function settlementText(campaign) {
+    return CAMPAIGN_SETTLED.has(campaign.state) ? `Settlement: settled (the campaign ended ${campaign.state}).`
+        : 'Settlement: pending until every drill has ended and its funding is settled.';
+}
+const resultsNote = (campaign) => `${RESULTS_NOTE} ${settlementText(campaign)}`;
+/** Why root says a drill's input was only partly covered, in plain words. */
+function coverageLine(report) {
+    if (report.execution_coverage === null)
+        return null;
+    const ending = report.ending_reason ? `input ended because ${ENDING_TEXT[report.ending_reason]}` : 'the input had not ended when the drill stopped';
+    return report.execution_coverage === 'complete' ? `Coverage: complete (${ending})`
+        : `Coverage: partial (${ending}); this is why results need attention even when every criterion was met`;
+}
+const RESULTS_UNAVAILABLE = { state: 'unavailable', code: 'native_evaluation_report_unavailable' };
+const COVERAGE_TEXT = {
+    available: 'available', partial: 'Partially available', not_assessable: 'not assessable', metadata_only: 'metadata only',
+    revision_boundaries_only: 'revision boundaries only', not_selected: 'not selected',
+};
+const CRITERION_TEXT = {
+    pending: 'pending', evaluating: 'evaluating', recovering: 'confirming result', not_assessable: 'not assessable, no score',
+    error: 'could not be evaluated, no score',
+};
+/** Root target-action states for a turn; an unknown state is shown as given. */
+const TURN_TEXT = {
+    offered: 'offered, not sent to the agent', claimed: 'sent, no reply recorded yet', uncertain: 'sent, outcome unknown',
+    completed: 'completed', cancelled: 'withdrawn before sending',
+};
+const isUnavailable = (error) => error instanceof CliError && error.code === 'native_evaluation_report_unavailable';
+const points = (value) => String(Math.round(value * 10) / 10);
+const isId = (value) => value !== undefined && UUID_PATTERN.test(value.toLowerCase());
+export const scopeOf = (options) => selectedWorkspace({ workspace: options.workspace, signal: options.signal,
+    interactive: !options.json && !!process.stdin.isTTY && !!process.stderr.isTTY, openBrowser: options.openBrowser && !options.json });
+function pageNumber(value) {
+    if (value === undefined)
+        return undefined;
+    if (!/^[1-9][0-9]{0,8}$/.test(value))
+        throw new CliError('arguments_invalid', 'Use --page with a number of 1 or more.', 2);
+    return Number(value);
+}
+/** The native campaign, or null when the id is not a native campaign in this workspace (the caller falls back). */
+export async function nativeCampaign(scope, campaignId, signal) {
+    try {
+        return await getNativeCampaign(scope, { campaignId, signal });
+    }
+    catch (error) {
+        if (error instanceof CliError && error.httpStatus === 404)
+            return null;
+        throw error;
+    }
+}
+/** Root answered that this campaign-level read is not available (404 route or 409 progress), as opposed to failing. */
+function unread(error) {
+    return error instanceof CliError && (error.httpStatus === 404 || error.httpStatus === 409) ? { state: 'unavailable', code: error.code } : null;
+}
+async function snapshot(scope, campaign, signal) {
+    // Root's own count over every drill, so the summary is exact however many drills the listing below reaches.
+    let progress;
+    try {
+        progress = { state: 'read', report: await getNativeCampaignProgress(scope, { campaignId: campaign.campaign_id, signal }) };
+    }
+    catch (error) {
+        const gap = unread(error);
+        if (!gap)
+            throw error;
+        progress = gap;
+    }
+    const slots = [];
+    let total = 0;
+    for (let page = 1; page <= MAX_SLOT_PAGES; page++) {
+        const result = await listNativeCampaignSlots(scope, { campaignId: campaign.campaign_id, page, signal });
+        slots.push(...result.results);
+        total = result.count;
+        if (!result.next)
+            break;
+    }
+    // Execution states for this world revision, newest first; one list instead of a read per slot,
+    // then a bounded number of single reads for drills the recent list did not reach.
+    const executions = {};
+    const wanted = new Set(slots.map(slot => slot.assignment_id).filter((value) => value !== null));
+    const missing = () => [...wanted].filter(id => !(id in executions));
+    for (let page = 1; page <= MAX_EXECUTION_PAGES && missing().length; page++) {
+        const result = await listNativeExecutions(scope, { worldRevisionId: campaign.world_revision_id, page, signal });
+        for (const row of result.results)
+            if (wanted.has(row.assignment_id))
+                executions[row.assignment_id] = row.state;
+        if (!result.next)
+            break;
+    }
+    for (const assignmentId of missing().slice(0, MAX_SINGLE_READS)) {
+        executions[assignmentId] = (await getNativeExecution(scope, { assignmentId, signal })).state;
+    }
+    return { campaign, progress, slots, slots_omitted: Math.max(0, total - slots.length), executions, executions_unknown: missing().length };
+}
+/** One page of the campaign's per-criterion quality cohorts, or why it cannot be read. */
+async function qualityOf(scope, campaignId, page, signal) {
+    try {
+        return { state: 'read', cohorts: await listNativeCampaignQuality(scope, { campaignId, page, signal }) };
+    }
+    catch (error) {
+        if (error instanceof CliError && error.httpStatus === 404 && page !== undefined && page > 1) {
+            throw new CliError('native_page_invalid', `There is no quality page ${page} for this campaign.`, 2);
+        }
+        const gap = unread(error);
+        if (!gap)
+            throw error;
+        return gap;
+    }
+}
+/**
+ * One line per compatible cohort. A criterion listed with more than one cohort
+ * changed between drills (rubric, evaluator model, threshold, descriptor or world
+ * revision); each cohort is labelled and kept apart.
+ */
+function qualityLines(quality, campaignId) {
+    if (quality.state !== 'read')
+        return [`Quality by criterion: unavailable (${quality.code})`];
+    const { results, count } = quality.cohorts;
+    if (!count)
+        return ['Quality by criterion: no evaluated drills yet.'];
+    const perCriterion = new Map();
+    for (const one of results)
+        perCriterion.set(one.criterion_id, (perCriterion.get(one.criterion_id) ?? 0) + 1);
+    const split = results.some(one => (perCriterion.get(one.criterion_id) ?? 0) > 1);
+    const shownTo = ((quality.cohorts.page ?? 1) - 1) * 25 + results.length;
+    return [
+        'Quality by criterion across drills (each compatible cohort on its own):',
+        ...results.map(one => {
+            const scored = one.assessed && one.average_quality !== null
+                ? `average ${points(one.average_quality)} (lowest ${points(one.minimum_quality)}, highest ${points(one.maximum_quality)}) over ${one.assessed} scored drills; threshold ${points(one.threshold)}: ${one.threshold_met} met, ${one.below_threshold} below threshold`
+                : `no score yet; threshold ${points(one.threshold)}`;
+            const missing = one.not_assessable ? `; ${one.not_assessable} not assessable (missing evidence, no score)` : '';
+            const cohort = (perCriterion.get(one.criterion_id) ?? 0) > 1 ? `  cohort ${one.cohort_digest.slice(0, COHORT_LABEL)}` : '';
+            return `  ${one.criterion_name}  ${scored}${missing}${cohort}`;
+        }),
+        split ? 'A criterion listed more than once changed between drills; its cohorts are not comparable and are never combined.' : null,
+        count > shownTo ? `${count - shownTo} more cohorts: firedrill report ${campaignId} quality --page ${(quality.cohorts.page ?? 1) + 1}` : null,
+    ].filter((line) => line !== null);
+}
+/**
+ * A drill's evaluation report, or why it cannot be shown: root's 409 means the
+ * results or their evidence are no longer retained, and its 404 means this one
+ * drill stopped being readable here (for example its world was deleted while
+ * the report was read). Neither affects other drills.
+ */
+async function evaluationOf(scope, assignmentId, signal) {
+    try {
+        return { state: 'read', report: await getNativeEvaluationReport(scope, { assignmentId, signal }) };
+    }
+    catch (error) {
+        if (isUnavailable(error))
+            return RESULTS_UNAVAILABLE;
+        if (error instanceof CliError && error.httpStatus === 404)
+            return { state: 'unavailable', code: error.code };
+        throw error;
+    }
+}
+/** The evaluation report and one page of criterion results (none before the evaluation basis is prepared). */
+async function readResults(scope, assignmentId, page, signal) {
+    const evaluation = await evaluationOf(scope, assignmentId, signal);
+    if (evaluation.state !== 'read' || !evaluation.report.criteria_total) {
+        if (page !== undefined && page > 1)
+            throw new CliError('native_page_invalid', 'This drill has no further criteria pages.', 2);
+        return { evaluation, criteria: null };
+    }
+    try {
+        return { evaluation, criteria: await listNativeEvaluationCriteria(scope, { assignmentId, page, signal }) };
+    }
+    catch (error) {
+        if (isUnavailable(error))
+            return { evaluation: RESULTS_UNAVAILABLE, criteria: null };
+        // The report answered for this drill, so a missing page is out of range.
+        if (error instanceof CliError && error.httpStatus === 404 && page !== undefined && page > 1) {
+            throw new CliError('native_page_invalid', `There is no criteria page ${page} for this drill.`, 2);
+        }
+        throw error;
+    }
+}
+/** Evaluation reports for drills that ran, in slot order, bounded; the rest are counted. */
+async function campaignResults(scope, view, signal) {
+    const evaluations = {};
+    let unread = 0;
+    let read = 0;
+    for (const slot of view.slots) {
+        const assignmentId = slot.assignment_id;
+        if (assignmentId === null || !RAN.has(view.executions[assignmentId] ?? ''))
+            continue;
+        if (read >= MAX_RESULT_READS) {
+            unread++;
+            continue;
+        }
+        read++;
+        evaluations[assignmentId] = await evaluationOf(scope, assignmentId, signal);
+    }
+    return { evaluations, unread };
+}
+function tally(values) {
+    const counts = new Map();
+    for (const value of values)
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    return [...counts].map(([name, value]) => `${value} ${name}`).join(', ') || 'none';
+}
+function gapText(gap) {
+    return gap.code === RESULTS_UNAVAILABLE.code
+        ? `unavailable: the results or their retained evidence are no longer available (${gap.code})`
+        : `unavailable: this drill can no longer be read in this workspace (${gap.code})`;
+}
+/** Non-zero criterion counts, e.g. "3 met, 1 below threshold, 1 not assessable". */
+function counts(report) {
+    return [[report.criteria_met, 'met'], [report.below_threshold, 'below threshold'], [report.not_assessable, 'not assessable'],
+        [report.errors, 'could not be evaluated'], [report.pending, 'pending']]
+        .filter(([value]) => value).map(([value, name]) => `${value} ${name}`).join(', ');
+}
+function summary(report) {
+    const total = report.criteria_total ?? 0;
+    if (report.criteria_total === null && report.status === 'needs_attention') {
+        return 'needs attention: not evaluated, because the drill ended through cleanup without a normal close (its evidence is incomplete)';
+    }
+    switch (report.status) {
+        case 'pending': return 'not started yet';
+        case 'preparing': return 'preparing the evaluation';
+        case 'evaluating': return `evaluating ${total} criteria: ${counts(report)}`;
+        case 'complete': return total ? `complete: ${report.criteria_met} of ${total} criteria met` : 'complete: this drill has no criteria';
+        case 'needs_attention': return `needs attention (${total} criteria): ${counts(report)}`;
+    }
+}
+/** Short per-drill label for campaign lists. */
+function resultLabel(view) {
+    if (view === undefined)
+        return '';
+    if (view.state !== 'read')
+        return '  results unavailable';
+    const { report } = view;
+    const total = report.criteria_total ?? 0;
+    switch (report.status) {
+        case 'pending': return '  results not started';
+        case 'preparing': return '  results preparing';
+        case 'evaluating': return `  evaluating ${total - report.pending}/${total}`;
+        case 'complete': return `  complete ${report.criteria_met}/${total} met`;
+        case 'needs_attention': return report.criteria_total === null ? '  needs attention (not evaluated)'
+            : `  needs attention ${report.criteria_met}/${total} met${report.execution_coverage === 'partial' ? ', partial coverage' : ''}`;
+    }
+}
+/** Exact checks summarized: they are declared facts over retained evidence, separate from the rubric score. */
+function exactSummary(value, declared) {
+    if (value === true)
+        return 'exact checks passed';
+    if (value === false)
+        return 'an exact check failed';
+    return declared ? 'exact checks not all checkable (evidence incomplete)' : null;
+}
+export function criterionLine(one, withId) {
+    const outcome = one.status === 'assessed' && one.quality_score !== null
+        ? `${one.threshold_met ? 'met' : 'below threshold'}: ${points(one.quality_score)} (threshold ${points(one.threshold)})`
+        : `${CRITERION_TEXT[one.status]} (threshold ${points(one.threshold)})`;
+    const exact = exactSummary(one.exact_check, one.exact_checks.length > 0);
+    return `  ${one.dimension ? `[${one.dimension.replace(/_/g, ' ')}] ` : ''}${one.name}  ${outcome}${exact ? `; ${exact}` : ''}`
+        + `${withId ? `  criterion ${one.criterion_id}` : ''}`;
+}
+const COMPARISON_TEXT = { eq: 'exactly', gte: 'at least', lte: 'at most' };
+/** Detail lines for one criterion's v2 parts: exact checks, memory probes, style and company policies. */
+function criterionDetail(one) {
+    const lines = [];
+    if (one.dimension)
+        lines.push(`Dimension: ${one.dimension.replace(/_/g, ' ')}`);
+    for (const check of one.exact_checks) {
+        const subject = check.service && check.operation ? `${terminalText(check.service)}.${terminalText(check.operation)}` : terminalText(check.source);
+        lines.push(`Exact check ${terminalText(check.key)}: ${subject} expected ${COMPARISON_TEXT[check.comparison]} ${check.expected}, `
+            + (check.observed === null ? `not checkable (${terminalText(check.reason ?? 'evidence incomplete')})`
+                : `observed ${check.observed}: ${check.passed ? 'passed' : 'failed'}`));
+    }
+    const probes = Array.isArray(one.memory?.probes) ? one.memory.probes : null;
+    if (probes) {
+        const available = probes.filter((probe) => probe?.coverage === 'available').length;
+        lines.push(`Memory probes: ${available} of ${probes.length} had the turns they need; the score says how the target recalled them (observed behavior, not proof).`);
+    }
+    if (one.style) {
+        const count = one.style.observed_count;
+        lines.push(`Style (em dashes in the target's prose): ${typeof count === 'number' ? `${count} observed` : 'not observable'}`
+            + `${typeof one.style.status === 'string' ? ` (${terminalText(one.style.status)})` : ''}.`);
+    }
+    for (const policy of one.company_policies) {
+        lines.push(`Company policy read by the evaluator only: ${terminalText(policy.name)} v${policy.version} (${policy.paragraphs.length} paragraph(s))`);
+    }
+    // One exact baseline record and one closing record per selection (not per-call differences).
+    for (const record of one.state_records) {
+        const { dependency, collection_key: collection, before_position: before, after_position: after } = record.selection;
+        lines.push(`State records ${terminalText(dependency)} collection ${collection.slice(0, 12)}, baseline position ${before}, closing position ${after}: `
+            + (record.coverage === 'available'
+                ? `read (baseline checkpoint ${record.before_checkpoint_id ?? 'none'}, closing checkpoint ${record.after_checkpoint_id ?? 'none'})`
+                : `not assessable (${terminalText(record.reason ?? 'state unavailable')})`));
+    }
+    return lines;
+}
+/** Results summary and evidence coverage lines for a drill. */
+function resultsHead(evaluation) {
+    if (evaluation.state !== 'read')
+        return [`Results: ${gapText(evaluation)}`];
+    const coverage = Object.entries(evaluation.report.coverage);
+    const covered = coverageLine(evaluation.report);
+    const exact = evaluation.report.exact_check === null ? null
+        : `Exact checks: ${evaluation.report.exact_check ? 'every declared check passed' : 'at least one declared check failed'} (separate from the criterion scores)`;
+    return [
+        `Results: ${summary(evaluation.report)}`,
+        ...covered ? [covered] : [],
+        ...exact ? [exact] : [],
+        ...coverage.length ? [`Evidence for evaluation: ${coverage.map(([kind, value]) => `${kind.replace(/_/g, ' ')} ${COVERAGE_TEXT[value]}`).join(', ')}`] : [],
+    ];
+}
+function snapshotText(view, results) {
+    const { campaign } = view;
+    const allocated = view.slots.filter(slot => slot.assignment_id !== null);
+    const execution = (slot) => view.executions[slot.assignment_id] ?? 'unknown';
+    const evaluations = results ? Object.values(results.evaluations) : [];
+    const shape = campaign.scenario_count !== undefined
+        ? ` (${campaign.scenario_count} scenarios x ${campaign.repetitions} repetitions, up to ${campaign.max_parallel} in parallel, reset ${campaign.reset})` : '';
+    const progress = view.progress.state === 'read' ? view.progress.report : null;
+    return [
+        `Campaign ${campaign.campaign_id}: ${campaign.state}`,
+        ...progress ? [
+            `Drills: ${progress.allocated_drills} of ${progress.planned_drills} allocated${progress.unallocated_drills ? `, ${progress.unallocated_drills} not allocated yet` : ''}${shape}`,
+            // Root counts a drill under its execution state, or its slot state before it has one.
+            `Drill states: ${progress.execution_counts.map(row => `${row.count} ${row.state}`).join(', ') || 'none'}`,
+        ] : [
+            `Drills: ${campaign.allocated_drills} of ${campaign.planned_drills} allocated${shape}`,
+            `Slots: ${tally(view.slots.map(slot => slot.state))}`,
+            `Executions: ${tally(allocated.map(execution))}`,
+            view.progress.state === 'unavailable' ? `Campaign summary unavailable (${view.progress.code}); states above are from the drills read here.` : null,
+        ],
+        results ? `Results: ${tally(evaluations.map(one => one.state === 'read' ? one.report.status.replace('_', ' ') : 'unavailable'))}` : null,
+        ...allocated.slice(0, LISTED_DRILLS).map(slot => `  #${slot.position} rep ${slot.repetition}  ${slot.state}  drill ${slot.drill_id}  ${execution(slot)}${resultLabel(results?.evaluations[slot.assignment_id])}`),
+        allocated.length > LISTED_DRILLS ? `  (${allocated.length - LISTED_DRILLS} more drills: use --json for the full list)` : null,
+        view.slots_omitted ? `${view.slots_omitted} more slots were not read in this snapshot.` : null,
+        view.executions_unknown ? `${view.executions_unknown} execution states were not read in this snapshot; shown as unknown.` : null,
+        results?.unread ? `${results.unread} finished drills' results were not read here; open one with firedrill report ${campaign.campaign_id} drill <drill-id>.` : null,
+        ...results?.quality ?? [],
+        results ? resultsNote(campaign)
+            : `Execution state only, not results. Per-criterion results: firedrill report ${campaign.campaign_id}. ${settlementText(campaign)}`,
+    ].filter((line) => line !== null).join('\n');
+}
+/**
+ * No drill is left to run, by root's exact progress counts (the slot and
+ * execution listings read here are bounded, so they cannot say this): every
+ * allocated drill is in a terminal state, and every planned drill was allocated
+ * unless a cancellation stopped allocation. Null when root gave no counts. This
+ * is not settlement: root settles the campaign later, once local processes,
+ * target actions, state and funding have closed.
+ */
+function drillsFinished(view) {
+    if (view.progress.state !== 'read')
+        return null;
+    const { report } = view.progress;
+    const { state } = view.campaign;
+    return (report.unallocated_drills === 0 || CANCELLING.has(state) || state === 'cancelled')
+        && report.execution_counts.every(row => TERMINAL.has(row.state));
+}
+/**
+ * `watch <campaign> [--follow]` for a native campaign. Returns false when the
+ * id is not a native campaign here, so the caller uses the hosted reports.
+ * `watch_done.settled` always means root moved the campaign to its final state.
+ * Following polls about every five seconds, prints only changes, and stops when
+ * the campaign settles, after FOLLOW_LIMIT_MS (saying it has not settled yet and
+ * how to keep watching), or on Ctrl-C.
+ */
+export async function nativeWatch(campaignId, options, emit) {
+    if (!isId(campaignId))
+        return false;
+    const scope = await scopeOf(options);
+    const first = await nativeCampaign(scope, campaignId, options.signal);
+    if (!first)
+        return false;
+    const read = (operation) => options.follow
+        ? retryTransient(operation, { signal: options.signal, attempts: 4 }) : operation();
+    const deadline = Date.now() + FOLLOW_LIMIT_MS;
+    let campaign = first;
+    let previous = '';
+    for (;;) {
+        const view = await read(() => snapshot(scope, campaign, options.signal));
+        const text = snapshotText(view);
+        // Watching reads execution state only; per-criterion results come from the report.
+        if (text !== previous)
+            emit('watch_snapshot', { ...view, results: { state: 'not_read', next_command: `firedrill report ${campaign.campaign_id} --json` },
+                settlement: settlementOf(view.campaign) }, text);
+        previous = text;
+        const id = campaign.campaign_id;
+        const settled = CAMPAIGN_SETTLED.has(view.campaign.state);
+        const finished = drillsFinished(view);
+        const done = { campaign_id: id, campaign_state: view.campaign.state, settled, drills_finished: finished };
+        const ended = `The campaign has settled: it ended ${view.campaign.state}. Results: firedrill report ${id}`;
+        if (!options.follow) {
+            emit('watch_done', { ...done, follow: false }, settled ? `Snapshot. ${ended}`
+                : 'Snapshot. Add --follow to keep watching until the campaign settles.');
+            return true;
+        }
+        if (settled) {
+            emit('watch_done', { ...done, follow: true }, ended);
+            return true;
+        }
+        if (Date.now() >= deadline) {
+            const next = `firedrill watch ${id} --follow`;
+            emit('watch_done', { ...done, follow: true, reason: 'follow_limit', next_command: next }, [
+                `Stopped watching after ${FOLLOW_LIMIT_MS / 60_000} minutes; the campaign has not settled yet (state ${view.campaign.state}). Nothing was changed.`,
+                finished ? 'Every drill has finished; Firedrill is still closing the campaign and settling its funding, so do not report charges as final.' : null,
+                `Keep watching: ${next}`,
+            ].filter((line) => line !== null).join('\n'));
+            return true;
+        }
+        if (!await sleep(jitteredInterval(FOLLOW_MS), options.signal))
+            return true;
+        campaign = await read(() => getNativeCampaign(scope, { campaignId: campaign.campaign_id, signal: options.signal }));
+    }
+}
+/** Find a drill's slot by drill id (bounded scan of the campaign's slots). */
+export async function drillSlot(scope, campaignId, drillId, signal) {
+    if (!isId(drillId))
+        throw new CliError('arguments_invalid', 'Use the drill id exactly as firedrill report <campaign> printed it.', 2);
+    const wanted = drillId.toLowerCase();
+    for (let page = 1; page <= MAX_SLOT_PAGES; page++) {
+        const result = await listNativeCampaignSlots(scope, { campaignId, page, signal });
+        const slot = result.results.find(one => one.drill_id?.toLowerCase() === wanted);
+        if (slot && slot.assignment_id !== null)
+            return slot;
+        if (!result.next)
+            break;
+    }
+    throw new CliError('native_drill_not_found', 'That drill is not an allocated drill of this campaign. Find drill ids with firedrill report <campaign>.', 2);
+}
+/** Whether these arguments name a native report shape (before any request is made). */
+export function nativeReportShape(args) {
+    const [campaignId, section, drillId, detail] = args;
+    if (!isId(campaignId))
+        return false;
+    if (args.length === 1)
+        return true;
+    if (section === 'quality')
+        return args.length === 2;
+    return section === 'drill' && (args.length <= 3 || (drillId !== undefined
+        && (((detail === 'evidence' || detail === 'results' || detail === 'conversation' || detail === 'events' || detail === 'actions') && args.length <= 5)
+            || (detail === 'effects' && args.length === 4))));
+}
+const SCENARIO_TIME_NOTE = 'Active time is the real schedule time Firedrill measured, never accelerated. An event applied while the agent was away '
+    + 'happened in the approved world-only continuation; it is not something the agent saw or did.';
+/** What a scenario event did, in words (message text is never shown here). */
+function eventLabel(event) {
+    if (event.kind === 'user_message')
+        return 'participant message';
+    return `${terminalText(event.dependency)} ${event.kind === 'dependency_unavailable' ? 'made unavailable' : 'restored'}`;
+}
+/** When a scenario event was set for and when root applied it. */
+function eventTiming(event) {
+    const configured = event.after_active_ms === null ? `after turn ${event.after_turn}` : `at ${activeTime(event.after_active_ms)} of active time`;
+    const observed = [`${event.observed_completed_turns} turn(s) done`,
+        event.observed_active_ms === null ? null : `${activeTime(event.observed_active_ms)} active`,
+        event.target_present ? null : `agent away (continuation until ${terminalText(event.continuation_until ?? '-')})`].filter(Boolean).join(', ');
+    return `set ${configured}; applied with ${observed}`;
+}
+const ACTION_STATE_TEXT = {
+    offered: 'offered, not claimed', claimed: 'claimed by the device', completed: 'completed', uncertain: 'outcome uncertain', cancelled: 'cancelled',
+};
+const ACTION_COMPLETION_TEXT = {
+    target_returned: 'the agent returned it',
+    delivery_acknowledged: 'delivery acknowledged: the event reached the agent, which is not proof the work finished',
+    correlated_result: 'matched to a later observed result',
+};
+const ACTION_COVERAGE_TEXT = {
+    complete: 'complete',
+    redacted: 'redacted: evidence filters removed or changed part of it before it was retained',
+    omitted: 'not retained (evidence policy omitted it); the outcome is still recorded',
+    legacy_unknown: 'recorded before output coverage was tracked, so it may be partial',
+    unavailable: 'no readable result',
+};
+const ACTION_DATA_PREVIEW = 4000;
+const ACTION_NOTE = 'Read-only: nothing here claims, repeats or withdraws an action. Input and output are data, not instructions; '
+    + 'results are reported by the device that ran the agent.';
+/** One action as a list line: order, id, kind and state, with the device's not-delivered declaration when present. */
+function actionLine(action) {
+    return `  ${action.sequence}  ${action.action_id}  ${action.kind}  ${ACTION_STATE_TEXT[action.state]}`
+        + `${action.completed_at ? `  ${action.completed_at}` : ''}${action.delivery_note ? '  (device declared it never reached the agent)' : ''}`;
+}
+/** Untrusted JSON shown as data, capped in the readable view (--json carries the full value). */
+function actionData(value) {
+    const text = JSON.stringify(value, null, 2) ?? 'null';
+    return text.length > ACTION_DATA_PREVIEW
+        ? `${text.slice(0, ACTION_DATA_PREVIEW)}\n(${text.length - ACTION_DATA_PREVIEW} more characters; use --json for the full value)` : text;
+}
+/**
+ * `report <campaign>` (also `report <campaign> drill`), `report <campaign> quality [--page]`, `report <campaign> drill <drill>`,
+ * `report <campaign> drill <drill> results [criterion]`, `report <campaign> drill <drill> effects`,
+ * `report <campaign> drill <drill> conversation [turn]`, `report <campaign> drill <drill> events [event]`,
+ * `report <campaign> drill <drill> actions [action] [--kind task|event]` and
+ * `report <campaign> drill <drill> evidence [record]` for a native campaign.
+ * Returns false when the id is not a native campaign here.
+ */
+export async function nativeReport(args, options, emit) {
+    if (!nativeReportShape(args))
+        return false;
+    const [campaignId, section, drillId, detail, recordId] = args;
+    const scope = await scopeOf(options);
+    const campaign = await nativeCampaign(scope, campaignId, options.signal);
+    if (!campaign)
+        return false;
+    const page = pageNumber(options.page);
+    if (section === 'quality') {
+        if (options.kind !== undefined)
+            throw new CliError('arguments_invalid', 'Use --page alone with firedrill report <campaign> quality.', 2);
+        const quality = await qualityOf(scope, campaign.campaign_id, page, options.signal);
+        emit('native_campaign_quality', { campaign_id: campaign.campaign_id, quality, settlement: settlementOf(campaign) }, [...qualityLines(quality, campaign.campaign_id), resultsNote(campaign)].join('\n'));
+        return true;
+    }
+    if (drillId === undefined) {
+        if (options.kind !== undefined || page !== undefined) {
+            throw new CliError('arguments_invalid', 'Use --page and --kind with firedrill report <campaign> drill <drill>, or --page with firedrill report <campaign> quality.', 2);
+        }
+        const view = await snapshot(scope, campaign, options.signal);
+        const results = await campaignResults(scope, view, options.signal);
+        const quality = await qualityOf(scope, campaign.campaign_id, undefined, options.signal);
+        emit('native_campaign_report', { ...view, evaluations: results.evaluations, evaluations_unread: results.unread, quality, settlement: settlementOf(view.campaign) }, `${snapshotText(view, { ...results, quality: qualityLines(quality, campaign.campaign_id) })}\nDrill detail: firedrill report ${campaign.campaign_id} drill <drill-id>`);
+        return true;
+    }
+    const slot = await drillSlot(scope, campaign.campaign_id, drillId, options.signal);
+    const assignmentId = slot.assignment_id;
+    const drillCommand = `firedrill report ${campaign.campaign_id} drill ${slot.drill_id}`;
+    if (detail === undefined) {
+        const execution = await getNativeExecution(scope, { assignmentId, signal: options.signal });
+        const observations = await listNativeObservations(scope, { assignmentId, page, kind: options.kind, signal: options.signal });
+        // --page and --kind page the observations here; the overview shows the first criteria page.
+        const results = await readResults(scope, assignmentId, undefined, options.signal);
+        const criteria = results.criteria?.results ?? [];
+        const shown = observations.page ?? page ?? 1;
+        emit('native_drill_report', { slot, execution, observations, ...results, settlement: settlementOf(campaign) }, [
+            `Drill ${slot.drill_id} (slot #${slot.position}, repetition ${slot.repetition}): ${execution.state}`,
+            `Accepted: ${execution.accepted_at ?? '-'}  Ended: ${execution.terminal_at ?? '-'}`,
+            `Retained: ${execution.retained_observation_count ?? 0} observations, ${execution.retained_artifact_count ?? 0} evidence records`,
+            ...resultsHead(results.evaluation),
+            ...criteria.slice(0, PREVIEW_CRITERIA).map(one => criterionLine(one, false)),
+            results.criteria && results.criteria.count > PREVIEW_CRITERIA ? `  (${results.criteria.count - PREVIEW_CRITERIA} more criteria)` : null,
+            criteria.length ? `All criteria with ids: ${drillCommand} results` : null,
+            `Observations${options.kind ? ` (${options.kind})` : ''}, page ${shown} (${observations.count} in all):`,
+            ...observations.results.map(one => `  ${one.sequence}  +${one.elapsed_ms}ms  ${one.kind}  record ${one.artifact_id}`),
+            observations.results.length ? null : '  none',
+            observations.next ? `More: --page ${shown + 1}` : null,
+            `Conversation: ${drillCommand} conversation [turn-id]`,
+            `Tool calls: ${drillCommand} effects`,
+            `Scenario events: ${drillCommand} events [event-id]`,
+            `Target tasks and events: ${drillCommand} actions [action-id]`,
+            `Evidence: ${drillCommand} evidence [record-id]`,
+            resultsNote(campaign),
+        ].filter((line) => line !== null).join('\n'));
+        return true;
+    }
+    if (options.kind !== undefined && !(detail === 'actions' && recordId === undefined)) {
+        throw new CliError('arguments_invalid', 'Use --kind with firedrill report <campaign> drill <drill> or its actions list.', 2);
+    }
+    if (detail === 'results') {
+        if (recordId === undefined) {
+            const results = await readResults(scope, assignmentId, page, options.signal);
+            const shown = results.criteria?.page ?? page ?? 1;
+            emit('native_drill_results', { slot, ...results, settlement: settlementOf(campaign) }, [
+                `Drill ${slot.drill_id} (slot #${slot.position}, repetition ${slot.repetition})`,
+                ...resultsHead(results.evaluation),
+                ...results.criteria ? [
+                    `Criteria, page ${shown} (${results.criteria.count} in all):`,
+                    ...results.criteria.results.map(one => criterionLine(one, true)),
+                    results.criteria.next ? `More: --page ${shown + 1}` : null,
+                    results.criteria.results.length ? `One criterion: ${drillCommand} results <criterion-id>` : null,
+                ] : [],
+                resultsNote(campaign),
+            ].filter((line) => line !== null).join('\n'));
+            return true;
+        }
+        if (page !== undefined)
+            throw new CliError('arguments_invalid', 'Use --page with the criteria list, not one criterion.', 2);
+        // Reading the report first separates an unavailable or not yet prepared evaluation from an unknown criterion id:
+        // before the evaluation is prepared root holds no criteria, so every criterion read would be a 404.
+        const evaluation = await evaluationOf(scope, assignmentId, options.signal);
+        let criterion = null;
+        let view = evaluation;
+        if (evaluation.state === 'read' && evaluation.report.criteria_total) {
+            try {
+                criterion = await getNativeEvaluationCriterion(scope, { assignmentId, criterionId: recordId, signal: options.signal });
+            }
+            catch (error) {
+                if (isUnavailable(error))
+                    view = RESULTS_UNAVAILABLE;
+                else if (error instanceof CliError && error.httpStatus === 404) {
+                    throw new CliError('native_criterion_not_found', `That criterion is not part of this drill's evaluation. List them with ${drillCommand} results.`, 2);
+                }
+                else
+                    throw error;
+            }
+        }
+        emit('native_criterion_result', { slot, evaluation: view, criterion, settlement: settlementOf(campaign) }, criterion === null
+            ? resultsHead(view).join('\n')
+            : [
+                `Criterion ${criterion.criterion_id} for drill ${slot.drill_id}: ${criterion.name}`,
+                criterion.status === 'assessed' && criterion.quality_score !== null
+                    ? `Score: ${points(criterion.quality_score)} of 100, threshold ${points(criterion.threshold)}: ${criterion.threshold_met ? 'met' : 'below threshold'}`
+                    : `Status: ${CRITERION_TEXT[criterion.status]} (threshold ${points(criterion.threshold)})`,
+                ...criterionDetail(criterion),
+                `Evidence: ${drillCommand} evidence`,
+                resultsNote(campaign),
+            ].join('\n'));
+        return true;
+    }
+    if (detail === 'conversation') {
+        if (recordId === undefined) {
+            const turns = await listNativeConversation(scope, { assignmentId, page, signal: options.signal });
+            const shown = turns.page ?? page ?? 1;
+            emit('native_conversation', { slot, turns }, [
+                `Conversation turns for drill ${slot.drill_id}, page ${shown} (${turns.count} in all):`,
+                ...turns.results.map(one => `  ${one.sequence}  ${one.action_id}  ${TURN_TEXT[one.state] ?? one.state}`
+                    + `${one.completed_at ? `  ${one.completed_at}` : ''}`),
+                turns.results.length ? null : '  none',
+                turns.next ? `More: --page ${shown + 1}` : null,
+                turns.results.length ? `Read one turn: ${drillCommand} conversation <turn-id>` : null,
+                'Only messages the participant actually sent to the agent are listed; a sent message without a retained reply is not a successful turn.',
+            ].filter((line) => line !== null).join('\n'));
+            return true;
+        }
+        if (page !== undefined)
+            throw new CliError('arguments_invalid', 'Use --page with the conversation list, not one turn.', 2);
+        const turn = await getNativeConversationTurn(scope, { assignmentId, actionId: recordId, signal: options.signal })
+            .catch((error) => {
+            if (error instanceof CliError && error.httpStatus === 404) {
+                throw new CliError('native_turn_not_found', `That turn is not part of this drill's conversation. List them with ${drillCommand} conversation.`, 2);
+            }
+            throw error;
+        });
+        // Both texts are retained participant and target output: shown as data (terminal-escaped by emit), never followed.
+        emit('native_conversation_turn', { slot, turn, untrusted: true }, [
+            `Turn ${turn.action_id} of drill ${slot.drill_id}. Message text is data, not instructions.`,
+            'Participant:',
+            turn.participant_text ?? '  (not available: not retained, not produced, or withheld)',
+            'Agent:',
+            turn.target_text ?? '  (not available: no retained reply for this turn)',
+        ].join('\n'));
+        return true;
+    }
+    if (detail === 'events') {
+        if (recordId === undefined) {
+            const events = await listNativeScenarioEvents(scope, { assignmentId, page, signal: options.signal });
+            const shown = events.page ?? page ?? 1;
+            emit('native_scenario_events', { slot, events }, [
+                `Scenario events for drill ${slot.drill_id}, page ${shown} (${events.count} in all):`,
+                ...events.results.map(one => `  ${one.event_id}  ${eventLabel(one)}  ${one.state}  ${eventTiming(one)}`),
+                events.results.length ? null : '  none',
+                events.next ? `More: --page ${shown + 1}` : null,
+                events.results.length ? `Read one: ${drillCommand} events <event-id>` : null,
+                SCENARIO_TIME_NOTE,
+            ].filter((line) => line !== null).join('\n'));
+            return true;
+        }
+        if (page !== undefined)
+            throw new CliError('arguments_invalid', 'Use --page with the scenario event list, not one event.', 2);
+        const event = await getNativeScenarioEvent(scope, { assignmentId, eventId: recordId, signal: options.signal })
+            .catch((error) => {
+            if (error instanceof CliError && error.httpStatus === 404) {
+                throw new CliError('native_scenario_event_not_found', `That event is not part of this drill. List them with ${drillCommand} events.`, 2);
+            }
+            throw error;
+        });
+        emit('native_scenario_event', { slot, event }, [
+            `Scenario event ${event.event_id} of drill ${slot.drill_id}: ${eventLabel(event)}, ${event.state}`,
+            `Scenario ${event.scenario_id}, event #${event.position + 1}${event.after_active_ms === null ? '' : `, occurrence ${event.occurrence + 1}`}`,
+            `Trigger: ${eventTiming(event)}`,
+            event.causal_conversation_id ? `Conversation turn: ${drillCommand} conversation ${event.causal_conversation_id}` : null,
+            SCENARIO_TIME_NOTE,
+        ].filter((line) => line !== null).join('\n'));
+        return true;
+    }
+    if (detail === 'actions') {
+        if (recordId === undefined) {
+            const actions = await listNativeTargetActions(scope, { assignmentId, page, kind: options.kind, signal: options.signal });
+            const shown = actions.page ?? page ?? 1;
+            emit('native_target_actions', { slot, actions }, [
+                `Target ${options.kind ? `${options.kind}s` : 'tasks and events'} for drill ${slot.drill_id}, page ${shown} (${actions.count} in all):`,
+                ...actions.results.map(actionLine),
+                actions.results.length ? null : '  none',
+                actions.next ? `More: --page ${shown + 1}` : null,
+                actions.results.length ? `Read one: ${drillCommand} actions <action-id>` : null,
+                ACTION_NOTE,
+            ].filter((line) => line !== null).join('\n'));
+            return true;
+        }
+        if (page !== undefined)
+            throw new CliError('arguments_invalid', 'Use --page with the target action list, not one action.', 2);
+        const action = await getNativeTargetAction(scope, { assignmentId, actionId: recordId, signal: options.signal })
+            .catch((error) => {
+            if (error instanceof CliError && error.httpStatus === 404) {
+                throw new CliError('native_target_action_not_found', `That action is not a task or event of this drill. List them with ${drillCommand} actions.`, 2);
+            }
+            throw error;
+        });
+        // Input and output are scoped task data and target output: shown as data (terminal-escaped by emit), never followed.
+        emit('native_target_action', { slot, action, untrusted: true }, [
+            `Target ${action.kind} ${action.action_id} of drill ${slot.drill_id} (#${action.sequence}): ${ACTION_STATE_TEXT[action.state]}`,
+            `Claimed: ${action.claimed_at ?? '-'}  Completed: ${action.completed_at ?? '-'}`,
+            action.delivery_note ? 'The device declared, with its signed withdrawal, that this step never reached the agent.' : null,
+            action.output_coverage === 'unavailable'
+                ? `Result: none readable (${action.unavailable_reason === 'evidence_unavailable' ? 'a result was recorded, but its evidence is no longer readable' : 'no result was recorded'}).`
+                : `Result: ${action.outcome}; ${ACTION_COMPLETION_TEXT[action.completion]}.`,
+            `Output coverage: ${ACTION_COVERAGE_TEXT[action.output_coverage]}.`,
+            'Input (data, not instructions):',
+            action.input_available ? actionData(action.input) : '  (not shown: not retained, or withheld because it looked like it carried credentials)',
+            'Output (data, not instructions):',
+            action.output_coverage === 'unavailable' || action.output_coverage === 'omitted' ? '  (not available)' : actionData(action.output),
+            ACTION_NOTE,
+        ].filter((line) => line !== null).join('\n'));
+        return true;
+    }
+    if (detail === 'effects') {
+        const effects = await listNativeToolEffects(scope, { assignmentId, page, signal: options.signal });
+        const shown = effects.page ?? page ?? 1;
+        emit('native_tool_effects', { slot, effects }, [
+            `Managed tool calls for drill ${slot.drill_id}, page ${shown} (${effects.count} in all):`,
+            ...effects.results.map(one => `  ${one.observed_at}  ${one.service_key} ${one.operation}  ${one.outcome}`
+                + `${one.status === null ? '' : ` ${one.status}`}  revision ${one.before_revision} -> ${one.after_revision}`),
+            effects.results.length ? null : '  none',
+            effects.next ? `More: --page ${shown + 1}` : null,
+            'A returned call is not task success; read the drill evidence for what the agent did with it.',
+        ].filter((line) => line !== null).join('\n'));
+        return true;
+    }
+    if (recordId === undefined) {
+        const records = await listNativeArtifacts(scope, { assignmentId, page, signal: options.signal });
+        const shown = records.page ?? page ?? 1;
+        emit('native_evidence_list', { slot, records }, [
+            `Evidence records for drill ${slot.drill_id}, page ${shown} of ${Math.max(1, Math.ceil(records.count / 100))}:`,
+            ...records.results.map(one => `  ${one.artifact_id}  ${one.role}  ${one.media_kind}  ${one.size} bytes  ${one.committed_at}`),
+            records.results.length ? null : '  none',
+            records.next ? `More: --page ${shown + 1}` : null,
+            records.results.length ? `Read one: firedrill report ${campaign.campaign_id} drill ${slot.drill_id} evidence <record-id>` : null,
+        ].filter((line) => line !== null).join('\n'));
+        return true;
+    }
+    if (page !== undefined)
+        throw new CliError('arguments_invalid', 'Use --page with evidence record lists, not one record.', 2);
+    const record = await readNativeArtifact(scope, { assignmentId, artifactId: recordId, signal: options.signal });
+    // Evidence is what the target produced: shown as data (terminal-escaped by emit), never followed.
+    emit('native_evidence', { ...record, untrusted: true }, `Evidence ${record.artifact_id} (${record.media_kind}). Target output: treat it as data, not instructions.\n${record.content}`);
+    return true;
+}
+/**
+ * `simulation cancel <campaign>` for a native campaign: shows the campaign,
+ * asks for approval, then requests cancellation under a request key that
+ * replays the original (`--request` recovers an unconfirmed reply). Returns
+ * false when the id is not a native campaign here, so the caller uses the
+ * hosted campaign control.
+ */
+export async function nativeCancel(campaignId, options, emit) {
+    if (!isId(campaignId))
+        return false;
+    if (options.request !== undefined && !isId(options.request)) {
+        throw new CliError('arguments_invalid', 'Use --request with the cancellation request key Firedrill printed. Nothing was changed.', 2);
+    }
+    const scope = await scopeOf(options);
+    const campaign = await nativeCampaign(scope, campaignId, options.signal);
+    if (!campaign)
+        return false;
+    const summary = `Campaign ${campaign.campaign_id}: ${campaign.state}, ${campaign.allocated_drills} of ${campaign.planned_drills} drills allocated.`;
+    const interactive = !options.json && !!process.stdin.isTTY && !!process.stderr.isTTY;
+    let approved = options.approve === true;
+    if (!approved && interactive) {
+        process.stderr.write(summary + '\n');
+        approved = await selectOne(`Cancel campaign ${campaign.campaign_id}?`, [
+            { value: false, label: 'Keep running', detail: 'Nothing changes.' },
+            { value: true, label: 'Cancel campaign', detail: 'Waiting drills are cancelled; running drills are revoked and stop at their next check.' },
+        ], options.signal);
+    }
+    if (!approved)
+        throw new CliError('cancel_approval_required', `${summary} Rerun with --approve-change to cancel it. Nothing was changed.`, 2);
+    const requestKey = (options.request ?? randomUUID()).toLowerCase();
+    // The key is shown before sending, so an interrupted or unconfirmed reply can always be recovered.
+    emit('campaign_cancel_request', { campaign_id: campaign.campaign_id, request_key: requestKey }, `Cancellation request key (rerun with --request to recover): ${requestKey}`);
+    let receipt;
+    try {
+        receipt = await cancelNativeCampaign(scope, { campaignId: campaign.campaign_id, requestKey, signal: options.signal });
+    }
+    catch (error) {
+        const answered = error instanceof CliError && error.httpStatus !== null && error.httpStatus >= 400 && error.httpStatus < 500;
+        // The campaign was just read in this workspace, and root cancels a campaign only for the member who
+        // created it; anyone else gets "not found". Say that instead of claiming the campaign is gone.
+        if (answered && error.httpStatus === 404 && !options.signal.aborted) {
+            throw new CliError('native_cancel_owner_only', `Campaign ${campaign.campaign_id} can be cancelled only by the member who created it `
+                + '(or the workspace is no longer active). Ask them to run this command. Nothing was changed.', 1, 404);
+        }
+        if (answered || options.signal.aborted)
+            throw error;
+        throw new CliError('native_cancel_unconfirmed', `The cancellation reply was not confirmed. Recover it with firedrill simulation cancel ${campaign.campaign_id} --request ${requestKey} --approve-change; the same key never sends a second request.`, 1);
+    }
+    emit('campaign_cancel', { ...receipt, state_before: campaign.state }, [
+        `Cancellation accepted for campaign ${receipt.campaign_id}.`,
+        'Waiting drills are cancelled and running drills are revoked; this does not yet confirm local cleanup or settlement.',
+        `Follow it: firedrill watch ${receipt.campaign_id} --follow`,
+    ].join('\n'));
+    return true;
+}