@zq-silk/yui 0.13.9 → 0.14.0

package/dist/scheduler/taskExecutionProjection.js

@@ -3,7 +3,7 @@ import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
 import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from "../execution/executionHealth.js";
 import { buildTaskObservabilityProjection } from "./taskObservabilityProjection.js";
-import { isRoleRunStalled, latestStallProgressAt } from "./roleRunStall.js";
+import { isRoleTurnStalled, latestStallProgressAt } from "./roleTurnStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
 /**
@@ -17,7 +17,7 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         return null;
     const roles = store.listRoles?.(taskId) ?? [];
     const events = store.listEvents?.(taskId) ?? [];
-    const runs = operationalTaskRecords(store.listAgentRuns?.(taskId) ?? [], events, "agent-run");
+    const turns = operationalTaskRecords(store.listTurns?.(taskId) ?? [], events, "turn");
     const leaderMailbox = store.getWorkMailbox?.({
         kind: "role",
         taskId,
@@ -32,7 +32,7 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
     return projectTaskExecution({
         task,
         roles,
-        runs,
+        turns,
         executionGroups: store.listWorkItems === undefined && store.listReviewRounds === undefined
             ? []
             : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? []),
@@ -71,21 +71,19 @@ export function projectTaskExecutionFromFacts(facts) {
         ?? collectExecutionGroups(facts.workItems ?? [], facts.reviewRounds ?? []);
     return projectTaskExecution({
         ...facts,
-        runs: operationalTaskRecords(facts.runs, facts.events ?? [], "agent-run"),
+        turns: operationalTaskRecords(facts.turns, facts.events ?? [], "turn"),
         executionGroups
     });
 }
-/** Alias kept intentionally small for scheduler callers and external read models. */
-export const deriveTaskExecutionProjection = projectTaskExecution;
 export function projectTaskExecution(facts) {
-    const { task, roles, runs, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, roleSessions = [], executionGroups = [] } = facts;
+    const { task, roles, turns, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, roleSessions = [], executionGroups = [] } = facts;
     const now = facts.now ?? new Date();
     const groupSummaries = executionGroups.map((group) => {
         const stageGroups = workItems.find((item) => (item.executionGroups.some(({ id }) => id === group.id)))?.executionGroups;
         return summarizeExecutionGroupHealth({
             group,
             ...(stageGroups === undefined ? {} : { stageGroups }),
-            runs,
+            turns,
             sessions: roleSessions,
             events,
             now,
@@ -108,7 +106,7 @@ export function projectTaskExecution(facts) {
         workItems,
         executionGroups: observabilityGroups,
         groupSummaries,
-        runs,
+        turns,
         events,
         contextSnapshots: facts.contextSnapshots,
         sessionTokens,
@@ -120,17 +118,20 @@ export function projectTaskExecution(facts) {
         executionGroups: groupSummaries,
         observability
     });
-    const activeRuns = runs.filter((run) => run.status === "active");
-    const activeRunViews = activeRuns.map((run) => ({
-        id: run.id,
-        roleName: run.roleName,
-        purpose: run.purpose,
-        delivered: run.deliveredAt !== undefined,
-        status: run.status,
-        ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
-        ...(run.reviewRoundId === undefined ? {} : { reviewRoundId: run.reviewRoundId }),
-        ...(run.executionGroupId === undefined ? {} : { executionGroupId: run.executionGroupId }),
-        ...(run.executionLaneId === undefined ? {} : { executionLaneId: run.executionLaneId })
+    const activeTurns = turns.filter((turn) => turn.status === "active");
+    const turnHasSession = (turn) => roleSessions.some((session) => (session.roleName === turn.roleName
+        && session.agentId === turn.effective.agentId
+        && session.status !== "ended"));
+    const activeTurnViews = activeTurns.map((turn) => ({
+        id: turn.id,
+        roleName: turn.roleName,
+        purpose: turn.purpose,
+        providerSession: turnHasSession(turn) ? "active" : "starting",
+        status: turn.status,
+        ...(turn.workItemId === undefined ? {} : { workItemId: turn.workItemId }),
+        ...(turn.reviewRoundId === undefined ? {} : { reviewRoundId: turn.reviewRoundId }),
+        ...(turn.executionGroupId === undefined ? {} : { executionGroupId: turn.executionGroupId }),
+        ...(turn.executionLaneId === undefined ? {} : { executionLaneId: turn.executionLaneId })
     }));
     const monitoring = task.executionGate.state === "stopped"
         || task.status === "completed"
@@ -149,7 +150,7 @@ export function projectTaskExecution(facts) {
                 reason: "execution-stopped",
                 monitoring,
                 failClosed: false,
-                activeRuns: activeRunViews,
+                activeTurns: activeTurnViews,
                 attention: [],
                 blockers: [],
                 pendingWakeup
@@ -165,7 +166,7 @@ export function projectTaskExecution(facts) {
             reason: "task-terminal",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention: [],
             blockers: [],
             pendingWakeup
@@ -174,7 +175,7 @@ export function projectTaskExecution(facts) {
     const attention = collectAttention({
         task,
         roles,
-        activeRuns,
+        activeTurns,
         events,
         leaderFailure,
         roleSessions,
@@ -182,16 +183,15 @@ export function projectTaskExecution(facts) {
     });
     const openInputs = inputRequests.filter((request) => request.status === "open");
     const blockers = collectBlockers(workItems, reviewRounds, integrations, openInputs, task);
-    const activeExecutionRuns = activeRuns.filter((run) => run.purpose === "execution");
-    const activeReviewRuns = activeRuns.filter((run) => run.purpose === "review");
-    const activeDelegatedExecutions = activeExecutionRuns.filter((run) => (run.roleName !== "leader"));
-    const healthyActiveRuns = activeRuns.filter((run) => (run.deliveredAt !== undefined
-        && !attention.some((item) => item.runId === run.id)));
-    const activeLeader = activeRuns.find((run) => run.roleName === "leader");
-    const pendingDeliveryRuns = activeRuns.filter((run) => run.deliveredAt === undefined);
+    const activeExecutionTurns = activeTurns.filter((turn) => turn.purpose === "execution");
+    const activeReviewTurns = activeTurns.filter((turn) => turn.purpose === "review");
+    const activeDelegatedExecutions = activeExecutionTurns.filter((turn) => (turn.roleName !== "leader"));
+    const healthyActiveTurns = activeTurns.filter((turn) => (turnHasSession(turn)
+        && !attention.some((item) => item.turnId === turn.id)));
+    const activeLeader = activeTurns.find((turn) => turn.roleName === "leader");
+    const pendingDeliveryTurns = activeTurns.filter((turn) => !turnHasSession(turn));
     const hasPendingLeaderWork = pendingWakeup !== null
-        || leaderMailbox !== null && (leaderMailbox.pending.normal !== null
-            || leaderMailbox.pending.userCorrection !== null);
+        || leaderMailbox?.pending !== null;
     const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure);
     const failedWork = workItems.some((item) => item.status === "failed");
     const candidateReady = workItems.some((item) => item.status === "awaiting_acceptance");
@@ -205,19 +205,19 @@ export function projectTaskExecution(facts) {
         if (first === undefined)
             throw new Error("Task execution attention disappeared.");
         const progressingWithAttention = first.kind === "checkpoint-overdue"
-            && healthyActiveRuns.length > 0;
+            && healthyActiveTurns.length > 0;
         return render({
             task,
             status: progressingWithAttention ? "progressing-with-attention" : "attention",
             owner: first.owner,
             action: "inspect-attention",
             summary: progressingWithAttention
-                ? `${healthyActiveRuns.length} healthy active Run(s) remain while ${first.summary}`
+                ? `${healthyActiveTurns.length} healthy active Turn(s) remain while ${first.summary}`
                 : first.summary,
             reason: progressingWithAttention ? "progressing-with-attention" : first.kind,
             monitoring,
             failClosed: hasLeaderMismatch || attention.some((item) => item.failClosed === true),
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -236,7 +236,7 @@ export function projectTaskExecution(facts) {
             reason: "open-input-request",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -252,11 +252,11 @@ export function projectTaskExecution(facts) {
             action: "recover-execution",
             summary: `Execution Lane ${laneRecovery.laneId} in ${laneRecovery.groupId}`
                 + ` requires ${laneRecovery.recovery}`
-                + (laneRecovery.runId === undefined ? "." : ` for exact Run ${laneRecovery.runId}.`),
+                + (laneRecovery.turnId === undefined ? "." : ` for exact Turn ${laneRecovery.turnId}.`),
             reason: `execution-lane-${laneRecovery.recovery}`,
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -275,7 +275,7 @@ export function projectTaskExecution(facts) {
             reason: blockedIntegration ? "integration-blocked" : failedWork ? "work-failed" : "identity-mismatch",
             monitoring,
             failClosed: hasLeaderMismatch,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -292,24 +292,24 @@ export function projectTaskExecution(facts) {
             reason: leaderFailure === null ? "recovery-pending" : "leader-recovery-failed",
             monitoring,
             failClosed: leaderFailure !== null,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    const leaderDeliveryPending = pendingDeliveryRuns.some((run) => run.roleName === "leader");
+    const leaderDeliveryPending = pendingDeliveryTurns.some((turn) => turn.roleName === "leader");
     if (leaderDeliveryPending) {
         return render({
             task,
             status: "recovering",
             owner: "leader",
             action: "recover-leader",
-            summary: "The active Leader Run is awaiting provider acceptance; delivery remains fail-closed.",
+            summary: "The active Leader Turn is awaiting provider acceptance; delivery remains fail-closed.",
             reason: "delivery-pending",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -317,14 +317,14 @@ export function projectTaskExecution(facts) {
     }
     if (activeLeader !== undefined) {
         const concurrentExecutionCount = activeDelegatedExecutions.length;
-        const concurrentReviewCount = activeReviewRuns.length;
+        const concurrentReviewCount = activeReviewTurns.length;
         const concurrentSummary = [
             concurrentExecutionCount === 0
                 ? null
-                : `${concurrentExecutionCount} delegated execution Run(s)`,
+                : `${concurrentExecutionCount} delegated execution Turn(s)`,
             concurrentReviewCount === 0
                 ? null
-                : `${concurrentReviewCount} Review Run(s)`
+                : `${concurrentReviewCount} Review Turn(s)`
         ].filter((value) => value !== null).join(" and ");
         return render({
             task,
@@ -332,12 +332,12 @@ export function projectTaskExecution(facts) {
             owner: "leader",
             action: "advance-task",
             summary: concurrentSummary.length === 0
-                ? "Leader Run is actively advancing the Task."
-                : `Leader Run is actively advancing the Task alongside ${concurrentSummary}.`,
-            reason: concurrentSummary.length === 0 ? "leader-run-active" : "leader-and-agents-active",
+                ? "Leader Turn is actively advancing the Task."
+                : `Leader Turn is actively advancing the Task alongside ${concurrentSummary}.`,
+            reason: concurrentSummary.length === 0 ? "leader-turn-active" : "leader-and-agents-active",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -349,62 +349,62 @@ export function projectTaskExecution(facts) {
             status: "needs-leader-action",
             owner: "leader",
             action: "advance-task",
-            summary: "A durable Leader wake is pending; concurrent AgentRuns remain visible but do not suppress it.",
+            summary: "A durable Leader wake is pending; concurrent Turns remain visible but do not suppress it.",
             reason: "leader-wake-pending",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (pendingDeliveryRuns.length > 0) {
+    if (pendingDeliveryTurns.length > 0) {
         return render({
             task,
             status: "recovering",
             owner: "leader",
             action: "recover-execution",
-            summary: `${pendingDeliveryRuns.length} active delegated AgentRun(s) are awaiting provider acceptance; delivery remains fail-closed.`,
+            summary: `${pendingDeliveryTurns.length} active delegated Turn(s) are awaiting provider acceptance; delivery remains fail-closed.`,
             reason: "delivery-pending",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
     if (activeDelegatedExecutions.length > 0) {
-        const reviewSuffix = activeReviewRuns.length === 0
+        const reviewSuffix = activeReviewTurns.length === 0
             ? ""
-            : `; ${activeReviewRuns.length} Review Run(s) are also active`;
+            : `; ${activeReviewTurns.length} Review Turn(s) are also active`;
         return render({
             task,
             status: "waiting-on-agents",
             owner: roleOwner(activeDelegatedExecutions[0].roleName),
             action: "wait-for-agents",
-            summary: `${activeDelegatedExecutions.length} delegated execution Run(s) are active${reviewSuffix}.`,
+            summary: `${activeDelegatedExecutions.length} delegated execution Turn(s) are active${reviewSuffix}.`,
             reason: "delegated-work-active",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (activeReviewRuns.length > 0) {
+    if (activeReviewTurns.length > 0) {
         return render({
             task,
             status: "waiting-on-agents",
             owner: "reviewer",
             action: "wait-for-agents",
-            summary: `${activeReviewRuns.length} Review Run(s) are evaluating frozen candidates; newer facts can still wake the Leader.`,
+            summary: `${activeReviewTurns.length} Review Turn(s) are evaluating frozen candidates; newer facts can still wake the Leader.`,
             reason: "review-active",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -424,7 +424,7 @@ export function projectTaskExecution(facts) {
                 : "integration-pending",
             monitoring,
             failClosed: false,
-            activeRuns: activeRunViews,
+            activeTurns: activeTurnViews,
             attention,
             blockers,
             pendingWakeup
@@ -439,7 +439,7 @@ export function projectTaskExecution(facts) {
         reason: "no-executor",
         monitoring,
         failClosed: false,
-        activeRuns: activeRunViews,
+        activeTurns: activeTurnViews,
         attention,
         blockers,
         pendingWakeup
@@ -456,7 +456,7 @@ function projection(input) {
         reason: input.reason,
         monitoring: input.monitoring,
         failClosed: input.failClosed,
-        activeRuns: input.activeRuns,
+        activeTurns: input.activeTurns,
         executionGroups: input.executionGroups ?? [],
         observability: input.observability,
         attention: input.attention,
@@ -516,7 +516,7 @@ function collectExecutionGroups(workItems, reviewRounds) {
 }
 function collectAttention(input) {
     const result = [];
-    const { task, activeRuns, events, leaderFailure } = input;
+    const { task, activeTurns, events, leaderFailure } = input;
     if (leaderFailure !== null) {
         result.push({
             kind: "leader-recovery",
@@ -526,82 +526,82 @@ function collectAttention(input) {
             failClosed: true
         });
     }
-    for (const run of activeRuns) {
-        const role = input.roles.find((candidate) => candidate.name === run.roleName);
-        const session = input.roleSessions.find((candidate) => candidate.roleName === run.roleName);
+    for (const turn of activeTurns) {
+        const role = input.roles.find((candidate) => candidate.name === turn.roleName);
+        const session = input.roleSessions.find((candidate) => candidate.roleName === turn.roleName);
         if (role !== undefined
-            && ((role.activeAgentId !== undefined && role.activeAgentId !== run.effective?.agentId)
-                || (role.adapterId !== undefined && role.adapterId !== run.effective?.adapterId))) {
+            && ((role.activeAgentId !== undefined && role.activeAgentId !== turn.effective?.agentId)
+                || (role.adapterId !== undefined && role.adapterId !== turn.effective?.adapterId))) {
             result.push({
                 kind: "identity-mismatch",
-                id: `identity:${run.id}`,
+                id: `identity:${turn.id}`,
                 owner: "leader",
-                summary: `Run ${run.id} does not match the current ${run.roleName} Agent/adapter fence.`,
-                runId: run.id,
-                roleName: run.roleName,
+                summary: `Turn ${turn.id} does not match the current ${turn.roleName} Agent/adapter fence.`,
+                turnId: turn.id,
+                roleName: turn.roleName,
                 failClosed: true
             });
         }
         if (session !== undefined
-            && (session.agentId !== run.effective?.agentId || session.adapterId !== run.effective?.adapterId)) {
+            && (session.agentId !== turn.effective?.agentId || session.adapterId !== turn.effective?.adapterId)) {
             result.push({
                 kind: "identity-mismatch",
-                id: `session:${run.id}`,
+                id: `session:${turn.id}`,
                 owner: "leader",
-                summary: `Run ${run.id} has a provider/session identity mismatch; monitoring fails closed.`,
-                runId: run.id,
-                roleName: run.roleName,
+                summary: `Turn ${turn.id} has a provider/session identity mismatch; monitoring fails closed.`,
+                turnId: turn.id,
+                roleName: turn.roleName,
                 failClosed: true
             });
         }
-        if (isRoleRunStalled(events, run.id)) {
-            if (run.roleName === "leader") {
-                const progressAt = latestStallProgressAt(events, run.id) ?? "unknown";
+        if (isRoleTurnStalled(events, turn.id)) {
+            if (turn.roleName === "leader") {
+                const progressAt = latestStallProgressAt(events, turn.id) ?? "unknown";
                 result.push({
                     kind: "leader-stalled",
-                    id: `leader-stall:${run.id}:${progressAt}`,
+                    id: `leader-stall:${turn.id}:${progressAt}`,
                     owner: "operator",
-                    summary: `Leader Run ${run.id} has an unresolved no-progress attention.`,
-                    runId: run.id,
-                    roleName: run.roleName
+                    summary: `Leader Turn ${turn.id} has an unresolved no-progress attention.`,
+                    turnId: turn.id,
+                    roleName: turn.roleName
                 });
             }
             else {
                 result.push({
                     kind: "checkpoint-overdue",
-                    id: `checkpoint-overdue:${run.id}`,
+                    id: `checkpoint-overdue:${turn.id}`,
                     owner: "leader",
-                    summary: `Delegated Run ${run.id} has an unresolved checkpoint-overdue signal.`,
-                    runId: run.id,
-                    roleName: run.roleName
+                    summary: `Delegated Turn ${turn.id} has an unresolved checkpoint-overdue signal.`,
+                    turnId: turn.id,
+                    roleName: turn.roleName
                 });
             }
         }
     }
     for (const request of input.inputRequests.filter(({ status }) => status === "open")) {
         const requester = request.requester;
-        const run = requester === undefined
+        const turn = requester === undefined
             ? undefined
-            : activeRuns.find(({ id }) => id === requester.runId);
+            : activeTurns.find(({ id }) => id === requester.turnId);
         const role = requester === undefined
             ? undefined
             : input.roles.find(({ name }) => name === requester.roleName);
         const session = requester === undefined
             ? undefined
             : input.roleSessions.find(({ roleName }) => roleName === requester.roleName);
-        if (run === undefined
-            || run.roleName !== "leader"
+        if (turn === undefined
+            || turn.roleName !== "leader"
             || requester === undefined
-            || run.effective?.agentId !== requester.agentId
-            || (role?.adapterId !== undefined && role.adapterId !== run.effective?.adapterId)
+            || turn.effective?.agentId !== requester.agentId
+            || (role?.adapterId !== undefined && role.adapterId !== turn.effective?.adapterId)
             || (requester.nativeSessionId !== undefined
                 && session?.nativeSessionId !== requester.nativeSessionId)) {
             result.push({
                 kind: "identity-mismatch",
                 id: `input:${request.id}`,
                 owner: "leader",
-                summary: `InputRequest ${request.id} does not match the active Leader Run/session; it is held fail-closed.`,
-                ...(requester?.runId === undefined ? {} : { runId: requester.runId }),
+                summary: `InputRequest ${request.id} does not match the active Leader Turn/session; it is held fail-closed.`,
+                ...(requester?.turnId === undefined ? {} : { turnId: requester.turnId }),
                 roleName: "leader",
                 failClosed: true
             });

package/dist/scheduler/taskObservabilityProjection.js

@@ -32,8 +32,8 @@ export function buildTaskObservabilityProjection(input) {
                 ...(summary?.resources === undefined ? {} : { resources: summary.resources })
             });
         });
-        const itemCost = projectCost(groups, input.runs, input.events, now);
-        const itemContext = projectContext(groups, input.runs, input.contextSnapshots);
+        const itemCost = projectCost(groups, input.turns, input.events, now);
+        const itemContext = projectContext(groups, input.turns, input.contextSnapshots);
         const evidence = groups.flatMap((group) => group.lanes.flatMap((lane) => (lane.result?.evidence ?? [])));
         const openFindingCount = groups.reduce((count, group) => count + group.lanes.reduce((laneCount, lane) => laneCount + (lane.result?.findings ?? [])
             .filter(({ status }) => status === "open").length, 0), 0);
@@ -51,8 +51,8 @@ export function buildTaskObservabilityProjection(input) {
             openFindingCount
         });
     });
-    const cost = projectCost(input.executionGroups, input.runs, input.events, now);
-    const context = projectContext(input.executionGroups, input.runs, input.contextSnapshots);
+    const cost = projectCost(input.executionGroups, input.turns, input.events, now);
+    const context = projectContext(input.executionGroups, input.turns, input.contextSnapshots);
     return Object.freeze({
         dag,
         workItems,
@@ -159,7 +159,7 @@ function resolveDependency(id, byId) {
     }
     return current;
 }
-function projectCost(groups, runs, events, now) {
+function projectCost(groups, turns, events, now) {
     const stageGroups = latestStageGroups(groups);
     let tokens = 0;
     let toolCalls = 0;
@@ -170,7 +170,7 @@ function projectCost(groups, runs, events, now) {
     let retryCount = 0;
     for (const group of stageGroups) {
         const lineage = groups.filter((candidate) => sameStage(candidate, group));
-        const usage = observedExecutionResourceUsage({ group, stageGroups: lineage, runs, events });
+        const usage = observedExecutionResourceUsage({ group, stageGroups: lineage, turns, events });
         tokens += usage.tokens;
         toolCalls += usage.toolCalls;
         tokensObservable = tokensObservable && (usage.tokensObservable ?? true);
@@ -192,15 +192,15 @@ function projectCost(groups, runs, events, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectContext(groups, runs, snapshots) {
+function projectContext(groups, turns, snapshots) {
     const refs = new Map();
     for (const group of groups) {
         const ref = group.stage?.contextSnapshotRef;
         if (ref !== undefined)
             refs.set(ref.id, ref);
     }
-    for (const run of runs) {
-        const ref = run.assignment.contextSnapshotRef;
+    for (const turn of turns) {
+        const ref = turn.inputs[0].input.contextSnapshotRef;
         if (ref !== undefined)
             refs.set(ref.id, ref);
     }
@@ -277,5 +277,5 @@ function stageDurationSeconds(groups, now) {
     return Math.max(0, Math.floor((end - Math.min(...started)) / 1_000));
 }
 function isTerminalLane(status) {
-    return status === "yielded" || status === "completed" || status === "failed" || status === "skipped";
+    return status === "completed" || status === "failed" || status === "skipped";
 }

package/dist/scheduler/taskWake.js

@@ -11,7 +11,7 @@ export function createTaskWake(input) {
         fromCursor: requireTimestamp(input.fromCursor, "Wake fromCursor"),
         toCursor: requireTimestamp(input.toCursor, "Wake toCursor"),
         status: "dispatched",
-        runId: requireIdentity(input.runId, "Wake run id"),
+        turnId: requireIdentity(input.turnId, "Wake Turn id"),
         createdAt: input.now.toISOString()
     };
     validateTaskWake(wake);
@@ -55,12 +55,12 @@ export function latestTaskWake(wakes) {
     return latest;
 }
 /**
- * The delta lower bound for a Task's first wake: the last Leader Run's
+ * The delta lower bound for a Task's first wake: the last Leader Turn's
  * creation time, preserving the pre-ledger watermark semantics. When no
- * Leader Run exists, the Task's own creation time bounds the window.
+ * Leader Turn exists, the Task's own creation time bounds the window.
  */
 export function fallbackWakeCursor(input) {
-    return input.leaderRunCreatedAt ?? input.taskCreatedAt;
+    return input.leaderTurnCreatedAt ?? input.taskCreatedAt;
 }
 function wakeSequence(id) {
     const prefix = `${TASK_RECORD_ID_PREFIXES.taskWake}-`;

package/dist/scheduler/wakeReason.js

@@ -8,32 +8,28 @@
  * queue — the wake layer owns the meaning of its tags.
  *
  * Tag wire format: `<kind>` or `<kind>:<ref>`. The ref is an exact record
- * identifier (InputRequest id, AgentRun id, ...) or, for `force-wake`, the
+ * identifier (InputRequest id, Turn id, ...) or, for `force-wake`, the
  * operator-supplied text. Unknown kinds parse losslessly so a newer producer
  * can never wedge an older reader.
  */
 export const WAKE_REASON_KINDS = Object.freeze([
     "role-result",
-    "task-orphaned",
     "input-timeout",
-    "role-run-stalled",
+    "role-turn-stalled",
     "agent-error",
     "agent-session-recovery",
     "review-failed",
     "task-reopened",
-    "agent-error",
-    "agent-session-recovery",
-    "leader-run-failed",
-    "role-run-failed",
+    "leader-turn-failed",
+    "role-turn-failed",
     "job-finished",
     "published-tree-authorized",
-    "review-contract-rebound",
     "force-wake"
 ]);
 const IMMEDIATE_KINDS = new Set([
     "task-reopened",
-    "leader-run-failed",
-    "role-run-failed"
+    "leader-turn-failed",
+    "role-turn-failed"
 ]);
 export function wakeReason(kind, ref) {
     if (ref === undefined)

package/dist/scheduler/wakeupQueue.js

@@ -1,5 +1,4 @@
 import { mergePendingWakeup } from "./pendingWakeup.js";
-import { wakeReason } from "./wakeReason.js";
 export function queueLeaderWakeup(store, taskId, reason, now) {
     if (store.enqueueLeaderWakeup !== undefined) {
         return store.enqueueLeaderWakeup(taskId, reason, now);
@@ -8,11 +7,3 @@ export function queueLeaderWakeup(store, taskId, reason, now) {
     store.savePendingWakeup(pending);
     return pending;
 }
-export function queueLeaderWakeupAfterYield(store, task, run, now) {
-    if (run.taskId !== task.id)
-        throw new Error(`AgentRun belongs to another Task: ${run.taskId}.`);
-    if (task.status !== "active" || task.executionGate.state !== "enabled" || run.roleName === "leader") {
-        return null;
-    }
-    return queueLeaderWakeup(store, task.id, wakeReason("role-result"), now);
-}

package/dist/setup/setupCommand.js

@@ -7,7 +7,7 @@ import { resolveTmuxBin } from "../config/yuiConfig.js";
 import { usageError } from "../errors/cliError.js";
 import { createGlobalRole, createRoleAgentBinding, updateGlobalRole } from "../role/role.js";
 import { SYSTEM_LEADER_ROLE, SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-import { initializeCompatibleTaskStore } from "../storage/compatibleTaskStore.js";
+import { initializeCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { ensureYuiHome, resolveYuiHome } from "../storage/taskStore.js";
 const BUILTIN_AGENTS = Object.freeze([
     Object.freeze({
@@ -36,7 +36,7 @@ export async function runSetupCommand(args, env, executor, io = {}) {
         const question = createSetupQuestion(readline, io);
         const home = resolveYuiHome(env);
         ensureYuiHome(home);
-        const store = initializeCompatibleTaskStore(home);
+        const store = initializeCurrentTaskStore(home);
         const tmuxBin = resolveTmuxBin(store.getConfig().tmuxBin);
         assertTmuxAvailable(executor, tmuxBin);
         const choices = availableAgentChoices(store, env);