@bbigbang/core 0.1.0

package/dist/services/nativeMissionOrchestrator.js

@@ -0,0 +1,2045 @@
+import { randomUUID } from 'node:crypto';
+import { readdirSync } from 'node:fs';
+import { MissionServiceError } from './missionService.js';
+import { parseMissionBrief } from './nativeMissionBriefParser.js';
+import { NativeMissionValidationRunner, } from './nativeMissionValidationRunner.js';
+export class NativeMissionOrchestrator {
+    missionService;
+    workerBroker;
+    validationRunner;
+    activeMissions = new Set();
+    pausedMissions = new Set();
+    runningFeatures = new Map();
+    currentMilestones = new Map();
+    constructor(params) {
+        this.missionService = params.missionService;
+        this.workerBroker = params.workerBroker;
+        this.validationRunner =
+            params.validationRunner ??
+                new NativeMissionValidationRunner({ missionService: params.missionService });
+    }
+    isMissionActive(missionId) {
+        return this.activeMissions.has(missionId) || this.workerBroker.hasActiveMission(missionId);
+    }
+    recordRuntimeEvent(missionId, eventType, payload, source = 'platform') {
+        this.missionService.recordMissionRuntimeEvent({
+            missionId,
+            eventType,
+            source,
+            eventTime: Date.now(),
+            payload,
+        });
+    }
+    emitOrchestratorDecision(missionId, decisionType, details) {
+        this.recordRuntimeEvent(missionId, 'orchestrator_decision', {
+            decisionType,
+            ...details,
+        });
+    }
+    emitPlanningEvents(missionId, requestId, features, assertionCount) {
+        const milestoneSet = new Set(features.map((feature) => feature.milestone));
+        this.recordRuntimeEvent(missionId, 'mission_planning_started', {
+            requestId,
+            featureCount: features.length,
+            milestoneCount: milestoneSet.size,
+        });
+        this.recordRuntimeEvent(missionId, 'mission_planning_completed', {
+            requestId,
+            featureCount: features.length,
+            milestoneCount: milestoneSet.size,
+            assertionCount,
+            plan: features.map((feature) => ({
+                featureId: feature.featureId,
+                milestone: feature.milestone,
+                description: feature.description,
+                ordering: feature.ordering,
+                preconditions: feature.preconditions,
+                expectedBehavior: feature.expectedBehavior,
+            })),
+        });
+    }
+    persistPlanAndMilestones(missionId, requestId, features, assertionCount) {
+        const milestoneNames = [...new Set(features.map((feature) => feature.milestone))];
+        const milestoneOrdering = new Map();
+        for (const feature of features) {
+            if (!milestoneOrdering.has(feature.milestone) || feature.ordering < milestoneOrdering.get(feature.milestone)) {
+                milestoneOrdering.set(feature.milestone, feature.ordering);
+            }
+        }
+        const plan = this.missionService.replaceMissionPlan({
+            missionId,
+            userId: '',
+            isAdmin: true,
+            plan: {
+                requestId,
+                version: (this.missionService.getMissionPlan({ missionId, userId: '', isAdmin: true })?.version ?? 0) + 1,
+                featureCount: features.length,
+                milestoneCount: milestoneNames.length,
+                assertionCount,
+                features: features.map((feature) => ({
+                    featureId: feature.featureId,
+                    milestone: feature.milestone,
+                    description: feature.description,
+                    skillName: feature.skillName,
+                    ordering: feature.ordering,
+                    preconditions: feature.preconditions,
+                    expectedBehavior: feature.expectedBehavior,
+                })),
+                milestones: milestoneNames.map((name) => ({
+                    name,
+                    ordering: milestoneOrdering.get(name) ?? 0,
+                })),
+            },
+        });
+        const existingMilestones = this.missionService.listMissionMilestones({ missionId, userId: '', isAdmin: true });
+        const milestoneByName = new Map(existingMilestones.map((m) => [m.name, m]));
+        const milestones = this.missionService.replaceMissionMilestones({
+            missionId,
+            userId: '',
+            isAdmin: true,
+            milestones: milestoneNames.map((name, index) => {
+                const existing = milestoneByName.get(name);
+                return {
+                    milestoneId: existing?.milestoneId,
+                    name,
+                    status: existing?.status ?? 'pending',
+                    ordering: milestoneOrdering.get(name) ?? index,
+                    startedAt: existing?.startedAt,
+                    completedAt: existing?.completedAt,
+                };
+            }),
+        });
+        this.emitOrchestratorDecision(missionId, 'plan_accepted', {
+            requestId,
+            planVersion: plan.version,
+            featureCount: features.length,
+            milestoneCount: milestoneNames.length,
+            assertionCount,
+        });
+        return { plan, milestones };
+    }
+    emitMilestoneStartedIfNeeded(missionId, milestone, featureId) {
+        const current = this.currentMilestones.get(missionId);
+        if (current === milestone)
+            return;
+        this.currentMilestones.set(missionId, milestone);
+        const milestones = this.missionService.listMissionMilestones({ missionId, userId: '', isAdmin: true });
+        const milestoneRow = milestones.find((m) => m.name === milestone);
+        if (milestoneRow && milestoneRow.status !== 'running' && milestoneRow.status !== 'completed' && milestoneRow.status !== 'failed') {
+            this.missionService.updateMissionMilestoneStatus({
+                missionId,
+                milestoneId: milestoneRow.milestoneId,
+                status: 'running',
+                startedAt: Date.now(),
+            });
+        }
+        this.recordRuntimeEvent(missionId, 'milestone_started', {
+            milestone,
+            featureId,
+        });
+        this.emitOrchestratorDecision(missionId, 'milestone_started', {
+            milestone,
+            featureId,
+            milestoneId: milestoneRow?.milestoneId,
+        });
+    }
+    emitMilestoneCompletedIfNeeded(missionId, milestone) {
+        const features = this.missionService.listMissionFeatures({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const milestoneFeatures = features.filter((feature) => feature.milestone === milestone);
+        const terminalStatuses = ['completed', 'failed', 'skipped', 'cancelled'];
+        const allTerminal = milestoneFeatures.length > 0 && milestoneFeatures.every((feature) => terminalStatuses.includes(feature.status));
+        if (!allTerminal)
+            return;
+        const statusCounts = {};
+        for (const feature of milestoneFeatures) {
+            statusCounts[feature.status] = (statusCounts[feature.status] ?? 0) + 1;
+        }
+        const milestones = this.missionService.listMissionMilestones({ missionId, userId: '', isAdmin: true });
+        const milestoneRow = milestones.find((m) => m.name === milestone);
+        if (milestoneRow) {
+            let finalStatus = 'completed';
+            if (statusCounts.failed > 0 || statusCounts.cancelled > 0) {
+                finalStatus = 'failed';
+            }
+            else if (statusCounts.skipped > 0 && statusCounts.completed === 0) {
+                finalStatus = 'skipped';
+            }
+            this.missionService.updateMissionMilestoneStatus({
+                missionId,
+                milestoneId: milestoneRow.milestoneId,
+                status: finalStatus,
+                completedAt: Date.now(),
+            });
+        }
+        this.recordRuntimeEvent(missionId, 'milestone_completed', {
+            milestone,
+            featureCount: milestoneFeatures.length,
+            statusCounts,
+        });
+        this.emitOrchestratorDecision(missionId, 'milestone_completed', {
+            milestone,
+            featureCount: milestoneFeatures.length,
+            statusCounts,
+            milestoneId: milestoneRow?.milestoneId,
+        });
+    }
+    async startMission(input) {
+        const mission = this.requireMission(input);
+        if (mission.runtimeProvider !== 'bigbang_native') {
+            throw this.error(400, 'Mission does not use the native runtime provider');
+        }
+        if (mission.state !== 'draft') {
+            throw this.error(409, 'Mission is already active or terminal');
+        }
+        if (this.activeMissions.has(mission.missionId) || this.workerBroker.hasActiveMission(mission.missionId)) {
+            throw this.error(409, 'Mission is already queued or running');
+        }
+        const nodeId = input.nodeId ?? mission.nodeId;
+        if (!nodeId)
+            throw this.error(400, 'nodeId is required');
+        if (!mission.missionDir)
+            throw this.error(400, 'missionDir is required');
+        this.activeMissions.add(mission.missionId);
+        try {
+            const requestId = randomUUID();
+            const queued = this.missionService.startMission({
+                missionId: mission.missionId,
+                userId: input.userId,
+                isAdmin: input.isAdmin,
+                nodeId,
+                eventPayload: { requestId, runtimeProvider: 'bigbang_native' },
+            });
+            const attempt = this.missionService.createMissionAttempt({
+                missionId: mission.missionId,
+                requestId,
+                attemptType: 'run',
+                nodeId,
+                missionDir: mission.missionDir,
+                prompt: mission.description || mission.title,
+            });
+            const parsedFeatures = parseMissionBrief(mission.description);
+            this.missionService.replaceMissionFeatures({
+                missionId: mission.missionId,
+                userId: input.userId,
+                isAdmin: input.isAdmin,
+                features: parsedFeatures.map((feature, index) => ({
+                    featureId: feature.featureId,
+                    milestone: feature.milestone,
+                    description: feature.description,
+                    skillName: feature.skillName,
+                    status: feature.status,
+                    ordering: feature.ordering ?? index,
+                    preconditions: feature.preconditions,
+                    expectedBehavior: feature.expectedBehavior,
+                })),
+            });
+            const generatedAssertions = this.missionService.generateValidationAssertionsFromFeatures({
+                missionId: mission.missionId,
+                userId: input.userId,
+                isAdmin: input.isAdmin,
+            });
+            const persistedFeatures = this.missionService.listMissionFeatures({
+                missionId: mission.missionId,
+                userId: input.userId,
+                isAdmin: input.isAdmin,
+            });
+            this.emitPlanningEvents(mission.missionId, requestId, persistedFeatures, generatedAssertions.length);
+            this.persistPlanAndMilestones(mission.missionId, requestId, persistedFeatures, generatedAssertions.length);
+            this.missionService.recordMissionRuntimeEvent({
+                missionId: mission.missionId,
+                eventType: 'mission_features_parsed',
+                source: 'platform',
+                eventTime: Date.now(),
+                payload: { requestId, featureCount: parsedFeatures.length, assertionCount: generatedAssertions.length },
+            });
+            this.missionService.recordMissionRuntimeEvent({
+                missionId: mission.missionId,
+                eventType: 'mission_assertions_generated',
+                source: 'platform',
+                eventTime: Date.now(),
+                payload: { requestId, assertionCount: generatedAssertions.length },
+            });
+            let accepted;
+            try {
+                accepted = await this.workerBroker.runMission(nodeId, queued, { requestId, attemptId: attempt.attemptId });
+            }
+            catch (error) {
+                const message = String(error?.message ?? error);
+                this.missionService.recordMissionRuntimeEvent({
+                    missionId: mission.missionId,
+                    eventType: 'mission_attempt_start_failed',
+                    source: 'platform',
+                    eventTime: Date.now(),
+                    payload: { requestId, error: message },
+                });
+                this.missionService.markMissionStartFailed({
+                    missionId: mission.missionId,
+                    error: message,
+                    requestId,
+                });
+                // Persist a partial snapshot even when the mission fails before any
+                // feature workers run so the UI has a normalized record of the failed
+                // start.
+                this.persistMissionSnapshot(mission.missionId);
+                throw error;
+            }
+            this.missionService.markMissionAccepted({
+                missionId: mission.missionId,
+                missionDir: mission.missionDir,
+                pid: accepted.pid,
+                requestId,
+            });
+            // Begin the ordered feature queue. For missions with no features this
+            // completes the mission immediately.
+            await this.dispatchNextFeature(mission.missionId, nodeId, mission.missionDir, input.userId, input.isAdmin);
+            const updated = this.missionService.getMission({
+                missionId: mission.missionId,
+                userId: input.userId,
+                isAdmin: input.isAdmin,
+            });
+            if (!updated)
+                throw this.error(404, 'Mission not found');
+            return {
+                mission: updated,
+                accepted: {
+                    requestId: accepted.requestId,
+                    missionId: accepted.missionId,
+                    missionDir: accepted.missionDir,
+                    pid: accepted.pid,
+                },
+            };
+        }
+        catch (error) {
+            this.activeMissions.delete(mission.missionId);
+            throw error;
+        }
+    }
+    pauseMission(input) {
+        const running = this.runningFeatures.get(input.missionId);
+        const features = this.missionService.listMissionFeatures({
+            missionId: input.missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const activeFeature = running ??
+            features
+                .filter((feature) => feature.status === 'running')
+                .map((feature) => ({
+                requestId: '',
+                featureId: feature.featureId,
+                nodeId: '',
+                attemptId: null,
+                milestone: feature.milestone,
+            }))[0] ??
+            null;
+        const nextFeature = activeFeature
+            ? null
+            : this.missionService.getNextMissionFeature({ missionId: input.missionId });
+        const milestones = this.missionService.listMissionMilestones({
+            missionId: input.missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const currentMilestoneRow = milestones.find((milestone) => milestone.status === 'running');
+        const effectivePausePoint = activeFeature
+            ? {
+                featureId: activeFeature.featureId,
+                milestone: activeFeature.milestone,
+                milestoneId: milestones.find((milestone) => milestone.name === activeFeature.milestone)?.milestoneId ?? null,
+                point: 'running_feature',
+            }
+            : nextFeature
+                ? {
+                    featureId: nextFeature.featureId,
+                    milestone: nextFeature.milestone,
+                    milestoneId: milestones.find((milestone) => milestone.name === nextFeature.milestone)?.milestoneId ?? null,
+                    point: 'next_pending_feature',
+                }
+                : {
+                    featureId: null,
+                    milestone: currentMilestoneRow?.name ?? null,
+                    milestoneId: currentMilestoneRow?.milestoneId ?? null,
+                    point: 'end_of_queue',
+                };
+        this.recordRuntimeEvent(input.missionId, 'mission_pause_requested', {
+            reason: input.reason ?? null,
+            effectivePausePoint,
+        });
+        try {
+            const mission = this.missionService.pauseMission({
+                missionId: input.missionId,
+                userId: input.userId,
+                isAdmin: input.isAdmin,
+                reason: input.reason,
+                effectivePausePoint,
+            });
+            this.recordRuntimeEvent(input.missionId, 'mission_pause_effective', {
+                effectivePausePoint,
+            });
+            this.pausedMissions.add(input.missionId);
+            return mission;
+        }
+        catch (error) {
+            // If the pause transition fails (e.g. mission already paused), only the
+            // requested event is emitted so the trace shows the intent without a
+            // spurious effective event.
+            throw error;
+        }
+    }
+    resumeMission(input) {
+        this.recordRuntimeEvent(input.missionId, 'mission_resume_requested', {
+            missionId: input.missionId,
+        });
+        try {
+            const mission = this.missionService.resumeMission(input);
+            this.recordRuntimeEvent(input.missionId, 'mission_resume_effective', {
+                missionId: input.missionId,
+                state: mission.state,
+            });
+            this.pausedMissions.delete(input.missionId);
+            // If no feature is currently running, continue the queue.
+            const running = this.runningFeatures.get(input.missionId);
+            if (!running) {
+                const missionDir = mission.missionDir;
+                const nodeId = mission.nodeId;
+                if (missionDir && nodeId && mission.state === 'running') {
+                    void this.advanceQueue(input.missionId, nodeId, missionDir);
+                }
+            }
+            return mission;
+        }
+        catch (error) {
+            // If the resume transition fails (e.g. mission not paused), only the
+            // requested event is emitted.
+            throw error;
+        }
+    }
+    async queueInteraction(input) {
+        const mission = this.requireMission(input);
+        if (mission.runtimeProvider !== 'bigbang_native') {
+            throw this.error(400, 'Mission does not use the native runtime provider');
+        }
+        const prompt = input.prompt.trim();
+        if (!prompt) {
+            throw this.error(400, 'prompt is required');
+        }
+        if (!['queued', 'running', 'paused'].includes(mission.state)) {
+            throw this.error(409, 'Mission is not active');
+        }
+        const interaction = this.missionService.queueMissionInteraction({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+            prompt,
+        });
+        // Deliver queued interactions to the orchestrator immediately. This does
+        // not abort the currently running feature worker; it only updates the
+        // orchestrator context so subsequent features see the follow-up.
+        const deliveredIds = this.deliverPendingInteractions(input.missionId);
+        if (deliveredIds.length > 0) {
+            this.recordRuntimeEvent(input.missionId, 'retry_scheduled', {
+                interactionIds: deliveredIds,
+                reason: 'follow_up_received',
+                retryTarget: 'validation_and_planning',
+            });
+        }
+        // Handle explicit follow-up intents: re-validation or plan amendment.
+        const amendmentAnalysis = this.analyzeFollowUpAmendment(input.prompt);
+        if (amendmentAnalysis.intent === 'revalidate') {
+            const revalidation = await this.revalidateMission(input.missionId, deliveredIds);
+            this.emitOrchestratorDecision(input.missionId, 'follow_up_handled', {
+                interactionIds: deliveredIds,
+                action: 'validation_retriggered',
+                resetFeatureCount: revalidation.resetFeatureCount,
+                evaluatedMilestones: revalidation.evaluatedMilestones,
+            });
+        }
+        else if (amendmentAnalysis.intent === 'plan_amendment'
+            || amendmentAnalysis.intent === 'append_natural') {
+            const amendment = this.applyFollowUpPlanAmendment(input.missionId, amendmentAnalysis.features, deliveredIds);
+            this.emitOrchestratorDecision(input.missionId, 'follow_up_handled', {
+                interactionIds: deliveredIds,
+                action: 'plan_modified',
+                modified: amendment.modified,
+                added: amendment.added,
+                modifiedFeatureIds: amendment.modifiedFeatureIds,
+                addedFeatureIds: amendment.addedFeatureIds,
+            });
+        }
+        else {
+            for (const interactionId of deliveredIds) {
+                this.missionService.updateMissionInteractionStatus({
+                    missionId: input.missionId,
+                    interactionId,
+                    status: 'completed',
+                });
+            }
+            this.emitOrchestratorDecision(input.missionId, 'follow_up_handled', {
+                interactionIds: deliveredIds,
+                action: 'contextual_guidance',
+            });
+        }
+        const updatedInteraction = this.missionService.listMissionInteractions({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        }).find((i) => i.interactionId === interaction.interactionId);
+        const updated = this.missionService.getMission({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        if (!updated)
+            throw this.error(404, 'Mission not found');
+        return { mission: updated, interaction: updatedInteraction ?? interaction };
+    }
+    deliverPendingInteractions(missionId) {
+        const pending = this.missionService.listMissionInteractions({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        }).filter((interaction) => interaction.status === 'queued');
+        const deliveredIds = [];
+        for (const interaction of pending) {
+            this.missionService.markMissionInteractionDelivered({
+                missionId,
+                interactionId: interaction.interactionId,
+            });
+            deliveredIds.push(interaction.interactionId);
+        }
+        // Transition delivered interactions to observed and emit a lifecycle
+        // event for each one. This is only done when the delivery loop succeeds
+        // so that no observed events are recorded for a failed delivery.
+        for (const interactionId of deliveredIds) {
+            this.missionService.updateMissionInteractionStatus({
+                missionId,
+                interactionId,
+                status: 'observed',
+            });
+            this.recordRuntimeEvent(missionId, 'mission_interaction_observed', {
+                interactionId,
+                missionId,
+            });
+        }
+        return deliveredIds;
+    }
+    analyzeFollowUpAmendment(prompt) {
+        const lower = prompt.toLowerCase();
+        const revalidateKeywords = [
+            're-validate',
+            'revalidate',
+            'validate again',
+            'reevaluate',
+            're-evaluate',
+            'check assertions again',
+            'run validation again',
+            're-run validation',
+            'validate the completed features',
+            'revalidate the results',
+        ];
+        if (revalidateKeywords.some((keyword) => lower.includes(keyword))) {
+            return { intent: 'revalidate' };
+        }
+        const hasStructure = /^#{2,3}\s+/m.test(prompt.trim());
+        if (hasStructure) {
+            const parsedFeatures = parseMissionBrief(prompt);
+            if (parsedFeatures.length > 0) {
+                return { intent: 'plan_amendment', features: parsedFeatures };
+            }
+        }
+        // Natural-language append intent: "Add a feature to ...", "Add feature: ...",
+        // "Please add a new feature that ...", etc.
+        const appendPattern = /^(?:please\s+)?(?:add|append|include|create)\s+(?:a\s+)?(?:new\s+)?feature\b(?:\s*[:,-]\s*|\s+to\s+|\s+for\s+|\s+that\s+|\s+which\s+|\s+)([\s\S]+)$/i;
+        const appendMatch = prompt.match(appendPattern);
+        if (appendMatch && appendMatch[1]?.trim()) {
+            return {
+                intent: 'append_natural',
+                features: [
+                    {
+                        featureId: randomUUID(),
+                        milestone: 'Follow-up',
+                        description: appendMatch[1].trim(),
+                        skillName: null,
+                        status: 'pending',
+                        ordering: 0,
+                        retryCount: 0,
+                        preconditions: [],
+                        expectedBehavior: [],
+                    },
+                ],
+            };
+        }
+        return { intent: 'contextual_guidance' };
+    }
+    async revalidateMission(missionId, interactionIds = []) {
+        const features = this.missionService.listMissionFeatures({ missionId, userId: '', isAdmin: true });
+        const completedFeatures = features.filter((feature) => feature.status === 'completed' && !feature.isValidator);
+        if (completedFeatures.length > 0) {
+            this.missionService.resetMissionValidationAssertionsByFeatureStatus({
+                missionId,
+                userId: '',
+                isAdmin: true,
+                featureStatus: 'completed',
+            });
+        }
+        const evaluatedMilestones = [...new Set(completedFeatures.map((feature) => feature.milestone))];
+        this.emitOrchestratorDecision(missionId, 'validation_retriggered', {
+            reason: 'follow_up_request',
+            resetScope: 'completed_features',
+            resetFeatureCount: completedFeatures.length,
+            evaluatedMilestones,
+        });
+        const progress = await this.runPendingMilestoneValidations(missionId);
+        if (progress.halted) {
+            this.activeMissions.delete(missionId);
+            this.pausedMissions.delete(missionId);
+        }
+        for (const interactionId of interactionIds) {
+            this.missionService.updateMissionInteractionStatus({
+                missionId,
+                interactionId,
+                status: 'completed',
+            });
+        }
+        if (interactionIds.length > 0) {
+            this.recordRuntimeEvent(missionId, 'mission_interaction_applied', {
+                action: 'revalidated',
+                interactionIds,
+                resetFeatureCount: completedFeatures.length,
+            });
+        }
+        return { resetFeatureCount: completedFeatures.length, evaluatedMilestones };
+    }
+    applyFollowUpPlanAmendment(missionId, parsedFeatures, interactionIds = []) {
+        const allFeatures = this.missionService.listMissionFeatures({ missionId, userId: '', isAdmin: true });
+        const pendingFeatures = allFeatures.filter((feature) => feature.status === 'pending');
+        // Group parsed features and pending features by milestone so we can align
+        // them by sequential position. This allows a follow-up to update a pending
+        // feature even when its description changes.
+        const parsedByMilestone = groupFeaturesByMilestone(parsedFeatures);
+        const pendingByMilestone = groupFeaturesByMilestone(pendingFeatures);
+        let modified = 0;
+        let added = 0;
+        const now = Date.now();
+        const pendingReplacements = new Map();
+        for (const [milestone, parsedList] of parsedByMilestone) {
+            const pendingList = pendingByMilestone.get(milestone) ?? [];
+            for (let index = 0; index < parsedList.length; index += 1) {
+                const parsed = parsedList[index];
+                const pending = pendingList[index];
+                if (pending) {
+                    pendingReplacements.set(pending.featureId, parsed);
+                    modified += 1;
+                }
+                else {
+                    added += 1;
+                }
+            }
+        }
+        if (modified === 0 && added === 0) {
+            return { modified: 0, added: 0, modifiedFeatureIds: [], addedFeatureIds: [] };
+        }
+        // Preserve the original milestone dispatch order inferred from existing
+        // features. New milestones introduced by the amendment are appended at
+        // the end.
+        const milestoneMinOrdering = new Map();
+        for (const feature of allFeatures) {
+            const current = milestoneMinOrdering.get(feature.milestone);
+            if (current === undefined || feature.ordering < current) {
+                milestoneMinOrdering.set(feature.milestone, feature.ordering);
+            }
+        }
+        const orderedMilestoneNames = [...milestoneMinOrdering.entries()]
+            .sort((left, right) => left[1] - right[1])
+            .map(([name]) => name);
+        // Identify parsed features that are genuinely new (not matched to an
+        // existing pending feature and not already present by description).
+        const newParsedFeatures = [];
+        for (const parsed of parsedFeatures) {
+            const alreadyMatched = [...pendingReplacements.values()].some((amended) => amended.description.trim().toLowerCase() === parsed.description.trim().toLowerCase());
+            if (alreadyMatched)
+                continue;
+            const existing = allFeatures.find((f) => f.description.trim().toLowerCase() === parsed.description.trim().toLowerCase());
+            if (existing)
+                continue;
+            newParsedFeatures.push(parsed);
+        }
+        // Build the feature list preserving original milestone order and feature
+        // order within each milestone. Replace matched pending features in-place,
+        // append new features for an existing milestone at the end of that
+        // milestone, and append new milestones at the very end.
+        const featuresByMilestone = groupFeaturesByMilestone(allFeatures);
+        const nextFeatures = [];
+        for (const milestone of orderedMilestoneNames) {
+            const milestoneFeatures = featuresByMilestone.get(milestone) ?? [];
+            for (const feature of milestoneFeatures) {
+                const amended = feature.status === 'pending' ? pendingReplacements.get(feature.featureId) : undefined;
+                if (amended) {
+                    nextFeatures.push({
+                        featureId: feature.featureId,
+                        milestone: amended.milestone,
+                        description: amended.description,
+                        skillName: amended.skillName,
+                        status: 'pending',
+                        ordering: feature.ordering,
+                        preconditions: amended.preconditions,
+                        expectedBehavior: amended.expectedBehavior,
+                        handoff: null,
+                    });
+                }
+                else {
+                    nextFeatures.push({
+                        featureId: feature.featureId,
+                        milestone: feature.milestone,
+                        description: feature.description,
+                        skillName: feature.skillName,
+                        status: feature.status,
+                        ordering: feature.ordering,
+                        preconditions: feature.preconditions,
+                        expectedBehavior: feature.expectedBehavior,
+                        handoff: feature.handoff ?? null,
+                    });
+                }
+            }
+            // Append new features for this existing milestone at its end.
+            for (const parsed of newParsedFeatures) {
+                if (parsed.milestone !== milestone)
+                    continue;
+                nextFeatures.push({
+                    featureId: parsed.featureId,
+                    milestone: parsed.milestone,
+                    description: parsed.description,
+                    skillName: parsed.skillName,
+                    status: 'pending',
+                    ordering: 0,
+                    preconditions: parsed.preconditions,
+                    expectedBehavior: parsed.expectedBehavior,
+                    handoff: null,
+                });
+            }
+        }
+        // New milestones are appended at the end in the order they first appear
+        // in the parsed amendment.
+        const existingMilestoneNames = new Set(orderedMilestoneNames);
+        const newMilestones = [...new Map(parsedFeatures.map((f) => [f.milestone, true])).keys()].filter((milestone) => !existingMilestoneNames.has(milestone));
+        for (const milestone of newMilestones) {
+            for (const parsed of newParsedFeatures) {
+                if (parsed.milestone !== milestone)
+                    continue;
+                nextFeatures.push({
+                    featureId: parsed.featureId,
+                    milestone: parsed.milestone,
+                    description: parsed.description,
+                    skillName: parsed.skillName,
+                    status: 'pending',
+                    ordering: 0,
+                    preconditions: parsed.preconditions,
+                    expectedBehavior: parsed.expectedBehavior,
+                    handoff: null,
+                });
+            }
+        }
+        // Reassign ordering sequentially to reflect the final preserved order.
+        for (let index = 0; index < nextFeatures.length; index += 1) {
+            nextFeatures[index].ordering = index;
+        }
+        this.missionService.replaceMissionFeatures({
+            missionId,
+            userId: '',
+            isAdmin: true,
+            features: nextFeatures,
+        });
+        this.missionService.generateValidationAssertionsFromFeatures({ missionId, userId: '', isAdmin: true });
+        // Refresh the persisted plan to reflect the amendment.
+        const features = this.missionService.listMissionFeatures({ missionId, userId: '', isAdmin: true });
+        const assertions = this.missionService.listMissionValidationAssertions({ missionId, userId: '', isAdmin: true });
+        this.persistPlanAndMilestones(missionId, `follow-up-${now}`, features, assertions.length);
+        const modifiedFeatureIds = [...pendingReplacements.keys()];
+        const addedFeatureIds = newParsedFeatures.map((feature) => feature.featureId);
+        this.emitOrchestratorDecision(missionId, 'plan_modified', {
+            modified,
+            added,
+            modifiedFeatureIds,
+            addedFeatureIds,
+            source: 'follow_up',
+            timestampMs: now,
+        });
+        for (const interactionId of interactionIds) {
+            this.missionService.updateMissionInteractionStatus({
+                missionId,
+                interactionId,
+                status: 'applied',
+            });
+        }
+        if (interactionIds.length > 0) {
+            this.recordRuntimeEvent(missionId, 'mission_interaction_applied', {
+                action: 'plan_amended',
+                interactionIds,
+            });
+        }
+        return { modified, added, modifiedFeatureIds, addedFeatureIds };
+    }
+    buildFeaturePrompt(missionId, mission, feature, enrichment = {}) {
+        const basePrompt = mission.description || mission.title;
+        const interactions = this.missionService.listMissionInteractions({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        }).filter((interaction) => interaction.status === 'delivered'
+            || interaction.status === 'observed'
+            || interaction.status === 'applied'
+            || interaction.status === 'completed');
+        const sections = [basePrompt];
+        if (enrichment.priorHandoffs && enrichment.priorHandoffs.length > 0) {
+            sections.push('', '## Prior Work');
+            for (const handoff of enrichment.priorHandoffs) {
+                sections.push(`- ${handoff.featureId}: ${handoff.salientSummary}`);
+                if (handoff.whatWasImplemented && handoff.whatWasImplemented.length > 0) {
+                    sections.push('  Implemented:');
+                    for (const item of handoff.whatWasImplemented) {
+                        sections.push(`  - ${item}`);
+                    }
+                }
+            }
+        }
+        if (interactions.length > 0) {
+            const followUps = interactions
+                .sort((left, right) => left.position - right.position)
+                .map((interaction, index) => `${index + 1}. ${interaction.prompt}`)
+                .join('\n');
+            sections.push('', 'User follow-ups during this mission:', followUps);
+        }
+        if (feature.preconditions.length > 0) {
+            sections.push('', '## Preconditions');
+            for (const precondition of feature.preconditions) {
+                sections.push(`- ${precondition}`);
+            }
+        }
+        if (enrichment.validationContract && enrichment.validationContract.trim().length > 0) {
+            sections.push('', '## Validation Criteria');
+            sections.push(enrichment.validationContract);
+        }
+        if (enrichment.workspaceFiles && enrichment.workspaceFiles.length > 0) {
+            sections.push('', '## Workspace Context');
+            sections.push('Top-level workspace entries:');
+            for (const entry of enrichment.workspaceFiles) {
+                sections.push(`- ${entry}`);
+            }
+        }
+        sections.push('', `Feature:\n${feature.description}`);
+        return sections.join('\n');
+    }
+    buildPriorHandoffs(missionId, currentFeatureId) {
+        const features = this.missionService.listMissionFeatures({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const completed = features.filter((feature) => feature.status === 'completed'
+            && feature.featureId !== currentFeatureId
+            && feature.handoff != null);
+        return completed
+            .slice(-5)
+            .map((feature) => {
+            const handoff = feature.handoff ?? {};
+            const salientSummary = typeof handoff.salientSummary === 'string' ? handoff.salientSummary : '';
+            const whatWasImplemented = Array.isArray(handoff.whatWasImplemented)
+                ? handoff.whatWasImplemented.filter((item) => typeof item === 'string')
+                : undefined;
+            return {
+                featureId: feature.featureId,
+                salientSummary,
+                whatWasImplemented: whatWasImplemented && whatWasImplemented.length > 0 ? whatWasImplemented : undefined,
+            };
+        })
+            .filter((handoff) => handoff.salientSummary.length > 0);
+    }
+    buildValidationContract(missionId, feature) {
+        const assertions = this.missionService.listMissionValidationAssertions({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const featureAssertions = assertions.filter((assertion) => assertion.featureId === feature.featureId);
+        const lines = [];
+        if (feature.expectedBehavior.length > 0) {
+            lines.push('Expected behavior:');
+            for (const item of feature.expectedBehavior) {
+                lines.push(`- ${item}`);
+            }
+        }
+        if (featureAssertions.length > 0) {
+            if (lines.length > 0)
+                lines.push('');
+            lines.push('Validation assertions:');
+            for (const assertion of featureAssertions) {
+                lines.push(`- ${assertion.assertionText}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    listWorkspaceFiles(workspaceRoot) {
+        try {
+            return readdirSync(workspaceRoot);
+        }
+        catch {
+            return [];
+        }
+    }
+    async cancelMission(input) {
+        const mission = this.missionService.getMission({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        if (!mission)
+            throw this.error(404, 'Mission not found');
+        if (mission.runtimeProvider !== 'bigbang_native') {
+            throw this.error(400, 'Mission does not use the native runtime provider');
+        }
+        // Compute the set of features that will be cancelled before the state
+        // transition so the effective event can report an accurate count.
+        const features = this.missionService.listMissionFeatures({
+            missionId: input.missionId,
+            userId: input.userId,
+            isAdmin: input.isAdmin,
+        });
+        const running = this.runningFeatures.get(input.missionId);
+        const runningFeatureId = running?.featureId ?? null;
+        const cancellableStatuses = new Set(['running', 'pending', 'queued']);
+        const cancelledFeatureCount = features.filter((feature) => cancellableStatuses.has(feature.status)
+            || (feature.featureId === runningFeatureId && feature.status === 'running')).length;
+        this.recordRuntimeEvent(input.missionId, 'mission_cancellation_requested', {
+            reason: 'user_requested',
+            expectedCancelledFeatureCount: cancelledFeatureCount,
+        });
+        let cancelled;
+        try {
+            cancelled = this.missionService.cancelMission(input);
+        }
+        catch (error) {
+            // If the cancellation transition fails (e.g. mission already terminal),
+            // only the requested event is emitted.
+            throw error;
+        }
+        this.pausedMissions.delete(input.missionId);
+        // Mark the currently running feature as cancelled before removing it from
+        // the in-memory tracking. This prevents a late worker-end message from
+        // leaving the feature row in a stale `running` state.
+        if (running) {
+            this.missionService.updateMissionFeatureStatus({
+                missionId: input.missionId,
+                featureId: running.featureId,
+                status: 'cancelled',
+                eventType: 'feature_cancelled',
+                source: 'platform',
+                eventPayload: { reason: 'mission_cancelled' },
+            });
+            this.workerBroker.cancelFeature(running.requestId);
+            this.runningFeatures.delete(input.missionId);
+        }
+        // Mark any pending or queued features as cancelled.
+        for (const feature of features) {
+            if (feature.status === 'pending' || feature.status === 'queued') {
+                this.missionService.updateMissionFeatureStatus({
+                    missionId: input.missionId,
+                    featureId: feature.featureId,
+                    status: 'cancelled',
+                    eventType: 'feature_cancelled',
+                    source: 'platform',
+                    eventPayload: { reason: 'mission_cancelled' },
+                });
+            }
+        }
+        // Run milestone validation after cancelling features so that assertions
+        // for skipped/cancelled features are marked blocked rather than pending.
+        try {
+            await this.runPendingMilestoneValidations(input.missionId);
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            this.missionService.recordMissionRuntimeEvent({
+                missionId: input.missionId,
+                eventType: 'mission_validation_failed',
+                source: 'platform',
+                eventTime: Date.now(),
+                payload: { error: message },
+            });
+        }
+        this.recordRuntimeEvent(input.missionId, 'mission_cancellation_effective', {
+            cancelledFeatureCount,
+        });
+        this.activeMissions.delete(input.missionId);
+        return cancelled;
+    }
+    recordWorkerEvent(attempt, msg) {
+        this.missionService.recordMissionRuntimeEvent({
+            missionId: attempt.missionId,
+            eventType: msg.eventType,
+            source: msg.source,
+            eventTime: msg.eventTime,
+            payload: {
+                ...msg.payload,
+                requestId: attempt.requestId,
+                featureId: attempt.featureId ?? msg.featureId ?? null,
+            },
+        });
+    }
+    handleAttemptSuperseded(attempt, reason, supersededAt) {
+        if (!attempt.attemptId)
+            return;
+        const successor = this.missionService.listAttempts({
+            missionId: attempt.missionId,
+            userId: '',
+            isAdmin: true,
+        })
+            .filter((a) => a.state === 'running' || a.state === 'queued')
+            .sort((left, right) => right.createdAt - left.createdAt)[0];
+        const supersededBy = successor && successor.attemptId !== attempt.attemptId ? successor.attemptId : null;
+        // For orphan_cleanup, node-disconnect failures are not retryable so no
+        // successor is created. Record the supersession with supersededBy=null.
+        if (!supersededBy && reason !== 'orphan_cleanup')
+            return;
+        try {
+            this.missionService.markAttemptSuperseded({
+                attemptId: attempt.attemptId,
+                supersededBy,
+                reason,
+                supersededAt,
+            });
+        }
+        catch (error) {
+            // If the attempt is already superseded, the cleanup intent is already
+            // satisfied; do not throw.
+            const message = String(error?.message ?? error);
+            if (!message.includes('already superseded')) {
+                this.recordRuntimeEvent(attempt.missionId, 'supersession_failed', {
+                    attemptId: attempt.attemptId,
+                    reason,
+                    error: message,
+                });
+            }
+        }
+    }
+    async onWorkerEnd(attempt, msg) {
+        const running = this.runningFeatures.get(attempt.missionId);
+        if (!running || running.requestId !== attempt.requestId)
+            return;
+        this.runningFeatures.delete(attempt.missionId);
+        const featureId = attempt.featureId ?? msg.featureId;
+        if (!featureId)
+            return;
+        const mission = this.missionService.getMission({ missionId: attempt.missionId, userId: '', isAdmin: true });
+        if (!mission || (mission.state !== 'running' && mission.state !== 'paused'))
+            return;
+        const finalStatus = this.resolveFeatureStatus(msg);
+        const failed = finalStatus === 'failed';
+        const skipped = finalStatus === 'skipped';
+        if (failed) {
+            const retryPolicy = this.resolveRetryPolicy(mission);
+            const feature = this.missionService
+                .listMissionFeatures({ missionId: attempt.missionId, userId: '', isAdmin: true })
+                .find((f) => f.featureId === featureId);
+            const retryCount = feature?.retryCount ?? 0;
+            if (this.isRetryableFailure(msg) && retryCount < retryPolicy.maxRetries) {
+                const nextRetryCount = retryCount + 1;
+                this.missionService.incrementMissionFeatureRetryCount({
+                    missionId: attempt.missionId,
+                    featureId,
+                });
+                this.missionService.updateMissionFeatureStatus({
+                    missionId: attempt.missionId,
+                    featureId,
+                    status: 'pending',
+                    eventType: 'retry_scheduled',
+                    source: 'platform',
+                    eventPayload: {
+                        requestId: attempt.requestId,
+                        attemptId: running.attemptId,
+                        featureId,
+                        milestone: running.milestone,
+                        retryCount: nextRetryCount,
+                        maxRetries: retryPolicy.maxRetries,
+                        reason: msg.reason ?? null,
+                        error: msg.error ?? null,
+                    },
+                });
+                this.missionService.resetMissionValidationAssertions({
+                    missionId: attempt.missionId,
+                    userId: '',
+                    isAdmin: true,
+                    featureId,
+                });
+                const delayMs = this.computeRetryDelay(retryPolicy, retryCount);
+                if (!this.pausedMissions.has(attempt.missionId)) {
+                    if (delayMs <= 0) {
+                        setImmediate(() => {
+                            void this.advanceQueue(attempt.missionId, attempt.nodeId, msg.missionDir, {
+                                attemptId: running.attemptId,
+                                reason: 'retry',
+                            });
+                        });
+                    }
+                    else {
+                        setTimeout(() => {
+                            void this.advanceQueue(attempt.missionId, attempt.nodeId, msg.missionDir, {
+                                attemptId: running.attemptId,
+                                reason: 'retry',
+                            });
+                        }, delayMs);
+                    }
+                }
+                return;
+            }
+            if (retryCount > 0) {
+                this.recordRuntimeEvent(attempt.missionId, 'retry_exhausted', {
+                    requestId: attempt.requestId,
+                    attemptId: running.attemptId,
+                    featureId,
+                    milestone: running.milestone,
+                    retryCount,
+                    maxRetries: retryPolicy.maxRetries,
+                    reason: msg.reason ?? null,
+                    error: msg.error ?? null,
+                });
+            }
+        }
+        this.missionService.updateMissionFeatureStatus({
+            missionId: attempt.missionId,
+            featureId,
+            status: finalStatus,
+            eventType: failed ? 'feature_failed' : skipped ? 'feature_skipped' : 'feature_completed',
+            source: 'agent_node',
+            eventPayload: {
+                requestId: attempt.requestId,
+                attemptId: running.attemptId,
+                featureId,
+                milestone: running.milestone,
+                exitCode: msg.exitCode ?? null,
+                signal: msg.signal ?? null,
+                error: msg.error ?? null,
+                reason: msg.reason ?? null,
+            },
+        });
+        // Persist the worker handoff (if any) against the feature so it can be
+        // aggregated into the mission snapshot and surfaced in the UI.
+        const handoff = this.extractHandoff(msg);
+        this.missionService.updateMissionFeatureHandoff({
+            missionId: attempt.missionId,
+            featureId,
+            handoff,
+        });
+        // Persist the full worker output so the validation runner can evaluate
+        // actual evidence (files changed, stdout, handoff content) rather than
+        // relying only on feature status.
+        this.missionService.updateMissionFeatureWorkerOutput({
+            missionId: attempt.missionId,
+            featureId,
+            workerOutput: msg.output ?? null,
+        });
+        this.recordRuntimeEvent(attempt.missionId, 'worker_output_received', {
+            requestId: attempt.requestId,
+            attemptId: running.attemptId,
+            featureId,
+            milestone: running.milestone,
+            exitCode: msg.exitCode ?? null,
+            signal: msg.signal ?? null,
+            reason: msg.reason ?? null,
+            outputStatus: msg.output?.status ?? null,
+            outputPreview: handoff && typeof handoff.salientSummary === 'string'
+                ? handoff.salientSummary.slice(0, 500)
+                : null,
+        }, 'agent_node');
+        if (handoff) {
+            this.recordRuntimeEvent(attempt.missionId, 'handoff_created', {
+                requestId: attempt.requestId,
+                attemptId: running.attemptId,
+                featureId,
+                milestone: running.milestone,
+                salientSummary: typeof handoff.salientSummary === 'string' ? handoff.salientSummary.slice(0, 500) : null,
+            }, 'agent_node');
+        }
+        // Inspect discovered issues from the worker handoff. Blocking issues spawn
+        // FIX features at the top of the queue; non-blocking issues are dismissed
+        // via a traceable mission event.
+        const discoveredIssues = this.extractDiscoveredIssues(handoff);
+        if (discoveredIssues.length > 0) {
+            this.handleDiscoveredIssues(attempt.missionId, featureId, running.milestone, discoveredIssues);
+        }
+        // Validator features update milestone assertion statuses from their handoff
+        // evidence. Do this before honouring returnToOrchestrator so that a usable
+        // validator result is always recorded.
+        const completedFeature = this.missionService.listMissionFeatures({
+            missionId: attempt.missionId,
+            userId: '',
+            isAdmin: true,
+        }).find((feature) => feature.featureId === featureId);
+        if (completedFeature?.isValidator) {
+            const validatorHalted = await this.applyValidatorHandoff(attempt.missionId, running.milestone, handoff);
+            if (validatorHalted) {
+                this.activeMissions.delete(attempt.missionId);
+                this.pausedMissions.delete(attempt.missionId);
+                this.persistMissionSnapshot(attempt.missionId);
+                return;
+            }
+        }
+        // If the worker handoff asks for orchestrator attention, pause the mission
+        // instead of continuing the queue or failing through the normal path.
+        if (handoff && handoff.returnToOrchestrator === true) {
+            this.emitOrchestratorDecision(attempt.missionId, 'worker_requested_attention', {
+                featureId,
+                successState: handoff.successState,
+                returnToOrchestrator: true,
+            });
+            this.pauseMission({
+                missionId: attempt.missionId,
+                userId: '',
+                isAdmin: true,
+                reason: 'returnToOrchestrator',
+            });
+            return;
+        }
+        this.emitMilestoneCompletedIfNeeded(attempt.missionId, running.milestone);
+        if (failed) {
+            // Node disconnect is an infrastructure failure; the validator cannot be
+            // dispatched because the node is gone, so fail the mission immediately.
+            if (msg.reason === 'node_disconnected') {
+                this.missionService.failMission({
+                    missionId: attempt.missionId,
+                    userId: '',
+                    isAdmin: true,
+                    error: msg.error ?? 'Agent node disconnected',
+                    payload: {
+                        requestId: attempt.requestId,
+                        featureId,
+                        exitCode: msg.exitCode ?? null,
+                        signal: msg.signal ?? null,
+                        reason: msg.reason ?? null,
+                    },
+                });
+                this.activeMissions.delete(attempt.missionId);
+                this.pausedMissions.delete(attempt.missionId);
+                this.persistMissionSnapshot(attempt.missionId);
+                return;
+            }
+            // Evaluate milestone assertions before failing the mission so that
+            // validation results are recorded alongside the failure. If a validator
+            // feature is injected, defer failing the mission until the validator
+            // completes; it will record assertion evidence and then fail the mission
+            // because the original implementation feature is still failed.
+            let progress = {
+                halted: false,
+                validatorInjected: false,
+            };
+            try {
+                progress = await this.runPendingMilestoneValidations(attempt.missionId);
+            }
+            catch (error) {
+                const message = String(error?.message ?? error);
+                this.missionService.recordMissionRuntimeEvent({
+                    missionId: attempt.missionId,
+                    eventType: 'mission_validation_failed',
+                    source: 'platform',
+                    eventTime: Date.now(),
+                    payload: { error: message },
+                });
+            }
+            if (!progress.halted && !progress.validatorInjected) {
+                this.missionService.failMission({
+                    missionId: attempt.missionId,
+                    userId: '',
+                    isAdmin: true,
+                    error: msg.error ?? (msg.signal ? `Process terminated by ${msg.signal}` : `Exit code ${msg.exitCode ?? 'unknown'}`),
+                    payload: {
+                        requestId: attempt.requestId,
+                        featureId,
+                        exitCode: msg.exitCode ?? null,
+                        signal: msg.signal ?? null,
+                        reason: msg.reason ?? null,
+                    },
+                });
+            }
+            if (progress.validatorInjected) {
+                // Let the injected validator run and record evidence before the
+                // mission is failed.
+                void this.advanceQueue(attempt.missionId, attempt.nodeId, msg.missionDir);
+                return;
+            }
+            this.activeMissions.delete(attempt.missionId);
+            this.pausedMissions.delete(attempt.missionId);
+            this.persistMissionSnapshot(attempt.missionId);
+            return;
+        }
+        // If the mission is paused, hold off on dispatching the next feature until
+        // resume is called.
+        if (this.pausedMissions.has(attempt.missionId)) {
+            return;
+        }
+        // completed or skipped: advance to the next feature sequentially.
+        void this.advanceQueue(attempt.missionId, attempt.nodeId, msg.missionDir);
+    }
+    extractHandoff(msg) {
+        const outputHandoff = msg.output?.handoff;
+        if (outputHandoff && typeof outputHandoff === 'object' && !Array.isArray(outputHandoff)) {
+            return outputHandoff;
+        }
+        const msgHandoff = msg.handoff;
+        if (msgHandoff && typeof msgHandoff === 'object' && !Array.isArray(msgHandoff)) {
+            return msgHandoff;
+        }
+        return null;
+    }
+    extractDiscoveredIssues(handoff) {
+        if (!handoff)
+            return [];
+        const issues = handoff.discoveredIssues;
+        if (!Array.isArray(issues))
+            return [];
+        return issues.filter((issue) => {
+            if (!issue || typeof issue !== 'object' || Array.isArray(issue))
+                return false;
+            const record = issue;
+            const id = record.id;
+            const severity = record.severity;
+            const description = record.description;
+            return (typeof id === 'string' &&
+                typeof description === 'string' &&
+                (severity === 'blocking' || severity === 'non-blocking'));
+        });
+    }
+    handleDiscoveredIssues(missionId, sourceFeatureId, milestone, issues) {
+        const blocking = issues.filter((issue) => issue.severity === 'blocking');
+        const nonBlocking = issues.filter((issue) => issue.severity === 'non-blocking');
+        if (blocking.length > 0) {
+            this.injectFixFeatures(missionId, sourceFeatureId, milestone, blocking);
+        }
+        if (nonBlocking.length > 0) {
+            this.recordRuntimeEvent(missionId, 'handoff_items_dismissed', {
+                featureId: sourceFeatureId,
+                milestone,
+                issues: nonBlocking.map((issue) => ({
+                    id: issue.id,
+                    severity: issue.severity,
+                    description: issue.description,
+                    justification: issue.suggestion
+                        ? `non-blocking, deferred: ${issue.suggestion}`
+                        : 'non-blocking, deferred',
+                })),
+            });
+        }
+    }
+    injectFixFeatures(missionId, sourceFeatureId, milestone, blockingIssues) {
+        const features = this.missionService.listMissionFeatures({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const minOrdering = features.length > 0 ? Math.min(...features.map((feature) => feature.ordering)) : 0;
+        const fixFeatures = [];
+        for (let index = 0; index < blockingIssues.length; index += 1) {
+            const issue = blockingIssues[index];
+            fixFeatures.push({
+                featureId: `fix-${sourceFeatureId}-${issue.id}-${Date.now()}-${index}`,
+                missionId,
+                milestone,
+                description: `FIX: ${issue.description}${issue.suggestion ? ` (${issue.suggestion})` : ''}`,
+                skillName: 'native-fix',
+                status: 'pending',
+                ordering: minOrdering - 1 - index,
+                preconditions: [],
+                expectedBehavior: [],
+                retryCount: 0,
+                isValidator: false,
+                handoff: null,
+                workerOutput: null,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+        }
+        const updatedFeatures = [...features, ...fixFeatures].sort((left, right) => left.ordering === right.ordering ? left.createdAt - right.createdAt : left.ordering - right.ordering);
+        this.missionService.replaceMissionFeatures({
+            missionId,
+            userId: '',
+            isAdmin: true,
+            features: updatedFeatures,
+        });
+        return fixFeatures;
+    }
+    persistMissionSnapshot(missionId) {
+        let reportPath = null;
+        try {
+            const mission = this.missionService.getMission({ missionId, userId: '', isAdmin: true });
+            if (mission?.missionDir) {
+                const report = this.missionService.generateNativeMissionReport({
+                    missionId,
+                    userId: '',
+                    isAdmin: true,
+                });
+                reportPath = report.reportPath;
+                this.recordRuntimeEvent(missionId, 'report_generated', {
+                    reportPath: report.reportPath,
+                    sizeBytes: report.sizeBytes,
+                });
+            }
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            this.missionService.recordMissionRuntimeEvent({
+                missionId,
+                eventType: 'mission_report_failed',
+                source: 'platform',
+                eventTime: Date.now(),
+                payload: { error: message },
+            });
+        }
+        try {
+            const snapshot = this.missionService.generateNativeMissionSnapshot({
+                missionId,
+                userId: '',
+                isAdmin: true,
+            });
+            const imported = this.missionService.importSnapshot({
+                missionId,
+                userId: '',
+                isAdmin: true,
+                request: { source: 'bigbang_native', snapshot },
+            });
+            this.recordRuntimeEvent(missionId, 'artifact_written', {
+                snapshotId: imported.snapshotId,
+                source: imported.source,
+                reportPath,
+            });
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            this.missionService.recordMissionRuntimeEvent({
+                missionId,
+                eventType: 'mission_snapshot_failed',
+                source: 'platform',
+                eventTime: Date.now(),
+                payload: { error: message },
+            });
+        }
+    }
+    async advanceQueue(missionId, nodeId, missionDir, supersession) {
+        try {
+            await this.dispatchNextFeature(missionId, nodeId, missionDir, '', true, supersession);
+            const mission = this.missionService.getMission({ missionId, userId: '', isAdmin: true });
+            if (mission && (mission.state === 'completed' || mission.state === 'failed')) {
+                this.persistMissionSnapshot(missionId);
+            }
+        }
+        catch (error) {
+            const mission = this.missionService.getMission({ missionId, userId: '', isAdmin: true });
+            if (mission && mission.state !== 'failed' && mission.state !== 'completed' && mission.state !== 'cancelled') {
+                const message = String(error?.message ?? error);
+                this.missionService.recordMissionRuntimeEvent({
+                    missionId,
+                    eventType: 'mission_dispatch_failed',
+                    source: 'platform',
+                    eventTime: Date.now(),
+                    payload: { error: message },
+                });
+                this.missionService.failMission({
+                    missionId,
+                    userId: '',
+                    isAdmin: true,
+                    error: message,
+                    payload: {},
+                });
+            }
+            const terminal = this.missionService.getMission({ missionId, userId: '', isAdmin: true });
+            if (terminal && (terminal.state === 'completed' || terminal.state === 'failed')) {
+                this.persistMissionSnapshot(missionId);
+            }
+            this.activeMissions.delete(missionId);
+        }
+    }
+    async dispatchNextFeature(missionId, nodeId, missionDir, userId, isAdmin, supersession) {
+        // Do not dispatch new features while the mission is paused.
+        if (this.pausedMissions.has(missionId))
+            return;
+        // Run any milestone validations whose features are all terminal but still
+        // have pending assertions. If a validation failure triggers the halt
+        // policy, fail the mission immediately. If a validator feature was injected,
+        // continue so it is dispatched through the normal queue.
+        const progress = await this.runPendingMilestoneValidations(missionId);
+        if (progress.halted && !progress.validatorInjected) {
+            this.activeMissions.delete(missionId);
+            this.pausedMissions.delete(missionId);
+            return;
+        }
+        const nextFeature = this.missionService.getNextMissionFeature({ missionId });
+        if (!nextFeature) {
+            // All features are done; complete the mission.
+            this.missionService.completeMission({ missionId, userId, isAdmin, payload: {} });
+            this.activeMissions.delete(missionId);
+            this.pausedMissions.delete(missionId);
+            return;
+        }
+        const requestId = randomUUID();
+        this.runningFeatures.set(missionId, {
+            requestId,
+            featureId: nextFeature.featureId,
+            nodeId,
+            attemptId: null,
+            milestone: nextFeature.milestone,
+        });
+        this.emitMilestoneStartedIfNeeded(missionId, nextFeature.milestone, nextFeature.featureId);
+        this.missionService.updateMissionFeatureStatus({
+            missionId,
+            featureId: nextFeature.featureId,
+            status: 'queued',
+            eventType: 'feature_queued',
+            eventPayload: { requestId, milestone: nextFeature.milestone },
+        });
+        this.emitOrchestratorDecision(missionId, 'feature_selected', {
+            requestId,
+            featureId: nextFeature.featureId,
+            milestone: nextFeature.milestone,
+            ordering: nextFeature.ordering,
+        });
+        const mission = this.missionService.getMission({ missionId, userId, isAdmin });
+        if (!mission)
+            throw this.error(404, 'Mission not found');
+        if (nextFeature.retryCount > 0) {
+            const retryPolicy = this.resolveRetryPolicy(mission);
+            this.recordRuntimeEvent(missionId, 'retry_started', {
+                requestId,
+                featureId: nextFeature.featureId,
+                milestone: nextFeature.milestone,
+                retryCount: nextFeature.retryCount,
+                maxRetries: retryPolicy.maxRetries,
+            });
+        }
+        try {
+            const priorHandoffs = this.buildPriorHandoffs(missionId, nextFeature.featureId);
+            const validationContract = this.buildValidationContract(missionId, nextFeature);
+            const workspaceFiles = this.listWorkspaceFiles(mission.workspacePath);
+            const promptOverride = this.buildFeaturePrompt(missionId, mission, nextFeature, {
+                priorHandoffs,
+                validationContract,
+                workspaceFiles,
+            });
+            const attempt = this.missionService.createMissionAttempt({
+                missionId,
+                requestId,
+                attemptType: 'run',
+                nodeId,
+                missionDir,
+                prompt: nextFeature.description,
+                supersedesAttemptId: supersession?.attemptId,
+                supersessionReason: supersession?.reason ?? null,
+            });
+            const running = this.runningFeatures.get(missionId);
+            if (running) {
+                running.attemptId = attempt.attemptId;
+            }
+            this.recordRuntimeEvent(missionId, 'worker_prompt_built', {
+                requestId,
+                attemptId: attempt.attemptId,
+                featureId: nextFeature.featureId,
+                milestone: nextFeature.milestone,
+                promptPreview: promptOverride.slice(0, 500),
+            });
+            const accepted = await this.workerBroker.runMission(nodeId, mission, {
+                requestId,
+                attemptId: attempt.attemptId,
+                promptOverride,
+                feature: {
+                    featureId: nextFeature.featureId,
+                    featureDescription: nextFeature.description,
+                    milestone: nextFeature.milestone,
+                    expectedBehavior: nextFeature.expectedBehavior,
+                    preconditions: nextFeature.preconditions,
+                    priorHandoffs,
+                    validationContract,
+                    workspaceFiles,
+                    useAgentDispatch: true,
+                    isValidator: nextFeature.isValidator,
+                },
+            });
+            this.missionService.updateMissionFeatureStatus({
+                missionId,
+                featureId: nextFeature.featureId,
+                status: 'running',
+                eventType: 'feature_accepted',
+                source: 'agent_node',
+                eventPayload: {
+                    requestId,
+                    attemptId: attempt.attemptId,
+                    featureId: nextFeature.featureId,
+                    pid: accepted.pid ?? null,
+                    milestone: nextFeature.milestone,
+                },
+            });
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            const running = this.runningFeatures.get(missionId);
+            this.runningFeatures.delete(missionId);
+            this.pausedMissions.delete(missionId);
+            this.missionService.updateMissionFeatureStatus({
+                missionId,
+                featureId: nextFeature.featureId,
+                status: 'failed',
+                eventType: 'feature_failed',
+                eventPayload: {
+                    requestId,
+                    attemptId: running?.attemptId ?? null,
+                    featureId: nextFeature.featureId,
+                    milestone: nextFeature.milestone,
+                    reason: 'node_unavailable',
+                    error: message,
+                },
+            });
+            this.missionService.failMission({
+                missionId,
+                userId,
+                isAdmin,
+                error: message,
+                payload: { requestId, featureId: nextFeature.featureId, reason: 'node_unavailable' },
+            });
+            this.activeMissions.delete(missionId);
+            throw error;
+        }
+    }
+    async runPendingMilestoneValidations(missionId, force = false) {
+        const features = this.missionService.listMissionFeatures({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const assertions = this.missionService.listMissionValidationAssertions({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const pendingAssertionFeatureIds = new Set(assertions.filter((a) => a.status === 'pending' && a.featureId).map((a) => a.featureId));
+        if (pendingAssertionFeatureIds.size === 0)
+            return { halted: false, validatorInjected: false };
+        const featuresByMilestone = new Map();
+        for (const feature of features) {
+            const list = featuresByMilestone.get(feature.milestone) ?? [];
+            list.push(feature);
+            featuresByMilestone.set(feature.milestone, list);
+        }
+        const terminalStatuses = ['completed', 'failed', 'skipped', 'cancelled'];
+        const pendingMilestones = [];
+        const validatorNeeded = [];
+        for (const [milestone, milestoneFeatures] of featuresByMilestone) {
+            const implementationFeatures = milestoneFeatures.filter((feature) => !feature.isValidator);
+            const validatorFeatures = milestoneFeatures.filter((feature) => feature.isValidator);
+            const allImplTerminal = implementationFeatures.length > 0 &&
+                implementationFeatures.every((feature) => terminalStatuses.includes(feature.status));
+            const hasFailedOrCancelled = implementationFeatures.some((feature) => feature.status === 'failed' || feature.status === 'cancelled');
+            if (!force && !allImplTerminal && !hasFailedOrCancelled)
+                continue;
+            const hasPendingAssertion = implementationFeatures.some((feature) => pendingAssertionFeatureIds.has(feature.featureId));
+            if (!hasPendingAssertion)
+                continue;
+            // Inject a validator feature if this milestone does not already have one.
+            // Completed or failed validators must not trigger a second injection.
+            if (validatorFeatures.length === 0) {
+                validatorNeeded.push(milestone);
+            }
+            else {
+                const allValidatorsTerminal = validatorFeatures.every((feature) => terminalStatuses.includes(feature.status));
+                if (allValidatorsTerminal) {
+                    pendingMilestones.push(milestone);
+                }
+            }
+        }
+        if (validatorNeeded.length > 0) {
+            for (const milestone of validatorNeeded) {
+                const milestoneAssertions = assertions.filter((assertion) => {
+                    if (!assertion.featureId)
+                        return false;
+                    const feature = features.find((f) => f.featureId === assertion.featureId);
+                    return feature?.milestone === milestone;
+                });
+                this.injectValidatorFeature(missionId, milestone, milestoneAssertions);
+            }
+            // The validator will be dispatched through the normal feature queue. Tell
+            // callers to stop further action until it completes.
+            return { halted: true, validatorInjected: true };
+        }
+        if (pendingMilestones.length === 0)
+            return { halted: false, validatorInjected: false };
+        // Order milestones by the minimum ordering of their implementation features so
+        // validation runs in the same order features were dispatched.
+        pendingMilestones.sort((left, right) => {
+            const leftMin = Math.min(...(featuresByMilestone.get(left) ?? [])
+                .filter((f) => !f.isValidator)
+                .map((f) => f.ordering));
+            const rightMin = Math.min(...(featuresByMilestone.get(right) ?? [])
+                .filter((f) => !f.isValidator)
+                .map((f) => f.ordering));
+            return leftMin - rightMin;
+        });
+        const mission = this.missionService.getMission({ missionId, userId: '', isAdmin: true });
+        const policy = this.validationRunner.resolvePolicy(mission?.effectiveModelConfig);
+        const timeoutMs = this.validationRunner.resolveTimeoutMs(mission?.effectiveModelConfig);
+        const terminalMissionStates = new Set(['completed', 'failed', 'cancelled']);
+        for (const milestone of pendingMilestones) {
+            // When a validator exists but did not produce a usable handoff, fall back to
+            // the synchronous keyword evaluator. The fallback must never claim observed
+            // confidence because it did not inspect actual test output.
+            const result = await this.validationRunner.runValidation({
+                missionId,
+                milestone,
+                policy,
+                timeoutMs,
+                forceInferredConfidence: true,
+            });
+            if (result.shouldHalt) {
+                if (mission && !terminalMissionStates.has(mission.state)) {
+                    const error = `Validation failed for milestone "${milestone}" with ${result.failed} failed assertion(s)`;
+                    this.missionService.failMission({
+                        missionId,
+                        userId: '',
+                        isAdmin: true,
+                        error,
+                        payload: {
+                            milestone,
+                            failedAssertions: result.failedAssertionIds,
+                            policy,
+                        },
+                    });
+                }
+                return { halted: true, validatorInjected: false };
+            }
+        }
+        return { halted: false, validatorInjected: false };
+    }
+    resolveFeatureStatus(msg) {
+        if (msg.error)
+            return 'failed';
+        if (msg.signal)
+            return 'failed';
+        if (msg.exitCode != null && msg.exitCode !== 0)
+            return 'failed';
+        const outputStatus = msg.output?.status;
+        if (outputStatus === 'failed')
+            return 'failed';
+        if (outputStatus === 'skipped')
+            return 'skipped';
+        return 'completed';
+    }
+    resolveRetryPolicy(mission) {
+        const policy = mission.effectiveModelConfig?.retryPolicy;
+        if (policy && typeof policy === 'object' && !Array.isArray(policy)) {
+            const maxRetriesRaw = policy.maxRetries;
+            const maxRetries = typeof maxRetriesRaw === 'number' && Number.isFinite(maxRetriesRaw)
+                ? Math.max(0, Math.floor(maxRetriesRaw))
+                : 0;
+            const backoff = policy.backoff === 'exponential' ? 'exponential' : 'fixed';
+            const baseDelayMsRaw = policy.baseDelayMs;
+            const baseDelayMs = typeof baseDelayMsRaw === 'number' && Number.isFinite(baseDelayMsRaw) && baseDelayMsRaw >= 0
+                ? Math.floor(baseDelayMsRaw)
+                : 0;
+            const maxDelayMsRaw = policy.maxDelayMs;
+            const maxDelayMs = typeof maxDelayMsRaw === 'number' && Number.isFinite(maxDelayMsRaw) && maxDelayMsRaw >= 0
+                ? Math.floor(maxDelayMsRaw)
+                : 60_000;
+            return { maxRetries, backoff, baseDelayMs, maxDelayMs };
+        }
+        return { maxRetries: 0, backoff: 'fixed', baseDelayMs: 0, maxDelayMs: 60_000 };
+    }
+    isRetryableFailure(msg) {
+        if (msg.output?.retryable === true)
+            return true;
+        const output = msg.output ?? {};
+        const outputStatus = output.status;
+        if (outputStatus === 'retryable')
+            return true;
+        const reason = msg.reason ?? output.reason;
+        if (typeof reason === 'string') {
+            const retryableReasons = new Set([
+                'retryable',
+                'network_timeout',
+                'rate_limit',
+                'transient',
+                'node_unavailable',
+            ]);
+            if (retryableReasons.has(reason))
+                return true;
+        }
+        return false;
+    }
+    computeRetryDelay(policy, retryCount) {
+        if (policy.baseDelayMs <= 0)
+            return 0;
+        let delay = policy.baseDelayMs;
+        if (policy.backoff === 'exponential') {
+            delay = policy.baseDelayMs * 2 ** retryCount;
+        }
+        return Math.min(delay, policy.maxDelayMs);
+    }
+    recoverAfterRestart() {
+        const missions = this.missionService.listNativeMissionsForRecovery();
+        for (const mission of missions) {
+            this.activeMissions.add(mission.missionId);
+            if (mission.state === 'paused') {
+                this.pausedMissions.add(mission.missionId);
+                continue;
+            }
+            const features = this.missionService.listMissionFeatures({
+                missionId: mission.missionId,
+                userId: '',
+                isAdmin: true,
+            });
+            const runningFeature = features.find((feature) => feature.status === 'running');
+            let supersession;
+            if (runningFeature) {
+                const attempts = this.missionService.listAttempts({
+                    missionId: mission.missionId,
+                    userId: '',
+                    isAdmin: true,
+                });
+                const stuckAttempt = attempts
+                    .filter((attempt) => (attempt.state === 'running' || attempt.state === 'queued') &&
+                    attempt.supersededBy === null)
+                    .sort((left, right) => right.createdAt - left.createdAt)[0];
+                if (stuckAttempt) {
+                    supersession = { attemptId: stuckAttempt.attemptId, reason: 'recovery' };
+                }
+                this.missionService.updateMissionFeatureStatus({
+                    missionId: mission.missionId,
+                    featureId: runningFeature.featureId,
+                    status: 'pending',
+                    eventType: 'orchestrator_decision',
+                    source: 'platform',
+                    eventPayload: {
+                        decisionType: 'recovery_requeued_running_feature',
+                        featureId: runningFeature.featureId,
+                        milestone: runningFeature.milestone,
+                        retryCount: runningFeature.retryCount,
+                    },
+                });
+            }
+            const milestones = this.missionService.listMissionMilestones({
+                missionId: mission.missionId,
+                userId: '',
+                isAdmin: true,
+            });
+            const currentMilestone = milestones.find((milestone) => milestone.status === 'running');
+            if (currentMilestone) {
+                this.currentMilestones.set(mission.missionId, currentMilestone.name);
+            }
+            else {
+                const nextFeature = this.missionService.getNextMissionFeature({ missionId: mission.missionId });
+                if (nextFeature) {
+                    this.currentMilestones.set(mission.missionId, nextFeature.milestone);
+                }
+            }
+            if (mission.state === 'running' && mission.nodeId && mission.missionDir) {
+                void this.advanceQueue(mission.missionId, mission.nodeId, mission.missionDir, supersession);
+            }
+        }
+    }
+    injectValidatorFeature(missionId, milestone, assertions) {
+        const features = this.missionService.listMissionFeatures({ missionId, userId: '', isAdmin: true });
+        const milestoneFeatures = features.filter((feature) => feature.milestone === milestone);
+        const minOrdering = milestoneFeatures.length > 0
+            ? Math.min(...milestoneFeatures.map((feature) => feature.ordering))
+            : 0;
+        const validatorFeature = {
+            featureId: `validator-${milestone.replace(/\s+/g, '-')}-${Date.now()}`,
+            missionId,
+            milestone,
+            description: this.buildValidatorPrompt(milestone, assertions),
+            skillName: 'native-validator',
+            status: 'pending',
+            ordering: minOrdering - 1,
+            preconditions: [],
+            expectedBehavior: [],
+            retryCount: 0,
+            isValidator: true,
+            handoff: null,
+            workerOutput: null,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        const updatedFeatures = [...features, validatorFeature].sort((left, right) => left.ordering === right.ordering
+            ? left.createdAt - right.createdAt
+            : left.ordering - right.ordering);
+        this.missionService.replaceMissionFeatures({
+            missionId,
+            userId: '',
+            isAdmin: true,
+            features: updatedFeatures,
+        });
+        this.recordRuntimeEvent(missionId, 'validator_feature_injected', {
+            featureId: validatorFeature.featureId,
+            milestone,
+            assertionCount: assertions.length,
+        });
+        return validatorFeature;
+    }
+    buildValidatorPrompt(milestone, assertions) {
+        const lines = [
+            `Validator for milestone: ${milestone}`,
+            '',
+            'You are a validation agent. Run the project test suite for this milestone and map the results to each pending assertion below.',
+            '',
+            'Run the following test command:',
+            'pnpm --filter @bbigbang/core test && pnpm --filter @bbigbang/agent-node test',
+            '',
+            'Inspect the test output and map results to assertions, marking each as passed, failed, or blocked.',
+            'Record the test command and its full output as evidence in your handoff.verification.commandsRun.',
+            '',
+            'Pending assertions:',
+        ];
+        for (const assertion of assertions) {
+            lines.push(`- ${assertion.assertionText}`);
+        }
+        lines.push('', 'If any test command exits with a non-zero code, mark the related assertions as failed and include the failing output as evidence.');
+        return lines.join('\n');
+    }
+    async applyValidatorHandoff(missionId, milestone, handoff) {
+        const features = this.missionService.listMissionFeatures({ missionId, userId: '', isAdmin: true });
+        const assertions = this.missionService.listMissionValidationAssertions({
+            missionId,
+            userId: '',
+            isAdmin: true,
+        });
+        const pendingAssertions = assertions.filter((assertion) => {
+            if (assertion.status !== 'pending' || !assertion.featureId)
+                return false;
+            const feature = features.find((f) => f.featureId === assertion.featureId);
+            return feature?.milestone === milestone;
+        });
+        if (pendingAssertions.length === 0)
+            return false;
+        const mission = this.missionService.getMission({ missionId, userId: '', isAdmin: true });
+        const policy = this.validationRunner.resolvePolicy(mission?.effectiveModelConfig);
+        const commandsRun = this.extractValidatorCommandsRun(handoff);
+        if (commandsRun.length > 0) {
+            const allCommandsPassed = commandsRun.every((entry) => entry.exitCode === 0);
+            for (const assertion of pendingAssertions) {
+                const linkedFeature = assertion.featureId
+                    ? features.find((f) => f.featureId === assertion.featureId)
+                    : undefined;
+                const featureFailed = linkedFeature?.status === 'failed';
+                const status = featureFailed || !allCommandsPassed ? 'failed' : 'passed';
+                this.missionService.updateMissionValidationAssertion({
+                    missionId,
+                    assertionId: assertion.assertionId,
+                    status,
+                    note: featureFailed
+                        ? 'Linked implementation feature failed.'
+                        : allCommandsPassed
+                            ? 'Validator test command passed.'
+                            : 'Validator test command reported failures.',
+                    evidence: commandsRun
+                        .map((entry) => `${entry.command} (exitCode=${entry.exitCode})`)
+                        .join('; '),
+                    confidence: 'observed',
+                });
+            }
+        }
+        else {
+            // No usable validator handoff: fall back to the synchronous evaluator.
+            const result = await this.validationRunner.runValidation({
+                missionId,
+                milestone,
+                policy,
+                timeoutMs: this.validationRunner.resolveTimeoutMs(mission?.effectiveModelConfig),
+                forceInferredConfidence: true,
+            });
+            if (result.shouldHalt) {
+                if (mission && !['completed', 'failed', 'cancelled'].includes(mission.state)) {
+                    const error = `Validation failed for milestone "${milestone}" with ${result.failed} failed assertion(s)`;
+                    this.missionService.failMission({
+                        missionId,
+                        userId: '',
+                        isAdmin: true,
+                        error,
+                        payload: { milestone, policy },
+                    });
+                }
+                return true;
+            }
+        }
+        const failedCount = this.missionService
+            .listMissionValidationAssertions({ missionId, userId: '', isAdmin: true })
+            .filter((assertion) => {
+            if (assertion.status !== 'failed' || !assertion.featureId)
+                return false;
+            const feature = features.find((f) => f.featureId === assertion.featureId);
+            return feature?.milestone === milestone;
+        }).length;
+        if (policy === 'failOnFirst' && failedCount > 0) {
+            if (mission && !['completed', 'failed', 'cancelled'].includes(mission.state)) {
+                const error = `Validation failed for milestone "${milestone}" with failed assertion(s)`;
+                this.missionService.failMission({
+                    missionId,
+                    userId: '',
+                    isAdmin: true,
+                    error,
+                    payload: { milestone, policy },
+                });
+            }
+            return true;
+        }
+        // If the milestone contains a failed implementation feature, the mission
+        // must still fail even when the validator itself passes, because the
+        // original feature failure is what triggered validation.
+        const failedImplementationFeature = features.find((f) => f.milestone === milestone && !f.isValidator && f.status === 'failed');
+        if (failedImplementationFeature) {
+            if (mission && !['completed', 'failed', 'cancelled'].includes(mission.state)) {
+                this.missionService.failMission({
+                    missionId,
+                    userId: '',
+                    isAdmin: true,
+                    error: `Feature ${failedImplementationFeature.featureId} failed`,
+                    payload: { featureId: failedImplementationFeature.featureId, milestone },
+                });
+            }
+            return true;
+        }
+        return false;
+    }
+    extractValidatorCommandsRun(handoff) {
+        if (!handoff)
+            return [];
+        const verification = handoff.verification;
+        if (!verification || typeof verification !== 'object' || Array.isArray(verification))
+            return [];
+        const commandsRun = verification.commandsRun;
+        if (!Array.isArray(commandsRun))
+            return [];
+        return commandsRun.filter((entry) => entry != null &&
+            typeof entry === 'object' &&
+            !Array.isArray(entry) &&
+            typeof entry.command === 'string' &&
+            typeof entry.exitCode === 'number' &&
+            typeof entry.observation === 'string');
+    }
+    requireMission(input) {
+        const mission = this.missionService.getMission(input);
+        if (!mission)
+            throw this.error(404, 'Mission not found');
+        return mission;
+    }
+    error(statusCode, message) {
+        return new MissionServiceError(statusCode, message);
+    }
+}
+function groupFeaturesByMilestone(features) {
+    const grouped = new Map();
+    for (const feature of features) {
+        const list = grouped.get(feature.milestone) ?? [];
+        list.push(feature);
+        grouped.set(feature.milestone, list);
+    }
+    for (const list of grouped.values()) {
+        list.sort((left, right) => left.ordering - right.ordering);
+    }
+    return grouped;
+}