@zq-silk/yui 0.15.7 → 0.15.8

package/dist/runtime/runtimeObservation.js

@@ -22,9 +22,6 @@ const KINDS = [
     "session.ended",
     "session.failed",
     "conversation.observed",
-    "activation.started",
-    "activation.ended",
-    "activation.failed",
     "goal.updated",
     "goal.cleared",
     "turn.accepted",
@@ -40,6 +37,7 @@ const KINDS = [
     "continuation.reported",
     "continuation.settled",
     "input.accepted",
+    "input.rejected",
     "input.delivery-unknown",
     "activity.observed",
     "observer.health"
@@ -53,8 +51,8 @@ const AUTHORITIES = [
     "diagnostic"
 ];
 /** Provider Turn facts always carry native Turn identity. `turnId` is only an
- * optional correlation when that Turn was started for a Yui Turn. */
-const TURN_SCOPED = new Set([
+ * optional correlation when that AgentRun was started for a Yui AgentRun. */
+const RUN_SCOPED = new Set([
     "turn.accepted",
     "turn.waiting",
     "turn.completed",
@@ -103,19 +101,14 @@ export function createRuntimeObservation(input) {
         throw new Error(`${input.kind} requires provider-structured or controller authority.`);
     }
     const fence = normalizeFence(input.fence);
-    if (TURN_SCOPED.has(input.kind) && fence.nativeSessionId === undefined) {
+    if (RUN_SCOPED.has(input.kind) && fence.nativeSessionId === undefined) {
         throw new Error(`${input.kind} requires nativeSessionId.`);
     }
-    if (TURN_SCOPED.has(input.kind) && fence.nativeTurnId === undefined
+    if (RUN_SCOPED.has(input.kind) && fence.nativeTurnId === undefined
         && fence.receiptId === undefined) {
         throw new Error(`${input.kind} requires a native Turn or exact receipt identity.`);
     }
-    if ((input.kind.startsWith("activation.") || CONTINUATION_SCOPED.has(input.kind)
-        || input.kind === "native-work.snapshot")
-        && fence.activationId === undefined) {
-        throw new Error(`${input.kind} requires activationId.`);
-    }
-    if ((input.kind === "conversation.observed" || input.kind.startsWith("activation.")
+    if ((input.kind === "conversation.observed"
         || CONTINUATION_SCOPED.has(input.kind) || input.kind === "native-work.snapshot")
         && fence.conversationId === undefined) {
         throw new Error(`${input.kind} requires conversationId.`);
@@ -123,9 +116,6 @@ export function createRuntimeObservation(input) {
     if (CONTINUATION_SCOPED.has(input.kind) && fence.continuationId === undefined) {
         throw new Error(`${input.kind} requires continuationId.`);
     }
-    if (CONTINUATION_SCOPED.has(input.kind) && fence.continuationGeneration === undefined) {
-        throw new Error(`${input.kind} requires continuationGeneration.`);
-    }
     const payload = normalizePayload(input.kind, input.payload);
     const sequence = input.sequence;
     if (sequence !== undefined && (!Number.isSafeInteger(sequence) || sequence < 0)) {
@@ -155,14 +145,11 @@ export function runtimeObservationFenceMatches(expected, actual) {
     for (const field of [
         "taskId",
         "roleName",
-        "turnId",
+        "runId",
         "agentId",
         "driverId",
-        "runtimeGenerationId",
         "conversationId",
-        "activationId",
         "continuationId",
-        "continuationGeneration",
         "parentContinuationId",
         "nativeSessionId",
         "nativeTurnId",
@@ -174,20 +161,19 @@ export function runtimeObservationFenceMatches(expected, actual) {
     return true;
 }
 /**
- * Matches observations that belong to one durable Turn/Runtime generation.
+ * Matches observations that belong to one durable AgentRun/Runtime Session.
  * A provider may advance its native Turn while background subagents from an
- * earlier Turn are still active and later mailbox activations use their own
+ * earlier AgentRun are still active and later mailbox activations use their own
  * exactly-once receipt, so nativeTurnId and receiptId are intentionally
  * excluded. Exact acceptance still validates both fields before persistence.
  */
-export function runtimeObservationTurnFenceMatches(expected, actual) {
+export function runtimeObservationRunFenceMatches(expected, actual) {
     for (const field of [
         "taskId",
         "roleName",
-        "turnId",
+        "runId",
         "agentId",
         "driverId",
-        "runtimeGenerationId",
         "nativeSessionId"
     ]) {
         if (expected[field] !== actual[field])
@@ -204,9 +190,8 @@ export function runtimeObservationTaskEventPayload(input) {
         roleName: observation.fence.roleName,
         agentId: observation.fence.agentId,
         driverId: observation.fence.driverId,
-        runtimeGenerationId: observation.fence.runtimeGenerationId,
         ...(observation.fence.taskId === undefined ? {} : { taskId: observation.fence.taskId }),
-        ...(observation.fence.turnId === undefined ? {} : { turnId: observation.fence.turnId }),
+        ...(observation.fence.runId === undefined ? {} : { runId: observation.fence.runId }),
         ...(observation.fence.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: observation.fence.nativeSessionId }),
@@ -229,15 +214,15 @@ export function runtimeObservationFromTaskEvent(event) {
 /**
  * Runtime observation events are compacted by operation identity: a terminal
  * operation replaces its matching start. Any retained exact start therefore
- * represents Provider-owned work that is still active for this Turn.
+ * represents Provider-owned work that is still active for this AgentRun.
  */
-export function turnHasActiveRuntimeOperations(events, owner) {
+export function runHasActiveRuntimeOperations(events, owner) {
     return events.some((event) => {
         const observation = runtimeObservationFromTaskEvent(event);
         return observation?.kind === "operation.started"
             && observation.fence.taskId === owner.taskId
             && observation.fence.roleName === owner.roleName
-            && observation.fence.turnId === owner.turnId
+            && observation.fence.runId === owner.runId
             && observation.fence.agentId === owner.agentId;
     });
 }
@@ -245,10 +230,9 @@ function normalizeFence(input) {
     return Object.freeze({
         ...(input.taskId === undefined ? {} : { taskId: requireIdentity(input.taskId, "Task id") }),
         roleName: requireIdentity(input.roleName, "Role name"),
-        ...(input.turnId === undefined ? {} : { turnId: requireIdentity(input.turnId, "Turn id") }),
+        ...(input.runId === undefined ? {} : { runId: requireIdentity(input.runId, "AgentRun id") }),
         agentId: requireIdentity(input.agentId, "Agent id"),
         driverId: requireDriverId(input.driverId),
-        runtimeGenerationId: requireIdentity(input.runtimeGenerationId, "Runtime generation id"),
         ...(input.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireIdentity(input.nativeSessionId, "Native Session id") }),
@@ -261,17 +245,9 @@ function normalizeFence(input) {
         ...(input.conversationId === undefined
             ? {}
             : { conversationId: requireIdentity(input.conversationId, "Provider Conversation id") }),
-        ...(input.activationId === undefined
-            ? {}
-            : { activationId: requireIdentity(input.activationId, "Provider Activation id") }),
         ...(input.continuationId === undefined
             ? {}
             : { continuationId: requireIdentity(input.continuationId, "Provider Continuation id") }),
-        ...(input.continuationGeneration === undefined
-            ? {}
-            : {
-                continuationGeneration: requireNonNegativeInteger(input.continuationGeneration, 1, "Provider Continuation generation")
-            }),
         ...(input.parentContinuationId === undefined
             ? {}
             : {
@@ -290,7 +266,7 @@ function normalizePayload(kind, input) {
         && input.reason !== "user"
         && input.reason !== "permission"
         && input.reason !== "external") {
-        throw new Error("turn.waiting requires a supported reason.");
+        throw new Error("run.waiting requires a supported reason.");
     }
     if (kind === "turn.waiting")
         requireIdentity(input.waitId, "Runtime wait id");
@@ -321,7 +297,7 @@ function normalizePayload(kind, input) {
         ? undefined
         : normalizeObserverSource(input.observerSource);
     if (kind === "turn.failed" && input.failure === undefined) {
-        throw new Error("turn.failed requires normalized failure evidence.");
+        throw new Error("run.failed requires normalized failure evidence.");
     }
     if (input.resultTransportDiagnostic !== undefined && kind !== "turn.completed") {
         throw new Error("Only turn.completed may carry a result transport diagnostic.");
@@ -412,11 +388,11 @@ function normalizePayload(kind, input) {
         ...(input.input === undefined ? {} : { input: requireText(input.input, "Provider-visible input") }),
         ...(input.output === undefined
             ? {}
-            : { output: requireResultText(input.output, "Runtime Turn output") }),
+            : { output: requireResultText(input.output, "Runtime AgentRun output") }),
         ...(input.resultTransportDiagnostic === undefined
             ? {}
             : {
-                resultTransportDiagnostic: requireText(input.resultTransportDiagnostic, "Runtime Turn result diagnostic")
+                resultTransportDiagnostic: requireText(input.resultTransportDiagnostic, "Runtime AgentRun result diagnostic")
             }),
         ...(input.summary === undefined ? {} : { summary: requireText(input.summary, "Runtime summary") }),
         ...(input.execution === undefined ? {} : { execution: input.execution }),
@@ -463,15 +439,13 @@ export function runtimeObservationSemanticKey(input) {
     const continuationIdentity = [
         fence.driverId,
         fence.agentId,
-        fence.conversationId ?? fence.nativeSessionId ?? fence.runtimeGenerationId,
-        fence.activationId ?? fence.runtimeGenerationId,
-        fence.continuationId ?? "none",
-        fence.continuationGeneration ?? "none"
+        fence.conversationId ?? fence.nativeSessionId ?? "none",
+        fence.continuationId ?? "none"
     ];
     // Terminal boundaries are semantic facts. Providers may replay them with a
     // fresh transport sequence after reconnect, so terminal identity must win
     // over occurrence ordering or one SessionEnd storm becomes many facts.
-    if (["session.ended", "session.failed", "activation.ended", "activation.failed",
+    if (["session.ended", "session.failed",
         "goal.cleared", "turn.completed", "turn.failed", "turn.cancelled", "continuation.settled"].includes(input.kind)) {
         return [
             "terminal",
@@ -480,7 +454,7 @@ export function runtimeObservationSemanticKey(input) {
             input.kind,
             input.payload?.outcome ?? input.payload?.failure?.error.code ?? "terminal",
             input.kind === "continuation.settled" ? input.payload?.resultRef ?? "none" : "none",
-            input.kind === "turn.failed" && input.payload?.failure?.turnTerminal === true
+            input.kind === "turn.failed" && input.payload?.failure?.runTerminal === true
                 ? "turn-terminal-failure"
                 : "turn-terminal"
         ].join(":");
@@ -489,7 +463,7 @@ export function runtimeObservationSemanticKey(input) {
         return [
             "goal-state",
             fence.driverId,
-            fence.conversationId ?? fence.nativeSessionId ?? fence.runtimeGenerationId,
+            fence.conversationId ?? fence.nativeSessionId ?? "none",
             input.payload?.goalStatus ?? "unknown",
             input.payload?.goalUpdatedAt ?? "unknown"
         ].join(":");
@@ -514,18 +488,8 @@ export function runtimeObservationSemanticKey(input) {
             input.payload?.resultRef ?? "none"
         ].join(":");
     }
-    if (input.sequence !== undefined) {
-        return [
-            "provider-sequence",
-            fence.driverId,
-            fence.conversationId ?? fence.nativeSessionId ?? fence.runtimeGenerationId,
-            fence.activationId ?? fence.runtimeGenerationId,
-            fence.continuationId ?? fence.receiptId ?? fence.nativeTurnId ?? "none",
-            fence.continuationGeneration ?? "none",
-            input.sequence,
-            input.kind
-        ].join(":");
-    }
+    // Sequence is transport-local ordering, not identity: it may restart when
+    // a Host reconnects to the same Session. Inbox retries retain the event id.
     return `provider-event:${requireIdentity(input.eventId, "Runtime observation event id")}`;
 }
 function normalizeObserverSource(input) {
@@ -554,9 +518,9 @@ function normalizeFailure(input) {
         ...(input.lastOutput === undefined
             ? {}
             : { lastOutput: requireText(input.lastOutput, "Runtime failure last output") }),
-        ...(input.turnTerminal === undefined
+        ...(input.runTerminal === undefined
             ? {}
-            : { turnTerminal: requireBoolean(input.turnTerminal, "Runtime failure turnTerminal") })
+            : { runTerminal: requireBoolean(input.runTerminal, "Runtime failure runTerminal") })
     });
 }
 function requireBoolean(value, label) {

package/dist/runtime/runtimeProjection.js

@@ -1,4 +1,4 @@
-import { createRuntimeObservation, runtimeObservationFromTaskEvent, runtimeObservationTurnFenceMatches } from "./runtimeObservation.js";
+import { createRuntimeObservation, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches } from "./runtimeObservation.js";
 import { DEFAULT_RUNTIME_HEALTH_POLICY } from "./runtimeHealthPolicy.js";
 export function createRuntimeProjection(fence, createdAt) {
     const timestamp = requireTimestamp(createdAt);
@@ -6,9 +6,8 @@ export function createRuntimeProjection(fence, createdAt) {
         fence: Object.freeze({ ...fence }),
         host: "unknown",
         session: "unknown",
-        turn: "none",
+        run: "none",
         conversation: "unknown",
-        activation: "none",
         goal: "none",
         continuations: Object.freeze({}),
         runActivity: "starting",
@@ -29,7 +28,7 @@ export function createRuntimeProjection(fence, createdAt) {
 export function projectRuntimeTaskEvents(fence, createdAt, events) {
     const observations = events
         .map(runtimeObservationFromTaskEvent)
-        .filter((event) => (event !== null && runtimeObservationTurnFenceMatches(fence, event.fence)))
+        .filter((event) => (event !== null && runtimeObservationRunFenceMatches(fence, event.fence)))
         .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
         || (left.sequence ?? -1) - (right.sequence ?? -1)
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
@@ -38,7 +37,7 @@ export function projectRuntimeTaskEvents(fence, createdAt, events) {
 }
 export function projectRuntimeObservation(current, raw) {
     const event = createRuntimeObservation(raw);
-    if (!runtimeObservationTurnFenceMatches(current.fence, event.fence)) {
+    if (!runtimeObservationRunFenceMatches(current.fence, event.fence)) {
         throw new Error("Runtime observation fence does not match the projection.");
     }
     const at = event.receivedAt;
@@ -52,7 +51,6 @@ export function projectRuntimeObservation(current, raw) {
             return next(current, {
                 session: "started",
                 conversation: "recoverable",
-                activation: "active",
                 stateSince: at
             });
         case "session.ready":
@@ -60,28 +58,28 @@ export function projectRuntimeObservation(current, raw) {
         case "session.ended":
             return next(current, {
                 session: "ended",
-                activation: "ended",
-                turn: terminalTurn(current.turn),
+                run: terminalRun(current.run),
                 // A parent provider Session ending is independent from native child
-                // operations already observed under the Turn. Keep those children
+                // operations already observed under the AgentRun. Keep those children
                 // visible until their own terminal facts arrive; host/session loss is
-                // health evidence, not proof that child work or the Yui Turn ended.
+                // health evidence, not proof that child work or the Yui AgentRun ended.
                 operations: activeSubagentOperations(current.operations),
                 stateSince: at
             });
         case "session.failed":
             return next(current, {
                 session: "failed",
-                activation: "failed",
-                turn: current.turn === "none" ? "failed" : terminalTurn(current.turn, "failed"),
+                run: current.run === "none" ? "failed" : terminalRun(current.run, "failed"),
                 operations: activeSubagentOperations(current.operations),
                 stateSince: at
             });
         case "turn.accepted":
         case "input.accepted":
+            if (event.fence.receiptId?.startsWith("turn-input:") === true)
+                return current;
             return withActivity(next(current, {
                 session: "active",
-                turn: "accepted",
+                run: "accepted",
                 waitingReason: undefined,
                 waitId: undefined,
                 stateSince: at
@@ -89,7 +87,7 @@ export function projectRuntimeObservation(current, raw) {
         case "turn.waiting":
             return next(current, {
                 session: "waiting",
-                turn: "waiting",
+                run: "waiting",
                 waitingReason: event.payload.reason,
                 waitId: event.payload.waitId,
                 stateSince: at
@@ -97,19 +95,19 @@ export function projectRuntimeObservation(current, raw) {
         case "turn.completed":
             return withActivity(next(current, {
                 session: "ready",
-                turn: "completed",
+                run: "completed",
                 waitingReason: undefined,
                 waitId: undefined,
                 // Tool operations belong to the completed native Turn. Provider-owned
                 // background subagents may legitimately outlive it and wake later
-                // native Provider activity inside the same durable Yui Turn.
+                // native Provider activity inside the same durable Yui AgentRun.
                 operations: activeSubagentOperations(current.operations),
                 stateSince: at
             }), "provider", at);
         case "turn.failed":
             return withActivity(next(current, {
                 session: "ready",
-                turn: "failed",
+                run: "failed",
                 waitingReason: undefined,
                 waitId: undefined,
                 operations: Object.freeze({}),
@@ -118,7 +116,7 @@ export function projectRuntimeObservation(current, raw) {
         case "turn.cancelled":
             return withActivity(next(current, {
                 session: "ready",
-                turn: "cancelled",
+                run: "cancelled",
                 waitingReason: undefined,
                 waitId: undefined,
                 operations: Object.freeze({}),
@@ -131,7 +129,7 @@ export function projectRuntimeObservation(current, raw) {
                 session: current.session === "ended" || current.session === "failed"
                     ? current.session
                     : "active",
-                turn: current.turn === "waiting" ? "accepted" : current.turn,
+                run: current.run === "waiting" ? "accepted" : current.run,
                 waitingReason: undefined,
                 waitId: undefined,
                 operations: Object.freeze({
@@ -149,7 +147,7 @@ export function projectRuntimeObservation(current, raw) {
                 session: current.session === "ended" || current.session === "failed"
                     ? current.session
                     : "active",
-                turn: current.turn === "waiting" ? "accepted" : current.turn,
+                run: current.run === "waiting" ? "accepted" : current.run,
                 waitingReason: undefined,
                 waitId: undefined,
                 operations: Object.freeze(operations),
@@ -163,8 +161,8 @@ export function projectRuntimeObservation(current, raw) {
             const projected = next(current, {
                 ...(usage === undefined ? {} : { usage: Object.freeze({ ...usage }) }),
                 ...(lifecycleActivity ? {
-                    session: current.turn === "waiting" ? "active" : current.session,
-                    turn: current.turn === "waiting" ? "accepted" : current.turn,
+                    session: current.run === "waiting" ? "active" : current.session,
+                    run: current.run === "waiting" ? "accepted" : current.run,
                     waitingReason: undefined,
                     waitId: undefined
                 } : {})
@@ -192,12 +190,6 @@ export function projectRuntimeObservation(current, raw) {
                     ? "unrecoverable"
                     : event.payload.recoverability === "recoverable" ? "recoverable" : "unknown"
             });
-        case "activation.started":
-            return next(current, { activation: "active", stateSince: at });
-        case "activation.ended":
-            return next(current, { activation: "ended", stateSince: at });
-        case "activation.failed":
-            return next(current, { activation: "failed", stateSince: at });
         case "goal.updated":
             return next(current, { goal: event.payload.goalStatus, stateSince: at });
         case "goal.cleared":
@@ -206,9 +198,7 @@ export function projectRuntimeObservation(current, raw) {
         case "continuation.reported":
         case "continuation.settled": {
             const id = [
-                event.fence.activationId,
-                event.fence.continuationId,
-                event.fence.continuationGeneration
+                event.fence.continuationId
             ].join("/");
             const existing = current.continuations[id];
             if (event.kind === "continuation.reported") {
@@ -263,7 +253,9 @@ export function projectRuntimeObservation(current, raw) {
             });
         }
         case "input.delivery-unknown":
-            return next(current, { turn: "delivery-unknown", stateSince: at });
+            if (event.fence.receiptId?.startsWith("turn-input:") === true)
+                return current;
+            return next(current, { run: "delivery-unknown", stateSince: at });
         case "native-work.snapshot":
             return next(current, {});
         default:
@@ -301,12 +293,12 @@ export function runtimeDisplayStatus(current) {
         return "stopped";
     if (operation !== null)
         return `${operation}-active`;
-    if (current.turn === "waiting")
+    if (current.run === "waiting")
         return `waiting-${current.waitingReason ?? "external"}`;
-    if (current.session === "ready" || current.turn === "completed"
-        || current.turn === "failed" || current.turn === "cancelled")
+    if (current.session === "ready" || current.run === "completed"
+        || current.run === "failed" || current.run === "cancelled")
         return "ready";
-    if (current.turn === "accepted" || current.session === "active") {
+    if (current.run === "accepted" || current.session === "active") {
         return current.activity.kind === "model" ? "model-active" : "active-quiet";
     }
     if (current.session === "started")
@@ -318,7 +310,7 @@ export function runtimeDisplayStatus(current) {
 /**
  * Classify one RuntimeProjection into the layered health state shared by CLI,
  * Web, and scheduler. The semantic progress timestamp is the same durable
- * fence the scheduler stall pass consumes (Turn creation plus Work/Review/
+ * fence the scheduler stall pass consumes (AgentRun creation plus Work/Review/
  * Integration checkpoints), so token/tool/CPU activity can never masquerade
  * as business progress.
  *
@@ -376,9 +368,14 @@ function classifyLayer(current, operation, runtimeIdleMs, semanticIdleMs, policy
     if (current.observer.status === "degraded" || current.observer.status === "unavailable") {
         return "diagnostic-needed";
     }
-    if (current.turn === "waiting") {
+    if (current.run === "waiting") {
         return `waiting-${current.waitingReason ?? "external"}`;
     }
+    if (current.session === "ready"
+        || current.run === "completed"
+        || current.run === "failed"
+        || current.run === "cancelled")
+        return "ready";
     // No durable semantic progress past fifteen minutes: display only. The
     // scheduler's coalesced read-only diagnostic remains a separate 30m clock.
     if (semanticIdleMs >= policy.diagnosticAfterMs)
@@ -386,13 +383,8 @@ function classifyLayer(current, operation, runtimeIdleMs, semanticIdleMs, policy
     // A live turn with no recent structured activity is quiet, not dead.
     if (runtimeIdleMs >= policy.quietAfterMs)
         return "quiet";
-    if (current.turn === "accepted" || current.session === "active")
+    if (current.run === "accepted" || current.session === "active")
         return "active-quiet";
-    if (current.session === "ready"
-        || current.turn === "completed"
-        || current.turn === "failed"
-        || current.turn === "cancelled")
-        return "ready";
     if (current.session === "started")
         return "awaiting-provider-acceptance";
     if (current.host === "alive")
@@ -404,7 +396,7 @@ function runtimeHealthReason(layer, current) {
         case "broken":
             return "the Agent Driver runtime is broken";
         case "stopped":
-            return "the Provider Activation ended while the Yui Turn remains active";
+            return "the Provider execution attachment has ended";
         case "subagent-active":
         case "tool-active":
         case "model-active":
@@ -423,9 +415,9 @@ function runtimeHealthReason(layer, current) {
         case "waiting-external":
             return `the Agent Driver is ${layer.replaceAll("-", " ")}`;
         case "ready":
-            return "the Provider turn ended while the Yui Turn is still active";
+            return "the Provider turn has ended; Task progress is recorded separately";
         case "awaiting-provider-acceptance":
-            return "the submitted active Turn is awaiting Provider acceptance";
+            return "the submitted active AgentRun is awaiting Provider acceptance";
         case "runtime-unobservable":
             return "the host is present but the Agent Driver exposes no current runtime state";
         case "starting":
@@ -454,7 +446,7 @@ function next(current, patch) {
         ...activeNativeOperations.map(([id]) => `native-operation:${id}`)
     ];
     const attention = [
-        ...(copy.turn === "delivery-unknown" ? ["delivery-unknown"] : []),
+        ...(copy.run === "delivery-unknown" ? ["delivery-unknown"] : []),
         ...continuations.flatMap(([id, continuation]) => (continuation.identityConflict ? [`identity-conflict:${id}`]
             : continuation.observation === "unavailable" ? [`continuation-unresolved:${id}`]
                 : [])),
@@ -469,10 +461,10 @@ function next(current, patch) {
         || copy.session === "ended"
         || copy.session === "failed"
         ? "unobservable"
-        : (copy.activation !== "active" && waitingNative.length > 0)
+        : (["unknown", "ended", "failed"].includes(copy.session) && waitingNative.length > 0)
             ? "reconciling"
             : "healthy";
-    const runActivity = copy.turn === "accepted"
+    const runActivity = copy.run === "accepted"
         || copy.session === "active"
         ? "running"
         : waitingNative.length > 0 || activeNativeOperations.length > 0 ? "waiting"
@@ -499,7 +491,7 @@ function dominantOperation(operations) {
 function activeSubagentOperations(operations) {
     return Object.freeze(Object.fromEntries(Object.entries(operations).filter(([, operation]) => operation.kind === "subagent")));
 }
-function terminalTurn(current, fallback = "cancelled") {
+function terminalRun(current, fallback = "cancelled") {
     return current === "completed" || current === "failed" || current === "cancelled"
         ? current
         : fallback;

package/dist/runtime/runtimeSessionCandidate.js

@@ -15,9 +15,7 @@ export function projectRuntimeSessionCandidate(sessions) {
         agentId: active.agentId,
         adapterId: active.adapterId,
         nativeSessionId: active.nativeSessionId,
-        ...(active.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: active.runtimeGenerationId }),
-        sessionUpdatedAt: active.updatedAt,
-        cleanupRequired: active.runtimeGenerationId !== undefined
+        sessionUpdatedAt: active.updatedAt
     };
 }
 /** Deterministic owner order shared by all storage backends. */

package/dist/runtime/sessionLaunchRequest.js

@@ -15,23 +15,19 @@ export function createSessionLaunchRequest(input) {
     const runtimeIsolation = input.runtimeIsolation === undefined
         ? undefined
         : parseTaskRuntimeIsolationDescriptor(JSON.stringify(input.runtimeIsolation));
-    if (runtimeIsolation !== undefined && (input.owner.scope !== "task"
-        || runtimeIsolation.taskId !== input.owner.taskId
-        || runtimeIsolation.workspace.root !== workspace
-        || runtimeIsolation.generation.runtimeGenerationId !== input.runtimeGenerationId)) {
+    if (runtimeIsolation !== undefined && (input.owner.scope !== "task" || runtimeIsolation.taskId !== input.owner.taskId || runtimeIsolation.workspace.root !== workspace)) {
         throw new TypeError("Session launch request does not match its Task runtime isolation descriptor.");
     }
     const common = {
-        runtimeGenerationId: requireSafeIdentity(input.runtimeGenerationId, "Runtime generation id"),
         owner: normalizeRuntimeOwner(input.owner),
         agentId,
         adapterId,
         effective,
         workspace,
         ...(runtimeIsolation === undefined ? {} : { runtimeIsolation }),
-        ...(input.turnId === undefined
+        ...(input.runId === undefined
             ? {}
-            : { turnId: requireSafeIdentity(input.turnId, "Turn id") }),
+            : { runId: requireSafeIdentity(input.runId, "AgentRun id") }),
         ...(input.environment === undefined
             ? {}
             : { environment: copyEnvironment(input.environment) })