firedrill-run 2.2.5 → 3.0.0

package/dist/cli/src/scenario-discovery.js

@@ -0,0 +1,216 @@
+import { randomUUID } from 'node:crypto';
+import { api } from './auth.js';
+import { CliError } from './http.js';
+import { selectOne, terminalText } from './prompts.js';
+import { selectedWorld } from './world-access.js';
+import { identifier } from './world-contracts.js';
+import { requestInput } from './request-input.js';
+import { scenarioWorldEventsMatch } from '../../contracts/scenario-world-contracts.js';
+import { revisionRequestMatches, revisionRequestPath } from '../../contracts/revision-request-contracts.js';
+import { compareScenarioDrafts, scenarioDraftReviewMatches } from '../../contracts/scenario-draft-comparison.js';
+const actions = new Set(['discover', 'discoveries', 'discovery', 'cancel-discovery', 'drafts', 'draft', 'edit-draft', 'accept-draft', 'coverage', 'world-events', 'revise-execution', 'draft-request', 'execution-request']);
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const invalid = () => new CliError('scenario_response_unconfirmed', 'The scenario response could not be confirmed. Inspect the original request; nothing was repeated.');
+const positive = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+export const isScenarioDiscoveryAction = (action) => !!action && actions.has(action);
+async function draftComparison(scope, row, options) {
+    if (!scenarioDraftReviewMatches(row))
+        throw invalid();
+    if (!row.parent_id)
+        return null;
+    const parent = await api(`${scope.prefix}/scenario-drafts/${row.parent_id}`, {
+        actor: scope.owner, workspace: scope.workspace, signal: options.signal
+    });
+    const result = compareScenarioDrafts(parent, row);
+    if (!result)
+        throw new CliError('scenario_draft_comparison_unavailable', 'The immediate previous draft does not match this saved revision. No comparison or approval was inferred. Reopen both exact drafts before continuing.', 2);
+    return result;
+}
+function comparisonText(row, scope) {
+    const text = (value) => {
+        const visible = value.text.slice(0, 600);
+        return visible.split('\n').map(terminalText).join('\n')
+            + (value.truncated || value.text.length > visible.length ? `\nShowing ${visible.length} of ${value.characters} characters. Inspect the full saved draft for the rest.` : '');
+    };
+    return `Changes from previous draft ${row.parent_id}\n${row.differences.length} changed fields.\n`
+        + (row.differences.length ? row.differences.map(one => `${terminalText(one.label)}\nBefore: ${text(one.before)}\nAfter: ${text(one.after)}`).join('\n\n') : 'No authored scenario fields changed.')
+        + `\nPrevious: firedrill scenarios draft ${row.parent_id} --world ${scope.world} --workspace ${scope.workspace}`
+        + `\nCurrent: firedrill scenarios draft ${row.draft_id} --world ${scope.world} --workspace ${scope.workspace}`;
+}
+async function confirm(message, options) {
+    if (options.approve)
+        return true;
+    if (options.json || !process.stdin.isTTY || !process.stderr.isTTY)
+        throw new CliError('approval_required', 'Review this exact change, then use --approve-change. No target is run by this action.', 2);
+    return selectOne(message, [{ value: false, label: 'Not now' }, { value: true, label: 'Apply this change' }], options.signal);
+}
+export async function scenarioDiscoveryCommand(args, options, output, selected) {
+    const action = args[0];
+    const directory = ['drafts', 'discoveries', 'coverage', 'world-events'].includes(action);
+    if (!isScenarioDiscoveryAction(action) || args.length > (action === 'discover' ? 100 : directory && action !== 'world-events' ? 1 : 2)
+        || (options.page !== undefined || options.search !== undefined) && !directory
+        || options.request !== undefined && !['discover', 'discoveries', 'edit-draft', 'revise-execution', 'draft-request', 'execution-request'].includes(action)
+        || options.file !== undefined && !['discover', 'edit-draft', 'revise-execution'].includes(action)
+        || options.file !== undefined && action === 'discover' && args.length > 1
+        || options.kind !== undefined && (action !== 'world-events' || !['record', 'operation', 'ingress', 'message'].includes(options.kind))
+        || options.approve && !['discover', 'edit-draft', 'accept-draft', 'cancel-discovery', 'revise-execution'].includes(action))
+        throw new CliError('arguments_invalid', 'Use scenarios discover [optional focus], drafts, draft <id>, edit-draft <id>, accept-draft <id>, coverage, world-events <scenario>, discoveries, discovery <id>, cancel-discovery <id>, revise-execution <id>, draft-request <parent> or execution-request <parent> --request-key <original UUID>.', 2);
+    const scope = selected ?? await selectedWorld({ ...options, interactive: !options.json && !!process.stdin.isTTY && !!process.stderr.isTTY });
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    const page = options.page ?? '1';
+    if (!/^[1-9][0-9]{0,8}$/.test(page) || (options.search ?? '').length > 200)
+        throw new CliError('arguments_invalid', 'Choose a positive page and a short search.', 2);
+    const params = new URLSearchParams({ page, q: options.search ?? '' });
+    if (action === 'draft-request' || action === 'execution-request') {
+        if (!options.request)
+            throw new CliError('request_key_required', 'Use --request-key <original UUID> with the original parent revision. This only reads its receipt.', 2);
+        const key = identifier(options.request);
+        const revisionScope = { actor: scope.owner, workspace: scope.workspace, world: scope.world,
+            parent: identifier(args[1]), kind: action === 'draft-request' ? 'scenario_draft' : 'execution_proposal' };
+        const row = await api(scope.prefix + revisionRequestPath(revisionScope, key), auth);
+        if (!revisionRequestMatches(row, revisionScope, key))
+            throw invalid();
+        output('revision_request', row, [`Original request: ${row.request_key}`,
+            row.state === 'not_received' ? 'No receipt is recorded yet. It may still arrive. Continue only with this same key and the exact original input.'
+                : row.state === 'unavailable' ? 'The original revision is recorded but is no longer readable. Do not replace it with another request.'
+                    : `Original revision: ${row.resource_id}`,
+            ...(row.resource_id ? [action === 'draft-request' ? `Inspect: firedrill scenarios draft ${row.resource_id} --world ${scope.world} --workspace ${scope.workspace}`
+                    : `Original proposal: ${row.resource_id}. New simulations use firedrill plan, apply and run.`] : [])].join('\n'));
+        return;
+    }
+    if (action === 'world-events') {
+        const id = identifier(args[1]);
+        const scenario = await api(`${scope.prefix}/scenarios/${id}`, auth);
+        if (scenario.id !== id || scenario.world_id !== scope.world || !/^[a-f0-9]{64}$/.test(scenario.definition_digest))
+            throw invalid();
+        if (scenario.world_timeline_problem)
+            throw new CliError('scenario_world_plan_invalid', 'This saved world progression needs review before the scenario can run.', 2);
+        if (!scenario.world_timeline) {
+            output('scenario_world_events', { scenario_id: id, world_timeline: null }, 'No continuous world events are declared for this scenario.');
+            return;
+        }
+        params.set('definition', scenario.definition_digest);
+        if (options.kind)
+            params.set('kind', options.kind);
+        const value = await api(`${scope.prefix}/scenarios/${id}/world-events?${params}`, auth);
+        if (!scenarioWorldEventsMatch(value, scenario.definition_digest) || value.page !== Number(page)
+            || options.kind && value.results.some(row => row.kind !== options.kind))
+            throw invalid();
+        output('scenario_world_events', value, [scenario.name, 'Saved scenario schedule, not observed execution. The agent clock is unchanged.',
+            ...value.results.map(row => `${row.id}\t${row.kind}\tafter ${row.after_ms}ms${row.repeat ? `; ${row.repeat.count} times every ${row.repeat.interval_ms}ms` : ''}\n${row.text_preview ?? row.operation ?? row.collection ?? 'Input to the configured agent event channel'}${row.text_shortened ? '…' : ''}${row.path ? '\n' + [row.method, row.path].filter(Boolean).join(' ') : ''}${row.conditional ? '\nRequires its declared condition.' : ''}${row.depends_on.length ? '\nAfter: ' + row.depends_on.join(', ') : ''}`),
+            `Page ${value.page}; ${value.count} declared event series.`, ...(value.next ? [`Next: firedrill scenarios world-events ${id} --world ${scope.world} --workspace ${scope.workspace} --page ${value.page + 1}${options.kind ? ' --kind ' + options.kind : ''}`] : [])].join('\n'));
+        return;
+    }
+    if (['drafts', 'discoveries', 'coverage'].includes(action)) {
+        const suffix = action === 'drafts' ? 'scenario-drafts' : action === 'discoveries' ? 'scenario-discovery' : 'scenario-coverage';
+        if (options.request)
+            params.set('request_key', identifier(options.request));
+        const raw = await api(`${scope.prefix}/${suffix}?${params}`, auth);
+        if (!object(raw) || !Array.isArray(raw.results) || raw.results.length > 100 || !positive(raw.count) || !positive(raw.page) || !positive(raw.page_size))
+            throw invalid();
+        const lines = raw.results.map(one => {
+            if (!object(one))
+                throw invalid();
+            if (action === 'drafts') {
+                if (!object(one.draft) || typeof one.draft.title !== 'string' || typeof one.accepted !== 'boolean')
+                    throw invalid();
+                return `${identifier(String(one.id))}  ${terminalText(one.draft.title)}${one.accepted ? ' (added)' : ''}`;
+            }
+            if (action === 'discoveries') {
+                if (typeof one.state !== 'string')
+                    throw invalid();
+                return `${identifier(String(one.id))}  ${terminalText(one.state)}  request ${identifier(String(one.request_key))}`;
+            }
+            if (typeof one.name !== 'string' || !['covered', 'unexplored'].includes(String(one.state)))
+                throw invalid();
+            return `${terminalText(one.name)}  ${one.state === 'covered' ? 'Has scenario' : 'Unexplored'}`;
+        });
+        output('scenario_' + action, raw, (lines.join('\n') || 'No matching records.') + `\nPage ${raw.page}, ${raw.count} records.`
+            + (action === 'coverage' ? '\nCoverage describes explicit scenario links, not execution success or complete behavioral coverage.' : ''));
+        return;
+    }
+    const id = action === 'discover' ? null : identifier(args[1]);
+    if (action === 'draft' || action === 'discovery') {
+        const row = await api(`${scope.prefix}/${action === 'draft' ? 'scenario-drafts' : 'scenario-discovery'}/${id}`, auth);
+        if (!object(row) || row.id !== id)
+            throw invalid();
+        output('scenario_' + action, row, JSON.stringify(row, null, 2).split('\n').map(terminalText).join('\n'));
+        if (action === 'draft') {
+            try {
+                const comparison = await draftComparison(scope, row, options);
+                if (comparison)
+                    output('scenario_draft_comparison', comparison, comparisonText(comparison, scope));
+            }
+            catch (error) {
+                if (!options.signal.aborted)
+                    output('scenario_draft_comparison_unavailable', { draft_id: id,
+                        parent_id: typeof row.parent_id === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(row.parent_id) ? row.parent_id : null,
+                        available: false }, 'The previous draft comparison is unavailable. This does not mean the definitions are unchanged; no scenario was added.');
+                throw error;
+            }
+        }
+        return;
+    }
+    if (action === 'cancel-discovery') {
+        const current = await api(`${scope.prefix}/scenario-discovery/${id}`, auth);
+        if (!object(current) || current.id !== id || typeof current.can_cancel !== 'boolean')
+            throw invalid();
+        if (!['queued', 'discovering'].includes(String(current.state))) {
+            output('scenario_discovery_finished', current, 'This discovery is already finished. Saved drafts remain available.');
+            return;
+        }
+        if (!current.can_cancel)
+            throw new CliError('scenario_discovery_access_required', 'Only the member who requested this discovery can cancel it. Saved drafts can still be inspected.', 2);
+        if (!await confirm('Cancel this discovery batch? Saved drafts remain available.', options))
+            return;
+        const row = await api(`${scope.prefix}/scenario-discovery/${id}`, { ...auth, method: 'DELETE' });
+        if (!object(row) || row.id !== id)
+            throw invalid();
+        output('scenario_discovery_canceled', row, row.state === 'canceled' ? 'Discovery canceled. Saved drafts remain available.' : 'Discovery already finished. Saved drafts remain available.');
+        return;
+    }
+    if (action === 'accept-draft') {
+        const row = await api(`${scope.prefix}/scenario-drafts/${id}`, auth);
+        if (!object(row) || row.id !== id || !object(row.draft) || typeof row.can_edit !== 'boolean')
+            throw invalid();
+        if (row.accepted === true) {
+            if (!object(row.scenario) || typeof row.scenario.id !== 'string')
+                throw new CliError('scenario_revision_unavailable', 'This draft was already accepted, but its original scenario is no longer available. No replacement was created.', 2);
+            output('scenario_already_added', row, `This draft is already linked to scenario ${identifier(row.scenario.id)}. No scenario or simulation was duplicated.`);
+            return;
+        }
+        if (!row.can_edit)
+            throw new CliError('scenario_draft_access_required', 'This draft is not editable by this account. Ask the original author or inspect its saved scenario.', 2);
+        const comparison = await draftComparison(scope, row, options);
+        output('scenario_draft_review', row, JSON.stringify(row.draft, null, 2).split('\n').map(terminalText).join('\n'));
+        if (comparison)
+            output('scenario_draft_comparison', comparison, comparisonText(comparison, scope));
+        if (!await confirm('Add this exact scenario draft? Startup validation will use the new scenario revision. No simulation starts.', options))
+            return;
+        const result = await api(`${scope.prefix}/scenario-drafts/${id}/accept`, { ...auth, method: 'POST', body: {} });
+        if (!object(result) || typeof result.id !== 'string')
+            throw invalid();
+        output('scenario_added', result, `Scenario added: ${identifier(result.id)}\nNo simulation started.`);
+        return;
+    }
+    if (['edit-draft', 'revise-execution'].includes(action) && !options.file)
+        throw new CliError('request_file_required', 'Use --file with the full reviewed draft or execution settings. Read the current draft/proposal first.', 2);
+    const raw = options.file ? await requestInput(options.file, options.signal, 512 * 1024) : JSON.stringify({ objective: args.slice(1).join(' ') });
+    const body = JSON.parse(raw);
+    if (!object(body))
+        throw new CliError('arguments_invalid', 'Use a JSON request object.', 2);
+    if (!await confirm(action === 'discover' ? 'Request a bounded batch of discovered scenarios? This does not run simulations or modify the agent.' : 'Save these settings as a new reviewable revision?', options))
+        return;
+    const key = options.request ? identifier(options.request) : randomUUID();
+    output('scenario_request', { request_key: key, world_id: scope.world, action }, `Original request: ${key}\nKeep this key if the response is interrupted. Use it with the same --request-key and input, not a replacement request.`);
+    if (action === 'edit-draft' || action === 'revise-execution')
+        output('revision_recovery', { parent_id: id, request_key: key }, `Read original receipt: firedrill scenarios ${action === 'edit-draft' ? 'draft-request' : 'execution-request'} ${id} --request-key ${key} --world ${scope.world} --workspace ${scope.workspace}`);
+    const route = action === 'discover' ? '/scenario-discovery' : action === 'edit-draft' ? `/scenario-drafts/${id}` : `/execution-proposals/${id}/revisions`;
+    const row = await api(scope.prefix + route, { ...auth, method: 'POST', bodyJson: raw, idempotencyKey: key });
+    if (!object(row) || typeof row.id !== 'string' || action === 'discover' && row.request_key !== key)
+        throw invalid();
+    identifier(row.id);
+    output('scenario_request_saved', row, action === 'discover' ? `Discovery requested: ${row.id}\nRead it with firedrill scenarios discovery ${row.id}. No target was invoked.`
+        : action === 'edit-draft' ? `Draft revision saved: ${row.id}\nInspect its previous-draft comparison before adding the scenario:\nfiredrill scenarios draft ${row.id} --world ${scope.world} --workspace ${scope.workspace}`
+            : `Execution proposal revised: ${row.id}\nReview execution access and the credit estimate again before running it.`);
+}

package/dist/cli/src/scenario-paths.js

@@ -0,0 +1,68 @@
+import { api } from './auth.js';
+import { CliError } from './http.js';
+import { selectOne, terminalText } from './prompts.js';
+import { selectedWorld } from './world-access.js';
+import { identifier } from './world-contracts.js';
+const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+export async function scenarioPaths(args, options, output) {
+    const page = options.page ?? '1', search = options.search ?? '';
+    if (args.length > 3 || !/^[1-9][0-9]{0,8}$/.test(page) || search.length > 200
+        || args.slice(1).some(value => !/^[1-9][0-9]{0,8}$/.test(value))
+        || options.definition !== undefined && !/^[a-f0-9]{64}$/.test(options.definition))
+        throw new CliError('arguments_invalid', 'Use scenarios paths [scenario-id] [path] [step], a positive page and a search of up to 200 characters. --basis-version pins the saved definition.', 2);
+    const interactive = !options.json && !!process.stdin.isTTY && !!process.stderr.isTTY;
+    const scope = await selectedWorld({ ...options, interactive });
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    let item = args[0] ? identifier(args[0]) : '';
+    let number = 1;
+    while (!item && interactive) {
+        const choices = await api(`${scope.prefix}/scenarios?page=${number}`, auth);
+        const values = choices.results.map(row => ({ value: identifier(row.id), label: row.name, detail: `Revision ${row.revision}` }));
+        if (number > 1)
+            values.unshift({ value: 'previous', label: 'Previous page', detail: '' });
+        if (choices.next)
+            values.push({ value: 'next', label: 'Next page', detail: '' });
+        if (!values.length)
+            throw new CliError('scenario_unavailable', 'No scenarios are available in this world.');
+        const chosen = await selectOne('Scenario', values, options.signal);
+        if (chosen === 'next')
+            number += 1;
+        else if (chosen === 'previous')
+            number -= 1;
+        else
+            item = identifier(chosen);
+    }
+    if (!item)
+        throw new CliError('scenario_required', 'Pass the scenario ID from firedrill scenarios. No simulation was started.', 2);
+    let definition = options.definition;
+    if (!definition) {
+        const original = await api(`${scope.prefix}/scenarios/${item}`, auth);
+        if (original.id !== item || original.world_id !== scope.world || !/^[a-f0-9]{64}$/.test(original.definition_digest))
+            throw new CliError('scenario_scope_changed', 'The original scenario could not be confirmed.');
+        definition = original.definition_digest;
+    }
+    const params = new URLSearchParams({ definition, page, q: search });
+    if (args[1])
+        params.set('path', args[1]);
+    if (args[2])
+        params.set('step', args[2]);
+    const result = await api(`${scope.prefix}/scenarios/${item}/reference-paths?${params}`, auth);
+    const expected = args[2] ? 'interfaces' : args[1] ? 'steps' : 'paths';
+    if (result.item_id !== item || result.world_id !== scope.world || result.definition_digest !== definition || result.view !== expected)
+        throw new CliError('scenario_scope_changed', 'The original reference path could not be confirmed.');
+    const lines = result.results.map(value => {
+        if ('step_count' in value)
+            return `${value.position}. ${value.kind === 'reference' ? 'Reference path' : `Alternative ${value.position - 1}`} · ${value.step_count} steps`;
+        if ('input_fields' in value)
+            return `${value.position}. ${value.tool || 'Operation not recorded'}\n${value.input_field_count} input fields: ${value.input_fields.join(', ')}${value.presentation_omitted ? '\nSome names are shortened, redacted or omitted.' : ''}`;
+        return `${value.service_name} · Revision ${value.service_revision}\n${value.protocol === 'http' && value.route ? `${value.method ?? ''} ${value.route}`.trim()
+            : value.protocol === 'mcp' ? `MCP: ${value.mcp_tool || value.operation}` : value.operation}\nService: ${value.service_id}`;
+    });
+    const follow = `firedrill scenarios paths ${item}${args[1] ? ' ' + args[1] : ''}${args[2] ? ' ' + args[2] : ''} --world ${scope.world} --workspace ${scope.workspace} --basis-version ${definition}`;
+    const readable = `${expected === 'interfaces' ? 'Exact declared operation-name matches, not recorded calls.' : 'Authored reference paths, not a required action sequence or observed execution.'}\n`
+        + (lines.join('\n\n') || (expected === 'interfaces' && !result.source_current ? 'Mappings are not shown for this previous world revision.' : 'No matching entries.'))
+        + `\nPage ${result.page}, ${result.count} entries.`
+        + (result.next ? `\nContinue: ${follow} --page ${result.page + 1}${search ? ' --search ' + quote(search) : ''}${options.json ? ' --json' : ''}` : '')
+        + (expected === 'paths' && result.count ? `\nInspect steps: ${follow} <path>` : expected === 'steps' && result.count ? `\nInspect interfaces: ${follow} <step>` : '');
+    output(result, readable.split('\n').map(terminalText).join('\n'));
+}

package/dist/cli/src/scenario-requests.js

@@ -0,0 +1,4 @@
+import { revisionRequests } from './revision-requests.js';
+export function scenarioRequests(args, options, output) {
+    return revisionRequests('scenario', args, options, output);
+}

package/dist/cli/src/service-receipts.js

@@ -0,0 +1,105 @@
+import { workspaceLink } from './browser-links.js';
+import { api } from './auth.js';
+import { CliError } from './http.js';
+import { selectOne } from './prompts.js';
+import { identifier } from './world-contracts.js';
+import { trialActions } from './trial-actions.js';
+const statusNames = { '': 'All responses', http_error: 'Response errors', unconfirmed: 'Response not confirmed' };
+const receiptNames = { admitted: 'Request recorded', dispatching: 'Dispatch started', response: 'Response received',
+    not_sent: 'Not dispatched', uncertain: 'Outcome not confirmed' };
+const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+export function validateReceiptOptions(options) {
+    if (options.page !== undefined && !/^[1-9][0-9]{0,8}$/.test(options.page)
+        || (options.search?.length ?? 0) > 200 || /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/.test(options.search ?? '')
+        || options.status !== undefined && !Object.hasOwn(statusNames, options.status)) {
+        throw new CliError('arguments_invalid', 'Use a positive page, a search up to 200 characters and --status http_error|unconfirmed for service receipts.', 2);
+    }
+}
+function responseLabel(row) {
+    const value = row.response;
+    if (!value || value.disposition === 'unknown')
+        return 'Response not confirmed';
+    if (value.rpc_error)
+        return 'MCP request error';
+    if (value.mcp_is_error)
+        return 'MCP tool error';
+    return value.http_status === null ? 'Response code not recorded' : `HTTP ${value.http_status}`;
+}
+function summary(row) {
+    return row.available === false ? `Receipt unavailable\n${row.problem.message}\n${row.id}`
+        : `${row.operation} · ${row.service.name} · Revision ${row.service.revision}\n${responseLabel(row)} · ${row.recorded_at}\n${row.id}`;
+}
+async function detail(path, scope, options, output, id, interactive) {
+    const row = await api(`${path}/${identifier(id)}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+    if (!row.available || row.id !== identifier(id))
+        throw new CliError('service_receipt_unavailable', 'This service receipt could not be read. No operation was repeated.');
+    const campaign = identifier(row.trial.campaign_id), trial = identifier(row.trial.id);
+    output(row, [summary(row), row.protocol === 'mcp' ? `MCP ${row.mcp_tool}` : `${row.method} ${row.route}`,
+        row.mode === 'real' ? 'Real-account connection. Resetting the world does not undo external changes.' : 'Simulated-service connection.',
+        row.origin === 'customer_device' ? 'Reported from the local device.' : 'Reported from the cloud sandbox.',
+        `Request: ${row.request_bytes.toLocaleString()} bytes`,
+        ...(row.response ? [`Response size: ${row.response.response_bytes === null ? 'Not recorded' : row.response.response_bytes.toLocaleString() + ' bytes'}`,
+            `Elapsed: ${row.response.elapsed_ms}ms`, `Response recorded: ${row.response.recorded_at}`] : []),
+        ...(row.mode === 'real' ? [`Cloud receipt: ${row.real_operation ? receiptNames[row.real_operation.outcome] : 'No receipt retained'}`,
+            `Operation result: ${row.real_operation?.business_outcome === 'not_dispatched' ? 'Not dispatched' : 'Not assessed here'}`] : []),
+        `Drill ${row.trial.number}: ${row.trial.scenario_name}`,
+        `World revision ${row.trial.world_revision}; configuration revision ${row.trial.configuration_revision}`,
+        row.captured_actions.supported ? `Captured action records: ${row.captured_actions.count?.toLocaleString() ?? 'Unavailable'}` : 'Payload capture is not available for this connection or response.',
+        ...(row.captured_actions.count ? [`Inspect: firedrill report ${campaign} drill ${trial} actions --service-request ${row.id} --workspace ${scope.workspace}`] : []),
+        'A transport response is not an evaluation score.',
+        workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${trial}?view=requests&request=${identifier(row.id)}`)].join('\n'));
+    if (interactive && row.captured_actions.count && await selectOne('Inspect receipt evidence', [
+        { value: true, label: 'Captured actions and payloads' }, { value: false, label: 'Done' }
+    ], options.signal)) {
+        await trialActions(`/api/workspaces/${scope.workspace}/campaigns/${campaign}/trials/${trial}`, scope, true, { signal: options.signal, serviceRequest: row.id }, output);
+    }
+}
+export async function serviceReceipts(path, scope, options, interactive, output, command, supplied) {
+    validateReceiptOptions(options);
+    if (supplied) {
+        if (options.page !== undefined || options.search !== undefined || options.status !== undefined)
+            throw new CliError('arguments_invalid', 'Page, search and response filters apply to receipt lists, not a single receipt.', 2);
+        await detail(path, scope, options, output, supplied, interactive);
+        return;
+    }
+    let page = Number(options.page ?? 1);
+    while (true) {
+        const params = new URLSearchParams({ page: String(page), q: options.search ?? '', status: options.status ?? '' });
+        const data = await api(`${path}${path.includes('?') ? '&' : '?'}${params}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+        const continuation = `${command} --workspace ${scope.workspace}${options.search ? ' --search ' + quote(options.search) : ''}${options.status ? ' --status ' + options.status : ''}`;
+        output(data, [...data.results.map(summary), ...(!data.count ? ['No matching service receipts.'] : []),
+            ...(data.page_unavailable ? [`${data.page_unavailable.toLocaleString()} receipts unavailable on this page. Their outcomes are unknown.`] : []),
+            `Page ${data.page}; ${data.count.toLocaleString()} matching retained requests.`,
+            ...(data.next ? [`Continue: ${continuation} --page ${page + 1}`] : []),
+            'Reading or refreshing receipts does not repeat a tool operation.'].join('\n\n'));
+        if (!interactive)
+            return;
+        const choices = data.results.flatMap(row => row.available === false ? []
+            : [{ value: { kind: 'receipt', row }, label: `${row.operation} · ${row.service.name}`, detail: `${responseLabel(row)} · ${row.recorded_at}` }]);
+        if (page > 1)
+            choices.push({ value: { kind: 'previous' }, label: 'Previous page' });
+        if (data.next)
+            choices.push({ value: { kind: 'next' }, label: 'Next page' });
+        if (data.page_unavailable)
+            choices.push({ value: { kind: 'refresh' }, label: 'Refresh retained receipts' });
+        choices.push({ value: { kind: 'done' }, label: 'Done' });
+        const selected = await selectOne('Service receipt', choices, options.signal);
+        if (selected.kind === 'done')
+            return;
+        if (selected.kind === 'next') {
+            page += 1;
+            continue;
+        }
+        if (selected.kind === 'previous') {
+            page -= 1;
+            continue;
+        }
+        if (selected.kind === 'refresh')
+            continue;
+        if (selected.kind !== 'receipt')
+            throw new CliError('selection_invalid', 'Choose a retained service receipt.', 2);
+        const row = selected.row;
+        const trialPath = `/api/workspaces/${scope.workspace}/campaigns/${identifier(row.trial.campaign_id)}/trials/${identifier(row.trial.id)}/requests`;
+        await detail(trialPath, scope, options, output, row.id, interactive);
+    }
+}