@shapeshift-labs/frontier-swarm 0.5.22 → 0.5.24

package/dist/index.js

@@ -1,4 +1,5 @@
 import { createRunDashboardSnapshot, createRunEdgeEvent, createRunEvent, createRunNodeEvent, defineRunArtifact, defineRunAttempt, defineRunDecision, defineRunEvidence, defineRunLane, defineRunPatch, defineRunTask, defineRunVerification, linkRunNodes, replayRunEvents } from '@shapeshift-labs/frontier-run';
+import { acquireSemanticLease, createSemanticLeaseState, defineSemanticLeaseScope, validateSemanticLeaseFence } from '@shapeshift-labs/frontier-lease';
 export const FRONTIER_SWARM_MANIFEST_KIND = 'frontier.swarm.manifest';
 export const FRONTIER_SWARM_MANIFEST_VERSION = 1;
 export const FRONTIER_SWARM_TASK_KIND = 'frontier.swarm.task';
@@ -2294,6 +2295,45 @@ export function createRunProjectionFromSwarmRunEvents(events, options = {}) {
         metadata: toJsonObject(options.metadata)
     });
 }
+export function createSwarmRunFromRunProjection(projection, options) {
+    const plan = options.plan;
+    const results = plan.jobs
+        .map((job) => deriveSwarmResultFromRunProjection(projection, job))
+        .filter((result) => !!result);
+    const run = createSwarmRun({
+        id: options.id ?? projection.run.id ?? plan.runId,
+        plan,
+        startedAt: options.startedAt ?? parseRunTimeMs(projection.run.createdAt, plan.createdAt),
+        status: options.status ?? deriveSwarmRunStatusFromResults(plan.jobs, results),
+        events: createSwarmEventsFromRunProjection(projection),
+        results,
+        metadata: mergeSwarmMetadata([
+            projection.run.metadata,
+            options.metadata,
+            { source: 'frontier-run.projection', frontierRunId: projection.run.id }
+        ])
+    });
+    const finishedAt = latestSwarmResultFinishedAt(run.results);
+    return finishedAt === undefined ? run : { ...run, finishedAt };
+}
+export function createSwarmQueueOverlayFromRunProjection(projection, options) {
+    const run = createSwarmRunFromRunProjection(projection, {
+        plan: options.plan,
+        id: projection.run.id,
+        startedAt: parseRunTimeMs(projection.run.createdAt, options.plan.createdAt),
+        metadata: options.metadata
+    });
+    return createSwarmQueueOverlay({
+        id: options.id,
+        runId: run.id,
+        results: run.results,
+        generatedAt: options.generatedAt,
+        metadata: mergeSwarmMetadata([
+            options.metadata,
+            { source: 'frontier-run.projection', frontierRunId: projection.run.id }
+        ])
+    });
+}
 export function createRunDashboardFromSwarmRun(input, options = {}) {
     const events = isFrontierRunEventList(input) ? input : createRunEventsFromSwarmRun(input, options);
     return createRunDashboardSnapshot(createRunProjectionFromSwarmRunEvents(events, options));
@@ -4075,6 +4115,11 @@ export function createSwarmHierarchicalMergeQueue(input) {
     const admissionPressure = summarizeSwarmMergeAdmissionPressure(assignments);
     const orderedScopes = Array.from(scopes.values()).sort((left, right) => (mergeQueueScopeRank(left.kind) - mergeQueueScopeRank(right.kind)
         || left.id.localeCompare(right.id)));
+    const semanticLeaseScopeMap = createSwarmSemanticLeaseScopeMap(orderedScopes, {
+        rootScopeId,
+        ...semanticLeaseScopeOptionsFromMetadata(input.metadata)
+    });
+    const scopesWithSemanticLeases = orderedScopes.map((scope) => attachSemanticLeaseScopeToMergeQueueScope(scope, semanticLeaseScopeMap));
     const queueId = input.id ?? 'swarm-hierarchical-merge-queue:' + stableHash([input.index.id, input.admission?.id, orderedScopes, assignments, promotions, generatedAt]);
     const linkedAssignments = assignments.map((assignment) => {
         if (!coordinatorAgentDrainActionIsTerminal(assignment.action))
@@ -4084,19 +4129,19 @@ export function createSwarmHierarchicalMergeQueue(input) {
             terminalDecisionId: hierarchicalQueueTerminalDecisionId(queueId, assignment),
             terminalDecisionQueueItemIds: [...assignment.queueItemIds]
         };
-    });
+    }).map((assignment) => attachSemanticLeaseScopesToAssignment(assignment, semanticLeaseScopeMap));
     const leaseRecords = createHierarchicalQueueLeaseRecords({
         queueId,
         rootScopeId,
         generatedAt,
-        scopes: orderedScopes,
+        scopes: scopesWithSemanticLeases,
         assignments: linkedAssignments,
         promotions,
         localLeader: input.localLeader,
         localLeaders: input.localLeaders
     });
     const byLeaseKey = groupJobIdsByMany(linkedAssignments, (assignment) => assignment.requiredLeaseKeys ?? [assignment.leaseKey]);
-    const scopeTree = createHierarchicalQueueScopeTree(orderedScopes, rootScopeId);
+    const scopeTree = createHierarchicalQueueScopeTree(scopesWithSemanticLeases, rootScopeId);
     return {
         kind: FRONTIER_SWARM_HIERARCHICAL_MERGE_QUEUE_KIND,
         version: FRONTIER_SWARM_HIERARCHICAL_MERGE_QUEUE_VERSION,
@@ -4106,13 +4151,14 @@ export function createSwarmHierarchicalMergeQueue(input) {
         generatedAt,
         rootScopeId,
         scopeTree,
-        scopes: orderedScopes,
+        scopes: scopesWithSemanticLeases,
         leaseRecords,
         assignments: linkedAssignments,
         promotions,
         byScope,
         byLeaseKey,
         byAction,
+        semanticLeaseScopes: uniqueSemanticLeaseScopes(Array.from(semanticLeaseScopeMap.values())),
         summary: {
             scopeCount: orderedScopes.length,
             assignmentCount: linkedAssignments.length,
@@ -4142,6 +4188,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
             title: scope.title,
             leaseScope: scope.leaseKey,
             leaseKey: scope.leaseKey,
+            ...(scope.semanticLeaseScope ? { semanticLeaseScope: scope.semanticLeaseScope } : {}),
             ...(scope.parentId ? { parentQueueId: scope.parentId } : {}),
             ...(scope.lane ? { lane: scope.lane } : {}),
             changedPaths: [...scope.changedPaths],
@@ -4171,6 +4218,9 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         const requiredLeaseKeys = assignmentRequiredLeaseKeys.length
             ? [...assignmentRequiredLeaseKeys]
             : [leaseScope];
+        const requiredSemanticLeaseScopes = requiredLeaseScopeIds
+            .map((scopeId) => scopesById.get(scopeId)?.semanticLeaseScope)
+            .filter((scope) => Boolean(scope));
         const decision = coordinatorAgentDrainDecisionForAction(assignment.action);
         const terminal = coordinatorAgentDrainActionIsTerminal(assignment.action);
         const parentQueueId = assignment.action === 'promote'
@@ -4207,6 +4257,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
             conflictingJobIds: [...assignment.conflictingJobIds],
             requiredLeaseScopeIds,
             requiredLeaseKeys,
+            ...(requiredSemanticLeaseScopes.length ? { requiredSemanticLeaseScopes } : {}),
             ...(assignment.retrySlices?.length ? { retrySlices: cloneMergeQueueRetrySlices(assignment.retrySlices) } : {}),
             ...(assignment.semanticSliceScopeIds?.length ? { semanticSliceScopeIds: [...assignment.semanticSliceScopeIds] } : {}),
             ...(assignment.semanticSliceLeaseKeys?.length ? { semanticSliceLeaseKeys: [...assignment.semanticSliceLeaseKeys] } : {}),
@@ -4231,6 +4282,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         reasons: [...assignment.reasons],
         requiredLeaseScopeIds: [...(assignment.requiredLeaseScopeIds ?? [])],
         requiredLeaseKeys: [...(assignment.requiredLeaseKeys ?? [])],
+        ...(assignment.requiredSemanticLeaseScopes?.length ? { requiredSemanticLeaseScopes: assignment.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope) } : {}),
         ...(assignment.retrySlices?.length ? { retrySlices: cloneMergeQueueRetrySlices(assignment.retrySlices) } : {}),
         ...(assignment.semanticSliceScopeIds?.length ? { semanticSliceScopeIds: [...assignment.semanticSliceScopeIds] } : {}),
         ...(assignment.semanticSliceLeaseKeys?.length ? { semanticSliceLeaseKeys: [...assignment.semanticSliceLeaseKeys] } : {}),
@@ -4257,6 +4309,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         reasons: [...assignment.reasons],
         requiredLeaseScopeIds: [...(assignment.requiredLeaseScopeIds ?? [])],
         requiredLeaseKeys: [...(assignment.requiredLeaseKeys ?? [])],
+        ...(assignment.requiredSemanticLeaseScopes?.length ? { requiredSemanticLeaseScopes: assignment.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope) } : {}),
         ...(assignment.metadata ? { metadata: cloneJsonValue(assignment.metadata) } : {})
     }));
     const activeAssignments = assignments.filter((assignment) => !coordinatorAgentDrainAssignmentIsTerminal(assignment));
@@ -4314,6 +4367,120 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
     };
 }
+export function createSwarmSemanticLeaseScopeForMergeQueueScope(scope, input = {}) {
+    const scopesById = new Map((input.scopes ?? []).map((entry) => [entry.id, entry]));
+    const parentKeys = [];
+    let parentId = scope.parentId;
+    const visited = new Set([scope.id]);
+    while (parentId && !visited.has(parentId)) {
+        const parent = scopesById.get(parentId);
+        if (!parent)
+            break;
+        parentKeys.push(parent.leaseKey);
+        visited.add(parentId);
+        parentId = parent.parentId;
+    }
+    const regionId = scope.changedRegions.length === 1 ? scope.changedRegions[0] : scope.id;
+    const path = scope.changedPaths.length === 1 ? scope.changedPaths[0] : undefined;
+    const metadata = mergeSwarmMetadata([
+        scope.metadata,
+        toJsonObject(input.metadata),
+        {
+            swarmQueueScopeId: scope.id,
+            swarmQueueScopeKind: scope.kind,
+            swarmLeaseKey: scope.leaseKey,
+            changedPaths: scope.changedPaths,
+            changedRegions: scope.changedRegions
+        }
+    ]);
+    return defineSemanticLeaseScope({
+        kind: semanticLeaseScopeKindForMergeQueueScope(scope),
+        key: scope.leaseKey,
+        repository: input.repository,
+        packageId: input.packageId,
+        lane: scope.lane,
+        path,
+        regionId,
+        name: semanticLeaseScopeNameForMergeQueueScope(scope),
+        parentKeys,
+        metadata
+    });
+}
+export function createSwarmSemanticLeaseScopesForMergeQueue(queue, input = {}) {
+    const existing = queue.scopes
+        .map((scope) => scope.semanticLeaseScope)
+        .filter((scope) => Boolean(scope));
+    if (existing.length)
+        return uniqueSemanticLeaseScopes(existing);
+    return uniqueSemanticLeaseScopes(queue.scopes.map((scope) => (createSwarmSemanticLeaseScopeForMergeQueueScope(scope, {
+        ...input,
+        rootScopeId: input.rootScopeId ?? queue.rootScopeId,
+        scopes: queue.scopes
+    }))));
+}
+export function createSwarmSemanticLeaseStateForMergeQueue(queue, input = {}) {
+    const semanticLeaseScopes = createSwarmSemanticLeaseScopesForMergeQueue(queue, input);
+    return createSemanticLeaseState({
+        id: input.id ?? `frontier-swarm-merge-queue:${queue.id}`,
+        defaultTtlMs: input.defaultTtlMs,
+        metadata: mergeSwarmMetadata([
+            toJsonObject(input.metadata),
+            {
+                swarmQueueId: queue.id,
+                swarmMergeIndexId: queue.mergeIndexId,
+                rootScopeId: queue.rootScopeId,
+                semanticLeaseScopeCount: semanticLeaseScopes.length,
+                generatedAt: input.now ?? queue.generatedAt
+            }
+        ])
+    });
+}
+export function acquireSwarmCoordinatorSemanticLease(input) {
+    const scopes = semanticLeaseScopesForCoordinatorAssignment(input.queue, input.assignment, input);
+    const requiredLeaseScopeIds = coordinatorAssignmentRequiredLeaseScopeIds(input.assignment);
+    const requiredLeaseKeys = coordinatorAssignmentRequiredLeaseKeys(input.assignment, scopes);
+    const state = input.state ?? createSwarmSemanticLeaseStateForMergeQueue(input.queue, input);
+    const acquireInput = {
+        ownerId: input.ownerId,
+        holderId: input.holderId,
+        now: input.now,
+        ttlMs: input.ttlMs,
+        purpose: input.purpose ?? `frontier swarm coordinator apply: ${input.assignment.jobId}`,
+        reason: input.reason,
+        scopes,
+        metadata: mergeSwarmMetadata([
+            toJsonObject(input.metadata),
+            {
+                swarmQueueId: input.queue.id,
+                swarmJobId: input.assignment.jobId,
+                swarmTaskId: input.assignment.taskId,
+                requiredLeaseScopeIds,
+                requiredLeaseKeys
+            }
+        ])
+    };
+    const mutation = acquireSemanticLease(state, acquireInput);
+    return {
+        state: mutation.state,
+        mutation,
+        scopes,
+        requiredLeaseScopeIds,
+        requiredLeaseKeys,
+        ...(mutation.lease ? { lease: mutation.lease } : {})
+    };
+}
+export function validateSwarmCoordinatorSemanticLeaseFence(input) {
+    const requiredScopes = input.requiredSemanticLeaseScopes?.length
+        ? input.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope)
+        : (input.assignment.requiredSemanticLeaseScopes ?? []).map(cloneSemanticLeaseScope);
+    return validateSemanticLeaseFence(input.state, {
+        leaseId: input.leaseId ?? input.lease?.id ?? '',
+        token: input.token,
+        fencingToken: input.fencingToken,
+        now: input.now,
+        scopes: requiredScopes.length ? requiredScopes : undefined
+    });
+}
 export function summarizeSwarmCoordinatorAgentDrainWork(work) {
     const activeAssignments = work.assignments.filter((assignment) => !coordinatorAgentDrainAssignmentIsTerminal(assignment));
     const terminalAssignments = work.assignments.filter((assignment) => coordinatorAgentDrainAssignmentIsTerminal(assignment));
@@ -5888,6 +6055,154 @@ function ensureMergeQueueScope(scopes, input) {
     scopes.set(scope.id, scope);
     return scope;
 }
+function createSwarmSemanticLeaseScopeMap(scopes, input = {}) {
+    const out = new Map();
+    for (const scope of scopes) {
+        out.set(scope.id, createSwarmSemanticLeaseScopeForMergeQueueScope(scope, { ...input, scopes }));
+    }
+    return out;
+}
+function attachSemanticLeaseScopeToMergeQueueScope(scope, semanticLeaseScopes) {
+    const semanticLeaseScope = semanticLeaseScopes.get(scope.id);
+    return {
+        ...scope,
+        ...(semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(semanticLeaseScope) } : {})
+    };
+}
+function attachSemanticLeaseScopesToAssignment(assignment, semanticLeaseScopes) {
+    const requiredLeaseScopeIds = assignment.requiredLeaseScopeIds?.length ? assignment.requiredLeaseScopeIds : [assignment.scopeId];
+    const requiredSemanticLeaseScopes = requiredLeaseScopeIds
+        .map((scopeId) => semanticLeaseScopes.get(scopeId))
+        .filter((scope) => Boolean(scope))
+        .map(cloneSemanticLeaseScope);
+    const retrySlices = assignment.retrySlices?.map((slice) => {
+        const requiredScopeIds = slice.requiredLeaseScopeIds?.length ? slice.requiredLeaseScopeIds : [slice.scopeId];
+        const requiredScopes = requiredScopeIds
+            .map((scopeId) => semanticLeaseScopes.get(scopeId))
+            .filter((scope) => Boolean(scope))
+            .map(cloneSemanticLeaseScope);
+        const semanticLeaseScope = semanticLeaseScopes.get(slice.scopeId);
+        return {
+            ...slice,
+            ...(semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(semanticLeaseScope) } : {}),
+            ...(requiredScopes.length ? { requiredSemanticLeaseScopes: requiredScopes } : {})
+        };
+    });
+    return {
+        ...assignment,
+        ...(requiredSemanticLeaseScopes.length ? { requiredSemanticLeaseScopes } : {}),
+        ...(retrySlices?.length ? { retrySlices } : {})
+    };
+}
+function semanticLeaseScopesForCoordinatorAssignment(queue, assignment, input = {}) {
+    if (assignment.requiredSemanticLeaseScopes?.length) {
+        return uniqueSemanticLeaseScopes(assignment.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope));
+    }
+    const queueScopes = new Map(queue.scopes.map((scope) => [scope.id, scope]));
+    const semanticByKey = new Map(createSwarmSemanticLeaseScopesForMergeQueue(queue, input).map((scope) => [scope.key, scope]));
+    const fromIds = coordinatorAssignmentRequiredLeaseScopeIds(assignment)
+        .map((scopeId) => queueScopes.get(scopeId)?.semanticLeaseScope)
+        .filter((scope) => Boolean(scope));
+    if (fromIds.length)
+        return uniqueSemanticLeaseScopes(fromIds);
+    const fromKeys = coordinatorAssignmentRequiredLeaseKeys(assignment, [])
+        .map((key) => semanticByKey.get(key))
+        .filter((scope) => Boolean(scope));
+    if (fromKeys.length)
+        return uniqueSemanticLeaseScopes(fromKeys);
+    const fallbackKey = 'leaseScope' in assignment ? assignment.leaseScope : assignment.leaseKey;
+    return [defineSemanticLeaseScope({
+            kind: 'custom',
+            key: fallbackKey,
+            repository: input.repository,
+            packageId: input.packageId,
+            metadata: mergeSwarmMetadata([
+                toJsonObject(input.metadata),
+                {
+                    swarmQueueId: queue.id,
+                    swarmJobId: assignment.jobId,
+                    fallbackLeaseKey: fallbackKey
+                }
+            ])
+        })];
+}
+function coordinatorAssignmentRequiredLeaseScopeIds(assignment) {
+    const explicit = assignment.requiredLeaseScopeIds ?? [];
+    if (explicit.length)
+        return uniqueStrings(explicit);
+    return uniqueStrings(['queueId' in assignment ? assignment.queueId : assignment.scopeId]);
+}
+function coordinatorAssignmentRequiredLeaseKeys(assignment, scopes) {
+    const explicit = assignment.requiredLeaseKeys ?? [];
+    if (explicit.length)
+        return uniqueStrings(explicit);
+    if (scopes.length)
+        return uniqueStrings(scopes.map((scope) => scope.key));
+    return uniqueStrings(['leaseScope' in assignment ? assignment.leaseScope : assignment.leaseKey]);
+}
+function semanticLeaseScopeOptionsFromMetadata(metadata) {
+    const object = toJsonObject(metadata);
+    if (!object)
+        return {};
+    return {
+        ...(typeof object.repository === 'string' ? { repository: object.repository } : {}),
+        ...(typeof object.packageId === 'string' ? { packageId: object.packageId } : {})
+    };
+}
+function semanticLeaseScopeKindForMergeQueueScope(scope) {
+    if (scope.kind === 'root')
+        return 'repository';
+    if (scope.kind === 'path')
+        return 'path';
+    if (scope.kind === 'lane')
+        return 'lane';
+    if (scope.kind === 'semantic-region' || scope.kind === 'semantic')
+        return semanticLeaseScopeKindForRegion(scope.changedRegions[0]);
+    if (scope.kind === 'package')
+        return 'package';
+    return 'custom';
+}
+function semanticLeaseScopeKindForRegion(region) {
+    if (!region)
+        return 'semantic-region';
+    const normalized = region.toLowerCase();
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_EXPORT_STABLE_KEY_KIND) || normalized.includes('named-export') || normalized.includes('default-export'))
+        return 'export';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_TYPE_STABLE_KEY_KIND) || normalized.includes('interface') || normalized.includes('type-alias'))
+        return 'type';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_CLI_COMMAND_STABLE_KEY_KIND))
+        return 'cli-command';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_DOCS_SECTION_STABLE_KEY_KIND))
+        return 'docs-section';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_FIXTURE_FAMILY_STABLE_KEY_KIND))
+        return 'test-fixture';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_TEST_CASE_STABLE_KEY_KIND))
+        return 'test-fixture';
+    if (normalized.includes('function'))
+        return 'function';
+    if (normalized.includes('class'))
+        return 'class';
+    if (normalized.includes('member'))
+        return 'member';
+    return 'semantic-region';
+}
+function semanticLeaseScopeNameForMergeQueueScope(scope) {
+    const region = scope.changedRegions[0];
+    if (region)
+        return region.split(':').filter(Boolean).at(-1);
+    if (scope.changedPaths.length === 1)
+        return scope.changedPaths[0].split('/').at(-1);
+    return scope.title || scope.id;
+}
+function uniqueSemanticLeaseScopes(scopes) {
+    const out = new Map();
+    for (const scope of scopes)
+        out.set(scope.key, cloneSemanticLeaseScope(scope));
+    return Array.from(out.values()).sort((left, right) => left.key.localeCompare(right.key));
+}
+function cloneSemanticLeaseScope(scope) {
+    return cloneJsonValue(scope);
+}
 function mergeQueueRootLeaseKey(rootScopeId) {
     return `merge:root:${rootScopeId}`;
 }
@@ -6002,6 +6317,8 @@ function cloneMergeQueueRetrySlices(slices) {
         leaseKey: slice.leaseKey,
         ...(slice.requiredLeaseScopeIds?.length ? { requiredLeaseScopeIds: [...slice.requiredLeaseScopeIds] } : {}),
         ...(slice.requiredLeaseKeys?.length ? { requiredLeaseKeys: [...slice.requiredLeaseKeys] } : {}),
+        ...(slice.semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(slice.semanticLeaseScope) } : {}),
+        ...(slice.requiredSemanticLeaseScopes?.length ? { requiredSemanticLeaseScopes: slice.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope) } : {}),
         ...(slice.lane ? { lane: slice.lane } : {}),
         changedPaths: [...slice.changedPaths],
         changedRegions: [...slice.changedRegions],
@@ -6051,6 +6368,7 @@ function createHierarchicalQueueLeaseRecords(input) {
             ...(scope.lane ? { lane: scope.lane } : {}),
             title: scope.title,
             leaseKey: scope.leaseKey,
+            ...(scope.semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(scope.semanticLeaseScope) } : {}),
             ...(hierarchicalQueueLocalLeaderForScope(input, scope) ? { localLeader: hierarchicalQueueLocalLeaderForScope(input, scope) } : {}),
             promotion: {
                 state: promotionState,
@@ -10173,6 +10491,258 @@ function swarmRunEventTime(options, fallback) {
     const value = options.now ?? fallback;
     return new Date(Number.isFinite(value) ? value : Date.now()).toISOString();
 }
+function createSwarmEventsFromRunProjection(projection) {
+    return projection.events.map((event) => ({
+        id: `frontier-run:${event.id}`,
+        type: event.type,
+        runId: projection.run.id,
+        at: parseRunTimeMs(event.time, Date.now()),
+        message: event.type,
+        data: event.payload,
+        metadata: pruneUndefinedJsonObject({
+            source: 'frontier-run.event',
+            eventId: event.id,
+            actorId: event.actorId,
+            actorSeq: event.actorSeq,
+            parents: event.parents
+        })
+    }));
+}
+function deriveSwarmResultFromRunProjection(projection, job) {
+    const graph = projection.run.graph;
+    const nodes = Object.values(graph.nodes);
+    const edges = Object.values(graph.edges);
+    const attempt = nodes.find((node) => node.kind === 'attempt' && runNodeMatchesJob(node, job));
+    const attemptId = attempt?.id ?? swarmRunAttemptNodeId(job.id);
+    const patchNodes = nodes.filter((node) => node.kind === 'patch' && runNodeMatchesJob(node, job));
+    const patchIds = new Set(patchNodes.map((node) => node.id));
+    const verificationNodeIds = new Set(edges
+        .filter((edge) => edge.from === attemptId && edge.type === 'verified-by')
+        .map((edge) => edge.to));
+    const verificationNodes = nodes.filter((node) => (node.kind === 'verification'
+        && (runNodeMatchesJob(node, job) || verificationNodeIds.has(node.id))));
+    const decisionNodes = nodes.filter((node) => (node.kind === 'decision'
+        && (runNodeMatchesJob(node, job) || runDecisionSubjectsJob(node, job, patchIds))));
+    const evidenceNodes = nodes.filter((node) => (node.kind === 'evidence'
+        && (runNodeMatchesJob(node, job) || runEvidenceLinkedToJob(node, attemptId, patchIds, edges))));
+    const hasProjectionResult = !!attempt || patchNodes.length > 0 || verificationNodes.length > 0 || evidenceNodes.length > 0 || decisionNodes.length > 0;
+    if (!hasProjectionResult)
+        return undefined;
+    const attemptMetadata = attempt ? runNodeMetadata(attempt) : undefined;
+    const patchMetadata = patchNodes.map(runNodeMetadata);
+    const decisionMetadata = decisionNodes.map(runNodeMetadata);
+    const mergedMetadata = mergeSwarmMetadata([
+        attemptMetadata,
+        ...patchMetadata,
+        ...decisionMetadata,
+        { source: 'frontier-run.projection', frontierRunId: projection.run.id }
+    ]);
+    const changedPaths = uniqueStrings(patchNodes.flatMap((node) => node.kind === 'patch' ? node.changedPaths : []));
+    const changedRegions = uniqueStrings(patchMetadata.flatMap((metadata) => jsonStringArray(metadata?.changedRegions)));
+    const ownershipViolations = uniqueStrings(patchMetadata.flatMap((metadata) => jsonStringArray(metadata?.ownershipViolations)));
+    const evidencePaths = deriveRunEvidencePaths(nodes, edges, attemptId, patchIds, evidenceNodes);
+    const patchPath = deriveRunPatchPath(nodes, edges, patchNodes);
+    const status = deriveSwarmResultStatusFromRunAttempt(attempt, verificationNodes, patchNodes);
+    const error = status === 'failed' || status === 'blocked'
+        ? (runMetadataString(attemptMetadata, 'reason') ?? (attempt?.kind === 'attempt' ? attempt.reason : undefined))
+        : undefined;
+    const startedAt = attempt?.kind === 'attempt' ? parseOptionalRunTimeMs(attempt.startedAt) : undefined;
+    const finishedAt = attempt?.kind === 'attempt' ? parseOptionalRunTimeMs(attempt.endedAt) : undefined;
+    return {
+        jobId: job.id,
+        status,
+        mergeReadiness: readSwarmMergeReadiness(attemptMetadata, patchMetadata, decisionMetadata),
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(finishedAt !== undefined ? { finishedAt } : {}),
+        ...(runMetadataNumber(attemptMetadata, 'exitCode') !== undefined ? { exitCode: runMetadataNumber(attemptMetadata, 'exitCode') } : {}),
+        ...(runMetadataString(attemptMetadata, 'signal') ? { signal: runMetadataString(attemptMetadata, 'signal') } : {}),
+        changedPaths,
+        changedRegions,
+        ownershipViolations,
+        evidencePaths,
+        ...(patchPath ? { patchPath } : {}),
+        queueItemIds: uniqueStrings([
+            ...jsonStringArray(attemptMetadata?.queueItemIds),
+            ...patchMetadata.flatMap((metadata) => jsonStringArray(metadata?.queueItemIds)),
+            ...decisionMetadata.flatMap((metadata) => jsonStringArray(metadata?.queueItemIds))
+        ]),
+        riskLevel: readSwarmRiskLevel(attemptMetadata, patchMetadata),
+        mergeDisposition: readSwarmMergeDisposition(attemptMetadata, patchMetadata, decisionMetadata),
+        verification: verificationNodes.map((node) => runVerificationNodeToSwarmResult(node)),
+        ...(attemptMetadata?.semanticImport !== undefined ? { semanticImport: cloneJsonValue(attemptMetadata.semanticImport) } : {}),
+        ...(patchNodes[0]?.kind === 'patch' && patchNodes[0].summary ? { lastMessage: patchNodes[0].summary } : {}),
+        ...(error ? { error } : {}),
+        ...(mergedMetadata ? { metadata: mergedMetadata } : {})
+    };
+}
+function runNodeMatchesJob(node, job) {
+    const metadata = runNodeMetadata(node);
+    const metadataJobId = runMetadataString(metadata, 'jobId');
+    if (metadataJobId === job.id)
+        return true;
+    if (node.kind === 'attempt' && node.taskId === swarmRunTaskNodeId(job.taskId))
+        return true;
+    if (node.kind === 'task' && node.id === swarmRunTaskNodeId(job.taskId))
+        return true;
+    if ((node.kind === 'attempt' || node.kind === 'patch') && stripRunNodePrefix(node.id, node.kind) === job.id)
+        return true;
+    return false;
+}
+function runDecisionSubjectsJob(node, job, patchIds) {
+    if (node.kind !== 'decision')
+        return false;
+    const taskId = swarmRunTaskNodeId(job.taskId);
+    return node.subjectIds.some((subjectId) => subjectId === taskId || patchIds.has(subjectId));
+}
+function runEvidenceLinkedToJob(node, attemptId, patchIds, edges) {
+    if (node.kind !== 'evidence')
+        return false;
+    return edges.some((edge) => edge.to === node.id && (edge.from === attemptId || patchIds.has(edge.from)));
+}
+function deriveRunEvidencePaths(nodes, edges, attemptId, patchIds, evidenceNodes) {
+    const artifacts = new Map(nodes
+        .filter((node) => node.kind === 'artifact')
+        .map((node) => [node.id, node]));
+    const subjectIds = new Set([attemptId, ...patchIds]);
+    const linkedArtifactIds = edges
+        .filter((edge) => edge.type === 'produces-artifact' && subjectIds.has(edge.from))
+        .map((edge) => edge.to);
+    return uniqueStrings([
+        ...evidenceNodes.flatMap((node) => node.kind === 'evidence' ? (node.artifactIds ?? []) : [])
+            .map((artifactId) => runArtifactPath(artifacts.get(artifactId)))
+            .filter((file) => !!file),
+        ...linkedArtifactIds
+            .map((artifactId) => artifacts.get(artifactId))
+            .filter((node) => !!node && node.kind === 'artifact' && node.artifactType !== 'patch')
+            .map(runArtifactPath)
+            .filter((file) => !!file)
+    ]);
+}
+function deriveRunPatchPath(nodes, edges, patchNodes) {
+    const artifacts = new Map(nodes
+        .filter((node) => node.kind === 'artifact')
+        .map((node) => [node.id, node]));
+    for (const patch of patchNodes) {
+        if (patch.kind !== 'patch')
+            continue;
+        const metadataPatchPath = runMetadataString(runNodeMetadata(patch), 'patchPath');
+        if (metadataPatchPath)
+            return metadataPatchPath;
+        if (patch.artifactId) {
+            const artifactPath = runArtifactPath(artifacts.get(patch.artifactId));
+            if (artifactPath)
+                return artifactPath;
+        }
+        const attached = edges
+            .filter((edge) => edge.from === patch.id && edge.type === 'produces-artifact')
+            .map((edge) => artifacts.get(edge.to))
+            .find((node) => node?.kind === 'artifact' && node.artifactType === 'patch');
+        const attachedPath = runArtifactPath(attached);
+        if (attachedPath)
+            return attachedPath;
+    }
+    return undefined;
+}
+function runVerificationNodeToSwarmResult(node) {
+    if (node.kind !== 'verification')
+        return { name: node.id };
+    const metadata = runNodeMetadata(node);
+    const command = node.command ? [node.command, ...(node.args ?? [])] : [];
+    return {
+        name: node.title ?? node.id,
+        command,
+        ...(command.length ? { commandLine: command.join(' ') } : {}),
+        ...(node.cwd ? { cwd: node.cwd } : {}),
+        ...(node.exitCode !== undefined ? { status: node.exitCode } : { status: node.status === 'passed' ? 0 : node.status === 'failed' ? 1 : undefined }),
+        ...(runMetadataNumber(metadata, 'durationMs') !== undefined ? { durationMs: runMetadataNumber(metadata, 'durationMs') } : {}),
+        stdoutTail: jsonStringArray(metadata?.stdoutTail),
+        stderrTail: jsonStringArray(metadata?.stderrTail),
+        required: node.required ?? true,
+        ...(runMetadataString(metadata, 'category') ? { category: runMetadataString(metadata, 'category') } : {}),
+        ...(metadata ? { metadata } : {})
+    };
+}
+function deriveSwarmResultStatusFromRunAttempt(attempt, verificationNodes, patchNodes) {
+    if (attempt?.kind === 'attempt') {
+        if (attempt.status === 'completed')
+            return 'completed';
+        if (attempt.status === 'running')
+            return 'running';
+        if (attempt.status === 'queued')
+            return 'scheduled';
+        if (attempt.status === 'cancelled' || attempt.status === 'timed-out' || attempt.status === 'failed')
+            return 'failed';
+    }
+    if (verificationNodes.some((node) => node.kind === 'verification' && node.required !== false && node.status === 'failed'))
+        return 'failed';
+    if (patchNodes.length > 0 || verificationNodes.length > 0)
+        return 'completed';
+    return 'planned';
+}
+function deriveSwarmRunStatusFromResults(jobs, results) {
+    if (results.length === 0)
+        return 'planned';
+    if (results.some((result) => result.status === 'failed'))
+        return 'failed';
+    if (results.some((result) => result.status === 'blocked'))
+        return 'blocked';
+    if (results.some((result) => result.status === 'running'))
+        return 'running';
+    if (results.length >= jobs.length && results.every((result) => result.status === 'completed' || result.status === 'verified'))
+        return 'completed';
+    return 'running';
+}
+function latestSwarmResultFinishedAt(results) {
+    const finishedAt = results
+        .map((result) => result.finishedAt)
+        .filter((value) => value !== undefined);
+    return finishedAt.length ? Math.max(...finishedAt) : undefined;
+}
+function readSwarmMergeReadiness(attemptMetadata, patchMetadata, decisionMetadata) {
+    return readFirstMetadataString('mergeReadiness', [attemptMetadata, ...patchMetadata, ...decisionMetadata]);
+}
+function readSwarmMergeDisposition(attemptMetadata, patchMetadata, decisionMetadata) {
+    return readFirstMetadataString('mergeDisposition', [attemptMetadata])
+        ?? readFirstMetadataString('disposition', [...patchMetadata, ...decisionMetadata]);
+}
+function readSwarmRiskLevel(attemptMetadata, patchMetadata) {
+    return readFirstMetadataString('riskLevel', [attemptMetadata, ...patchMetadata]);
+}
+function readFirstMetadataString(key, metadata) {
+    for (const entry of metadata) {
+        const value = runMetadataString(entry, key);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function runNodeMetadata(node) {
+    return toJsonObject(node.metadata);
+}
+function runMetadataString(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === 'string' && value ? value : undefined;
+}
+function runMetadataNumber(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function runArtifactPath(node) {
+    if (!node || node.kind !== 'artifact')
+        return undefined;
+    return node.path ?? node.uri ?? node.title;
+}
+function stripRunNodePrefix(id, prefix) {
+    return id.startsWith(`${prefix}:`) ? id.slice(prefix.length + 1) : undefined;
+}
+function parseRunTimeMs(value, fallback) {
+    const parsed = value ? Date.parse(value) : NaN;
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function parseOptionalRunTimeMs(value) {
+    const parsed = value ? Date.parse(value) : NaN;
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 function isFrontierRunEventList(input) {
     return Array.isArray(input);
 }