@zq-silk/yui 0.13.9 → 0.14.0

package/dist/scheduler/{roleRunStall.js → roleTurnStall.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 Run becomes a
- * traceable needs-attention signal. It is deliberately long: a healthy Run that
+ * 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
  * 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 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";
+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";
 /** 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([
-    RUN_PROGRESS_EVENT,
+    TURN_PROGRESS_EVENT,
     "message.sent",
     "input.answered",
     "input.auto-answered",
@@ -34,24 +34,23 @@ const ACTIVITY_EVENT_TYPES = new Set([
  * as exact-generation diagnostic evidence; it never changes the durable
  * progress clock, suppresses workflow attention, or authorizes recovery.
  */
-export function projectRoleRunHealth(input) {
+export function projectRoleTurnHealth(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 run stall window must be a positive number of milliseconds.");
+        throw new Error("Role Turn stall window must be a positive number of milliseconds.");
     }
-    const evaluation = evaluateRoleRunStall({
+    const evaluation = evaluateRoleTurnStall({
         progressAt: input.progressAt,
         now: input.now,
         windowMs
     });
     const idleMs = evaluation.idleMs;
-    const candidateStart = input.deliveredAt ?? input.createdAt;
-    const candidateAge = input.now.getTime() - Date.parse(candidateStart);
+    const candidateAge = input.now.getTime() - Date.parse(input.createdAt);
     const candidate = Number.isFinite(candidateAge) && candidateAge >= windowMs;
     const providerAcceptance = input.providerAcceptance
-        ?? (input.deliveredAt === undefined ? "ambiguous" : "accepted");
+        ?? "ambiguous";
     const hostLiveness = input.hostLiveness;
     const session = input.nativeSession;
     const nativeSession = session === null || session === undefined
@@ -74,7 +73,7 @@ export function projectRoleRunHealth(input) {
     // no persisted nativeSessionId.  With a present host, durable no-progress
     // evidence is still actionable in that case.  Only an explicit stopped or
     // broken Session blocks the projection; identity mismatches are fenced by
-    // reconcileStalledRoleRuns below before this projection is routed.
+    // reconcileStalledRoleTurns below before this projection is routed.
     const workflowStall = candidate
         && evaluation.stalled
         && hostLiveness === "present"
@@ -108,16 +107,16 @@ export function projectRoleRunHealth(input) {
 /**
  * Pure stall decision. Given the last durable progress timestamp and whatever
  * progress point the previous attention (if any) recorded, decide whether the
- * Run is stalled and whether this is new evidence worth surfacing again.
+ * Turn is stalled and whether this is new evidence worth surfacing again.
  */
-export function evaluateRoleRunStall(input) {
+export function evaluateRoleTurnStall(input) {
     const windowMs = input.windowMs ?? DEFAULT_STALL_WINDOW_MS;
     if (!Number.isFinite(windowMs) || windowMs <= 0) {
-        throw new Error("Role run stall window must be a positive number of milliseconds.");
+        throw new Error("Role Turn stall window must be a positive number of milliseconds.");
     }
     const progressMs = Date.parse(input.progressAt);
     if (!Number.isFinite(progressMs)) {
-        throw new Error("Role run stall progress timestamp is invalid.");
+        throw new Error("Role Turn stall progress timestamp is invalid.");
     }
     const idleMs = input.now.getTime() - progressMs;
     const stalled = idleMs >= windowMs;
@@ -125,29 +124,29 @@ export function evaluateRoleRunStall(input) {
     return { stalled, isNewEpisode, idleMs, progressAt: input.progressAt };
 }
 /**
- * Latest durable progress timestamp for an active Run. Provider acceptance
- * (deliveredAt), explicit workflow checkpoints, and semantic domain activity
- * count as progress. Provider operations, tokens, CPU/memory and bookkeeping
- * timestamps are intentionally excluded.
+ * Latest durable progress timestamp for an active Turn. Turn creation,
+ * explicit workflow checkpoints, and semantic domain activity count as
+ * progress. Provider operations, tokens, CPU/memory and bookkeeping are
+ * intentionally excluded.
  */
 export function latestDurableProgressAt(input) {
     const candidates = [
-        input.deliveredAt,
+        input.startedAt,
         input.latestCheckpointAt,
         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 Run.");
+        throw new Error("No durable progress timestamp is available for the Turn.");
     }
     return candidates.reduce((latest, value) => (Date.parse(value) > Date.parse(latest) ? value : latest));
 }
-/** Most recent semantic timestamp carried by a Run progress event. */
-export function latestRunProgressAt(events, runId) {
+/** Most recent semantic timestamp carried by a Turn progress event. */
+export function latestTurnProgressAt(events, turnId) {
     let latest;
     for (const event of events) {
-        if (event.type !== RUN_PROGRESS_EVENT)
+        if (event.type !== TURN_PROGRESS_EVENT)
             continue;
-        if (event.payload.runId !== runId)
+        if (event.payload.turnId !== turnId)
             continue;
         const progressAt = typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
@@ -164,89 +163,45 @@ export function latestRunProgressAt(events, runId) {
 }
 /**
  * Resolve the exact semantic progress fence shared by resource production and
- * stall consumption for one active Run. The richer adapter fold remains
- * authoritative when available; the retained Run progress/activity events are
- * the provider-neutral fallback. Resource evidence carries this value as an
- * exact fence, but never advances it.
+ * stall consumption for one active Turn. Resource evidence carries this value
+ * as an exact fence, but never advances it.
  */
-export function currentRoleRunProgressAt(store, taskId, roleName, run, events, progressFacts) {
-    let richerProgress;
-    try {
-        richerProgress = store.getRunDurableProgress?.(taskId, roleName, run.id);
-    }
-    catch {
-        // A related-record fold is advisory. The retained Run/Event fence remains
-        // usable when that optional read is unavailable.
-        richerProgress = undefined;
-    }
-    if (run.deliveredAt === undefined)
-        return { progressAt: run.createdAt };
-    // The richer fold is authoritative when present; skip the per-candidate
-    // full-history scans that every stall candidate otherwise pays.
-    if (richerProgress !== undefined && richerProgress !== null) {
+export function currentRoleTurnProgressAt(store, taskId, roleName, run) {
+    const progress = store.getTurnDurableProgress(taskId, roleName, run.id);
+    if (progress !== null) {
         return {
-            progressAt: richerProgress.progressAt,
-            ...(richerProgress.evidence === undefined
+            progressAt: progress.progressAt,
+            ...(progress.evidence === undefined
                 ? {}
-                : { evidence: richerProgress.evidence })
+                : { evidence: progress.evidence })
         };
     }
-    // A present fold port is authoritative even when this Run has no entry. Do
-    // not evaluate a default history argument or fall back to listEvents in
-    // that case: an absent entry is the folded empty fact.
-    const folded = store.getRunProgressFacts !== undefined;
-    const foldedFacts = folded
-        ? progressFacts ?? store.getRunProgressFacts?.(taskId, run.id)
-        : undefined;
-    if (folded) {
-        const fallbackProgressAt = latestDurableProgressAt({
-            deliveredAt: run.deliveredAt,
-            latestCheckpointAt: foldedFacts?.latestCheckpointAt,
-            latestActivityAt: foldedFacts?.latestActivityAt
-        });
-        return { progressAt: fallbackProgressAt };
-    }
-    // Legacy ports retain the per-Run event-history fallback. Resolve the
-    // history only in this branch so fold-backed callers perform zero scans.
-    const history = events ?? store.listEvents?.(taskId) ?? [];
-    const fallbackProgressAt = latestDurableProgressAt({
-        deliveredAt: run.deliveredAt,
-        latestCheckpointAt: latestRunProgressAt(history, run.id),
-        latestActivityAt: latestRunActivityAt(history, run.id)
-    });
-    return {
-        progressAt: fallbackProgressAt
-    };
+    return { progressAt: run.createdAt };
 }
 /**
- * Computes the current semantic progress fence for an exact Run. The optional
- * related-record readers mirror the adapter's Work/Review/Integration fold;
- * narrow scheduler ports can omit them and still retain Run/Event evidence.
+ * Computes the current semantic progress fence for an exact Turn. The optional
+ * related-record readers add Work/Review/Integration evidence to the Turn and
+ * event facts used by on-demand projections.
  */
-export function latestRunDurableProgressAt(store, taskId, roleName, runId, precomputed) {
-    const run = store.getAgentRun(taskId, runId);
+export function latestTurnDurableProgressAt(store, taskId, roleName, turnId, precomputed) {
+    const run = store.getTurn(taskId, turnId);
     if (run === null || run.taskId !== taskId || run.roleName !== roleName)
         return null;
-    // The adapter folds checkpoint/activity once per revision. When the fold
-    // port exists, a missing per-Run entry is an authoritative empty fold: use
-    // its (possibly undefined) values directly and never re-scan the whole
-    // history per candidate. Legacy callers without the port omit precomputed
-    // and keep the per-candidate full-history scans.
+    // Scheduler reconciliation supplies its once-per-revision fold; on-demand
+    // views omit it and compute the same facts from the Task event history.
     const folded = precomputed !== undefined;
     const events = folded ? undefined : store.listEvents(taskId);
     const latestCheckpointAt = folded
         ? precomputed.latestCheckpointAt
-        : latestRunProgressAt(events, run.id);
+        : latestTurnProgressAt(events, run.id);
     const latestActivityAt = folded
         ? precomputed.latestActivityAt
-        : latestRunActivityAt(events, run.id);
-    const baseline = run.deliveredAt === undefined
-        ? run.createdAt
-        : latestDurableProgressAt({
-            deliveredAt: run.deliveredAt,
-            latestCheckpointAt,
-            latestActivityAt
-        });
+        : latestTurnActivityAt(events, run.id);
+    const baseline = latestDurableProgressAt({
+        startedAt: run.createdAt,
+        latestCheckpointAt,
+        latestActivityAt
+    });
     if (run.workItemId === undefined) {
         return { progressAt: baseline };
     }
@@ -262,8 +217,8 @@ export function latestRunDurableProgressAt(store, taskId, roleName, runId, preco
         .filter(({ changeSetIds: ids }) => ids.some((id) => changeSetIds.has(id)))
         ?? [];
     const inputProgress = store.listInputRequests?.(taskId)
-        .filter((request) => (request.requester.runId === run.id
-        || request.blockedRefs.some((ref) => ref.type === "run" && ref.id === run.id)))
+        .filter((request) => (request.requester.turnId === run.id
+        || request.blockedRefs.some((ref) => ref.type === "turn" && ref.id === run.id)))
         ?? [];
     const related = [
         workItem?.updatedAt,
@@ -276,10 +231,7 @@ export function latestRunDurableProgressAt(store, taskId, roleName, runId, preco
     const latestRelatedAt = related.reduce((latest, value) => latest === undefined || Date.parse(value) > Date.parse(latest)
         ? value
         : latest, undefined);
-    // Before provider acceptance the Run clock remains anchored to creation,
-    // while related records are retained as diagnostic evidence only.
-    return run.deliveredAt !== undefined
-        && latestRelatedAt !== undefined
+    return latestRelatedAt !== undefined
         && Date.parse(latestRelatedAt) > Date.parse(baseline)
         ? { progressAt: latestRelatedAt, evidence: "work-review-integration" }
         : {
@@ -287,11 +239,11 @@ export function latestRunDurableProgressAt(store, taskId, roleName, runId, preco
             ...(latestRelatedAt === undefined ? {} : { evidence: "work-review-integration" })
         };
 }
-/** Most recent createdAt of a Run-scoped event of one type, if any. */
-export function latestRunEventTime(events, type, runId) {
+/** Most recent createdAt of a Turn-scoped event of one type, if any. */
+export function latestTurnEventTime(events, type, turnId) {
     let latest;
     for (const event of events) {
-        if (event.type !== type || event.payload.runId !== runId)
+        if (event.type !== type || event.payload.turnId !== turnId)
             continue;
         if (latest === undefined || Date.parse(event.createdAt) > Date.parse(latest)) {
             latest = event.createdAt;
@@ -299,16 +251,16 @@ export function latestRunEventTime(events, type, runId) {
     }
     return latest;
 }
-/** Most recent non-control event carrying a Run identity. */
-export function latestRunActivityAt(events, runId) {
+/** Most recent non-control event carrying a Turn identity. */
+export function latestTurnActivityAt(events, turnId) {
     let latest;
     for (const event of events) {
         if (!ACTIVITY_EVENT_TYPES.has(event.type)
-            || event.payload.runId !== runId
-            || event.type === RUN_STALLED_EVENT
-            || event.type === RUN_RECOVERED_EVENT)
+            || event.payload.turnId !== turnId
+            || event.type === TURN_STALLED_EVENT
+            || event.type === TURN_RECOVERED_EVENT)
             continue;
-        const activityAt = event.type === RUN_PROGRESS_EVENT
+        const activityAt = event.type === TURN_PROGRESS_EVENT
             && typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
             ? event.payload.progressAt
@@ -319,11 +271,11 @@ export function latestRunActivityAt(events, runId) {
     }
     return latest;
 }
-/** The progress point recorded by the most recent stall attention for a Run. */
-export function latestStallProgressAt(events, runId) {
+/** The progress point recorded by the most recent stall attention for a Turn. */
+export function latestStallProgressAt(events, turnId) {
     let latest;
     for (const event of events) {
-        if (event.type !== RUN_STALLED_EVENT || event.payload.runId !== runId)
+        if (event.type !== TURN_STALLED_EVENT || event.payload.turnId !== turnId)
             continue;
         if (latest === undefined || Date.parse(event.createdAt) > Date.parse(latest.createdAt)) {
             latest = event;
@@ -332,10 +284,10 @@ export function latestStallProgressAt(events, runId) {
     return latest?.payload.progressAt;
 }
 /** Latest stall episode identity used for source-idempotent attention. */
-export function latestStallEvidenceKey(events, runId) {
+export function latestStallEvidenceKey(events, turnId) {
     let latest;
     for (const event of events) {
-        if (event.type !== RUN_STALLED_EVENT || event.payload.runId !== runId)
+        if (event.type !== TURN_STALLED_EVENT || event.payload.turnId !== turnId)
             continue;
         if (latest === undefined || Date.parse(event.createdAt) > Date.parse(latest.createdAt)) {
             latest = event;
@@ -349,27 +301,27 @@ export function latestStallEvidenceKey(events, runId) {
     };
 }
 /**
- * Folds a Task's event history into per-Run progress facts in one O(events)
+ * Folds a Task's event history into per-Turn 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 latestRunProgressAt/latestRunActivityAt/
+ * read. The fold mirrors latestTurnProgressAt/latestTurnActivityAt/
  * latestStallProgressAt/latestStallEvidenceKey exactly.
  */
-export function foldRunProgressFacts(events) {
-    const byRun = new Map();
+export function foldTurnProgressFacts(events) {
+    const byTurn = new Map();
     const latestStallCreatedAt = new Map();
     for (const event of events) {
-        const runId = event.payload.runId;
-        if (typeof runId !== "string")
+        const turnId = event.payload.turnId;
+        if (typeof turnId !== "string")
             continue;
-        let facts = byRun.get(runId);
+        let facts = byTurn.get(turnId);
         if (facts === undefined) {
             facts = {};
-            byRun.set(runId, facts);
+            byTurn.set(turnId, facts);
         }
         const type = event.type;
-        const isProgress = type === RUN_PROGRESS_EVENT;
+        const isProgress = type === TURN_PROGRESS_EVENT;
         if (isProgress) {
             const validProgress = typeof event.payload.progressAt === "string"
                 && Number.isFinite(Date.parse(event.payload.progressAt));
@@ -386,11 +338,11 @@ export function foldRunProgressFacts(events) {
                 facts.latestActivityAt = progressAt;
             }
         }
-        else if (type === RUN_STALLED_EVENT) {
-            const previousCreatedAt = latestStallCreatedAt.get(runId);
+        else if (type === TURN_STALLED_EVENT) {
+            const previousCreatedAt = latestStallCreatedAt.get(turnId);
             if (previousCreatedAt === undefined
                 || Date.parse(event.createdAt) > Date.parse(previousCreatedAt)) {
-                latestStallCreatedAt.set(runId, event.createdAt);
+                latestStallCreatedAt.set(turnId, event.createdAt);
                 facts.latestStall = typeof event.payload.progressAt === "string"
                     ? {
                         progressAt: event.payload.progressAt,
@@ -402,33 +354,33 @@ export function foldRunProgressFacts(events) {
             }
         }
         else if (ACTIVITY_EVENT_TYPES.has(type)
-            && type !== RUN_STALLED_EVENT
-            && type !== RUN_RECOVERED_EVENT) {
+            && type !== TURN_STALLED_EVENT
+            && type !== TURN_RECOVERED_EVENT) {
             if (facts.latestActivityAt === undefined
                 || Date.parse(event.createdAt) > Date.parse(facts.latestActivityAt)) {
                 facts.latestActivityAt = event.createdAt;
             }
         }
     }
-    return byRun;
+    return byTurn;
 }
 /** Yield the event loop so already-written control requests stay responsive. */
 function yieldEventLoop() {
     return new Promise((resolve) => setImmediate(resolve));
 }
 /**
- * True while a Run remains in an unresolved stall episode: a stall was raised
+ * True while a Turn 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 isRoleRunStalled(events, runId) {
+export function isRoleTurnStalled(events, turnId) {
     let stalled;
     let recoveredAt;
     let progressAt;
     for (const event of events) {
-        if (event.payload.runId !== runId)
+        if (event.payload.turnId !== turnId)
             continue;
-        if (event.type === RUN_STALLED_EVENT) {
+        if (event.type === TURN_STALLED_EVENT) {
             if (event.payload.status === "diagnostic-only")
                 continue;
             if (stalled === undefined
@@ -437,14 +389,14 @@ export function isRoleRunStalled(events, runId) {
             }
             continue;
         }
-        if (event.type === RUN_RECOVERED_EVENT) {
+        if (event.type === TURN_RECOVERED_EVENT) {
             if (recoveredAt === undefined
                 || Date.parse(event.createdAt) > Date.parse(recoveredAt)) {
                 recoveredAt = event.createdAt;
             }
             continue;
         }
-        if (event.type !== RUN_PROGRESS_EVENT)
+        if (event.type !== TURN_PROGRESS_EVENT)
             continue;
         const candidate = typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
@@ -467,32 +419,26 @@ export function isRoleRunStalled(events, runId) {
     return progressAt === undefined || Date.parse(progressAt) <= Date.parse(stalledProgressAt);
 }
 /**
- * Low-frequency health pass for active Task Role Runs. An unaccepted Run is
+ * Low-frequency health pass for active Task Role Turns. An unaccepted Turn is
  * watched as delivery-stalled after the reasonable delivery window; an
- * accepted Run is displayed as checkpoint-overdue after fifteen minutes, but
+ * accepted Turn is displayed as checkpoint-overdue after fifteen minutes, but
  * this scheduler performs no runtime inspection until the thirty-minute
  * diagnostic window is due.
- * Leader Runs are only persisted when classification reaches truly-stalled —
+ * Leader Turns 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 Run status.
+ * replaces a Session, or changes Turn status.
  */
-export async function reconcileStalledRoleRuns(store, delivery, now, selection, windowMs = DEFAULT_STALL_WINDOW_MS, liveStatuses, resourceEvidence, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS) {
+export async function reconcileStalledRoleTurns(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-Run scan; dirty passes may still route the
+    // reconcile owns the all-active-Turn scan; dirty passes may still route the
     // existing mailbox work without manufacturing another episode.
     if (selection !== undefined && !selection.full)
         return [];
-    if ((store.getRunProgressFacts === undefined && store.listEvents === undefined)
-        || store.recordRoleRunStall === undefined)
+    if (store.recordRoleTurnStall === undefined)
         return [];
-    // When the fold port exists, a missing per-Run entry is an authoritative
-    // empty fold: the stall reconciliation must not re-scan the whole history
-    // per candidate. Legacy stores without the port keep the per-candidate
-    // scans.
-    const foldPortPresent = store.getRunProgressFacts !== undefined;
     const candidates = selectedActiveSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
-        const run = store.getActiveAgentRun(task.id, role.name);
+        const run = store.getActiveTurn(task.id, role.name);
         if (run === null || run.status !== "active")
             return [];
         return [{
@@ -511,23 +457,20 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         eventsByTask.set(taskId, events);
         return events;
     };
-    const cadenceCandidates = candidates.filter(({ task, run }) => isStallCandidate(run, now, windowMs, latestRunEventTime(diagnosticEvents(task.id), RUN_DIAGNOSTIC_FINISHED_EVENT, run.id)));
+    const cadenceCandidates = candidates.filter(({ task, run }) => isStallCandidate(run, now, windowMs, latestTurnEventTime(diagnosticEvents(task.id), TURN_DIAGNOSTIC_FINISHED_EVENT, run.id)));
     const stallCandidates = cadenceCandidates.filter(({ task, role, run }) => {
-        const progressFacts = foldPortPresent
-            ? store.getRunProgressFacts?.(task.id, run.id)
-            : undefined;
-        const progressAt = currentRoleRunProgressAt(store, task.id, role.name, run, foldPortPresent ? undefined : diagnosticEvents(task.id), progressFacts).progressAt;
-        return isStallCandidate(run, now, windowMs, latestRunEventTime(diagnosticEvents(task.id), RUN_DIAGNOSTIC_FINISHED_EVENT, run.id), progressAt);
+        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);
     });
     if (stallCandidates.length === 0)
         return [];
     const diagnosticStartedAt = now.toISOString();
     const finishDiagnostics = (outcome) => {
         for (const { task, role, run } of stallCandidates) {
-            store.recordRoleRunDiagnostic?.({
+            store.recordRoleTurnDiagnostic?.({
                 taskId: task.id,
                 roleName: role.name,
-                runId: run.id,
+                turnId: run.id,
                 startedAt: diagnosticStartedAt,
                 outcome,
                 now
@@ -536,7 +479,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
     };
     const stallCandidateKeys = new Set(stallCandidates.map(({ task, role }) => (`${task.id}\0${role.name}`)));
     const observed = new Map();
-    // Recent active Runs are known healthy enough for Leader classification from
+    // Recent active Turns 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) {
@@ -546,7 +489,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         observed.set(key, {
             candidate,
             live: liveStatuses?.get(key) ?? "present",
-            progressAt: candidate.run.deliveredAt ?? candidate.run.createdAt,
+            progressAt: candidate.run.createdAt,
             idleMs: 0,
             stalled: false,
             resourceActivity: false,
@@ -562,32 +505,30 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             statuses = await delivery.inspectRoles(stallCandidates.map(({ task, role, run, session }) => ({
                 taskId: task.id,
                 roleName: role.name,
-                runId: run.id,
-                progressAt: run.deliveredAt ?? run.createdAt,
+                turnId: run.id,
+                progressAt: run.createdAt,
                 agentId: session?.agentId ?? run.effective.agentId,
                 adapterId: session?.adapterId ?? run.effective.adapterId,
                 ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId })
-            })), stallCandidates.flatMap(({ task, role, run, session }) => (run.deliveredAt === undefined
-                ? []
-                : [{
-                        taskId: task.id,
-                        roleName: role.name,
-                        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?.launchId === undefined ? {} : { launchId: session.launchId }),
-                        ...(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,
+                agentId: session?.agentId ?? run.effective.agentId,
+                adapterId: session?.adapterId ?? run.effective.adapterId,
+                ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(session?.nativeSessionId === undefined
+                    ? {}
+                    : { nativeSessionId: session.nativeSessionId })
+            })));
         }
         catch {
             // Health inspection is advisory. Unknown host state must leave the exact
-            // Run/Session fence untouched. Closing this window schedules the next
+            // Turn/Session fence untouched. Closing this window schedules the next
             // bounded diagnostic thirty minutes later instead of hot-looping.
             finishDiagnostics("observation-error");
             return [];
@@ -634,7 +575,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
                     : byRole.get(key);
         }
         catch {
-            // Without a complete live snapshot, especially for downstream Runs,
+            // Without a complete live snapshot, especially for downstream Turns,
             // Leader classification would be unsafe. Treat the whole advisory pass
             // as unknown instead of escalating a false stall.
             finishDiagnostics("observation-error");
@@ -654,30 +595,16 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             });
             continue;
         }
-        // Fold-backed adapters expose an authoritative per-Run fact, so do not
-        // load the Task history just to satisfy currentRoleRunProgressAt or its
-        // fallback. Legacy ports retain one history read for these projections.
-        const progressFacts = foldPortPresent
-            ? store.getRunProgressFacts?.(candidate.task.id, candidate.run.id)
-            : undefined;
-        const events = foldPortPresent
-            ? undefined
-            : store.listEvents?.(candidate.task.id);
-        // Before exact acceptance there is no execution progress clock. Keep the
-        // delivery watch anchored to the Run creation/transport boundary even if
-        // checkpoints, output, or related WorkItem/Review/Integration records are
-        // newer; those facts are useful evidence but cannot prove provider
-        // acceptance or reset delivery timeout. Once accepted, deliveredAt is the
-        // semantic baseline and the durable fold may advance it.
-        const progress = currentRoleRunProgressAt(store, candidate.task.id, candidate.role.name, candidate.run, events, progressFacts);
+        const progressFacts = store.getTurnProgressFacts(candidate.task.id, candidate.run.id);
+        // The Turn 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 progressAt = progress.progressAt;
-        const evaluation = evaluateRoleRunStall({
+        const evaluation = evaluateRoleTurnStall({
             progressAt,
             now,
             windowMs,
-            lastAttentionProgressAt: foldPortPresent
-                ? progressFacts?.latestStall?.progressAt
-                : latestStallProgressAt(events ?? [], candidate.run.id)
+            lastAttentionProgressAt: progressFacts?.latestStall?.progressAt
         });
         const runAgentId = candidate.run.effective.agentId;
         const runAdapterId = candidate.run.effective.adapterId;
@@ -691,7 +618,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             : {
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                runId: candidate.run.id,
+                turnId: candidate.run.id,
                 agentId: runAgentId,
                 adapterId: runAdapterId,
                 ...(candidate.session.nativeSessionId === undefined
@@ -709,30 +636,23 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             && resourceEvidenceMatchesCurrentRun(resourceSnapshot, expectedResourceIdentity, progressAt)
             && resourceEvidenceIsFresh(resourceSnapshot, now, windowMs, diagnosticAfterMs);
         const resource = resourceIsCurrent ? resourceSnapshot : undefined;
-        const health = projectRoleRunHealth({
+        const health = projectRoleTurnHealth({
             progressAt,
             createdAt: candidate.run.createdAt,
-            ...(candidate.run.deliveredAt === undefined
-                ? {}
-                : { deliveredAt: candidate.run.deliveredAt }),
             now,
             windowMs,
             diagnosticAfterMs,
             hostLiveness: live,
             nativeSession: candidate.session,
-            providerAcceptance: candidate.run.deliveredAt === undefined
-                ? "ambiguous"
-                : "accepted",
+            providerAcceptance: candidate.session === null ? "ambiguous" : "accepted",
             resource,
             roleName: candidate.role.name
         });
-        // Delivery-stalled Runs retain the existing delivery clock and immediate
-        // provider-uncertainty path. Accepted execution Runs use the shared
+        // Delivery-stalled Turns retain the existing delivery clock and immediate
+        // Provider-uncertainty path. Accepted execution Turns use the shared
         // projection. Exact Session/host resource evidence remains diagnostic.
         const resourceActivity = health.resourceActivity;
-        const stalled = candidate.run.deliveredAt === undefined
-            ? evaluation.stalled && live === "present"
-            : health.stalled && sessionMatchesRun && sessionUsable;
+        const stalled = health.stalled && sessionMatchesRun && sessionUsable;
         observed.set(key, {
             candidate,
             live,
@@ -753,24 +673,22 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         if (current.live !== "present" || !current.stalled || !current.stallCandidate)
             continue;
         const { candidate, progressAt } = current;
-        const previous = foldPortPresent
-            ? store.getRunProgressFacts?.(candidate.task.id, candidate.run.id)?.latestStall
-            : latestStallEvidenceKey(store.listEvents?.(candidate.task.id) ?? [], candidate.run.id);
+        const previous = store.getTurnProgressFacts(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 Run+progressAt episode below.
-            store.recordRoleRunProgress?.({
+            // pass records the next Turn+progressAt episode below.
+            store.recordRoleTurnProgress?.({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                runId: candidate.run.id,
+                turnId: candidate.run.id,
                 progressAt,
                 ...(current.evidence === undefined ? {} : { evidence: current.evidence }),
                 now
             });
         }
-        const kind = candidate.run.deliveredAt === undefined
+        const kind = candidate.session === null
             ? "delivery-stalled"
             : "workflow-not-progressing";
         const classification = candidate.role.name === "leader"
@@ -789,15 +707,15 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
                 : []),
             ...(current.evidence === undefined ? [] : [current.evidence])
         ].join(":");
-        // The final contract is one episode per Run + semantic progress point.
+        // The final contract is one episode per Turn + 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.recordRoleRunStall({
+        const persisted = store.recordRoleTurnStall({
             taskId: candidate.task.id,
             roleName: candidate.role.name,
-            runId: candidate.run.id,
+            turnId: candidate.run.id,
             agentId: candidate.run.effective.agentId,
             adapterId: candidate.run.effective.adapterId,
             session: candidate.session,
@@ -812,7 +730,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             raised.push({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                runId: candidate.run.id,
+                turnId: candidate.run.id,
                 status: persisted,
                 kind,
                 classification,
@@ -821,21 +739,19 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         }
     }
     // A related WorkItem/Review/Integration fold may advance progress without
-    // carrying the Run id. Materialize it once so context/web can clear the
+    // carrying the Turn 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 = foldPortPresent
-            ? store.getRunProgressFacts?.(candidate.task.id, candidate.run.id)?.latestStall
-            : latestStallEvidenceKey(store.listEvents?.(candidate.task.id) ?? [], candidate.run.id);
+        const previous = store.getTurnProgressFacts(candidate.task.id, candidate.run.id)?.latestStall;
         if (previous !== undefined
             && Date.parse(progressAt) > Date.parse(previous.progressAt)) {
-            store.recordRoleRunProgress?.({
+            store.recordRoleTurnProgress?.({
                 taskId: candidate.task.id,
                 roleName: candidate.role.name,
-                runId: candidate.run.id,
+                turnId: candidate.run.id,
                 progressAt,
                 ...(current.evidence === undefined ? {} : { evidence: current.evidence }),
                 now
@@ -846,8 +762,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
     return raised;
 }
 function isStallCandidate(run, now, windowMs, lastDiagnosticFinishedAt, latestProgressAt) {
-    const startAt = run.deliveredAt ?? run.createdAt;
-    const baseline = [startAt, lastDiagnosticFinishedAt, latestProgressAt]
+    const baseline = [run.createdAt, lastDiagnosticFinishedAt, latestProgressAt]
         .filter((value) => (value !== undefined && Number.isFinite(Date.parse(value))))
         .reduce((latest, value) => (Date.parse(value) > Date.parse(latest) ? value : latest));
     const ageMs = now.getTime() - Date.parse(baseline);
@@ -859,7 +774,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 Run keeps recovery Leader-owned. If that Run is
+    // A present downstream Turn keeps recovery Leader-owned. If that Turn 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.
@@ -868,13 +783,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 === "run"
+    const processingCurrent = processing?.executionRef?.type === "turn"
         && processing.executionRef.taskId === taskId
         && leader !== undefined
         && processing.executionRef.id === leader.candidate.run.id;
-    const currentRunId = leader?.candidate.run.id;
-    if (processingCurrent && currentRunId !== undefined && processing !== null) {
-        const actionProgressAt = latestLeaderActionProgressAt(store, taskId, currentRunId, processing.startedAt, processing.batch, now);
+    const currentTurnId = leader?.candidate.run.id;
+    if (processingCurrent && currentTurnId !== undefined && processing !== null) {
+        const actionProgressAt = latestLeaderActionProgressAt(store, taskId, currentTurnId, processing.startedAt, processing.batch, now);
         const actionProgressMs = Date.parse(actionProgressAt);
         const actionStalled = Number.isFinite(actionProgressMs)
             && now.getTime() - actionProgressMs >= windowMs;
@@ -893,7 +808,7 @@ function classifyLeaderStall(store, taskId, observed, now, windowMs) {
     return "truly-stalled";
 }
 const LEADER_ACTION_PROGRESS_TYPES = new Set([
-    RUN_PROGRESS_EVENT,
+    TURN_PROGRESS_EVENT,
     "input.answered",
     "input.auto-answered",
     "input.cancelled",
@@ -909,7 +824,7 @@ const LEADER_ACTION_PROGRESS_TYPES = new Set([
     "decision.superseded",
     "milestone.added"
 ]);
-function latestLeaderActionProgressAt(store, taskId, runId, startedAt, batch, now) {
+function latestLeaderActionProgressAt(store, taskId, turnId, startedAt, batch, now) {
     const startedMs = Date.parse(startedAt);
     if (!Number.isFinite(startedMs))
         return "";
@@ -920,14 +835,14 @@ function latestLeaderActionProgressAt(store, taskId, runId, startedAt, batch, no
             continue;
         if (event.payload.taskId !== undefined && event.payload.taskId !== taskId)
             continue;
-        if (!leaderActionEventMatches(event, taskId, runId, batch))
+        if (!leaderActionEventMatches(event, taskId, turnId, batch))
             continue;
         const createdMs = Date.parse(event.createdAt);
         if (!Number.isFinite(createdMs)
             || createdMs < startedMs
             || createdMs > now.getTime())
             continue;
-        const value = event.type === RUN_PROGRESS_EVENT
+        const value = event.type === TURN_PROGRESS_EVENT
             && typeof event.payload.progressAt === "string"
             && Number.isFinite(Date.parse(event.payload.progressAt))
             ? event.payload.progressAt
@@ -943,12 +858,12 @@ function latestLeaderActionProgressAt(store, taskId, runId, startedAt, batch, no
     }
     return latest;
 }
-function leaderActionEventMatches(event, taskId, runId, batch) {
+function leaderActionEventMatches(event, taskId, turnId, batch) {
     if (event.taskId !== taskId)
         return false;
-    if (event.payload.leaderRunId === runId)
+    if (event.payload.leaderTurnId === turnId)
         return true;
-    if (event.payload.runId === runId)
+    if (event.payload.turnId === turnId)
         return true;
     const refs = batch.refs ?? [];
     const refMatches = (type, payloadKey) => {
@@ -957,7 +872,7 @@ function leaderActionEventMatches(event, taskId, runId, batch) {
             && ref.id === id
             && (ref.taskId === undefined || ref.taskId === taskId)));
     };
-    if (refMatches("run", "runId"))
+    if (refMatches("turn", "turnId"))
         return true;
     if (refMatches("work-item", "workItemId"))
         return true;
@@ -983,7 +898,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 === "run"
+    const processingCurrent = processing?.executionRef?.type === "turn"
         && processing.executionRef.taskId === taskId
         && leader !== undefined
         && processing.executionRef.id === leader.candidate.run.id;
@@ -1014,10 +929,10 @@ function exactLiveStatuses(statuses, candidates) {
         throw new Error("Tmux Role stall snapshot is incomplete.");
     return result;
 }
-function resourceForRun(snapshot, taskId, roleName, runId) {
+function resourceForRun(snapshot, taskId, roleName, turnId) {
     if (snapshot === undefined)
         return undefined;
-    return snapshot.get(`${taskId}\0${roleName}\0${runId}`);
+    return snapshot.get(`${taskId}\0${roleName}\0${turnId}`);
 }
 function resourceEvidenceMatchesCurrentRun(resource, expected, progressAt) {
     if (resource === undefined || expected === undefined)
@@ -1027,7 +942,7 @@ function resourceEvidenceMatchesCurrentRun(resource, expected, progressAt) {
         || resource.progressAt !== progressAt
         || identity.taskId !== expected.taskId
         || identity.roleName !== expected.roleName
-        || identity.runId !== expected.runId
+        || identity.turnId !== expected.turnId
         || identity.agentId !== expected.agentId
         || identity.adapterId !== expected.adapterId
         || identity.nativeSessionId !== expected.nativeSessionId