@zq-silk/yui 0.13.9 → 0.14.0

package/dist/commands/taskContextCommand.js

@@ -1,7 +1,7 @@
 import { taskNotFound, usageError } from "../errors/cliError.js";
 import { taskMessageAuthorLabel } from "../message/message.js";
 import { formatTimestamp } from "../output/timePresentation.js";
-import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
+import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectNextAction } from "../task/nextAction.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
@@ -43,7 +43,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             }))
         ].filter((mailbox) => mailbox !== null);
         const events = reader.listEvents(task.id);
-        const agentRuns = chronological(operationalTaskRecords(reader.listAgentRuns(task.id), events, "agent-run"));
+        const turns = chronological(operationalTaskRecords(reader.listTurns(task.id), events, "turn"));
         const reviewRounds = chronological(reader.listReviewRounds(task.id));
         const reviewConfig = reader.getReviewConfig();
         const changeSets = chronological(reader.listChangeSets(task.id));
@@ -61,7 +61,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
                 store: reader,
                 task,
                 roles,
-                runs: agentRuns,
+                turns,
                 rounds: reviewRounds,
                 reviewConfig,
                 currentCandidate: currentTaskReviewCandidate
@@ -75,7 +75,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             roleSessionSets,
             coordinationMailboxes,
             workItems,
-            agentRuns,
+            turns,
             reviewRounds,
             changeSets,
             integrations,
@@ -91,13 +91,13 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             })
         };
     });
-    const { task, execution, reviewConfig, reviewDecision, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, workItems, agentRuns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
+    const { task, execution, reviewConfig, reviewDecision, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, workItems, turns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
     const timeZone = store.getConfig().timeZone;
     const displayedActiveDecisions = activeDecisions.slice(-RECENT_RECORD_LIMIT);
     const displayedWorkItems = currentAndRecentWorkItems(workItems);
     const displayedOpenInputRequests = openInputRequests.slice(-RECENT_RECORD_LIMIT);
     const displayedResolvedInputRequests = resolvedInputRequests.slice(-RECENT_RECORD_LIMIT);
-    const displayedActiveRuns = execution.activeRuns;
+    const displayedActiveTurns = execution.activeTurns;
     const executionGroupsById = new Map(execution.executionGroups.map((group) => [
         group.groupId,
         group
@@ -141,10 +141,10 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         `  Attention: ${execution.attention.length === 0
             ? "none"
             : execution.attention.map(({ kind, owner }) => `${kind}/${owner}`).join(", ")}`,
-        `  Active AgentRuns (${displayedActiveRuns.length}):`,
-        ...(displayedActiveRuns.length === 0
+        `  Active Turns (${displayedActiveTurns.length}):`,
+        ...(displayedActiveTurns.length === 0
             ? ["    None."]
-            : displayedActiveRuns.map((run) => (`    ${run.roleName}: ${run.id} [${run.status}/${run.purpose}; ${run.delivered ? "accepted" : "delivery-pending"}${run.workItemId === undefined ? "" : `; work-item=${run.workItemId}`}${run.reviewRoundId === undefined ? "" : `; review-round=${run.reviewRoundId}`}${run.executionGroupId === undefined ? "" : `; group=${run.executionGroupId}`}${run.executionLaneId === undefined ? "" : `; lane=${run.executionLaneId}`}]`))),
+            : displayedActiveTurns.map((run) => (`    ${run.roleName}: ${run.id} [${run.status}/${run.purpose}; ${`provider-${run.providerSession}`}${run.workItemId === undefined ? "" : `; work-item=${run.workItemId}`}${run.reviewRoundId === undefined ? "" : `; review-round=${run.reviewRoundId}`}${run.executionGroupId === undefined ? "" : `; group=${run.executionGroupId}`}${run.executionLaneId === undefined ? "" : `; lane=${run.executionLaneId}`}]`))),
         "Observability:",
         `  DAG: ${observability.dag.nodes.length} node(s), ${observability.dag.edges.length} edge(s); ready=${observability.dag.readyIds.join(", ") || "none"}; blocked=${observability.dag.blockedIds.join(", ") || "none"}`,
         `  Cost: tokens=${resourceUsageLabel(observability.cost.tokens, undefined, observability.cost.tokensObservable)}; tools=${resourceUsageLabel(observability.cost.toolCalls, undefined, observability.cost.toolCallsObservable)}; wall=${observability.cost.wallClockSeconds}s; lanes=${observability.cost.laneCount}; groups=${observability.cost.groupCount}; retries=${observability.cost.retryCount}; marginal-value=unavailable`,
@@ -200,7 +200,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         `  Reviewer slots: ${reviewDecision.reviewers.length === 0
             ? "none configured"
             : reviewDecision.reviewers.map((reviewer) => (`${reviewer.reviewerRoleName}=${reviewer.status}`
-                + `${reviewer.activeRunId === undefined ? "" : `(${reviewer.activeRunId})`}`)).join(", ")}`,
+                + `${reviewer.activeTurnId === undefined ? "" : `(${reviewer.activeTurnId})`}`)).join(", ")}`,
         `  Accepted baseline: ${reviewDecision.latestAcceptedBaseline === null
             ? "none"
             : `${reviewDecision.latestAcceptedBaseline.reviewRoundId}`
@@ -242,14 +242,14 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             ? ["  None."]
             : roles.flatMap((role) => {
                 const binding = role.agentBindings[role.activeAgentId];
-                const activeRun = agentRuns.find((run) => (run.roleName === role.name && run.status === "active"));
+                const activeTurn = turns.find((run) => (run.roleName === role.name && run.status === "active"));
                 const sessions = roleSessionSets.find((set) => set.owner.roleName === role.name);
                 const activeSession = sessions?.sessions[sessions.activeAgentId];
-                const effective = activeRun?.effective ?? activeSession?.effective;
-                const effectiveSource = activeRun === undefined ? "Session" : "Run";
+                const effective = activeTurn?.effective ?? activeSession?.effective;
+                const effectiveSource = activeTurn === undefined ? "Session" : "Turn";
                 const creation = [...events].reverse().find((event) => (event.type === "role.added" && event.payload.role === role.name));
                 return [
-                    `  ${role.name} [${activeRun === undefined ? "idle" : "running"}]: ${role.activeAgentId}/${binding.adapterId}`,
+                    `  ${role.name} [${activeTurn === undefined ? "idle" : "running"}]: ${role.activeAgentId}/${binding.adapterId}`,
                     `    Desired: r${role.launchRevision}; Profile intent: ${role.defaultAccess}; Model: ${binding.config.model ?? "default"}; effort: ${binding.config.effort ?? "default"}; permission: ${binding.config.permission.strategy}`,
                     `    Effective: ${effective === undefined
                         ? "not started"
@@ -274,8 +274,8 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         ...(displayedWorkItems.length === 0
             ? ["  None."]
             : displayedWorkItems.flatMap((item) => {
-                const itemRuns = agentRuns.filter((run) => run.workItemId === item.id);
-                const latestRun = itemRuns.at(-1);
+                const itemRuns = turns.filter((run) => run.workItemId === item.id);
+                const latestTurn = itemRuns.at(-1);
                 return [
                     `  ${item.id} [${item.status}]: ${compactText(item.title)}`,
                     `    Objective: ${compactText(item.objective)}`,
@@ -294,7 +294,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
                     ...(item.candidates.length === 0
                         ? []
                         : item.candidates.flatMap((candidate) => [
-                            `    Candidate ${candidate.sequence}: ${candidate.id}${item.status === "awaiting_acceptance" && candidate === item.candidates.at(-1) ? " [current]" : ""} (${candidate.source.type === "run" ? candidate.source.runId : "direct"})`,
+                            `    Candidate ${candidate.sequence}: ${candidate.id}${item.status === "awaiting_acceptance" && candidate === item.candidates.at(-1) ? " [current]" : ""} (${candidate.source.type === "turn" ? candidate.source.turnId : "direct"})`,
                             `      Review policy: ${candidate.reviewPolicy === undefined ? "none" : `${candidate.reviewPolicy.roleName} (${candidate.reviewPolicy.trigger})`}`,
                             `      Task-final contract: ${candidate.taskFinalReviewContract === undefined
                                 ? "none"
@@ -304,14 +304,14 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
                                 : `${candidate.gitSnapshot.reviewBaseCommit} (${candidate.gitSnapshot.projects.length} Projects)`}`,
                             `      Summary: ${compactText(candidate.summary)}`
                         ])),
-                    ...(latestRun === undefined
-                        ? ["    AgentRuns: none."]
+                    ...(latestTurn === undefined
+                        ? ["    Turns: none."]
                         : [
-                            `    AgentRuns: ${itemRuns.length}; latest ${latestRun.id} [${latestRun.status}] ${latestRun.effective.agentId}/${latestRun.effective.adapterId} · effective r${latestRun.effective.sourceDesiredRevision}/${latestRun.effective.profileAccess}/${latestRun.effective.permission.strategy}`,
-                            `      Assignment: ${latestRun.assignment.action}${latestRun.assignment.directive === undefined ? "" : ` · ${compactText(latestRun.assignment.directive)}`}`,
-                            ...(latestRun.summary === undefined
+                            `    Turns: ${itemRuns.length}; latest ${latestTurn.id} [${latestTurn.status}] ${latestTurn.effective.agentId}/${latestTurn.effective.adapterId} · effective r${latestTurn.effective.sourceDesiredRevision}/${latestTurn.effective.profileAccess}/${latestTurn.effective.permission.strategy}`,
+                            `      Assignment: ${latestTurn.inputs[0].input.source.channel}${latestTurn.inputs[0].input.directive === undefined ? "" : ` · ${compactText(latestTurn.inputs[0].input.directive)}`}`,
+                            ...(latestTurn.result === undefined
                                 ? []
-                                : [`      Summary: ${compactText(latestRun.summary)}`])
+                                : [`      Summary: ${compactText(latestTurn.result.output)}`])
                         ]),
                     ...renderReviewRounds(reviewRounds.filter((round) => round.workItemId === item.id), executionGroupsById)
                 ];
@@ -320,21 +320,21 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         "Task-final reviews:",
         ...renderReviewRounds(reviewRounds.filter((round) => (round.scope ?? "work-item") === "task"), executionGroupsById),
         "",
-        ...recentSection("AgentRuns", agentRuns, (run) => [
+        ...recentSection("Turns", turns, (run) => [
             `  ${run.id} [${run.status}/${run.purpose}] ${run.roleName} via ${run.effective.agentId}/${run.effective.adapterId}`,
             `    Effective: r${run.effective.sourceDesiredRevision}; Profile intent: ${run.effective.profileAccess}; permission: ${run.effective.permission.strategy}; model: ${run.effective.model ?? "default"}; effort: ${run.effective.effort ?? "default"}`,
-            ...(run.summary === undefined ? [] : [`    Result: ${compactText(run.summary)}`])
+            ...(run.result === undefined ? [] : [`    Result: ${compactText(run.result.output)}`])
         ]),
         "",
         "Runtime health:",
         ...(() => {
-            const stalled = agentRuns.filter((run) => (run.status === "active" && isRoleRunStalled(events, run.id)));
+            const stalled = turns.filter((run) => (run.status === "active" && isRoleTurnStalled(events, run.id)));
             return stalled.length === 0
-                ? ["  No needs-attention Runs."]
+                ? ["  No needs-attention Turns."]
                 : stalled.flatMap((run) => [
                     `  ${run.id} [needs-attention] ${run.roleName}`,
                     `    Durable progress: ${formatTimestamp(latestStallProgressAt(events, run.id) ?? run.updatedAt, timeZone)}`,
-                    `    Cause: ${latestStallKind(events, run.id)} with no new semantic Run evidence in the stall window`,
+                    `    Cause: ${latestStallKind(events, run.id)} with no new semantic Turn evidence in the stall window`,
                     "    Next: inspect Task context/Role status; no automatic retry or Session replacement was performed."
                 ]);
         })(),
@@ -401,18 +401,17 @@ function renderCoordinationMailbox(mailbox) {
     const target = mailbox.target.kind === "role"
         ? `role/${mailbox.target.roleName}`
         : mailbox.target.kind;
-    const pending = [mailbox.pending.userCorrection, mailbox.pending.normal]
-        .filter((batch) => batch !== null);
+    const pending = mailbox.pending === null ? [] : [mailbox.pending];
     return [
-        `  ${target}: cursor normal=${mailbox.pending.cursors.normal}, correction=${mailbox.pending.cursors.userCorrection}; next=${mailbox.nextSequence}`,
-        `    Delivery: ${mailbox.inputDelivery?.status ?? "none"}; processing: ${mailbox.processing?.batchId ?? "none"}; pending batches: ${pending.length}`,
+        `  ${target}: next=${mailbox.nextSequence}`,
+        `    Processing: ${mailbox.processing?.batchId ?? "none"}; pending batches: ${pending.length}`,
         ...pending.map((batch) => (`    Pending ${batch.fromSequence}-${batch.toSequence}: ${batch.reasons.join(", ")} · refs ${batch.refs.map((ref) => `${ref.type}:${ref.id}`).join(", ") || "none"}`))
     ];
 }
-function latestStallKind(events, runId) {
+function latestStallKind(events, turnId) {
     const event = [...events]
-        .filter((candidate) => candidate.type === "run.stalled"
-        && candidate.payload.runId === runId
+        .filter((candidate) => candidate.type === "turn.stalled"
+        && candidate.payload.turnId === turnId
         && candidate.payload.status !== "diagnostic-only")
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return event?.payload.kind ?? "workflow-not-progressing";
@@ -576,7 +575,7 @@ function renderExecutionGroup(group, projected) {
         ...summary.laneSummaries.flatMap((lane) => {
             const laneHealth = projected?.laneSummaries.find(({ laneId }) => laneId === lane.laneId);
             return [
-                `      Lane ${lane.laneId} (#${lane.ordinal}, ${lane.roleName}${lane.runId === undefined ? "" : `, run ${lane.runId}`}) [${lane.status}${laneHealth?.runtimeHealth === undefined ? "" : `/${laneHealth.runtimeHealth}`}]${lane.summary === undefined ? "" : `: ${compactText(lane.summary)}`}`,
+                `      Lane ${lane.laneId} (#${lane.ordinal}, ${lane.roleName}${lane.turnId === undefined ? "" : `, run ${lane.turnId}`}) [${lane.status}${laneHealth?.runtimeHealth === undefined ? "" : `/${laneHealth.runtimeHealth}`}]${lane.summary === undefined ? "" : `: ${compactText(lane.summary)}`}`,
                 ...(lane.effective === undefined
                     ? []
                     : [`        Config: ${lane.effective.adapterId}/${lane.effective.model ?? "default"}/${lane.effective.effort ?? "default"}; profile=${lane.effective.profileAccess}`]),

package/dist/commands/taskExecutionCommands.js

@@ -1,10 +1,9 @@
 import { createTaskEvent } from "../event/taskEvent.js";
-import { terminalizeTaskRoleRunSession } from "../executor/agentExecutor.js";
 import { recordExecutionLaneResult } from "../execution/executionGroup.js";
 import { usageError } from "../errors/cliError.js";
 import { requestDurableJobCancel } from "../job/durableJob.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
-import { failAgentRun } from "../run/agentRun.js";
+import { failTurn } from "../turn/turn.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { startTaskExecution, stopTaskExecution } from "../task/task.js";
 import { updateWorkItemExecutionGroup, workItemExecutionGroupById } from "../workItem/workItem.js";
@@ -61,33 +60,29 @@ export function stopTaskExecutionCommand(request, store, options = {}) {
         }
         const changed = task.executionGate.state !== "stopped";
         tx.saveTask(stopTaskExecution(task, now));
-        const activeRuns = tx.listAgentRuns(task.id).filter((run) => run.status === "active");
+        const activeTurns = tx.listTurns(task.id).filter((run) => run.status === "active");
         const activeJobs = tx.listDurableJobs(task.id)
             .filter((job) => job.status === "queued" || job.status === "running");
         for (const job of activeJobs) {
             tx.saveDurableJob(task.id, requestDurableJobCancel(job, now));
         }
-        failExecutionAttempts(tx, task.id, activeRuns, request.reason, now);
-        for (const run of activeRuns) {
-            tx.saveAgentRun(failAgentRun(run, `Task execution stopped: ${request.reason}`, now));
+        failExecutionAttempts(tx, task.id, activeTurns, request.reason, now);
+        for (const run of activeTurns) {
+            tx.saveTurn(failTurn(run, "cancelled", `Task execution stopped: ${request.reason}`, now));
             if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
-                tx.clearActiveExecutionLaneRun(task.id, run.executionGroupId, run.executionLaneId);
+                tx.clearActiveExecutionLaneTurn(task.id, run.executionGroupId, run.executionLaneId);
             }
-            tx.clearActiveAgentRun(task.id, run.roleName);
+            tx.clearActiveTurn(task.id, run.roleName);
         }
-        const roleNames = taskRuntimeRoleNames(tx, task.id, activeRuns);
+        const roleNames = taskRuntimeRoleNames(tx, task.id, activeTurns);
         for (const roleName of roleNames) {
-            tx.clearActiveAgentRun(task.id, roleName);
-            const sessions = tx.getTaskRoleSessionSet(task.id, roleName);
-            if (sessions !== null && sessions.inFlight !== null) {
-                tx.saveTaskRoleSessionSet(terminalizeCurrentRun(sessions, now));
-            }
+            tx.clearActiveTurn(task.id, roleName);
         }
         // A stop is allowed to discard stale pointer projections even when their
-        // historical Runs are already terminal.
-        for (const run of tx.listAgentRuns(task.id)) {
+        // historical Turns are already terminal.
+        for (const run of tx.listTurns(task.id)) {
             if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
-                tx.clearActiveExecutionLaneRun(task.id, run.executionGroupId, run.executionLaneId);
+                tx.clearActiveExecutionLaneTurn(task.id, run.executionGroupId, run.executionLaneId);
             }
         }
         for (const mailbox of tx.listWorkMailboxes()) {
@@ -99,17 +94,17 @@ export function stopTaskExecutionCommand(request, store, options = {}) {
         tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, "task.execution-stopped", {
             by: actor,
             reason: request.reason,
-            terminatedRuns: String(activeRuns.length)
+            terminatedRuns: String(activeTurns.length)
         }, now));
         return {
             taskId: task.id,
             changed,
             roleNames,
-            terminatedRunIds: activeRuns.map(({ id }) => id),
+            terminatedTurnIds: activeTurns.map(({ id }) => id),
             cancelledJobIds: activeJobs.map(({ id }) => id),
             output: changed
                 ? `Stopped Task execution: ${task.id}. Progress was preserved; `
-                    + `${activeRuns.length} active attempt(s) were terminated and `
+                    + `${activeTurns.length} active attempt(s) were terminated and `
                     + `${activeJobs.length} DurableJob(s) were cancelled.`
                 : `Task execution is already stopped: ${task.id}. Runtime cleanup will be verified.`
         };
@@ -129,7 +124,7 @@ export function startTaskExecutionCommand(taskId, store, options = {}) {
         if (task.executionGate.state === "enabled") {
             return { taskId: task.id, changed: false, output: `Task execution is already enabled: ${task.id}.` };
         }
-        if (tx.listAgentRuns(task.id).some((run) => run.status === "active")
+        if (tx.listTurns(task.id).some((run) => run.status === "active")
             || tx.listDurableJobs(task.id).some((job) => job.status === "queued" || job.status === "running")) {
             throw usageError(`Task still has an active execution attempt: ${task.id}.`);
         }
@@ -173,20 +168,12 @@ function requireOperatorOrUser(environment, taskId) {
     }
     return actor;
 }
-function terminalizeCurrentRun(sessions, now) {
-    const inFlight = sessions.inFlight;
-    return terminalizeTaskRoleRunSession(sessions, {
-        agentId: inFlight.agentId,
-        runId: inFlight.runId,
-        receiptId: inFlight.receiptId
-    }, now);
-}
-function taskRuntimeRoleNames(store, taskId, runs) {
+function taskRuntimeRoleNames(store, taskId, turns) {
     const names = new Set(store.listRoles(taskId).map(({ name }) => name));
     for (const sessions of store.listRoleSessionSets(taskId))
         names.add(sessions.owner.roleName);
-    for (const run of runs)
-        names.add(run.roleName);
+    for (const turn of turns)
+        names.add(turn.roleName);
     for (const owner of store.listSessionOwners()) {
         if (owner.owner.scope === "task" && owner.owner.taskId === taskId) {
             names.add(owner.owner.roleName);
@@ -194,36 +181,36 @@ function taskRuntimeRoleNames(store, taskId, runs) {
     }
     return [...names].sort();
 }
-function failExecutionAttempts(store, taskId, runs, reason, now) {
+function failExecutionAttempts(store, taskId, turns, reason, now) {
     const summary = `Task execution stopped: ${reason}`;
     const workItems = new Map(store.listWorkItems(taskId).map((item) => [item.id, item]));
     const reviewRounds = new Map(store.listReviewRounds(taskId).map((round) => [round.id, round]));
     const affectedReviewRoundIds = new Set();
-    for (const run of runs) {
-        if (run.executionGroupId === undefined || run.executionLaneId === undefined)
+    for (const turn of turns) {
+        if (turn.executionGroupId === undefined || turn.executionLaneId === undefined)
             continue;
-        if (run.workItemId !== undefined) {
-            const item = workItems.get(run.workItemId);
+        if (turn.workItemId !== undefined) {
+            const item = workItems.get(turn.workItemId);
             const group = item === undefined
                 ? undefined
-                : workItemExecutionGroupById(item, run.executionGroupId);
-            const lane = group?.lanes.find(({ id }) => id === run.executionLaneId);
+                : workItemExecutionGroupById(item, turn.executionGroupId);
+            const lane = group?.lanes.find(({ id }) => id === turn.executionLaneId);
             if (item !== undefined && group !== undefined && lane !== undefined
                 && item.currentExecutionGroupId === group.id
-                && !["yielded", "completed", "failed", "skipped"].includes(lane.status)) {
+                && !["completed", "failed", "skipped"].includes(lane.status)) {
                 const updated = updateWorkItemExecutionGroup(item, recordExecutionLaneResult(group, lane.id, { summary }, "failed", now), now);
                 workItems.set(item.id, updated);
             }
         }
-        if (run.reviewRoundId !== undefined) {
-            affectedReviewRoundIds.add(run.reviewRoundId);
-            const round = reviewRounds.get(run.reviewRoundId);
-            const group = round?.executionGroup?.id === run.executionGroupId
+        if (turn.reviewRoundId !== undefined) {
+            affectedReviewRoundIds.add(turn.reviewRoundId);
+            const round = reviewRounds.get(turn.reviewRoundId);
+            const group = round?.executionGroup?.id === turn.executionGroupId
                 ? round.executionGroup
                 : undefined;
-            const lane = group?.lanes.find(({ id }) => id === run.executionLaneId);
+            const lane = group?.lanes.find(({ id }) => id === turn.executionLaneId);
             if (round !== undefined && group !== undefined && lane !== undefined
-                && !["yielded", "completed", "failed", "skipped"].includes(lane.status)) {
+                && !["completed", "failed", "skipped"].includes(lane.status)) {
                 reviewRounds.set(round.id, updateReviewExecutionGroup(round, recordExecutionLaneResult(group, lane.id, { summary }, "failed", now)));
             }
         }

package/dist/commands/taskInputCommands.js

@@ -4,10 +4,8 @@ import { activeLiveRoleAgentSession } from "../executor/agentExecutor.js";
 import { answerInputRequest, cancelInputRequest, createInputRequest } from "../input/inputRequest.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
-import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
-import { isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
-import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
+import { isRoleTurnStalled, TURN_RECOVERED_EVENT } from "../scheduler/roleTurnStall.js";
 import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isLinuxProcessLive, listOwnedProcessTree } from "../runtime/sessionOwnerIdentity.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
@@ -63,36 +61,17 @@ function createRequest(args, store, options) {
         validateBlockedInputOwnership(tx, task.id, blockedRefs);
         const origin = requireLeaderInputOrigin(tx, task.id, options.environment);
         const created = createInputRequest(tx.nextInputRequestId(task.id), task.id, origin.requester, { question, choices, blockedRefs, policy }, now);
-        const wasStalled = isRoleRunStalled(tx.listEvents(task.id), origin.run.id);
+        const wasStalled = isRoleTurnStalled(tx.listEvents(task.id), origin.turn.id);
         tx.saveInputRequest(task.id, created);
         enqueueWork(tx, { kind: "operator" }, "input-requested", now, [
             { type: "input", taskId: task.id, id: created.id }
         ], {
             source: "input-request",
-            dedupeKey: `operator-input:${task.id}:${created.id}`,
-            deliveryMode: "followup",
-            lane: "normal"
+            dedupeKey: `operator-input:${task.id}:${created.id}`
         });
-        const terminal = terminalizeExactTaskRun(tx, {
-            taskId: task.id,
-            roleName: LEADER_ROLE,
-            agentId: origin.run.effective.agentId,
-            runId: origin.run.id,
-            receiptId: agentRunDeliveryReceiptId(origin.run),
-            ...(origin.requester.nativeSessionId === undefined
-                ? {}
-                : { nativeSessionId: origin.requester.nativeSessionId }),
-            outcome: {
-                status: "yielded",
-                summary: `Waiting for input ${created.id}: ${created.question}`
-            }
-        }, now);
-        if (terminal.disposition !== "applied") {
-            throw usageError(`Task Leader Run changed while requesting input: ${origin.run.id}/${terminal.reason}.`);
-        }
         if (wasStalled) {
-            recordTaskEvent(tx, task.id, RUN_RECOVERED_EVENT, {
-                runId: origin.run.id,
+            recordTaskEvent(tx, task.id, TURN_RECOVERED_EVENT, {
+                turnId: origin.turn.id,
                 roleName: LEADER_ROLE,
                 progressAt: now.toISOString(),
                 kind: "input-request"
@@ -100,7 +79,7 @@ function createRequest(args, store, options) {
         }
         recordTaskEvent(tx, task.id, "input.requested", {
             requestId: created.id,
-            requesterRunId: created.requester.runId,
+            requesterTurnId: created.requester.turnId,
             policy: created.policy.kind
         }, now);
         return created;
@@ -222,33 +201,32 @@ function cancelRequest(args, store, options) {
 function requireLeaderInputOrigin(store, taskId, environment) {
     const env = environment ?? {};
     const role = requireRole(store, taskId, LEADER_ROLE);
-    const run = store.getActiveAgentRun(taskId, LEADER_ROLE);
+    const turn = store.getActiveTurn(taskId, LEADER_ROLE);
     if (env.YUI_SESSION_SCOPE !== "task"
         || env.YUI_TASK_ID !== taskId
         || env.YUI_ROLE !== LEADER_ROLE
-        || run === null
-        || env.YUI_AGENT_ID !== run.effective.agentId
-        || run.status !== "active"
-        || run.pushedAt === undefined
-        || run.workItemId !== undefined) {
-        throw usageError("Task input request requires the active Leader Run environment.");
+        || turn === null
+        || env.YUI_AGENT_ID !== turn.effective.agentId
+        || turn.status !== "active"
+        || turn.workItemId !== undefined) {
+        throw usageError("Task input request requires the active Leader Turn environment.");
     }
     const sessions = store.getTaskRoleSessionSet(taskId, LEADER_ROLE);
     const nativeSessionId = trimmed(env.YUI_NATIVE_SESSION_ID);
     if (nativeSessionId !== undefined
-        && sessions?.sessions[run.effective.agentId]?.nativeSessionId !== nativeSessionId) {
+        && sessions?.sessions[turn.effective.agentId]?.nativeSessionId !== nativeSessionId) {
         throw usageError("Task input request native session does not match the active Leader session.");
     }
     return {
         requester: {
             taskId,
             roleName: "leader",
-            agentId: run.effective.agentId,
-            runId: run.id,
+            agentId: turn.effective.agentId,
+            turnId: turn.id,
             ...(nativeSessionId === undefined ? {} : { nativeSessionId })
         },
         role,
-        run,
+        turn,
         sessions
     };
 }
@@ -364,8 +342,8 @@ function parseInputBlockedRef(value, taskId) {
     const separator = value.indexOf(":");
     const type = value.slice(0, separator);
     const id = value.slice(separator + 1).trim();
-    if ((type !== "work-item" && type !== "run") || separator <= 0 || id.length === 0) {
-        throw usageError("--blocks must use work-item:<id> or run:<id>.");
+    if ((type !== "work-item" && type !== "turn") || separator <= 0 || id.length === 0) {
+        throw usageError("--blocks must use work-item:<id> or turn:<id>.");
     }
     return { type, taskId, id };
 }
@@ -373,7 +351,7 @@ function validateBlockedInputOwnership(store, taskId, references) {
     for (const reference of references) {
         const record = reference.type === "work-item"
             ? store.getWorkItem(taskId, reference.id)
-            : store.getAgentRun(taskId, reference.id);
+            : store.getTurn(taskId, reference.id);
         if (record === null)
             throw dataError(`Blocked ${reference.type} not found: ${reference.id}.`);
     }
@@ -408,7 +386,7 @@ function renderInputRequest(request, timeZone) {
         `Task: ${request.taskId}`,
         `Status: ${request.status}`,
         `Question: ${request.question}`,
-        `Requested by: ${request.requester.agentId}/${request.requester.runId}`,
+        `Requested by: ${request.requester.agentId}/${request.requester.turnId}`,
         ...(request.choices.length === 0
             ? ["Answer type: text"]
             : ["Choices:", ...request.choices.map((choice) => `  ${choice.key}: ${choice.label}`)]),

package/dist/commands/taskNextActionCommand.js

@@ -70,20 +70,20 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
         }
         const events = reader.listEvents(taskId);
         const task = reader.getTask(taskId);
-        const operationalRuns = operationalTaskRecords(reader.listAgentRuns(taskId), events, "agent-run");
+        const operationalTurns = operationalTaskRecords(reader.listTurns(taskId), events, "turn");
         const reviewRounds = reader.listReviewRounds(taskId);
         const reviewDecision = projectReviewDecision({
             store: reader,
             task,
             roles: reader.listRoles(taskId),
-            runs: operationalRuns,
+            turns: operationalTurns,
             rounds: reviewRounds,
             reviewConfig: reader.getReviewConfig(),
             currentCandidate: currentTaskReviewCandidate
         });
         const orchestration = projectTaskOrchestration({
             task,
-            runs: operationalRuns,
+            turns: operationalTurns,
             roleSessionSets: reader.listRoleSessionSets(taskId),
             workItems: reader.listWorkItems(taskId),
             changeSets: reader.listChangeSets(taskId),
@@ -141,10 +141,10 @@ function renderNextAction(action, taskType, repairWave, completionReadiness, kno
         `Next action: ${action.kind}`,
         `Reason: ${action.reason}`,
         `Execution view: ${execution.status}; owner/action=${execution.owner}/${execution.action}; reason=${execution.reason}; ${execution.summary}`,
-        `Active AgentRuns (${execution.activeRuns.length}):`,
-        ...(execution.activeRuns.length === 0
+        `Active Turns (${execution.activeTurns.length}):`,
+        ...(execution.activeTurns.length === 0
             ? ["  none"]
-            : execution.activeRuns.map((run) => `  ${renderActiveRun(run)}`)),
+            : execution.activeTurns.map((run) => `  ${renderActiveTurn(run)}`)),
         ...(action.refs.length === 0
             ? ["Refs: none"]
             : ["Refs:", ...action.refs.map((ref) => `  ${ref.kind}: ${ref.id}`)]),
@@ -217,14 +217,14 @@ function renderNextAction(action, taskType, repairWave, completionReadiness, kno
     }
     return `${lines.join("\n")}\n`;
 }
-function renderActiveRun(run) {
+function renderActiveTurn(run) {
     const subject = run.reviewRoundId === undefined
         ? run.workItemId === undefined ? "task" : `work-item=${run.workItemId}`
         : `review-round=${run.reviewRoundId}`;
     const lane = run.executionGroupId === undefined
         ? ""
         : `; group=${run.executionGroupId}${run.executionLaneId === undefined ? "" : `; lane=${run.executionLaneId}`}`;
-    return `${run.id} [${run.purpose}/${run.status}; role=${run.roleName}; ${run.delivered ? "accepted" : "delivery-pending"}; ${subject}${lane}]`;
+    return `${run.id} [${run.purpose}/${run.status}; role=${run.roleName}; ${`provider-${run.providerSession}`}; ${subject}${lane}]`;
 }
 function nextActionExecutionView(execution) {
     return {
@@ -233,6 +233,6 @@ function nextActionExecutionView(execution) {
         action: execution.action,
         reason: execution.reason,
         summary: execution.summary,
-        activeRuns: execution.activeRuns
+        activeTurns: execution.activeTurns
     };
 }