@bbigbang/core 0.1.0

package/dist/services/missionService.js

@@ -0,0 +1,2361 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { importDroidMissionArtifacts } from './droidMissionImporter.js';
+import { generateNativeMissionReport, NATIVE_MISSION_REPORT_FILE_NAME, } from './nativeMissionReportGenerator.js';
+import { deriveMissionTrace, filterMissionTrace } from './missionTrace.js';
+import { deriveMissionEvidence, filterMissionEvidence } from './missionEvidence.js';
+const DEFAULT_DROID_MODEL = 'custom:DeepSeek-V4-Pro';
+const DEFAULT_RETRY_POLICY = { maxRetries: 0, backoff: 'fixed' };
+export class MissionServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class MissionService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    listNativeMissionsForRecovery() {
+        const rows = this.db.prepare(`
+      SELECT mission_id as missionId, owner_user_id as ownerUserId, title, description, state,
+             runtime_provider as runtimeProvider, node_id as nodeId, workspace_path as workspacePath,
+             mission_dir as missionDir, initiator_agent_id as initiatorAgentId,
+             control_conversation_id as controlConversationId, model_mode as modelMode,
+             orchestrator_model as orchestratorModel, worker_model as workerModel,
+             validator_model as validatorModel, effective_model_config_json as effectiveModelConfigJson,
+             created_at as createdAt, updated_at as updatedAt, started_at as startedAt,
+             completed_at as completedAt, last_imported_at as lastImportedAt,
+             latest_factory_session_id as latestFactorySessionId,
+             latest_factory_artifact_dir as latestFactoryArtifactDir,
+             latest_factory_seen_at as latestFactorySeenAt
+        FROM missions
+       WHERE runtime_provider = 'bigbang_native'
+         AND state IN ('queued', 'running', 'paused')
+       ORDER BY updated_at DESC
+    `).all();
+        return rows.map(mapMissionRow);
+    }
+    listMissions(input) {
+        const rows = input.isAdmin
+            ? this.db.prepare(`
+          SELECT mission_id as missionId, owner_user_id as ownerUserId, title, description, state,
+                 runtime_provider as runtimeProvider, node_id as nodeId, workspace_path as workspacePath,
+                 mission_dir as missionDir, initiator_agent_id as initiatorAgentId,
+                 control_conversation_id as controlConversationId, model_mode as modelMode,
+                 orchestrator_model as orchestratorModel, worker_model as workerModel,
+                 validator_model as validatorModel, effective_model_config_json as effectiveModelConfigJson,
+                 created_at as createdAt, updated_at as updatedAt, started_at as startedAt,
+                 completed_at as completedAt, last_imported_at as lastImportedAt,
+                 latest_factory_session_id as latestFactorySessionId,
+                 latest_factory_artifact_dir as latestFactoryArtifactDir,
+                 latest_factory_seen_at as latestFactorySeenAt
+            FROM missions
+           ORDER BY updated_at DESC
+        `).all()
+            : this.db.prepare(`
+          SELECT mission_id as missionId, owner_user_id as ownerUserId, title, description, state,
+                 runtime_provider as runtimeProvider, node_id as nodeId, workspace_path as workspacePath,
+                 mission_dir as missionDir, initiator_agent_id as initiatorAgentId,
+                 control_conversation_id as controlConversationId, model_mode as modelMode,
+                 orchestrator_model as orchestratorModel, worker_model as workerModel,
+                 validator_model as validatorModel, effective_model_config_json as effectiveModelConfigJson,
+                 created_at as createdAt, updated_at as updatedAt, started_at as startedAt,
+                 completed_at as completedAt, last_imported_at as lastImportedAt,
+                 latest_factory_session_id as latestFactorySessionId,
+                 latest_factory_artifact_dir as latestFactoryArtifactDir,
+                 latest_factory_seen_at as latestFactorySeenAt
+            FROM missions
+           WHERE owner_user_id = ?
+           ORDER BY updated_at DESC
+        `).all(input.userId);
+        return rows.map(mapMissionRow);
+    }
+    getMission(input) {
+        const row = this.db.prepare(`
+      SELECT mission_id as missionId, owner_user_id as ownerUserId, title, description, state,
+             runtime_provider as runtimeProvider, node_id as nodeId, workspace_path as workspacePath,
+             mission_dir as missionDir, initiator_agent_id as initiatorAgentId,
+             control_conversation_id as controlConversationId, model_mode as modelMode,
+             orchestrator_model as orchestratorModel, worker_model as workerModel,
+             validator_model as validatorModel, effective_model_config_json as effectiveModelConfigJson,
+             created_at as createdAt, updated_at as updatedAt, started_at as startedAt,
+             completed_at as completedAt, last_imported_at as lastImportedAt,
+             latest_factory_session_id as latestFactorySessionId,
+             latest_factory_artifact_dir as latestFactoryArtifactDir,
+             latest_factory_seen_at as latestFactorySeenAt
+        FROM missions
+       WHERE mission_id = ?
+    `).get(input.missionId);
+        if (!row)
+            return null;
+        if (!input.isAdmin && row.ownerUserId !== input.userId)
+            return null;
+        return mapMissionRow(row);
+    }
+    createMission(input) {
+        const now = Date.now();
+        const title = normalizeRequiredString(input.request.title, 'title');
+        const workspacePath = normalizeRequiredString(input.request.workspacePath, 'workspacePath');
+        const modelMode = normalizeModelMode(input.request.modelMode);
+        const model = modelMode === 'platform_override' ? DEFAULT_DROID_MODEL : null;
+        const runtimeProvider = hasOwn(input.request, 'runtimeProvider')
+            ? normalizeMissionRuntimeProvider(input.request.runtimeProvider)
+                ?? (() => {
+                    throw new MissionServiceError(400, "runtimeProvider must be 'droid_cli' or 'bigbang_native'");
+                })()
+            : 'droid_cli';
+        const missionId = randomUUID();
+        const effectiveModelConfig = buildEffectiveModelConfig({
+            mode: modelMode,
+            validationPolicy: normalizeValidationPolicy(input.request.validationPolicy),
+            validationTimeoutMs: normalizeValidationTimeoutMs(input.request.validationTimeoutMs),
+            retryPolicy: normalizeRetryPolicy(input.request.retryPolicy),
+        });
+        const create = this.db.transaction(() => {
+            this.db.prepare(`
+        INSERT INTO missions (
+          mission_id, owner_user_id, title, description, state, runtime_provider, node_id,
+          workspace_path, mission_dir, initiator_agent_id, control_conversation_id, model_mode,
+          orchestrator_model, worker_model, validator_model, effective_model_config_json,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, 'draft', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(missionId, input.userId, title, normalizeOptionalString(input.request.description) ?? '', runtimeProvider, normalizeOptionalString(input.request.nodeId), workspacePath, normalizeOptionalString(input.request.missionDir), normalizeOptionalString(input.request.initiatorAgentId), normalizeOptionalString(input.request.controlConversationId), modelMode, normalizeOptionalString(input.request.orchestratorModel) ?? model, normalizeOptionalString(input.request.workerModel) ?? model, normalizeOptionalString(input.request.validatorModel) ?? model, JSON.stringify(effectiveModelConfig), now, now);
+            this.appendEvent({
+                missionId,
+                eventType: 'mission_created',
+                source: 'platform',
+                eventTime: now,
+                payload: { title, workspacePath, modelMode, runtimeProvider },
+            });
+        });
+        create();
+        const mission = this.getMission({ missionId, userId: input.userId, isAdmin: true });
+        if (!mission)
+            throw new MissionServiceError(500, 'Mission was not created.');
+        return mission;
+    }
+    updateMission(input) {
+        const current = this.requireMissionAccess(input);
+        if (current.state === 'queued' || current.state === 'running') {
+            throw new MissionServiceError(409, 'Mission configuration cannot be changed while queued or running');
+        }
+        const request = input.request ?? {};
+        const modelMode = hasOwn(request, 'modelMode') ? normalizeModelMode(request.modelMode) : current.modelMode;
+        const runtimeProvider = hasOwn(request, 'runtimeProvider')
+            ? normalizeMissionRuntimeProviderForUpdate(request.runtimeProvider, current)
+            : current.runtimeProvider;
+        const next = {
+            title: hasOwn(request, 'title') ? normalizeRequiredString(request.title, 'title') : current.title,
+            description: hasOwn(request, 'description') ? normalizeOptionalString(request.description) ?? '' : current.description,
+            runtimeProvider,
+            nodeId: hasOwn(request, 'nodeId') ? normalizeOptionalString(request.nodeId) : current.nodeId,
+            workspacePath: hasOwn(request, 'workspacePath')
+                ? normalizeRequiredString(request.workspacePath, 'workspacePath')
+                : current.workspacePath,
+            missionDir: hasOwn(request, 'missionDir') ? normalizeOptionalString(request.missionDir) : current.missionDir,
+            initiatorAgentId: hasOwn(request, 'initiatorAgentId')
+                ? normalizeOptionalString(request.initiatorAgentId)
+                : current.initiatorAgentId,
+            controlConversationId: hasOwn(request, 'controlConversationId')
+                ? normalizeOptionalString(request.controlConversationId)
+                : current.controlConversationId,
+            modelMode,
+            orchestratorModel: nextModelValue(request, 'orchestratorModel', current.orchestratorModel, modelMode),
+            workerModel: nextModelValue(request, 'workerModel', current.workerModel, modelMode),
+            validatorModel: nextModelValue(request, 'validatorModel', current.validatorModel, modelMode),
+            validationPolicy: hasOwn(request, 'validationPolicy')
+                ? normalizeValidationPolicy(request.validationPolicy)
+                : readValidationPolicy(current.effectiveModelConfig),
+            validationTimeoutMs: hasOwn(request, 'validationTimeoutMs')
+                ? normalizeValidationTimeoutMs(request.validationTimeoutMs)
+                : readValidationTimeoutMs(current.effectiveModelConfig),
+            retryPolicy: hasOwn(request, 'retryPolicy')
+                ? normalizeRetryPolicy(request.retryPolicy)
+                : readRetryPolicy(current.effectiveModelConfig),
+        };
+        const changedFields = collectChangedMissionFields(current, next);
+        const effectiveModelConfig = buildEffectiveModelConfig({
+            mode: next.modelMode,
+            validationPolicy: next.validationPolicy,
+            validationTimeoutMs: next.validationTimeoutMs,
+            retryPolicy: next.retryPolicy,
+        });
+        const effectiveConfigChanged = JSON.stringify(current.effectiveModelConfig) !== JSON.stringify(effectiveModelConfig);
+        if (effectiveConfigChanged) {
+            if (next.validationPolicy !== readValidationPolicy(current.effectiveModelConfig)) {
+                changedFields.push('validationPolicy');
+            }
+            if (next.validationTimeoutMs !== readValidationTimeoutMs(current.effectiveModelConfig)) {
+                changedFields.push('validationTimeoutMs');
+            }
+            if (JSON.stringify(next.retryPolicy) !== JSON.stringify(readRetryPolicy(current.effectiveModelConfig))) {
+                changedFields.push('retryPolicy');
+            }
+        }
+        if (changedFields.length === 0)
+            return current;
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET title = ?, description = ?, runtime_provider = ?, node_id = ?, workspace_path = ?, mission_dir = ?,
+             initiator_agent_id = ?, control_conversation_id = ?, model_mode = ?,
+             orchestrator_model = ?, worker_model = ?, validator_model = ?,
+             effective_model_config_json = ?, updated_at = ?
+       WHERE mission_id = ?
+    `).run(next.title, next.description, next.runtimeProvider, next.nodeId, next.workspacePath, next.missionDir, next.initiatorAgentId, next.controlConversationId, next.modelMode, next.orchestratorModel, next.workerModel, next.validatorModel, JSON.stringify(effectiveModelConfig), now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_updated',
+            source: 'platform',
+            eventTime: now,
+            payload: { fields: changedFields },
+        });
+        const updated = this.getMission({ missionId: input.missionId, userId: input.userId, isAdmin: true });
+        if (!updated)
+            throw new MissionServiceError(404, 'Mission not found');
+        return updated;
+    }
+    startMission(input) {
+        const mission = this.requireMissionAccess(input);
+        if (mission.state === 'queued' || mission.state === 'running') {
+            throw new MissionServiceError(409, 'Mission is already queued or running');
+        }
+        const nodeId = normalizeOptionalString(input.nodeId) ?? mission.nodeId;
+        if (!nodeId)
+            throw new MissionServiceError(400, 'nodeId is required');
+        if (!mission.missionDir)
+            throw new MissionServiceError(400, 'missionDir is required');
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'queued', node_id = ?, updated_at = ?
+       WHERE mission_id = ?
+    `).run(nodeId, now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: input.eventType ?? 'mission_queued',
+            source: 'platform',
+            eventTime: now,
+            payload: { nodeId, ...(input.eventPayload ?? {}) },
+        });
+        const updated = this.getMission({ missionId: input.missionId, userId: input.userId, isAdmin: true });
+        if (!updated)
+            throw new MissionServiceError(404, 'Mission not found');
+        return updated;
+    }
+    pauseMission(input) {
+        const mission = this.requireMissionAccess(input);
+        if (mission.state !== 'running') {
+            throw new MissionServiceError(409, 'Mission can only be paused while running');
+        }
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'paused', updated_at = ?
+       WHERE mission_id = ?
+    `).run(now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_paused',
+            source: 'platform',
+            eventTime: now,
+            payload: {
+                reason: input.reason ?? null,
+                effectivePausePoint: input.effectivePausePoint ?? null,
+            },
+        });
+        const updated = this.getMission({ missionId: input.missionId, userId: input.userId, isAdmin: true });
+        if (!updated)
+            throw new MissionServiceError(404, 'Mission not found');
+        return updated;
+    }
+    resumeMission(input) {
+        const mission = this.requireMissionAccess(input);
+        if (mission.state !== 'paused') {
+            throw new MissionServiceError(409, 'Mission can only be resumed from paused');
+        }
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'running', updated_at = ?
+       WHERE mission_id = ?
+    `).run(now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_resumed',
+            source: 'platform',
+            eventTime: now,
+            payload: {},
+        });
+        const updated = this.getMission({ missionId: input.missionId, userId: input.userId, isAdmin: true });
+        if (!updated)
+            throw new MissionServiceError(404, 'Mission not found');
+        return updated;
+    }
+    cancelMission(input) {
+        const mission = this.requireMissionAccess(input);
+        if (!['queued', 'running', 'paused'].includes(mission.state)) {
+            throw new MissionServiceError(409, 'Mission can only be cancelled while queued, running, or paused');
+        }
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'cancelled', completed_at = ?, updated_at = ?
+       WHERE mission_id = ?
+    `).run(now, now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_cancelled',
+            source: 'platform',
+            eventTime: now,
+            payload: {},
+        });
+        const updated = this.getMission({ missionId: input.missionId, userId: input.userId, isAdmin: true });
+        if (!updated)
+            throw new MissionServiceError(404, 'Mission not found');
+        return updated;
+    }
+    deleteMission(input) {
+        this.requireMissionAccess(input);
+        this.db.prepare(`DELETE FROM missions WHERE mission_id = ?`).run(input.missionId);
+    }
+    completeMission(input) {
+        const mission = this.requireMissionAccess(input);
+        if (mission.state !== 'running') {
+            throw new MissionServiceError(409, 'Mission can only be completed while running');
+        }
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'completed', completed_at = ?, updated_at = ?
+       WHERE mission_id = ?
+    `).run(now, now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_completed',
+            source: 'agent_node',
+            eventTime: now,
+            payload: input.payload ?? {},
+        });
+        const updated = this.getMission({ missionId: input.missionId, userId: input.userId, isAdmin: true });
+        if (!updated)
+            throw new MissionServiceError(404, 'Mission not found');
+        return updated;
+    }
+    failMission(input) {
+        const mission = this.requireMissionAccess(input);
+        if (!['queued', 'running', 'paused'].includes(mission.state)) {
+            throw new MissionServiceError(409, 'Mission cannot be failed from its current state');
+        }
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'failed', completed_at = ?, updated_at = ?
+       WHERE mission_id = ?
+    `).run(now, now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_failed',
+            source: 'agent_node',
+            eventTime: now,
+            payload: { error: input.error ?? null, ...(input.payload ?? {}) },
+        });
+        const updated = this.getMission({ missionId: input.missionId, userId: input.userId, isAdmin: true });
+        if (!updated)
+            throw new MissionServiceError(404, 'Mission not found');
+        return updated;
+    }
+    markMissionStartFailed(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'failed', completed_at = ?, updated_at = ?
+       WHERE mission_id = ?
+    `).run(now, now, input.missionId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_start_failed',
+            source: 'platform',
+            eventTime: now,
+            payload: { error: input.error, requestId: input.requestId ?? null },
+        });
+    }
+    markMissionContinueStartFailed(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = ?, completed_at = ?, updated_at = ?
+       WHERE mission_id = ?
+    `).run(input.previousState, input.previousCompletedAt, now, input.missionId);
+        this.markAttemptFailedByRequestId({
+            missionId: input.missionId,
+            requestId: input.requestId,
+            error: input.error,
+            completedAt: now,
+        });
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_continue_start_failed',
+            source: 'platform',
+            eventTime: now,
+            payload: { error: input.error, requestId: input.requestId ?? null },
+        });
+    }
+    markMissionAccepted(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE missions
+         SET state = 'running', mission_dir = ?, started_at = COALESCE(started_at, ?), updated_at = ?
+       WHERE mission_id = ?
+    `).run(input.missionDir, now, now, input.missionId);
+        this.markAttemptAccepted({
+            missionId: input.missionId,
+            requestId: input.requestId,
+            missionDir: input.missionDir,
+            pid: input.pid,
+            acceptedAt: now,
+        });
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_run_accepted',
+            source: 'agent_node',
+            eventTime: now,
+            payload: {
+                missionDir: input.missionDir,
+                pid: input.pid ?? null,
+                requestId: input.requestId ?? null,
+            },
+        });
+    }
+    recordMissionRuntimeEvent(input) {
+        if (input.eventType === 'mission_interaction_accepted') {
+            this.markAttemptAccepted({
+                missionId: input.missionId,
+                requestId: asPayloadString(input.payload, 'requestId'),
+                missionDir: asPayloadString(input.payload, 'missionDir'),
+                pid: asPayloadNumber(input.payload, 'pid'),
+                acceptedAt: input.eventTime,
+            });
+        }
+        else if (input.eventType === 'mission_interaction_completed' || input.eventType === 'mission_interaction_failed') {
+            this.markAttemptEnded({
+                missionId: input.missionId,
+                requestId: asPayloadString(input.payload, 'requestId'),
+                missionDir: asPayloadString(input.payload, 'missionDir'),
+                factorySessionId: asPayloadString(input.payload, 'factorySessionId'),
+                factoryArtifactDir: asPayloadString(input.payload, 'factoryArtifactDir'),
+                exitCode: asPayloadNumber(input.payload, 'exitCode'),
+                signal: asPayloadString(input.payload, 'signal'),
+                error: asPayloadString(input.payload, 'error'),
+                completedAt: input.eventTime,
+            });
+        }
+        else if (input.eventType === 'mission_interaction_start_failed') {
+            this.markAttemptFailedByRequestId({
+                missionId: input.missionId,
+                requestId: asPayloadString(input.payload, 'requestId'),
+                error: asPayloadString(input.payload, 'error') ?? 'Droid mission interaction did not start.',
+                completedAt: input.eventTime,
+            });
+        }
+        else if (input.eventType === 'mission_attempt_start_failed') {
+            this.markAttemptFailedByRequestId({
+                missionId: input.missionId,
+                requestId: asPayloadString(input.payload, 'requestId'),
+                error: asPayloadString(input.payload, 'error') ?? 'Droid mission did not start.',
+                completedAt: input.eventTime,
+            });
+        }
+        else if (input.eventType === 'mission_stdout' || input.eventType === 'mission_stderr') {
+            this.recordAttemptOutput({
+                missionId: input.missionId,
+                requestId: asPayloadString(input.payload, 'requestId'),
+                stream: input.eventType === 'mission_stdout' ? 'stdout' : 'stderr',
+                text: asPayloadString(input.payload, 'text') ?? '',
+                eventTime: input.eventTime,
+            });
+        }
+        this.persistFactoryEvidenceFromPayload(input.missionId, input.payload, input.eventTime);
+        this.appendEvent(input);
+    }
+    recordPhase1ClosureDecision(input) {
+        const mission = this.requireMissionAccess(input);
+        if (input.request?.decision !== 'accepted_paused_partial_boundary') {
+            throw new MissionServiceError(400, 'Unsupported Phase 1 closure decision.');
+        }
+        if (!this.isPhase1PausedPartialBoundaryEligible(mission)) {
+            throw new MissionServiceError(409, 'Phase 1 paused partial boundary is not eligible for acceptance.');
+        }
+        const now = Date.now();
+        const note = normalizeOptionalString(input.request.note);
+        const eventId = this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_phase1_closure_decision',
+            source: 'platform',
+            eventTime: now,
+            payload: {
+                phase: 'phase1',
+                decision: 'accepted_paused_partial_boundary',
+                closureStatus: 'partial_boundary',
+                reason: 'Operator accepted the documented paused partial boundary; this does not mark the Droid run completed.',
+                note: note ?? null,
+                acceptedByUserId: input.userId,
+                acceptedAt: now,
+            },
+        });
+        const event = this.getEventById(eventId);
+        if (!event)
+            throw new MissionServiceError(500, 'Phase 1 closure decision was not recorded.');
+        return event;
+    }
+    finishDroidMission(input) {
+        const now = Date.now();
+        const failed = Boolean(input.error) || (input.exitCode != null && input.exitCode !== 0) || Boolean(input.signal);
+        const factorySessionId = normalizeOptionalString(input.factorySessionId);
+        const factoryArtifactDir = normalizeOptionalString(input.factoryArtifactDir);
+        const trustedCompletionFactoryDir = resolveTrustedFactoryArtifactDir(factorySessionId, factoryArtifactDir);
+        const trustedCompletionFactorySessionId = trustedCompletionFactoryDir ? path.basename(trustedCompletionFactoryDir) : null;
+        this.db.prepare(`
+      UPDATE missions
+         SET state = ?, completed_at = ?, updated_at = ?, mission_dir = ?,
+             latest_factory_session_id = COALESCE(?, latest_factory_session_id),
+             latest_factory_artifact_dir = COALESCE(?, latest_factory_artifact_dir),
+             latest_factory_seen_at = CASE WHEN ? IS NOT NULL OR ? IS NOT NULL THEN ? ELSE latest_factory_seen_at END
+       WHERE mission_id = ?
+    `).run(failed ? 'failed' : 'completed', now, now, input.missionDir, trustedCompletionFactorySessionId, trustedCompletionFactoryDir, trustedCompletionFactorySessionId, trustedCompletionFactoryDir, now, input.missionId);
+        this.markAttemptEnded({
+            missionId: input.missionId,
+            requestId: input.requestId,
+            missionDir: input.missionDir,
+            factorySessionId,
+            factoryArtifactDir,
+            exitCode: input.exitCode,
+            signal: input.signal,
+            error: input.error,
+            completedAt: now,
+        });
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: failed ? 'mission_failed' : 'mission_completed',
+            source: 'agent_node',
+            eventTime: now,
+            payload: {
+                missionDir: input.missionDir,
+                factorySessionId: factorySessionId ?? null,
+                factoryArtifactDir: factoryArtifactDir ?? null,
+                exitCode: input.exitCode ?? null,
+                signal: input.signal ?? null,
+                error: input.error ?? null,
+                requestId: input.requestId ?? null,
+            },
+        });
+        if (!failed) {
+            try {
+                const importDir = trustedCompletionFactoryDir
+                    ?? input.missionDir;
+                const snapshot = importDroidMissionArtifacts(importDir, Date.now(), {
+                    platformMissionDir: input.missionDir,
+                    factorySessionId: trustedCompletionFactorySessionId,
+                    fallbackMissionId: input.missionId,
+                    fallbackState: 'completed',
+                });
+                assertDroidSnapshotImportable(snapshot, importDir);
+                this.importSnapshot({
+                    missionId: input.missionId,
+                    userId: '',
+                    isAdmin: true,
+                    request: { source: 'droid_cli', snapshot },
+                });
+            }
+            catch (error) {
+                const message = String(error.message ?? error);
+                this.appendEvent({
+                    missionId: input.missionId,
+                    eventType: 'mission_import_failed',
+                    source: 'platform',
+                    eventTime: Date.now(),
+                    payload: { error: message },
+                });
+                this.importSnapshot({
+                    missionId: input.missionId,
+                    userId: '',
+                    isAdmin: true,
+                    request: {
+                        source: 'droid_cli_runtime',
+                        snapshot: this.buildRuntimeFallbackSnapshot(input.missionId, input.missionDir, message),
+                    },
+                });
+            }
+        }
+    }
+    listEvents(input) {
+        this.requireMissionAccess(input);
+        const afterCreatedAt = typeof input.afterCreatedAt === 'number' && Number.isFinite(input.afterCreatedAt)
+            ? Math.max(0, Math.floor(input.afterCreatedAt))
+            : null;
+        const limit = typeof input.limit === 'number' && Number.isFinite(input.limit)
+            ? Math.min(1_000, Math.max(1, Math.floor(input.limit)))
+            : null;
+        const rows = this.db.prepare(`
+      SELECT event_id as eventId, mission_id as missionId, event_type as eventType,
+             source, event_time as eventTime, payload_json as payloadJson, created_at as createdAt
+        FROM mission_events
+       WHERE mission_id = ?
+         AND (? IS NULL OR created_at > ?)
+       ORDER BY event_time ASC, created_at ASC, rowid ASC
+       LIMIT ?
+    `).all(input.missionId, afterCreatedAt, afterCreatedAt, limit ?? -1);
+        return rows.map(mapEventRow);
+    }
+    listAttempts(input) {
+        this.requireMissionAccess(input);
+        const rows = this.db.prepare(`
+      SELECT attempt_id as attemptId, mission_id as missionId, request_id as requestId,
+             attempt_type as attemptType, state, node_id as nodeId, mission_dir as missionDir,
+             prompt_preview as promptPreview, pid, exit_code as exitCode, signal, error,
+             factory_session_id as factorySessionId, factory_artifact_dir as factoryArtifactDir,
+             stdout_event_count as stdoutEventCount, stderr_event_count as stderrEventCount,
+             output_preview as outputPreview, last_output_at as lastOutputAt,
+             superseded_by as supersededBy, supersession_reason as supersessionReason,
+             superseded_at as supersededAt,
+             created_at as createdAt, accepted_at as acceptedAt, completed_at as completedAt,
+             updated_at as updatedAt
+        FROM mission_attempts
+       WHERE mission_id = ?
+       ORDER BY created_at ASC, rowid ASC
+    `).all(input.missionId);
+        return rows.map(mapAttemptRow);
+    }
+    listMissionFeatures(input) {
+        this.requireMissionAccess(input);
+        const rows = this.db.prepare(`
+      SELECT feature_id as featureId, mission_id as missionId, milestone, description,
+             skill_name as skillName, status, ordering,
+             preconditions as preconditionsJson, expected_behavior as expectedBehaviorJson,
+             handoff as handoffJson, worker_output as workerOutputJson, retry_count as retryCount,
+             is_validator as isValidator,
+             created_at as createdAt, updated_at as updatedAt
+        FROM mission_features
+       WHERE mission_id = ?
+       ORDER BY ordering ASC, created_at ASC, rowid ASC
+    `).all(input.missionId);
+        return rows.map(mapFeatureRow);
+    }
+    replaceMissionFeatures(input) {
+        this.requireMissionAccess(input);
+        const now = Date.now();
+        const insert = this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM mission_features WHERE mission_id = ?`).run(input.missionId);
+            for (const feature of input.features) {
+                this.db.prepare(`
+          INSERT INTO mission_features (
+            feature_id, mission_id, milestone, description, skill_name, status, ordering,
+            preconditions, expected_behavior, handoff, worker_output, is_validator, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(normalizeOptionalString(feature.featureId) ?? randomUUID(), input.missionId, feature.milestone, feature.description, normalizeOptionalString(feature.skillName), normalizeNativeFeatureStatus(feature.status), feature.ordering, JSON.stringify(feature.preconditions ?? []), JSON.stringify(feature.expectedBehavior ?? []), JSON.stringify(feature.handoff ?? null), JSON.stringify(feature.workerOutput ?? null), feature.isValidator ? 1 : 0, now, now);
+            }
+        });
+        insert();
+        return this.listMissionFeatures({ missionId: input.missionId, userId: input.userId, isAdmin: input.isAdmin });
+    }
+    getNextMissionFeature(input) {
+        const row = this.db.prepare(`
+      SELECT feature_id as featureId, mission_id as missionId, milestone, description,
+             skill_name as skillName, status, ordering,
+             preconditions as preconditionsJson, expected_behavior as expectedBehaviorJson,
+             handoff as handoffJson, worker_output as workerOutputJson, retry_count as retryCount,
+             is_validator as isValidator,
+             created_at as createdAt, updated_at as updatedAt
+        FROM mission_features
+       WHERE mission_id = ?
+         AND status = 'pending'
+       ORDER BY ordering ASC, created_at ASC, rowid ASC
+       LIMIT 1
+    `).get(input.missionId);
+        return row ? mapFeatureRow(row) : null;
+    }
+    listMissionValidationAssertions(input) {
+        this.requireMissionAccess(input);
+        const rows = this.db.prepare(`
+      SELECT assertion_id as assertionId, mission_id as missionId, feature_id as featureId,
+             assertion_text as assertionText, status, note, evidence, confidence,
+             created_at as createdAt, updated_at as updatedAt
+        FROM mission_validation_assertions
+       WHERE mission_id = ?
+       ORDER BY created_at ASC, rowid ASC
+    `).all(input.missionId);
+        return rows.map(mapAssertionRow);
+    }
+    replaceMissionValidationAssertions(input) {
+        this.requireMissionAccess(input);
+        const now = Date.now();
+        const insert = this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM mission_validation_assertions WHERE mission_id = ?`).run(input.missionId);
+            for (const assertion of input.assertions) {
+                this.db.prepare(`
+          INSERT INTO mission_validation_assertions (
+            assertion_id, mission_id, feature_id, assertion_text, status, note, evidence, confidence,
+            created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(randomUUID(), input.missionId, normalizeOptionalString(assertion.featureId), assertion.assertionText, normalizeNativeAssertionStatus(assertion.status), normalizeOptionalString(assertion.note), normalizeOptionalString(assertion.evidence), normalizeMissionTraceConfidence(assertion.confidence), now, now);
+            }
+        });
+        insert();
+        return this.listMissionValidationAssertions({ missionId: input.missionId, userId: input.userId, isAdmin: input.isAdmin });
+    }
+    generateValidationAssertionsFromFeatures(input) {
+        this.requireMissionAccess(input);
+        const features = this.listMissionFeatures({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const assertions = [];
+        for (const feature of features) {
+            for (const expectedBehavior of feature.expectedBehavior) {
+                assertions.push({
+                    featureId: feature.featureId,
+                    assertionText: expectedBehavior,
+                    status: 'pending',
+                });
+            }
+        }
+        return this.replaceMissionValidationAssertions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+            assertions,
+        });
+    }
+    queueMissionInteraction(input) {
+        this.requireMissionAccess(input);
+        const now = Date.now();
+        const interactionId = randomUUID();
+        const positionRow = this.db.prepare(`
+      SELECT COALESCE(MAX(position), 0) as maxPosition
+        FROM mission_interactions
+       WHERE mission_id = ?
+    `).get(input.missionId);
+        const position = (positionRow?.maxPosition ?? 0) + 1;
+        this.db.prepare(`
+      INSERT INTO mission_interactions (
+        interaction_id, mission_id, prompt, status, position, created_at, updated_at
+      ) VALUES (?, ?, ?, 'queued', ?, ?, ?)
+    `).run(interactionId, input.missionId, input.prompt, position, now, now);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_interaction_queued',
+            source: 'platform',
+            eventTime: now,
+            payload: { interactionId, prompt: input.prompt, position },
+        });
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_interaction_accepted',
+            source: 'platform',
+            eventTime: now,
+            payload: { interactionId, prompt: input.prompt, position },
+        });
+        const interaction = this.getMissionInteractionById(interactionId);
+        if (!interaction)
+            throw new MissionServiceError(500, 'Interaction was not created.');
+        return interaction;
+    }
+    listMissionInteractions(input) {
+        this.requireMissionAccess(input);
+        const rows = this.db.prepare(`
+      SELECT interaction_id as interactionId, mission_id as missionId, prompt, status,
+             position, created_at as createdAt, updated_at as updatedAt
+        FROM mission_interactions
+       WHERE mission_id = ?
+       ORDER BY position ASC, created_at ASC, rowid ASC
+    `).all(input.missionId);
+        return rows.map(mapInteractionRow);
+    }
+    getMissionPlan(input) {
+        this.requireMissionAccess(input);
+        const row = this.db.prepare(`
+      SELECT mission_id as missionId, plan_json as planJson, version,
+             created_at as createdAt, updated_at as updatedAt
+        FROM mission_plans
+       WHERE mission_id = ?
+    `).get(input.missionId);
+        return row ? mapPlanRow(row) : null;
+    }
+    replaceMissionPlan(input) {
+        this.requireMissionAccess(input);
+        const existing = this.getMissionPlan({ missionId: input.missionId, userId: input.userId, isAdmin: input.isAdmin });
+        const now = Date.now();
+        const version = (existing?.version ?? 0) + 1;
+        this.db.prepare(`
+      INSERT INTO mission_plans (mission_id, plan_json, version, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(mission_id) DO UPDATE SET
+        plan_json = excluded.plan_json,
+        version = excluded.version,
+        updated_at = excluded.updated_at
+    `).run(input.missionId, JSON.stringify(input.plan), version, now, now);
+        const updated = this.getMissionPlan({ missionId: input.missionId, userId: input.userId, isAdmin: input.isAdmin });
+        if (!updated)
+            throw new MissionServiceError(500, 'Mission plan was not persisted.');
+        return updated;
+    }
+    listMissionMilestones(input) {
+        this.requireMissionAccess(input);
+        const rows = this.db.prepare(`
+      SELECT milestone_id as milestoneId, mission_id as missionId, name, status, ordering,
+             started_at as startedAt, completed_at as completedAt,
+             created_at as createdAt, updated_at as updatedAt
+        FROM mission_milestones
+       WHERE mission_id = ?
+       ORDER BY ordering ASC, created_at ASC, rowid ASC
+    `).all(input.missionId);
+        return rows.map(mapMilestoneRow);
+    }
+    replaceMissionMilestones(input) {
+        this.requireMissionAccess(input);
+        const now = Date.now();
+        const insert = this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM mission_milestones WHERE mission_id = ?`).run(input.missionId);
+            for (const milestone of input.milestones) {
+                this.db.prepare(`
+          INSERT INTO mission_milestones (
+            milestone_id, mission_id, name, status, ordering,
+            started_at, completed_at, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(normalizeOptionalString(milestone.milestoneId) ?? randomUUID(), input.missionId, milestone.name, normalizeMilestoneStatus(milestone.status), milestone.ordering, normalizeOptionalNumber(milestone.startedAt), normalizeOptionalNumber(milestone.completedAt), now, now);
+            }
+        });
+        insert();
+        return this.listMissionMilestones({ missionId: input.missionId, userId: input.userId, isAdmin: input.isAdmin });
+    }
+    updateMissionMilestoneStatus(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_milestones
+         SET status = ?,
+             started_at = COALESCE(?, started_at),
+             completed_at = COALESCE(?, completed_at),
+             updated_at = ?
+       WHERE mission_id = ?
+         AND milestone_id = ?
+    `).run(input.status, normalizeOptionalNumber(input.startedAt), normalizeOptionalNumber(input.completedAt), now, input.missionId, input.milestoneId);
+        const updated = this.listMissionMilestones({ missionId: input.missionId, userId: '', isAdmin: true })
+            .find((milestone) => milestone.milestoneId === input.milestoneId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Milestone not found');
+        return updated;
+    }
+    resetMissionValidationAssertions(input) {
+        this.requireMissionAccess(input);
+        const now = Date.now();
+        if (input.featureId) {
+            this.db.prepare(`
+        UPDATE mission_validation_assertions
+           SET status = 'pending', note = NULL, evidence = NULL, confidence = NULL, updated_at = ?
+         WHERE mission_id = ?
+           AND feature_id = ?
+      `).run(now, input.missionId, input.featureId);
+        }
+        else {
+            this.db.prepare(`
+        UPDATE mission_validation_assertions
+           SET status = 'pending', note = NULL, evidence = NULL, confidence = NULL, updated_at = ?
+         WHERE mission_id = ?
+      `).run(now, input.missionId);
+        }
+        return this.listMissionValidationAssertions({ missionId: input.missionId, userId: input.userId, isAdmin: input.isAdmin });
+    }
+    resetMissionValidationAssertionsByFeatureStatus(input) {
+        this.requireMissionAccess(input);
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_validation_assertions
+         SET status = 'pending', note = NULL, evidence = NULL, confidence = NULL, updated_at = ?
+       WHERE mission_id = ?
+         AND feature_id IN (
+           SELECT feature_id FROM mission_features WHERE mission_id = ? AND status = ?
+         )
+    `).run(now, input.missionId, input.missionId, input.featureStatus);
+        return this.listMissionValidationAssertions({ missionId: input.missionId, userId: input.userId, isAdmin: input.isAdmin });
+    }
+    listEvidence(input) {
+        const mission = this.requireMissionAccess(input);
+        const events = this.listEvents({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const attempts = this.listAttempts({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const snapshot = this.getLatestSnapshot({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const features = this.listMissionFeatures({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const assertions = this.listMissionValidationAssertions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const interactions = this.listMissionInteractions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const evidence = deriveMissionEvidence({
+            mission,
+            events,
+            attempts,
+            snapshot,
+            features,
+            assertions,
+            interactions,
+        });
+        const filter = {
+            sourceType: input.sourceType,
+            featureId: input.featureId,
+            after: input.after,
+            limit: input.limit,
+        };
+        return filterMissionEvidence(evidence, filter);
+    }
+    listTrace(input) {
+        const mission = this.requireMissionAccess(input);
+        const events = this.listEvents({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const attempts = this.listAttempts({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const snapshot = this.getLatestSnapshot({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const features = this.listMissionFeatures({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const assertions = this.listMissionValidationAssertions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const interactions = this.listMissionInteractions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const traces = deriveMissionTrace({
+            mission,
+            events,
+            attempts,
+            snapshot,
+            features,
+            assertions,
+            interactions,
+        });
+        const filter = {
+            role: input.role,
+            operation: input.operation,
+            confidence: input.confidence,
+            after: input.after,
+            limit: input.limit,
+        };
+        return filterMissionTrace(traces, filter);
+    }
+    markMissionInteractionDelivered(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_interactions
+         SET status = 'delivered', updated_at = ?
+       WHERE mission_id = ?
+         AND interaction_id = ?
+    `).run(now, input.missionId, input.interactionId);
+        const updated = this.getMissionInteractionById(input.interactionId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Interaction not found');
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: 'mission_interaction_delivered',
+            source: 'platform',
+            eventTime: now,
+            payload: {
+                interactionId: updated.interactionId,
+                prompt: updated.prompt,
+                position: updated.position,
+            },
+        });
+        return updated;
+    }
+    updateMissionInteractionStatus(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_interactions
+         SET status = ?, updated_at = ?
+       WHERE mission_id = ?
+         AND interaction_id = ?
+    `).run(input.status, now, input.missionId, input.interactionId);
+        const updated = this.getMissionInteractionById(input.interactionId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Interaction not found');
+        return updated;
+    }
+    getMissionInteractionById(interactionId) {
+        const row = this.db.prepare(`
+      SELECT interaction_id as interactionId, mission_id as missionId, prompt, status,
+             position, created_at as createdAt, updated_at as updatedAt
+        FROM mission_interactions
+       WHERE interaction_id = ?
+    `).get(interactionId);
+        return row ? mapInteractionRow(row) : null;
+    }
+    updateMissionValidationAssertion(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_validation_assertions
+         SET status = ?, note = ?, evidence = ?, confidence = ?, updated_at = ?
+       WHERE mission_id = ?
+         AND assertion_id = ?
+    `).run(input.status, normalizeOptionalString(input.note), normalizeOptionalString(input.evidence), normalizeMissionTraceConfidence(input.confidence), now, input.missionId, input.assertionId);
+        const updated = this.listMissionValidationAssertions({ missionId: input.missionId, userId: '', isAdmin: true })
+            .find((assertion) => assertion.assertionId === input.assertionId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Assertion not found');
+        return updated;
+    }
+    updateMissionFeatureStatus(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_features
+         SET status = ?, updated_at = ?
+       WHERE mission_id = ?
+         AND feature_id = ?
+    `).run(input.status, now, input.missionId, input.featureId);
+        this.appendEvent({
+            missionId: input.missionId,
+            eventType: input.eventType ?? `feature_${input.status}`,
+            source: input.source ?? 'platform',
+            eventTime: now,
+            payload: {
+                featureId: input.featureId,
+                status: input.status,
+                ...(input.eventPayload ?? {}),
+            },
+        });
+        const updated = this.listMissionFeatures({ missionId: input.missionId, userId: '', isAdmin: true })
+            .find((feature) => feature.featureId === input.featureId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Feature not found');
+        return updated;
+    }
+    updateMissionFeatureHandoff(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_features
+         SET handoff = ?, updated_at = ?
+       WHERE mission_id = ?
+         AND feature_id = ?
+    `).run(JSON.stringify(input.handoff), now, input.missionId, input.featureId);
+        const updated = this.listMissionFeatures({ missionId: input.missionId, userId: '', isAdmin: true })
+            .find((feature) => feature.featureId === input.featureId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Feature not found');
+        return updated;
+    }
+    updateMissionFeatureWorkerOutput(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_features
+         SET worker_output = ?, updated_at = ?
+       WHERE mission_id = ?
+         AND feature_id = ?
+    `).run(JSON.stringify(input.workerOutput), now, input.missionId, input.featureId);
+        const updated = this.listMissionFeatures({ missionId: input.missionId, userId: '', isAdmin: true })
+            .find((feature) => feature.featureId === input.featureId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Feature not found');
+        return updated;
+    }
+    incrementMissionFeatureRetryCount(input) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE mission_features
+         SET retry_count = retry_count + 1, updated_at = ?
+       WHERE mission_id = ?
+         AND feature_id = ?
+    `).run(now, input.missionId, input.featureId);
+        const updated = this.listMissionFeatures({ missionId: input.missionId, userId: '', isAdmin: true })
+            .find((feature) => feature.featureId === input.featureId);
+        if (!updated)
+            throw new MissionServiceError(404, 'Feature not found');
+        return updated;
+    }
+    createMissionAttempt(input) {
+        const now = input.createdAt ?? Date.now();
+        const existing = this.getMissionAttemptByRequestId(input.missionId, input.requestId);
+        if (existing) {
+            this.db.prepare(`
+        UPDATE mission_attempts
+           SET node_id = ?,
+               mission_dir = ?,
+               prompt_preview = COALESCE(?, prompt_preview),
+               updated_at = ?
+         WHERE mission_id = ?
+           AND request_id = ?
+      `).run(input.nodeId, input.missionDir, normalizePromptPreview(input.prompt), now, input.missionId, input.requestId);
+        }
+        else {
+            const supersessionReason = normalizeSupersessionReason(input.supersessionReason);
+            if (input.supersedesAttemptId && !supersessionReason) {
+                throw new MissionServiceError(400, 'supersessionReason is required when supersedesAttemptId is provided');
+            }
+            const create = this.db.transaction(() => {
+                this.db.prepare(`
+          INSERT INTO mission_attempts (
+            attempt_id, mission_id, request_id, attempt_type, state, node_id, mission_dir,
+            prompt_preview, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, 'queued', ?, ?, ?, ?, ?)
+        `).run(randomUUID(), input.missionId, input.requestId, input.attemptType, input.nodeId, input.missionDir, normalizePromptPreview(input.prompt), now, now);
+                if (input.supersedesAttemptId && supersessionReason) {
+                    const prior = this.db.prepare(`
+            SELECT attempt_id as attemptId, superseded_by as supersededBy
+              FROM mission_attempts
+             WHERE attempt_id = ?
+          `).get(input.supersedesAttemptId);
+                    if (!prior) {
+                        throw new MissionServiceError(404, 'Prior attempt not found');
+                    }
+                    if (prior.supersededBy) {
+                        throw new MissionServiceError(409, 'Prior attempt is already superseded');
+                    }
+                    const newAttempt = this.db.prepare(`
+            SELECT attempt_id as attemptId
+              FROM mission_attempts
+             WHERE mission_id = ?
+               AND request_id = ?
+          `).get(input.missionId, input.requestId);
+                    if (!newAttempt) {
+                        throw new MissionServiceError(500, 'Newly created attempt was not found');
+                    }
+                    this.db.prepare(`
+            UPDATE mission_attempts
+               SET superseded_by = ?,
+                   supersession_reason = ?,
+                   superseded_at = ?,
+                   updated_at = ?
+             WHERE attempt_id = ?
+          `).run(newAttempt.attemptId, supersessionReason, now, now, input.supersedesAttemptId);
+                }
+            });
+            create();
+        }
+        const attempt = this.getMissionAttemptByRequestId(input.missionId, input.requestId);
+        if (!attempt)
+            throw new MissionServiceError(500, 'Mission attempt was not created.');
+        return attempt;
+    }
+    markAttemptSuperseded(input) {
+        const now = input.supersededAt ?? Date.now();
+        const reason = normalizeSupersessionReason(input.reason);
+        if (!reason) {
+            throw new MissionServiceError(400, "reason must be 'retry', 'recovery', or 'orphan_cleanup'");
+        }
+        const update = this.db.transaction(() => {
+            const prior = this.db.prepare(`
+        SELECT attempt_id as attemptId, mission_id as missionId, superseded_by as supersededBy
+          FROM mission_attempts
+         WHERE attempt_id = ?
+      `).get(input.attemptId);
+            if (!prior) {
+                throw new MissionServiceError(404, 'Attempt not found');
+            }
+            if (prior.supersededBy) {
+                throw new MissionServiceError(409, 'Attempt is already superseded');
+            }
+            const successor = input.supersededBy
+                ? this.db.prepare(`
+            SELECT attempt_id as attemptId
+              FROM mission_attempts
+             WHERE attempt_id = ?
+          `).get(input.supersededBy)
+                : undefined;
+            if (input.supersededBy && !successor) {
+                throw new MissionServiceError(404, 'Superseding attempt not found');
+            }
+            this.db.prepare(`
+        UPDATE mission_attempts
+           SET superseded_by = ?,
+               supersession_reason = ?,
+               superseded_at = ?,
+               updated_at = ?
+         WHERE attempt_id = ?
+      `).run(input.supersededBy, reason, now, now, input.attemptId);
+        });
+        update();
+        const attempt = this.db.prepare(`
+      SELECT attempt_id as attemptId, mission_id as missionId, request_id as requestId,
+             attempt_type as attemptType, state, node_id as nodeId, mission_dir as missionDir,
+             prompt_preview as promptPreview, pid, exit_code as exitCode, signal, error,
+             factory_session_id as factorySessionId, factory_artifact_dir as factoryArtifactDir,
+             stdout_event_count as stdoutEventCount, stderr_event_count as stderrEventCount,
+             output_preview as outputPreview, last_output_at as lastOutputAt,
+             superseded_by as supersededBy, supersession_reason as supersessionReason,
+             superseded_at as supersededAt,
+             created_at as createdAt, accepted_at as acceptedAt, completed_at as completedAt,
+             updated_at as updatedAt
+        FROM mission_attempts
+       WHERE attempt_id = ?
+    `).get(input.attemptId);
+        if (!attempt)
+            throw new MissionServiceError(500, 'Attempt was not found after supersession.');
+        return mapAttemptRow(attempt);
+    }
+    getLatestSnapshot(input) {
+        this.requireMissionAccess(input);
+        const row = this.db.prepare(`
+      SELECT snapshot_id as snapshotId, mission_id as missionId, source, snapshot_json as snapshotJson,
+             created_at as createdAt
+       FROM mission_snapshots
+       WHERE mission_id = ?
+       ORDER BY created_at DESC, rowid DESC
+       LIMIT 1
+    `).get(input.missionId);
+        return row ? mapSnapshotRow(row) : null;
+    }
+    importSnapshot(input) {
+        this.requireMissionAccess(input);
+        const now = Date.now();
+        const snapshotId = randomUUID();
+        const source = normalizeOptionalString(input.request.source) ?? 'manual';
+        const snapshot = normalizeSnapshotPayload(input.request.snapshot);
+        const importSnapshot = this.db.transaction(() => {
+            this.db.prepare(`
+        INSERT INTO mission_snapshots (snapshot_id, mission_id, source, snapshot_json, created_at)
+        VALUES (?, ?, ?, ?, ?)
+      `).run(snapshotId, input.missionId, source, JSON.stringify(snapshot), now);
+            this.db.prepare(`
+        UPDATE missions
+           SET last_imported_at = ?, updated_at = ?
+         WHERE mission_id = ?
+      `).run(now, now, input.missionId);
+            this.persistFactoryEvidenceFromPayload(input.missionId, snapshot, now);
+            this.appendEvent({
+                missionId: input.missionId,
+                eventType: 'mission_snapshot_imported',
+                source,
+                eventTime: now,
+                payload: { snapshotId },
+            });
+        });
+        importSnapshot();
+        const row = this.db.prepare(`
+      SELECT snapshot_id as snapshotId, mission_id as missionId, source, snapshot_json as snapshotJson,
+             created_at as createdAt
+        FROM mission_snapshots
+       WHERE snapshot_id = ?
+    `).get(snapshotId);
+        return mapSnapshotRow(row);
+    }
+    importDroidArtifacts(input) {
+        const mission = this.requireMissionAccess(input);
+        const missionDir = mission.missionDir;
+        if (!missionDir)
+            throw new MissionServiceError(400, 'missionDir is required');
+        const trustedFactoryDir = resolveTrustedFactoryArtifactDir(mission.latestFactorySessionId, mission.latestFactoryArtifactDir);
+        const trustedFactorySessionId = trustedFactoryDir ? path.basename(trustedFactoryDir) : null;
+        const importDir = trustedFactoryDir ?? missionDir;
+        let snapshot;
+        try {
+            snapshot = importDroidMissionArtifacts(importDir, Date.now(), {
+                platformMissionDir: trustedFactoryDir ? missionDir : null,
+                factorySessionId: trustedFactorySessionId,
+                fallbackMissionId: mission.missionId,
+            });
+        }
+        catch (error) {
+            throw new MissionServiceError(400, String(error.message ?? error));
+        }
+        assertDroidSnapshotImportable(snapshot, importDir);
+        return this.importSnapshot({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+            request: {
+                source: 'droid_cli',
+                snapshot,
+            },
+        });
+    }
+    generateNativeMissionSnapshot(input) {
+        const mission = this.requireMissionAccess(input);
+        const features = this.listMissionFeatures({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const assertions = this.listMissionValidationAssertions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const events = this.listEvents({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const featureItems = features.map((feature) => ({
+            id: feature.featureId,
+            milestone: feature.milestone,
+            description: feature.description,
+            skillName: feature.skillName,
+            status: feature.status,
+            ordering: feature.ordering,
+            preconditions: feature.preconditions,
+            expectedBehavior: feature.expectedBehavior,
+            createdAt: feature.createdAt,
+            updatedAt: feature.updatedAt,
+        }));
+        const handoffItems = features
+            .filter((feature) => feature.handoff != null)
+            .map((feature) => {
+            const handoff = feature.handoff ?? {};
+            return {
+                featureId: feature.featureId,
+                milestone: feature.milestone,
+                status: feature.status,
+                fileName: `${feature.featureId}.json`,
+                timestampMs: feature.updatedAt,
+                salientSummary: typeof handoff.salientSummary === 'string' ? handoff.salientSummary : null,
+                verification: isPlainObject(handoff.verification) ? handoff.verification : null,
+                discoveredIssues: Array.isArray(handoff.discoveredIssues) ? handoff.discoveredIssues : [],
+                raw: handoff,
+            };
+        });
+        const assertionItems = assertions.map((assertion) => ({
+            id: assertion.assertionId,
+            featureId: assertion.featureId,
+            status: assertion.status,
+            note: assertion.note,
+            evidence: assertion.evidence,
+            confidence: assertion.confidence,
+            raw: {
+                assertionId: assertion.assertionId,
+                featureId: assertion.featureId,
+                assertionText: assertion.assertionText,
+                status: assertion.status,
+                note: assertion.note,
+                evidence: assertion.evidence,
+                confidence: assertion.confidence,
+            },
+        }));
+        const timelineRows = events.map((event) => ({
+            eventId: event.eventId,
+            type: event.eventType,
+            source: event.source,
+            timestampMs: event.eventTime,
+            payload: event.payload,
+        }));
+        const statusCounts = countRows(features.map((feature) => feature.status));
+        const assertionStatusCounts = countRows(assertions.map((assertion) => assertion.status));
+        const effectiveConfig = mission.effectiveModelConfig ?? {};
+        const reportEntries = [];
+        if (mission.missionDir) {
+            const reportPath = path.join(mission.missionDir, NATIVE_MISSION_REPORT_FILE_NAME);
+            if (existsSync(reportPath)) {
+                try {
+                    const raw = readFileSync(reportPath, 'utf8');
+                    const REPORT_TEXT_LIMIT = 120_000;
+                    const truncated = raw.length > REPORT_TEXT_LIMIT;
+                    reportEntries.push({
+                        path: NATIVE_MISSION_REPORT_FILE_NAME,
+                        sizeBytes: Buffer.byteLength(raw, 'utf8'),
+                        truncated,
+                        text: truncated ? `${raw.slice(0, REPORT_TEXT_LIMIT)}\n[truncated]` : raw,
+                    });
+                }
+                catch {
+                    // Ignore unreadable report; snapshot should still be generated.
+                }
+            }
+        }
+        const snapshot = {
+            schemaVersion: 1,
+            importedAt: Date.now(),
+            source: 'bigbang_native',
+            missionDir: mission.missionDir,
+            overview: {
+                missionId: mission.missionId,
+                title: mission.title,
+                state: mission.state,
+                runtimeProvider: mission.runtimeProvider,
+                workspacePath: mission.workspacePath,
+                modelMode: mission.modelMode,
+                featureCount: features.length,
+                completedFeatureCount: statusCounts.completed ?? 0,
+                failedFeatureCount: statusCounts.failed ?? 0,
+                validationAssertionCount: assertions.length,
+                handoffCount: handoffItems.length,
+                timelineEventCount: events.length,
+                reportCount: reportEntries.length,
+            },
+            features: {
+                summary: {
+                    total: features.length,
+                    statusCounts,
+                    milestoneCounts: countRows(features.map((feature) => feature.milestone)),
+                },
+                items: featureItems,
+            },
+            timeline: {
+                summary: {
+                    total: timelineRows.length,
+                    typeCounts: countRows(timelineRows.map((row) => row.type)),
+                },
+                events: timelineRows,
+            },
+            handoffs: {
+                summary: {
+                    total: handoffItems.length,
+                    milestoneCounts: countRows(handoffItems.map((item) => item.milestone)),
+                    statusCounts: countRows(handoffItems.map((item) => item.status)),
+                },
+                items: handoffItems,
+            },
+            validation: {
+                summary: {
+                    total: assertions.length,
+                    statusCounts: assertionStatusCounts,
+                },
+                assertions: assertionItems,
+            },
+            artifacts: {
+                files: [],
+                reports: reportEntries,
+            },
+            settings: {
+                modelSettings: {
+                    orchestratorModel: mission.orchestratorModel,
+                    workerModel: mission.workerModel,
+                    validatorModel: mission.validatorModel,
+                },
+                runtimeCustomModels: null,
+                validationPolicy: readValidationPolicy(effectiveConfig),
+                validationTimeoutMs: readValidationTimeoutMs(effectiveConfig),
+            },
+            anomalies: [],
+        };
+        const redacted = redactFallbackSecrets(snapshot);
+        return redacted;
+    }
+    generateNativeMissionReport(input) {
+        const mission = this.requireMissionAccess(input);
+        const missionDir = mission.missionDir;
+        if (!missionDir)
+            throw new MissionServiceError(400, 'missionDir is required');
+        const features = this.listMissionFeatures({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const assertions = this.listMissionValidationAssertions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const events = this.listEvents({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const reportInput = {
+            mission,
+            features,
+            assertions,
+            events,
+        };
+        return generateNativeMissionReport(missionDir, reportInput);
+    }
+    requireMissionAccess(input) {
+        const mission = this.getMission(input);
+        if (!mission)
+            throw new MissionServiceError(404, 'Mission not found');
+        return mission;
+    }
+    appendEvent(input) {
+        const eventId = randomUUID();
+        this.db.prepare(`
+      INSERT INTO mission_events (event_id, mission_id, event_type, source, event_time, payload_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(eventId, input.missionId, input.eventType, input.source, input.eventTime, JSON.stringify(input.payload ?? {}), Date.now());
+        return eventId;
+    }
+    getEventById(eventId) {
+        const row = this.db.prepare(`
+      SELECT event_id as eventId, mission_id as missionId, event_type as eventType,
+             source, event_time as eventTime, payload_json as payloadJson, created_at as createdAt
+        FROM mission_events
+       WHERE event_id = ?
+    `).get(eventId);
+        return row ? mapEventRow(row) : null;
+    }
+    isPhase1PausedPartialBoundaryEligible(mission) {
+        if (mission.state !== 'queued' && mission.state !== 'running')
+            return false;
+        const snapshot = this.getLatestSnapshot({ missionId: mission.missionId, userId: '', isAdmin: true });
+        const events = this.listEvents({ missionId: mission.missionId, userId: '', isAdmin: true });
+        const attempts = this.listAttempts({ missionId: mission.missionId, userId: '', isAdmin: true });
+        if (events.some((event) => isAcceptedPhase1ClosureDecisionEvent(event)))
+            return false;
+        const snapshotData = snapshot?.snapshot ?? {};
+        const observedDroidState = readObservedDroidState(snapshot, events);
+        if (observedDroidState !== 'paused')
+            return false;
+        const hasRunEvidence = attempts.some((attempt) => attempt.attemptType === 'run')
+            || events.some((event) => event.eventType === 'mission_run_accepted');
+        const hasRuntimeOutput = events.some((event) => event.eventType === 'mission_stdout' || event.eventType === 'mission_stderr' || event.eventType === 'mission_progress' || event.eventType === 'mission_session_event');
+        const hasFactoryEvidence = Boolean(resolveTrustedFactoryArtifactDir(mission.latestFactorySessionId, mission.latestFactoryArtifactDir));
+        const artifactMode = readArtifactMode(snapshotData);
+        const hasArtifactEvidence = artifactMode === 'structured' || artifactMode === 'report_only' || artifactMode === 'runtime_fallback';
+        const hasStructuredOrReportEvidence = artifactMode === 'structured' || artifactMode === 'report_only';
+        const latestInteractionStatus = readLatestInteractionStatus(events);
+        const hasCompletedInteractionEvidence = latestInteractionStatus === 'completed';
+        const latestSessionContinuation = attempts
+            .filter((attempt) => attempt.attemptType === 'session_continuation')
+            .sort((left, right) => right.updatedAt - left.updatedAt)[0];
+        const hasNoFailedContinuation = latestSessionContinuation?.state !== 'failed';
+        const hasTerminalEvidence = attempts.some((attempt) => attempt.attemptType === 'run' && (attempt.state === 'completed' || attempt.state === 'failed'));
+        return hasRunEvidence
+            && hasRuntimeOutput
+            && hasFactoryEvidence
+            && hasArtifactEvidence
+            && hasStructuredOrReportEvidence
+            && hasCompletedInteractionEvidence
+            && hasNoFailedContinuation
+            && !hasTerminalEvidence;
+    }
+    markAttemptAccepted(input) {
+        const requestId = normalizeOptionalString(input.requestId);
+        if (!requestId)
+            return;
+        this.db.prepare(`
+      UPDATE mission_attempts
+         SET state = 'running',
+             mission_dir = COALESCE(?, mission_dir),
+             pid = COALESCE(?, pid),
+             accepted_at = COALESCE(accepted_at, ?),
+             updated_at = ?
+       WHERE mission_id = ?
+         AND request_id = ?
+    `).run(normalizeOptionalString(input.missionDir), normalizeOptionalNumber(input.pid), input.acceptedAt, input.acceptedAt, input.missionId, requestId);
+    }
+    markAttemptEnded(input) {
+        const requestId = normalizeOptionalString(input.requestId);
+        if (!requestId)
+            return;
+        const exitCode = normalizeOptionalNumber(input.exitCode);
+        const signal = normalizeOptionalString(input.signal);
+        const error = normalizeOptionalString(input.error);
+        const failed = Boolean(error) || (exitCode != null && exitCode !== 0) || Boolean(signal);
+        this.db.prepare(`
+      UPDATE mission_attempts
+         SET state = ?,
+             mission_dir = COALESCE(?, mission_dir),
+             factory_session_id = COALESCE(?, factory_session_id),
+             factory_artifact_dir = COALESCE(?, factory_artifact_dir),
+             exit_code = ?,
+             signal = ?,
+             error = ?,
+             completed_at = ?,
+             updated_at = ?
+       WHERE mission_id = ?
+         AND request_id = ?
+    `).run(failed ? 'failed' : 'completed', normalizeOptionalString(input.missionDir), normalizeOptionalString(input.factorySessionId), normalizeOptionalString(input.factoryArtifactDir), exitCode, signal, error, input.completedAt, input.completedAt, input.missionId, requestId);
+    }
+    markAttemptFailedByRequestId(input) {
+        const requestId = normalizeOptionalString(input.requestId);
+        if (!requestId)
+            return;
+        this.db.prepare(`
+      UPDATE mission_attempts
+         SET state = 'failed',
+             error = ?,
+             completed_at = COALESCE(completed_at, ?),
+             updated_at = ?
+       WHERE mission_id = ?
+         AND request_id = ?
+    `).run(input.error, input.completedAt, input.completedAt, input.missionId, requestId);
+    }
+    recordAttemptOutput(input) {
+        const requestId = normalizeOptionalString(input.requestId);
+        if (!requestId)
+            return;
+        const preview = normalizeOutputPreview(input.stream, input.text);
+        this.db.prepare(`
+      UPDATE mission_attempts
+         SET stdout_event_count = stdout_event_count + ?,
+             stderr_event_count = stderr_event_count + ?,
+             output_preview = COALESCE(?, output_preview),
+             last_output_at = ?,
+             updated_at = ?
+       WHERE mission_id = ?
+         AND request_id = ?
+    `).run(input.stream === 'stdout' ? 1 : 0, input.stream === 'stderr' ? 1 : 0, preview, input.eventTime, input.eventTime, input.missionId, requestId);
+    }
+    getMissionAttemptByRequestId(missionId, requestId) {
+        const row = this.db.prepare(`
+      SELECT attempt_id as attemptId, mission_id as missionId, request_id as requestId,
+             attempt_type as attemptType, state, node_id as nodeId, mission_dir as missionDir,
+             prompt_preview as promptPreview, pid, exit_code as exitCode, signal, error,
+             factory_session_id as factorySessionId, factory_artifact_dir as factoryArtifactDir,
+             stdout_event_count as stdoutEventCount, stderr_event_count as stderrEventCount,
+             output_preview as outputPreview, last_output_at as lastOutputAt,
+             superseded_by as supersededBy, supersession_reason as supersessionReason,
+             superseded_at as supersededAt,
+             created_at as createdAt, accepted_at as acceptedAt, completed_at as completedAt,
+             updated_at as updatedAt
+        FROM mission_attempts
+       WHERE mission_id = ?
+         AND request_id = ?
+       LIMIT 1
+    `).get(missionId, requestId);
+        return row ? mapAttemptRow(row) : null;
+    }
+    persistFactoryEvidenceFromPayload(missionId, payload, seenAt) {
+        if (!isPlainObject(payload))
+            return;
+        const factorySessionId = normalizeOptionalString(payload.factorySessionId);
+        const factoryArtifactDir = normalizeOptionalString(payload.factoryArtifactDir);
+        if (!factorySessionId && !factoryArtifactDir)
+            return;
+        if (factoryArtifactDir && !resolveTrustedFactoryArtifactDir(factorySessionId, factoryArtifactDir))
+            return;
+        this.db.prepare(`
+      UPDATE missions
+         SET latest_factory_session_id = CASE
+               WHEN ? IS NOT NULL THEN COALESCE(?, latest_factory_session_id)
+               WHEN latest_factory_artifact_dir IS NULL THEN COALESCE(?, latest_factory_session_id)
+               ELSE latest_factory_session_id
+             END,
+             latest_factory_artifact_dir = COALESCE(?, latest_factory_artifact_dir),
+             latest_factory_seen_at = CASE
+               WHEN ? IS NOT NULL THEN ?
+               WHEN latest_factory_artifact_dir IS NULL THEN ?
+               ELSE latest_factory_seen_at
+             END
+       WHERE mission_id = ?
+    `).run(factoryArtifactDir, factorySessionId, factorySessionId, factoryArtifactDir, factoryArtifactDir, seenAt, seenAt, missionId);
+    }
+    buildRuntimeFallbackSnapshot(missionId, missionDir, importError) {
+        const mission = this.getMission({ missionId, userId: '', isAdmin: true });
+        const events = this.db.prepare(`
+      SELECT event_id as eventId, mission_id as missionId, event_type as eventType,
+             source, event_time as eventTime, payload_json as payloadJson, created_at as createdAt
+        FROM mission_events
+       WHERE mission_id = ?
+       ORDER BY event_time ASC, created_at ASC, rowid ASC
+    `).all(missionId);
+        const timeline = events.map((row) => mapEventRow(row)).map((event) => ({
+            eventId: event.eventId,
+            type: event.eventType,
+            source: event.source,
+            timestampMs: event.eventTime,
+            payload: redactRuntimePayload(event.payload),
+        }));
+        return {
+            schemaVersion: 1,
+            importedAt: Date.now(),
+            missionDir,
+            overview: {
+                missionId,
+                title: mission?.title ?? null,
+                state: mission?.state ?? 'completed',
+                runtimeProvider: mission?.runtimeProvider ?? 'droid_cli',
+                workspacePath: mission?.workspacePath ?? null,
+                modelMode: mission?.modelMode ?? null,
+                droidArtifactImport: 'failed',
+                runtimeEventCount: timeline.length,
+            },
+            features: { summary: { total: 0 }, items: [] },
+            timeline: {
+                summary: { total: timeline.length, typeCounts: countFallbackEvents(timeline) },
+                events: timeline,
+            },
+            handoffs: { summary: { total: 0 }, items: [] },
+            validation: { summary: { total: 0 }, assertions: [] },
+            artifacts: { files: [] },
+            settings: {
+                modelSettings: {
+                    orchestratorModel: mission?.orchestratorModel ?? null,
+                    workerModel: mission?.workerModel ?? null,
+                    validatorModel: mission?.validatorModel ?? null,
+                },
+                runtimeCustomModels: null,
+            },
+            anomalies: [
+                {
+                    severity: 'warning',
+                    type: 'missing_droid_artifacts',
+                    message: importError,
+                    path: missionDir,
+                },
+            ],
+        };
+    }
+}
+function mapMissionRow(row) {
+    return {
+        missionId: row.missionId,
+        ownerUserId: row.ownerUserId,
+        title: row.title,
+        description: row.description,
+        state: normalizeMissionState(row.state),
+        runtimeProvider: normalizeMissionRuntimeProvider(row.runtimeProvider) ?? 'droid_cli',
+        nodeId: row.nodeId,
+        workspacePath: row.workspacePath,
+        missionDir: row.missionDir,
+        initiatorAgentId: row.initiatorAgentId,
+        controlConversationId: row.controlConversationId,
+        modelMode: normalizeModelMode(row.modelMode),
+        orchestratorModel: row.orchestratorModel,
+        workerModel: row.workerModel,
+        validatorModel: row.validatorModel,
+        effectiveModelConfig: parseJsonObject(row.effectiveModelConfigJson),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        startedAt: row.startedAt,
+        completedAt: row.completedAt,
+        lastImportedAt: row.lastImportedAt,
+        latestFactorySessionId: row.latestFactorySessionId,
+        latestFactoryArtifactDir: row.latestFactoryArtifactDir,
+        latestFactorySeenAt: row.latestFactorySeenAt,
+    };
+}
+function mapSnapshotRow(row) {
+    return {
+        snapshotId: row.snapshotId,
+        missionId: row.missionId,
+        source: row.source,
+        snapshot: parseJsonObject(row.snapshotJson) ?? {},
+        createdAt: row.createdAt,
+    };
+}
+function mapEventRow(row) {
+    return {
+        eventId: row.eventId,
+        missionId: row.missionId,
+        eventType: row.eventType,
+        source: row.source,
+        eventTime: row.eventTime,
+        payload: parseJsonObject(row.payloadJson) ?? {},
+        createdAt: row.createdAt,
+    };
+}
+function mapAttemptRow(row) {
+    return {
+        attemptId: row.attemptId,
+        missionId: row.missionId,
+        requestId: row.requestId,
+        attemptType: normalizeAttemptType(row.attemptType),
+        state: normalizeAttemptState(row.state),
+        nodeId: row.nodeId,
+        missionDir: row.missionDir,
+        promptPreview: row.promptPreview,
+        pid: row.pid,
+        exitCode: row.exitCode,
+        signal: row.signal,
+        error: row.error,
+        factorySessionId: row.factorySessionId,
+        factoryArtifactDir: row.factoryArtifactDir,
+        stdoutEventCount: row.stdoutEventCount,
+        stderrEventCount: row.stderrEventCount,
+        outputPreview: row.outputPreview,
+        lastOutputAt: row.lastOutputAt,
+        supersededBy: row.supersededBy ?? null,
+        supersessionReason: normalizeSupersessionReason(row.supersessionReason),
+        supersededAt: row.supersededAt ?? null,
+        createdAt: row.createdAt,
+        acceptedAt: row.acceptedAt,
+        completedAt: row.completedAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function mapFeatureRow(row) {
+    return {
+        featureId: row.featureId,
+        missionId: row.missionId,
+        milestone: row.milestone,
+        description: row.description,
+        skillName: row.skillName,
+        status: normalizeNativeFeatureStatus(row.status),
+        ordering: row.ordering,
+        preconditions: parseJsonStringArray(row.preconditionsJson),
+        expectedBehavior: parseJsonStringArray(row.expectedBehaviorJson),
+        retryCount: typeof row.retryCount === 'number' ? Math.max(0, row.retryCount) : 0,
+        isValidator: row.isValidator === 1,
+        handoff: parseJsonObject(row.handoffJson),
+        workerOutput: parseJsonObject(row.workerOutputJson),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function normalizeNativeFeatureStatus(value) {
+    if (value === 'pending'
+        || value === 'queued'
+        || value === 'running'
+        || value === 'completed'
+        || value === 'failed'
+        || value === 'skipped'
+        || value === 'cancelled') {
+        return value;
+    }
+    return 'pending';
+}
+function mapAssertionRow(row) {
+    return {
+        assertionId: row.assertionId,
+        missionId: row.missionId,
+        featureId: row.featureId,
+        assertionText: row.assertionText,
+        status: normalizeNativeAssertionStatus(row.status),
+        note: row.note,
+        evidence: row.evidence,
+        confidence: normalizeMissionTraceConfidence(row.confidence),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function normalizeMissionTraceConfidence(value) {
+    if (value === 'observed' || value === 'derived' || value === 'inferred' || value === 'unknown') {
+        return value;
+    }
+    return null;
+}
+function normalizeNativeAssertionStatus(value) {
+    if (value === 'pending' || value === 'passed' || value === 'failed' || value === 'blocked') {
+        return value;
+    }
+    return 'pending';
+}
+function mapInteractionRow(row) {
+    return {
+        interactionId: row.interactionId,
+        missionId: row.missionId,
+        prompt: row.prompt,
+        status: normalizeMissionInteractionStatus(row.status),
+        position: row.position,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function mapPlanRow(row) {
+    return {
+        missionId: row.missionId,
+        plan: parseJsonObject(row.planJson) ?? {},
+        version: row.version,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function mapMilestoneRow(row) {
+    return {
+        milestoneId: row.milestoneId,
+        missionId: row.missionId,
+        name: row.name,
+        status: normalizeMilestoneStatus(row.status),
+        ordering: row.ordering,
+        startedAt: row.startedAt,
+        completedAt: row.completedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function normalizeMilestoneStatus(value) {
+    if (value === 'pending'
+        || value === 'running'
+        || value === 'completed'
+        || value === 'failed'
+        || value === 'skipped') {
+        return value;
+    }
+    return 'pending';
+}
+function normalizeMissionInteractionStatus(value) {
+    if (value === 'queued' || value === 'delivered' || value === 'observed' || value === 'applied' || value === 'completed' || value === 'failed') {
+        return value;
+    }
+    return 'queued';
+}
+function parseJsonStringArray(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) && parsed.every((item) => typeof item === 'string')
+            ? parsed
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function countRows(values) {
+    const counts = {};
+    for (const value of values) {
+        const key = value || 'unknown';
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+}
+function normalizeMissionState(value) {
+    return ['draft', 'queued', 'running', 'paused', 'completed', 'failed', 'cancelled'].includes(value)
+        ? value
+        : 'draft';
+}
+function normalizeAttemptType(value) {
+    return ['run', 'session_continuation', 'active_interaction'].includes(value)
+        ? value
+        : 'run';
+}
+function normalizeAttemptState(value) {
+    return ['queued', 'running', 'completed', 'failed'].includes(value)
+        ? value
+        : 'queued';
+}
+function normalizeSupersessionReason(value) {
+    if (value === 'retry' || value === 'recovery' || value === 'orphan_cleanup')
+        return value;
+    return null;
+}
+function normalizeModelMode(value) {
+    return value === 'droid_default' ? 'droid_default' : 'platform_override';
+}
+function normalizeMissionRuntimeProvider(value) {
+    return value === 'droid_cli' || value === 'bigbang_native' ? value : null;
+}
+function normalizeMissionRuntimeProviderForUpdate(value, current) {
+    const normalized = normalizeMissionRuntimeProvider(value);
+    if (!normalized) {
+        throw new MissionServiceError(400, "runtimeProvider must be 'droid_cli' or 'bigbang_native'");
+    }
+    if (normalized !== current.runtimeProvider && isMissionRuntimeProviderImmutable(current.state)) {
+        throw new MissionServiceError(409, 'Runtime provider cannot be changed for terminal missions');
+    }
+    return normalized;
+}
+function isMissionRuntimeProviderImmutable(state) {
+    return state === 'failed' || state === 'completed' || state === 'paused' || state === 'cancelled';
+}
+function normalizeRequiredString(value, field) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized)
+        throw new MissionServiceError(400, `${field} is required`);
+    return normalized;
+}
+function normalizeOptionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function normalizeOptionalNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function normalizePromptPreview(value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized)
+        return null;
+    return normalized.length <= 2_000 ? normalized : `${normalized.slice(0, 2_000)}...`;
+}
+function normalizeOutputPreview(stream, value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized)
+        return null;
+    const collapsed = normalized.replace(/\s+/g, ' ').trim();
+    if (!collapsed)
+        return null;
+    const tagged = `${stream}: ${collapsed}`;
+    return tagged.length <= 2_000 ? tagged : `...${tagged.slice(-2_000)}`;
+}
+function asPayloadString(payload, key) {
+    return normalizeOptionalString(payload[key]);
+}
+function asPayloadNumber(payload, key) {
+    return normalizeOptionalNumber(payload[key]);
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function nextModelValue(request, key, current, modelMode) {
+    if (modelMode === 'droid_default')
+        return null;
+    if (hasOwn(request, key))
+        return normalizeOptionalString(request[key]) ?? DEFAULT_DROID_MODEL;
+    return current ?? DEFAULT_DROID_MODEL;
+}
+function collectChangedMissionFields(current, next) {
+    const scalarFields = [
+        'title',
+        'description',
+        'runtimeProvider',
+        'nodeId',
+        'workspacePath',
+        'missionDir',
+        'initiatorAgentId',
+        'controlConversationId',
+        'modelMode',
+        'orchestratorModel',
+        'workerModel',
+        'validatorModel',
+    ];
+    const changed = scalarFields.filter((field) => current[field] !== next[field]);
+    if (next.validationPolicy !== readValidationPolicy(current.effectiveModelConfig)) {
+        changed.push('validationPolicy');
+    }
+    if (next.validationTimeoutMs !== readValidationTimeoutMs(current.effectiveModelConfig)) {
+        changed.push('validationTimeoutMs');
+    }
+    if (JSON.stringify(next.retryPolicy) !== JSON.stringify(readRetryPolicy(current.effectiveModelConfig))) {
+        changed.push('retryPolicy');
+    }
+    return changed.sort();
+}
+function normalizeValidationPolicy(value) {
+    if (value === 'failOnFirst' || value === 'continueOnWarning')
+        return value;
+    if (value === null || value === undefined)
+        return null;
+    throw new MissionServiceError(400, "validationPolicy must be 'failOnFirst' or 'continueOnWarning'");
+}
+function normalizeValidationTimeoutMs(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0)
+        return Math.floor(value);
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return Math.floor(parsed);
+    }
+    throw new MissionServiceError(400, 'validationTimeoutMs must be a positive number');
+}
+function readValidationPolicy(config) {
+    const value = config?.validationPolicy;
+    if (value === 'failOnFirst' || value === 'continueOnWarning')
+        return value;
+    return null;
+}
+function readValidationTimeoutMs(config) {
+    const value = config?.validationTimeoutMs;
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0)
+        return Math.floor(value);
+    return null;
+}
+function normalizeRetryBackoff(value) {
+    if (value === 'exponential')
+        return 'exponential';
+    return 'fixed';
+}
+function normalizeRetryPolicy(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (!isPlainObject(value)) {
+        throw new MissionServiceError(400, 'retryPolicy must be an object');
+    }
+    const obj = value;
+    let maxRetries;
+    const maxRetriesRaw = obj.maxRetries;
+    if (typeof maxRetriesRaw === 'number' && Number.isFinite(maxRetriesRaw)) {
+        maxRetries = Math.max(0, Math.floor(maxRetriesRaw));
+    }
+    else if (typeof maxRetriesRaw === 'string' && maxRetriesRaw.trim() !== '') {
+        const parsed = Number(maxRetriesRaw);
+        if (Number.isFinite(parsed)) {
+            maxRetries = Math.max(0, Math.floor(parsed));
+        }
+        else {
+            throw new MissionServiceError(400, 'retryPolicy.maxRetries must be a non-negative number');
+        }
+    }
+    else if (maxRetriesRaw === null || maxRetriesRaw === undefined) {
+        maxRetries = 0;
+    }
+    else {
+        throw new MissionServiceError(400, 'retryPolicy.maxRetries must be a non-negative number');
+    }
+    const backoff = normalizeRetryBackoff(obj.backoff);
+    let baseDelayMs;
+    if (typeof obj.baseDelayMs === 'number' && Number.isFinite(obj.baseDelayMs) && obj.baseDelayMs >= 0) {
+        baseDelayMs = Math.floor(obj.baseDelayMs);
+    }
+    else if (typeof obj.baseDelayMs === 'string' && obj.baseDelayMs.trim() !== '') {
+        const parsed = Number(obj.baseDelayMs);
+        if (Number.isFinite(parsed) && parsed >= 0) {
+            baseDelayMs = Math.floor(parsed);
+        }
+    }
+    let maxDelayMs;
+    if (typeof obj.maxDelayMs === 'number' && Number.isFinite(obj.maxDelayMs) && obj.maxDelayMs >= 0) {
+        maxDelayMs = Math.floor(obj.maxDelayMs);
+    }
+    else if (typeof obj.maxDelayMs === 'string' && obj.maxDelayMs.trim() !== '') {
+        const parsed = Number(obj.maxDelayMs);
+        if (Number.isFinite(parsed) && parsed >= 0) {
+            maxDelayMs = Math.floor(parsed);
+        }
+    }
+    const policy = { maxRetries, backoff };
+    if (typeof baseDelayMs === 'number')
+        policy.baseDelayMs = baseDelayMs;
+    if (typeof maxDelayMs === 'number')
+        policy.maxDelayMs = maxDelayMs;
+    return policy;
+}
+function readRetryPolicy(config) {
+    const value = config?.retryPolicy;
+    if (!isPlainObject(value))
+        return DEFAULT_RETRY_POLICY;
+    const obj = value;
+    const maxRetriesRaw = obj.maxRetries;
+    const maxRetries = typeof maxRetriesRaw === 'number' && Number.isFinite(maxRetriesRaw)
+        ? Math.max(0, Math.floor(maxRetriesRaw))
+        : 0;
+    const backoff = normalizeRetryBackoff(obj.backoff);
+    const policy = { maxRetries, backoff };
+    if (typeof obj.baseDelayMs === 'number' && Number.isFinite(obj.baseDelayMs) && obj.baseDelayMs >= 0) {
+        policy.baseDelayMs = Math.floor(obj.baseDelayMs);
+    }
+    if (typeof obj.maxDelayMs === 'number' && Number.isFinite(obj.maxDelayMs) && obj.maxDelayMs >= 0) {
+        policy.maxDelayMs = Math.floor(obj.maxDelayMs);
+    }
+    return policy;
+}
+function buildEffectiveModelConfig(input) {
+    const config = { mode: input.mode };
+    if (input.validationPolicy) {
+        config.validationPolicy = input.validationPolicy;
+    }
+    if (typeof input.validationTimeoutMs === 'number') {
+        config.validationTimeoutMs = input.validationTimeoutMs;
+    }
+    const retryPolicy = input.retryPolicy ?? DEFAULT_RETRY_POLICY;
+    if (retryPolicy.maxRetries > 0 || retryPolicy.backoff !== 'fixed') {
+        config.retryPolicy = retryPolicy;
+    }
+    return config;
+}
+function redactRuntimePayload(payload) {
+    return redactFallbackSecrets(payload);
+}
+function redactFallbackSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactFallbackSecrets);
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            out[key] = isSecretLikeKey(key) ? '[redacted]' : redactFallbackSecrets(item);
+        }
+        return out;
+    }
+    if (typeof value === 'string')
+        return redactSecretLikeText(value);
+    return value;
+}
+function isSecretLikeKey(key) {
+    return /(api[_-]?key|secret|token|password|authorization|credential|bearer)/i.test(key);
+}
+function redactSecretLikeText(value) {
+    return value
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, 'Bearer [redacted]')
+        .replace(/\b(?:sk|sk-ant|sk-proj|ghp|github_pat|xox[baprs])[-_A-Za-z0-9]{8,}\b/g, '[redacted]');
+}
+function countFallbackEvents(events) {
+    const counts = {};
+    for (const event of events) {
+        const type = typeof event.type === 'string' && event.type ? event.type : 'unknown';
+        counts[type] = (counts[type] ?? 0) + 1;
+    }
+    return counts;
+}
+function normalizeSnapshotPayload(value) {
+    if (isPlainObject(value))
+        return value;
+    throw new MissionServiceError(400, 'snapshot must be an object');
+}
+export function resolveTrustedFactoryArtifactDir(factorySessionId, factoryArtifactDir) {
+    const sessionId = normalizeOptionalString(factorySessionId);
+    const artifactDir = normalizeOptionalString(factoryArtifactDir);
+    if (!sessionId || !artifactDir)
+        return null;
+    if (!isSafeFactorySessionId(sessionId))
+        return null;
+    const resolved = path.resolve(artifactDir);
+    const factoryMissionsRoot = path.resolve(homedir(), '.factory', 'missions');
+    const artifactSessionId = path.basename(resolved);
+    if (path.dirname(resolved) !== factoryMissionsRoot)
+        return null;
+    if (artifactSessionId !== sessionId)
+        return null;
+    return resolved;
+}
+function isSafeFactorySessionId(value) {
+    return /^[A-Za-z0-9._-]+$/.test(value) && /[A-Za-z0-9_-]/.test(value);
+}
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function parseJsonObject(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAcceptedPhase1ClosureDecisionEvent(event) {
+    const payload = event.payload ?? {};
+    return event.eventType === 'mission_phase1_closure_decision'
+        && normalizeOptionalString(payload.phase) === 'phase1'
+        && normalizeOptionalString(payload.decision) === 'accepted_paused_partial_boundary';
+}
+function readObservedDroidState(snapshot, events) {
+    const snapshotData = snapshot?.snapshot ?? {};
+    const overviewState = normalizeOptionalString(asRecordValue(snapshotData.overview).state);
+    const snapshotTime = snapshot?.createdAt ?? null;
+    let latest = overviewState
+        ? { state: overviewState, eventTime: snapshotTime }
+        : { state: null, eventTime: null };
+    const timelineEvents = asRecordArray(asRecordValue(snapshotData.timeline).events);
+    const pausedTimeline = timelineEvents.find((event) => normalizeOptionalString(event.type)?.includes('paused'));
+    if (pausedTimeline && latest.state == null) {
+        latest = { state: 'paused', eventTime: snapshotTime };
+    }
+    for (const event of events) {
+        const state = readObservedDroidStateFromEvent(event);
+        if (!state)
+            continue;
+        if (latest.eventTime == null || event.eventTime >= latest.eventTime) {
+            latest = { state, eventTime: event.eventTime };
+        }
+    }
+    return latest.state;
+}
+function readObservedDroidStateFromEvent(event) {
+    if (event.eventType === 'mission_run_accepted')
+        return 'running';
+    if (event.eventType === 'mission_completed')
+        return 'completed';
+    if (event.eventType === 'mission_failed')
+        return 'failed';
+    if (event.eventType !== 'mission_progress')
+        return null;
+    const payload = asRecordValue(event.payload);
+    const type = normalizeOptionalString(payload.type) ?? normalizeOptionalString(asRecordValue(payload.droidEvent).type);
+    if (type?.includes('paused'))
+        return 'paused';
+    if (type?.includes('completed'))
+        return 'completed';
+    if (type?.includes('failed'))
+        return 'failed';
+    if (type === 'mission_run_started' || type === 'mission_resumed' || type === 'worker_started')
+        return 'running';
+    return null;
+}
+function readLatestInteractionStatus(events) {
+    const latestByRequest = new Map();
+    for (const event of events) {
+        const status = readInteractionStatusFromEvent(event.eventType);
+        if (!status)
+            continue;
+        const payload = asRecordValue(event.payload);
+        const requestId = normalizeOptionalString(payload.requestId) ?? `event:${event.eventId}`;
+        const current = latestByRequest.get(requestId);
+        if (!current || event.eventTime >= current.eventTime) {
+            latestByRequest.set(requestId, { eventTime: event.eventTime, status });
+        }
+    }
+    const latest = Array.from(latestByRequest.values()).sort((left, right) => right.eventTime - left.eventTime)[0];
+    return latest?.status ?? null;
+}
+function readInteractionStatusFromEvent(eventType) {
+    if (eventType === 'mission_continue_queued' || eventType === 'mission_interaction_queued')
+        return 'queued';
+    if (eventType === 'mission_interaction_accepted')
+        return 'accepted';
+    if (eventType === 'mission_interaction_delivered')
+        return 'delivered';
+    if (eventType === 'mission_interaction_completed')
+        return 'completed';
+    if (eventType === 'mission_interaction_failed' || eventType === 'mission_interaction_start_failed' || eventType === 'mission_continue_start_failed')
+        return 'failed';
+    return null;
+}
+function readArtifactMode(snapshot) {
+    if (Object.keys(snapshot).length === 0)
+        return 'pending';
+    const overview = asRecordValue(snapshot.overview);
+    const artifacts = asRecordValue(snapshot.artifacts);
+    if (normalizeOptionalString(snapshot.droidArtifactImport) === 'runtime_fallback' || normalizeOptionalString(overview.droidArtifactImport) === 'failed') {
+        return 'runtime_fallback';
+    }
+    if (overview.reportOnly === true)
+        return 'report_only';
+    const features = asRecordArray(asRecordValue(snapshot.features).items);
+    const timeline = asRecordArray(asRecordValue(snapshot.timeline).events);
+    const handoffs = asRecordArray(asRecordValue(snapshot.handoffs).items);
+    const validation = asRecordArray(asRecordValue(snapshot.validation).assertions);
+    const reports = asRecordArray(artifacts.reports);
+    if (features.length > 0 || timeline.length > 0 || handoffs.length > 0 || validation.length > 0)
+        return 'structured';
+    if (reports.length > 0)
+        return 'report_only';
+    return 'sparse';
+}
+function asRecordValue(value) {
+    return isPlainObject(value) ? value : {};
+}
+function asRecordArray(value) {
+    return Array.isArray(value) ? value.filter(isPlainObject) : [];
+}
+function assertDroidSnapshotImportable(snapshot, missionDir) {
+    const anomalies = Array.isArray(snapshot.anomalies) ? snapshot.anomalies : [];
+    const blocking = anomalies.filter((item) => {
+        return isPlainObject(item)
+            && (item.type === 'missing_required_artifact' || item.type === 'invalid_required_artifact');
+    });
+    if (blocking.length > 0) {
+        const overview = isPlainObject(snapshot.overview) ? snapshot.overview : null;
+        const reportOnly = overview?.reportOnly === true && typeof overview.reportCount === 'number' && overview.reportCount > 0;
+        if (!reportOnly) {
+            throw new MissionServiceError(400, `Droid mission artifacts are incomplete or invalid: ${missionDir}`);
+        }
+    }
+    const overview = isPlainObject(snapshot.overview) ? snapshot.overview : null;
+    if (!normalizeOptionalString(overview?.missionId) || !normalizeOptionalString(overview?.state)) {
+        throw new MissionServiceError(400, `Droid mission state is incomplete: ${missionDir}`);
+    }
+}