@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/control/observabilityApiController.js

@@ -0,0 +1,173 @@
+import { buildCompatibilityErrorResponse, buildCompatibilityIssueNotFoundResponse, buildCompatibilityMethodNotAllowedResponse, buildCompatibilityNotFoundResponse, buildCompatibilityRefreshRejectedResponse, buildCompatibilityTraceability, readCompatibilityIssue, readCompatibilityRefresh, readCompatibilityState, readDispatchExtension } from './observabilitySurface.js';
+const COMPATIBILITY_API_PREFIX = '/api/v1';
+const COMPATIBILITY_STATE_PATH = `${COMPATIBILITY_API_PREFIX}/state`;
+const COMPATIBILITY_REFRESH_PATH = `${COMPATIBILITY_API_PREFIX}/refresh`;
+const COMPATIBILITY_DISPATCH_EXTENSION_PATH = `${COMPATIBILITY_API_PREFIX}/dispatch`;
+const SYMPHONY_COMPATIBILITY_CORE_SEGMENTS = new Set(['state', 'refresh']);
+const CO_COMPATIBILITY_EXTENSION_SEGMENTS = new Set(['dispatch']);
+const JSON_HEADERS = { 'Content-Type': 'application/json' };
+const JSON_NO_STORE_HEADERS = { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' };
+export async function handleObservabilityApiRequest(context) {
+    const method = context.req.method ?? 'GET';
+    const pathname = new URL(context.req.url ?? '/', 'http://localhost').pathname;
+    const route = resolveObservabilityApiRoute(pathname);
+    switch (route.kind) {
+        case 'none':
+            return false;
+        case 'state':
+            if (method !== 'GET') {
+                writeObservabilityResponse(context.res, buildCompatibilityMethodNotAllowedResponse(context.presenterContext, 'GET'));
+                return true;
+            }
+            writeObservabilityResponse(context.res, {
+                status: 200,
+                headers: JSON_NO_STORE_HEADERS,
+                body: await readCompatibilityState(context.presenterContext)
+            });
+            return true;
+        case 'dispatch': {
+            if (method !== 'GET') {
+                writeDispatchExtensionMethodNotAllowed(context.res, context.presenterContext);
+                return true;
+            }
+            const result = await readDispatchExtension({
+                readDispatchEvaluation: context.readDispatchEvaluation
+            });
+            if (context.onDispatchEvaluated) {
+                await context.onDispatchEvaluated({
+                    surface: 'api_v1_dispatch',
+                    evaluation: result.evaluation,
+                    issueIdentifier: result.issueIdentifier
+                });
+            }
+            const traceability = buildCompatibilityTraceability(context.presenterContext, {
+                decision: result.kind === 'fail_closed' ? 'rejected' : 'acknowledged',
+                reason: result.kind === 'fail_closed'
+                    ? result.evaluation.failure?.reason ?? result.evaluation.summary.reason
+                    : result.evaluation.summary.reason,
+                issueIdentifier: result.issueIdentifier
+            });
+            if (result.kind === 'fail_closed') {
+                writeObservabilityResponse(context.res, buildCompatibilityErrorResponse({
+                    status: result.failure.status,
+                    code: result.failure.code,
+                    message: 'Dispatch pilot evaluation failed closed.',
+                    details: result.details,
+                    traceability
+                }));
+                return true;
+            }
+            writeObservabilityResponse(context.res, {
+                status: 200,
+                headers: JSON_NO_STORE_HEADERS,
+                body: {
+                    ...result.payload,
+                    traceability
+                }
+            });
+            return true;
+        }
+        case 'refresh': {
+            if (method !== 'POST') {
+                writeObservabilityResponse(context.res, buildCompatibilityMethodNotAllowedResponse(context.presenterContext, 'POST'));
+                return true;
+            }
+            const result = await readCompatibilityRefresh({
+                controlStore: context.presenterContext.controlStore,
+                paths: context.presenterContext.paths,
+                requestRefresh: context.requestRefresh
+            }, await context.readRequestBody());
+            if (result.kind === 'rejected') {
+                writeObservabilityResponse(context.res, buildCompatibilityRefreshRejectedResponse(context.presenterContext, result));
+                return true;
+            }
+            writeObservabilityResponse(context.res, {
+                status: 202,
+                headers: JSON_HEADERS,
+                body: result.payload
+            });
+            return true;
+        }
+        case 'issue': {
+            if (method !== 'GET') {
+                writeObservabilityResponse(context.res, buildCompatibilityMethodNotAllowedResponse(context.presenterContext, 'GET', route.issueIdentifier));
+                return true;
+            }
+            const result = await readCompatibilityIssue(context.presenterContext, route.issueIdentifier);
+            if (result.kind === 'issue_not_found') {
+                writeObservabilityResponse(context.res, buildCompatibilityIssueNotFoundResponse(context.presenterContext, route.issueIdentifier));
+                return true;
+            }
+            writeObservabilityResponse(context.res, {
+                status: 200,
+                headers: JSON_NO_STORE_HEADERS,
+                body: result.payload
+            });
+            return true;
+        }
+        case 'not_found':
+            writeObservabilityResponse(context.res, buildCompatibilityNotFoundResponse(context.presenterContext));
+            return true;
+    }
+}
+export function resolveObservabilityApiRoute(pathname) {
+    if (pathname === COMPATIBILITY_STATE_PATH) {
+        return { kind: 'state' };
+    }
+    if (pathname === COMPATIBILITY_DISPATCH_EXTENSION_PATH) {
+        return { kind: 'dispatch' };
+    }
+    if (pathname === COMPATIBILITY_REFRESH_PATH) {
+        return { kind: 'refresh' };
+    }
+    const issueIdentifier = resolveCompatibilityIssueIdentifierFromPath(pathname);
+    if (issueIdentifier !== null) {
+        return { kind: 'issue', issueIdentifier };
+    }
+    if (pathname === COMPATIBILITY_API_PREFIX || pathname.startsWith(`${COMPATIBILITY_API_PREFIX}/`)) {
+        return { kind: 'not_found' };
+    }
+    return { kind: 'none' };
+}
+function resolveCompatibilityIssueIdentifierFromPath(pathname) {
+    if (!pathname.startsWith(`${COMPATIBILITY_API_PREFIX}/`)) {
+        return null;
+    }
+    const suffix = pathname.slice(`${COMPATIBILITY_API_PREFIX}/`.length);
+    if (!suffix || suffix.includes('/')) {
+        return null;
+    }
+    try {
+        const decoded = decodeURIComponent(suffix);
+        const normalized = decoded.toLowerCase();
+        if (!decoded ||
+            decoded.includes('/') ||
+            SYMPHONY_COMPATIBILITY_CORE_SEGMENTS.has(normalized) ||
+            CO_COMPATIBILITY_EXTENSION_SEGMENTS.has(normalized)) {
+            return null;
+        }
+        return decoded;
+    }
+    catch {
+        return null;
+    }
+}
+function writeObservabilityResponse(res, response) {
+    res.writeHead(response.status, response.headers);
+    res.end(JSON.stringify(response.body));
+}
+function writeDispatchExtensionMethodNotAllowed(res, context) {
+    writeObservabilityResponse(res, buildCompatibilityErrorResponse({
+        status: 405,
+        code: 'method_not_allowed',
+        message: 'Method not allowed',
+        details: {
+            surface: 'api_v1',
+            allowed_method: 'GET'
+        },
+        traceability: buildCompatibilityTraceability(context, {
+            decision: 'rejected',
+            reason: 'method_not_allowed'
+        })
+    }));
+}

package/dist/orchestrator/src/cli/control/observabilityReadModel.js

@@ -0,0 +1,500 @@
+import { isProviderLinearWorkerProofFreshForStage } from './providerLinearWorkerTruth.js';
+import { normalizeProviderWorkerHostName } from './providerWorkerHosts.js';
+export function buildTrackedPayloadEnvelope(tracked) {
+    return tracked ?? { linear: null };
+}
+export function buildTrackedLinearPayload(trackedIssue) {
+    if (!trackedIssue) {
+        return null;
+    }
+    return {
+        linear: {
+            provider: trackedIssue.provider,
+            id: trackedIssue.id,
+            identifier: trackedIssue.identifier,
+            title: trackedIssue.title,
+            url: trackedIssue.url,
+            state: trackedIssue.state,
+            state_type: trackedIssue.state_type,
+            workspace_id: trackedIssue.workspace_id,
+            team_id: trackedIssue.team_id,
+            team_key: trackedIssue.team_key,
+            team_name: trackedIssue.team_name,
+            project_id: trackedIssue.project_id,
+            project_name: trackedIssue.project_name,
+            updated_at: trackedIssue.updated_at,
+            recent_activity: trackedIssue.recent_activity
+        }
+    };
+}
+export function buildSelectedRunQuestionSummaryPayload(summary) {
+    return {
+        queued_count: summary.queuedCount,
+        latest_question: summary.latestQuestion
+            ? {
+                question_id: summary.latestQuestion.questionId,
+                prompt: summary.latestQuestion.prompt,
+                urgency: summary.latestQuestion.urgency,
+                queued_at: summary.latestQuestion.queuedAt
+            }
+            : null
+    };
+}
+export function buildSelectedRunLatestEventPayload(latestEvent, options = {}) {
+    if (!latestEvent) {
+        return null;
+    }
+    return {
+        at: latestEvent.at,
+        event: latestEvent.event,
+        message: latestEvent.message,
+        source: latestEvent.source ?? null,
+        message_recorded_at: latestEvent.messageRecordedAt ?? null,
+        source_updated_at: latestEvent.sourceUpdatedAt ?? null,
+        candidates: latestEvent.candidates ?? [],
+        ...(options.includeRequestMetadata
+            ? {
+                requested_by: latestEvent.requestedBy,
+                reason: latestEvent.reason
+            }
+            : {})
+    };
+}
+export function readProviderLinearWorkerHost(proof, stageStartedAt) {
+    if (!proof
+        || !isProviderLinearWorkerProofFreshForStage(proof, stageStartedAt ?? null)) {
+        return { kind: 'missing' };
+    }
+    return readResolvedWorkerHost(proof);
+}
+export function resolveProviderWorkerHost(input) {
+    const claimLaunchStartedAt = input.providerDebugSnapshot?.claim?.launch_started_at ?? null;
+    const stageStartedAt = claimLaunchStartedAt
+        ?? input.stageStartedAt
+        ?? null;
+    const claimHost = readResolvedWorkerHost(input.providerDebugSnapshot?.claim);
+    if (claimHost.kind === 'host') {
+        return claimHost.value;
+    }
+    if (claimHost.kind === 'cleared') {
+        return null;
+    }
+    const proofHost = readProviderLinearWorkerHost(input.providerLinearWorkerProof, stageStartedAt);
+    if (proofHost.kind === 'host') {
+        return proofHost.value;
+    }
+    if (proofHost.kind === 'cleared') {
+        return null;
+    }
+    const selectedClaim = input.providerIntake?.selected_claim ?? null;
+    if (!selectedClaim) {
+        return null;
+    }
+    const issueIdentifier = input.issueIdentifier ?? null;
+    const issueId = input.issueId ?? null;
+    if (issueIdentifier !== null
+        && selectedClaim.issue_identifier !== issueIdentifier
+        && issueId !== null
+        && selectedClaim.issue_id !== issueId) {
+        return null;
+    }
+    if (issueIdentifier !== null
+        && selectedClaim.issue_identifier !== issueIdentifier
+        && issueId === null) {
+        return null;
+    }
+    if (issueId !== null
+        && selectedClaim.issue_id !== issueId
+        && issueIdentifier === null) {
+        return null;
+    }
+    return normalizeProviderWorkerHostName(selectedClaim.worker_host);
+}
+function readResolvedWorkerHost(source) {
+    if (!source
+        || !Object.prototype.hasOwnProperty.call(source, 'worker_host')
+        || source.worker_host === undefined) {
+        return { kind: 'missing' };
+    }
+    const workerHost = normalizeProviderWorkerHostName(source.worker_host);
+    return workerHost === null
+        ? { kind: 'cleared' }
+        : { kind: 'host', value: workerHost };
+}
+export function buildProjectionSelectedPayload(selected, providerIntake = null) {
+    const workerHost = resolveProviderWorkerHost({
+        providerLinearWorkerProof: selected.providerLinearWorkerProof,
+        providerDebugSnapshot: selected.providerDebugSnapshot,
+        providerIntake,
+        issueIdentifier: selected.issueIdentifier,
+        issueId: selected.issueId,
+        stageStartedAt: selected.startedAt
+    });
+    return {
+        issue_id: selected.issueId,
+        issue_identifier: selected.issueIdentifier,
+        task_id: selected.taskId,
+        run_id: selected.runId,
+        raw_status: selected.rawStatus,
+        display_status: selected.displayStatus,
+        status_reason: selected.statusReason,
+        started_at: selected.startedAt,
+        updated_at: selected.updatedAt,
+        completed_at: selected.completedAt,
+        summary: selected.summary,
+        last_error: selected.lastError,
+        latest_action: selected.latestAction,
+        latest_event: buildSelectedRunLatestEventPayload(selected.latestEvent, {
+            includeRequestMetadata: true
+        }),
+        workspace: {
+            path: selected.workspacePath
+        },
+        ...(workerHost !== null ? { worker_host: workerHost } : {}),
+        question_summary: buildSelectedRunQuestionSummaryPayload(selected.questionSummary),
+        tracked: buildTrackedPayloadEnvelope(selected.tracked),
+        ...(selected.providerLinearWorkerProof
+            ? {
+                provider_linear_worker_proof: selected.providerLinearWorkerProof
+            }
+            : {}),
+        ...(selected.providerDebugSnapshot
+            ? {
+                provider_debug_snapshot: selected.providerDebugSnapshot
+            }
+            : {})
+    };
+}
+export function serializeProviderIntakeSummary(providerIntake) {
+    return {
+        summary_scope: providerIntake.summary_scope,
+        selection_strategy: providerIntake.selection_strategy,
+        claim_count: providerIntake.claim_count,
+        active_claim_count: providerIntake.active_claim_count,
+        running_claim_count: providerIntake.running_claim_count,
+        active_issue_identifiers: [...providerIntake.active_issue_identifiers],
+        running_issue_identifiers: [...providerIntake.running_issue_identifiers],
+        selected_claim: {
+            issue_identifier: providerIntake.selected_claim.issue_identifier,
+            task_id: providerIntake.selected_claim.task_id,
+            state: providerIntake.selected_claim.state,
+            reason: providerIntake.selected_claim.reason,
+            run_id: providerIntake.selected_claim.run_id,
+            freshness: providerIntake.selected_claim.freshness,
+            retry: providerIntake.selected_claim.retry,
+            worker_host: providerIntake.selected_claim.worker_host ?? null
+        },
+        rehydrated_at: providerIntake.rehydrated_at,
+        is_rehydrated: providerIntake.is_rehydrated,
+        updated_at: providerIntake.updated_at
+    };
+}
+export function buildSelectedRunRuntimeFingerprintInput(snapshot) {
+    const selected = snapshot.selected ?? null;
+    const dispatchPilot = snapshot.dispatchPilot ?? null;
+    const trackedLinear = selected?.tracked?.linear ?? snapshot.tracked?.linear ?? null;
+    const providerIntake = snapshot.providerIntake ?? null;
+    const providerWorkflow = snapshot.providerWorkflow ?? null;
+    const questionSummary = selected?.questionSummary ?? null;
+    if (!selected && !trackedLinear && !dispatchPilot && !questionSummary && !providerIntake && !providerWorkflow) {
+        return null;
+    }
+    return {
+        selected: selected
+            ? {
+                issue_identifier: selected.issueIdentifier,
+                run_id: selected.runId,
+                raw_status: selected.rawStatus,
+                display_status: selected.displayStatus,
+                status_reason: selected.statusReason,
+                summary: selected.summary,
+                latest_event: selected.latestEvent
+                    ? {
+                        event: selected.latestEvent.event,
+                        message: selected.latestEvent.message,
+                        at: selected.latestEvent.at
+                    }
+                    : null,
+                provider_linear_worker_proof: selected.providerLinearWorkerProof ?? null,
+                provider_debug_snapshot: selected.providerDebugSnapshot ?? null,
+                provider_retry_state: selected.providerRetryState ?? null,
+                question_summary: questionSummary
+                    ? {
+                        queued_count: questionSummary.queuedCount,
+                        latest_question_id: questionSummary.latestQuestion?.questionId ?? null,
+                        latest_question_prompt: questionSummary.latestQuestion?.prompt ?? null,
+                        latest_question_urgency: questionSummary.latestQuestion?.urgency ?? null
+                    }
+                    : null
+            }
+            : null,
+        dispatch_pilot: dispatchPilot
+            ? {
+                status: dispatchPilot.status ?? null,
+                source_status: dispatchPilot.source_status ?? null,
+                reason: dispatchPilot.reason ?? null
+            }
+            : null,
+        tracked_linear: trackedLinear
+            ? {
+                identifier: trackedLinear.identifier,
+                title: trackedLinear.title,
+                state: trackedLinear.state,
+                url: trackedLinear.url,
+                team_key: trackedLinear.team_key
+            }
+            : null,
+        provider_intake: providerIntake ? serializeProviderIntakeSummary(providerIntake) : null,
+        provider_workflow: providerWorkflow
+            ? {
+                status: providerWorkflow.status,
+                pipeline_id: providerWorkflow.pipeline_id,
+                source_path: providerWorkflow.source_path,
+                snapshot_path: providerWorkflow.snapshot_path,
+                last_reload_attempt_at: providerWorkflow.last_reload_attempt_at,
+                last_success_at: providerWorkflow.last_success_at,
+                last_error_at: providerWorkflow.last_error_at,
+                last_error: providerWorkflow.last_error,
+                terminal_cleanup: providerWorkflow.terminal_cleanup
+                    ? {
+                        enabled: providerWorkflow.terminal_cleanup.enabled,
+                        close_attached_pr: {
+                            enabled: providerWorkflow.terminal_cleanup.close_attached_pr.enabled,
+                            comment_template: providerWorkflow.terminal_cleanup.close_attached_pr.comment_template
+                        },
+                        last_result: providerWorkflow.terminal_cleanup.last_result
+                            ? {
+                                attempted_at: providerWorkflow.terminal_cleanup.last_result.attempted_at,
+                                status: providerWorkflow.terminal_cleanup.last_result.status,
+                                summary: providerWorkflow.terminal_cleanup.last_result.summary,
+                                error: providerWorkflow.terminal_cleanup.last_result.error,
+                                issue_id: providerWorkflow.terminal_cleanup.last_result.issue_id,
+                                issue_identifier: providerWorkflow.terminal_cleanup.last_result.issue_identifier,
+                                workspace_path: providerWorkflow.terminal_cleanup.last_result.workspace_path,
+                                branch: providerWorkflow.terminal_cleanup.last_result.branch,
+                                attached_pr_urls: [
+                                    ...providerWorkflow.terminal_cleanup.last_result.attached_pr_urls
+                                ],
+                                matching_open_pr_urls: [
+                                    ...providerWorkflow.terminal_cleanup.last_result.matching_open_pr_urls
+                                ],
+                                closed_pr_urls: [
+                                    ...providerWorkflow.terminal_cleanup.last_result.closed_pr_urls
+                                ]
+                            }
+                            : null
+                    }
+                    : null,
+                worker_hosts: Array.isArray(providerWorkflow.worker_hosts)
+                    ? providerWorkflow.worker_hosts.map((host) => ({
+                        ...host,
+                        ssh_options: [...host.ssh_options]
+                    }))
+                    : [],
+                operator_autopilot: providerWorkflow.operator_autopilot
+                    ? {
+                        enabled: providerWorkflow.operator_autopilot.enabled,
+                        backlog_promotion: {
+                            enabled: providerWorkflow.operator_autopilot.backlog_promotion.enabled,
+                            state_name: providerWorkflow.operator_autopilot.backlog_promotion.state_name,
+                            target_state_name: providerWorkflow.operator_autopilot.backlog_promotion.target_state_name,
+                            snapshot_retention: {
+                                max_untracked_cycles: providerWorkflow.operator_autopilot.backlog_promotion
+                                    .snapshot_retention?.max_untracked_cycles ?? 3,
+                                terminal_state_types: [
+                                    ...(providerWorkflow.operator_autopilot.backlog_promotion
+                                        .snapshot_retention?.terminal_state_types ?? [
+                                        'completed',
+                                        'canceled'
+                                    ])
+                                ]
+                            }
+                        },
+                        review_handoff_rework: {
+                            enabled: providerWorkflow.operator_autopilot.review_handoff_rework.enabled,
+                            target_state_name: providerWorkflow.operator_autopilot.review_handoff_rework.target_state_name,
+                            excluded_action_required_reasons: [
+                                ...providerWorkflow.operator_autopilot.review_handoff_rework.excluded_action_required_reasons
+                            ]
+                        },
+                        post_merge_rollout: {
+                            enabled: providerWorkflow.operator_autopilot.post_merge_rollout.enabled,
+                            summary: providerWorkflow.operator_autopilot.post_merge_rollout.summary,
+                            execution: providerWorkflow.operator_autopilot.post_merge_rollout.execution
+                        },
+                        audit_path: providerWorkflow.operator_autopilot.audit_path,
+                        lifecycle_path: providerWorkflow.operator_autopilot.lifecycle_path,
+                        execution_path: providerWorkflow.operator_autopilot.execution_path,
+                        last_result: providerWorkflow.operator_autopilot.last_result
+                            ? {
+                                recorded_at: providerWorkflow.operator_autopilot.last_result.recorded_at,
+                                status: providerWorkflow.operator_autopilot.last_result.status,
+                                summary: providerWorkflow.operator_autopilot.last_result.summary,
+                                error: providerWorkflow.operator_autopilot.last_result.error,
+                                actions: providerWorkflow.operator_autopilot.last_result.actions.map((action) => ({
+                                    kind: action.kind,
+                                    issue_id: action.issue_id,
+                                    issue_identifier: action.issue_identifier,
+                                    reason: action.reason,
+                                    summary: action.summary,
+                                    transition: {
+                                        status: action.transition.status,
+                                        attempted_at: action.transition.attempted_at,
+                                        previous_state: action.transition.previous_state,
+                                        target_state: action.transition.target_state,
+                                        issue_state: action.transition.issue_state,
+                                        issue_state_type: action.transition.issue_state_type,
+                                        issue_updated_at: action.transition.issue_updated_at,
+                                        force_path_used: action.transition.force_path_used ?? false,
+                                        error: action.transition.error
+                                    },
+                                    action_required_reasons: [...action.action_required_reasons]
+                                })),
+                                holds: providerWorkflow.operator_autopilot.last_result.holds.map((hold) => ({
+                                    kind: hold.kind,
+                                    issue_id: hold.issue_id,
+                                    issue_identifier: hold.issue_identifier,
+                                    issue_state: hold.issue_state ?? null,
+                                    issue_state_type: hold.issue_state_type ?? null,
+                                    issue_updated_at: hold.issue_updated_at ?? null,
+                                    promotion_attempted_at: hold.promotion_attempted_at ?? null,
+                                    promotion_issue_updated_at: hold.promotion_issue_updated_at ?? null,
+                                    force_path_used: hold.force_path_used ?? false,
+                                    reason: hold.reason,
+                                    summary: hold.summary,
+                                    action_required_reasons: [...hold.action_required_reasons]
+                                })),
+                                pending_actions: providerWorkflow.operator_autopilot.last_result.pending_actions.map((pendingAction) => ({
+                                    kind: pendingAction.kind,
+                                    action_instance_id: pendingAction.action_instance_id,
+                                    issue_id: pendingAction.issue_id,
+                                    issue_identifier: pendingAction.issue_identifier,
+                                    summary: pendingAction.summary,
+                                    merge_closeout_recorded_at: pendingAction.merge_closeout_recorded_at,
+                                    merge_closeout_reason: pendingAction.merge_closeout_reason,
+                                    shared_root_status: pendingAction.shared_root_status,
+                                    linear_transition_status: pendingAction.linear_transition_status,
+                                    executable_action_ids: [
+                                        ...(pendingAction.executable_action_ids ?? [])
+                                    ],
+                                    lifecycle_state: pendingAction.lifecycle_state,
+                                    lifecycle_actor: pendingAction.lifecycle_actor,
+                                    lifecycle_reason: pendingAction.lifecycle_reason,
+                                    lifecycle_recorded_at: pendingAction.lifecycle_recorded_at
+                                })),
+                                terminal_blocker_advisories: (providerWorkflow.operator_autopilot.last_result
+                                    .terminal_blocker_advisories ?? []).map((advisory) => ({
+                                    kind: advisory.kind,
+                                    issue_id: advisory.issue_id,
+                                    issue_identifier: advisory.issue_identifier,
+                                    issue_state: advisory.issue_state,
+                                    issue_state_type: advisory.issue_state_type,
+                                    issue_updated_at: advisory.issue_updated_at,
+                                    blockers: advisory.blockers.map((blocker) => ({
+                                        id: blocker.id,
+                                        identifier: blocker.identifier,
+                                        state: blocker.state,
+                                        state_type: blocker.state_type
+                                    })),
+                                    canonical_owner_hints: [...advisory.canonical_owner_hints],
+                                    duplicate_hints: [...advisory.duplicate_hints],
+                                    recommended_action: advisory.recommended_action,
+                                    summary: advisory.summary
+                                })),
+                                resolved_actions: (providerWorkflow.operator_autopilot.last_result.resolved_actions ?? []).map((resolvedAction) => ({
+                                    kind: resolvedAction.kind,
+                                    action_instance_id: resolvedAction.action_instance_id,
+                                    issue_id: resolvedAction.issue_id,
+                                    issue_identifier: resolvedAction.issue_identifier,
+                                    summary: resolvedAction.summary,
+                                    merge_closeout_recorded_at: resolvedAction.merge_closeout_recorded_at,
+                                    merge_closeout_reason: resolvedAction.merge_closeout_reason,
+                                    shared_root_status: resolvedAction.shared_root_status,
+                                    linear_transition_status: resolvedAction.linear_transition_status,
+                                    executable_action_ids: [
+                                        ...(resolvedAction.executable_action_ids ?? [])
+                                    ],
+                                    lifecycle_state: resolvedAction.lifecycle_state,
+                                    lifecycle_actor: resolvedAction.lifecycle_actor,
+                                    lifecycle_reason: resolvedAction.lifecycle_reason,
+                                    lifecycle_recorded_at: resolvedAction.lifecycle_recorded_at
+                                })),
+                                lifecycle_records: (providerWorkflow.operator_autopilot.last_result.lifecycle_records ?? []).map((record) => ({
+                                    action_instance_id: record.action_instance_id,
+                                    kind: record.kind,
+                                    issue_id: record.issue_id,
+                                    issue_identifier: record.issue_identifier,
+                                    state: record.state,
+                                    actor: record.actor,
+                                    reason: record.reason,
+                                    recorded_at: record.recorded_at,
+                                    source: record.source
+                                })),
+                                local_rollout_execution_attempts: (providerWorkflow.operator_autopilot.last_result
+                                    .local_rollout_execution_attempts ?? []).map((attempt) => ({
+                                    action_instance_id: attempt.action_instance_id,
+                                    record_kind: attempt.record_kind,
+                                    action_id: attempt.action_id,
+                                    issue_id: attempt.issue_id,
+                                    issue_identifier: attempt.issue_identifier,
+                                    preflight: {
+                                        status: attempt.preflight.status,
+                                        reason: attempt.preflight.reason,
+                                        checked_at: attempt.preflight.checked_at,
+                                        summary: attempt.preflight.summary
+                                    },
+                                    started_at: attempt.started_at,
+                                    ended_at: attempt.ended_at,
+                                    terminal_state: attempt.terminal_state,
+                                    reason: attempt.reason,
+                                    summary: attempt.summary,
+                                    command: {
+                                        runner: attempt.command.runner,
+                                        command: attempt.command.command,
+                                        args: [...attempt.command.args],
+                                        cwd: attempt.command.cwd,
+                                        timeout_ms: attempt.command.timeout_ms
+                                    },
+                                    exit_code: attempt.exit_code,
+                                    stdout: attempt.stdout,
+                                    stderr: attempt.stderr
+                                })),
+                                backlog_promotion_snapshots: (providerWorkflow.operator_autopilot.last_result
+                                    .backlog_promotion_snapshots ?? []).map((snapshot) => ({
+                                    issue_id: snapshot.issue_id,
+                                    issue_identifier: snapshot.issue_identifier,
+                                    target_state: snapshot.target_state,
+                                    attempted_at: snapshot.attempted_at,
+                                    issue_updated_at: snapshot.issue_updated_at,
+                                    force_path_used: snapshot.force_path_used,
+                                    untracked_cycles: snapshot.untracked_cycles ?? 0
+                                })),
+                                backlog_promotion_snapshot_retention_records: (providerWorkflow.operator_autopilot.last_result
+                                    .backlog_promotion_snapshot_retention_records ?? []).map((record) => ({
+                                    issue_id: record.issue_id,
+                                    issue_identifier: record.issue_identifier,
+                                    target_state: record.target_state,
+                                    attempted_at: record.attempted_at,
+                                    issue_updated_at: record.issue_updated_at,
+                                    evaluated_at: record.evaluated_at,
+                                    decision: record.decision,
+                                    reason: record.reason,
+                                    age_ms: record.age_ms,
+                                    untracked_cycles: record.untracked_cycles,
+                                    max_untracked_cycles: record.max_untracked_cycles,
+                                    issue_state: record.issue_state,
+                                    issue_state_type: record.issue_state_type,
+                                    issue_archived_at: record.issue_archived_at,
+                                    issue_trashed: record.issue_trashed,
+                                    issue_observed_updated_at: record.issue_observed_updated_at,
+                                    terminal_state_evidence: record.terminal_state_evidence,
+                                    force_path_used: record.force_path_used
+                                }))
+                            }
+                            : null
+                    }
+                    : null
+            }
+            : null
+    };
+}