@zq-silk/yui 0.15.7 → 0.15.8

package/dist/commands/taskOverviewCommand.js

@@ -1,5 +1,5 @@
 import { usageError } from "../errors/cliError.js";
-import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
+import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { pendingWakeupProjection } from "../storage/taskStore.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
@@ -65,7 +65,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 turns = store.listTurns(task.id);
+    const runs = store.listRuns(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" });
@@ -77,15 +77,19 @@ 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, turns, events, leaderFailure);
+    const providerRuns = new Map(roles.map((role) => [role.name, store.getTaskRoleSessionSet(task.id, role.name)?.providerBinding?.run]));
+    const runDelivery = Object.fromEntries(runs.map((run) => {
+        const native = providerRuns.get(run.roleName);
+        return [run.id, native?.runId === run.id ? native.status : "unobserved"];
+    }));
+    const attention = collectAttention(task, runs, events, leaderFailure);
     const blockers = collectBlockers(workItems, openInputRequests, attention);
     const leader = {
         role: "leader",
         roleStatus: leaderRole === null
             ? "missing"
-            : turns.some((run) => run.roleName === "leader" && run.status === "active")
-                ? "running"
-                : roleSessions.find((session) => session.roleName === "leader")?.status ?? "idle",
+            : providerRuns.get("leader")?.status === "accepted" ? "running"
+                : roleSessions.some((session) => session.roleName === "leader") ? "unknown" : "idle",
         summary: brief?.leaderSummary ?? null,
         currentFocus: brief?.currentFocus ?? null,
         updatedAt: brief?.updatedAt ?? null,
@@ -93,29 +97,28 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         summaryStatus: brief === null ? "missing" : "available"
     };
     const counts = countWorkItems(workItems);
-    const runtimeTurns = turns
+    const runtimeRuns = runs
         .filter((run) => run.status === "active")
         .map((run) => ({
         id: run.id,
         roleName: run.roleName,
         status: run.status,
-        runtime: roleSessions.some((session) => (session.roleName === run.roleName
-            && session.agentId === run.effective.agentId
-            && session.status !== "ended")) ? "session-active" : "starting",
+        runtime: runDelivery[run.id],
         createdAt: run.createdAt,
         updatedAt: run.updatedAt
     }));
     const runtime = {
-        activeTurns: runtimeTurns,
-        activeTurnCount: runtimeTurns.length,
-        pendingDeliveryCount: runtimeTurns.filter((run) => run.runtime === "starting").length
+        activeRuns: runtimeRuns,
+        activeRunCount: runtimeRuns.length,
+        pendingDeliveryCount: runtimeRuns.filter((run) => run.runtime !== "accepted").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,
-        turns,
+        runs,
+        runDelivery,
         workItems,
         inputRequests,
         reviewRounds,
@@ -140,7 +143,7 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         currentTaskReviewCandidate: null,
         executionGroups: execution.executionGroups
     }));
-    const persistedCandidate = task.status === "active" || task.status === "retired"
+    const persistedCandidate = task.status === "active" || task.status === "cancelled"
         ? taskRemoteDeliveryCandidate(task)
         : null;
     const remoteDelivery = projectTaskRemoteDeliveryFromStore(store, task, persistedCandidate);
@@ -166,7 +169,7 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         remoteDelivery
     };
 }
-function collectAttention(task, turns, events, failure) {
+function collectAttention(task, runs, events, failure) {
     const items = [];
     if (failure !== null) {
         items.push({
@@ -178,21 +181,21 @@ function collectAttention(task, turns, events, failure) {
             updatedAt: failure.lastFailedAt
         });
     }
-    for (const turn of turns) {
-        if (turn.roleName !== "leader"
-            || turn.status !== "active"
-            || !isRoleTurnStalled(events, turn.id))
+    for (const run of runs) {
+        if (run.roleName !== "leader"
+            || run.status !== "active"
+            || !isRoleRunStalled(events, run.id))
             continue;
-        const progressAt = latestStallProgressAt(events, turn.id) ?? turn.updatedAt;
+        const progressAt = latestStallProgressAt(events, run.id) ?? run.updatedAt;
         items.push({
             kind: "leader-stalled",
-            id: `leader-stall:${turn.id}:${progressAt}`,
+            id: `leader-stall:${run.id}:${progressAt}`,
             status: "needs-attention",
             owner: "operator",
-            summary: `Turn ${turn.id} for ${turn.roleName} has no durable progress after ${progressAt}.`,
+            summary: `AgentRun ${run.id} for ${run.roleName} has no durable progress after ${progressAt}.`,
             updatedAt: progressAt,
-            turnId: turn.id,
-            roleName: turn.roleName
+            runId: run.id,
+            roleName: run.roleName
         });
     }
     return items.sort((left, right) => (Date.parse(left.updatedAt) - Date.parse(right.updatedAt)
@@ -202,19 +205,7 @@ function collectBlockers(workItems, openInputRequests, attention) {
     const blockers = [];
     const workById = new Map(workItems.map((item) => [item.id, item]));
     for (const item of workItems) {
-        if (item.status === "failed") {
-            blockers.push({
-                kind: "work",
-                type: "work",
-                id: item.id,
-                status: item.status,
-                owner: item.assignee ?? "leader",
-                action: "review-failed-work",
-                summary: item.outcome ?? `Work Item ${item.id} failed.`
-            });
-            continue;
-        }
-        if (item.status === "awaiting_acceptance") {
+        if ((item.status === "open" && item.currentCandidateId !== undefined)) {
             blockers.push({
                 kind: "work",
                 type: "work",
@@ -226,9 +217,9 @@ function collectBlockers(workItems, openInputRequests, attention) {
             });
             continue;
         }
-        if (item.status !== "pending")
+        if (item.status !== "open")
             continue;
-        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "completed"));
+        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "accepted"));
         if (dependencies.length === 0)
             continue;
         blockers.push({
@@ -296,11 +287,8 @@ function overviewNextAction(task, workItems, execution, action) {
 function countWorkItems(items) {
     const counts = {
         total: items.length,
-        pending: 0,
-        running: 0,
-        awaiting_acceptance: 0,
-        completed: 0,
-        failed: 0,
+        open: 0,
+        accepted: 0,
         retired: 0
     };
     for (const item of items)

package/dist/commands/taskRemoteDeliveryCommand.js

@@ -29,7 +29,7 @@ export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate
         events: store.listEvents(task.id),
         publications: store.listPublicationReferences(task.id),
         managedWorkspaces: store.listManagedWorkspaces(task.id),
-        turns: store.listTurns(task.id),
+        runs: store.listRuns(task.id),
         currentCandidate
     });
 }
@@ -40,7 +40,7 @@ export function createTaskRemoteDeliveryProof(store, task, currentCandidate = nu
         events: store.listEvents(task.id),
         publications,
         managedWorkspaces: store.listManagedWorkspaces(task.id),
-        turns: store.listTurns(task.id),
+        runs: store.listRuns(task.id),
         currentCandidate
     });
     return {

package/dist/commands/taskRoleRuntimeStatus.js

@@ -1,12 +1,14 @@
 import { isDeepStrictEqual } from "node:util";
+import { runExecutionObservation } from "../agentRun/agentRun.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
+import { currentProviderConversation, managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
+import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { classifyRuntimeHealth, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
-import { latestTurnDurableProgressAt } from "../scheduler/roleTurnStall.js";
+import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
-import { formatTurnReceiptId } from "../task/taskRecordReference.js";
+import { formatRunReceiptId } 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,21 +23,25 @@ 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 activeTurn = status.activeTurn === null
+    const activeRun = status.activeRun === null
         ? "-"
-        : `${status.activeTurn.id} (${activeTurnDeliveryLabel(status.activeTurn)})`;
-    const lastTurn = status.activeTurn !== null || status.lastTurn === null
+        : `${status.activeRun.id} (${status.execution?.delivery ?? "unobserved"})`;
+    const lastRun = status.activeRun !== null || status.lastRun === null
         ? undefined
-        : `${status.lastTurn.id} (${status.lastTurn.status}${status.lastTurn.result === undefined ? "" : ` at ${status.lastTurn.result.completedAt}`})`;
+        : `${status.lastRun.id} (${status.lastRun.status}${status.lastRun.result === undefined ? "" : ` at ${status.lastRun.result.completedAt}`})`;
     const activeWork = status.activeWork === null
         ? "-"
         : `${status.activeWork.id} (${status.activeWork.status}) ${status.activeWork.title}`;
+    // Both lines name the execution component, as the Role view does. The
+    // connection plan cannot stand in for it here either: two different ACP
+    // products would print identically, and this display exists to say what is
+    // actually running.
     const nativeSession = status.nativeSession === null
         ? "not recorded"
-        : `${status.nativeSession.nativeSessionId} (${status.nativeSession.status}, ${status.nativeSession.adapterId}, effective r${status.nativeSession.effective.sourceDesiredRevision})`;
+        : `${status.nativeSession.nativeSessionId} (${status.nativeSession.status}, ${status.nativeSession.effective.component}, effective r${status.nativeSession.effective.sourceDesiredRevision})`;
     const effectiveLaunch = status.effectiveLaunch === null
         ? "not started"
-        : `${status.effectiveLaunch.agentId}/${status.effectiveLaunch.adapterId}; r${status.effectiveLaunch.sourceDesiredRevision}; Profile intent=${status.effectiveLaunch.profileAccess}; permission=${status.effectiveLaunch.permission.strategy}`;
+        : `${status.effectiveLaunch.agentId}/${status.effectiveLaunch.component}; r${status.effectiveLaunch.sourceDesiredRevision}; Profile intent=${status.effectiveLaunch.profileAccess}; permission=${status.effectiveLaunch.permission.strategy}`;
     const tmux = status.tmux.state === "missing"
         ? "missing"
         : [
@@ -84,11 +90,11 @@ export function renderTaskRoleRuntimeStatus(status) {
         `  Desired drift    ${status.effectiveLaunch === null
             ? "-"
             : status.launchDrift ? "pending next launch" : "none"}`,
-        `  Turn/session     ${status.turnSessionDrift ? "snapshot mismatch" : "snapshot consistent"}`,
+        `  AgentRun/session     ${status.runSessionDrift ? "snapshot mismatch" : "snapshot consistent"}`,
         `  Active work      ${activeWork}`,
-        `  Active run       ${activeTurn}`,
-        ...(lastTurn === undefined ? [] : [`  Last turn        ${lastTurn}`]),
-        `  Turn attention   ${status.stall.active
+        `  Active run       ${activeRun}`,
+        ...(lastRun === undefined ? [] : [`  Last turn        ${lastRun}`]),
+        `  AgentRun attention   ${status.stall.active
             ? `needs-attention (${status.stall.kind ?? "workflow-not-progressing"}; no workflow progress since ${status.stall.progressAt ?? "unknown"})`
             : "none"}`,
         `  Native session   ${nativeSession}`,
@@ -103,15 +109,15 @@ export function renderTaskRoleRuntimeStatus(status) {
 export function taskRoleActiveWorkLabel(status) {
     if (status.activeWork !== null)
         return `${status.activeWork.id}: ${status.activeWork.title}`;
-    return status.activeTurn === null ? "-" : status.activeTurn.id;
+    return status.activeRun === null ? "-" : status.activeRun.id;
 }
-/** 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)
+/** Issue 09: compact last-AgentRun 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)
         return "-";
-    return `${status.lastTurn.id} ${status.lastTurn.status}`;
+    return `${status.lastRun.id} ${status.lastRun.status}`;
 }
 export function taskRoleNativeSessionLabel(status) {
     if (status.runtimeCleanupPending && status.nativeSession === null)
@@ -140,26 +146,26 @@ export function taskRoleTmuxLabel(status) {
         : `running (${status.tmux.currentCommand})`;
 }
 function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now) {
-    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")
+    const activeRun = store.getActiveRun(taskId, role.name);
+    // The last AgentRun outcome is a separate axis from the Session lifecycle. A
+    // Session that stops after its AgentRun completed must not retroactively turn
+    // that AgentRun into a failure; the status display keeps both visible.
+    const lastRun = operationalTaskRecords(store.listRuns(taskId), store.listEvents(taskId), "run")
         .filter((candidate) => candidate.roleName === role.name)
         .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))[0]
         ?? null;
-    const activeWork = activeTurn?.workItemId === undefined
+    const activeWork = activeRun?.workItemId === undefined
         ? null
-        : store.getWorkItem(taskId, activeTurn.workItemId);
+        : store.getWorkItem(taskId, activeRun.workItemId);
     const sessions = store.getTaskRoleSessionSet(taskId, role.name);
-    const effectiveAgentId = activeTurn?.effective.agentId ?? sessions?.activeAgentId;
+    const effectiveAgentId = activeRun?.effective.agentId ?? sessions?.activeAgentId;
     const nativeSession = effectiveAgentId === undefined
         ? null
         : sessions?.sessions[effectiveAgentId] ?? null;
-    const effectiveLaunch = activeTurn?.effective ?? nativeSession?.effective ?? null;
-    const turnSessionDrift = activeTurn !== null
+    const effectiveLaunch = activeRun?.effective ?? nativeSession?.effective ?? null;
+    const runSessionDrift = activeRun !== null
         && nativeSession !== null
-        && !isDeepStrictEqual(activeTurn.effective, nativeSession.effective);
+        && !isDeepStrictEqual(activeRun.effective, nativeSession.effective);
     const recovery = inspectTaskRoleSessionRecovery(taskId, role.name, store);
     const tmux = pane === undefined
         ? { state: "missing" }
@@ -170,30 +176,46 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
             ...(pane.pid === undefined ? {} : { pid: pane.pid }),
             currentCommand: pane.currentCommand
         };
-    // The active Turn snapshot is authoritative for the live Role session. It
+    // The active AgentRun 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 = activeTurn?.workspace
-        ?? (activeTurn?.workItemId === undefined
-            ? store.getTaskWorkspace(taskId)
-            : store.getWorkItemWorkspace(taskId, activeTurn.workItemId));
+    const actualWorkspaceRoot = effectiveLaunch?.workspace.root ?? role.workspace;
+    const managedWorkspace = activeRun?.workspace
+        ?? store.listManagedWorkspaces(taskId).find(({ root }) => root === actualWorkspaceRoot)
+        ?? null;
     const workspace = managedWorkspace === null
-        ? { managed: false, path: role.workspace }
+        ? { managed: false, path: actualWorkspaceRoot }
         : { ...managedWorkspace, managed: true };
     const events = store.listEvents(taskId);
     const sessionTokens = projectSessionTokenMetrics(events, resolveSessionTokenIdentity(nativeSession === null
         ? null
         : { taskId, roleName: role.name, ...nativeSession }));
-    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
+    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
         ? undefined
-        : latestStallProgressAt(events, activeTurn.id);
-    const stallKind = activeTurn === null
+        : latestStallProgressAt(events, activeRun.id);
+    const stallKind = activeRun === null
         ? undefined
-        : latestStallKind(events, activeTurn.id);
-    const health = calculateHealth(role, activeTurn, lastTurn, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime);
-    const stall = activeTurn === null
+        : latestStallKind(events, activeRun.id);
+    const execution = activeRun === null ? undefined
+        : runExecutionObservation(activeRun, sessions?.providerBinding, events);
+    const conversation = sessions?.providerBinding == null
+        ? undefined : currentProviderConversation(sessions.providerBinding);
+    const currentProvider = nativeSession !== null
+        && conversation?.conversationId === nativeSession.nativeSessionId
+        ? sessions?.providerBinding : undefined;
+    const computedHealth = calculateHealth(role, activeRun, lastRun, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime, currentProvider?.run?.status, currentProvider != null && conversation?.recoverability === "unrecoverable");
+    const retainedInput = sessions?.providerBinding?.run;
+    const health = nativeSession === null && retainedInput != null
+        && ["submitting", "accepted", "delivery-unknown"].includes(retainedInput.status)
+        ? { health: "needs-attention",
+            healthReason: `Session cache is unbound; retained native input is ${retainedInput.status}. Inspect or replace this Role's Session.` }
+        : execution !== undefined && computedHealth.health === "running" && execution.delivery !== "accepted"
+            ? { health: execution?.delivery === "delivery-unknown" ? "needs-attention" : "awaiting-provider-acceptance",
+                healthReason: `Execution record is open; native admission is ${execution?.delivery ?? "unobserved"}.` }
+            : computedHealth;
+    const stall = activeRun === null
         ? { active: false }
         : {
             active: stalled,
@@ -209,13 +231,14 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         effectiveLaunch,
         launchDrift: effectiveLaunch !== null
             && effectiveLaunch.sourceDesiredRevision !== role.launchRevision,
-        turnSessionDrift,
+        runSessionDrift,
         ...health,
         openInputRequestCount,
         role,
-        activeTurn,
-        lastTurn,
+        activeRun,
+        lastRun,
         activeWork,
+        ...(execution === undefined ? {} : { execution }),
         nativeSession,
         tmux,
         workspace,
@@ -236,17 +259,17 @@ function sessionCumulativeTokenLabel(metrics) {
     ];
     return `${total.totalTokens} (${breakdown.join(", ")})`;
 }
-function latestStallKind(events, turnId) {
+function latestStallKind(events, runId) {
     const event = [...events]
-        .filter((candidate) => candidate.type === "turn.stalled"
-        && candidate.payload.turnId === turnId
+        .filter((candidate) => candidate.type === "run.stalled"
+        && candidate.payload.runId === runId
         && 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, activeTurn, lastTurn, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime) {
+function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime, nativeInputStatus, nativeConversationUnrecoverable = false) {
     if (runtimeCleanupPending && nativeSession === null) {
         return {
             health: "needs-attention",
@@ -254,33 +277,40 @@ function calculateHealth(role, activeTurn, lastTurn, nativeSession, runtimeClean
         };
     }
     if (nativeSession?.status === "ended" && nativeSession.endReason === "failed") {
-        // 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) {
+        // A broken Session only fails a live AgentRun. When the last AgentRun already
+        // completed, the Session death is a lifecycle event, not a AgentRun failure —
+        // surface it as attention with the persisted AgentRun outcome.
+        if (activeRun !== null) {
             return { health: "failed", healthReason: "the active native session is broken" };
         }
         return {
             health: "needs-attention",
-            healthReason: lastTurn === null
+            healthReason: lastRun === null
                 ? "the native session is broken"
-                : `the native session is broken; last Turn ${lastTurn.id} ${lastTurn.status}`
+                : `the native session is broken; last AgentRun ${lastRun.id} ${lastRun.status}`
         };
     }
     if (tmux.state === "exited") {
+        if (nativeSession?.status === "ended" && nativeSession.endReason === "stopped"
+            && activeRun === null && !runtimeCleanupPending
+            && !["submitting", "accepted", "delivery-unknown"].includes(nativeInputStatus ?? "")) {
+            return role.name === "leader" && openInputRequestCount > 0
+                ? { health: "blocked-input", healthReason: `${openInputRequestCount} durable InputRequest(s) still require user input` }
+                : { health: "idle", healthReason: "the Session was deliberately stopped; no native input remains unsettled" };
+        }
         return {
             health: "needs-attention",
             healthReason: "the tmux pane exited; Provider Conversation/continuation state is unobservable"
         };
     }
-    if (activeTurn !== null) {
+    if (activeRun !== null) {
         if (tmux.state !== "running") {
-            return { health: "needs-attention", healthReason: "the active Turn has no live tmux pane" };
+            return { health: "needs-attention", healthReason: "the active AgentRun has no live tmux pane" };
         }
         if (stalled) {
             return {
                 health: "needs-attention",
-                healthReason: "the live active Turn has no durable progress in the configured stall window"
+                healthReason: "the live active AgentRun has no durable progress in the configured stall window"
             };
         }
         if (runtime !== null) {
@@ -315,7 +345,7 @@ function calculateHealth(role, activeTurn, lastTurn, nativeSession, runtimeClean
         }
         return {
             health: "starting",
-            healthReason: "the active Turn is awaiting Provider runtime observations"
+            healthReason: "the active AgentRun is awaiting Provider runtime observations"
         };
     }
     if (nativeSession?.status === "active" && tmux.state !== "running") {
@@ -324,6 +354,20 @@ function calculateHealth(role, activeTurn, lastTurn, nativeSession, runtimeClean
     if (nativeSession?.status === "ended" && tmux.state === "running") {
         return { health: "needs-attention", healthReason: "a stopped native session has a live tmux pane" };
     }
+    if (nativeSession?.status === "active" && tmux.state === "running") {
+        if (nativeConversationUnrecoverable) {
+            return { health: "needs-attention", healthReason: "the native conversation cannot resume; stop its idle Session and explicitly select a new one" };
+        }
+        if (nativeInputStatus === "submitting") {
+            return { health: "awaiting-provider-acceptance", healthReason: "native input is submitting; no AgentRun is required for a notification" };
+        }
+        if (nativeInputStatus === "accepted") {
+            return { health: "running", healthReason: "accepted native input is awaiting its terminal, independently of AgentRun records" };
+        }
+        if (nativeInputStatus === "delivery-unknown") {
+            return { health: "needs-attention", healthReason: "native input disposition is unknown; absence of an AgentRun does not prove idle" };
+        }
+    }
     if (role.name === "leader" && openInputRequestCount > 0) {
         return {
             health: "blocked-input",
@@ -335,52 +379,51 @@ function calculateHealth(role, activeTurn, lastTurn, nativeSession, runtimeClean
         : { health: "idle", healthReason: "there is no active work or live tmux pane" };
 }
 function projectTaskRoleRuntime(run, session, tmux, events, _mailbox, store, taskId, roleName, now) {
-    if (run === null || session?.runtimeGenerationId === undefined)
+    if (session === null)
+        return null;
+    const observed = store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding?.run;
+    // A newly admitted Run must not inherit the preceding input's receipt. A
+    // terminal Run no longer occupies the active index, but its exact binding
+    // still identifies the observations to render.
+    const native = run !== null && managedProviderTurnId(observed) !== run.id ? undefined : observed;
+    if (run === null && native == null)
         return null;
     let driverId;
     try {
-        driverId = builtinDriverIdForAdapter(run.effective.adapterId);
+        driverId = builtinDriverIdForAdapter(run?.effective.adapterId ?? session.adapterId);
     }
     catch {
         return null;
     }
-    const fence = {
-        taskId: run.taskId,
-        roleName: run.roleName,
-        turnId: run.id,
-        agentId: run.effective.agentId,
+    const createdAt = run?.createdAt ?? native.submittedAt;
+    const updatedAt = run?.updatedAt ?? native.updatedAt;
+    const receiptId = native?.attemptId ?? formatRunReceiptId(taskId, run.id);
+    const basicFence = {
+        taskId,
+        roleName,
+        ...(run?.id === undefined && native?.runId === undefined ? {} : { runId: run?.id ?? native?.runId }),
+        agentId: run?.effective.agentId ?? session.agentId,
         driverId,
-        runtimeGenerationId: session.runtimeGenerationId,
         nativeSessionId: session.nativeSessionId,
-        nativeTurnId: runtimeNativeTurnId(events, {
-            taskId: run.taskId,
-            roleName: run.roleName,
-            turnId: run.id,
-            agentId: run.effective.agentId,
-            driverId,
-            runtimeGenerationId: session.runtimeGenerationId,
-            nativeSessionId: session.nativeSessionId,
-            receiptId: store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding?.turn?.attemptId
-                ?? formatTurnReceiptId(run.taskId, run.id)
-        }) ?? run.id,
-        receiptId: store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding?.turn?.attemptId
-            ?? formatTurnReceiptId(run.taskId, run.id)
+        receiptId
     };
-    let projection = projectRuntimeTaskEvents(fence, run.createdAt, events);
+    const nativeTurnId = native?.nativeTurnId ?? runtimeNativeTurnId(events, basicFence);
+    const fence = { ...basicFence, ...(nativeTurnId === undefined ? {} : { nativeTurnId }) };
+    let projection = projectRuntimeTaskEvents(fence, createdAt, events);
     projection = projectRuntimeObservation(projection, createRuntimeObservation({
         schemaVersion: 4,
-        eventId: `runtime-host-${run.id}`,
-        semanticKey: `runtime-host-${run.id}`,
+        eventId: `runtime-host-${receiptId}`,
+        semanticKey: `runtime-host-${receiptId}`,
         kind: "host.observed",
         authority: "host",
-        receivedAt: run.updatedAt,
+        receivedAt: updatedAt,
         fence,
         payload: { alive: tmux.state === "running" }
     }));
     // The semantic progress fence is the same durable fold the scheduler stall
     // pass consumes, so CLI/Web/scheduler share one progress clock.
-    const semanticProgress = latestTurnDurableProgressAt(store, taskId, roleName, run.id)
-        ?? { progressAt: run.createdAt };
+    const semanticProgress = (run === null ? undefined : latestRunDurableProgressAt(store, taskId, roleName, run.id))
+        ?? { progressAt: createdAt };
     const classification = classifyRuntimeHealth({
         projection,
         semanticProgressAt: semanticProgress.progressAt,
@@ -414,16 +457,7 @@ function projectTaskRoleRuntime(run, session, tmux, events, _mailbox, store, tas
 function runtimeNativeTurnId(events, expected) {
     const observations = events
         .map(runtimeObservationFromTaskEvent)
-        .filter((observation) => observation !== null
-        && observation.fence.taskId === expected.taskId
-        && observation.fence.roleName === expected.roleName
-        && observation.fence.turnId === expected.turnId
-        && observation.fence.agentId === expected.agentId
-        && observation.fence.driverId === expected.driverId
-        && observation.fence.runtimeGenerationId === expected.runtimeGenerationId
-        && observation.fence.nativeSessionId === expected.nativeSessionId
-        && observation.fence.receiptId === expected.receiptId
-        && observation.fence.nativeTurnId !== undefined)
+        .filter((observation) => observation !== null && observation.fence.taskId === expected.taskId && observation.fence.roleName === expected.roleName && observation.fence.runId === expected.runId && observation.fence.agentId === expected.agentId && observation.fence.driverId === expected.driverId && observation.fence.nativeSessionId === expected.nativeSessionId && observation.fence.receiptId === expected.receiptId && observation.fence.nativeTurnId !== undefined)
         .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
         || (left.sequence ?? -1) - (right.sequence ?? -1)
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
@@ -432,6 +466,3 @@ function runtimeNativeTurnId(events, expected) {
         ?.fence.nativeTurnId
         ?? observations.at(-1)?.fence.nativeTurnId;
 }
-function activeTurnDeliveryLabel(run) {
-    return run.status === "active" ? "active" : run.status;
-}