@zq-silk/yui 0.15.7 → 0.15.8

package/dist/runtime/providerRuntimeIdentity.js

@@ -1,5 +1,5 @@
 export function createProviderRuntimeBinding(input) {
-    const startedAt = timestamp(input.startedAt, "Provider Activation startedAt");
+    const startedAt = timestamp(input.startedAt, "Provider Conversation startedAt");
     return validateProviderRuntimeBinding({
         schemaVersion: 5,
         providerNamespace: identity(input.providerNamespace, "Provider namespace"),
@@ -12,20 +12,13 @@ export function createProviderRuntimeBinding(input) {
                 recoverability: "unknown",
                 createdAt: startedAt
             }],
-        activations: [{
-                activationId: identity(input.activationId, "Provider Activation id"),
-                conversationId: input.conversationId,
-                generation: 1,
-                status: "active",
-                startedAt
-            }],
         authority: {
             epoch: 1,
             owner: "controller",
-            holderId: input.activationId,
+            holderId: "controller",
             changedAt: startedAt
         },
-        turn: null,
+        run: null,
         goal: null
     });
 }
@@ -51,72 +44,6 @@ export function currentProviderConversation(binding) {
     validateProviderRuntimeBinding(binding);
     return binding.conversations.find((entry) => (entry.epoch === binding.currentConversationEpoch && entry.status === "current"));
 }
-export function currentProviderActivation(binding) {
-    const conversation = currentProviderConversation(binding);
-    return [...binding.activations].reverse().find((entry) => (entry.conversationId === conversation.conversationId && entry.status === "active")) ?? null;
-}
-export function startProviderActivation(raw, input) {
-    const binding = validateProviderRuntimeBinding(raw);
-    if (currentProviderActivation(binding) !== null) {
-        throw new Error("Provider Conversation already has a live writer Activation.");
-    }
-    if (binding.authority.owner !== "none") {
-        throw new Error("Provider Conversation authority must be unowned before a new Activation starts.");
-    }
-    const conversation = currentProviderConversation(binding);
-    const generation = binding.activations
-        .filter((entry) => entry.conversationId === conversation.conversationId)
-        .reduce((maximum, entry) => Math.max(maximum, entry.generation), 0) + 1;
-    const startedAt = timestamp(input.startedAt, "Provider Activation startedAt");
-    const activationId = identity(input.activationId, "Provider Activation id");
-    return validateProviderRuntimeBinding({
-        ...binding,
-        activations: [...binding.activations, {
-                activationId,
-                conversationId: conversation.conversationId,
-                generation,
-                status: "active",
-                startedAt
-            }],
-        authority: {
-            epoch: binding.authority.epoch + 1,
-            owner: "controller",
-            holderId: activationId,
-            changedAt: startedAt
-        }
-    });
-}
-export function endProviderActivation(raw, activationId, input) {
-    const binding = validateProviderRuntimeBinding(raw);
-    const id = identity(activationId, "Provider Activation id");
-    const target = binding.activations.find((entry) => entry.activationId === id);
-    if (target === undefined)
-        throw new Error(`Provider Activation is not recorded: ${id}.`);
-    if (target.status !== "active")
-        return binding;
-    const endedAt = timestamp(input.endedAt, "Provider Activation endedAt");
-    if (Date.parse(endedAt) < Date.parse(target.startedAt)) {
-        throw new Error("Provider Activation endedAt is earlier than startedAt.");
-    }
-    return validateProviderRuntimeBinding({
-        ...binding,
-        activations: binding.activations.map((entry) => entry.activationId === id
-            ? {
-                ...entry,
-                status: input.status,
-                endedAt,
-                ...(input.reason === undefined
-                    ? {}
-                    : { terminalReason: identity(input.reason, "Provider Activation terminal reason") })
-            }
-            : entry),
-        authority: {
-            epoch: binding.authority.epoch + 1,
-            owner: "none",
-            changedAt: endedAt
-        }
-    });
-}
 /**
  * Compare-and-swap the only Provider writer. A stale Controller or detached
  * terminal cannot regain authority with an older epoch.
@@ -127,10 +54,9 @@ export function transferProviderAuthority(raw, input) {
         || binding.authority.owner !== input.expectedOwner) {
         throw new Error("Provider authority fence is stale.");
     }
-    if (providerTurnIsActive(binding.turn)) {
-        throw new Error("Provider authority cannot transfer while a Turn is unsettled.");
+    if (providerTurnIsActive(binding.run)) {
+        throw new Error("Provider authority cannot transfer while a AgentRun is unsettled.");
     }
-    const active = currentProviderActivation(binding);
     const changedAt = timestamp(input.changedAt, "Provider authority changedAt");
     if (Date.parse(changedAt) < Date.parse(binding.authority.changedAt)) {
         throw new Error("Provider authority changedAt moved backwards.");
@@ -142,12 +68,9 @@ export function transferProviderAuthority(raw, input) {
         }
     }
     else {
-        if (active === null) {
-            throw new Error("Provider authority requires a live Activation.");
-        }
         holderId = identity(input.holderId, "Provider authority holder id");
-        if (input.owner === "controller" && holderId !== active.activationId) {
-            throw new Error("Controller authority must be held by the live Activation.");
+        if (input.owner === "controller" && holderId !== "controller") {
+            throw new Error("Controller authority must name the Controller.");
         }
     }
     return validateProviderRuntimeBinding({
@@ -163,13 +86,13 @@ export function transferProviderAuthority(raw, input) {
 export function beginProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     const attemptId = identity(input.attemptId, "Provider input attempt id");
-    const turnId = input.turnId === undefined ? undefined : identity(input.turnId, "Turn id");
-    const currentTurn = binding.turn;
-    if (currentTurn !== null
-        && currentTurn.turnId === turnId
-        && currentTurn.attemptId === attemptId
-        && currentTurn.authorityEpoch === input.authorityEpoch
-        && currentTurn.status === "submitting") {
+    const runId = input.runId === undefined ? undefined : identity(input.runId, "AgentRun id");
+    const currentRun = binding.run;
+    if (currentRun !== null
+        && currentRun.runId === runId
+        && currentRun.attemptId === attemptId
+        && currentRun.authorityEpoch === input.authorityEpoch
+        && currentRun.status === "submitting") {
         return binding;
     }
     if (binding.authority.epoch !== input.authorityEpoch
@@ -177,16 +100,15 @@ export function beginProviderTurn(raw, input) {
         || binding.authority.owner === "unknown") {
         throw new Error("Provider Turn authority fence is stale.");
     }
-    if (providerTurnIsActive(binding.turn)) {
-        throw new Error("Provider Conversation already has an unsettled Turn.");
+    if (providerTurnIsActive(binding.run)) {
+        throw new Error("Provider Conversation already has an unsettled AgentRun.");
     }
     const submittedAt = timestamp(input.submittedAt, "Provider Turn submittedAt");
     return validateProviderRuntimeBinding({
         ...binding,
-        turn: {
-            ...(turnId === undefined ? {} : { turnId }),
+        run: {
+            ...(runId === undefined ? {} : { runId }),
             attemptId,
-            activationId: currentProviderActivation(binding).activationId,
             authorityEpoch: input.authorityEpoch,
             status: "submitting",
             submittedAt,
@@ -197,16 +119,16 @@ export function beginProviderTurn(raw, input) {
 export function acceptProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     const attemptId = identity(input.attemptId, "Provider input attempt id");
-    const turn = binding.turn;
-    if (turn === null || turn.attemptId !== attemptId
-        || (turn.status !== "submitting" && turn.status !== "delivery-unknown")) {
+    const run = binding.run;
+    if (run === null || run.attemptId !== attemptId
+        || (run.status !== "submitting" && run.status !== "delivery-unknown")) {
         throw new Error("Provider Turn does not match an acceptable delivery state.");
     }
-    const acceptedAt = orderedTurnTimestamp(turn, input.acceptedAt, "Provider Turn acceptedAt");
+    const acceptedAt = orderedRunTimestamp(run, input.acceptedAt, "Provider Turn acceptedAt");
     return validateProviderRuntimeBinding({
         ...binding,
-        turn: {
-            ...turn,
+        run: {
+            ...run,
             status: "accepted",
             ...(input.nativeTurnId === undefined
                 ? {}
@@ -217,12 +139,12 @@ export function acceptProviderTurn(raw, input) {
 }
 export function markProviderTurnDeliveryUnknown(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
-    const turn = requireProviderTurn(binding, input.attemptId, "submitting");
-    const observedAt = orderedTurnTimestamp(turn, input.observedAt, "Provider Turn unknownAt");
+    const run = requireProviderTurn(binding, input.attemptId, "submitting");
+    const observedAt = orderedRunTimestamp(run, input.observedAt, "Provider Turn unknownAt");
     return validateProviderRuntimeBinding({
         ...binding,
-        turn: {
-            ...turn,
+        run: {
+            ...run,
             status: "delivery-unknown",
             terminalReason: identity(input.reason, "Provider Turn unknown reason"),
             updatedAt: observedAt
@@ -232,16 +154,16 @@ export function markProviderTurnDeliveryUnknown(raw, input) {
 /** Exact negative acknowledgement before a Provider Turn identity existed. */
 export function rejectProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
-    const turn = binding.turn;
-    if (turn === null || turn.attemptId !== identity(input.attemptId, "Provider input attempt id")
-        || (turn.status !== "submitting" && turn.status !== "delivery-unknown")) {
+    const run = binding.run;
+    if (run === null || run.attemptId !== identity(input.attemptId, "Provider input attempt id")
+        || (run.status !== "submitting" && run.status !== "delivery-unknown")) {
         throw new Error("Provider Turn does not match a rejectable delivery state.");
     }
-    const rejectedAt = orderedTurnTimestamp(turn, input.rejectedAt, "Provider Turn rejectedAt");
+    const rejectedAt = orderedRunTimestamp(run, input.rejectedAt, "Provider Turn rejectedAt");
     return validateProviderRuntimeBinding({
         ...binding,
-        turn: {
-            ...turn,
+        run: {
+            ...run,
             status: "rejected",
             terminalReason: identity(input.reason, "Provider Turn rejection reason"),
             updatedAt: rejectedAt
@@ -252,15 +174,26 @@ export function rejectProviderTurn(raw, input) {
 export function settleProviderTurnSubmission(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     const attemptId = identity(input.attemptId, "Provider input attempt id");
-    if (binding.turn?.attemptId !== attemptId) {
+    if (binding.run?.attemptId !== attemptId) {
         throw new Error("Provider Turn does not match a resolvable delivery state.");
     }
-    if (binding.turn.status === input.status)
+    if (binding.run.status === input.status)
         return binding;
-    if (binding.turn.status !== "submitting"
-        && !(binding.turn.status === "delivery-unknown" && input.status === "rejected")) {
+    if (binding.run.status !== "submitting"
+        && !(binding.run.status === "delivery-unknown" && input.status === "rejected")) {
         throw new Error("Provider Turn does not match a resolvable delivery state.");
     }
+    if (input.status === "deferred") {
+        return validateProviderRuntimeBinding({
+            ...binding,
+            run: {
+                ...binding.run,
+                status: "deferred",
+                terminalReason: identity(input.reason, "Provider admission deferral reason"),
+                updatedAt: orderedRunTimestamp(binding.run, input.resolvedAt, "Provider deferredAt")
+            }
+        });
+    }
     return input.status === "delivery-unknown"
         ? markProviderTurnDeliveryUnknown(binding, {
             attemptId,
@@ -275,23 +208,23 @@ export function settleProviderTurnSubmission(raw, input) {
 }
 export function settleProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
-    const turn = binding.turn;
+    const run = binding.run;
     const nativeTurnId = input.nativeTurnId === undefined
         ? undefined : identity(input.nativeTurnId, "Provider native Turn id");
-    if (turn === null
+    if (run === null
         || (input.attemptId === undefined
-            ? nativeTurnId === undefined || turn.nativeTurnId !== nativeTurnId
-            : turn.attemptId !== input.attemptId)
-        || (turn.nativeTurnId !== undefined && nativeTurnId !== undefined
-            && turn.nativeTurnId !== nativeTurnId)
-        || turn.status !== "accepted") {
-        throw new Error("Provider Turn settlement does not match the current Turn.");
-    }
-    const settledAt = orderedTurnTimestamp(turn, input.settledAt, "Provider Turn settledAt");
+            ? nativeTurnId === undefined || run.nativeTurnId !== nativeTurnId
+            : run.attemptId !== input.attemptId)
+        || (run.nativeTurnId !== undefined && nativeTurnId !== undefined
+            && run.nativeTurnId !== nativeTurnId)
+        || run.status !== "accepted") {
+        throw new Error("Provider Turn settlement does not match the current AgentRun.");
+    }
+    const settledAt = orderedRunTimestamp(run, input.settledAt, "Provider Turn settledAt");
     return validateProviderRuntimeBinding({
         ...binding,
-        turn: {
-            ...turn,
+        run: {
+            ...run,
             ...(nativeTurnId === undefined ? {} : { nativeTurnId }),
             status: input.status,
             updatedAt: settledAt,
@@ -301,6 +234,21 @@ export function settleProviderTurn(raw, input) {
         }
     });
 }
+/** Explicitly abandon an engineering input only after its execution resources
+ * are quiescent. This does not invent native acceptance, a Turn id or success. */
+export function cancelQuiescentProviderInput(raw, input) {
+    const binding = validateProviderRuntimeBinding(raw);
+    if (binding.run?.attemptId !== input.attemptId)
+        throw new Error("Provider input identity changed during stop.");
+    if (!providerTurnIsActive(binding.run))
+        return binding;
+    return validateProviderRuntimeBinding({
+        ...binding,
+        run: { ...binding.run, status: "cancelled",
+            updatedAt: orderedRunTimestamp(binding.run, input.cancelledAt, "Provider input cancelledAt"),
+            terminalReason: input.reason }
+    });
+}
 export function updateProviderConversationRecoverability(raw, recoverability) {
     const binding = validateProviderRuntimeBinding(raw);
     const current = currentProviderConversation(binding);
@@ -314,11 +262,8 @@ export function updateProviderConversationRecoverability(raw, recoverability) {
 /** Shared pre-start and commit guard for explicit native Conversation replacement. */
 export function assertProviderConversationReplaceable(raw) {
     const binding = validateProviderRuntimeBinding(raw);
-    if (currentProviderActivation(binding) !== null || binding.authority.owner !== "none") {
-        throw new Error("Provider Conversation replacement requires its prior Activation to be ended and unowned.");
-    }
-    if (providerTurnIsActive(binding.turn)) {
-        throw new Error(`Provider Conversation replacement cannot discard unsettled input attempt ${binding.turn.attemptId} (${binding.turn.status}). Resolve its actual outcome before selecting a new Conversation.`);
+    if (providerTurnIsActive(binding.run)) {
+        throw new Error(`Provider Conversation replacement cannot discard unsettled input attempt ${binding.run.attemptId} (${binding.run.status}). Resolve its actual outcome before selecting a new Conversation.`);
     }
 }
 export function supersedeProviderConversation(raw, input) {
@@ -345,17 +290,10 @@ export function supersedeProviderConversation(raw, input) {
                 createdAt: switchedAt
             }
         ],
-        activations: [...binding.activations, {
-                activationId: identity(input.activationId, "Provider Activation id"),
-                conversationId: input.conversationId,
-                generation: 1,
-                status: "active",
-                startedAt: switchedAt
-            }],
         authority: {
             epoch: binding.authority.epoch + 1,
             owner: "controller",
-            holderId: input.activationId,
+            holderId: "controller",
             changedAt: switchedAt
         },
         goal: null
@@ -406,70 +344,24 @@ export function validateProviderRuntimeBinding(value) {
     }
     if (currentCount !== 1)
         throw new Error("Provider Runtime Binding requires one current Conversation.");
-    const activationIds = new Set();
-    const activeByConversation = new Set();
-    const generations = new Set();
-    for (const activation of value.activations) {
-        identity(activation.activationId, "Provider Activation id");
-        if (activationIds.has(activation.activationId)) {
-            throw new Error("Provider Runtime Binding contains duplicate Activation identity.");
-        }
-        activationIds.add(activation.activationId);
-        if (!conversationIds.has(activation.conversationId)) {
-            throw new Error("Provider Activation references an unknown Conversation.");
-        }
-        integer(activation.generation, 1, "Provider Activation generation");
-        const generationKey = `${activation.conversationId}\u0000${activation.generation}`;
-        if (generations.has(generationKey)) {
-            throw new Error("Provider Runtime Binding contains duplicate Activation generation.");
-        }
-        generations.add(generationKey);
-        if (!["active", "ended", "failed"].includes(activation.status)) {
-            throw new Error("Provider Activation status is invalid.");
-        }
-        timestamp(activation.startedAt, "Provider Activation startedAt");
-        if (activation.status === "active") {
-            if (activation.endedAt !== undefined) {
-                throw new Error("Active Provider Activation cannot have endedAt.");
-            }
-            if (activeByConversation.has(activation.conversationId)) {
-                throw new Error("Provider Conversation has multiple live writer Activations.");
-            }
-            activeByConversation.add(activation.conversationId);
-        }
-        else {
-            if (activation.endedAt === undefined)
-                throw new Error("Terminal Provider Activation requires endedAt.");
-            timestamp(activation.endedAt, "Provider Activation endedAt");
-        }
-    }
     integer(value.authority.epoch, 1, "Provider authority epoch");
     timestamp(value.authority.changedAt, "Provider authority changedAt");
     if (!["controller", "human", "none", "unknown"].includes(value.authority.owner)) {
         throw new Error("Provider authority owner is invalid.");
     }
-    const active = currentActivationUnchecked(value);
     if (value.authority.owner === "controller" || value.authority.owner === "human") {
         const holderId = identity(value.authority.holderId, "Provider authority holder id");
-        if (active === null)
-            throw new Error("Owned Provider authority requires a live Activation.");
-        if (value.authority.owner === "controller" && holderId !== active.activationId) {
-            throw new Error("Controller authority must be held by the live Activation.");
+        if (value.authority.owner === "controller" && holderId !== "controller") {
+            throw new Error("Controller authority must name the Controller.");
         }
     }
     else if (value.authority.holderId !== undefined) {
         throw new Error("Unowned or unknown Provider authority cannot name a holder.");
     }
-    if (active !== null && (value.authority.owner === "none" || value.authority.owner === "unknown")) {
-        throw new Error("A live Provider Activation requires an exact writer authority.");
-    }
-    if (!Object.hasOwn(value, "turn"))
-        throw new Error("Provider Runtime Binding requires Turn state.");
-    if (value.turn !== null) {
-        validateProviderTurn(value.turn, value.authority.epoch);
-        if (value.turn.activationId !== undefined && !activationIds.has(value.turn.activationId)) {
-            throw new Error("Provider Turn references an unknown original Activation.");
-        }
+    if (!Object.hasOwn(value, "run"))
+        throw new Error("Provider Runtime Binding requires AgentRun state.");
+    if (value.run !== null) {
+        validateProviderTurn(value.run, value.authority.epoch);
     }
     if (!Object.hasOwn(value, "goal"))
         throw new Error("Provider Runtime Binding requires Goal state.");
@@ -501,56 +393,52 @@ function validateProviderGoal(goal) {
     };
     return Object.freeze(normalized);
 }
-function validateProviderTurn(turn, currentAuthorityEpoch) {
-    if (turn.turnId !== undefined)
-        identity(turn.turnId, "Turn id");
-    identity(turn.attemptId, "Provider input attempt id");
-    integer(turn.authorityEpoch, 1, "Provider Turn authority epoch");
-    if (turn.authorityEpoch > currentAuthorityEpoch) {
+function validateProviderTurn(run, currentAuthorityEpoch) {
+    if (run.runId !== undefined)
+        identity(run.runId, "AgentRun id");
+    identity(run.attemptId, "Provider input attempt id");
+    integer(run.authorityEpoch, 1, "Provider Turn authority epoch");
+    if (run.authorityEpoch > currentAuthorityEpoch) {
         throw new Error("Provider Turn authority epoch is ahead of current authority.");
     }
-    if (!["submitting", "accepted", "completed", "failed", "cancelled", "rejected", "delivery-unknown"]
-        .includes(turn.status)) {
+    if (!["submitting", "accepted", "completed", "failed", "cancelled", "rejected", "deferred", "delivery-unknown"]
+        .includes(run.status)) {
         throw new Error("Provider Turn status is invalid.");
     }
-    timestamp(turn.submittedAt, "Provider Turn submittedAt");
-    timestamp(turn.updatedAt, "Provider Turn updatedAt");
-    if (Date.parse(turn.updatedAt) < Date.parse(turn.submittedAt)) {
+    timestamp(run.submittedAt, "Provider Turn submittedAt");
+    timestamp(run.updatedAt, "Provider Turn updatedAt");
+    if (Date.parse(run.updatedAt) < Date.parse(run.submittedAt)) {
         throw new Error("Provider Turn updatedAt is earlier than submittedAt.");
     }
-    const hasAcceptedIdentity = turn.status === "accepted"
-        || turn.status === "completed" || turn.status === "failed" || turn.status === "cancelled";
-    if (hasAcceptedIdentity && turn.nativeTurnId !== undefined) {
-        identity(turn.nativeTurnId, "Provider native Turn id");
+    const hasAcceptedIdentity = run.status === "accepted"
+        || run.status === "completed" || run.status === "failed" || run.status === "cancelled";
+    if (hasAcceptedIdentity && run.nativeTurnId !== undefined) {
+        identity(run.nativeTurnId, "Provider native Turn id");
     }
-    else if (!hasAcceptedIdentity && turn.nativeTurnId !== undefined) {
+    else if (!hasAcceptedIdentity && run.nativeTurnId !== undefined) {
         throw new Error("Unaccepted Provider Turn cannot have a native Turn id.");
     }
 }
-export function managedProviderTurnId(turn) {
-    return turn?.turnId ?? null;
+export function managedProviderTurnId(run) {
+    return run?.runId ?? null;
 }
 function requireProviderTurn(binding, attemptId, status) {
     const id = identity(attemptId, "Provider input attempt id");
-    if (binding.turn === null || binding.turn.attemptId !== id || binding.turn.status !== status) {
+    if (binding.run === null || binding.run.attemptId !== id || binding.run.status !== status) {
         throw new Error("Provider Turn does not match the expected delivery state.");
     }
-    return binding.turn;
+    return binding.run;
 }
-function orderedTurnTimestamp(turn, value, label) {
+function orderedRunTimestamp(run, value, label) {
     const normalized = timestamp(value, label);
-    if (Date.parse(normalized) < Date.parse(turn.updatedAt)) {
+    if (Date.parse(normalized) < Date.parse(run.updatedAt)) {
         throw new Error(`${label} moved backwards.`);
     }
     return normalized;
 }
-function providerTurnIsActive(turn) {
-    return turn !== null && ["submitting", "accepted", "delivery-unknown"]
-        .includes(turn.status);
-}
-function currentActivationUnchecked(binding) {
-    const current = binding.conversations.find((entry) => (entry.epoch === binding.currentConversationEpoch && entry.status === "current"));
-    return current === undefined ? null : [...binding.activations].reverse().find((entry) => (entry.conversationId === current.conversationId && entry.status === "active")) ?? null;
+function providerTurnIsActive(run) {
+    return run !== null && ["submitting", "accepted", "delivery-unknown"]
+        .includes(run.status);
 }
 function identity(value, label) {
     if (typeof value !== "string" || value.trim().length === 0)

package/dist/runtime/providerRuntimeReconciler.js

@@ -4,8 +4,8 @@ const MAX_RECONCILE_MS = 5 * 60_000;
 const CIRCUIT_ERROR_LIMIT = 5;
 const QUERY_TIMEOUT_MS = 5_000;
 /**
- * Reconciles only already-known children, grouped under one Conversation and
- * Activation generation. Missing entries settle ownership only for an exact
+ * Reconciles only already-known children, grouped under one Conversation.
+ * Missing entries settle ownership only for an exact
  * snapshot; partial/unavailable absence is never terminal evidence.
  */
 export async function reconcileKnownDetachedContinuations(input) {
@@ -17,16 +17,14 @@ export async function reconcileKnownDetachedContinuations(input) {
     const groupKey = [
         first.identity.providerNamespace,
         first.identity.accountScope,
-        first.identity.conversationId,
-        first.identity.activationId
+        first.identity.conversationId
     ].join("\u0000");
     if (candidates.some((entry) => [
         entry.identity.providerNamespace,
         entry.identity.accountScope,
-        entry.identity.conversationId,
-        entry.identity.activationId
+        entry.identity.conversationId
     ].join("\u0000") !== groupKey)) {
-        throw new Error("Provider reconcile input must contain one Conversation/Activation group.");
+        throw new Error("Provider reconcile input must contain one Conversation group.");
     }
     const nowMs = input.now.getTime();
     if (input.previous?.circuitOpenUntil !== undefined
@@ -44,10 +42,8 @@ export async function reconcileKnownDetachedContinuations(input) {
             providerNamespace: first.identity.providerNamespace,
             accountScope: first.identity.accountScope,
             conversationId: first.identity.conversationId,
-            activationId: first.identity.activationId,
             continuations: Object.freeze(candidates.map((entry) => Object.freeze({
                 continuationId: entry.identity.continuationId,
-                generation: entry.identity.generation
             })))
         }), QUERY_TIMEOUT_MS);
         result = validateQueryResult(raw, new Set(candidates.map((entry) => (providerContinuationKey(entry.identity)))));

package/dist/runtime/runtimeBinding.js

@@ -7,7 +7,6 @@ export function createRuntimeBinding(input) {
         : requireBoolean(input.hostCreated, "Runtime host-created flag");
     return {
         id: requireSafeIdentity(input.id, "Runtime binding id"),
-        runtimeGenerationId: requireSafeIdentity(input.runtimeGenerationId, "Runtime generation id"),
         owner: normalizeRuntimeOwner(input.owner),
         agentId: requireSafeIdentity(input.agentId, "Agent id"),
         adapterId: requireSafeIdentity(input.adapterId, "Agent adapter id"),

package/dist/runtime/runtimeContinuationProjection.js

@@ -12,17 +12,14 @@ export function projectProviderContinuations(events) {
     // Provider sequence and must not be moved before the Provider start fact.
     for (const observation of observations) {
         const fence = observation.fence;
-        if (fence.conversationId === undefined || fence.activationId === undefined
-            || fence.continuationId === undefined || fence.continuationGeneration === undefined) {
+        if (fence.conversationId === undefined || fence.continuationId === undefined) {
             continue;
         }
         const key = [
             fence.driverId,
             fence.agentId,
             fence.conversationId,
-            fence.activationId,
-            fence.continuationId,
-            fence.continuationGeneration
+            fence.continuationId
         ].join("\u0000");
         const result = foldContinuationObservation(projected.get(key) ?? null, observation);
         projected.set(providerContinuationKey(result.continuation.identity), result.continuation);
@@ -32,10 +29,10 @@ export function projectProviderContinuations(events) {
 export function blockingProviderContinuations(events) {
     return projectProviderContinuations(events).filter((entry) => (continuationOwnsWriterUmbrella(entry) || entry.identityConflict));
 }
-/** Exact Turn-scoped writer fence shared by terminalization and retry paths. */
+/** Exact AgentRun-scoped writer fence shared by terminalization and retry paths. */
 export function runOwnsBlockingProviderContinuation(events, owner) {
     return blockingProviderContinuations(events).some((continuation) => (continuation.taskId === owner.taskId
         && continuation.roleName === owner.roleName
-        && continuation.turnId === owner.turnId
+        && continuation.runId === owner.runId
         && continuation.identity.accountScope === owner.agentId));
 }

package/dist/runtime/runtimeDeadlines.js

@@ -12,3 +12,12 @@ export const LIFECYCLE_REQUEST_TIMEOUT_MS = AGENT_HOST_CONTROL_TIMEOUT_MS + RUNT
 export const CONTROLLER_SHUTDOWN_TIMEOUT_MS = LIFECYCLE_REQUEST_TIMEOUT_MS + RUNTIME_ENVELOPE_MARGIN_MS;
 export const RELEASE_HANDOVER_OLD_OWNER_GRACE_MS = CONTROLLER_SHUTDOWN_TIMEOUT_MS + RUNTIME_ENVELOPE_MARGIN_MS;
 export const RELEASE_HANDOVER_PROMOTION_TIMEOUT_MS = RELEASE_HANDOVER_OLD_OWNER_GRACE_MS + RUNTIME_ENVELOPE_MARGIN_MS;
+/** Grace for an owned Provider client to exit after the Host asks it to stop. */
+export const AGENT_HOST_CLIENT_EXIT_GRACE_MS = 10_000;
+/**
+ * Bounded wait for Endpoint implementation references to drain during shutdown.
+ * Strictly inside the owned client's exit grace, so reporting the remaining
+ * references never delays the Host past the point where it stops waiting for
+ * that client. Expiry reports what is still in use; it never kills anything.
+ */
+export const ENDPOINT_DRAIN_TIMEOUT_MS = AGENT_HOST_CLIENT_EXIT_GRACE_MS / 2;

package/dist/runtime/runtimeHealthPolicy.js

@@ -5,7 +5,7 @@
  * The layers are deliberately time-based and conservative: short silence is
  * normal for high-reasoning-effort turns, large reviews, and tool waits.
  * Time-based layers authorize display hints and coalesced read-only diagnosis
- * only. They never reset a Turn or replace a Provider Session.
+ * only. They never reset a AgentRun or replace a Provider Session.
  */
 /** Runtime silence after which a live turn is surfaced as "quiet" (hint only). */
 export const RUNTIME_QUIET_AFTER_MS = 5 * 60_000;