@zq-silk/yui 0.13.9 → 0.14.0

package/dist/executor/agentExecutor.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
+import { hasRecentTurnId, rememberRecentTurnId, validateRecentTurnIds } from "../runtime/recentTurnIds.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
 import { currentProviderActivation, endProviderActivation, settleProviderTurn, settleProviderTurnSubmission, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
@@ -14,8 +14,7 @@ export function createRoleSessionSet(owner, activeAgentId, now) {
         ? { ...base, schemaVersion: 4 }
         : {
             ...base,
-            schemaVersion: 8,
-            inFlight: null,
+            schemaVersion: 11,
             providerBinding: null
         };
 }
@@ -179,9 +178,6 @@ export function updateRoleAgentSessionStatus(set, agentId, status, now, endReaso
 }
 export function retireTaskRoleSessionsForWorkspace(set, now) {
     validateRoleSessionSet(set);
-    if (set.inFlight !== null) {
-        throw new Error("Cannot retire a Task Role session with unsettled Run state.");
-    }
     const live = Object.values(set.sessions).find(({ status }) => status === "active");
     if (live !== undefined) {
         throw new Error(`Task Role session must be stopped before workspace migration: ${live.agentId}.`);
@@ -205,9 +201,6 @@ export function retireTaskRoleSessionsForWorkspace(set, now) {
  */
 export function retireConfirmedAbsentInactiveTaskRolePlaceholders(set, now) {
     validateRoleSessionSet(set);
-    if (set.inFlight !== null) {
-        throw new Error("Cannot retire a Task Role placeholder with unsettled Run state.");
-    }
     const timestamp = now.toISOString();
     let changed = false;
     const sessions = Object.fromEntries(Object.entries(set.sessions).map(([agentId, session]) => {
@@ -295,35 +288,6 @@ export function roleAgentSessionResumeMode(set, agentId, desired) {
     throw new Error(`Role Agent session is incompatible with the next effective launch: ${agentId}. `
         + "Stop the existing native process before starting a fresh Session.");
 }
-export function bindTaskRoleRun(set, fence, preparedAt, mode) {
-    validateRoleSessionSet(set);
-    assertTaskRoleSessionSet(set);
-    const normalized = normalizeTaskRoleRunFence(fence);
-    if (normalized.agentId !== set.activeAgentId) {
-        throw new Error("Task Role Run Agent does not match the active Agent.");
-    }
-    if (set.inFlight !== null) {
-        if (sameRunFence(set.inFlight, normalized))
-            return set;
-        throw new Error("Task Role session set already has an in-flight Run.");
-    }
-    const timestamp = requireDate(preparedAt, "Task Role Run preparedAt");
-    // A fresh Session follows physical cleanup and does not inherit runtime
-    // evidence from the disposable old Conversation. A resumed Session keeps
-    // that evidence unchanged here: claiming a durable Run is a workflow
-    // mutation, not a Provider operation. AgentHost binds the Conversation to
-    // this Run only when it can actually submit the next serialized Turn.
-    const providerBinding = mode === "new"
-        ? null
-        : set.providerBinding;
-    const updated = {
-        ...set,
-        inFlight: { ...normalized, preparedAt: timestamp },
-        providerBinding,
-        updatedAt: timestamp
-    };
-    return validateRoleSessionSet(updated);
-}
 export function bindTaskRoleProviderRuntime(set, binding, updatedAt) {
     validateRoleSessionSet(set);
     const normalized = validateProviderRuntimeBinding(binding);
@@ -382,9 +346,9 @@ export function detachRoleAgentSessionHost(set, now) {
     let binding = taskSet.providerBinding;
     const turn = binding?.turn;
     if (binding !== null && binding !== undefined && turn !== null && turn !== undefined
-        && ["accepted", "running"].includes(turn.status)) {
+        && turn.status === "accepted") {
         binding = settleProviderTurn(binding, {
-            turnId: turn.turnId,
+            nativeTurnId: turn.nativeTurnId,
             status: "cancelled",
             settledAt: timestamp,
             reason: "runtime-physical-exit"
@@ -413,51 +377,13 @@ export function detachRoleAgentSessionHost(set, now) {
     }
     return taskSet;
 }
-export function markTaskRoleRunPushed(set, fence, pushedAt) {
-    validateRoleSessionSet(set);
-    assertTaskRoleSessionSet(set);
-    const inFlight = requireMatchingInFlight(set, fence);
-    if (inFlight.pushedAt !== undefined)
-        return set;
-    const timestamp = requireDate(pushedAt, "Task Role Run pushedAt");
-    if (Date.parse(timestamp) < Date.parse(inFlight.preparedAt)) {
-        throw new Error("Task Role Run pushedAt must not be earlier than preparedAt.");
-    }
-    const updated = {
-        ...set,
-        inFlight: { ...inFlight, pushedAt: timestamp },
-        updatedAt: timestamp
-    };
-    return validateRoleSessionSet(updated);
-}
-export function markTaskRoleRunDelivered(set, fence, deliveredAt) {
-    validateRoleSessionSet(set);
-    assertTaskRoleSessionSet(set);
-    const inFlight = requireMatchingInFlight(set, fence);
-    if (inFlight.deliveredAt !== undefined)
-        return set;
-    const timestamp = requireDate(deliveredAt, "Task Role Run deliveredAt");
-    if (Date.parse(timestamp) < Date.parse(inFlight.preparedAt)) {
-        throw new Error("Task Role Run deliveredAt must not be earlier than preparedAt.");
-    }
-    const updated = {
-        ...set,
-        inFlight: {
-            ...inFlight,
-            ...(inFlight.pushedAt === undefined ? { pushedAt: timestamp } : {}),
-            deliveredAt: timestamp
-        },
-        updatedAt: timestamp
-    };
-    return validateRoleSessionSet(updated);
-}
 /**
- * Records a provider Turn boundary without changing the durable Yui Run.
+ * Records a Provider activity boundary without changing the durable Yui Turn.
  *
  * A native session may finish one foreground Turn while provider-owned
  * subagents, mailbox work, or later user corrections still belong to the same
- * application-level Run.  Only an explicit Yui workflow outcome may clear the
- * Run fence; this transition merely makes the native session available for a
+ * application-level Turn. Only the native Provider terminal may clear the
+ * Turn fence; this transition merely makes the native Session available for a
  * subsequent input and remembers the provider Turn idempotently.
  */
 export function recordTaskRoleTurnBoundary(set, input, completedAt) {
@@ -472,9 +398,6 @@ export function recordTaskRoleTurnBoundary(set, input, completedAt) {
     }
     if (session.recentCompletedTurnIds.includes(turnId))
         return set;
-    if (set.inFlight !== null && set.inFlight.agentId !== agentId) {
-        throw new Error("Completed Turn Agent does not match the in-flight Run.");
-    }
     const timestamp = requireDate(completedAt, "Turn completedAt");
     return validateRoleSessionSet({
         ...set,
@@ -489,94 +412,19 @@ export function recordTaskRoleTurnBoundary(set, input, completedAt) {
         updatedAt: timestamp
     });
 }
-export function recordObservedTaskRoleCompletion(set, completion) {
-    const observed = validatePendingTurnCompletion(completion);
-    return recordTaskRoleTurnBoundary(set, {
-        agentId: observed.agentId,
-        nativeSessionId: observed.nativeSessionId,
-        turnId: observed.turnId
-    }, new Date(observed.observedAt));
-}
-/**
- * Rebinds the same active Run to a bounded control-input receipt while keeping
- * its observed native Turn completion unsettled. No new Run fence is created.
- */
-export function rebindTaskRoleRunControlReceipt(set, input, now) {
-    validateRoleSessionSet(set);
-    assertTaskRoleSessionSet(set);
-    const inFlight = set.inFlight;
-    if (inFlight === null
-        || inFlight.agentId !== input.agentId
-        || inFlight.runId !== input.runId) {
-        throw new Error("Workflow outcome control request does not match the unsettled Run.");
-    }
-    const timestamp = requireDate(now, "Workflow outcome control receipt timestamp");
-    return validateRoleSessionSet({
-        ...set,
-        inFlight: {
-            ...inFlight,
-            receiptId: requireSafeIdentity(input.receiptId, "Workflow outcome control receipt id")
-        },
-        updatedAt: timestamp
-    });
-}
-export function clearTaskRoleRun(set, fence, clearedAt) {
-    validateRoleSessionSet(set);
-    assertTaskRoleSessionSet(set);
-    const inFlight = requireMatchingInFlight(set, fence);
-    const timestamp = requireDate(clearedAt, "Task Role Run clearedAt");
-    if (Date.parse(timestamp) < Date.parse(inFlight.preparedAt)) {
-        throw new Error("Task Role Run clearedAt must not be earlier than preparedAt.");
-    }
-    const updated = {
-        ...set,
-        inFlight: null,
-        updatedAt: timestamp
-    };
-    return validateRoleSessionSet(updated);
-}
-/**
- * Applies an authoritative application-level Run terminal fact to its exact
- * delivery receipt. Provider lifecycle remains independent: only the matching
- * native Turn boundary may move the Session from running to ready. AgentHost
- * serializes a retained next delivery while that Turn is still active.
- */
-export function terminalizeTaskRoleRunSession(set, fence, terminalAt) {
-    validateRoleSessionSet(set);
-    const inFlight = set.inFlight;
-    return inFlight === null ? set : clearTaskRoleRun(set, fence, terminalAt);
-}
-export function settleTaskRoleCompletion(set, expected, settledAt) {
-    validateRoleSessionSet(set);
-    assertTaskRoleSessionSet(set);
-    const agentId = requireSafeIdentity(expected.agentId, "Agent id");
-    const runId = requireSafeIdentity(expected.runId, "Run id");
-    const turnId = requireText(expected.turnId, "Turn id");
-    const inFlight = set.inFlight;
-    if (inFlight === null || inFlight.agentId !== agentId || inFlight.runId !== runId) {
-        throw new Error("Pending Turn completion does not match the in-flight Run.");
-    }
-    const session = set.sessions[agentId];
-    if (session === undefined || !session.recentCompletedTurnIds.includes(turnId)) {
-        throw new Error("Turn completion has not been observed for the Role Agent session.");
-    }
-    const timestamp = requireDate(settledAt, "Turn settledAt");
-    const updated = {
-        ...set,
-        sessions: {
-            ...set.sessions,
-            [agentId]: {
-                ...session,
-                recentCompletedTurnIds: session.recentCompletedTurnIds,
-                updatedAt: timestamp
-            }
-        },
-        inFlight: null,
-        updatedAt: timestamp
-    };
-    return validateRoleSessionSet(updated);
-}
 export function validateRoleSessionSet(set) {
+    const ownerScope = set.owner?.scope;
+    rejectUnknownFields(set, ownerScope === "global"
+        ? ["schemaVersion", "owner", "activeAgentId", "sessions", "updatedAt", "history"]
+        : [
+            "schemaVersion",
+            "owner",
+            "activeAgentId",
+            "sessions",
+            "updatedAt",
+            "history",
+            "providerBinding"
+        ], "Role session set");
     normalizeOwner(set.owner);
     requireSafeIdentity(set.activeAgentId, "Active Agent id");
     for (const [agentId, session] of Object.entries(set.sessions)) {
@@ -586,8 +434,7 @@ export function validateRoleSessionSet(set) {
         if (set.schemaVersion !== 4) {
             throw new Error("Global Role session set schema version is invalid.");
         }
-        if (Object.hasOwn(set, "inFlight")
-            || Object.hasOwn(set, "providerBinding")) {
+        if (Object.hasOwn(set, "providerBinding")) {
             throw new Error("Global Role session set must not contain Task Role lifecycle fields.");
         }
         const history = set.history;
@@ -602,12 +449,11 @@ export function validateRoleSessionSet(set) {
         }
     }
     else {
-        if (set.schemaVersion !== 8) {
+        if (set.schemaVersion !== 11) {
             throw new Error("Task Role session set schema version is invalid.");
         }
-        if (!Object.hasOwn(set, "inFlight")
-            || !Object.hasOwn(set, "providerBinding")) {
-            throw new Error("Task Role session set must contain its Turn fence.");
+        if (!Object.hasOwn(set, "providerBinding")) {
+            throw new Error("Task Role session set must contain its Provider Runtime Binding.");
         }
         const taskSet = set;
         if (taskSet.history !== undefined) {
@@ -632,17 +478,11 @@ export function validateRoleSessionSet(set) {
                 }
             }
         }
-        const inFlight = taskSet.inFlight === null
-            ? null
-            : validateTaskRoleInFlight(taskSet.inFlight);
         const providerBinding = taskSet.providerBinding === null
             ? null
             : validateProviderRuntimeBinding(taskSet.providerBinding);
-        if (inFlight !== null && inFlight.agentId !== set.activeAgentId) {
-            throw new Error("Task Role in-flight Run Agent must be active.");
-        }
         if (providerBinding !== null) {
-            const session = taskSet.sessions[inFlight?.agentId ?? set.activeAgentId];
+            const session = taskSet.sessions[set.activeAgentId];
             if (session === undefined) {
                 throw new Error("Provider Runtime Binding has no active Role Agent session.");
             }
@@ -732,93 +572,12 @@ function assertTaskRoleSessionSet(set) {
         throw new Error("Turn fences require a Task Role session set.");
     }
 }
-function normalizeTaskRoleRunFence(fence) {
-    return {
-        agentId: requireSafeIdentity(fence.agentId, "Agent id"),
-        runId: requireSafeIdentity(fence.runId, "Run id"),
-        receiptId: requireText(fence.receiptId, "Delivery receipt id")
-    };
-}
-function requireMatchingInFlight(set, fence) {
-    const normalized = normalizeTaskRoleRunFence(fence);
-    const inFlight = set.inFlight;
-    if (inFlight === null)
-        throw new Error("Task Role session set has no in-flight Run.");
-    if (inFlight.agentId !== normalized.agentId) {
-        throw new Error("Task Role Run Agent does not match the in-flight Run.");
-    }
-    if (inFlight.runId !== normalized.runId) {
-        throw new Error("Task Role Run does not match the in-flight Run.");
-    }
-    if (inFlight.receiptId !== normalized.receiptId) {
-        throw new Error("Task Role Run receipt does not match the in-flight Run.");
-    }
-    return inFlight;
-}
-function validateTaskRoleInFlight(value) {
-    const fields = Object.keys(value);
-    const unknown = fields.find((field) => !["agentId", "runId", "receiptId", "preparedAt", "pushedAt", "deliveredAt"].includes(field));
-    if (unknown !== undefined) {
-        throw new Error(`Task Role in-flight Run has unknown field: ${unknown}.`);
-    }
-    for (const required of ["agentId", "runId", "receiptId", "preparedAt"]) {
-        if (!Object.hasOwn(value, required)) {
-            throw new Error(`Task Role in-flight Run is missing field: ${required}.`);
-        }
-    }
-    const preparedAt = requirePersistedTimestamp(value.preparedAt, "Task Role Run preparedAt");
-    if (value.pushedAt !== undefined) {
-        const pushedAt = requirePersistedTimestamp(value.pushedAt, "Task Role Run pushedAt");
-        if (Date.parse(pushedAt) < Date.parse(preparedAt)) {
-            throw new Error("Task Role Run pushedAt must not be earlier than preparedAt.");
-        }
-    }
-    if (value.deliveredAt !== undefined) {
-        const deliveredAt = requirePersistedTimestamp(value.deliveredAt, "Task Role Run deliveredAt");
-        if (Date.parse(deliveredAt) < Date.parse(preparedAt)) {
-            throw new Error("Task Role Run deliveredAt must not be earlier than preparedAt.");
-        }
-        if (value.pushedAt === undefined) {
-            throw new Error("Task Role Run deliveredAt requires a prior pushedAt.");
-        }
-    }
-    requireSafeIdentity(value.agentId, "Agent id");
-    requireSafeIdentity(value.runId, "Run id");
-    requireText(value.receiptId, "Delivery receipt id");
-    return value;
-}
-function assertCompletionOwner(set, completion) {
-    if (completion.taskId !== set.owner.taskId) {
-        throw new Error("Observed Turn Task does not match the Task Role session set.");
-    }
-    if (completion.roleName !== set.owner.roleName) {
-        throw new Error("Observed Turn Role does not match the Task Role session set.");
-    }
-    if (completion.agentId !== set.activeAgentId) {
-        throw new Error("Observed Turn Agent does not match the active Agent.");
-    }
-}
-function sameRunFence(inFlight, fence) {
-    return inFlight.agentId === fence.agentId
-        && inFlight.runId === fence.runId
-        && inFlight.receiptId === fence.receiptId;
-}
-function samePendingTurnCompletion(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
-}
 function requireDate(value, label) {
     if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
         throw new Error(`${label} must be a valid date.`);
     }
     return value.toISOString();
 }
-function requirePersistedTimestamp(value, label) {
-    const timestamp = Date.parse(value);
-    if (!Number.isFinite(timestamp) || new Date(timestamp).toISOString() !== value) {
-        throw new Error(`${label} must be a canonical timestamp.`);
-    }
-    return value;
-}
 function normalizeOwner(owner) {
     const roleName = requireSafeIdentity(owner.roleName, "Role name");
     return owner.scope === "global"
@@ -840,6 +599,12 @@ function requireSafeIdentity(value, label) {
     }
     return normalized;
 }
+function rejectUnknownFields(value, fields, label) {
+    const allowed = new Set(fields);
+    const unknown = Object.keys(value).find((field) => !allowed.has(field));
+    if (unknown !== undefined)
+        throw new Error(`${label} has unknown field: ${unknown}.`);
+}
 function requireText(value, label) {
     if (typeof value !== "string" || value.includes("\0"))
         throw new Error(`${label} is invalid.`);

package/dist/executor/effectiveLaunch.js

@@ -79,7 +79,7 @@ export function effectiveLaunchSnapshotsCompatible(existing, desired) {
     return isDeepStrictEqual(withoutDesiredRevision(existing), withoutDesiredRevision(desired));
 }
 /**
- * Task Role Sessions keep one physical workspace while Run-scoped facts move.
+ * Task Role Sessions keep one physical workspace while Turn-scoped facts move.
  * Candidate commits, ReviewRound identity and desired-revision bookkeeping do
  * not define a native Session. Agent, adapter, permission, model, sandbox,
  * manifest, Role context and physical workspace identity still do.
@@ -99,7 +99,7 @@ export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
     validateEffectiveLaunchSnapshot(existing);
     validateManagedWorkspace(workspace);
     if (workspace.owner.type !== "task") {
-        throw new Error("Only a Task-owned main workspace may refresh fixed Session Run evidence.");
+        throw new Error("Only a Task-owned main workspace may refresh fixed Session Turn evidence.");
     }
     return validateEffectiveLaunchSnapshot({
         ...existing,
@@ -120,8 +120,8 @@ function taskSessionCompatibleSnapshot(snapshot) {
     };
 }
 export function validateEffectiveLaunchSnapshot(snapshot) {
-    if (snapshot.schemaVersion !== 2) {
-        throw new Error("Effective launch snapshot must use schemaVersion 2.");
+    if (snapshot.schemaVersion !== 3) {
+        throw new Error("Effective launch snapshot must use schemaVersion 3.");
     }
     positiveInteger(snapshot.sourceDesiredRevision, "Source desired revision");
     identity(snapshot.agentId, "Effective Agent id");
@@ -148,18 +148,12 @@ export function validateEffectiveLaunchSnapshot(snapshot) {
         identity(snapshot.reviewRoundId, "Effective ReviewRound id");
         commit(snapshot.reviewBaseCommit, "Effective review base commit");
     }
-    if (snapshot.contextProtocolVersion !== undefined
-        && snapshot.contextProtocolVersion !== SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION) {
+    if (snapshot.contextProtocolVersion !== SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION) {
         throw new Error("Effective launch context protocol version is unsupported.");
     }
-    if (snapshot.sessionManifestCompatibilityDigest !== undefined
-        && !/^[a-f0-9]{64}$/u.test(snapshot.sessionManifestCompatibilityDigest)) {
+    if (!/^[a-f0-9]{64}$/u.test(snapshot.sessionManifestCompatibilityDigest)) {
         throw new Error("Effective launch Session Manifest compatibility digest is invalid.");
     }
-    if ((snapshot.contextProtocolVersion === undefined)
-        !== (snapshot.sessionManifestCompatibilityDigest === undefined)) {
-        throw new Error("Effective launch Context protocol compatibility identity is incomplete.");
-    }
     validateWorkspace(snapshot.workspace);
     cloneContext(snapshot.context);
     const config = effectiveLaunchConfigUnchecked(snapshot);
@@ -198,7 +192,7 @@ function snapshotFromConfig(input) {
             reviewBaseCommit: commit(input.reviewBaseCommit ?? "", "Review base commit")
         };
     const common = {
-        schemaVersion: 2,
+        schemaVersion: 3,
         sourceDesiredRevision: positiveInteger(input.sourceDesiredRevision, "Source desired revision"),
         agentId: identity(input.agentId, "Effective Agent id"),
         profileAccess: input.profileAccess,
@@ -212,12 +206,8 @@ function snapshotFromConfig(input) {
         writeProjectIds: [...input.writeProjectIds],
         workspace: cloneWorkspace(input.workspace),
         context: cloneContext(input.context),
-        ...(input.contextProtocolVersion === undefined
-            ? {}
-            : { contextProtocolVersion: input.contextProtocolVersion }),
-        ...(input.sessionManifestCompatibilityDigest === undefined
-            ? {}
-            : { sessionManifestCompatibilityDigest: input.sessionManifestCompatibilityDigest }),
+        contextProtocolVersion: input.contextProtocolVersion,
+        sessionManifestCompatibilityDigest: input.sessionManifestCompatibilityDigest,
         ...review
     };
     const snapshot = config.adapterId === "codex"

package/dist/executor/executorRegistry.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import { createPromptEnvelope, createSessionLaunchRequest } from "../runtime/index.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { formatTurnReceiptId } from "../task/taskRecordReference.js";
 /**
  * rr13/test: Test-only liveness seam. Integration tests that spawn a real
  * Controller subprocess cannot inject a fake TmuxDeliveryPort, and a saved
- * active Leader Run would be reaped by the startup liveness pass without a
+ * active Leader Turn would be reaped by the startup liveness pass without a
  * real tmux role. When this env var is "1", every role reads "present"
  * without probing tmux. The Controller subprocess inherits it from the
  * test's CLI env. Never set in production.
@@ -12,7 +12,7 @@ import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 const TEST_ROLE_LIVENESS_PRESENT = process.env.YUI_TEST_ROLE_LIVENESS_PRESENT === "1";
 /**
  * Scheduler-to-tmux adapter. It retains only in-process prepared launch data;
- * durable session identity remains owned by FileTaskStore.
+ * durable session identity remains owned by TaskStore.
  */
 export class ExecutorRegistry {
     planner;
@@ -38,7 +38,7 @@ export class ExecutorRegistry {
             agentId: input.agentId,
             adapterId: input.adapterId,
             mode: input.mode,
-            ...(input.runId === undefined ? {} : { runId: input.runId })
+            ...(input.turnId === undefined ? {} : { turnId: input.turnId })
         };
         const cached = this.#prepared.get(deliveryBase.deliveryId);
         if (cached !== undefined)
@@ -74,7 +74,7 @@ export class ExecutorRegistry {
                 ...(input.runtimePolicy === undefined
                     ? {}
                     : { runtimePolicy: input.runtimePolicy }),
-                ...(input.runId === undefined ? {} : { runId: input.runId })
+                ...(input.turnId === undefined ? {} : { turnId: input.turnId })
             };
             if (this.runtimePorts.launchCoordinator !== undefined) {
                 binding = await this.runtimePorts.launchCoordinator.prepare(input.mode === "new"
@@ -141,13 +141,13 @@ export class ExecutorRegistry {
     async sendOnce(input) {
         const prepared = this.requirePrepared(input.delivery.prepared);
         if (prepared.binding !== undefined && this.runtimePorts !== undefined) {
-            const runId = input.delivery.prepared.runId;
-            if (runId === undefined) {
-                throw new Error("Runtime prompt delivery requires a Task-local Run id.");
+            const turnId = input.delivery.prepared.turnId;
+            if (turnId === undefined) {
+                throw new Error("Runtime prompt delivery requires a Task-local Turn id.");
             }
             // A reused native process retains the stable descriptor path from its
             // original control plane. Publish only the current-control source after
-            // the Run/Session fence is durable and immediately before provider input;
+            // the Turn/Session fence is durable and immediately before Provider input;
             // the reused Hook self-refreshes its own source before the volatile
             // fence instead of the Controller scanning history to keep it fresh.
             if (prepared.binding.hostCreated === false
@@ -158,7 +158,7 @@ export class ExecutorRegistry {
                 this.planner.refreshTaskRuntimeDescriptor({
                     taskId: input.delivery.prepared.taskId,
                     roleName: input.delivery.prepared.roleName,
-                    runId,
+                    turnId,
                     launchId: prepared.binding.launchId,
                     nativeSessionId: prepared.binding.nativeSessionId,
                     agentId: prepared.binding.agentId,
@@ -171,9 +171,9 @@ export class ExecutorRegistry {
                 envelope: createPromptEnvelope({
                     id: input.receiptId,
                     source: {
-                        kind: input.receiptId === formatAgentRunReceiptId(input.delivery.prepared.taskId, runId) ? "agent-run" : "run-input",
+                        kind: input.receiptId === formatTurnReceiptId(input.delivery.prepared.taskId, turnId) ? "turn" : "turn-input",
                         taskId: input.delivery.prepared.taskId,
-                        localId: runId
+                        localId: turnId
                     },
                     text: input.text,
                     createdAt: new Date()
@@ -190,6 +190,26 @@ export class ExecutorRegistry {
         }
         return outcome;
     }
+    async steerOnce(input) {
+        if (this.runtimePorts === undefined)
+            return "unavailable";
+        const outcome = await this.runtimePorts.promptPush.trySteer({
+            owner: { scope: "task", taskId: input.taskId, roleName: input.roleName },
+            launchId: input.launchId,
+            agentId: input.agentId,
+            adapterId: input.adapterId,
+            nativeSessionId: input.nativeSessionId,
+            nativeTurnId: input.nativeTurnId,
+            providerAuthority: input.authority,
+            envelope: createPromptEnvelope({
+                id: input.receiptId,
+                source: { kind: "turn-input", taskId: input.taskId, localId: activeTurnId(input.receiptId) },
+                text: input.text,
+                createdAt: new Date()
+            })
+        });
+        return outcome === "delivered" ? "sent" : outcome;
+    }
     async notifyOperatorInputOnce(input) {
         const probe = this.readiness(input.adapterId, "operator");
         return this.tmux.sendRoleInputOnceIfReadyAsync === undefined
@@ -201,8 +221,8 @@ export class ExecutorRegistry {
             const delivery = prepared.delivery;
             if (delivery.taskId !== input.taskId
                 || delivery.roleName !== input.roleName
-                || (input.runId !== undefined
-                    && delivery.runId !== input.runId)
+                || (input.turnId !== undefined
+                    && delivery.turnId !== input.turnId)
                 || (input.launchId !== undefined
                     && delivery.launchId !== input.launchId)) {
                 continue;
@@ -261,7 +281,7 @@ export class ExecutorRegistry {
         const requested = resourceInputs ?? inputs.map((input) => ({
             taskId: input.taskId,
             roleName: input.roleName,
-            ...(input.runId === undefined ? {} : { runId: input.runId }),
+            ...(input.turnId === undefined ? {} : { turnId: input.turnId }),
             agentId: input.agentId,
             adapterId: input.adapterId,
             ...(input.nativeSessionId === undefined
@@ -329,11 +349,17 @@ export class ExecutorRegistry {
         return planned;
     }
 }
+function activeTurnId(receiptId) {
+    const match = /^turn-input:[^/]+\/([^/]+)\/[1-9]\d*$/u.exec(receiptId);
+    if (match === null)
+        throw new Error("Turn steer receipt is invalid.");
+    return decodeURIComponent(match[1]);
+}
 export function agentProcessReadinessProbe(adapterId, _surface = "role") {
     if (adapterId !== "codex" && adapterId !== "claude") {
         throw new Error(`No tmux readiness probe is registered for Agent adapter: ${adapterId}.`);
     }
-    // Run state and receipt fences decide whether delivery is allowed. Provider
+    // Turn state and receipt fences decide whether delivery is allowed. Provider
     // terminal contents are display-only evidence and never lifecycle input.
     return livePane;
 }
@@ -348,7 +374,7 @@ function preparedDeliveryId(input) {
         input.adapterId,
         input.effective,
         input.mode,
-        input.runId ?? null,
+        input.turnId ?? null,
         input.nativeSessionId ?? null,
         input.hostActivationId ?? null
     ])).digest("hex");