@zq-silk/yui 0.13.9 → 0.14.0

package/dist/controller/jobControl.js

@@ -187,23 +187,23 @@ function validateStartParams(store, params) {
 /**
  * rr8/rr12: Bind the declared job owner to the caller's managed identity. The
  * Controller validates the declared owner/workspace and verifies the caller
- * against durable Run/Session state — a self-reported role or scope is never
+ * against durable Turn/Session state — a self-reported role or scope is never
  * authority on its own. The rules:
  *
  * - `user` (non-managed): rejected because it has no managed Session identity.
  * - `global`: full Task authority after current Role Session verification.
  * - `task` + mismatched taskId: rejected.
- * - `task` + missing `runId`: rejected (a managed caller must bind to a Run).
- * - `task` + Run not found / not active / `roleName !== role`: rejected — the
- *   claimed Role must be the real Role of an active Run.
- * - `task`: full authority inside the matching Task after active Run and
+ * - `task` + missing `turnId`: rejected (a managed caller must bind to a Turn).
+ * - `task` + Turn not found / not active / `roleName !== role`: rejected — the
+ *   claimed Role must be the real Role of an active Turn.
+ * - `task`: full authority inside the matching Task after active Turn and
  *   per-Session caller-key verification; Role does not narrow it.
  */
 /**
  * rr13: `job.start`/`job.cancel` caller authorization at the Controller
  * boundary. Every identity claim the Controller can verify from durable state
- * (role and runId) is replayable by any client in the
- * same Home that reads state.json. The channel itself is therefore not
+ * (role and turnId) is replayable by any client in the
+ * same authoritative Controller. The channel itself is therefore not
  * authenticated by those claims alone. A non-replayable per-Session caller key
  * closes the gap:
  *
@@ -213,10 +213,10 @@ function validateStartParams(store, params) {
  * - `task` scope: the caller must present `callerKey` — the
  *   `YUI_JOB_CALLER_KEY` injected at its native Session launch. The Controller
  *   hashes it (SHA-256) and compares against the durable `jobCallerKeyHashes`
- *   map for the caller's Role + Agent. No legacy fallback: an absent hash or a
+ *   map for the caller's Role + Agent. An absent hash or a
  *   mismatched key is UNAUTHORIZED.
  *
- * The existing Run binding checks run after the key check, so a forged
+ * The existing Turn binding checks run after the key check, so a forged
  * identity that also lacks the key is rejected at the channel boundary.
  */
 function assertCallerAuthorized(store, caller, taskId) {
@@ -257,16 +257,16 @@ function assertCallerAuthorized(store, caller, taskId) {
     if (caller.taskId !== taskId) {
         throw jobControlError("UNAUTHORIZED", "A managed Task Session may not start or cancel Jobs for a different Task.");
     }
-    if (caller.runId === undefined) {
-        throw jobControlError("UNAUTHORIZED", "A managed Task Session must bind its request to a Run.");
+    if (caller.turnId === undefined) {
+        throw jobControlError("UNAUTHORIZED", "A managed Task Session must bind its request to a Turn.");
     }
-    const run = store.getAgentRun(taskId, caller.runId);
+    const run = store.getTurn(taskId, caller.turnId);
     if (run === null || run.status !== "active" || run.roleName !== caller.role) {
-        throw jobControlError("UNAUTHORIZED", "A managed Task Session's Role is not bound to an active Run.");
+        throw jobControlError("UNAUTHORIZED", "A managed Task Session's Role is not bound to an active Turn.");
     }
     // rr13: Verify the non-replayable per-Session caller key. The key is injected
     // at native Session launch and never persisted in plaintext; only its SHA-256
-    // hash is durable. A client that reads state.json can see the hash but cannot
+    // hash is durable. A client with database read access can see the hash but cannot
     // recover the key.
     if (caller.callerKey === undefined) {
         throw jobControlError("UNAUTHORIZED", "job.start/job.cancel requires a managed Session caller key.");
@@ -490,7 +490,7 @@ function parseCaller(value) {
     const record = value;
     const allowed = new Set([
         "scope", "taskId", "role", "agentId", "adapterId", "launchId", "nativeSessionId",
-        "runId", "callerKey"
+        "turnId", "callerKey"
     ]);
     for (const key of Object.keys(record)) {
         if (!allowed.has(key)) {
@@ -512,7 +512,7 @@ function parseCaller(value) {
     const adapterId = optionalId("adapterId");
     const launchId = optionalId("launchId");
     const nativeSessionId = optionalId("nativeSessionId");
-    const runId = optionalId("runId");
+    const turnId = optionalId("turnId");
     const callerKey = record.callerKey === undefined
         ? undefined
         : requiredId(record.callerKey, "job caller callerKey");
@@ -524,7 +524,7 @@ function parseCaller(value) {
         ...(adapterId === undefined ? {} : { adapterId }),
         ...(launchId === undefined ? {} : { launchId }),
         ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
-        ...(runId === undefined ? {} : { runId }),
+        ...(turnId === undefined ? {} : { turnId }),
         ...(callerKey === undefined ? {} : { callerKey })
     };
 }

package/dist/controller/resourceInventory.js

@@ -32,7 +32,7 @@ export function createRuntimeResourceActivityTracker() {
             || roleKey === undefined)
             return reject();
         const identityKey = JSON.stringify([
-            identity.runId,
+            identity.turnId,
             identity.agentId,
             identity.adapterId,
             identity.nativeSessionId ?? null,
@@ -262,7 +262,7 @@ function roleOwner(role) {
             ...(role.adapterId === undefined ? {} : { adapterId: role.adapterId }),
             ...(role.nativeSessionId === undefined ? {} : { nativeSessionId: role.nativeSessionId }),
             ...(role.launchId === undefined ? {} : { launchId: role.launchId }),
-            ...(role.runId === undefined ? {} : { runId: role.runId })
+            ...(role.turnId === undefined ? {} : { turnId: role.turnId })
         };
     }
     return {
@@ -275,7 +275,7 @@ function roleOwner(role) {
         ...(role.adapterId === undefined ? {} : { adapterId: role.adapterId }),
         ...(role.nativeSessionId === undefined ? {} : { nativeSessionId: role.nativeSessionId }),
         ...(role.launchId === undefined ? {} : { launchId: role.launchId }),
-        ...(role.runId === undefined ? {} : { runId: role.runId })
+        ...(role.turnId === undefined ? {} : { turnId: role.turnId })
     };
 }
 function processTree(processes, rootPid) {
@@ -437,8 +437,8 @@ function matchesResourceIdentity(identity, owner) {
         || identity.taskId.length === 0
         || typeof identity.roleName !== "string"
         || identity.roleName.length === 0
-        || typeof identity.runId !== "string"
-        || identity.runId.length === 0
+        || typeof identity.turnId !== "string"
+        || identity.turnId.length === 0
         || typeof identity.agentId !== "string"
         || identity.agentId.length === 0
         || typeof identity.adapterId !== "string"
@@ -449,7 +449,7 @@ function matchesResourceIdentity(identity, owner) {
     if (owner.kind !== "task-role"
         || owner.taskId !== identity.taskId
         || owner.roleName !== identity.roleName
-        || owner.runId !== identity.runId
+        || owner.turnId !== identity.turnId
         || owner.agentId !== identity.agentId
         || owner.adapterId !== identity.adapterId)
         return false;

package/dist/controller/resourceInventoryLinux.js

@@ -3,7 +3,7 @@ import { existsSync, lstatSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { activeLiveRoleAgentSession } from "../executor/agentExecutor.js";
 import { inspectStorageSchema } from "../storage/storageSchema.js";
-import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
 import { TmuxManager, yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { tmuxSocketDirectory, tmuxSocketEnvironment } from "../tmux/tmuxSocketEndpoint.js";
@@ -450,8 +450,7 @@ function inspectRuntimeDomain(home, processes, roles, storageStatus, now) {
         // A current, ordinary YUI_HOME is a real control domain, not a disposable
         // test domain. Keep it visible even when it is currently idle so a stale
         // artifact cannot acquire ephemeral cleanup authority by omission. An
-        // uninitialized temporary directory with no runtime facts remains absent
-        // to preserve the legacy empty-home inventory behavior.
+        // uninitialized temporary directory with no runtime facts remains absent.
         if (storageStatus !== "current"
             && processes.length === 0
             && roles.length === 0)
@@ -614,19 +613,14 @@ function inspectRuntimeDomain(home, processes, roles, storageStatus, now) {
 }
 function loadHomeState(home, warnings, options) {
     const schema = (options.inspectStorage ?? inspectStorageSchema)(home);
-    const recordOnlyOlder = schema.status === "unsupported"
-        && schema.incompatibleComponent === "record"
-        && schema.direction === "older"
-        && schema.currentLayoutVersion === schema.latestLayoutVersion
-        && schema.currentAggregateSchemaVersion === schema.latestAggregateSchemaVersion;
-    if (schema.status !== "current" && !recordOnlyOlder) {
+    if (schema.status !== "current") {
         return {
             storageStatus: schema.status,
             roles: []
         };
     }
     try {
-        const store = (options.openCompatibleStore ?? openCompatibleFileTaskStore)(home);
+        const store = (options.openCurrentStore ?? openCurrentTaskStore)(home);
         const roles = [...store.listGlobalRoles()]
             .sort((left, right) => numericCompare(left.name, right.name))
             .map((role) => {
@@ -646,7 +640,7 @@ function loadHomeState(home, warnings, options) {
         const appendTaskRole = (task, role) => {
             const session = activeLiveRoleAgentSession(store.getRoleSessionSet(task.id, role.name));
             const binding = role.agentBindings[role.activeAgentId];
-            const run = store.getActiveAgentRun(task.id, role.name);
+            const run = store.getActiveTurn(task.id, role.name);
             const agentId = session?.effective.agentId ?? role.activeAgentId;
             const adapterId = session?.effective.adapterId ?? binding?.adapterId;
             roles.push({
@@ -659,57 +653,42 @@ function loadHomeState(home, warnings, options) {
                 ...(adapterId === undefined ? {} : { adapterId }),
                 ...(session === null ? {} : { nativeSessionId: session.nativeSessionId }),
                 ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
-                ...(run === null ? {} : { runId: run.id })
+                ...(run === null ? {} : { turnId: run.id })
             });
         };
-        // Layout-7 SQLite owns bounded active-Task and current-Session indexes.
-        // Use those indexes only as selectors, then point-read the authoritative
-        // Task/Role/Session/Run records so an index row cannot bypass ownership
-        // fences. The legacy File store intentionally retains its complete
-        // listTasks fallback because it has no equivalent active selector.
-        const hotStore = store;
-        const indexedTaskIds = hotStore.listActiveTaskIds === undefined
-            ? undefined
-            : [...new Set(hotStore.listActiveTaskIds())].sort(numericCompare);
-        if (indexedTaskIds === undefined) {
-            for (const task of store.listTasks()) {
-                for (const role of [...store.listRoles(task.id)].sort((left, right) => (numericCompare(left.name, right.name)))) {
-                    appendTaskRole(task, role);
-                }
-            }
+        // The current SQLite store owns bounded active-Task and current-Session
+        // indexes. Use them only as selectors, then point-read the authoritative
+        // Task/Role/Session/Turn records so an index row cannot bypass ownership
+        // fences.
+        const indexedTaskIds = [...new Set(store.listActiveTaskIds())].sort(numericCompare);
+        const sessionCandidates = store.listRuntimeSessionCandidates({ scope: "task" });
+        const candidateRoles = new Map();
+        for (const candidate of sessionCandidates) {
+            if (candidate.owner.scope !== "task")
+                continue;
+            const roleNames = candidateRoles.get(candidate.owner.taskId) ?? new Set();
+            roleNames.add(candidate.owner.roleName);
+            candidateRoles.set(candidate.owner.taskId, roleNames);
         }
-        else {
-            const sessionCandidates = typeof store.listRuntimeSessionCandidates === "function"
-                ? store.listRuntimeSessionCandidates({ scope: "task" })
-                : [];
-            const candidateRoles = new Map();
-            for (const candidate of sessionCandidates) {
-                if (candidate.owner.scope !== "task")
-                    continue;
-                const roleNames = candidateRoles.get(candidate.owner.taskId) ?? new Set();
-                roleNames.add(candidate.owner.roleName);
-                candidateRoles.set(candidate.owner.taskId, roleNames);
-            }
-            const activeTaskSet = new Set(indexedTaskIds);
-            const taskIds = [...new Set([
-                    ...indexedTaskIds,
-                    ...candidateRoles.keys()
-                ])].sort(numericCompare);
-            for (const taskId of taskIds) {
-                const task = store.getTask(taskId);
-                if (task === null)
-                    continue;
-                const rolesForTask = activeTaskSet.has(taskId) && task.status === "active"
-                    ? store.listRoles(taskId)
-                    : [...(candidateRoles.get(taskId) ?? [])]
-                        .sort(numericCompare)
-                        .flatMap((roleName) => {
-                        const role = store.getRole(taskId, roleName);
-                        return role === null ? [] : [role];
-                    });
-                for (const role of [...rolesForTask].sort((left, right) => (numericCompare(left.name, right.name)))) {
-                    appendTaskRole(task, role);
-                }
+        const activeTaskSet = new Set(indexedTaskIds);
+        const taskIds = [...new Set([
+                ...indexedTaskIds,
+                ...candidateRoles.keys()
+            ])].sort(numericCompare);
+        for (const taskId of taskIds) {
+            const task = store.getTask(taskId);
+            if (task === null)
+                continue;
+            const rolesForTask = activeTaskSet.has(taskId) && task.status === "active"
+                ? store.listRoles(taskId)
+                : [...(candidateRoles.get(taskId) ?? [])]
+                    .sort(numericCompare)
+                    .flatMap((roleName) => {
+                    const role = store.getRole(taskId, roleName);
+                    return role === null ? [] : [role];
+                });
+            for (const role of [...rolesForTask].sort((left, right) => (numericCompare(left.name, right.name)))) {
+                appendTaskRole(task, role);
             }
         }
         return {

package/dist/controller/resourceInventoryRpc.js

@@ -4,7 +4,7 @@
  *
  * The `/proc` scanning in `resourceInventoryLinux` is blocking IO (hundreds of
  * `readFileSync` calls per pass, `spawnSync`, tmux inspection). When the worker
- * backend is active (`YUI_STORE_BACKEND=sqlite` + `YUI_STORE_WORKER=1`, the same
+ * persistence worker is active (`YUI_STORE_WORKER=1`, the same
  * flag as the persistence worker, §6), the Controller runtime and the ephemeral
  * reaper scan through this client instead: the scan runs in the inventory
  * worker (its own thread), the main event loop stays free, and the result is
@@ -17,8 +17,8 @@
  *   worker -> main: ready | result | error
  *
  * Only structured-cloneable scan options cross the port (the file-backed
- * `inspectStorage` / `openCompatibleStore` / `now` seams stay on the direct
- * path, which the file backend still uses). The inventory worker never touches
+ * `inspectStorage` / `openCurrentStore` / `now` seams stay on the direct
+ * path used without the worker). The inventory worker never touches
  * the persistence worker's database connection (§3.3): it is a separate worker
  * with a separate concern.
  */

package/dist/controller/resourceInventoryWorker.js

@@ -3,7 +3,7 @@
  *
  * Runs the blocking `/proc` scanning of `resourceInventoryLinux` off the main
  * thread. The main thread asks for a scan over a `MessageChannel` port; the
- * worker runs the exact same `scanControllerResourceInventory` the file backend
+ * worker runs the exact same `scanControllerResourceInventory` as the main thread
  * calls directly and posts the inventory back. Because worker threads share the
  * process, the scanner's self-exclusion (`process.pid`, its start identity)
  * keeps excluding the Controller process exactly as on the main thread.

package/dist/controller/runtime.js

@@ -11,7 +11,7 @@ import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleF
 import { AgentConfigurationCatalogService, validateAgentLaunchConfiguration } from "../executor/agentConfigurationCatalog.js";
 import { isTaskOwnedWorkspace, managedWorkspaceIdentity, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
 import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
-import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { SqliteTaskStore } from "../storage/sqliteStore.js";
 import { AsyncTaskStoreClient, resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
@@ -45,13 +45,13 @@ import { createTaskEvent } from "../event/taskEvent.js";
 export function refreshAppliedTaskRuntimeDescriptor(store, planner, input) {
     if (input.launchId === undefined)
         return;
-    const run = input.runId === undefined
+    const run = input.turnId === undefined
         ? null
-        : store.getAgentRun(input.taskId, input.runId);
-    if (input.runId !== undefined && run === null) {
+        : store.getTurn(input.taskId, input.turnId);
+    if (input.turnId !== undefined && run === null) {
         throw new Error("Prepared Task runtime generation is not current.");
     }
-    // A terminal completion has already settled this exact Run and no later
+    // A terminal completion has already settled this exact Turn and no later
     // prompt can use its descriptor. Acknowledge the applied provider fact
     // without republishing a dead generation.
     if (run !== null && run.status !== "active")
@@ -76,22 +76,18 @@ export function refreshAppliedTaskRuntimeDescriptor(store, planner, input) {
         workspace: effective.workspace.root
     });
 }
-/** Production composition root for the lean FileTaskStore + tmux Controller. */
+/** Production composition root for the current SQLite TaskStore + tmux Controller. */
 export async function startFileTaskControllerRuntime(home, options = {}) {
-    // The Home decides the backend (Issue 01): a layout-7 Home runs SQLite with
-    // the persistence worker on by default; YUI_STORE_WORKER=0/false forces the
-    // in-process SQLite connection. The non-worker path opens the Home-decided
-    // backend through the compatibility opener (SQLite for layout 7, file store
-    // with normalization for older layouts).
+    // The current Home always uses SQLite. The persistence worker is enabled by
+    // default; YUI_STORE_WORKER=0/false keeps the same database in-process.
     const useWorker = resolveStoreWorkerEnabledForHome(home, options.environment ?? process.env);
     const store = options.store
         ?? (useWorker
-            // Transitional: the scheduler/planner still use a sync store. The worker
-            // owns the event-processing hot path; the scheduler migration is the next
-            // step (see work-item-5 remaining call sites). Both connections point at
-            // the same WAL db and serialize via BEGIN IMMEDIATE + busy_timeout.
+            // The worker owns the event-processing hot path while the scheduler uses
+            // the synchronous connection. Both point at the same WAL database and
+            // serialize via BEGIN IMMEDIATE + busy_timeout.
             ? new SqliteTaskStore(home)
-            : openCompatibleFileTaskStore(home));
+            : openCurrentTaskStore(home));
     const homeId = store.getHomeIdentity().homeId;
     const durableConfig = store.getConfig();
     // When the worker backend is active, the db-touching observer folds run in
@@ -259,9 +255,8 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         onCleanupRequired: signalRuntimeCleanup,
         runtimeIsolation
     });
-    // One inventory scan per scheduler pass. When the worker backend is active
-    // the blocking /proc scan runs in the inventory worker; otherwise it runs on
-    // the main thread (file backend, unchanged).
+    // One inventory scan per scheduler pass. When the inventory worker is active
+    // the blocking /proc scan runs there; otherwise it runs on the main thread.
     const scanInventory = (panes) => inventoryClient !== undefined
         ? inventoryClient.scan({
             currentHome: home,
@@ -297,7 +292,7 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                     && candidate.roleName === owner.roleName));
                 if (input === undefined)
                     return [];
-                const identity = owner.runId === undefined
+                const identity = owner.turnId === undefined
                     || owner.adapterId === undefined
                     || (owner.nativeSessionId === undefined && owner.launchId === undefined)
                     || (owner.nativeSessionId !== undefined && owner.nativeSessionId.trim().length === 0)
@@ -306,7 +301,7 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                     : {
                         taskId: owner.taskId,
                         roleName: owner.roleName,
-                        runId: owner.runId,
+                        turnId: owner.turnId,
                         agentId: owner.agentId,
                         adapterId: owner.adapterId,
                         ...(owner.nativeSessionId === undefined
@@ -314,12 +309,12 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                             : { nativeSessionId: owner.nativeSessionId }),
                         ...(owner.launchId === undefined ? {} : { launchId: owner.launchId })
                     };
-                const changed = !active || input.runId === undefined
+                const changed = !active || input.turnId === undefined
                     ? false
                     : resourceActivity({
                         taskId: input.taskId,
                         roleName: input.roleName,
-                        runId: input.runId,
+                        turnId: input.turnId,
                         agentId: input.agentId,
                         adapterId: input.adapterId,
                         ...(input.nativeSessionId === undefined
@@ -570,7 +565,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 schedulerStore.beginAgentHostProviderTurn({
                     taskId: value.taskId,
                     roleName: value.roleName,
-                    runId: value.runId,
+                    ...(value.turnId === undefined ? {} : { turnId: value.turnId }),
                     agentId: value.agentId,
                     launchId: value.launchId,
                     nativeSessionId: value.nativeSessionId,
@@ -602,7 +597,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             schedulerStore.resolveAgentHostProviderTurnSubmission({
                 taskId: value.taskId,
                 roleName: value.roleName,
-                runId: value.runId,
+                ...(value.turnId === undefined ? {} : { turnId: value.turnId }),
                 attemptId: value.attemptId,
                 status,
                 reason,
@@ -613,9 +608,9 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
         }
         if (method === "runtime.process-exit-observe") {
             const observation = validateRuntimeProcessExitObservation(params);
-            const run = observation.taskId === undefined || observation.runId === undefined
+            const run = observation.taskId === undefined || observation.turnId === undefined
                 ? null
-                : store.getAgentRun(observation.taskId, observation.runId);
+                : store.getTurn(observation.taskId, observation.turnId);
             const globalRole = observation.taskId === undefined
                 ? store.getGlobalRole(observation.roleName)
                 : null;
@@ -625,20 +620,20 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 ? null
                 : builtinAgentDriverRegistry().findByAdapterId(adapterId);
             const turnTerminalObserved = observation.taskId !== undefined
-                && observation.runId !== undefined
+                && observation.turnId !== undefined
                 && store.listEvents(observation.taskId).some((event) => {
                     const runtime = runtimeObservationFromTaskEvent(event);
                     return runtime !== null
-                        && runtime.fence.runId === observation.runId
+                        && runtime.fence.turnId === observation.turnId
                         && ["turn.completed", "turn.failed", "turn.cancelled"].includes(runtime.kind)
                         && Date.parse(runtime.receivedAt) <= Date.parse(observation.observedAt);
                 });
             const turnFailureObserved = observation.taskId !== undefined
-                && observation.runId !== undefined
+                && observation.turnId !== undefined
                 && store.listEvents(observation.taskId).some((event) => {
                     const runtime = runtimeObservationFromTaskEvent(event);
                     return runtime !== null
-                        && runtime.fence.runId === observation.runId
+                        && runtime.fence.turnId === observation.turnId
                         && runtime.fence.launchId === observation.launchId
                         && runtime.kind === "turn.failed"
                         && Date.parse(runtime.receivedAt) <= Date.parse(observation.observedAt);
@@ -750,20 +745,20 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                     ? `Role not found: ${request.taskId}/${request.roleName}.`
                     : `Global Role not found: ${request.roleName}.`);
             }
-            const activeRun = request.scope === "task"
-                ? store.getActiveAgentRun(request.taskId, request.roleName)
+            const activeTurn = request.scope === "task"
+                ? store.getActiveTurn(request.taskId, request.roleName)
                 : null;
-            if (request.scope === "task" && activeRun === null) {
-                throw applicationError("INVALID_PARAMS", "Task Role runtime attachment requires an admitted active Run; it cannot create an empty Provider Conversation.");
+            if (request.scope === "task" && activeTurn === null) {
+                throw applicationError("INVALID_PARAMS", "Task Role runtime attachment requires an admitted active Turn; it cannot create an empty Provider Conversation.");
             }
             const managedWorkspace = request.scope === "task"
-                ? activeRun?.workspace
+                ? activeTurn?.workspace
                     ?? currentDesiredManagedWorkspace(store, request.taskId, request.roleName)
                 : undefined;
             const sessions = request.scope === "task"
                 ? store.getTaskRoleSessionSet(request.taskId, request.roleName)
                 : store.getGlobalRoleSessionSet(request.roleName);
-            const effective = activeRun?.effective
+            const effective = activeTurn?.effective
                 ?? activeLiveRoleAgentSession(sessions)?.effective
                 ?? resolveRuntimeDesiredEffective(store, request, role);
             const binding = role.agentBindings[effective.agentId];
@@ -776,14 +771,12 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             }
             validateLifecycleEnvironment(request.environment, agent);
             const session = sessions?.sessions[effective.agentId];
-            const managedTurnDispatch = activeRun !== null && (activeRun.pushedAt === undefined
-                || activeRun.controlRequest?.state === "dispatching");
-            // An ensure call may reattach the already-admitted Run to its existing
+            // An ensure call may reattach the already-admitted Turn to its existing
             // Conversation, but it may not manufacture a fresh Conversation without a
-            // pending managed Turn. Fresh replacement remains owned by Run dispatch.
-            const mode = activeRun === null
+            // pending managed Turn. Fresh replacement remains owned by Turn dispatch.
+            const mode = activeTurn === null
                 ? roleAgentSessionResumeMode(sessions, effective.agentId, effective)
-                : managedTurnDispatch ? activeRun.mode : "resume";
+                : session?.nativeSessionId === undefined ? activeTurn.mode : "resume";
             if (request.scope === "task" && mode === "resume"
                 && (session?.nativeSessionId === undefined
                     || session.nativeSessionId.trim().length === 0)) {
@@ -799,7 +792,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 effective,
                 workspace: effective.workspace.root,
                 ...(managedWorkspace === undefined ? {} : { managedWorkspace }),
-                ...(activeRun === null ? {} : { runId: activeRun.id }),
+                ...(activeTurn === null ? {} : { turnId: activeTurn.id }),
                 ...(request.environment === undefined
                     ? {}
                     : { environment: request.environment })
@@ -852,7 +845,7 @@ function resolveRuntimeDesiredEffective(store, request, role) {
     });
 }
 function assertRuntimeLaunchRequestCurrent(store, request) {
-    let activeRun = null;
+    let activeTurn = null;
     if (request.owner.scope === "task") {
         const task = store.getTask(request.owner.taskId);
         if (task === null
@@ -860,10 +853,10 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
             || task.executionGate.state !== "enabled") {
             throw new Error(`Task is no longer active: ${request.owner.taskId}.`);
         }
-        activeRun = store.getActiveAgentRun(request.owner.taskId, request.owner.roleName);
-        if (request.runId !== undefined
-            && activeRun?.id !== request.runId) {
-            throw new Error(`Role Run is no longer current: ${request.runId}.`);
+        activeTurn = store.getActiveTurn(request.owner.taskId, request.owner.roleName);
+        if (request.turnId !== undefined
+            && activeTurn?.id !== request.turnId) {
+            throw new Error(`Role Turn is no longer current: ${request.turnId}.`);
         }
     }
     const role = request.owner.scope === "task"
@@ -875,8 +868,8 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
     const sessions = request.owner.scope === "task"
         ? store.getTaskRoleSessionSet(request.owner.taskId, request.owner.roleName)
         : store.getGlobalRoleSessionSet(request.owner.roleName);
-    const expectedEffective = request.owner.scope === "task" && request.runId !== undefined
-        ? activeRun?.effective
+    const expectedEffective = request.owner.scope === "task" && request.turnId !== undefined
+        ? activeTurn?.effective
         : activeLiveRoleAgentSession(sessions)?.effective
             ?? currentDesiredEffective(store, request, role);
     if (expectedEffective === undefined
@@ -887,7 +880,7 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
         throw new Error(`Role launch state changed: ${request.owner.roleName}.`);
     }
     if (request.owner.scope === "task" && request.managedWorkspace !== undefined) {
-        const expectedWorkspace = activeRun?.workspace
+        const expectedWorkspace = activeTurn?.workspace
             ?? currentDesiredManagedWorkspace(store, request.owner.taskId, request.owner.roleName);
         if (expectedWorkspace === undefined
             || !sameManagedWorkspaceIdentity(expectedWorkspace, request.managedWorkspace)) {
@@ -1129,7 +1122,7 @@ function providerTurnControlParams(params) {
     return {
         taskId: requiredParam(value.taskId),
         roleName: requiredParam(value.roleName),
-        runId: requiredParam(value.runId),
+        ...(value.turnId === undefined ? {} : { turnId: requiredParam(value.turnId) }),
         agentId: requiredParam(value.agentId),
         launchId: requiredParam(value.launchId),
         nativeSessionId: requiredParam(value.nativeSessionId),