@zq-silk/yui 0.15.7 → 0.15.9

package/dist/execution/workItemExecution.js

@@ -2,16 +2,15 @@ import { isDeepStrictEqual } from "node:util";
 import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
 import { validateContextSnapshotRef } from "../context/contextSnapshot.js";
 import { validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
-import { MAX_SYNTHESIS_SOURCE_TURNS } from "../context/sourceTurnContext.js";
+import { MAX_SYNTHESIS_SOURCE_RUNS } from "../context/sourceRunContext.js";
 export const WORK_ITEM_EXECUTION_GROUP_SCHEMA_VERSION = 2;
 export const WORK_ITEM_EXECUTION_LANE_SCHEMA_VERSION = 2;
 export const WORK_ITEM_EXECUTION_ASSIGNMENT_SCHEMA_VERSION = 1;
-export const MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS = 2;
+export const MINIMUM_EXECUTION_GROUP_LANES = 2;
 export const EXECUTION_GROUP_SCHEMA_VERSION = WORK_ITEM_EXECUTION_GROUP_SCHEMA_VERSION;
 export const EXECUTION_LANE_SCHEMA_VERSION = WORK_ITEM_EXECUTION_LANE_SCHEMA_VERSION;
 export const EXECUTION_ASSIGNMENT_SCHEMA_VERSION = WORK_ITEM_EXECUTION_ASSIGNMENT_SCHEMA_VERSION;
-export const MINIMUM_SYNTHESIS_RESULTS = MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS;
-export const MAXIMUM_SYNTHESIS_RESULTS = MAX_SYNTHESIS_SOURCE_TURNS;
+export const MAXIMUM_SYNTHESIS_RESULTS = MAX_SYNTHESIS_SOURCE_RUNS;
 export function createWorkItemExecutionAssignment(input) {
     return validateWorkItemExecutionAssignment({
         schemaVersion: WORK_ITEM_EXECUTION_ASSIGNMENT_SCHEMA_VERSION,
@@ -25,7 +24,7 @@ export function createReviewExecutionAssignment(input) {
     });
 }
 export function createExecutionGroup(id, taskId, assignment, laneInputs, now) {
-    if (laneInputs.length < MINIMUM_SYNTHESIS_RESULTS) {
+    if (laneInputs.length < MINIMUM_EXECUTION_GROUP_LANES) {
         throw new Error("A replicated ExecutionGroup requires at least two Lanes.");
     }
     if (laneInputs.length > MAXIMUM_SYNTHESIS_RESULTS) {
@@ -51,7 +50,7 @@ export function createExecutionGroup(id, taskId, assignment, laneInputs, now) {
             roleName: lane.roleName,
             ...(lane.effective === undefined ? {} : { effective: lane.effective }),
             ...(lane.workspace === undefined ? {} : { workspace: lane.workspace }),
-            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
+            ...(lane.currentRunId === undefined ? {} : { currentRunId: lane.currentRunId }),
             disposition: "open",
             createdAt: timestamp,
             updatedAt: timestamp
@@ -74,28 +73,28 @@ export function updateExecutionLane(group, laneId, patch, now) {
         throw new Error(`Terminal ExecutionLane is immutable: ${laneId}.`);
     }
     const disposition = patch.disposition ?? current.disposition;
-    const currentTurnId = patch.currentTurnId ?? current.currentTurnId;
-    const successfulTurnId = patch.successfulTurnId ?? current.successfulTurnId;
+    const currentRunId = patch.currentRunId ?? current.currentRunId;
+    const successfulRunId = patch.successfulRunId ?? current.successfulRunId;
     const effective = patch.effective ?? current.effective;
     const workspace = patch.workspace ?? current.workspace;
     if ((effective === undefined) !== (workspace === undefined)) {
         throw new Error("ExecutionLane launch facts are incomplete.");
     }
     if (disposition === "succeeded") {
-        if (successfulTurnId === undefined || successfulTurnId !== currentTurnId) {
-            throw new Error("A succeeded Lane must identify its current successful Turn.");
+        if (successfulRunId === undefined || successfulRunId !== currentRunId) {
+            throw new Error("A succeeded Lane must identify its current successful AgentRun.");
         }
     }
-    else if (successfulTurnId !== undefined) {
-        throw new Error("Only a succeeded Lane may identify a successful Turn.");
+    else if (successfulRunId !== undefined) {
+        throw new Error("Only a succeeded Lane may identify a successful AgentRun.");
     }
     const timestamp = now.toISOString();
     const updated = {
         ...current,
         ...(effective === undefined ? {} : { effective }),
         ...(workspace === undefined ? {} : { workspace }),
-        ...(currentTurnId === undefined ? {} : { currentTurnId }),
-        ...(successfulTurnId === undefined ? {} : { successfulTurnId }),
+        ...(currentRunId === undefined ? {} : { currentRunId }),
+        ...(successfulRunId === undefined ? {} : { successfulRunId }),
         disposition,
         updatedAt: timestamp,
         ...(disposition === "open" ? {} : { endedAt: timestamp })
@@ -114,7 +113,7 @@ export function updateWorkItemExecutionLane(group, laneId, patch, now) {
 /**
  * Reopen only failed Lanes for an explicit retry of the same semantic
  * execution. Successful results remain settled, while each failed Lane
- * returns to the same state produced by a naturally failed Turn: open and
+ * returns to the same state produced by a naturally failed AgentRun: open and
  * still pointing at the failed attempt that dispatch must replace.
  *
  * This is the sole terminal-to-open Lane transition. Normal Lane updates keep
@@ -255,7 +254,7 @@ export function validateExecutionGroup(group) {
     if (assignment.taskId !== group.taskId) {
         throw new Error("ExecutionGroup Assignment Task does not match its Group.");
     }
-    if (!Array.isArray(group.lanes) || group.lanes.length < MINIMUM_SYNTHESIS_RESULTS) {
+    if (!Array.isArray(group.lanes) || group.lanes.length < MINIMUM_EXECUTION_GROUP_LANES) {
         throw new Error("A replicated ExecutionGroup requires at least two Lanes.");
     }
     if (group.lanes.length > MAXIMUM_SYNTHESIS_RESULTS) {
@@ -353,8 +352,8 @@ export function summarizeExecutionGroup(group) {
             roleName: lane.roleName,
             ordinal: lane.ordinal,
             disposition: lane.disposition,
-            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
-            ...(lane.successfulTurnId === undefined ? {} : { successfulTurnId: lane.successfulTurnId }),
+            ...(lane.currentRunId === undefined ? {} : { currentRunId: lane.currentRunId }),
+            ...(lane.successfulRunId === undefined ? {} : { successfulRunId: lane.successfulRunId }),
             ...(lane.effective === undefined ? {} : { effective: lane.effective })
         }))
     };
@@ -385,8 +384,8 @@ function validateWorkItemExecutionLane(lane, groupId, ordinal) {
         "roleName",
         "effective",
         "workspace",
-        "currentTurnId",
-        "successfulTurnId",
+        "currentRunId",
+        "successfulRunId",
         "disposition",
         "createdAt",
         "updatedAt",
@@ -413,23 +412,23 @@ function validateWorkItemExecutionLane(lane, groupId, ordinal) {
         requireText(lane.workspace.root, "ExecutionLane workspace root");
         normalizedUniqueIdentities(lane.workspace.writableProjectIds, "ExecutionLane writable Project");
     }
-    if (lane.currentTurnId !== undefined && lane.effective === undefined) {
+    if (lane.currentRunId !== undefined && lane.effective === undefined) {
         throw new Error("A dispatched ExecutionLane requires launch facts.");
     }
-    if (lane.currentTurnId !== undefined)
-        requireIdentity(lane.currentTurnId, "ExecutionLane current Turn id");
-    if (lane.successfulTurnId !== undefined)
-        requireIdentity(lane.successfulTurnId, "ExecutionLane successful Turn id");
+    if (lane.currentRunId !== undefined)
+        requireIdentity(lane.currentRunId, "ExecutionLane current AgentRun id");
+    if (lane.successfulRunId !== undefined)
+        requireIdentity(lane.successfulRunId, "ExecutionLane successful AgentRun id");
     if (!["open", "succeeded", "failed"].includes(lane.disposition)) {
         throw new Error(`ExecutionLane disposition is invalid: ${String(lane.disposition)}.`);
     }
     if (lane.disposition === "succeeded") {
-        if (lane.currentTurnId === undefined || lane.successfulTurnId !== lane.currentTurnId) {
-            throw new Error("A succeeded Lane must identify its current successful Turn.");
+        if (lane.currentRunId === undefined || lane.successfulRunId !== lane.currentRunId) {
+            throw new Error("A succeeded Lane must identify its current successful AgentRun.");
         }
     }
-    else if (lane.successfulTurnId !== undefined) {
-        throw new Error("Only a succeeded Lane may identify a successful Turn.");
+    else if (lane.successfulRunId !== undefined) {
+        throw new Error("Only a succeeded Lane may identify a successful AgentRun.");
     }
     requireTimestamp(lane.createdAt, "ExecutionLane createdAt");
     requireTimestamp(lane.updatedAt, "ExecutionLane updatedAt");

package/dist/execution/workItemExecutionProjection.js

@@ -1,14 +1,14 @@
 import { governingWorkItemCandidate, currentWorkItemExecutionGroup } from "../workItem/workItem.js";
-import { MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS } from "./workItemExecution.js";
-export function projectWorkItemExecution(item, turns, sessionSets = []) {
+import { synthesisSourceRunIds } from "../context/runContextPack.js";
+export function projectWorkItemExecution(item, runs, sessionSets = [], sourceStore) {
     const group = currentWorkItemExecutionGroup(item);
-    const relevantTurns = turns.filter((turn) => turn.workItemId === item.id);
+    const relevantRuns = runs.filter((run) => run.workItemId === item.id);
     const sessionsByRole = new Map(sessionSets.map((set) => [set.owner.roleName, set]));
     const lanes = group === undefined
         ? []
         : [...group.lanes]
             .sort((left, right) => left.ordinal - right.ordinal || left.id.localeCompare(right.id))
-            .map((lane) => projectLane(item, group, lane, relevantTurns, sessionsByRole));
+            .map((lane) => projectLane(item, group, lane, relevantRuns, sessionsByRole));
     const laneCounts = Object.freeze({
         running: lanes.filter(({ status }) => status === "running").length,
         succeeded: lanes.filter(({ status }) => status === "succeeded").length,
@@ -16,9 +16,9 @@ export function projectWorkItemExecution(item, turns, sessionSets = []) {
         failed: lanes.filter(({ status }) => status === "failed").length,
         unknown: lanes.filter(({ status }) => status === "unknown").length
     });
-    const mainTurn = projectMainTurn(item, group, relevantTurns, sessionsByRole);
-    const synthesis = projectSynthesis(group, lanes, mainTurn);
-    const candidate = projectCandidate(item, group, relevantTurns, lanes, mainTurn);
+    const mainRun = projectMainRun(item, group, relevantRuns, sessionsByRole);
+    const synthesis = projectSynthesis(group, lanes, mainRun);
+    const candidate = projectCandidate(item, group, relevantRuns, mainRun, sourceStore);
     return Object.freeze({
         schemaVersion: 1,
         shape: group === undefined ? "direct" : "replicated",
@@ -26,15 +26,15 @@ export function projectWorkItemExecution(item, turns, sessionSets = []) {
         lanes: Object.freeze(lanes),
         laneCounts,
         synthesis,
-        mainTurn,
+        mainRun,
         candidate,
-        nextAction: projectNextAction(item, lanes, synthesis, mainTurn, candidate)
+        nextAction: projectNextAction(item, lanes, synthesis, mainRun, candidate)
     });
 }
-function projectLane(item, group, lane, turns, sessionsByRole) {
-    const current = lane.currentTurnId === undefined
+function projectLane(item, group, lane, runs, sessionsByRole) {
+    const current = lane.currentRunId === undefined
         ? undefined
-        : turns.find(({ id }) => id === lane.currentTurnId);
+        : runs.find(({ id }) => id === lane.currentRunId);
     const exact = current !== undefined
         && current.taskId === item.taskId
         && current.workItemId === item.id
@@ -42,7 +42,7 @@ function projectLane(item, group, lane, turns, sessionsByRole) {
         && current.executionLaneId === lane.id
         && current.roleName === lane.roleName;
     const session = exact
-        ? turnSessionStatus(current, sessionsByRole.get(lane.roleName))
+        ? runSessionStatus(current, sessionsByRole.get(lane.roleName))
         : "unobserved";
     if (lane.disposition === "failed") {
         return Object.freeze({
@@ -50,14 +50,14 @@ function projectLane(item, group, lane, turns, sessionsByRole) {
             ordinal: lane.ordinal,
             roleName: lane.roleName,
             status: "failed",
-            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
+            ...(lane.currentRunId === undefined ? {} : { currentRunId: lane.currentRunId }),
             session,
             observation: exact ? "observed" : "unobserved"
         });
     }
     if (lane.disposition === "succeeded") {
         const producerObserved = exact
-            && lane.successfulTurnId === current.id
+            && lane.successfulRunId === current.id
             && current.status === "completed"
             && current.result !== undefined;
         return Object.freeze({
@@ -65,8 +65,8 @@ function projectLane(item, group, lane, turns, sessionsByRole) {
             ordinal: lane.ordinal,
             roleName: lane.roleName,
             status: producerObserved ? "succeeded" : "unknown",
-            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
-            ...(lane.successfulTurnId === undefined ? {} : { successfulTurnId: lane.successfulTurnId }),
+            ...(lane.currentRunId === undefined ? {} : { currentRunId: lane.currentRunId }),
+            ...(lane.successfulRunId === undefined ? {} : { successfulRunId: lane.successfulRunId }),
             session,
             observation: producerObserved ? "observed" : "unobserved"
         });
@@ -77,7 +77,7 @@ function projectLane(item, group, lane, turns, sessionsByRole) {
             ordinal: lane.ordinal,
             roleName: lane.roleName,
             status: "unknown",
-            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
+            ...(lane.currentRunId === undefined ? {} : { currentRunId: lane.currentRunId }),
             session: "unobserved",
             observation: "unobserved"
         });
@@ -88,10 +88,10 @@ function projectLane(item, group, lane, turns, sessionsByRole) {
             ordinal: lane.ordinal,
             roleName: lane.roleName,
             status: "needs-attention",
-            currentTurnId: current.id,
+            currentRunId: current.id,
             session,
-            retryTurnId: current.id,
-            settleTurnId: current.id,
+            retryRunId: current.id,
+            settleRunId: current.id,
             observation: "observed"
         });
     }
@@ -101,7 +101,8 @@ function projectLane(item, group, lane, turns, sessionsByRole) {
             ordinal: lane.ordinal,
             roleName: lane.roleName,
             status: session === "ended" ? "needs-attention" : "running",
-            currentTurnId: current.id,
+            currentRunId: current.id,
+            delivery: observedAdmission(current, sessionsByRole.get(lane.roleName)),
             session,
             observation: "observed"
         });
@@ -111,19 +112,19 @@ function projectLane(item, group, lane, turns, sessionsByRole) {
         ordinal: lane.ordinal,
         roleName: lane.roleName,
         status: "unknown",
-        currentTurnId: current.id,
+        currentRunId: current.id,
         session,
         observation: "unobserved"
     });
 }
-function projectMainTurn(item, group, turns, sessionsByRole) {
-    const candidates = turns.filter((turn) => (turn.purpose === "execution"
-        && turn.roleName === item.assignee
-        && turn.executionGroupId === undefined
-        && turn.executionLaneId === undefined
-        && turn.sourceExecutionGroupId === group?.id)).sort(compareTurns);
-    const turn = candidates.at(-1);
-    if (turn === undefined) {
+function projectMainRun(item, group, runs, sessionsByRole) {
+    const candidates = runs.filter((run) => (run.purpose === "execution"
+        && run.roleName === item.assignee
+        && run.executionGroupId === undefined
+        && run.executionLaneId === undefined
+        && run.sourceExecutionGroupId === group?.id)).sort(compareRuns);
+    const run = candidates.at(-1);
+    if (run === undefined) {
         return Object.freeze({
             status: "not-started",
             ...(item.assignee === undefined ? {} : { roleName: item.assignee }),
@@ -132,65 +133,56 @@ function projectMainTurn(item, group, turns, sessionsByRole) {
             observation: "unobserved"
         });
     }
-    const session = turnSessionStatus(turn, sessionsByRole.get(turn.roleName));
+    const session = runSessionStatus(run, sessionsByRole.get(run.roleName));
     const base = {
-        roleName: turn.roleName,
-        turnId: turn.id,
-        ...(turn.sourceExecutionGroupId === undefined
+        roleName: run.roleName,
+        runId: run.id,
+        ...(run.sourceExecutionGroupId === undefined
             ? {}
-            : { sourceExecutionGroupId: turn.sourceExecutionGroupId }),
+            : { sourceExecutionGroupId: run.sourceExecutionGroupId }),
         session
     };
-    if (turn.status === "failed") {
+    if (run.status === "failed") {
         return Object.freeze({
             ...base,
             status: "needs-attention",
-            retryTurnId: turn.id,
+            retryRunId: run.id,
             observation: "observed"
         });
     }
-    if (turn.status === "active") {
+    if (run.status === "active") {
         return Object.freeze({
             ...base,
+            delivery: observedAdmission(run, sessionsByRole.get(run.roleName)),
             status: session === "ended" ? "needs-attention" : "running",
             observation: "observed"
         });
     }
     return Object.freeze({
         ...base,
-        status: turn.result === undefined ? "unknown" : "succeeded",
-        observation: turn.result === undefined ? "unobserved" : "observed"
+        status: run.result === undefined ? "unknown" : "succeeded",
+        observation: run.result === undefined ? "unobserved" : "observed"
     });
 }
-function projectSynthesis(group, lanes, mainTurn) {
+function projectSynthesis(group, lanes, mainRun) {
     if (group === undefined) {
         return Object.freeze({
             status: "not-applicable",
-            successfulLaneCount: 0,
-            requiredSuccessfulLaneCount: MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS
+            successfulLaneCount: 0
         });
     }
     const successfulLaneCount = group.lanes.filter(({ disposition }) => disposition === "succeeded").length;
     let status;
-    if (group.lanes.some(({ disposition }) => disposition === "open")) {
-        status = "blocked-by-open-lanes";
+    if (mainRun.status === "not-started") {
+        status = "awaiting-selection";
     }
-    else if (lanes.some((lane) => (lane.status === "unknown" && group.lanes.some(({ id, disposition }) => (id === lane.laneId && disposition === "succeeded"))))) {
-        status = "unknown";
-    }
-    else if (successfulLaneCount < MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS) {
-        status = "insufficient-results";
-    }
-    else if (mainTurn.status === "not-started") {
-        status = "eligible";
-    }
-    else if (mainTurn.status === "running") {
+    else if (mainRun.status === "running") {
         status = "main-running";
     }
-    else if (mainTurn.status === "needs-attention") {
+    else if (mainRun.status === "needs-attention") {
         status = "main-needs-attention";
     }
-    else if (mainTurn.status === "succeeded") {
+    else if (mainRun.status === "succeeded") {
         status = "complete";
     }
     else {
@@ -198,16 +190,15 @@ function projectSynthesis(group, lanes, mainTurn) {
     }
     return Object.freeze({
         status,
-        successfulLaneCount,
-        requiredSuccessfulLaneCount: MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS
+        successfulLaneCount
     });
 }
-function projectCandidate(item, group, turns, lanes, mainTurn) {
+function projectCandidate(item, group, runs, mainRun, sourceStore) {
     const candidate = governingWorkItemCandidate(item);
     if (candidate === undefined) {
         return Object.freeze({
             status: "none",
-            successfulLaneTurns: Object.freeze([]),
+            successfulLaneRuns: Object.freeze([]),
             observation: "observed"
         });
     }
@@ -215,43 +206,43 @@ function projectCandidate(item, group, turns, lanes, mainTurn) {
         const valid = group === undefined && item.assignee === undefined;
         return candidateProjection(candidate, valid ? "observed" : "unknown", [], valid);
     }
-    const sourceTurnId = candidate.source.turnId;
-    const sourceTurn = turns.find(({ id }) => id === sourceTurnId);
-    const laneTurns = group === undefined
+    const sourceRunId = candidate.source.runId;
+    const sourceRun = runs.find(({ id }) => id === sourceRunId);
+    const laneRuns = group === undefined || sourceStore === undefined || sourceRun === undefined
         ? []
-        : [...group.lanes]
-            .filter(({ disposition, successfulTurnId }) => (disposition === "succeeded" && successfulTurnId !== undefined))
-            .sort((left, right) => left.ordinal - right.ordinal || left.id.localeCompare(right.id))
-            .map((lane) => ({ laneId: lane.id, successfulTurnId: lane.successfulTurnId }));
-    const valid = sourceTurn !== undefined
-        && sourceTurn.id === mainTurn.turnId
-        && sourceTurn.status === "completed"
-        && sourceTurn.result !== undefined
-        && sourceTurn.executionGroupId === undefined
-        && sourceTurn.executionLaneId === undefined
-        && sourceTurn.sourceExecutionGroupId === group?.id
+        : synthesisSourceRunIds(sourceStore, sourceRun).flatMap((id) => {
+            const selected = runs.find((run) => run.id === id);
+            return selected?.executionLaneId === undefined ? [] : [{
+                    laneId: selected.executionLaneId, successfulRunId: selected.id
+                }];
+        });
+    const valid = sourceRun !== undefined
+        && sourceRun.id === mainRun.runId
+        && sourceRun.status === "completed"
+        && sourceRun.result !== undefined
+        && sourceRun.executionGroupId === undefined
+        && sourceRun.executionLaneId === undefined
+        && sourceRun.sourceExecutionGroupId === group?.id
         && candidate.executionLaneId === undefined
         && candidate.executionGroupId === undefined
-        && (group === undefined || (laneTurns.length >= MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS
-            && lanes.filter(({ successfulTurnId }) => successfulTurnId !== undefined)
-                .every(({ status }) => status === "succeeded")));
-    return candidateProjection(candidate, valid ? "observed" : "unknown", laneTurns, valid, group?.id);
+        && (group === undefined || laneRuns.length > 0);
+    return candidateProjection(candidate, valid ? "observed" : "unknown", laneRuns, valid, group?.id);
 }
-function candidateProjection(candidate, status, successfulLaneTurns, observed, sourceExecutionGroupId) {
+function candidateProjection(candidate, status, successfulLaneRuns, observed, sourceExecutionGroupId) {
     return Object.freeze({
         status,
         candidateId: candidate.id,
         sourceType: candidate.source.type,
-        ...(candidate.source.type === "turn" ? { mainTurnId: candidate.source.turnId } : {}),
+        ...(candidate.source.type === "run" ? { mainRunId: candidate.source.runId } : {}),
         ...(sourceExecutionGroupId === undefined ? {} : { sourceExecutionGroupId }),
-        successfulLaneTurns: Object.freeze(successfulLaneTurns),
+        successfulLaneRuns: Object.freeze(successfulLaneRuns),
         observation: observed ? "observed" : "unobserved"
     });
 }
-function projectNextAction(item, lanes, synthesis, mainTurn, candidate) {
-    if (["completed", "retired"].includes(item.status))
+function projectNextAction(item, lanes, synthesis, mainRun, candidate) {
+    if (["accepted", "retired"].includes(item.status))
         return action("none", [], []);
-    if (item.status === "awaiting_acceptance") {
+    if ((item.status === "open" && item.currentCandidateId !== undefined)) {
         return candidate.status === "observed"
             ? action("decide-candidate", ["leader"], [candidate.candidateId])
             : action("inspect-unknown", ["leader"], candidate.candidateId === undefined ? [] : [candidate.candidateId]);
@@ -261,35 +252,32 @@ function projectNextAction(item, lanes, synthesis, mainTurn, candidate) {
             .filter(({ status }) => status === "unknown")
             .map(({ laneId }) => laneId));
     }
-    const recoveries = lanes.filter(({ retryTurnId }) => retryTurnId !== undefined);
+    const recoveries = lanes.filter(({ retryRunId }) => retryRunId !== undefined);
     if (recoveries.length > 0) {
-        return action("retry-or-settle-lanes", ["leader"], recoveries.map(({ retryTurnId }) => retryTurnId));
+        return action("retry-or-settle-lanes", ["leader"], recoveries.map(({ retryRunId }) => retryRunId));
     }
     const activeLanes = lanes.filter(({ status }) => status === "running");
     if (activeLanes.length > 0) {
         return action("wait-for-lanes", activeLanes.map(({ roleName }) => roleName), activeLanes.map(({ laneId }) => laneId));
     }
-    if (synthesis.status === "insufficient-results") {
-        return action("redispatch-work", ["leader"], [item.id]);
+    if (synthesis.status === "awaiting-selection") {
+        return action("select-synthesis-sources", ["leader"], [item.id]);
     }
-    if (synthesis.status === "eligible") {
-        return action("await-main-dispatch", ["controller", ...(item.assignee === undefined ? [] : [item.assignee])], [item.id]);
+    if (mainRun.status === "running") {
+        return action("wait-for-main", mainRun.roleName === undefined ? [] : [mainRun.roleName], mainRun.runId === undefined ? [] : [mainRun.runId]);
     }
-    if (mainTurn.status === "running") {
-        return action("wait-for-main", mainTurn.roleName === undefined ? [] : [mainTurn.roleName], mainTurn.turnId === undefined ? [] : [mainTurn.turnId]);
+    if (mainRun.status === "needs-attention") {
+        return mainRun.retryRunId === undefined
+            ? action("inspect-unknown", ["leader"], mainRun.runId === undefined ? [] : [mainRun.runId])
+            : action("retry-main", ["leader"], [mainRun.retryRunId]);
     }
-    if (mainTurn.status === "needs-attention") {
-        return mainTurn.retryTurnId === undefined
-            ? action("inspect-unknown", ["leader"], mainTurn.turnId === undefined ? [] : [mainTurn.turnId])
-            : action("retry-main", ["leader"], [mainTurn.retryTurnId]);
+    if (mainRun.status === "succeeded" && item.status === "open") {
+        return action("submit-candidate", ["leader"], [mainRun.runId]);
     }
-    if (mainTurn.status === "succeeded" && item.status === "running") {
-        return action("submit-candidate", ["leader"], [mainTurn.turnId]);
+    if (mainRun.status === "unknown" || synthesis.status === "unknown") {
+        return action("inspect-unknown", ["leader"], mainRun.runId === undefined ? [item.id] : [mainRun.runId]);
     }
-    if (mainTurn.status === "unknown" || synthesis.status === "unknown") {
-        return action("inspect-unknown", ["leader"], mainTurn.turnId === undefined ? [item.id] : [mainTurn.turnId]);
-    }
-    if (item.status === "pending" || item.status === "failed") {
+    if (item.status === "open") {
         return action("dispatch-work", ["leader"], [item.id]);
     }
     return action("inspect-unknown", ["leader"], [item.id]);
@@ -301,9 +289,13 @@ function action(kind, owners, targetIds) {
         targetIds: Object.freeze([...new Set(targetIds)])
     });
 }
-function turnSessionStatus(turn, set) {
-    return set?.sessions[turn.effective.agentId]?.status ?? "unobserved";
+function runSessionStatus(run, set) {
+    return set?.sessions[run.effective.agentId]?.status ?? "unobserved";
+}
+function observedAdmission(run, sessions) {
+    const native = sessions?.providerBinding?.run;
+    return native?.runId === run.id ? native.status : "unobserved";
 }
-function compareTurns(left, right) {
+function compareRuns(left, right) {
     return left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id);
 }