@zq-silk/yui 0.13.7 → 0.13.8

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -9,7 +9,7 @@ import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
 import { createTaskWake, fallbackWakeCursor, latestTaskWake } from "../scheduler/taskWake.js";
 import { answerInputRequest } from "../input/inputRequest.js";
-import { activeRoleAgentBinding, updateRoleStatus } from "../role/role.js";
+import { activeRoleAgentBinding } from "../role/role.js";
 import { effectiveLaunchWithTaskMainWorkspace, effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
 import { failAgentRun, markAgentRunDelivered, markAgentRunPushed, reopenRunForProviderRetry, clearProviderRetryOnProgress, agentRunDeliveryReceiptId, withProviderRetry } from "../run/agentRun.js";
@@ -101,7 +101,7 @@ export class FileSchedulerStoreAdapter {
                 outcome = this.observeRuntimePromptAccepted(input, adapterId, now);
                 break;
             case "turn.completed": {
-                const completed = {
+                const classification = this.classifyRuntimeTurnCompleted({
                     taskId,
                     roleName: input.fence.roleName,
                     agentId: input.fence.agentId,
@@ -110,10 +110,8 @@ export class FileSchedulerStoreAdapter {
                     nativeSessionId: input.fence.nativeSessionId,
                     turnId: input.fence.nativeTurnId,
                     attemptId: input.fence.receiptId,
-                    runId: input.fence.runId,
-                    summary: input.payload.summary ?? "Agent turn completed without a workflow outcome."
-                };
-                const classification = this.classifyRuntimeTurnCompleted(completed);
+                    runId: input.fence.runId
+                });
                 if (classification !== "apply")
                     return classification;
                 if (this.runtimeTurnHasActiveNativeSubagents(input)) {
@@ -123,39 +121,24 @@ export class FileSchedulerStoreAdapter {
                     outcome = this.validateCanonicalRunObservation(input, now);
                     break;
                 }
-                const result = this.observeRuntimeTurnCompleted(completed, now);
-                outcome = result.disposition === "obsolete" ? "obsolete" : "applied";
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "completed", input.payload.summary ?? "Agent turn completed without a workflow outcome.", now);
                 break;
             }
             case "turn.failed": {
                 const failureEvidence = input.payload.failure;
                 if (failureEvidence.runTerminal !== true) {
-                    const classification = this.classifyRuntimeTurnCompleted({
-                        taskId,
-                        roleName: input.fence.roleName,
-                        agentId: input.fence.agentId,
-                        adapterId,
-                        launchId: input.fence.launchId,
-                        nativeSessionId: input.fence.nativeSessionId,
-                        turnId: input.fence.nativeTurnId,
-                        runId: input.fence.runId
-                    });
-                    if (classification !== "apply")
-                        return classification;
-                    const boundary = this.observeRuntimeTurnCompleted({
-                        taskId,
-                        roleName: input.fence.roleName,
-                        agentId: input.fence.agentId,
-                        adapterId,
-                        launchId: input.fence.launchId,
-                        nativeSessionId: input.fence.nativeSessionId,
-                        turnId: input.fence.nativeTurnId,
-                        attemptId: input.fence.receiptId,
-                        runId: input.fence.runId,
-                        summary: input.payload.summary ?? `Provider Turn failed: ${failureEvidence.code}.`,
-                        providerStatus: "failed"
-                    }, now);
-                    outcome = boundary.disposition === "obsolete" ? "obsolete" : "applied";
+                    outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", input.payload.summary ?? `Provider Turn failed: ${failureEvidence.code}.`, now);
+                    break;
+                }
+                const active = this.store.getActiveAgentRun(taskId, input.fence.roleName);
+                const recordedTurn = this.store.getTaskRoleSessionSet(taskId, input.fence.roleName)?.providerBinding?.turn;
+                if (input.fence.runId !== undefined
+                    && active?.id !== input.fence.runId
+                    && recordedTurn !== null
+                    && recordedTurn !== undefined
+                    && recordedTurn.runId === input.fence.runId
+                    && recordedTurn.turnId === input.fence.nativeTurnId) {
+                    outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", input.payload.summary ?? `Provider Turn failed: ${failureEvidence.code}.`, now);
                     break;
                 }
                 const failure = {
@@ -194,7 +177,6 @@ export class FileSchedulerStoreAdapter {
             case "operation.completed":
             case "operation.failed":
             case "turn.waiting":
-            case "turn.cancelled":
             case "activity.observed":
             case "observer.health":
             case "native-work.snapshot":
@@ -204,6 +186,10 @@ export class FileSchedulerStoreAdapter {
             case "input.delivery-unknown":
                 outcome = this.validateCanonicalRunObservation(input, now);
                 break;
+            case "turn.cancelled": {
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "cancelled", input.payload.summary ?? "Provider Turn was cancelled.", now);
+                break;
+            }
             case "conversation.observed":
             case "activation.started":
             case "activation.ended":
@@ -292,6 +278,26 @@ export class FileSchedulerStoreAdapter {
         const projection = projectRuntimeTaskEvents(input.fence, run.createdAt, this.store.listEvents(taskId));
         return Object.values(projection.operations).some(({ kind }) => kind === "subagent");
     }
+    foldProviderTurnBoundary(input, adapterId, providerStatus, summary, now) {
+        const completed = {
+            taskId: input.fence.taskId,
+            roleName: input.fence.roleName,
+            agentId: input.fence.agentId,
+            adapterId,
+            launchId: input.fence.launchId,
+            nativeSessionId: input.fence.nativeSessionId,
+            turnId: input.fence.nativeTurnId,
+            attemptId: input.fence.receiptId,
+            runId: input.fence.runId,
+            summary,
+            providerStatus
+        };
+        const classification = this.classifyRuntimeTurnCompleted(completed);
+        if (classification !== "apply")
+            return classification;
+        const result = this.observeRuntimeTurnCompleted(completed, now);
+        return result.disposition === "obsolete" ? "obsolete" : "applied";
+    }
     validateCanonicalSessionObservation(input, now) {
         return this.store.transaction((store) => {
             const run = store.getAgentRun(input.fence.taskId, input.fence.runId);
@@ -381,7 +387,6 @@ export class FileSchedulerStoreAdapter {
                 && active.status === "active"
                 && active.deliveredAt !== undefined
                 && role !== null) {
-                store.saveRole(input.fence.taskId, updateRoleStatus(role, "detached", now));
                 if (role.name === "leader") {
                     const message = [
                         `Leader native Session became unavailable while Run ${active.id} remains active.`,
@@ -827,10 +832,6 @@ export class FileSchedulerStoreAdapter {
             return existing && !recovered ? "already-recorded" : "recorded";
         });
     }
-    hasInFlightTurn(taskId, roleName) {
-        const sessions = this.store.getTaskRoleSessionSet(taskId, roleName);
-        return sessions !== null && sessions.inFlight !== null;
-    }
     beginAgentHostProviderTurn(input) {
         this.store.transaction((store) => {
             const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
@@ -844,7 +845,6 @@ export class FileSchedulerStoreAdapter {
             if (sessions === null || sessions === undefined
                 || binding === null || binding === undefined
                 || sessions.inFlight?.runId !== input.runId
-                || binding.runId !== input.runId
                 || session?.launchId !== input.launchId
                 || session.nativeSessionId !== input.nativeSessionId
                 || currentProviderConversation(binding).conversationId !== input.nativeSessionId
@@ -854,7 +854,8 @@ export class FileSchedulerStoreAdapter {
                 || !processingOwnsExactInitialDelivery(mailbox, input.taskId, input.runId, input.attemptId)) {
                 throw new AgentHostProviderTurnFenceError("Agent Host Provider Turn carries a stale durable writer fence. Release and reacquire Provider authority before retrying input.");
             }
-            const exactReplay = binding.turn?.attemptId === input.attemptId
+            const exactReplay = binding.turn?.runId === input.runId
+                && binding.turn.attemptId === input.attemptId
                 && binding.turn.authorityEpoch === input.authorityEpoch
                 && binding.turn.status === "submitting";
             if (!exactReplay && binding.turn !== null
@@ -863,6 +864,7 @@ export class FileSchedulerStoreAdapter {
                 throw new AgentHostProviderTurnFenceError("Provider Conversation already has an unsettled Turn.");
             }
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, beginProviderTurn(binding, {
+                runId: input.runId,
                 attemptId: input.attemptId,
                 authorityEpoch: input.authorityEpoch,
                 submittedAt: input.now.toISOString()
@@ -875,7 +877,7 @@ export class FileSchedulerStoreAdapter {
             const binding = sessions?.providerBinding;
             if (sessions === null || sessions === undefined
                 || binding === null || binding === undefined
-                || binding.runId !== input.runId
+                || binding.turn?.runId !== input.runId
                 || binding.turn?.attemptId !== input.attemptId) {
                 throw new Error("Agent Host Provider Turn submission is no longer current.");
             }
@@ -893,7 +895,6 @@ export class FileSchedulerStoreAdapter {
         const session = sessions?.sessions[input.agentId];
         const binding = sessions?.providerBinding;
         if (binding === null || binding === undefined
-            || binding.runId !== input.runId
             || session?.launchId !== input.launchId
             || session.nativeSessionId !== input.nativeSessionId
             || currentProviderConversation(binding).conversationId !== input.nativeSessionId)
@@ -1022,7 +1023,6 @@ export class FileSchedulerStoreAdapter {
                 const binding = sessions?.providerBinding;
                 if (sessions === null || sessions === undefined
                     || binding === null || binding === undefined
-                    || binding.runId !== input.executionRef.id
                     || binding.authority.owner !== "controller") {
                     throw new Error("Controller does not own the Provider writer authority.");
                 }
@@ -1034,6 +1034,7 @@ export class FileSchedulerStoreAdapter {
                     throw new Error("Provider input claim carries a stale Conversation/Activation fence.");
                 }
                 const next = beginProviderTurn(binding, {
+                    runId: input.executionRef.id,
                     attemptId: input.attemptId,
                     authorityEpoch: binding.authority.epoch,
                     submittedAt: input.now.toISOString()
@@ -1282,7 +1283,6 @@ export class FileSchedulerStoreAdapter {
             store.saveAgentRun(input.run);
             store.saveActiveAgentRun(input.run);
             store.saveWorkMailbox(claimed);
-            store.saveRole(input.task.id, updateRoleStatus(role, "running", input.now));
             bindTaskRoleRunInFlight(store, role, input.run, input.now);
             store.saveEvent(input.task.id, createTaskEvent(store.nextEventId(input.task.id), input.task.id, "run.dispatched", runLaunchEventPayload(input.run), input.now));
             if (input.wakeId !== undefined && input.wakeFromCursor !== undefined) {
@@ -1368,9 +1368,6 @@ export class FileSchedulerStoreAdapter {
                     markTaskRoleRunPushedInFlight(store, role, deliveryRun, input.now);
                 }
             }
-            if (role.status !== "running") {
-                store.saveRole(input.task.id, updateRoleStatus(role, "running", input.now));
-            }
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 const existing = store.getRoleSession(input.task.id, input.role.name);
                 const reservation = matchingPreparedRuntimeReservation(store, input);
@@ -1494,10 +1491,6 @@ export class FileSchedulerStoreAdapter {
                 routeRoleEvent(store, deliveryFailureEvent, input.roleName, terminal.purpose === "review" ? "review-failed" : "role-run-failed", input.now);
             }
             else {
-                const failedRole = store.getRole(input.taskId, input.roleName);
-                if (failedRole !== null) {
-                    store.saveRole(input.taskId, updateRoleStatus(failedRole, "failed", input.now));
-                }
                 store.saveLeaderFailure(recordLeaderFailure(input.taskId, session?.nativeSessionId ?? "(unregistered)", summary, input.now, store.getLeaderFailure(input.taskId)));
                 routeRoleEvent(store, deliveryFailureEvent, input.roleName, "leader-run-failed", input.now);
             }
@@ -1534,7 +1527,6 @@ export class FileSchedulerStoreAdapter {
             // Consume this failed delivery attempt. Releasing it would immediately
             // redispatch the same wake and manufacture another Leader Session.
             store.saveWorkMailbox(completeProcessing(mailbox, mailbox.processing.batchId));
-            store.saveRole(input.task.id, updateRoleStatus(role, "failed", input.now));
             breakTaskSessionIfPresent(store, input.task.id, role.name, active.effective.agentId, input.now);
             const failure = recordLeaderFailure(input.task.id, input.failure.nativeSessionId, input.failure.message, input.now, store.getLeaderFailure(input.task.id));
             store.saveLeaderFailure(failure);
@@ -1599,7 +1591,6 @@ export class FileSchedulerStoreAdapter {
                 }, input.now);
                 if (terminal.disposition !== "applied")
                     return "state-changed";
-                store.saveRole(task.id, updateRoleStatus(role, "exited", input.now));
                 stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
                 queueLeaderWakeup(store, task.id, wakeReason("review-failed"), input.now);
                 return "failed";
@@ -1639,7 +1630,6 @@ export class FileSchedulerStoreAdapter {
                 }
             }
             const leaderFailed = role.name === "leader";
-            store.saveRole(task.id, updateRoleStatus(role, leaderFailed ? "failed" : "exited", input.now));
             stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
             if (leaderFailed) {
                 const failure = recordLeaderFailure(task.id, input.session?.nativeSessionId ?? "(unregistered)", input.summary, input.now, store.getLeaderFailure(task.id));
@@ -1860,6 +1850,19 @@ export class FileSchedulerStoreAdapter {
         catch {
             return "obsolete";
         }
+        const providerTurn = sessions?.providerBinding?.turn;
+        const canonicalTurnId = sessions === null || sessions === undefined
+            ? input.turnId
+            : canonicalStructuredProviderTurnId(sessions, input.turnId, input.attemptId);
+        const recordedProviderTurn = input.runId !== undefined
+            && providerTurn?.runId === input.runId
+            && providerTurn.turnId === canonicalTurnId;
+        if (recordedProviderTurn) {
+            const run = this.store.getAgentRun(input.taskId, input.runId);
+            return run === null
+                ? "obsolete"
+                : run.pushedAt === undefined ? "deferred" : "apply";
+        }
         // A normal explicit CLI yield may precede its native Hook; that Hook still
         // owns the turn fact. A forced cleanup boundary or stopped process instead
         // makes the old generation obsolete.
@@ -1893,6 +1896,13 @@ export class FileSchedulerStoreAdapter {
             let sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName)
                 ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
             const canonicalTurnId = canonicalStructuredProviderTurnId(sessions, input.turnId, input.attemptId);
+            const providerTurn = sessions.providerBinding?.turn;
+            const recordedProviderTurn = input.runId !== undefined
+                && providerTurn?.runId === input.runId
+                && providerTurn.turnId === canonicalTurnId;
+            const observedRun = input.runId === undefined
+                ? null
+                : store.getAgentRun(input.taskId, input.runId);
             const existing = sessions.sessions[input.agentId];
             const owner = {
                 scope: "task",
@@ -1912,7 +1922,8 @@ export class FileSchedulerStoreAdapter {
                 && hasRecentTurnId(effectiveExisting.recentCompletedTurnIds, canonicalTurnId)) {
                 return { session: effectiveExisting, duplicate: true };
             }
-            if (sessions.inFlight === null
+            if (!recordedProviderTurn
+                && sessions.inFlight === null
                 && existing !== undefined
                 && (hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget(owner)))
                     || isObsoleteTerminalRuntimeRun(store, input))) {
@@ -1920,7 +1931,8 @@ export class FileSchedulerStoreAdapter {
             }
             // Classification is only an optimization. Revalidate the Run inside the
             // authoritative transaction before a Hook may claim a native identity.
-            if (sessions.inFlight !== null
+            if (!recordedProviderTurn
+                && sessions.inFlight !== null
                 && (input.runId === undefined
                     || sessions.inFlight.runId !== input.runId)) {
                 if (effectiveExisting === undefined) {
@@ -1928,7 +1940,9 @@ export class FileSchedulerStoreAdapter {
                 }
                 return { session: effectiveExisting, duplicate: false };
             }
-            if (sessions.inFlight !== null && sessions.inFlight.pushedAt === undefined) {
+            if (recordedProviderTurn
+                ? observedRun?.pushedAt === undefined
+                : sessions.inFlight !== null && sessions.inFlight.pushedAt === undefined) {
                 throw new Error("Runtime turn completion requires an independently committed transport receipt.");
             }
             const idleStatus = effectiveExisting?.status === "stopped"
@@ -2016,6 +2030,11 @@ export class FileSchedulerStoreAdapter {
                 recordObsoleteRuntimeEvent(store, input, "run-missing", now);
                 return { disposition: "obsolete", runId: input.runId };
             }
+            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+            if (sessions?.providerBinding?.turn?.runId === input.runId
+                && sessions.providerBinding.turn.turnId === input.nativeTurnId) {
+                store.saveTaskRoleSessionSet(settleStructuredProviderTurn(sessions, input.nativeTurnId, "failed", now));
+            }
             const summary = runtimeTurnFailureSummary(input);
             // Issue 04: a classified transient Provider failure keeps the exact Run
             // and Native Session and is retried in place instead of terminalizing.
@@ -2045,10 +2064,6 @@ export class FileSchedulerStoreAdapter {
                 roleName: input.roleName
             }), RUNTIME_CLEANUP_REQUIRED_REASON, now, [{ type: "task", id: input.taskId }]);
             const terminal = result.run;
-            const role = store.getRole(input.taskId, input.roleName);
-            if (role !== null) {
-                store.saveRole(input.taskId, updateRoleStatus(role, input.roleName === "leader" ? "failed" : "idle", now));
-            }
             const failureEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.turn-failed", {
                 eventId: input.eventId,
                 runId: input.runId,
@@ -2555,7 +2570,6 @@ export class FileSchedulerStoreAdapter {
             const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
             const run = store.getAgentRun(taskId, input.fence.runId);
             if (sessions === null || sessions.providerBinding === null || run === null
-                || sessions.providerBinding.runId !== input.fence.runId
                 || input.fence.conversationId === undefined) {
                 recordCanonicalObservationObsolete(store, input, "provider-binding-missing", now);
                 return "obsolete";
@@ -2747,10 +2761,6 @@ export class FileSchedulerStoreAdapter {
                     return "obsolete";
                 }
                 store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(updateRoleAgentSessionStatus(sessions, input.fence.agentId, "running", now), input, now));
-                const role = store.getRole(input.fence.taskId, input.fence.roleName);
-                if (role !== null && role.status !== "running") {
-                    store.saveRole(input.fence.taskId, updateRoleStatus(role, "running", now));
-                }
                 store.saveEvent(input.fence.taskId, createTaskEvent(store.nextEventId(input.fence.taskId), input.fence.taskId, "run.input-delivered", {
                     attemptId: inputDelivery.attemptId,
                     runId: active.id,
@@ -3339,10 +3349,6 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
         elapsedMs: String(Math.max(0, now.getTime() - Date.parse(retry.firstFailureAt)))
     }, now);
     store.saveEvent(run.taskId, exhaustionEvent);
-    const role = store.getRole(run.taskId, run.roleName);
-    if (role !== null) {
-        store.saveRole(run.taskId, updateRoleStatus(role, run.roleName === "leader" ? "failed" : "idle", now));
-    }
     if (run.roleName === "leader") {
         store.saveLeaderFailure(recordLeaderFailure(run.taskId, retry.nativeSessionId ?? "(unproven)", summary, now, store.getLeaderFailure(run.taskId)));
     }
@@ -3527,8 +3533,7 @@ function mapRole(store, role) {
         ...(binding.config.effort === undefined ? {} : { effort: binding.config.effort }),
         effective,
         workspace: role.workspace,
-        ...(workspace === undefined ? {} : { managedWorkspace: workspace }),
-        status: role.status
+        ...(workspace === undefined ? {} : { managedWorkspace: workspace })
     };
 }
 function taskSessionEffective(store, taskId, roleName, agentId, existing) {
@@ -3822,7 +3827,9 @@ function recordStructuredProviderAcceptance(sessions, input, now) {
     const turnId = input.fence.nativeTurnId;
     if (current === null || attemptId === undefined || turnId === undefined)
         return sessions;
-    if (current.turn?.attemptId === attemptId
+    if (current.turn === null || current.turn.runId !== input.fence.runId)
+        return sessions;
+    if (current.turn.attemptId === attemptId
         && ["accepted", "running", "completed", "failed", "cancelled"].includes(current.turn.status))
         return sessions;
     const binding = acceptProviderTurn(current, {
@@ -3855,7 +3862,6 @@ function bindOrSupersedeProviderRuntime(sessions, input, now, replacementBasis)
         return bindTaskRoleProviderRuntime(sessions, createProviderRuntimeBinding({
             providerNamespace: input.fence.driverId,
             accountScope: input.fence.agentId,
-            runId: sessions.inFlight.runId,
             conversationId,
             activationId,
             startedAt: sessions.inFlight.preparedAt
@@ -3893,7 +3899,7 @@ function rejectSubmittingProviderTurn(store, target, delivery, now, reason) {
     const binding = sessions?.providerBinding;
     if (sessions === null || sessions === undefined
         || binding === null || binding === undefined
-        || binding.runId !== delivery.executionRef.id
+        || binding.turn?.runId !== delivery.executionRef.id
         || binding.turn?.attemptId !== delivery.attemptId
         || (binding.turn.status !== "submitting"
             && binding.turn.status !== "delivery-unknown"))
@@ -3931,7 +3937,7 @@ function markSubmittingProviderTurnUnknown(store, target, delivery, now, reason)
     const binding = sessions?.providerBinding;
     if (sessions === null || sessions === undefined
         || binding === null || binding === undefined
-        || binding.runId !== delivery.executionRef.id
+        || binding.turn?.runId !== delivery.executionRef.id
         || binding.turn?.attemptId !== delivery.attemptId
         || binding.turn.status !== "submitting")
         return;

package/dist/executor/agentExecutor.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
-import { currentProviderActivation, endProviderActivation, rebindProviderRuntimeRun, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
+import { currentProviderActivation, endProviderActivation, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
     const base = {
@@ -14,7 +14,7 @@ export function createRoleSessionSet(owner, activeAgentId, now) {
         ? { ...base, schemaVersion: 3 }
         : {
             ...base,
-            schemaVersion: 6,
+            schemaVersion: 7,
             inFlight: null,
             providerBinding: null
         };
@@ -298,15 +298,14 @@ export function bindTaskRoleRun(set, fence, preparedAt, mode) {
         throw new Error("Task Role session set already has an in-flight Run.");
     }
     const timestamp = requireDate(preparedAt, "Task Role Run preparedAt");
-    // A fresh Session follows physical cleanup and does not inherit execution
-    // fences from the disposable old Conversation. Runtime events retain its
-    // audit evidence; the new Provider binds a fresh control identity when it is
-    // observed. Resume keeps the existing exact Conversation fence.
+    // A fresh Session follows physical cleanup and does not inherit runtime
+    // evidence from the disposable old Conversation. A resumed Session keeps
+    // that evidence unchanged here: claiming a durable Run is a workflow
+    // mutation, not a Provider operation. AgentHost binds the Conversation to
+    // this Run only when it can actually submit the next serialized Turn.
     const providerBinding = mode === "new"
         ? null
-        : set.providerBinding !== null
-            ? rebindProviderRuntimeRun(set.providerBinding, normalized.runId)
-            : null;
+        : set.providerBinding;
     const updated = {
         ...set,
         inFlight: { ...normalized, preparedAt: timestamp },
@@ -340,9 +339,6 @@ export function prepareTaskRoleRunRedispatch(set, fence, preparedAt) {
 export function bindTaskRoleProviderRuntime(set, binding, updatedAt) {
     validateRoleSessionSet(set);
     const normalized = validateProviderRuntimeBinding(binding);
-    if (set.inFlight === null || set.inFlight.runId !== normalized.runId) {
-        throw new Error("Provider Runtime Binding does not match the in-flight Run.");
-    }
     if (set.providerBinding !== null) {
         if (JSON.stringify(set.providerBinding) === JSON.stringify(normalized))
             return set;
@@ -358,7 +354,6 @@ export function updateTaskRoleProviderRuntime(set, binding, updatedAt) {
     validateRoleSessionSet(set);
     const normalized = validateProviderRuntimeBinding(binding);
     if (set.providerBinding === null
-        || normalized.runId !== set.providerBinding.runId
         || normalized.providerNamespace !== set.providerBinding.providerNamespace
         || normalized.accountScope !== set.providerBinding.accountScope) {
         throw new Error("Provider Runtime Binding identity cannot change in place.");
@@ -525,21 +520,15 @@ export function clearTaskRoleRun(set, fence, clearedAt) {
     return validateRoleSessionSet(updated);
 }
 /**
- * Applies an authoritative application-level Run terminal fact to the native
- * session fence. A later native Hook is only advisory and must not be required
- * to make the next Run dispatchable.
+ * Applies an authoritative application-level Run terminal fact to its exact
+ * delivery receipt. Provider lifecycle remains independent: only the matching
+ * native Turn boundary may move the Session from running to ready. AgentHost
+ * serializes a retained next delivery while that Turn is still active.
  */
 export function terminalizeTaskRoleRunSession(set, fence, terminalAt) {
     validateRoleSessionSet(set);
     const inFlight = set.inFlight;
-    let updated = inFlight === null
-        ? set
-        : clearTaskRoleRun(set, fence, terminalAt);
-    const session = updated.sessions[updated.activeAgentId];
-    if (session?.status === "running") {
-        updated = updateRoleAgentSessionStatus(updated, updated.activeAgentId, "ready", terminalAt);
-    }
-    return updated;
+    return inFlight === null ? set : clearTaskRoleRun(set, fence, terminalAt);
 }
 export function settleTaskRoleCompletion(set, expected, settledAt) {
     validateRoleSessionSet(set);
@@ -597,7 +586,7 @@ export function validateRoleSessionSet(set) {
         }
     }
     else {
-        if (set.schemaVersion !== 6) {
+        if (set.schemaVersion !== 7) {
             throw new Error("Task Role session set schema version is invalid.");
         }
         if (!Object.hasOwn(set, "inFlight")
@@ -637,9 +626,6 @@ export function validateRoleSessionSet(set) {
             throw new Error("Task Role in-flight Run Agent must be active.");
         }
         if (providerBinding !== null) {
-            if (inFlight !== null && providerBinding.runId !== inFlight.runId) {
-                throw new Error("Provider Runtime Binding must match the in-flight Run.");
-            }
             const session = taskSet.sessions[inFlight?.agentId ?? set.activeAgentId];
             if (session === undefined) {
                 throw new Error("Provider Runtime Binding has no active Role Agent session.");

package/dist/executor/fileRoleLaunchPlanner.js

@@ -608,8 +608,7 @@ export class FileRoleLaunchPlanner {
             role: {
                 name: role.name,
                 workspace: effectiveWorkspace,
-                ...(agentWorkspace === effectiveWorkspace ? {} : { cwd: agentWorkspace }),
-                ...(owner.scope === "task" ? { status: role.status } : {})
+                ...(agentWorkspace === effectiveWorkspace ? {} : { cwd: agentWorkspace })
             },
             launch: ordinaryConversationLaunch,
             session,
@@ -659,7 +658,7 @@ export class FileRoleLaunchPlanner {
     }
     #providerOwnedTurnForLaunch(taskId, roleName, runId) {
         const binding = this.store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding;
-        if (binding === null || binding === undefined || binding.runId !== runId)
+        if (binding === null || binding === undefined || binding.turn?.runId !== runId)
             return undefined;
         const turn = binding.turn;
         if (turn === null || !["accepted", "running"].includes(turn.status))

package/dist/lifecycle/exactRunTerminalization.js

@@ -2,7 +2,6 @@ import { isDeepStrictEqual } from "node:util";
 import { completeProcessing } from "../coordination/workMailbox.js";
 import { settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
 import { terminalizeTaskRoleRunSession } from "../executor/agentExecutor.js";
-import { updateRoleStatus } from "../role/role.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
 import { reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
 import { agentRunDeliveryReceiptId, failAgentRun, withYieldReceipt, yieldAgentRun } from "../run/agentRun.js";
@@ -265,7 +264,7 @@ export function retireExactActiveAgentRun(store, input, now) {
     const session = sessions?.sessions[input.agentId];
     const providerBinding = sessions?.providerBinding;
     const providerTurn = providerBinding?.turn;
-    const providerSettled = providerBinding?.runId === current.id
+    const providerSettled = providerTurn?.runId === current.id
         && (providerTurn?.status === "completed"
             || providerTurn?.status === "failed"
             || providerTurn?.status === "cancelled"
@@ -450,7 +449,6 @@ export function terminalizeExactTaskRun(store, input, now) {
     else {
         store.clearActiveAgentRun(input.taskId, input.roleName);
     }
-    store.saveRole(input.taskId, updateRoleStatus(role, "idle", now));
     if (sessions !== null) {
         store.saveTaskRoleSessionSet(terminalizeTaskRoleRunSession(sessions, {
             agentId: input.agentId,

package/dist/output/rolePresentation.js

@@ -23,7 +23,6 @@ export function renderRoleDetails(title, role, input) {
     const overview = [
         `  Kind             ${input.kind}`,
         `  Active Agent     ${role.activeAgentId}`,
-        ...("status" in role ? [`  Status           ${role.status}`] : []),
         `  Workspace        ${role.workspace}`,
         `  Desired launch   r${role.launchRevision}; Profile intent=${role.defaultAccess}`,
         `  Effective launch ${effective === undefined

package/dist/repository/taskWorkspacePreparer.js

@@ -2764,7 +2764,6 @@ function retireWorkspaceBoundSession(store, taskId, roleName, now) {
 }
 function canCorrectActiveWorkItemRoleWorkspaceHint(store, taskId, role, item, workspace) {
     if (role.taskId !== taskId
-        || role.status !== "running"
         || item.taskId !== taskId
         || item.assignee !== role.name
         || ["completed", "failed", "retired"].includes(item.status)