@zq-silk/yui 0.13.9 → 0.14.0

package/dist/commands/taskOverviewCommand.js

@@ -1,10 +1,11 @@
 import { usageError } from "../errors/cliError.js";
-import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
+import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { pendingWakeupProjection } from "../storage/taskStore.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { projectTaskExecutionFromFacts } from "../scheduler/taskExecutionProjection.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
+import { projectNextAction } from "../task/nextAction.js";
 export function parseTaskListOptions(args) {
     const allowed = new Set(["--all", "--verbose"]);
     if (args.some((argument) => !allowed.has(argument))
@@ -61,7 +62,7 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
     const workItems = store.listWorkItems(task.id);
     const inputRequests = store.listInputRequests(task.id);
     const openInputRequests = inputRequests.filter((request) => request.status === "open");
-    const agentRuns = store.listAgentRuns(task.id);
+    const turns = store.listTurns(task.id);
     const events = store.listEvents(task.id);
     const leaderFailure = store.getLeaderFailure(task.id);
     const leaderMailbox = store.getWorkMailbox({ kind: "role", taskId: task.id, roleName: "leader" });
@@ -73,14 +74,13 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         const session = store.getRoleSession(task.id, role.name);
         return session === null ? [] : [{ roleName: role.name, ...session }];
     });
-    const attention = collectAttention(task, agentRuns, events, leaderFailure);
+    const attention = collectAttention(task, turns, events, leaderFailure);
     const blockers = collectBlockers(workItems, openInputRequests, attention);
-    const legacyNext = deriveNextAction(task, brief, workItems, openInputRequests, blockers, pendingWakeup);
     const leader = {
         role: "leader",
         roleStatus: leaderRole === null
             ? "missing"
-            : agentRuns.some((run) => run.roleName === "leader" && run.status === "active")
+            : turns.some((run) => run.roleName === "leader" && run.status === "active")
                 ? "running"
                 : roleSessions.find((session) => session.roleName === "leader")?.status ?? "idle",
         summary: brief?.leaderSummary ?? null,
@@ -90,28 +90,29 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         summaryStatus: brief === null ? "missing" : "available"
     };
     const counts = countWorkItems(workItems);
-    const runtimeRuns = agentRuns
+    const runtimeTurns = turns
         .filter((run) => run.status === "active")
         .map((run) => ({
         id: run.id,
         roleName: run.roleName,
         status: run.status,
-        delivery: run.deliveredAt === undefined ? "pending" : "delivered",
-        deliveredAt: run.deliveredAt ?? null,
+        runtime: roleSessions.some((session) => (session.roleName === run.roleName
+            && session.agentId === run.effective.agentId
+            && session.status !== "ended")) ? "session-active" : "starting",
         createdAt: run.createdAt,
         updatedAt: run.updatedAt
     }));
     const runtime = {
-        activeRuns: runtimeRuns,
-        activeRunCount: runtimeRuns.length,
-        pendingDeliveryCount: runtimeRuns.filter((run) => run.delivery === "pending").length
+        activeTurns: runtimeTurns,
+        activeTurnCount: runtimeTurns.length,
+        pendingDeliveryCount: runtimeTurns.filter((run) => run.runtime === "starting").length
     };
     // Fold the execution projection from the facts already read above instead of
     // reading the store a second time for the same unchanged revision.
     const execution = projectTaskExecutionFromFacts({
         task,
         roles,
-        runs: agentRuns,
+        turns,
         workItems,
         inputRequests,
         reviewRounds,
@@ -127,21 +128,15 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         now,
         runtimeHealthPolicy
     });
-    const next = execution.status === "stopped"
-        ? {
-            action: execution.action,
-            owner: execution.owner,
-            kind: "execution",
-            summary: execution.summary
-        }
-        : execution.action === "recover-execution"
-            ? {
-                action: execution.action,
-                owner: execution.owner,
-                kind: "execution",
-                summary: execution.summary
-            }
-            : legacyNext;
+    const nextActionFacts = store.readNextActionFacts(task.id);
+    if (nextActionFacts === null) {
+        throw new Error(`Task disappeared while building its overview: ${task.id}.`);
+    }
+    const next = overviewNextAction(task, workItems, execution, projectNextAction({
+        ...nextActionFacts,
+        currentTaskReviewCandidate: null,
+        executionGroups: execution.executionGroups
+    }));
     return {
         ...task,
         brief,
@@ -163,7 +158,7 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         execution
     };
 }
-function collectAttention(task, runs, events, failure) {
+function collectAttention(task, turns, events, failure) {
     const items = [];
     if (failure !== null) {
         items.push({
@@ -175,21 +170,21 @@ function collectAttention(task, runs, events, failure) {
             updatedAt: failure.lastFailedAt
         });
     }
-    for (const run of runs) {
-        if (run.roleName !== "leader"
-            || run.status !== "active"
-            || !isRoleRunStalled(events, run.id))
+    for (const turn of turns) {
+        if (turn.roleName !== "leader"
+            || turn.status !== "active"
+            || !isRoleTurnStalled(events, turn.id))
             continue;
-        const progressAt = latestStallProgressAt(events, run.id) ?? run.updatedAt;
+        const progressAt = latestStallProgressAt(events, turn.id) ?? turn.updatedAt;
         items.push({
             kind: "leader-stalled",
-            id: `leader-stall:${run.id}:${progressAt}`,
+            id: `leader-stall:${turn.id}:${progressAt}`,
             status: "needs-attention",
             owner: "operator",
-            summary: `Run ${run.id} for ${run.roleName} has no durable progress after ${progressAt}.`,
+            summary: `Turn ${turn.id} for ${turn.roleName} has no durable progress after ${progressAt}.`,
             updatedAt: progressAt,
-            runId: run.id,
-            roleName: run.roleName
+            turnId: turn.id,
+            roleName: turn.roleName
         });
     }
     return items.sort((left, right) => (Date.parse(left.updatedAt) - Date.parse(right.updatedAt)
@@ -266,64 +261,30 @@ function collectBlockers(workItems, openInputRequests, attention) {
     }
     return blockers;
 }
-function deriveNextAction(task, brief, workItems, openInputRequests, blockers, pendingWakeup) {
-    const input = openInputRequests[0];
-    if (input !== undefined) {
-        return {
-            action: "answer-input",
-            owner: "user",
-            kind: "input",
-            id: input.id,
-            summary: input.question
-        };
-    }
-    const attention = blockers.find((blocker) => blocker.kind === "attention");
-    if (attention !== undefined) {
-        return {
-            action: attention.action,
-            owner: attention.owner,
-            kind: "attention",
-            id: attention.id,
-            summary: attention.summary
-        };
-    }
-    const workBlocker = blockers.find((blocker) => blocker.kind === "work");
-    if (workBlocker !== undefined) {
-        return {
-            action: workBlocker.action,
-            owner: workBlocker.owner,
-            kind: "work",
-            id: workBlocker.id,
-            summary: workBlocker.summary
-        };
-    }
-    if (pendingWakeup !== null) {
-        return {
-            action: "process-leader-wakeup",
-            owner: "leader",
-            kind: "wakeup",
-            summary: pendingWakeup.reasons.join(", ")
-        };
-    }
-    const pending = workItems.find((item) => item.status === "pending");
-    if (pending !== undefined) {
-        return {
-            action: "start-work-item",
-            owner: pending.assignee ?? "leader",
-            kind: "work",
-            id: pending.id,
-            summary: pending.title
-        };
-    }
-    if (task.status === "active" && brief === null) {
-        return {
-            action: "update-leader-summary",
-            owner: "leader",
-            kind: "summary",
-            summary: "No persisted Task Brief is available."
-        };
-    }
-    return null;
+function overviewNextAction(task, workItems, execution, action) {
+    if (task.status !== "active" && task.status !== "draft")
+        return null;
+    const primary = action.refs[0];
+    const workItem = action.refs
+        .filter(({ kind }) => kind === "work-item")
+        .map(({ id }) => workItems.find((item) => item.id === id))
+        .find((item) => item !== undefined);
+    const kind = primary?.kind === "input-request"
+        ? "input"
+        : primary?.kind === "work-item"
+            ? "work"
+            : action.kind.includes("attention") || action.kind.includes("inconsistency")
+                ? "attention"
+                : "execution";
+    return {
+        action: action.kind,
+        owner: action.kind === "resolve-input"
+            ? "user"
+            : workItem?.assignee ?? execution.owner,
+        kind,
+        ...(primary === undefined ? {} : { id: primary.id }),
+        summary: action.reason
+    };
 }
 function countWorkItems(items) {
     const counts = {

package/dist/commands/taskRoleRuntimeStatus.js

@@ -1,12 +1,12 @@
 import { isDeepStrictEqual } from "node:util";
-import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
+import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { classifyRuntimeHealth, projectRuntimeMailbox, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
-import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
+import { classifyRuntimeHealth, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
+import { latestTurnDurableProgressAt } from "../scheduler/roleTurnStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
+import { formatTurnReceiptId } from "../task/taskRecordReference.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
@@ -21,12 +21,12 @@ export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now
     return roles.map((role) => inspectTaskRoleRuntimeStatus(taskId, role, store, panesByRole.get(role.name), role.name === "leader" ? taskOpenInputRequestCount : 0, now));
 }
 export function renderTaskRoleRuntimeStatus(status) {
-    const activeRun = status.activeRun === null
+    const activeTurn = status.activeTurn === null
         ? "-"
-        : `${status.activeRun.id} (${activeRunDeliveryLabel(status.activeRun)})`;
-    const lastRun = status.activeRun !== null || status.lastRun === null
+        : `${status.activeTurn.id} (${activeTurnDeliveryLabel(status.activeTurn)})`;
+    const lastTurn = status.activeTurn !== null || status.lastTurn === null
         ? undefined
-        : `${status.lastRun.id} (${status.lastRun.status}${status.lastRun.endedAt === undefined ? "" : ` at ${status.lastRun.endedAt}`})`;
+        : `${status.lastTurn.id} (${status.lastTurn.status}${status.lastTurn.result === undefined ? "" : ` at ${status.lastTurn.result.completedAt}`})`;
     const activeWork = status.activeWork === null
         ? "-"
         : `${status.activeWork.id} (${status.activeWork.status}) ${status.activeWork.title}`;
@@ -84,15 +84,15 @@ export function renderTaskRoleRuntimeStatus(status) {
         `  Desired drift    ${status.effectiveLaunch === null
             ? "-"
             : status.launchDrift ? "pending next launch" : "none"}`,
-        `  Run/session      ${status.runSessionDrift ? "snapshot mismatch" : "snapshot consistent"}`,
+        `  Turn/session     ${status.turnSessionDrift ? "snapshot mismatch" : "snapshot consistent"}`,
         `  Active work      ${activeWork}`,
-        `  Active run       ${activeRun}`,
-        ...(lastRun === undefined ? [] : [`  Last run         ${lastRun}`]),
-        `  Run attention    ${status.stall.active
+        `  Active run       ${activeTurn}`,
+        ...(lastTurn === undefined ? [] : [`  Last turn        ${lastTurn}`]),
+        `  Turn attention   ${status.stall.active
             ? `needs-attention (${status.stall.kind ?? "workflow-not-progressing"}; no workflow progress since ${status.stall.progressAt ?? "unknown"})`
             : "none"}`,
         `  Native session   ${nativeSession}`,
-        `  Agent runtime    ${runtime}`,
+        `  AgentRuntime    ${runtime}`,
         `  Session tokens   ${sessionTokens}`,
         `  Runtime cleanup  ${status.runtimeCleanupPending ? "pending" : "none"}`,
         `  tmux pane        ${tmux}`,
@@ -103,15 +103,15 @@ export function renderTaskRoleRuntimeStatus(status) {
 export function taskRoleActiveWorkLabel(status) {
     if (status.activeWork !== null)
         return `${status.activeWork.id}: ${status.activeWork.title}`;
-    return status.activeRun === null ? "-" : status.activeRun.id;
+    return status.activeTurn === null ? "-" : status.activeTurn.id;
 }
-/** Issue 09: compact last-Run outcome label for the Role list table. */
-export function taskRoleLastRunLabel(status) {
-    if (status.activeRun !== null)
-        return `${status.activeRun.id} ${status.activeRun.status}`;
-    if (status.lastRun === null)
+/** Issue 09: compact last-Turn outcome label for the Role list table. */
+export function taskRoleLastTurnLabel(status) {
+    if (status.activeTurn !== null)
+        return `${status.activeTurn.id} ${status.activeTurn.status}`;
+    if (status.lastTurn === null)
         return "-";
-    return `${status.lastRun.id} ${status.lastRun.status}`;
+    return `${status.lastTurn.id} ${status.lastTurn.status}`;
 }
 export function taskRoleNativeSessionLabel(status) {
     if (status.runtimeCleanupPending && status.nativeSession === null)
@@ -140,26 +140,26 @@ export function taskRoleTmuxLabel(status) {
         : `running (${status.tmux.currentCommand})`;
 }
 function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now) {
-    const activeRun = store.getActiveAgentRun(taskId, role.name);
-    // Issue 09: the last Run outcome is a separate axis from the Session
-    // lifecycle. A Session that stops after its Run yielded must not retroactively
-    // turn that Run into a failure; the status display keeps both visible.
-    const lastRun = operationalTaskRecords(store.listAgentRuns(taskId), store.listEvents(taskId), "agent-run")
+    const activeTurn = store.getActiveTurn(taskId, role.name);
+    // The last Turn outcome is a separate axis from the Session lifecycle. A
+    // Session that stops after its Turn completed must not retroactively turn
+    // that Turn into a failure; the status display keeps both visible.
+    const lastTurn = operationalTaskRecords(store.listTurns(taskId), store.listEvents(taskId), "turn")
         .filter((candidate) => candidate.roleName === role.name)
         .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))[0]
         ?? null;
-    const activeWork = activeRun?.workItemId === undefined
+    const activeWork = activeTurn?.workItemId === undefined
         ? null
-        : store.getWorkItem(taskId, activeRun.workItemId);
+        : store.getWorkItem(taskId, activeTurn.workItemId);
     const sessions = store.getTaskRoleSessionSet(taskId, role.name);
-    const effectiveAgentId = activeRun?.effective.agentId ?? sessions?.activeAgentId;
+    const effectiveAgentId = activeTurn?.effective.agentId ?? sessions?.activeAgentId;
     const nativeSession = effectiveAgentId === undefined
         ? null
         : sessions?.sessions[effectiveAgentId] ?? null;
-    const effectiveLaunch = activeRun?.effective ?? nativeSession?.effective ?? null;
-    const runSessionDrift = activeRun !== null
+    const effectiveLaunch = activeTurn?.effective ?? nativeSession?.effective ?? null;
+    const turnSessionDrift = activeTurn !== null
         && nativeSession !== null
-        && !isDeepStrictEqual(activeRun.effective, nativeSession.effective);
+        && !isDeepStrictEqual(activeTurn.effective, nativeSession.effective);
     const recovery = inspectTaskRoleSessionRecovery(taskId, role.name, store);
     const tmux = pane === undefined
         ? { state: "missing" }
@@ -170,13 +170,13 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
             ...(pane.pid === undefined ? {} : { pid: pane.pid }),
             currentCommand: pane.currentCommand
         };
-    // The active Run snapshot is authoritative for the live Role session.  It
+    // The active Turn snapshot is authoritative for the live Role session. It
     // may point at a ReviewRound-owned workspace, which is intentionally
     // distinct from the WorkItem Develop workspace.
-    const managedWorkspace = activeRun?.workspace
-        ?? (activeRun?.workItemId === undefined
+    const managedWorkspace = activeTurn?.workspace
+        ?? (activeTurn?.workItemId === undefined
             ? store.getTaskWorkspace(taskId)
-            : store.getWorkItemWorkspace(taskId, activeRun.workItemId));
+            : store.getWorkItemWorkspace(taskId, activeTurn.workItemId));
     const workspace = managedWorkspace === null
         ? { managed: false, path: role.workspace }
         : { ...managedWorkspace, managed: true };
@@ -184,16 +184,16 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
     const sessionTokens = projectSessionTokenMetrics(events, resolveSessionTokenIdentity(nativeSession === null
         ? null
         : { taskId, roleName: role.name, ...nativeSession }));
-    const runtime = projectTaskRoleRuntime(activeRun, nativeSession, tmux, events, store.getWorkMailbox({ kind: "role", taskId, roleName: role.name }), store, taskId, role.name, now);
-    const stalled = activeRun !== null && isRoleRunStalled(events, activeRun.id);
-    const stallProgressAt = activeRun === null
+    const runtime = projectTaskRoleRuntime(activeTurn, nativeSession, tmux, events, store.getWorkMailbox({ kind: "role", taskId, roleName: role.name }), store, taskId, role.name, now);
+    const stalled = activeTurn !== null && isRoleTurnStalled(events, activeTurn.id);
+    const stallProgressAt = activeTurn === null
         ? undefined
-        : latestStallProgressAt(events, activeRun.id);
-    const stallKind = activeRun === null
+        : latestStallProgressAt(events, activeTurn.id);
+    const stallKind = activeTurn === null
         ? undefined
-        : latestStallKind(events, activeRun.id);
-    const health = calculateHealth(role, activeRun, lastRun, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime);
-    const stall = activeRun === null
+        : latestStallKind(events, activeTurn.id);
+    const health = calculateHealth(role, activeTurn, lastTurn, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime);
+    const stall = activeTurn === null
         ? { active: false }
         : {
             active: stalled,
@@ -209,12 +209,12 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         effectiveLaunch,
         launchDrift: effectiveLaunch !== null
             && effectiveLaunch.sourceDesiredRevision !== role.launchRevision,
-        runSessionDrift,
+        turnSessionDrift,
         ...health,
         openInputRequestCount,
         role,
-        activeRun,
-        lastRun,
+        activeTurn,
+        lastTurn,
         activeWork,
         nativeSession,
         tmux,
@@ -236,17 +236,17 @@ function sessionCumulativeTokenLabel(metrics) {
     ];
     return `${total.totalTokens} (${breakdown.join(", ")})`;
 }
-function latestStallKind(events, runId) {
+function latestStallKind(events, turnId) {
     const event = [...events]
-        .filter((candidate) => candidate.type === "run.stalled"
-        && candidate.payload.runId === runId
+        .filter((candidate) => candidate.type === "turn.stalled"
+        && candidate.payload.turnId === turnId
         && candidate.payload.status !== "diagnostic-only")
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return event?.payload.kind === "delivery-stalled" || event?.payload.kind === "workflow-not-progressing"
         ? event.payload.kind
         : undefined;
 }
-function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime) {
+function calculateHealth(role, activeTurn, lastTurn, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime) {
     if (runtimeCleanupPending && nativeSession === null) {
         return {
             health: "needs-attention",
@@ -254,26 +254,17 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
         };
     }
     if (nativeSession?.status === "ended" && nativeSession.endReason === "failed") {
-        // Issue 09: a broken Session only fails a live Run. When the last Run
-        // already yielded, the Session death is a lifecycle event, not a Run
-        // failure — surface it as attention with the persisted Run outcome.
-        if (activeRun !== null) {
+        // A broken Session only fails a live Turn. When the last Turn already
+        // completed, the Session death is a lifecycle event, not a Turn failure —
+        // surface it as attention with the persisted Turn outcome.
+        if (activeTurn !== null) {
             return { health: "failed", healthReason: "the active native session is broken" };
         }
         return {
             health: "needs-attention",
-            healthReason: lastRun === null
+            healthReason: lastTurn === null
                 ? "the native session is broken"
-                : `the native session is broken; last run ${lastRun.id} ${lastRun.status}`
-        };
-    }
-    const awaitingProviderAcceptance = activeRun?.pushedAt !== undefined
-        && activeRun.deliveredAt === undefined;
-    if (awaitingProviderAcceptance
-        && tmux.state !== "running") {
-        return {
-            health: "needs-attention",
-            healthReason: "the pushed active Run is awaiting provider acceptance and has no live tmux pane"
+                : `the native session is broken; last Turn ${lastTurn.id} ${lastTurn.status}`
         };
     }
     if (tmux.state === "exited") {
@@ -282,23 +273,17 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
             healthReason: "the tmux pane exited; Provider Conversation/continuation state is unobservable"
         };
     }
-    if (activeRun !== null) {
-        if (activeRun.deliveredAt !== undefined && tmux.state !== "running") {
-            return { health: "needs-attention", healthReason: "the delivered active Run has no live tmux pane" };
+    if (activeTurn !== null) {
+        if (tmux.state !== "running") {
+            return { health: "needs-attention", healthReason: "the active Turn has no live tmux pane" };
         }
         if (stalled) {
             return {
                 health: "needs-attention",
-                healthReason: "the live active Run has no durable progress in the configured stall window"
+                healthReason: "the live active Turn has no durable progress in the configured stall window"
             };
         }
-        if (activeRun.deliveredAt !== undefined) {
-            if (runtime === null) {
-                return {
-                    health: "needs-attention",
-                    healthReason: "the delivered Run has no authoritative Agent Driver state"
-                };
-            }
+        if (runtime !== null) {
             switch (runtime.healthLayer) {
                 case "broken":
                     return { health: "failed", healthReason: runtime.healthReason };
@@ -328,6 +313,10 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
                     return { health: "running", healthReason: runtime.healthReason };
             }
         }
+        return {
+            health: "starting",
+            healthReason: "the active Turn is awaiting Provider runtime observations"
+        };
     }
     if (nativeSession?.status === "active" && tmux.state !== "running") {
         return { health: "needs-attention", healthReason: "the native session is running without a live tmux pane" };
@@ -341,25 +330,11 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
             healthReason: `${openInputRequestCount} open InputRequest${openInputRequestCount === 1 ? "" : "s"} require user input`
         };
     }
-    if (activeRun !== null) {
-        if (activeRun.deliveredAt !== undefined)
-            return {
-                health: "needs-attention",
-                healthReason: "the delivered Run has no authoritative Agent Driver state"
-            };
-        if (activeRun.pushedAt !== undefined) {
-            return {
-                health: "awaiting-provider-acceptance",
-                healthReason: "the pushed active Run is awaiting provider acceptance"
-            };
-        }
-        return { health: "starting", healthReason: "the active Run is awaiting tmux delivery" };
-    }
     return tmux.state === "running"
         ? { health: "ready", healthReason: "the native Agent pane is ready without active work" }
         : { health: "idle", healthReason: "there is no active work or live tmux pane" };
 }
-function projectTaskRoleRuntime(run, session, tmux, events, mailbox, store, taskId, roleName, now) {
+function projectTaskRoleRuntime(run, session, tmux, events, _mailbox, store, taskId, roleName, now) {
     if (run === null || session?.launchId === undefined)
         return null;
     let driverId;
@@ -372,7 +347,7 @@ function projectTaskRoleRuntime(run, session, tmux, events, mailbox, store, task
     const fence = {
         taskId: run.taskId,
         roleName: run.roleName,
-        runId: run.id,
+        turnId: run.id,
         agentId: run.effective.agentId,
         driverId,
         launchId: session.launchId,
@@ -381,17 +356,18 @@ function projectTaskRoleRuntime(run, session, tmux, events, mailbox, store, task
         nativeTurnId: runtimeNativeTurnId(events, {
             taskId: run.taskId,
             roleName: run.roleName,
-            runId: run.id,
+            turnId: run.id,
             agentId: run.effective.agentId,
             driverId,
             launchId: session.launchId,
             nativeSessionId: session.nativeSessionId,
-            receiptId: agentRunDeliveryReceiptId(run)
+            receiptId: store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding?.turn?.attemptId
+                ?? formatTurnReceiptId(run.taskId, run.id)
         }) ?? run.id,
-        receiptId: agentRunDeliveryReceiptId(run)
+        receiptId: store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding?.turn?.attemptId
+            ?? formatTurnReceiptId(run.taskId, run.id)
     };
     let projection = projectRuntimeTaskEvents(fence, run.createdAt, events);
-    projection = projectRuntimeMailbox(projection, mailbox);
     projection = projectRuntimeObservation(projection, createRuntimeObservation({
         schemaVersion: 2,
         eventId: `runtime-host-${run.id}`,
@@ -404,10 +380,8 @@ function projectTaskRoleRuntime(run, session, tmux, events, mailbox, store, task
     }));
     // The semantic progress fence is the same durable fold the scheduler stall
     // pass consumes, so CLI/Web/scheduler share one progress clock.
-    const semanticProgress = run.deliveredAt === undefined
-        ? { progressAt: run.createdAt }
-        : latestRunDurableProgressAt(store, taskId, roleName, run.id)
-            ?? { progressAt: run.deliveredAt };
+    const semanticProgress = latestTurnDurableProgressAt(store, taskId, roleName, run.id)
+        ?? { progressAt: run.createdAt };
     const classification = classifyRuntimeHealth({
         projection,
         semanticProgressAt: semanticProgress.progressAt,
@@ -444,7 +418,7 @@ function runtimeNativeTurnId(events, expected) {
         .filter((observation) => observation !== null
         && observation.fence.taskId === expected.taskId
         && observation.fence.roleName === expected.roleName
-        && observation.fence.runId === expected.runId
+        && observation.fence.turnId === expected.turnId
         && observation.fence.agentId === expected.agentId
         && observation.fence.driverId === expected.driverId
         && observation.fence.launchId === expected.launchId
@@ -459,10 +433,6 @@ function runtimeNativeTurnId(events, expected) {
         ?.fence.nativeTurnId
         ?? observations.at(-1)?.fence.nativeTurnId;
 }
-function activeRunDeliveryLabel(run) {
-    if (run.deliveredAt !== undefined)
-        return "delivered";
-    if (run.pushedAt !== undefined)
-        return "pushed (awaiting provider acceptance)";
-    return "queued";
+function activeTurnDeliveryLabel(run) {
+    return run.status === "active" ? "active" : run.status;
 }

package/dist/commands/taskUpstreamCommands.js

@@ -42,11 +42,11 @@ async function integrateUpstream(args, store, options) {
         throw usageError(`Task must be active to integrate upstream: ${taskId}/${task.status}.`);
     }
     // RFC Phase 4: integrating upstream rewrites the Task worktree HEAD. Refuse
-    // while the Leader has an active Run so the merge never lands under a
+    // while the Leader has an active Turn so the merge never lands under a
     // running Session.
-    const activeLeaderRun = store.getActiveAgentRun(taskId, "leader");
+    const activeLeaderRun = store.getActiveTurn(taskId, "leader");
     if (activeLeaderRun !== null) {
-        throw usageError(`Task has an active Leader Run (${activeLeaderRun.id}); stop it before integrating upstream: ${taskId}.`);
+        throw usageError(`Task has an active Leader Turn (${activeLeaderRun.id}); stop it before integrating upstream: ${taskId}.`);
     }
     const workspace = store.getTaskWorkspace(taskId);
     if (workspace === null) {