@zq-silk/yui 0.15.7 → 0.15.8

package/dist/scheduler/{roleTurnStall.js → roleRunStall.js}

@@ -2,21 +2,21 @@ import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js
 import { nextPendingBatch } from "../coordination/workMailbox.js";
 import { RUNTIME_DIAGNOSTIC_AFTER_MS, SEMANTIC_STALL_WINDOW_MS } from "../runtime/runtimeHealthPolicy.js";
 /**
- * Default window of no durable progress before a live-but-idle Turn becomes a
- * traceable needs-attention signal. It is deliberately long: a healthy Turn that
+ * Default window of no durable progress before a live-but-idle AgentRun becomes a
+ * traceable needs-attention signal. It is deliberately long: a healthy AgentRun that
  * is simply slow keeps its structured checkpoint fresh and never crosses it.
  */
 export const DEFAULT_STALL_WINDOW_MS = SEMANTIC_STALL_WINDOW_MS;
 /** Cheap workflow-stall candidate filter; the real threshold remains 30m. */
 export const DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS = RUNTIME_DIAGNOSTIC_AFTER_MS;
-export const TURN_PROGRESS_EVENT = "turn.progress";
-export const TURN_STALLED_EVENT = "turn.stalled";
-export const TURN_RECOVERED_EVENT = "turn.recovered";
-export const TURN_DIAGNOSTIC_FINISHED_EVENT = "runtime.diagnostic-finished";
+export const RUN_PROGRESS_EVENT = "run.progress";
+export const RUN_STALLED_EVENT = "run.stalled";
+export const RUN_RECOVERED_EVENT = "run.recovered";
+export const RUN_DIAGNOSTIC_FINISHED_EVENT = "runtime.diagnostic-finished";
 /** Structured, non-Message recovery evidence written by an explicit Leader. */
 /** Workflow-semantic events that count for the durable progress clock. */
 const ACTIVITY_EVENT_TYPES = new Set([
-    TURN_PROGRESS_EVENT,
+    RUN_PROGRESS_EVENT,
     "message.sent",
     "input.answered",
     "input.auto-answered",
@@ -31,17 +31,17 @@ const ACTIVITY_EVENT_TYPES = new Set([
 ]);
 /**
  * One pure projection used by every Role. Resource activity is retained only
- * as exact-generation diagnostic evidence; it never changes the durable
+ * as exact-Session diagnostic evidence; it never changes the durable
  * progress clock, suppresses workflow attention, or authorizes recovery.
  */
-export function projectRoleTurnHealth(input) {
+export function projectRoleRunHealth(input) {
     const windowMs = input.windowMs ?? DEFAULT_STALL_WINDOW_MS;
     const diagnosticAfterMs = input.diagnosticAfterMs
         ?? DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS;
     if (!Number.isFinite(windowMs) || windowMs <= 0) {
-        throw new Error("Role Turn stall window must be a positive number of milliseconds.");
+        throw new Error("Role AgentRun stall window must be a positive number of milliseconds.");
     }
-    const evaluation = evaluateRoleTurnStall({
+    const evaluation = evaluateRoleRunStall({
         progressAt: input.progressAt,
         now: input.now,
         windowMs
@@ -58,7 +58,6 @@ export function projectRoleTurnHealth(input) {
         : session.status === "ended"
             ? session.endReason === "failed" ? "broken" : "stopped"
             : !hasResourceIdentityText(session.nativeSessionId)
-                && !hasResourceIdentityText(session.runtimeGenerationId)
                 ? "unknown"
                 : "matching";
     const resourceActivity = hostLiveness === "present"
@@ -107,16 +106,16 @@ export function projectRoleTurnHealth(input) {
 /**
  * Pure stall decision. Given the last durable progress timestamp and whatever
  * progress point the previous attention (if any) recorded, decide whether the
- * Turn is stalled and whether this is new evidence worth surfacing again.
+ * AgentRun is stalled and whether this is new evidence worth surfacing again.
  */
-export function evaluateRoleTurnStall(input) {
+export function evaluateRoleRunStall(input) {
     const windowMs = input.windowMs ?? DEFAULT_STALL_WINDOW_MS;
     if (!Number.isFinite(windowMs) || windowMs <= 0) {
-        throw new Error("Role Turn stall window must be a positive number of milliseconds.");
+        throw new Error("Role AgentRun stall window must be a positive number of milliseconds.");
     }
     const progressMs = Date.parse(input.progressAt);
     if (!Number.isFinite(progressMs)) {
-        throw new Error("Role Turn stall progress timestamp is invalid.");
+        throw new Error("Role AgentRun stall progress timestamp is invalid.");
     }
     const idleMs = input.now.getTime() - progressMs;
     const stalled = idleMs >= windowMs;
@@ -124,7 +123,7 @@ export function evaluateRoleTurnStall(input) {
     return { stalled, isNewEpisode, idleMs, progressAt: input.progressAt };
 }
 /**
- * Latest durable progress timestamp for an active Turn. Turn creation,
+ * Latest durable progress timestamp for an active AgentRun. AgentRun creation,
  * explicit workflow checkpoints, and semantic domain activity count as
  * progress. Provider operations, tokens, CPU/memory and bookkeeping are
  * intentionally excluded.
@@ -136,17 +135,17 @@ export function latestDurableProgressAt(input) {
         input.latestActivityAt
     ].filter((value) => (typeof value === "string" && Number.isFinite(Date.parse(value))));
     if (candidates.length === 0) {
-        throw new Error("No durable progress timestamp is available for the Turn.");
+        throw new Error("No durable progress timestamp is available for the AgentRun.");
     }
     return candidates.reduce((latest, value) => (Date.parse(value) > Date.parse(latest) ? value : latest));
 }
-/** Most recent semantic timestamp carried by a Turn progress event. */
-export function latestTurnProgressAt(events, turnId) {
+/** Most recent semantic timestamp carried by a AgentRun progress event. */
+export function latestRunProgressAt(events, runId) {
     let latest;
     for (const event of events) {
-        if (event.type !== TURN_PROGRESS_EVENT)
+        if (event.type !== RUN_PROGRESS_EVENT)
             continue;
-        if (event.payload.turnId !== turnId)
+        if (event.payload.runId !== runId)
             continue;
         const progressAt = typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
@@ -163,11 +162,11 @@ export function latestTurnProgressAt(events, turnId) {
 }
 /**
  * Resolve the exact semantic progress fence shared by resource production and
- * stall consumption for one active Turn. Resource evidence carries this value
+ * stall consumption for one active AgentRun. Resource evidence carries this value
  * as an exact fence, but never advances it.
  */
-export function currentRoleTurnProgressAt(store, taskId, roleName, run) {
-    const progress = store.getTurnDurableProgress(taskId, roleName, run.id);
+export function currentRoleRunProgressAt(store, taskId, roleName, run) {
+    const progress = store.getRunDurableProgress(taskId, roleName, run.id);
     if (progress !== null) {
         return {
             progressAt: progress.progressAt,
@@ -179,12 +178,12 @@ export function currentRoleTurnProgressAt(store, taskId, roleName, run) {
     return { progressAt: run.createdAt };
 }
 /**
- * Computes the current semantic progress fence for an exact Turn. The optional
- * related-record readers add Work/Review/Integration evidence to the Turn and
+ * Computes the current semantic progress fence for an exact AgentRun. The optional
+ * related-record readers add Work/Review/Integration evidence to the AgentRun and
  * event facts used by on-demand projections.
  */
-export function latestTurnDurableProgressAt(store, taskId, roleName, turnId, precomputed) {
-    const run = store.getTurn(taskId, turnId);
+export function latestRunDurableProgressAt(store, taskId, roleName, runId, precomputed) {
+    const run = store.getRun(taskId, runId);
     if (run === null || run.taskId !== taskId || run.roleName !== roleName)
         return null;
     // Scheduler reconciliation supplies its once-per-revision fold; on-demand
@@ -193,10 +192,10 @@ export function latestTurnDurableProgressAt(store, taskId, roleName, turnId, pre
     const events = folded ? undefined : store.listEvents(taskId);
     const latestCheckpointAt = folded
         ? precomputed.latestCheckpointAt
-        : latestTurnProgressAt(events, run.id);
+        : latestRunProgressAt(events, run.id);
     const latestActivityAt = folded
         ? precomputed.latestActivityAt
-        : latestTurnActivityAt(events, run.id);
+        : latestRunActivityAt(events, run.id);
     const baseline = latestDurableProgressAt({
         startedAt: run.createdAt,
         latestCheckpointAt,
@@ -216,8 +215,8 @@ export function latestTurnDurableProgressAt(store, taskId, roleName, turnId, pre
         .filter(({ source }) => (source.kind === "work-item" && source.workItemId === run.workItemId))
         ?? [];
     const inputProgress = store.listInputRequests?.(taskId)
-        .filter((request) => (request.requester.turnId === run.id
-        || request.blockedRefs.some((ref) => ref.type === "turn" && ref.id === run.id)))
+        .filter((request) => (request.requester.runId === run.id
+        || request.blockedRefs.some((ref) => ref.type === "run" && ref.id === run.id)))
         ?? [];
     const related = [
         workItem?.updatedAt,
@@ -238,11 +237,11 @@ export function latestTurnDurableProgressAt(store, taskId, roleName, turnId, pre
             ...(latestRelatedAt === undefined ? {} : { evidence: "work-review-integration" })
         };
 }
-/** Most recent createdAt of a Turn-scoped event of one type, if any. */
-export function latestTurnEventTime(events, type, turnId) {
+/** Most recent createdAt of a AgentRun-scoped event of one type, if any. */
+export function latestRunEventTime(events, type, runId) {
     let latest;
     for (const event of events) {
-        if (event.type !== type || event.payload.turnId !== turnId)
+        if (event.type !== type || event.payload.runId !== runId)
             continue;
         if (latest === undefined || Date.parse(event.createdAt) > Date.parse(latest)) {
             latest = event.createdAt;
@@ -250,16 +249,16 @@ export function latestTurnEventTime(events, type, turnId) {
     }
     return latest;
 }
-/** Most recent non-control event carrying a Turn identity. */
-export function latestTurnActivityAt(events, turnId) {
+/** Most recent non-control event carrying a AgentRun identity. */
+export function latestRunActivityAt(events, runId) {
     let latest;
     for (const event of events) {
         if (!ACTIVITY_EVENT_TYPES.has(event.type)
-            || event.payload.turnId !== turnId
-            || event.type === TURN_STALLED_EVENT
-            || event.type === TURN_RECOVERED_EVENT)
+            || event.payload.runId !== runId
+            || event.type === RUN_STALLED_EVENT
+            || event.type === RUN_RECOVERED_EVENT)
             continue;
-        const activityAt = event.type === TURN_PROGRESS_EVENT
+        const activityAt = event.type === RUN_PROGRESS_EVENT
             && typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
             ? event.payload.progressAt
@@ -270,11 +269,11 @@ export function latestTurnActivityAt(events, turnId) {
     }
     return latest;
 }
-/** The progress point recorded by the most recent stall attention for a Turn. */
-export function latestStallProgressAt(events, turnId) {
+/** The progress point recorded by the most recent stall attention for a AgentRun. */
+export function latestStallProgressAt(events, runId) {
     let latest;
     for (const event of events) {
-        if (event.type !== TURN_STALLED_EVENT || event.payload.turnId !== turnId)
+        if (event.type !== RUN_STALLED_EVENT || event.payload.runId !== runId)
             continue;
         if (latest === undefined || Date.parse(event.createdAt) > Date.parse(latest.createdAt)) {
             latest = event;
@@ -283,10 +282,10 @@ export function latestStallProgressAt(events, turnId) {
     return latest?.payload.progressAt;
 }
 /** Latest stall episode identity used for source-idempotent attention. */
-export function latestStallEvidenceKey(events, turnId) {
+export function latestStallEvidenceKey(events, runId) {
     let latest;
     for (const event of events) {
-        if (event.type !== TURN_STALLED_EVENT || event.payload.turnId !== turnId)
+        if (event.type !== RUN_STALLED_EVENT || event.payload.runId !== runId)
             continue;
         if (latest === undefined || Date.parse(event.createdAt) > Date.parse(latest.createdAt)) {
             latest = event;
@@ -300,27 +299,27 @@ export function latestStallEvidenceKey(events, turnId) {
     };
 }
 /**
- * Folds a Task's event history into per-Turn progress facts in one O(events)
+ * Folds a Task's event history into per-AgentRun progress facts in one O(events)
  * pass. The adapter builds this once per durable revision and serves the
  * stall reconciliation from it, replacing the per-candidate full-history
  * clones and scans that turned one pass into an O(candidates x events) hot
  * read. The fold mirrors latestTurnProgressAt/latestTurnActivityAt/
  * latestStallProgressAt/latestStallEvidenceKey exactly.
  */
-export function foldTurnProgressFacts(events) {
-    const byTurn = new Map();
+export function foldRunProgressFacts(events) {
+    const byRun = new Map();
     const latestStallCreatedAt = new Map();
     for (const event of events) {
-        const turnId = event.payload.turnId;
-        if (typeof turnId !== "string")
+        const runId = event.payload.runId;
+        if (typeof runId !== "string")
             continue;
-        let facts = byTurn.get(turnId);
+        let facts = byRun.get(runId);
         if (facts === undefined) {
             facts = {};
-            byTurn.set(turnId, facts);
+            byRun.set(runId, facts);
         }
         const type = event.type;
-        const isProgress = type === TURN_PROGRESS_EVENT;
+        const isProgress = type === RUN_PROGRESS_EVENT;
         if (isProgress) {
             const validProgress = typeof event.payload.progressAt === "string"
                 && Number.isFinite(Date.parse(event.payload.progressAt));
@@ -337,11 +336,11 @@ export function foldTurnProgressFacts(events) {
                 facts.latestActivityAt = progressAt;
             }
         }
-        else if (type === TURN_STALLED_EVENT) {
-            const previousCreatedAt = latestStallCreatedAt.get(turnId);
+        else if (type === RUN_STALLED_EVENT) {
+            const previousCreatedAt = latestStallCreatedAt.get(runId);
             if (previousCreatedAt === undefined
                 || Date.parse(event.createdAt) > Date.parse(previousCreatedAt)) {
-                latestStallCreatedAt.set(turnId, event.createdAt);
+                latestStallCreatedAt.set(runId, event.createdAt);
                 facts.latestStall = typeof event.payload.progressAt === "string"
                     ? {
                         progressAt: event.payload.progressAt,
@@ -353,33 +352,33 @@ export function foldTurnProgressFacts(events) {
             }
         }
         else if (ACTIVITY_EVENT_TYPES.has(type)
-            && type !== TURN_STALLED_EVENT
-            && type !== TURN_RECOVERED_EVENT) {
+            && type !== RUN_STALLED_EVENT
+            && type !== RUN_RECOVERED_EVENT) {
             if (facts.latestActivityAt === undefined
                 || Date.parse(event.createdAt) > Date.parse(facts.latestActivityAt)) {
                 facts.latestActivityAt = event.createdAt;
             }
         }
     }
-    return byTurn;
+    return byRun;
 }
 /** Yield the event loop so already-written control requests stay responsive. */
 function yieldEventLoop() {
     return new Promise((resolve) => setImmediate(resolve));
 }
 /**
- * True while a Turn remains in an unresolved stall episode: a stall was raised
+ * True while a AgentRun remains in an unresolved stall episode: a stall was raised
  * and no later checkpoint has advanced its durable progress since. This is the
  * projection the runtime-health view reads to surface needs-attention.
  */
-export function isRoleTurnStalled(events, turnId) {
+export function isRoleRunStalled(events, runId) {
     let stalled;
     let recoveredAt;
     let progressAt;
     for (const event of events) {
-        if (event.payload.turnId !== turnId)
+        if (event.payload.runId !== runId)
             continue;
-        if (event.type === TURN_STALLED_EVENT) {
+        if (event.type === RUN_STALLED_EVENT) {
             if (event.payload.status === "diagnostic-only")
                 continue;
             if (stalled === undefined
@@ -388,14 +387,14 @@ export function isRoleTurnStalled(events, turnId) {
             }
             continue;
         }
-        if (event.type === TURN_RECOVERED_EVENT) {
+        if (event.type === RUN_RECOVERED_EVENT) {
             if (recoveredAt === undefined
                 || Date.parse(event.createdAt) > Date.parse(recoveredAt)) {
                 recoveredAt = event.createdAt;
             }
             continue;
         }
-        if (event.type !== TURN_PROGRESS_EVENT)
+        if (event.type !== RUN_PROGRESS_EVENT)
             continue;
         const candidate = typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
@@ -418,26 +417,30 @@ export function isRoleTurnStalled(events, turnId) {
     return progressAt === undefined || Date.parse(progressAt) <= Date.parse(stalledProgressAt);
 }
 /**
- * Low-frequency health pass for active Task Role Turns. An unaccepted Turn is
+ * Low-frequency health pass for active Task Role AgentRuns. An unaccepted AgentRun is
  * watched as delivery-stalled after the reasonable delivery window; an
- * accepted Turn is displayed as checkpoint-overdue after fifteen minutes, but
+ * accepted AgentRun is displayed as checkpoint-overdue after fifteen minutes, but
  * this scheduler performs no runtime inspection until the thirty-minute
  * diagnostic window is due.
- * Leader Turns are only persisted when classification reaches truly-stalled —
+ * Leader AgentRuns are only persisted when classification reaches truly-stalled —
  * healthy downstream work, open user input, and recent own progress remain
  * structured waiting/working facts. No branch sends terminal bytes, retries,
- * replaces a Session, or changes Turn status.
+ * replaces a Session, or changes AgentRun status.
  */
-export async function reconcileStalledRoleTurns(store, delivery, now, selection, windowMs = DEFAULT_STALL_WINDOW_MS, liveStatuses, resourceEvidence, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS) {
+export async function reconcileStalledRoleRuns(store, delivery, now, selection, windowMs = DEFAULT_STALL_WINDOW_MS, liveStatuses, resourceEvidence, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS) {
     // Dirty mailbox passes are intentionally not a second scheduler. Full
-    // reconcile owns the all-active-Turn scan; dirty passes may still route the
+    // reconcile owns the all-active-AgentRun scan; dirty passes may still route the
     // existing mailbox work without manufacturing another episode.
     if (selection !== undefined && !selection.full)
         return [];
-    if (store.recordRoleTurnStall === undefined)
+    if (store.recordRoleRunStall === undefined)
         return [];
-    const candidates = selectedActiveSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
-        const run = store.getActiveTurn(task.id, role.name);
+    // A Draft planning Turn can stall exactly like any other admitted Turn, so it
+    // is selected here too; the episode stays diagnostic-only either way.
+    const candidates = selectedActiveSchedulerTasks(store, selection, {
+        includePlanningDrafts: true
+    }).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
+        const run = store.getActiveRun(task.id, role.name);
         if (run === null || run.status !== "active")
             return [];
         return [{
@@ -456,20 +459,20 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
         eventsByTask.set(taskId, events);
         return events;
     };
-    const cadenceCandidates = candidates.filter(({ task, run }) => isStallCandidate(run, now, windowMs, latestTurnEventTime(diagnosticEvents(task.id), TURN_DIAGNOSTIC_FINISHED_EVENT, run.id)));
+    const cadenceCandidates = candidates.filter(({ task, run }) => isStallCandidate(run, now, windowMs, latestRunEventTime(diagnosticEvents(task.id), RUN_DIAGNOSTIC_FINISHED_EVENT, run.id)));
     const stallCandidates = cadenceCandidates.filter(({ task, role, run }) => {
-        const progressAt = currentRoleTurnProgressAt(store, task.id, role.name, run).progressAt;
-        return isStallCandidate(run, now, windowMs, latestTurnEventTime(diagnosticEvents(task.id), TURN_DIAGNOSTIC_FINISHED_EVENT, run.id), progressAt);
+        const progressAt = currentRoleRunProgressAt(store, task.id, role.name, run).progressAt;
+        return isStallCandidate(run, now, windowMs, latestRunEventTime(diagnosticEvents(task.id), RUN_DIAGNOSTIC_FINISHED_EVENT, run.id), progressAt);
     });
     if (stallCandidates.length === 0)
         return [];
     const diagnosticStartedAt = now.toISOString();
     const finishDiagnostics = (outcome) => {
         for (const { task, role, run } of stallCandidates) {
-            store.recordRoleTurnDiagnostic?.({
+            store.recordRoleRunDiagnostic?.({
                 taskId: task.id,
                 roleName: role.name,
-                turnId: run.id,
+                runId: run.id,
                 startedAt: diagnosticStartedAt,
                 outcome,
                 now
@@ -478,7 +481,7 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
     };
     const stallCandidateKeys = new Set(stallCandidates.map(({ task, role }) => (`${task.id}\0${role.name}`)));
     const observed = new Map();
-    // Recent active Turns are known healthy enough for Leader classification from
+    // Recent active AgentRuns are known healthy enough for Leader classification from
     // their exact acceptance/creation boundary, but are deliberately not read
     // from tmux or Event history until the 30-minute diagnostic window.
     for (const candidate of candidates) {
@@ -504,22 +507,20 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
             statuses = await delivery.inspectRoles(stallCandidates.map(({ task, role, run, session }) => ({
                 taskId: task.id,
                 roleName: role.name,
-                turnId: run.id,
+                runId: run.id,
                 progressAt: run.createdAt,
                 agentId: session?.agentId ?? run.effective.agentId,
                 adapterId: session?.adapterId ?? run.effective.adapterId,
-                ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId })
             })), stallCandidates.map(({ task, role, run, session }) => ({
                 taskId: task.id,
                 roleName: role.name,
-                turnId: run.id,
-                progressAt: currentRoleTurnProgressAt(store, task.id, role.name, run).progressAt,
+                runId: run.id,
+                progressAt: currentRoleRunProgressAt(store, task.id, role.name, run).progressAt,
                 agentId: session?.agentId ?? run.effective.agentId,
                 adapterId: session?.adapterId ?? run.effective.adapterId,
-                ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId })
@@ -527,7 +528,7 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
         }
         catch {
             // Health inspection is advisory. Unknown host state must leave the exact
-            // Turn/Session fence untouched. Closing this window schedules the next
+            // AgentRun/Session fence untouched. Closing this window schedules the next
             // bounded diagnostic thirty minutes later instead of hot-looping.
             finishDiagnostics("observation-error");
             return [];
@@ -574,7 +575,7 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
                     : byRole.get(key);
         }
         catch {
-            // Without a complete live snapshot, especially for downstream Turns,
+            // Without a complete live snapshot, especially for downstream AgentRuns,
             // Leader classification would be unsafe. Treat the whole advisory pass
             // as unknown instead of escalating a false stall.
             finishDiagnostics("observation-error");
@@ -594,12 +595,12 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
             });
             continue;
         }
-        const progressFacts = store.getTurnProgressFacts(candidate.task.id, candidate.run.id);
-        // The Turn creation boundary starts the execution clock; durable workflow
+        const progressFacts = store.getRunProgressFacts(candidate.task.id, candidate.run.id);
+        // The AgentRun creation boundary starts the execution clock; durable workflow
         // facts may advance it independently of Provider transport observations.
-        const progress = currentRoleTurnProgressAt(store, candidate.task.id, candidate.role.name, candidate.run);
+        const progress = currentRoleRunProgressAt(store, candidate.task.id, candidate.role.name, candidate.run);
         const progressAt = progress.progressAt;
-        const evaluation = evaluateRoleTurnStall({
+        const evaluation = evaluateRoleRunStall({
             progressAt,
             now,
             windowMs,
@@ -617,15 +618,12 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
             : {
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                turnId: candidate.run.id,
+                runId: candidate.run.id,
                 agentId: runAgentId,
                 adapterId: runAdapterId,
                 ...(candidate.session.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: candidate.session.nativeSessionId }),
-                ...(candidate.session.runtimeGenerationId === undefined
-                    ? {}
-                    : { runtimeGenerationId: candidate.session.runtimeGenerationId })
             };
         const resourceSnapshot = resourceForRun(resourceEvidence, candidate.task.id, candidate.role.name, candidate.run.id);
         const resourceIsCurrent = live === "present"
@@ -635,7 +633,7 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
             && resourceEvidenceMatchesCurrentRun(resourceSnapshot, expectedResourceIdentity, progressAt)
             && resourceEvidenceIsFresh(resourceSnapshot, now, windowMs, diagnosticAfterMs);
         const resource = resourceIsCurrent ? resourceSnapshot : undefined;
-        const health = projectRoleTurnHealth({
+        const health = projectRoleRunHealth({
             progressAt,
             createdAt: candidate.run.createdAt,
             now,
@@ -647,8 +645,8 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
             resource,
             roleName: candidate.role.name
         });
-        // Delivery-stalled Turns retain the existing delivery clock and immediate
-        // Provider-uncertainty path. Accepted execution Turns use the shared
+        // Delivery-stalled AgentRuns retain the existing delivery clock and immediate
+        // Provider-uncertainty path. Accepted execution AgentRuns use the shared
         // projection. Exact Session/host resource evidence remains diagnostic.
         const resourceActivity = health.resourceActivity;
         const stalled = health.stalled && sessionMatchesRun && sessionUsable;
@@ -672,16 +670,16 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
         if (current.live !== "present" || !current.stalled || !current.stallCandidate)
             continue;
         const { candidate, progressAt } = current;
-        const previous = store.getTurnProgressFacts(candidate.task.id, candidate.run.id)?.latestStall;
+        const previous = store.getRunProgressFacts(candidate.task.id, candidate.run.id)?.latestStall;
         if (previous !== undefined
             && Date.parse(progressAt) > Date.parse(previous.progressAt)) {
             // A new semantic progress point closes the previous episode first. It
             // may itself already be older than the window, in which case the same
-            // pass records the next Turn+progressAt episode below.
-            store.recordRoleTurnProgress?.({
+            // pass records the next AgentRun+progressAt episode below.
+            store.recordRoleRunProgress?.({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                turnId: candidate.run.id,
+                runId: candidate.run.id,
                 progressAt,
                 ...(current.evidence === undefined ? {} : { evidence: current.evidence }),
                 now
@@ -706,15 +704,15 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
                 : []),
             ...(current.evidence === undefined ? [] : [current.evidence])
         ].join(":");
-        // The final contract is one episode per Turn + semantic progress point.
+        // The final contract is one episode per AgentRun + semantic progress point.
         // New role/session/provider evidence is retained in the Leader's next
         // diagnostic context, not duplicated as another Task-level alert.
         if (previous?.progressAt === progressAt)
             continue;
-        const persisted = store.recordRoleTurnStall({
+        const persisted = store.recordRoleRunStall({
             taskId: candidate.task.id,
             roleName: candidate.role.name,
-            turnId: candidate.run.id,
+            runId: candidate.run.id,
             agentId: candidate.run.effective.agentId,
             adapterId: candidate.run.effective.adapterId,
             session: candidate.session,
@@ -729,7 +727,7 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
             raised.push({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                turnId: candidate.run.id,
+                runId: candidate.run.id,
                 status: persisted,
                 kind,
                 classification,
@@ -738,19 +736,19 @@ export async function reconcileStalledRoleTurns(store, delivery, now, selection,
         }
     }
     // A related WorkItem/Review/Integration fold may advance progress without
-    // carrying the Turn id. Materialize it once so context/web can clear the
+    // carrying the AgentRun id. Materialize it once so context/web can clear the
     // attention projection and the event history records the recovery boundary.
     for (const current of observed.values()) {
         if (current.live !== "present" || current.stalled || !current.stallCandidate)
             continue;
         const { candidate, progressAt } = current;
-        const previous = store.getTurnProgressFacts(candidate.task.id, candidate.run.id)?.latestStall;
+        const previous = store.getRunProgressFacts(candidate.task.id, candidate.run.id)?.latestStall;
         if (previous !== undefined
             && Date.parse(progressAt) > Date.parse(previous.progressAt)) {
-            store.recordRoleTurnProgress?.({
+            store.recordRoleRunProgress?.({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                turnId: candidate.run.id,
+                runId: candidate.run.id,
                 progressAt,
                 ...(current.evidence === undefined ? {} : { evidence: current.evidence }),
                 now
@@ -773,7 +771,7 @@ function classifyLeaderStall(store, taskId, observed, now, windowMs) {
     if (store.hasOpenInputRequest(taskId))
         return "waiting-user";
     const downstream = [...observed.values()].filter((entry) => (entry.candidate.task.id === taskId && entry.candidate.role.name !== "leader"));
-    // A present downstream Turn keeps recovery Leader-owned. If that Turn is
+    // A present downstream AgentRun keeps recovery Leader-owned. If that AgentRun is
     // itself stalled, this pass has just routed its structured attention to the
     // Leader; escalating the Leader to the Operator in the same pass would skip
     // the intended recovery owner.
@@ -782,13 +780,13 @@ function classifyLeaderStall(store, taskId, observed, now, windowMs) {
     const mailbox = store.getWorkMailbox({ kind: "role", taskId, roleName: "leader" });
     const pending = mailbox === null || mailbox === undefined ? null : nextPendingBatch(mailbox);
     const processing = mailbox?.processing;
-    const processingCurrent = processing?.executionRef?.type === "turn"
+    const processingCurrent = processing?.executionRef?.type === "run"
         && processing.executionRef.taskId === taskId
         && leader !== undefined
         && processing.executionRef.id === leader.candidate.run.id;
-    const currentTurnId = leader?.candidate.run.id;
-    if (processingCurrent && currentTurnId !== undefined && processing !== null) {
-        const actionProgressAt = latestLeaderActionProgressAt(store, taskId, currentTurnId, processing.startedAt, processing.batch, now);
+    const currentRunId = leader?.candidate.run.id;
+    if (processingCurrent && currentRunId !== undefined && processing !== null) {
+        const actionProgressAt = latestLeaderActionProgressAt(store, taskId, currentRunId, processing.startedAt, processing.batch, now);
         const actionProgressMs = Date.parse(actionProgressAt);
         const actionStalled = Number.isFinite(actionProgressMs)
             && now.getTime() - actionProgressMs >= windowMs;
@@ -807,7 +805,7 @@ function classifyLeaderStall(store, taskId, observed, now, windowMs) {
     return "truly-stalled";
 }
 const LEADER_ACTION_PROGRESS_TYPES = new Set([
-    TURN_PROGRESS_EVENT,
+    RUN_PROGRESS_EVENT,
     "input.answered",
     "input.auto-answered",
     "input.cancelled",
@@ -823,7 +821,7 @@ const LEADER_ACTION_PROGRESS_TYPES = new Set([
     "decision.superseded",
     "milestone.added"
 ]);
-function latestLeaderActionProgressAt(store, taskId, turnId, startedAt, batch, now) {
+function latestLeaderActionProgressAt(store, taskId, runId, startedAt, batch, now) {
     const startedMs = Date.parse(startedAt);
     if (!Number.isFinite(startedMs))
         return "";
@@ -834,14 +832,14 @@ function latestLeaderActionProgressAt(store, taskId, turnId, startedAt, batch, n
             continue;
         if (event.payload.taskId !== undefined && event.payload.taskId !== taskId)
             continue;
-        if (!leaderActionEventMatches(event, taskId, turnId, batch))
+        if (!leaderActionEventMatches(event, taskId, runId, batch))
             continue;
         const createdMs = Date.parse(event.createdAt);
         if (!Number.isFinite(createdMs)
             || createdMs < startedMs
             || createdMs > now.getTime())
             continue;
-        const value = event.type === TURN_PROGRESS_EVENT
+        const value = event.type === RUN_PROGRESS_EVENT
             && typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
             ? event.payload.progressAt
@@ -857,12 +855,12 @@ function latestLeaderActionProgressAt(store, taskId, turnId, startedAt, batch, n
     }
     return latest;
 }
-function leaderActionEventMatches(event, taskId, turnId, batch) {
+function leaderActionEventMatches(event, taskId, runId, batch) {
     if (event.taskId !== taskId)
         return false;
-    if (event.payload.leaderTurnId === turnId)
+    if (event.payload.leaderRunId === runId)
         return true;
-    if (event.payload.turnId === turnId)
+    if (event.payload.runId === runId)
         return true;
     const refs = batch.refs ?? [];
     const refMatches = (type, payloadKey) => {
@@ -871,7 +869,7 @@ function leaderActionEventMatches(event, taskId, turnId, batch) {
             && ref.id === id
             && (ref.taskId === undefined || ref.taskId === taskId)));
     };
-    if (refMatches("turn", "turnId"))
+    if (refMatches("run", "runId"))
         return true;
     if (refMatches("work-item", "workItemId"))
         return true;
@@ -897,7 +895,7 @@ function leaderStallEvidence(store, taskId, observed, now, windowMs) {
             : "recent";
     const processing = store.getWorkMailbox({ kind: "role", taskId, roleName: "leader" })?.processing;
     const leader = [...observed.values()].find((entry) => (entry.candidate.task.id === taskId && entry.candidate.role.name === "leader"));
-    const processingCurrent = processing?.executionRef?.type === "turn"
+    const processingCurrent = processing?.executionRef?.type === "run"
         && processing.executionRef.taskId === taskId
         && leader !== undefined
         && processing.executionRef.id === leader.candidate.run.id;
@@ -928,27 +926,18 @@ function exactLiveStatuses(statuses, candidates) {
         throw new Error("Tmux Role stall snapshot is incomplete.");
     return result;
 }
-function resourceForRun(snapshot, taskId, roleName, turnId) {
+function resourceForRun(snapshot, taskId, roleName, runId) {
     if (snapshot === undefined)
         return undefined;
-    return snapshot.get(`${taskId}\0${roleName}\0${turnId}`);
+    return snapshot.get(`${taskId}\0${roleName}\0${runId}`);
 }
 function resourceEvidenceMatchesCurrentRun(resource, expected, progressAt) {
     if (resource === undefined || expected === undefined)
         return false;
     const identity = resource.identity;
-    if (identity === undefined
-        || resource.progressAt !== progressAt
-        || identity.taskId !== expected.taskId
-        || identity.roleName !== expected.roleName
-        || identity.turnId !== expected.turnId
-        || identity.agentId !== expected.agentId
-        || identity.adapterId !== expected.adapterId
-        || identity.nativeSessionId !== expected.nativeSessionId
-        || identity.runtimeGenerationId !== expected.runtimeGenerationId)
+    if (identity === undefined || resource.progressAt !== progressAt || identity.taskId !== expected.taskId || identity.roleName !== expected.roleName || identity.runId !== expected.runId || identity.agentId !== expected.agentId || identity.adapterId !== expected.adapterId || identity.nativeSessionId !== expected.nativeSessionId)
         return false;
-    return hasResourceIdentityText(identity.nativeSessionId)
-        || hasResourceIdentityText(identity.runtimeGenerationId);
+    return hasResourceIdentityText(identity.nativeSessionId);
 }
 function hasResourceIdentityText(value) {
     return typeof value === "string" && value.trim().length > 0;