@zq-silk/yui 0.13.9 → 0.14.0

package/dist/lifecycle/{exactRunTerminalization.js → exactTurnTerminalization.js}

@@ -1,30 +1,27 @@
 import { isDeepStrictEqual } from "node:util";
 import { completeProcessing } from "../coordination/workMailbox.js";
-import { settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
-import { terminalizeTaskRoleRunSession } from "../executor/agentExecutor.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
 import { reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
-import { agentRunDeliveryReceiptId, failAgentRun, withYieldReceipt, yieldAgentRun } from "../run/agentRun.js";
-import { createYieldReceipt } from "../run/yieldReceipt.js";
+import { completeTurn, failTurn } from "../turn/turn.js";
 import { recordExecutionLaneResult, resolveExecutionGroup } from "../execution/executionGroup.js";
 import { isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.js";
-import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
+import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
+import { latestTurnDurableProgressAt } from "../scheduler/roleTurnStall.js";
 import { markTaskWakeConsumed } from "../scheduler/taskWake.js";
 import { workItemExecutionGroupById, updateWorkItemExecutionGroup } from "../workItem/workItem.js";
 /**
  * Validate every immutable identity and frozen Project head needed before a
- * review Run can settle any mailbox or Round state.  This is deliberately
+ * review Turn can settle any mailbox or Round state. This is deliberately
  * read-only: callers use it as the compare-and-swap fence immediately before
  * their aggregate mutation.
  */
-export function validateExactRunReviewRound(store, run, options = {}) {
-    if (run.purpose !== "review")
+export function validateExactTurnReviewRound(store, turn, options = {}) {
+    if (turn.purpose !== "review")
         return { disposition: "applied", round: null };
-    if (run.reviewRoundId === undefined) {
+    if (turn.reviewRoundId === undefined) {
         return { disposition: "obsolete", round: null, reason: "review-round-missing" };
     }
-    const round = store.getReviewRound(run.taskId, run.reviewRoundId);
+    const round = store.getReviewRound(turn.taskId, turn.reviewRoundId);
     if (round === null) {
         return { disposition: "obsolete", round: null, reason: "review-round-missing" };
     }
@@ -32,60 +29,60 @@ export function validateExactRunReviewRound(store, run, options = {}) {
         && round.status !== "pending" && round.status !== "running") {
         return { disposition: "obsolete", round, reason: "review-round-terminal" };
     }
-    const lane = round.executionGroup?.lanes.find(({ id }) => id === run.executionLaneId);
-    const exactReviewerRun = round.reviewerRunId === run.id || lane?.runId === run.id;
-    const exactReviewerRole = round.reviewerRoleName === run.roleName || lane?.roleName === run.roleName;
-    if (!exactReviewerRun
+    const lane = round.executionGroup?.lanes.find(({ id }) => id === turn.executionLaneId);
+    const exactReviewerTurn = round.reviewerTurnId === turn.id || lane?.turnId === turn.id;
+    const exactReviewerRole = round.reviewerRoleName === turn.roleName || lane?.roleName === turn.roleName;
+    if (!exactReviewerTurn
         || !exactReviewerRole
-        || round.workItemId !== run.workItemId
-        || round.reviewBaseCommit !== run.effective.reviewBaseCommit) {
+        || round.workItemId !== turn.workItemId
+        || round.reviewBaseCommit !== turn.effective.reviewBaseCommit) {
         return { disposition: "obsolete", round, reason: "review-round-mismatch" };
     }
     const laneWorkspaceRoot = lane?.workspace?.root;
-    if (run.workspace === undefined || round.workspace === undefined
-        || (laneWorkspaceRoot === undefined && !isDeepStrictEqual(run.workspace, round.workspace))
-        || (laneWorkspaceRoot !== undefined && run.workspace.root !== laneWorkspaceRoot)) {
+    if (turn.workspace === undefined || round.workspace === undefined
+        || (laneWorkspaceRoot === undefined && !isDeepStrictEqual(turn.workspace, round.workspace))
+        || (laneWorkspaceRoot !== undefined && turn.workspace.root !== laneWorkspaceRoot)) {
         return { disposition: "obsolete", round, reason: "review-workspace-mismatch" };
     }
-    const storedWorkspace = run.workspace.owner.type === "execution-lane"
-        ? store.getManagedWorkspace(run.workspace.owner)
-        : store.getReviewRoundWorkspace(run.taskId, round.id);
+    const storedWorkspace = turn.workspace.owner.type === "execution-lane"
+        ? store.getManagedWorkspace(turn.workspace.owner)
+        : store.getReviewRoundWorkspace(turn.taskId, round.id);
     if (storedWorkspace === null
-        || (run.workspace.owner.type !== "execution-lane"
+        || (turn.workspace.owner.type !== "execution-lane"
             && !isDeepStrictEqual(storedWorkspace, round.workspace))
-        || !isDeepStrictEqual(storedWorkspace, run.workspace)) {
+        || !isDeepStrictEqual(storedWorkspace, turn.workspace)) {
         return { disposition: "obsolete", round, reason: "review-workspace-drift" };
     }
-    if (run.workspace.owner.type !== "execution-lane") {
+    if (turn.workspace.owner.type !== "execution-lane") {
         if (storedWorkspace.owner.type !== "review-round"
-            || storedWorkspace.owner.taskId !== run.taskId
+            || storedWorkspace.owner.taskId !== turn.taskId
             || storedWorkspace.owner.reviewRoundId !== round.id) {
             return { disposition: "obsolete", round, reason: "review-workspace-owner-mismatch" };
         }
     }
-    if (run.workspace.owner.type === "execution-lane"
-        && (run.workspace.owner.purpose !== "review"
-            || run.workspace.owner.executionGroupId !== run.executionGroupId
-            || run.workspace.owner.executionLaneId !== run.executionLaneId
-            || run.workspace.owner.reviewRoundId !== round.id)) {
+    if (turn.workspace.owner.type === "execution-lane"
+        && (turn.workspace.owner.purpose !== "review"
+            || turn.workspace.owner.executionGroupId !== turn.executionGroupId
+            || turn.workspace.owner.executionLaneId !== turn.executionLaneId
+            || turn.workspace.owner.reviewRoundId !== round.id)) {
         return { disposition: "obsolete", round, reason: "review-lane-workspace-owner-mismatch" };
     }
-    if (run.workspace.owner.type === "execution-lane") {
+    if (turn.workspace.owner.type === "execution-lane") {
         if (lane === undefined
-            || lane.runId !== run.id
-            || lane.roleName !== run.roleName
-            || lane.workspace?.root !== run.workspace.root
-            || lane.workspace.writableProjectIds.length !== run.workspace.entries.length
-            || run.workspace.entries.some((entry) => (entry.access !== "write"
+            || lane.turnId !== turn.id
+            || lane.roleName !== turn.roleName
+            || lane.workspace?.root !== turn.workspace.root
+            || lane.workspace.writableProjectIds.length !== turn.workspace.entries.length
+            || turn.workspace.entries.some((entry) => (entry.access !== "write"
                 || !lane.workspace.writableProjectIds.includes(entry.projectId)))) {
             return { disposition: "obsolete", round, reason: "review-lane-workspace-lineage-mismatch" };
         }
     }
-    const task = store.getTask(run.taskId);
+    const task = store.getTask(turn.taskId);
     const taskScope = (round.scope ?? "work-item") === "task";
     const item = taskScope || round.workItemId === undefined
         ? null
-        : store.getWorkItem(run.taskId, round.workItemId);
+        : store.getWorkItem(turn.taskId, round.workItemId);
     if (!taskScope && item === null) {
         return { disposition: "obsolete", round, reason: "review-work-item-missing" };
     }
@@ -129,22 +126,22 @@ export function validateExactRunReviewRound(store, run, options = {}) {
     return { disposition: "applied", round };
 }
 /**
- * Atomically terminalizes the exact ReviewRound bound to a review AgentRun.
+ * Atomically terminalizes the exact ReviewRound bound to a review Turn.
  * The round must still be pending/running and its reviewer identity must match
- * the Run exactly. This is the sole review-round convergence primitive shared
- * by the exact Run terminalization path and the pre-delivery launch-failure
- * path: a failed review Run must never leave its Round stranded.
+ * the Turn exactly. This is the sole review-round convergence primitive shared
+ * by the exact Turn terminalization path and the pre-delivery launch-failure
+ * path: a failed review Turn must never leave its Round stranded.
  */
-export function terminalizeExactRunReviewRound(store, input, now) {
-    const validation = validateExactRunReviewRound(store, input.run);
+export function terminalizeExactTurnReviewRound(store, input, now) {
+    const validation = validateExactTurnReviewRound(store, input.turn);
     if (validation.disposition !== "applied" || validation.round === null) {
         return validation;
     }
     const reviewRound = validation.round;
-    let groupedRound = input.run.executionGroupId !== undefined
-        && input.run.executionLaneId !== undefined
+    let groupedRound = input.turn.executionGroupId !== undefined
+        && input.turn.executionLaneId !== undefined
         && reviewRound.executionGroup !== undefined
-        ? updateReviewExecutionGroup(reviewRound, recordExecutionLaneResult(reviewRound.executionGroup, input.run.executionLaneId, {
+        ? updateReviewExecutionGroup(reviewRound, recordExecutionLaneResult(reviewRound.executionGroup, input.turn.executionLaneId, {
             summary: input.outcome.summary,
             ...(input.reviewResult?.report === undefined ? {} : { report: input.reviewResult.report }),
             ...(input.reviewResult?.checks === undefined
@@ -168,14 +165,13 @@ export function terminalizeExactRunReviewRound(store, input, now) {
             ...(input.reviewResult?.gitSnapshot === undefined
                 ? {}
                 : { gitSnapshot: input.reviewResult.gitSnapshot })
-        }, input.outcome.status === "yielded" ? "completed" : "failed", now))
+        }, input.outcome.status, now))
         : reviewRound;
     if (input.settleFailedExecutionGroup === true
         && input.outcome.status === "failed"
         && groupedRound.executionGroup !== undefined
         && groupedRound.executionGroup.resolution === undefined
-        && groupedRound.executionGroup.lanes.every((lane) => (lane.status === "yielded"
-            || lane.status === "completed"
+        && groupedRound.executionGroup.lanes.every((lane) => (lane.status === "completed"
             || lane.status === "failed"
             || lane.status === "skipped"))) {
         groupedRound = updateReviewExecutionGroup(groupedRound, resolveExecutionGroup(groupedRound.executionGroup, {
@@ -195,7 +191,7 @@ export function terminalizeExactRunReviewRound(store, input, now) {
         store.saveReviewRound(input.taskId, groupedRound);
         return { disposition: "applied", round: groupedRound };
     }
-    const terminal = finishReviewRound(groupedRound, input.outcome.status === "yielded" ? "completed" : "failed", input.outcome.summary, now, input.reviewResult);
+    const terminal = finishReviewRound(groupedRound, input.outcome.status, input.outcome.summary, now, input.reviewResult);
     store.saveReviewRound(input.taskId, terminal);
     // Issue 06: a completed (semantic) Round feeds the finding ledger; a failed
     // execution attempt is skipped by the classifier and never creates findings.
@@ -205,17 +201,17 @@ export function terminalizeExactRunReviewRound(store, input, now) {
     return { disposition: "applied", round: terminal };
 }
 /**
- * Retire one stranded active Run only after its exact Provider Turn is
+ * Retire one stranded active Turn only after its exact Provider Turn is
  * terminal and every durable execution fence is quiet. The caller owns the
- * surrounding aggregate transaction so the Run, ReviewRound/Lane, mailbox,
+ * surrounding aggregate transaction so the Turn, ReviewRound/Lane, mailbox,
  * Session, and append-only retirement record commit together.
  */
-export function retireExactActiveAgentRun(store, input, now) {
-    const current = store.getAgentRun(input.taskId, input.runId);
+export function retireExactActiveTurn(store, input, now) {
+    const current = store.getTurn(input.taskId, input.turnId);
     const stateChanged = (reason) => ({
         disposition: "state-changed",
-        run: current,
-        ...(current === null ? {} : { progressAt: latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId)?.progressAt }),
+        turn: current,
+        ...(current === null ? {} : { progressAt: latestTurnDurableProgressAt(store, input.taskId, input.roleName, input.turnId)?.progressAt }),
         reason
     });
     const task = store.getTask(input.taskId);
@@ -224,22 +220,22 @@ export function retireExactActiveAgentRun(store, input, now) {
     if (task.status !== "active")
         return stateChanged("task-terminal");
     if (current === null)
-        return stateChanged("run-missing");
+        return stateChanged("turn-missing");
     if (current.status !== "active")
-        return stateChanged("run-terminal");
+        return stateChanged("turn-terminal");
     if (current.taskId !== input.taskId || current.roleName !== input.roleName) {
-        return stateChanged("run-owner-mismatch");
+        return stateChanged("turn-owner-mismatch");
     }
     if (current.effective.agentId !== input.agentId
         || current.effective.adapterId !== input.adapterId) {
-        return stateChanged("run-launch-identity-mismatch");
+        return stateChanged("turn-launch-identity-mismatch");
     }
     const active = current.executionGroupId !== undefined && current.executionLaneId !== undefined
-        ? store.getActiveExecutionLaneRun(input.taskId, current.executionGroupId, current.executionLaneId)
-        : store.getActiveAgentRun(input.taskId, input.roleName);
+        ? store.getActiveExecutionLaneTurn(input.taskId, current.executionGroupId, current.executionLaneId)
+        : store.getActiveTurn(input.taskId, input.roleName);
     if (active?.id !== current.id)
-        return stateChanged("active-run-mismatch");
-    const progress = latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId);
+        return stateChanged("active-turn-mismatch");
+    const progress = latestTurnDurableProgressAt(store, input.taskId, input.roleName, input.turnId);
     if (progress === null)
         return stateChanged("progress-unavailable");
     if (progress.progressAt !== input.expectedProgressAt) {
@@ -250,21 +246,16 @@ export function retireExactActiveAgentRun(store, input, now) {
         taskId: input.taskId,
         roleName: input.roleName,
         agentId: input.agentId,
-        runId: input.runId,
-        receiptId: agentRunDeliveryReceiptId(current),
+        turnId: input.turnId,
         ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
         ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
         settleFailedExecutionGroup: true,
-        outcome: { status: "failed", summary: input.reason }
+        outcome: { status: "failed", summary: input.reason, failureReason: "missing-result" }
     };
-    if (!matchesSessionFence(sessions, terminalInput)
-        || !matchesLaunchFence(store, sessions, terminalInput)) {
-        return stateChanged("session-or-launch-fence-mismatch");
-    }
     const session = sessions?.sessions[input.agentId];
     const providerBinding = sessions?.providerBinding;
     const providerTurn = providerBinding?.turn;
-    const providerSettled = providerTurn?.runId === current.id
+    const providerSettled = managedProviderTurnId(providerTurn) === current.id
         && (providerTurn?.status === "completed"
             || providerTurn?.status === "failed"
             || providerTurn?.status === "cancelled"
@@ -272,107 +263,59 @@ export function retireExactActiveAgentRun(store, input, now) {
     if (session?.status === "active" && !providerSettled) {
         return {
             disposition: "blocked",
-            run: current,
+            turn: current,
             progressAt: progress.progressAt,
             reason: "runtime-not-terminal"
         };
     }
-    const terminal = terminalizeExactTaskRun(store, terminalInput, now);
-    if (terminal.disposition !== "applied" || terminal.run === null) {
+    const terminal = terminalizeExactTaskTurn(store, terminalInput, now);
+    if (terminal.disposition !== "applied" || terminal.turn === null) {
         return stateChanged(terminal.reason ?? "terminalization-fence-mismatch");
     }
     return {
         disposition: "applied",
-        run: terminal.run,
+        turn: terminal.turn,
         progressAt: progress.progressAt
     };
 }
 /**
  * Applies one exact application-level terminal fact inside the caller's
- * FileTaskStore transaction. All caller-owned outcome records can therefore
+ * TaskStore transaction. All caller-owned outcome records can therefore
  * be saved in the same aggregate commit.
  */
-export function terminalizeExactTaskRun(store, input, now) {
-    const run = store.getAgentRun(input.taskId, input.runId);
-    if (run === null)
-        return obsolete(null, "run-missing");
-    if (run.status !== "active")
-        return obsolete(run, "run-terminal");
-    if (run.taskId !== input.taskId || run.roleName !== input.roleName) {
-        return obsolete(run, "run-owner-mismatch");
-    }
-    if (run.effective.agentId !== input.agentId) {
-        return obsolete(run, "run-agent-mismatch");
+export function terminalizeExactTaskTurn(store, input, now) {
+    const turn = store.getTurn(input.taskId, input.turnId);
+    if (turn === null)
+        return obsolete(null, "turn-missing");
+    if (turn.status !== "active")
+        return obsolete(turn, "turn-terminal");
+    if (turn.taskId !== input.taskId || turn.roleName !== input.roleName) {
+        return obsolete(turn, "turn-owner-mismatch");
+    }
+    if (turn.effective.agentId !== input.agentId) {
+        return obsolete(turn, "turn-agent-mismatch");
     }
     const role = store.getRole(input.taskId, input.roleName);
     if (role === null)
-        return obsolete(run, "role-missing");
-    const active = run.executionGroupId !== undefined && run.executionLaneId !== undefined
-        ? store.getActiveExecutionLaneRun(input.taskId, run.executionGroupId, run.executionLaneId)
-        : store.getActiveAgentRun(input.taskId, input.roleName);
-    if (active?.id !== run.id)
-        return obsolete(run, "active-run-mismatch");
+        return obsolete(turn, "role-missing");
+    const active = turn.executionGroupId !== undefined && turn.executionLaneId !== undefined
+        ? store.getActiveExecutionLaneTurn(input.taskId, turn.executionGroupId, turn.executionLaneId)
+        : store.getActiveTurn(input.taskId, input.roleName);
+    if (active?.id !== turn.id)
+        return obsolete(turn, "active-turn-mismatch");
     const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-    if (!matchesSessionFence(sessions, input)) {
-        return obsolete(run, "session-fence-mismatch");
-    }
-    if (!matchesLaunchFence(store, sessions, input)) {
-        return obsolete(run, "launch-fence-mismatch");
-    }
-    if (input.settleFailedExecutionGroup !== true
-        && runOwnsBlockingProviderContinuation(store.listEvents(input.taskId), {
-            taskId: run.taskId,
-            roleName: run.roleName,
-            runId: run.id,
-            agentId: run.effective.agentId
-        })) {
-        return obsolete(run, "provider-continuation-writer-owned");
-    }
     // Validate the exact ReviewRound, Candidate, stored workspace, and frozen
     // Project heads before any mailbox or Round write.
-    const reviewValidation = validateExactRunReviewRound(store, run);
+    const reviewValidation = validateExactTurnReviewRound(store, turn);
     if (reviewValidation.disposition !== "applied") {
-        return obsolete(run, reviewValidation.reason ?? "review-round-mismatch");
-    }
-    const roleTarget = {
-        kind: "role",
-        taskId: input.taskId,
-        roleName: input.roleName
-    };
-    if (input.mailboxDisposition === "discard") {
-        store.removeWorkMailbox(roleTarget);
-    }
-    else {
-        // For review Runs the mailbox must carry an exact pending or processing
-        // entry for this Run: an absent or unrelated mailbox means the review
-        // dispatch was never recorded and the terminalization must fail closed.
-        // Execution/Leader Runs keep the historical absent-is-clean behavior so
-        // direct Leader completion and normal execution are unaffected.
-        const isReview = run.purpose === "review";
-        const mailbox = store.getWorkMailbox(roleTarget);
-        const processing = mailbox?.processing;
-        if (mailbox !== null && processing !== null && processing !== undefined) {
-            if (processing.executionRef === undefined
-                || processing.executionRef.type !== "run"
-                || processing.executionRef.taskId !== run.taskId
-                || processing.executionRef.id !== run.id) {
-                return obsolete(run, "mailbox-busy");
-            }
-            store.saveWorkMailbox(completeProcessing(mailbox, processing.batchId));
-        }
-        else {
-            const mailboxSettlement = settleExactWorkExecution(store, roleTarget, { type: "run", taskId: run.taskId, id: run.id });
-            if (mailboxSettlement === "absent" && isReview && run.deliveredAt === undefined) {
-                return obsolete(run, "review-mailbox-missing");
-            }
-        }
+        return obsolete(turn, reviewValidation.reason ?? "review-round-mismatch");
     }
-    // All Run, active-pointer, Session, launch, and mailbox fences have passed.
-    // Only now may the exact ReviewRound be terminalized alongside the Run so a
-    // stale fence never leaves a Round written while the Run stays active.
-    const reviewRoundTerminalization = terminalizeExactRunReviewRound(store, {
+    // All Turn, active-pointer, Session, launch, and mailbox fences have passed.
+    // Only now may the exact ReviewRound be terminalized alongside the Turn so a
+    // stale fence never leaves a Round written while the Turn stays active.
+    const reviewRoundTerminalization = terminalizeExactTurnReviewRound(store, {
         taskId: input.taskId,
-        run,
+        turn,
         outcome: input.outcome,
         reviewResult: input.reviewResult,
         ...(input.settleFailedExecutionGroup === undefined
@@ -380,38 +323,21 @@ export function terminalizeExactTaskRun(store, input, now) {
             : { settleFailedExecutionGroup: input.settleFailedExecutionGroup })
     }, now);
     if (reviewRoundTerminalization.disposition !== "applied") {
-        return obsolete(run, reviewRoundTerminalization.reason ?? "review-round-mismatch");
-    }
-    const terminal = input.outcome.status === "yielded"
-        ? withYieldReceipt(yieldAgentRun(run, input.outcome.summary, now), createYieldReceipt(input.taskId, input.runId, {
-            status: "yielded",
-            summary: input.outcome.summary,
-            ...(input.reviewResult === undefined
-                ? {}
-                : {
-                    reviewResult: {
-                        ...(input.reviewResult.report === undefined ? {} : { report: input.reviewResult.report }),
-                        ...(input.reviewResult.checks === undefined ? {} : { checks: input.reviewResult.checks }),
-                        ...(input.reviewResult.findings === undefined ? {} : { findings: input.reviewResult.findings }),
-                        ...(input.reviewResult.evidence === undefined ? {} : { evidence: input.reviewResult.evidence }),
-                        ...(input.reviewResult.evidenceCommit === undefined ? {} : { evidenceCommit: input.reviewResult.evidenceCommit }),
-                        ...(input.reviewResult.gitSnapshot === undefined ? {} : { gitSnapshot: input.reviewResult.gitSnapshot }),
-                        ...(input.reviewResult.deltaDisposition === undefined ? {} : { deltaDisposition: input.reviewResult.deltaDisposition }),
-                        ...(input.reviewResult.deltaReasoning === undefined ? {} : { deltaReasoning: input.reviewResult.deltaReasoning })
-                    }
-                })
-        }, now))
-        : failAgentRun(run, input.outcome.summary, now);
-    if (run.executionGroupId !== undefined
-        && run.executionLaneId !== undefined
-        && run.purpose === "execution"
-        && run.workItemId !== undefined) {
-        const item = store.getWorkItem(input.taskId, run.workItemId);
+        return obsolete(turn, reviewRoundTerminalization.reason ?? "review-round-mismatch");
+    }
+    const terminal = input.outcome.status === "completed"
+        ? completeTurn(turn, input.outcome.summary, now, input.outcome.provider)
+        : failTurn(turn, input.outcome.failureReason ?? "runtime-failed", input.outcome.summary, now, input.outcome.provider);
+    if (turn.executionGroupId !== undefined
+        && turn.executionLaneId !== undefined
+        && turn.purpose === "execution"
+        && turn.workItemId !== undefined) {
+        const item = store.getWorkItem(input.taskId, turn.workItemId);
         const group = item === null
             ? undefined
-            : workItemExecutionGroupById(item, run.executionGroupId);
+            : workItemExecutionGroupById(item, turn.executionGroupId);
         if (item !== null && group !== undefined) {
-            let grouped = recordExecutionLaneResult(group, run.executionLaneId, {
+            let grouped = recordExecutionLaneResult(group, turn.executionLaneId, {
                 summary: input.outcome.summary,
                 ...(input.reviewResult?.report === undefined ? {} : { report: input.reviewResult.report }),
                 ...(input.reviewResult?.checks === undefined ? {} : { checks: input.reviewResult.checks }),
@@ -419,12 +345,11 @@ export function terminalizeExactTaskRun(store, input, now) {
                 ...(input.reviewResult?.evidence === undefined ? {} : { evidence: input.reviewResult.evidence }),
                 ...(input.reviewResult?.evidenceCommit === undefined ? {} : { evidenceCommit: input.reviewResult.evidenceCommit }),
                 ...(input.reviewResult?.gitSnapshot === undefined ? {} : { gitSnapshot: input.reviewResult.gitSnapshot })
-            }, input.outcome.status === "yielded" ? "completed" : "failed", now);
+            }, input.outcome.status, now);
             if (input.settleFailedExecutionGroup === true
                 && input.outcome.status === "failed"
                 && grouped.resolution === undefined
-                && grouped.lanes.every((lane) => (lane.status === "yielded"
-                    || lane.status === "completed"
+                && grouped.lanes.every((lane) => (lane.status === "completed"
                     || lane.status === "failed"
                     || lane.status === "skipped"))) {
                 grouped = resolveExecutionGroup(grouped, {
@@ -435,63 +360,22 @@ export function terminalizeExactTaskRun(store, input, now) {
             store.saveWorkItem(input.taskId, updateWorkItemExecutionGroup(item, grouped, now));
         }
     }
-    store.saveAgentRun(terminal);
+    store.saveTurn(terminal);
     if (terminal.roleName === "leader") {
         const wake = store.listTaskWakes(input.taskId)
-            .find((candidate) => candidate.runId === terminal.id && candidate.status === "dispatched");
+            .find((candidate) => candidate.turnId === terminal.id && candidate.status === "dispatched");
         if (wake !== undefined) {
             store.saveTaskWake(input.taskId, markTaskWakeConsumed(wake, now));
         }
     }
     if (terminal.executionGroupId !== undefined && terminal.executionLaneId !== undefined) {
-        store.clearActiveExecutionLaneRun(input.taskId, terminal.executionGroupId, terminal.executionLaneId);
+        store.clearActiveExecutionLaneTurn(input.taskId, terminal.executionGroupId, terminal.executionLaneId);
     }
     else {
-        store.clearActiveAgentRun(input.taskId, input.roleName);
-    }
-    if (sessions !== null) {
-        store.saveTaskRoleSessionSet(terminalizeTaskRoleRunSession(sessions, {
-            agentId: input.agentId,
-            runId: input.runId,
-            receiptId: input.receiptId
-        }, now));
+        store.clearActiveTurn(input.taskId, input.roleName);
     }
     settleLaunchReservation(store, sessions, input);
-    return { disposition: "applied", run: terminal };
-}
-function matchesSessionFence(sessions, input) {
-    if (sessions === null)
-        return input.nativeSessionId === undefined;
-    if (sessions.activeAgentId !== input.agentId)
-        return false;
-    const session = sessions.sessions[input.agentId];
-    if (input.nativeSessionId !== undefined) {
-        if (session?.nativeSessionId !== input.nativeSessionId)
-            return false;
-    }
-    const inFlight = sessions.inFlight;
-    return inFlight === null || (inFlight.agentId === input.agentId
-        && inFlight.runId === input.runId
-        && inFlight.receiptId === input.receiptId);
-}
-function matchesLaunchFence(store, sessions, input) {
-    // A resumed Run shares the native Provider Session whose process environment
-    // was created for an earlier Run. Once that exact native Session has passed
-    // matchesSessionFence, its immutable per-launch environment is not a second
-    // Run identity. Opaque hosts still require the launch fence below.
-    if (input.nativeSessionId !== undefined)
-        return true;
-    if (input.launchId === undefined)
-        return true;
-    const session = sessions?.sessions[input.agentId];
-    if (session?.launchId === input.launchId)
-        return true;
-    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget({
-        scope: "task",
-        taskId: input.taskId,
-        roleName: input.roleName
-    }));
-    return isRuntimeLaunchReservation(mailbox?.processing, input.launchId);
+    return { disposition: "applied", turn: terminal };
 }
 function settleLaunchReservation(store, sessions, input) {
     const target = runtimeLifecycleTarget({
@@ -515,6 +399,6 @@ function settleLaunchReservation(store, sessions, input) {
         store.saveWorkMailbox(settled);
     }
 }
-function obsolete(run, reason) {
-    return { disposition: "obsolete", run, reason };
+function obsolete(turn, reason) {
+    return { disposition: "obsolete", turn, reason };
 }

package/dist/message/message.js

@@ -12,9 +12,9 @@ export function createTaskMessage(id, taskId, body, kind, author, now, context =
         ...(context.wakePolicy === undefined
             ? {}
             : { wakePolicy: context.wakePolicy }),
-        ...(context.runId === undefined
+        ...(context.turnId === undefined
             ? {}
-            : { runId: requireSafeIdentity(context.runId, "Message Run id") }),
+            : { turnId: requireSafeIdentity(context.turnId, "Message Turn id") }),
         ...(context.workItemId === undefined
             ? {}
             : { workItemId: requireSafeIdentity(context.workItemId, "Message Work item id") }),
@@ -43,16 +43,16 @@ export function validateTaskMessage(message) {
         && message.kind !== "operator") {
         throw new Error("Message wakePolicy is only valid for user/operator messages.");
     }
-    if (message.runId !== undefined)
-        requireSafeIdentity(message.runId, "Message Run id");
+    if (message.turnId !== undefined)
+        requireSafeIdentity(message.turnId, "Message Turn id");
     if (message.workItemId !== undefined) {
         validateTaskRecordReference({
             taskId: message.taskId,
             localId: message.workItemId
         }, "workItem");
     }
-    if (message.runId !== undefined) {
-        validateTaskRecordReference({ taskId: message.taskId, localId: message.runId }, "agentRun");
+    if (message.turnId !== undefined) {
+        validateTaskRecordReference({ taskId: message.taskId, localId: message.turnId }, "turn");
     }
     if (typeof message.createdAt !== "string" || Number.isNaN(Date.parse(message.createdAt))) {
         throw new Error("Message createdAt is invalid.");