@zq-silk/yui 0.13.9 → 0.14.0

package/dist/execution/executionGroup.js

@@ -96,7 +96,7 @@ export function assertExecutionTargetUnchanged(group, target) {
  * Enforce the only durable Group/Lane evolution accepted by both domain
  * helpers and storage. Identity, target, prior results, and a final Leader
  * resolution never move backwards. A terminal Lane may only reopen as an
- * explicit retry with a fresh Run identity, or reset to pending for a
+ * explicit retry with a fresh Turn identity, or reset to pending for a
  * Task-final Review execution retry.
  */
 export function assertExecutionGroupTransition(existing, candidate) {
@@ -153,11 +153,11 @@ export function updateExecutionLane(group, laneId, patch, now) {
     }
     const status = patch.status ?? existing.status;
     const timestamp = now.toISOString();
-    const terminal = status === "completed" || status === "failed" || status === "yielded";
+    const terminal = status === "completed" || status === "failed";
     const next = {
         ...existing,
         ...(patch.effective === undefined ? {} : { effective: validateEffectiveLaunchSnapshot(patch.effective) }),
-        ...(patch.runId === undefined ? {} : { runId: requireIdentity(patch.runId, "Agent Run id") }),
+        ...(patch.turnId === undefined ? {} : { turnId: requireIdentity(patch.turnId, "Turn id") }),
         ...(patch.sessionId === undefined ? {} : { sessionId: requireIdentity(patch.sessionId, "Session id") }),
         ...(patch.reviewRoundId === undefined ? {} : { reviewRoundId: requireIdentity(patch.reviewRoundId, "ReviewRound id") }),
         ...(patch.workspace === undefined ? {} : { workspace: validateLaneWorkspace(patch.workspace) }),
@@ -173,8 +173,8 @@ export function updateExecutionLane(group, laneId, patch, now) {
     });
 }
 /**
- * Reopens only a failed Lane for an explicit WorkItem retry. Completed and
- * yielded results are immutable reusable outputs; retrying them would erase
+ * Reopens only a failed Lane for an explicit WorkItem retry. Completed
+ * results are immutable reusable outputs; retrying them would erase
  * the Group's durable evidence instead of recovering unfinished work.
  */
 export function restartExecutionLane(group, laneId, patch, now) {
@@ -187,14 +187,14 @@ export function restartExecutionLane(group, laneId, patch, now) {
     if (existing === undefined)
         throw new Error(`ExecutionLane not found: ${group.id}/${id}.`);
     if (existing.status !== "failed") {
-        throw new Error(`Only failed ExecutionLanes can start a new AgentRun: ${group.id}/${id}.`);
+        throw new Error(`Only failed ExecutionLanes can start a new Turn: ${group.id}/${id}.`);
     }
     const timestamp = now.toISOString();
     const { result: _result, endedAt: _endedAt, ...base } = existing;
     const next = {
         ...base,
         ...(patch.effective === undefined ? {} : { effective: validateEffectiveLaunchSnapshot(patch.effective) }),
-        ...(patch.runId === undefined ? {} : { runId: requireIdentity(patch.runId, "Agent Run id") }),
+        ...(patch.turnId === undefined ? {} : { turnId: requireIdentity(patch.turnId, "Turn id") }),
         ...(patch.sessionId === undefined ? {} : { sessionId: requireIdentity(patch.sessionId, "Session id") }),
         ...(patch.reviewRoundId === undefined ? {} : { reviewRoundId: requireIdentity(patch.reviewRoundId, "ReviewRound id") }),
         ...(patch.workspace === undefined ? {} : { workspace: validateLaneWorkspace(patch.workspace) }),
@@ -209,8 +209,8 @@ export function restartExecutionLane(group, laneId, patch, now) {
     });
 }
 /**
- * Reopen a failed execution Lane without starting its next Run when Resource
- * Broker capacity is unavailable. The failed attempt remains in AgentRun
+ * Reopen a failed execution Lane without starting its next Turn when Resource
+ * Broker capacity is unavailable. The failed attempt remains in Turn
  * history; the Lane freezes the next launch input until ordinary dispatch can
  * admit it.
  */
@@ -229,7 +229,7 @@ export function queueExecutionLaneRetry(group, laneId, patch, now) {
         throw new Error(`Only a failed ExecutionLane can queue a retry: ${group.id}/${laneId}.`);
     }
     const timestamp = now.toISOString();
-    const { runId: _runId, sessionId: _sessionId, result: _result, endedAt: _endedAt, ...base } = existing;
+    const { turnId: _turnId, sessionId: _sessionId, result: _result, endedAt: _endedAt, ...base } = existing;
     const next = {
         ...base,
         effective: validateEffectiveLaunchSnapshot(patch.effective),
@@ -246,7 +246,7 @@ export function queueExecutionLaneRetry(group, laneId, patch, now) {
 }
 /**
  * Resets a terminal Reviewer Lane to pending without replacing its ExecutionGroup.
- * The old AgentRun remains the attempt trail; clearing the Lane's Run/session and
+ * The old Turn remains the attempt trail; clearing the Lane's Turn/Session and
  * result lets the same semantic ReviewRound be dispatched again.
  */
 export function resetReviewExecutionLane(group, laneId, now) {
@@ -263,7 +263,7 @@ export function resetReviewExecutionLane(group, laneId, now) {
     if (!isTerminalLane(existing.status))
         return existing;
     const timestamp = now.toISOString();
-    const { effective: _effective, runId: _runId, sessionId: _sessionId, result: _result, endedAt: _endedAt, ...base } = existing;
+    const { effective: _effective, turnId: _turnId, sessionId: _sessionId, result: _result, endedAt: _endedAt, ...base } = existing;
     return validateExecutionLane({
         ...base,
         status: "pending",
@@ -289,7 +289,7 @@ export function recordExecutionLaneResult(group, laneId, result, status, now) {
     });
 }
 /**
- * Stop only work that has never started. Running Lanes retain their exact Run
+ * Stop only work that has never started. Running Lanes retain their exact Turn
  * and Session; the Resource Broker never kills a straggler merely to save
  * budget. Skipped Lanes are terminal but never usable Candidate inputs.
  */
@@ -309,7 +309,7 @@ export function skipPendingExecutionLanes(group, laneIds, summary, now) {
         const lane = group.lanes.find(({ id }) => id === laneId);
         if (lane === undefined)
             throw new Error(`ExecutionLane not found: ${group.id}/${laneId}.`);
-        if (lane.status !== "pending" || lane.runId !== undefined) {
+        if (lane.status !== "pending" || lane.turnId !== undefined) {
             throw new Error(`Only an unstarted pending ExecutionLane can be skipped: ${group.id}/${laneId}.`);
         }
     }
@@ -339,7 +339,7 @@ export function resolveExecutionGroup(group, input, now) {
     const summary = requireText(input.summary, "Execution resolution summary");
     const defaultSelectedLaneIds = input.decision === "accept"
         ? group.lanes
-            .filter((lane) => lane.status === "yielded" || lane.status === "completed")
+            .filter((lane) => lane.status === "completed")
             .map(({ id }) => id)
         : group.lanes.map(({ id }) => id);
     const selected = [...new Set((input.selectedLaneIds ?? defaultSelectedLaneIds)
@@ -349,12 +349,12 @@ export function resolveExecutionGroup(group, input, now) {
     }
     if (input.decision === "accept" && selected.some((id) => {
         const lane = group.lanes.find((candidate) => candidate.id === id);
-        return lane?.status !== "yielded" && lane?.status !== "completed";
+        return lane?.status !== "completed";
     })) {
         throw new Error(`ExecutionGroup accept selects a Lane without usable terminal output: ${group.id}.`);
     }
     if (input.decision === "accept" && group.stage?.resources !== undefined) {
-        const usable = group.lanes.filter(({ status }) => (status === "yielded" || status === "completed")).length;
+        const usable = group.lanes.filter(({ status }) => status === "completed").length;
         if (usable < group.stage.resources.quorum) {
             throw new Error(`ExecutionGroup quorum is not met: ${usable}/${group.stage.resources.quorum} usable Lanes.`);
         }
@@ -398,7 +398,7 @@ export function summarizeExecutionGroup(group) {
             laneId: lane.id,
             roleName: lane.roleName,
             ordinal: lane.ordinal,
-            ...(lane.runId === undefined ? {} : { runId: lane.runId }),
+            ...(lane.turnId === undefined ? {} : { turnId: lane.turnId }),
             ...(lane.sessionId === undefined ? {} : { sessionId: lane.sessionId }),
             ...(lane.effective === undefined ? {} : { effective: lane.effective }),
             ...(lane.directive === undefined ? {} : { directive: lane.directive }),
@@ -571,7 +571,7 @@ export function validateExecutionLane(lane, group) {
             throw new Error(`ExecutionLane belongs to another Group: ${lane.id}.`);
         if (group.purpose === "review" && lane.reviewRoundId === undefined) {
             // A review lane may be pending before its ReviewRound is dispatched, but
-            // it must acquire that identity before it can run.
+            // it must acquire that identity before it can turn.
             if (lane.status === "running"
                 || lane.status === "completed"
                 || lane.status === "failed"
@@ -584,8 +584,8 @@ export function validateExecutionLane(lane, group) {
     requireIdentity(lane.roleName, "ExecutionLane Role");
     if (lane.effective !== undefined)
         validateEffectiveLaunchSnapshot(lane.effective);
-    if (lane.runId !== undefined)
-        requireIdentity(lane.runId, "Agent Run id");
+    if (lane.turnId !== undefined)
+        requireIdentity(lane.turnId, "Turn id");
     if (lane.sessionId !== undefined)
         requireIdentity(lane.sessionId, "Session id");
     if (lane.reviewRoundId !== undefined)
@@ -594,14 +594,14 @@ export function validateExecutionLane(lane, group) {
         validateLaneWorkspace(lane.workspace);
     if (lane.directive !== undefined)
         requireText(lane.directive, "ExecutionLane directive");
-    if (!["pending", "running", "yielded", "completed", "failed", "skipped"].includes(lane.status)) {
+    if (!["pending", "running", "completed", "failed", "skipped"].includes(lane.status)) {
         throw new Error(`ExecutionLane status is invalid: ${String(lane.status)}.`);
     }
     if (lane.status === "skipped") {
         if (group !== undefined && group.purpose !== "execution") {
             throw new Error(`Only WorkItem ExecutionLanes can be skipped: ${lane.id}.`);
         }
-        if (lane.runId !== undefined || lane.sessionId !== undefined) {
+        if (lane.turnId !== undefined || lane.sessionId !== undefined) {
             throw new Error(`Skipped ExecutionLane must never have started: ${lane.id}.`);
         }
     }
@@ -627,7 +627,7 @@ function createLane(id, groupId, input, ordinal, timestamp) {
         ordinal: positiveInteger(input.ordinal ?? ordinal, "ExecutionLane ordinal"),
         roleName: requireIdentity(input.roleName, "ExecutionLane Role"),
         ...(input.effective === undefined ? {} : { effective: validateEffectiveLaunchSnapshot(input.effective) }),
-        ...(input.runId === undefined ? {} : { runId: requireIdentity(input.runId, "Agent Run id") }),
+        ...(input.turnId === undefined ? {} : { turnId: requireIdentity(input.turnId, "Turn id") }),
         ...(input.sessionId === undefined ? {} : { sessionId: requireIdentity(input.sessionId, "Session id") }),
         ...(input.reviewRoundId === undefined ? {} : { reviewRoundId: requireIdentity(input.reviewRoundId, "ReviewRound id") }),
         ...(input.workspace === undefined ? {} : { workspace: validateLaneWorkspace(input.workspace) }),
@@ -745,7 +745,7 @@ function validateResolution(resolution, group) {
         && (resolution.selectedLaneIds.length === 0
             || resolution.selectedLaneIds.some((id) => {
                 const lane = group.lanes.find((candidate) => candidate.id === id);
-                return lane?.status !== "yielded" && lane?.status !== "completed";
+                return lane?.status !== "completed";
             }))) {
         throw new Error("Execution accept resolution must select usable Lane output.");
     }
@@ -780,7 +780,7 @@ function assertExecutionLaneTransition(existing, candidate, groupId, groupPurpos
         if (groupPurpose === "review"
             && candidate.status === "pending"
             && candidate.effective === undefined
-            && candidate.runId === undefined
+            && candidate.turnId === undefined
             && candidate.sessionId === undefined
             && candidate.result === undefined
             && candidate.endedAt === undefined
@@ -791,7 +791,7 @@ function assertExecutionLaneTransition(existing, candidate, groupId, groupPurpos
             && existing.status === "failed"
             && candidate.status === "pending"
             && candidate.effective !== undefined
-            && candidate.runId === undefined
+            && candidate.turnId === undefined
             && candidate.sessionId === undefined
             && candidate.result === undefined
             && candidate.endedAt === undefined
@@ -799,16 +799,16 @@ function assertExecutionLaneTransition(existing, candidate, groupId, groupPurpos
             return;
         }
         if (candidate.status !== "running"
-            || candidate.runId === undefined
-            || candidate.runId === existing.runId) {
-            throw new Error(`Terminal ExecutionLane is immutable without a fresh retry Run: ${existing.id}.`);
+            || candidate.turnId === undefined
+            || candidate.turnId === existing.turnId) {
+            throw new Error(`Terminal ExecutionLane is immutable without a fresh retry Turn: ${existing.id}.`);
         }
         return;
     }
     if (existing.status === "running" && candidate.status === "pending") {
         throw new Error(`Running ExecutionLane cannot return to pending: ${existing.id}.`);
     }
-    for (const key of ["effective", "runId", "sessionId", "workspace", "directive"]) {
+    for (const key of ["effective", "turnId", "sessionId", "workspace", "directive"]) {
         if (existing[key] !== undefined
             && !isDeepStrictEqual(existing[key], candidate[key])) {
             throw new Error(`ExecutionLane ${key} changed without retry: ${existing.id}.`);
@@ -837,8 +837,7 @@ function validatePurpose(purpose) {
     return purpose;
 }
 function isTerminalLane(status) {
-    return status === "yielded"
-        || status === "completed"
+    return status === "completed"
         || status === "failed"
         || status === "skipped";
 }

package/dist/execution/executionHealth.js

@@ -1,4 +1,4 @@
-import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
+import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
 import { validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
@@ -7,9 +7,9 @@ import { runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuat
 import { summarizeExecutionGroup } from "./executionGroup.js";
 import { executionStageSpendClosed, observedExecutionResourceUsage, projectExecutionStageResources } from "./resourceBroker.js";
 /**
- * Fold existing Run, runtime, Session, process-exit, and stall facts into the
+ * Fold existing Turn, runtime, Session, process-exit, and stall facts into the
  * four Lane health states. This is a read model only: it never advances a
- * Lane, terminalizes a Run, or guesses that silence means death.
+ * Lane, terminalizes a Turn, or guesses that silence means death.
  */
 export function projectExecutionGroupHealth(input) {
     const policy = input.policy ?? DEFAULT_RUNTIME_HEALTH_POLICY;
@@ -23,7 +23,7 @@ export function projectExecutionGroupHealth(input) {
         confirmedDeadLaneCount: countHealth(lanes, "confirmed-dead"),
         reusableLaneIds: lanes.filter(({ resultReusable }) => resultReusable)
             .map(({ laneId }) => laneId),
-        retryableLaneIds: lanes.filter(({ recovery }) => recovery === "retry-new-agent-run")
+        retryableLaneIds: lanes.filter(({ recovery }) => recovery === "retry-new-turn")
             .map(({ laneId }) => laneId)
     });
 }
@@ -39,7 +39,7 @@ export function summarizeExecutionGroupHealth(input) {
             usage: observedExecutionResourceUsage({
                 group: input.group,
                 ...(input.stageGroups === undefined ? {} : { stageGroups: input.stageGroups }),
-                runs: input.runs,
+                turns: input.turns,
                 events: input.events
             }),
             now: input.now
@@ -67,45 +67,44 @@ export function actionableExecutionLaneRecoveries(groups) {
     return groups
         .filter(({ resolution }) => resolution === undefined)
         .flatMap((group) => group.laneSummaries.flatMap((lane) => {
-        if (lane.recovery === "retry-new-agent-run"
+        if (lane.recovery === "retry-new-turn"
             && group.resources !== undefined
             && executionStageSpendClosed(group.resources))
             return [];
-        if (lane.recovery !== "retry-new-agent-run")
+        if (lane.recovery !== "retry-new-turn")
             return [];
         return [{
                 groupId: group.groupId,
                 laneId: lane.laneId,
-                ...(lane.runId === undefined ? {} : { runId: lane.runId }),
+                ...(lane.turnId === undefined ? {} : { turnId: lane.turnId }),
                 ...(lane.runtimeHealth === undefined ? {} : { runtimeHealth: lane.runtimeHealth }),
                 recovery: lane.recovery
             }];
     }));
 }
 function projectExecutionLaneHealth(lane, input, policy) {
-    const run = lane.runId === undefined
+    const run = lane.turnId === undefined
         ? undefined
-        : input.runs.find((candidate) => exactLaneRun(candidate, input.group, lane));
+        : input.turns.find((candidate) => exactLaneTurn(candidate, input.group, lane));
     const continuationAgentId = run?.effective.agentId ?? lane.effective?.agentId;
     if (lane.status !== "completed"
-        && lane.status !== "yielded"
-        && lane.runId !== undefined
+        && lane.turnId !== undefined
         && continuationAgentId !== undefined
         && runOwnsBlockingProviderContinuation(input.events, {
             taskId: input.group.taskId,
             roleName: lane.roleName,
-            runId: lane.runId,
+            turnId: lane.turnId,
             agentId: continuationAgentId
         })) {
         return projection(lane, {
             runtimeHealth: "active",
             recovery: "none",
             resultReusable: false,
-            reason: "the exact Run still owns an unsettled Provider continuation writer",
+            reason: "the exact Turn still owns an unsettled Provider continuation writer",
             evidence: ["runtime-continuation-writer-owned"]
         });
     }
-    if (lane.status === "completed" || lane.status === "yielded") {
+    if (lane.status === "completed") {
         return projection(lane, {
             recovery: "reuse-result",
             resultReusable: true,
@@ -116,9 +115,9 @@ function projectExecutionLaneHealth(lane, input, policy) {
     if (lane.status === "failed") {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
-            recovery: "retry-new-agent-run",
+            recovery: "retry-new-turn",
             resultReusable: false,
-            reason: "the exact Lane attempt is durably failed; a retry must create a new AgentRun",
+            reason: "the exact Lane attempt is durably failed; a retry must create a new Turn",
             evidence: ["execution-lane-terminal-failure"]
         });
     }
@@ -143,17 +142,17 @@ function projectExecutionLaneHealth(lane, input, policy) {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the running Lane has no exact AgentRun record",
+            reason: "the running Lane has no exact Turn record",
             evidence: ["execution-lineage-missing"]
         });
     }
     if (run.status === "failed") {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
-            recovery: "retry-new-agent-run",
+            recovery: "retry-new-turn",
             resultReusable: false,
-            reason: "the exact AgentRun is durably failed",
-            evidence: ["agent-run-terminal-failure"]
+            reason: "the exact Turn is durably failed",
+            evidence: ["turn-terminal-failure"]
         });
     }
     if (run.status !== "active") {
@@ -161,14 +160,14 @@ function projectExecutionLaneHealth(lane, input, policy) {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the Lane is running but its exact AgentRun is terminal without a Lane result",
+            reason: "the Lane is running but its exact Turn is terminal without a Lane result",
             evidence: ["execution-lineage-inconsistent"]
         });
     }
     const session = input.sessions.find((candidate) => (candidate.roleName === run.roleName
         && candidate.agentId === run.effective.agentId
         && candidate.adapterId === run.effective.adapterId));
-    const observations = exactRunObservations(input.events, run, session);
+    const observations = exactTurnObservations(input.events, run, session);
     const runtime = runtimeProjection(observations, input.events, run);
     const unsettledContinuation = runtime !== null
         && Object.values(runtime.continuations).some((continuation) => (continuation.execution === "active"
@@ -178,13 +177,13 @@ function projectExecutionLaneHealth(lane, input, policy) {
         && (Object.values(runtime.operations).some(({ kind }) => kind === "subagent")
             || unsettledContinuation);
     if (observations.some((observation) => (observation.kind === "turn.failed"
-        && observation.payload.failure?.runTerminal === true)) && !unsettledChildWork) {
+        && observation.payload.failure?.turnTerminal === true)) && !unsettledChildWork) {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the Provider reported an exact run-terminal failure",
-            evidence: ["provider-run-terminal"]
+            reason: "the Provider reported an exact Turn-terminal failure",
+            evidence: ["provider-turn-terminal"]
         });
     }
     const runtimeTerminalEvidence = runtime === null
@@ -218,20 +217,19 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: ["native-session-terminal", `process-exit:${exit.classification}`]
         });
     }
-    if (isRoleRunStalled(input.events, run.id)) {
+    if (isRoleTurnStalled(input.events, run.id)) {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
             reason: `the durable progress clock has not advanced since ${latestStallProgressAt(input.events, run.id) ?? run.updatedAt}; no death proof exists`,
-            evidence: ["run-stalled"]
+            evidence: ["turn-stalled"]
         });
     }
     const activeOperation = runtime !== null
         && (Object.keys(runtime.operations).length > 0 || unsettledContinuation);
     const lastActivityAt = runtime?.lastRuntimeActivityAt
-        ?? run.deliveredAt
-        ?? run.pushedAt
+        ?? run.updatedAt
         ?? run.createdAt;
     const recentActivity = input.now.getTime() - Date.parse(lastActivityAt) < policy.quietAfterMs;
     if (activeOperation || recentActivity) {
@@ -243,7 +241,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
                 ? "the exact runtime reports unsettled continuation work"
                 : activeOperation
                     ? "the exact runtime reports an active operation"
-                    : "the exact Run has recent structured runtime activity",
+                    : "the exact Turn has recent structured runtime activity",
             evidence: unsettledContinuation
                 ? ["runtime-continuation-unsettled"]
                 : activeOperation ? ["runtime-operation-active"] : ["runtime-activity-recent"]
@@ -253,25 +251,25 @@ function projectExecutionLaneHealth(lane, input, policy) {
         runtimeHealth: "silent",
         recovery: "none",
         resultReusable: false,
-        reason: "the exact Run remains active without recent structured activity; silence alone is not death",
-        evidence: ["agent-run-active"]
+        reason: "the exact Turn remains active without recent structured activity; silence alone is not death",
+        evidence: ["turn-active"]
     });
 }
 function projection(lane, value) {
     return Object.freeze({ laneId: lane.id, ...value });
 }
-function exactLaneRun(run, group, lane) {
-    return run.id === lane.runId
+function exactLaneTurn(run, group, lane) {
+    return run.id === lane.turnId
         && run.taskId === group.taskId
         && run.roleName === lane.roleName
         && run.executionGroupId === group.id
         && run.executionLaneId === lane.id;
 }
-function exactRunObservations(events, run, session) {
+function exactTurnObservations(events, run, session) {
     return events.map(runtimeObservationFromTaskEvent)
         .filter((observation) => (observation !== null
         && observation.fence.taskId === run.taskId
-        && observation.fence.runId === run.id
+        && observation.fence.turnId === run.id
         && observation.fence.roleName === run.roleName
         && observation.fence.agentId === run.effective.agentId
         && (session?.launchId === undefined || observation.fence.launchId === session.launchId)
@@ -291,7 +289,7 @@ function latestExactProcessExit(events, run, session) {
         try {
             const observation = validateRuntimeProcessExitObservation(JSON.parse(event.payload.observation ?? ""));
             if (observation.taskId !== run.taskId
-                || observation.runId !== run.id
+                || observation.turnId !== run.id
                 || observation.roleName !== run.roleName
                 || (session?.launchId !== undefined && observation.launchId !== session.launchId)
                 || (session?.nativeSessionId !== undefined

package/dist/execution/resourceBroker.js

@@ -300,23 +300,23 @@ export function observedExecutionResourceUsage(input) {
     const group = validateExecutionGroup(input.group);
     const stageGroups = executionStageRetryLineage(group, input.stageGroups);
     const groupIds = new Set(stageGroups.map(({ id }) => id));
-    const runIds = new Set([
+    const turnIds = new Set([
         ...stageGroups.flatMap((candidate) => candidate.lanes
-            .flatMap(({ runId }) => runId === undefined ? [] : [runId])),
-        ...(input.runs ?? []).filter((run) => (run.taskId === group.taskId
-            && run.purpose === "execution"
-            && run.executionGroupId !== undefined
-            && groupIds.has(run.executionGroupId))).map(({ id }) => id)
+            .flatMap(({ turnId }) => turnId === undefined ? [] : [turnId])),
+        ...(input.turns ?? []).filter((turn) => (turn.taskId === group.taskId
+            && turn.purpose === "execution"
+            && turn.executionGroupId !== undefined
+            && groupIds.has(turn.executionGroupId))).map(({ id }) => id)
     ]);
     const observations = input.events.map(runtimeObservationFromTaskEvent)
         .filter((value) => (value !== null
         && value.fence.taskId === group.taskId
-        && value.fence.runId !== undefined
-        && runIds.has(value.fence.runId)));
+        && value.fence.turnId !== undefined
+        && turnIds.has(value.fence.turnId)));
     let tokens = 0;
     let tokensObservable = true;
-    for (const runId of runIds) {
-        const usage = observations.filter(({ fence, payload }) => (fence.runId === runId && payload.usage !== undefined)).sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
+    for (const turnId of turnIds) {
+        const usage = observations.filter(({ fence, payload }) => (fence.turnId === turnId && payload.usage !== undefined)).sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
             || (left.sequence ?? 0) - (right.sequence ?? 0)
             || (left.ordinal ?? 0) - (right.ordinal ?? 0)));
         if (usage.length === 0) {
@@ -345,7 +345,7 @@ export function observedExecutionResourceUsage(input) {
             tokensObservable = false;
     }
     const toolOperationIds = new Set(observations.flatMap((observation) => (observation.kind === "operation.started" && observation.payload.operation === "tool"
-        ? [`${observation.fence.runId}\0${observation.payload.operationId ?? observation.semanticKey}`]
+        ? [`${observation.fence.turnId}\0${observation.payload.operationId ?? observation.semanticKey}`]
         : [])));
     const toolCallsObservable = observations.some(({ kind, payload }) => (kind === "operation.started" && payload.operation === "tool"));
     return Object.freeze({
@@ -422,5 +422,5 @@ function percentage(value, label) {
     return value;
 }
 function isUsable(status) {
-    return status === "yielded" || status === "completed";
+    return status === "completed";
 }