@zq-silk/yui 0.15.7 → 0.15.8

package/dist/commands/taskExecutionCommands.js

@@ -3,7 +3,7 @@ import { updateExecutionLane } from "../execution/workItemExecution.js";
 import { usageError } from "../errors/cliError.js";
 import { requestDurableJobCancel } from "../job/durableJob.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
-import { failTurn } from "../turn/turn.js";
+import { failRun } from "../agentRun/agentRun.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { startTaskExecution, stopTaskExecution } from "../task/task.js";
 import { taskActor } from "./taskActor.js";
@@ -54,34 +54,34 @@ export function stopTaskExecutionCommand(request, store, options = {}) {
         const task = tx.getTask(request.taskId);
         if (task === null)
             throw usageError(`Task not found: ${request.taskId}.`);
-        if (task.status !== "active") {
-            throw usageError(`Only an active Task can be stopped: ${task.id}.`);
+        if (task.status !== "active" && task.status !== "draft") {
+            throw usageError(`Only an open Task can be stopped: ${task.id}.`);
         }
         const changed = task.executionGate.state !== "stopped";
         tx.saveTask(stopTaskExecution(task, now));
-        const activeTurns = tx.listTurns(task.id).filter((run) => run.status === "active");
+        const activeRuns = tx.listRuns(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, activeTurns, request.reason, now);
-        for (const run of activeTurns) {
-            tx.saveTurn(failTurn(run, "cancelled", `Task execution stopped: ${request.reason}`, now));
+        failExecutionAttempts(tx, task.id, activeRuns, request.reason, now);
+        for (const run of activeRuns) {
+            tx.saveRun(failRun(run, "cancelled", `Task execution stopped: ${request.reason}`, now));
             if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
-                tx.clearActiveExecutionLaneTurn(task.id, run.executionGroupId, run.executionLaneId);
+                tx.clearActiveExecutionLaneRun(task.id, run.executionGroupId, run.executionLaneId);
             }
-            tx.clearActiveTurn(task.id, run.roleName);
+            tx.clearActiveRun(task.id, run.roleName);
         }
-        const roleNames = taskRuntimeRoleNames(tx, task.id, activeTurns);
+        const roleNames = taskRuntimeRoleNames(tx, task.id, activeRuns);
         for (const roleName of roleNames) {
-            tx.clearActiveTurn(task.id, roleName);
+            tx.clearActiveRun(task.id, roleName);
         }
         // A stop is allowed to discard stale pointer projections even when their
-        // historical Turns are already terminal.
-        for (const run of tx.listTurns(task.id)) {
+        // historical AgentRuns are already terminal.
+        for (const run of tx.listRuns(task.id)) {
             if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
-                tx.clearActiveExecutionLaneTurn(task.id, run.executionGroupId, run.executionLaneId);
+                tx.clearActiveExecutionLaneRun(task.id, run.executionGroupId, run.executionLaneId);
             }
         }
         for (const mailbox of tx.listWorkMailboxes()) {
@@ -93,17 +93,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(activeTurns.length)
+            terminatedRuns: String(activeRuns.length)
         }, now));
         return {
             taskId: task.id,
             changed,
             roleNames,
-            terminatedTurnIds: activeTurns.map(({ id }) => id),
+            terminatedRunIds: activeRuns.map(({ id }) => id),
             cancelledJobIds: activeJobs.map(({ id }) => id),
             output: changed
                 ? `Stopped Task execution: ${task.id}. Progress was preserved; `
-                    + `${activeTurns.length} active attempt(s) were terminated and `
+                    + `${activeRuns.length} AgentRun record(s) were cancelled and `
                     + `${activeJobs.length} DurableJob(s) were cancelled.`
                 : `Task execution is already stopped: ${task.id}. Runtime cleanup will be verified.`
         };
@@ -117,13 +117,13 @@ export function startTaskExecutionCommand(taskId, store, options = {}) {
         const task = tx.getTask(taskId);
         if (task === null)
             throw usageError(`Task not found: ${taskId}.`);
-        if (task.status !== "active") {
-            throw usageError(`Only an active Task can be started: ${task.id}.`);
+        if (task.status !== "active" && task.status !== "draft") {
+            throw usageError(`Only an open Task can be started: ${task.id}.`);
         }
         if (task.executionGate.state === "enabled") {
             return { taskId: task.id, changed: false, output: `Task execution is already enabled: ${task.id}.` };
         }
-        if (tx.listTurns(task.id).some((run) => run.status === "active")
+        if (tx.listRuns(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}.`);
         }
@@ -167,12 +167,12 @@ function requireOperatorOrUser(environment, taskId) {
     }
     return actor;
 }
-function taskRuntimeRoleNames(store, taskId, turns) {
+function taskRuntimeRoleNames(store, taskId, runs) {
     const names = new Set(store.listRoles(taskId).map(({ name }) => name));
     for (const sessions of store.listRoleSessionSets(taskId))
         names.add(sessions.owner.roleName);
-    for (const turn of turns)
-        names.add(turn.roleName);
+    for (const run of runs)
+        names.add(run.roleName);
     for (const owner of store.listSessionOwners()) {
         if (owner.owner.scope === "task" && owner.owner.taskId === taskId) {
             names.add(owner.owner.roleName);
@@ -180,24 +180,24 @@ function taskRuntimeRoleNames(store, taskId, turns) {
     }
     return [...names].sort();
 }
-function failExecutionAttempts(store, taskId, turns, reason, now) {
+function failExecutionAttempts(store, taskId, runs, reason, now) {
     const summary = `Task execution stopped: ${reason}`;
     const reviewRounds = new Map(store.listReviewRounds(taskId).map((round) => [round.id, round]));
     const affectedReviewRoundIds = new Set();
-    for (const turn of turns) {
-        if (turn.reviewRoundId !== undefined) {
-            affectedReviewRoundIds.add(turn.reviewRoundId);
-            if (turn.executionGroupId === undefined || turn.executionLaneId === undefined)
+    for (const run of runs) {
+        if (run.reviewRoundId !== undefined) {
+            affectedReviewRoundIds.add(run.reviewRoundId);
+            if (run.executionGroupId === undefined || run.executionLaneId === undefined)
                 continue;
-            const round = reviewRounds.get(turn.reviewRoundId);
-            const group = round?.executionGroup?.id === turn.executionGroupId
+            const round = reviewRounds.get(run.reviewRoundId);
+            const group = round?.executionGroup?.id === run.executionGroupId
                 ? round.executionGroup
                 : undefined;
-            const lane = group?.lanes.find(({ id }) => id === turn.executionLaneId);
+            const lane = group?.lanes.find(({ id }) => id === run.executionLaneId);
             if (round !== undefined && group !== undefined && lane !== undefined
                 && lane.disposition === "open") {
                 reviewRounds.set(round.id, updateReviewExecutionGroup(round, updateExecutionLane(group, lane.id, {
-                    currentTurnId: turn.id,
+                    currentRunId: run.id,
                     disposition: "failed"
                 }, now)));
             }

package/dist/commands/taskInputCommands.js

@@ -5,9 +5,8 @@ import { answerInputRequest, cancelInputRequest, createInputRequest } from "../i
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.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 { isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
+import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 const LEADER_ROLE = "leader";
 export function runTaskInputCommand(args, store, options) {
@@ -55,13 +54,13 @@ function createRequest(args, store, options) {
         };
     const request = store.transaction((tx) => {
         const task = requireTask(tx, parsed.positionals[0]);
-        if (task.status !== "active")
+        if (task.status !== "active" && task.status !== "draft")
             throw usageError(inactiveTaskMessage(task, "requesting input"));
         const blockedRefs = blockedValues.map((value) => parseInputBlockedRef(value, task.id));
         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 = isRoleTurnStalled(tx.listEvents(task.id), origin.turn.id);
+        const wasStalled = origin.run !== null && isRoleRunStalled(tx.listEvents(task.id), origin.run.id);
         tx.saveInputRequest(task.id, created);
         enqueueWork(tx, { kind: "operator" }, "input-requested", now, [
             { type: "input", taskId: task.id, id: created.id }
@@ -69,9 +68,9 @@ function createRequest(args, store, options) {
             source: "input-request",
             dedupeKey: `operator-input:${task.id}:${created.id}`
         });
-        if (wasStalled) {
-            recordTaskEvent(tx, task.id, TURN_RECOVERED_EVENT, {
-                turnId: origin.turn.id,
+        if (wasStalled && origin.run !== null) {
+            recordTaskEvent(tx, task.id, RUN_RECOVERED_EVENT, {
+                runId: origin.run.id,
                 roleName: LEADER_ROLE,
                 progressAt: now.toISOString(),
                 kind: "input-request"
@@ -79,7 +78,8 @@ function createRequest(args, store, options) {
         }
         recordTaskEvent(tx, task.id, "input.requested", {
             requestId: created.id,
-            requesterTurnId: created.requester.turnId,
+            ...(created.requester.runId === undefined ? {} : { requesterRunId: created.requester.runId }),
+            ...(created.requester.nativeSessionId === undefined ? {} : { requesterNativeSessionId: created.requester.nativeSessionId }),
             policy: created.policy.kind
         }, now);
         return created;
@@ -154,7 +154,7 @@ function answerRequest(args, store, options) {
         if (current === null)
             throw dataError(`Input request not found: ${located.id}.`);
         const task = requireTask(tx, current.taskId);
-        if (task.status !== "active")
+        if (task.status !== "active" && task.status !== "draft")
             throw usageError(inactiveTaskMessage(task, "answering input"));
         const answered = answerInputRequest(current, answer, inputAnswerer(options.environment), now);
         tx.saveInputRequest(task.id, answered);
@@ -176,7 +176,7 @@ function cancelRequest(args, store, options) {
     const now = clock(options);
     const request = store.transaction((tx) => {
         const task = requireTask(tx, parsed.positionals[0]);
-        if (task.status !== "active")
+        if (task.status !== "active" && task.status !== "draft")
             throw usageError(inactiveTaskMessage(task, "cancelling input"));
         const current = tx.getInputRequest(task.id, parsed.positionals[1]);
         if (current === null)
@@ -200,33 +200,24 @@ function cancelRequest(args, store, options) {
 }
 function requireLeaderInputOrigin(store, taskId, environment) {
     const env = environment ?? {};
-    const role = requireRole(store, 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
-        || 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 caller = requireManagedTaskCaller(store, env);
+    if (caller.taskId !== taskId || caller.roleName !== LEADER_ROLE) {
+        throw usageError("Only the current Task Leader may request user input.");
     }
+    const role = requireRole(store, taskId, LEADER_ROLE);
+    const run = store.getActiveRun(taskId, LEADER_ROLE);
     const sessions = store.getTaskRoleSessionSet(taskId, LEADER_ROLE);
-    const nativeSessionId = trimmed(env.YUI_NATIVE_SESSION_ID);
-    if (nativeSessionId !== undefined
-        && sessions?.sessions[turn.effective.agentId]?.nativeSessionId !== nativeSessionId) {
-        throw usageError("Task input request native session does not match the active Leader session.");
-    }
+    const nativeSessionId = caller.nativeSessionId;
     return {
         requester: {
             taskId,
             roleName: "leader",
-            agentId: turn.effective.agentId,
-            turnId: turn.id,
-            ...(nativeSessionId === undefined ? {} : { nativeSessionId })
+            agentId: caller.agentId,
+            ...(run === null ? {} : { runId: run.id }),
+            nativeSessionId
         },
         role,
-        turn,
+        run,
         sessions
     };
 }
@@ -235,93 +226,38 @@ function assertInputCancelOrigin(store, request, environment) {
     if (isCurrentGlobalOperator(store, env)) {
         return "operator";
     }
-    if (env.YUI_SESSION_SCOPE !== "task"
-        || env.YUI_TASK_ID !== request.taskId
-        || env.YUI_ROLE !== request.requester.roleName
-        || env.YUI_AGENT_ID !== request.requester.agentId
-        || (request.requester.nativeSessionId !== undefined
-            && env.YUI_NATIVE_SESSION_ID !== request.requester.nativeSessionId)) {
-        throw usageError("Only the originating Leader may cancel this input request.");
+    const caller = requireManagedTaskCaller(store, env);
+    if (caller.taskId !== request.taskId || caller.roleName !== LEADER_ROLE) {
+        throw usageError("Only the current Task Leader or Operator may cancel this input request.");
     }
     return "leader";
 }
 export function isCurrentGlobalOperator(store, environment) {
-    if (environment.YUI_SESSION_SCOPE !== "global"
-        || environment.YUI_ROLE !== "operator"
+    if ((environment.YUI_SESSION_SCOPE !== undefined && environment.YUI_SESSION_SCOPE !== "global")
+        || (environment.YUI_ROLE !== undefined && environment.YUI_ROLE !== "operator")
         || environment.YUI_TASK_ID !== undefined)
         return false;
     const role = store.getGlobalRole("operator");
     if (role === null)
         return false;
-    const agentId = exactIdentity(environment.YUI_AGENT_ID);
-    const adapterId = exactIdentity(environment.YUI_ADAPTER_ID);
-    const runtimeGenerationId = exactIdentity(environment.YUI_RUNTIME_GENERATION_ID);
-    const nativeSessionId = exactIdentity(environment.YUI_NATIVE_SESSION_ID);
     const binding = role.agentBindings[role.activeAgentId];
-    if (agentId === undefined
-        || adapterId === undefined
-        || runtimeGenerationId === undefined
-        || binding === undefined
-        || binding.agentId !== agentId
-        || binding.adapterId !== adapterId)
+    if (binding === undefined)
         return false;
     const sessions = store.getGlobalRoleSessionSet(role.name);
     const session = activeLiveRoleAgentSession(sessions);
     if (sessions === null || session === null || sessions.activeAgentId !== role.activeAgentId) {
-        // Codex learns its native Session ID only after the first Turn. During
-        // that narrow bootstrap window, authenticate against the durable launch
-        // reservation and its strongly attributed live process owner instead.
-        return nativeSessionId === undefined
-            && binding.adapterId === "codex"
-            && currentProcessBelongsToReservedGlobalLaunch(store, {
-                roleName: role.name,
-                agentId,
-                adapterId,
-                runtimeGenerationId
-            });
+        return false;
     }
-    // A fresh Codex launch discovers its native Session asynchronously. Its
-    // launch envelope therefore cannot carry YUI_NATIVE_SESSION_ID, but the
-    // durable Session still binds that provider identity to the exact launch
-    // generation. Accept that one transport shape only when the current
-    // launch, Agent, and adapter all match; Claude and stale/unknown launches
-    // remain fail-closed on the native identity fence.
-    const nativeSessionMatches = binding !== undefined && (nativeSessionId === session.nativeSessionId
-        || (nativeSessionId === undefined
-            && binding.adapterId === "codex"
-            && session.adapterId === "codex"
-            && session.runtimeGenerationId !== undefined
-            && session.runtimeGenerationId === runtimeGenerationId));
+    // The provider's conversation survives Host restarts and entry-point changes.
+    // Prefer its command-time identity over a launch-time environment snapshot.
+    // A launch reservation alone is not a registered Operator conversation.
+    const nativeSessionId = exactIdentity(binding.adapterId === "codex"
+        ? environment.CODEX_THREAD_ID ?? environment.YUI_NATIVE_SESSION_ID
+        : environment.YUI_NATIVE_SESSION_ID);
     return binding.agentId === session.agentId
         && binding.adapterId === session.adapterId
-        && session.agentId === agentId
-        && session.adapterId === adapterId
-        && session.runtimeGenerationId !== undefined
-        && session.runtimeGenerationId === runtimeGenerationId
-        && nativeSessionMatches;
-}
-function currentProcessBelongsToReservedGlobalLaunch(store, input) {
-    if (store.getSessionOwner === undefined || store.getWorkMailbox === undefined)
-        return false;
-    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget({
-        scope: "global",
-        roleName: input.roleName
-    }));
-    if (!isRuntimeLaunchReservation(mailbox?.processing, input.runtimeGenerationId)
-        || hasRuntimeCleanupObligation(mailbox))
-        return false;
-    const owner = store.getSessionOwner(input.runtimeGenerationId);
-    if (owner === null
-        || owner.owner.scope !== "global"
-        || owner.owner.roleName !== input.roleName
-        || owner.agentId !== input.agentId
-        || owner.adapterId !== input.adapterId
-        || owner.runtimeGenerationId !== input.runtimeGenerationId
-        || owner.providerRoot.attribution !== "launch-env"
-        || !isLinuxProcessLive(owner.providerRoot.pid, owner.providerRoot.startIdentity)) {
-        return false;
-    }
-    return listOwnedProcessTree(owner.providerRoot.pid, owner.providerRoot.processGroupId).some(({ pid }) => pid === process.pid);
+        && nativeSessionId !== undefined
+        && nativeSessionId === session.nativeSessionId;
 }
 function inputAnswerer(environment) {
     const env = environment ?? {};
@@ -342,7 +278,7 @@ 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 !== "turn") || separator <= 0 || id.length === 0) {
+    if ((type !== "work-item" && type !== "run") || separator <= 0 || id.length === 0) {
         throw usageError("--blocks must use work-item:<id> or turn:<id>.");
     }
     return { type, taskId, id };
@@ -351,7 +287,7 @@ function validateBlockedInputOwnership(store, taskId, references) {
     for (const reference of references) {
         const record = reference.type === "work-item"
             ? store.getWorkItem(taskId, reference.id)
-            : store.getTurn(taskId, reference.id);
+            : store.getRun(taskId, reference.id);
         if (record === null)
             throw dataError(`Blocked ${reference.type} not found: ${reference.id}.`);
     }
@@ -386,7 +322,7 @@ function renderInputRequest(request, timeZone) {
         `Task: ${request.taskId}`,
         `Status: ${request.status}`,
         `Question: ${request.question}`,
-        `Requested by: ${request.requester.agentId}/${request.requester.turnId}`,
+        `Requested by: ${request.requester.agentId}/${request.requester.runId ?? request.requester.nativeSessionId}`,
         ...(request.choices.length === 0
             ? ["Answer type: text"]
             : ["Choices:", ...request.choices.map((choice) => `  ${choice.key}: ${choice.label}`)]),
@@ -435,7 +371,7 @@ function inactiveTaskMessage(task, action) {
     if (task.status === "completed") {
         return `Task ${task.id} is completed; reopen it before ${action}.`;
     }
-    if (task.status === "retired")
+    if (task.status === "cancelled")
         return `Task ${task.id} is retired; it cannot resume ${action}.`;
     return `Task is archived: ${task.id}.`;
 }

package/dist/commands/taskIntegrationCommands.js

@@ -7,8 +7,9 @@ import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegratio
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { runTaskIntegrationQueueCommand } from "./taskIntegrationQueueCommands.js";
-import { taskLocalActor } from "./taskActor.js";
+import { assertTaskDeliveryAuthority as taskLocalActor } from "./taskActor.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { governingWorkItemCandidate } from "../workItem/workItem.js";
 export async function runTaskIntegrationCommand(args, store, home, options = {}) {
     const now = options.now ?? (() => new Date());
     const [command, ...rest] = args;
@@ -101,7 +102,7 @@ async function start(args, store, home, now, options) {
     const workItem = store.getWorkItem(task.id, workItemId);
     if (workItem === null)
         throw usageError(`WorkItem not found: ${workItemId}.`);
-    const candidate = workItem.candidates.at(-1);
+    const candidate = governingWorkItemCandidate(workItem);
     if (candidate?.gitSnapshot === undefined || candidate.workspace === undefined) {
         throw usageError(`WorkItem has no committed result snapshot: ${workItem.id}.`);
     }

package/dist/commands/taskIntegrationQueueCommands.js

@@ -3,7 +3,7 @@ import { defaultTableWidth, renderTable } from "../output/table.js";
 import { resolveProject } from "../repository/project.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { enqueueIntegrationQueueEntry, processIntegrationQueue, reconcileIntegrationQueueEntry, requeueIntegrationQueueEntry, supersedeIntegrationQueueEntry } from "../integration/integrationQueueService.js";
-import { taskLocalActor } from "./taskActor.js";
+import { assertTaskDeliveryAuthority as taskLocalActor } from "./taskActor.js";
 import { parseRepeatable } from "./taskIntegrationCommands.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 /**

package/dist/commands/taskNextActionCommand.js

@@ -69,20 +69,20 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
         const events = reader.listEvents(taskId);
         const task = reader.getTask(taskId);
         const remoteDelivery = projectTaskRemoteDeliveryFromStore(reader, task, currentTaskReviewCandidate);
-        const operationalTurns = operationalTaskRecords(reader.listTurns(taskId), events, "turn");
+        const operationalRuns = operationalTaskRecords(reader.listRuns(taskId), events, "run");
         const reviewRounds = reader.listReviewRounds(taskId);
         const reviewDecision = projectReviewDecision({
             store: reader,
             task,
             roles: reader.listRoles(taskId),
-            turns: operationalTurns,
+            runs: operationalRuns,
             rounds: reviewRounds,
             reviewConfig: reader.getReviewConfig(),
             currentCandidate: currentTaskReviewCandidate
         });
         const orchestration = projectTaskOrchestration({
             task,
-            turns: operationalTurns,
+            runs: operationalRuns,
             roleSessionSets: reader.listRoleSessionSets(taskId),
             workItems: reader.listWorkItems(taskId),
             changeSets: reader.listChangeSets(taskId),
@@ -125,10 +125,10 @@ function renderNextAction(action, taskType, completionReadiness, knowledgePropos
         `Next action: ${action.kind}`,
         `Reason: ${action.reason}`,
         `Execution view: ${execution.status}; owner/action=${execution.owner}/${execution.action}; reason=${execution.reason}; ${execution.summary}`,
-        `Active Turns (${execution.activeTurns.length}):`,
-        ...(execution.activeTurns.length === 0
+        `Active AgentRuns (${execution.activeRuns.length}):`,
+        ...(execution.activeRuns.length === 0
             ? ["  none"]
-            : execution.activeTurns.map((run) => `  ${renderActiveTurn(run)}`)),
+            : execution.activeRuns.map((run) => `  ${renderActiveRun(run)}`)),
         ...(action.refs.length === 0
             ? ["Refs: none"]
             : ["Refs:", ...action.refs.map((ref) => `  ${ref.kind}: ${ref.id}`)]),
@@ -196,7 +196,7 @@ function renderNextAction(action, taskType, completionReadiness, knowledgePropos
     }
     return `${lines.join("\n")}\n`;
 }
-function renderActiveTurn(run) {
+function renderActiveRun(run) {
     const subject = run.reviewRoundId === undefined
         ? run.workItemId === undefined ? "task" : `work-item=${run.workItemId}`
         : `review-round=${run.reviewRoundId}`;
@@ -212,6 +212,6 @@ function nextActionExecutionView(execution) {
         action: execution.action,
         reason: execution.reason,
         summary: execution.summary,
-        activeTurns: execution.activeTurns
+        activeRuns: execution.activeRuns
     };
 }