@zq-silk/yui 0.15.9 → 0.15.12

package/dist/controller/structuredProviderObservation.js

@@ -7,39 +7,70 @@ import { createRuntimeObservation, runtimeObservationSemanticKey } from "../runt
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
-import { resolveRuntimeHookRunFence } from "./runtimeHookRunFence.js";
+import { AGENT_HOST_EVENT_PROTOCOL } from "../runtime/agentHostProtocol.js";
+import { redactAgentErrorText } from "../runtime/agentError.js";
 let structuredSequence = 0;
+let deliveryFailure;
+// Only live diagnostics for this process's immutable files, not another queue.
+// No payload, retry, or authoritative delivery state is kept in this map.
+const emittedEvents = new Map();
+/** A live transport observation, independent of Provider state and Run truth. */
+export function structuredProviderEventDelivery(home, environment, nativeSessionId) {
+    try {
+        const inbox = new FileRuntimeEventInbox(home);
+        const pending = [];
+        for (const [id, entry] of emittedEvents) {
+            if (entry.home !== home)
+                continue;
+            if (!inbox.has(id)) {
+                emittedEvents.delete(id);
+                continue;
+            }
+            if (entry.taskId === environment.YUI_TASK_ID && entry.roleName === environment.YUI_ROLE
+                && (nativeSessionId === undefined || entry.nativeSessionId === nativeSessionId))
+                pending.push(entry);
+        }
+        return {
+            pending: pending.length,
+            pendingTerminals: pending.filter(event => event.terminal).length,
+            ...(deliveryFailure === undefined ? {} : { failure: deliveryFailure })
+        };
+    }
+    catch (error) {
+        return { pending: 0, pendingTerminals: 0, failure: deliveryFault("persistence", error) };
+    }
+}
+function deliveryFault(stage, error) {
+    return {
+        stage, detail: redactAgentErrorText(error instanceof Error ? error.message : String(error)),
+        observedAt: new Date().toISOString()
+    };
+}
 export async function publishStructuredProviderAttachmentExit(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const owner = resolveRuntimeHookRunFence(input.environment, adapterId, input.nativeSessionId, {
-        terminal: true, attemptId: input.attemptId, nativeTurnId: input.nativeTurnId
-    });
+    const owner = describeHostIdentity(input.environment, adapterId, input.nativeSessionId);
     await persistAndApply(input.home, [observation({
             kind: input.failed ? "session.failed" : "session.ended", observedAt: input.observedAt,
             sequence: nextStructuredSequence(), ordinal: 0,
             fence: {
                 taskId: owner.taskId, roleName: owner.roleName, agentId: owner.agentId, driverId: driver.id,
                 nativeSessionId: input.nativeSessionId, conversationId: input.nativeSessionId,
-                ...(owner.runId === undefined ? {} : { runId: owner.runId }),
                 ...(input.attemptId === undefined ? {} : { receiptId: input.attemptId }),
                 ...(input.nativeTurnId === undefined ? {} : { nativeTurnId: input.nativeTurnId })
             }
-        })], owner.taskId, owner.roleName);
+        })], input.environment);
 }
 export async function publishStructuredProviderActivity(input) {
     const activity = input.activity;
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const owner = resolveRuntimeHookRunFence(input.environment, adapterId, activity.nativeSessionId, {
-        nativeTurnId: activity.nativeTurnId, attemptId: activity.attemptId
-    });
+    const owner = describeHostIdentity(input.environment, adapterId, activity.nativeSessionId);
     const event = observation({
         kind: activity.phase === "model" ? "activity.observed" : `operation.${activity.phase}`,
         observedAt: activity.observedAt, sequence: nextStructuredSequence(), ordinal: 0,
         fence: {
             taskId: owner.taskId, roleName: owner.roleName,
-            ...(owner.runId === undefined ? {} : { runId: owner.runId }),
             agentId: owner.agentId, driverId: driver.id,
             nativeSessionId: activity.nativeSessionId, conversationId: activity.conversationId,
             receiptId: activity.attemptId,
@@ -49,7 +80,7 @@ export async function publishStructuredProviderActivity(input) {
             ? { activity: "model", activityId: activity.id }
             : { operation: "tool", operationId: activity.id }
     });
-    await persistAndApply(input.home, [event], owner.taskId, owner.roleName);
+    await persistAndApply(input.home, [event], input.environment);
 }
 /** An exact provider item id is evidence of visible input, not an inferred
  * human author. The original managed request is never replaced.
@@ -57,28 +88,21 @@ export async function publishStructuredProviderActivity(input) {
 export async function publishStructuredProviderInputObserved(input) {
     const observed = input.observed;
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, observed.nativeSessionId, {
-        nativeTurnId: observed.nativeTurnId, terminal: true, sessionOnly: true
-    });
-    if (fence.runId === undefined)
-        return; // Ordinary chat need not be mirrored.
+    const fence = describeHostIdentity(input.environment, adapterId, observed.nativeSessionId);
     await persistAndApply(input.home, [observation({
             kind: "input.accepted", observedAt: observed.observedAt, sequence: nextStructuredSequence(), ordinal: 0,
             fence: { ...fence, driverId: builtinAgentDriverRegistry().requireByAdapterId(adapterId).id,
                 conversationId: observed.conversationId, nativeTurnId: observed.nativeTurnId,
                 receiptId: `native-input:${observed.nativeTurnId}/${observed.inputId}` },
             payload: { input: observed.input }
-        })], fence.taskId, fence.roleName);
+        })], input.environment);
 }
 export async function publishStructuredProviderStarted(input) {
     if (input.started.clientOwned)
         return;
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.started.nativeSessionId, {
-        nativeTurnId: input.started.nativeTurnId,
-        sessionOnly: true
-    });
+    const fence = describeHostIdentity(input.environment, adapterId, input.started.nativeSessionId);
     const receiptId = `direct:${input.started.nativeTurnId}`;
     const startedObservation = observation({
         kind: "turn.accepted",
@@ -97,22 +121,16 @@ export async function publishStructuredProviderStarted(input) {
         },
         payload: input.started.input === undefined ? {} : { input: input.started.input }
     });
-    await persistAndApply(input.home, [startedObservation], fence.taskId, fence.roleName);
+    await persistAndApply(input.home, [startedObservation], input.environment);
 }
 export async function publishStructuredProviderAccepted(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const startupSession = driver.capabilities.observation.sessionBootstrap;
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.receipt.nativeSessionId, {
-        startupSession,
-        nativeTurnId: input.receipt.nativeTurnId,
-        attemptId: input.receipt.attemptId
-    });
+    const fence = describeHostIdentity(input.environment, adapterId, input.receipt.nativeSessionId);
     const observedAt = input.receipt.acceptedAt;
     const commonFence = {
         taskId: fence.taskId,
         roleName: fence.roleName,
-        ...(fence.runId === undefined ? {} : { runId: fence.runId }),
         agentId: fence.agentId,
         driverId: driver.id,
         conversationId: input.receipt.conversationId,
@@ -136,18 +154,15 @@ export async function publishStructuredProviderAccepted(input) {
             ordinal: 0,
             fence: commonFence
         })];
-    await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
+    await persistAndApply(input.home, observations, input.environment);
 }
 /** Steer settles an additional input, never the parent AgentRun's initial delivery. */
 export async function publishStructuredProviderInputSettlement(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.nativeSessionId, {
-        nativeTurnId: input.nativeTurnId,
-        terminal: true
-    });
-    if (fence.runId === undefined)
-        throw new Error("Steer settlement has no exact original AgentRun.");
+    const fence = describeHostIdentity(input.environment, adapterId, input.nativeSessionId);
+    // The Host reports the exact Session/turn/attempt, including input with no
+    // AgentRun. Only the Controller resolves a current Run from durable state.
     const entry = observation({
         kind: input.status === "accepted" ? "input.accepted"
             : input.status === "rejected" ? "input.rejected" : "input.delivery-unknown",
@@ -157,7 +172,6 @@ export async function publishStructuredProviderInputSettlement(input) {
         fence: {
             taskId: fence.taskId,
             roleName: fence.roleName,
-            runId: fence.runId,
             agentId: fence.agentId,
             driverId: driver.id,
             conversationId: input.nativeSessionId,
@@ -180,22 +194,20 @@ export async function publishStructuredProviderInputSettlement(input) {
             })
         }
     });
-    await persistAndApply(input.home, [entry], fence.taskId, fence.roleName);
+    await persistAndApply(input.home, [entry], input.environment);
 }
 export async function publishStructuredProviderOpened(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
     const startupSession = driver.capabilities.observation.sessionBootstrap;
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.nativeSessionId, { startupSession });
+    const fence = describeHostIdentity(input.environment, adapterId, input.nativeSessionId);
     const commonFence = {
         taskId: fence.taskId,
         roleName: fence.roleName,
-        ...(fence.runId === undefined ? {} : { runId: fence.runId }),
         agentId: fence.agentId,
         driverId: driver.id,
         conversationId: input.conversationId,
-        nativeSessionId: input.nativeSessionId,
-        ...(fence.receiptId === undefined ? {} : { receiptId: fence.receiptId })
+        nativeSessionId: input.nativeSessionId
     };
     const sequence = nextStructuredSequence();
     const observations = [observation({
@@ -212,12 +224,12 @@ export async function publishStructuredProviderOpened(input) {
             fence: commonFence,
             payload: { recoverability: input.recoverability }
         })];
-    await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
+    await persistAndApply(input.home, observations, input.environment, undefined, input.startupRunId);
 }
 export async function publishStructuredProviderGoal(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.conversationId, { sessionOnly: true });
+    const fence = describeHostIdentity(input.environment, adapterId, input.conversationId);
     const goal = input.goal;
     const observedAt = input.observedAt ?? goal?.updatedAt ?? new Date().toISOString();
     const goalObservation = observation({
@@ -241,22 +253,20 @@ export async function publishStructuredProviderGoal(input) {
             ...(goal.tokenBudget === undefined ? {} : { goalTokenBudget: goal.tokenBudget })
         }
     });
-    await persistAndApply(input.home, [goalObservation], fence.taskId, fence.roleName);
+    await persistAndApply(input.home, [goalObservation], input.environment);
 }
 export async function publishStructuredConversationRecoverability(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.conversationId, { sessionOnly: true });
+    const fence = describeHostIdentity(input.environment, adapterId, input.conversationId);
     const sequence = nextStructuredSequence();
     const observationFence = {
         taskId: fence.taskId,
         roleName: fence.roleName,
-        ...(fence.runId === undefined ? {} : { runId: fence.runId }),
         agentId: fence.agentId,
         driverId: driver.id,
         conversationId: input.conversationId,
-        nativeSessionId: input.conversationId,
-        ...(fence.receiptId === undefined ? {} : { receiptId: fence.receiptId })
+        nativeSessionId: input.conversationId
     };
     const observations = [observation({
             kind: "conversation.observed",
@@ -266,17 +276,12 @@ export async function publishStructuredConversationRecoverability(input) {
             fence: observationFence,
             payload: { recoverability: input.recoverability }
         })];
-    await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
+    await persistAndApply(input.home, observations, input.environment);
 }
 export async function publishStructuredProviderTerminal(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.terminal.nativeSessionId, {
-        terminal: true,
-        nativeTurnId: input.terminal.nativeTurnId,
-        attemptId: input.terminal.attemptId,
-        ...(input.terminal.clientOwned ? {} : { sessionOnly: true })
-    });
+    const fence = describeHostIdentity(input.environment, adapterId, input.terminal.nativeSessionId);
     const kind = input.terminal.status === "completed"
         ? "turn.completed"
         : input.terminal.status === "cancelled" ? "turn.cancelled" : "turn.failed";
@@ -321,7 +326,6 @@ export async function publishStructuredProviderTerminal(input) {
         fence: {
             taskId: fence.taskId,
             roleName: fence.roleName,
-            ...(fence.runId === undefined ? {} : { runId: fence.runId }),
             agentId: fence.agentId,
             driverId: driver.id,
             conversationId: input.terminal.conversationId,
@@ -329,9 +333,7 @@ export async function publishStructuredProviderTerminal(input) {
             ...(input.terminal.nativeTurnId === undefined ? {} : {
                 nativeTurnId: input.terminal.nativeTurnId
             }),
-            ...(input.terminal.attemptId === undefined
-                ? fence.receiptId === undefined ? {} : { receiptId: fence.receiptId }
-                : { receiptId: input.terminal.attemptId })
+            ...(input.terminal.attemptId === undefined ? {} : { receiptId: input.terminal.attemptId })
         },
         payload: {
             ...payload,
@@ -340,7 +342,7 @@ export async function publishStructuredProviderTerminal(input) {
             ...(input.terminal.input === undefined ? {} : { input: input.terminal.input })
         }
     });
-    await persistAndApply(input.home, [terminalObservation], fence.taskId, fence.roleName);
+    await persistAndApply(input.home, [terminalObservation], input.environment);
 }
 function observation(input) {
     const eventId = `agent-host-${randomUUID()}`;
@@ -367,7 +369,8 @@ function observation(input) {
 }
 async function signalController(home, taskId, roleName) {
     await callController(home, "scheduler.signal", {
-        key: runtimeLifecycleSignalKey({ scope: "task", taskId, roleName })
+        key: runtimeLifecycleSignalKey(taskId === undefined
+            ? { scope: "global", roleName } : { scope: "task", taskId, roleName })
     }, { timeoutMs: 100 }).catch(() => { });
 }
 function nextStructuredSequence() {
@@ -380,20 +383,42 @@ function requireIdentity(value, label) {
     }
     return value.trim();
 }
-async function persistAndApply(home, observations, taskId, roleName) {
+async function persistAndApply(home, observations, environment, connection, startupRunId) {
     const inbox = new FileRuntimeEventInbox(home);
-    for (const entry of observations)
-        inbox.enqueueObservation(entry);
+    const host = {
+        protocol: AGENT_HOST_EVENT_PROTOCOL,
+        adapterId: requireIdentity(environment.YUI_ADAPTER_ID, "Agent adapter id"),
+        workspace: requireIdentity(environment.YUI_WORKSPACE, "Yui workspace"),
+        ...(connection === undefined ? {} : { connection })
+    };
+    let events;
+    try {
+        structuredProviderEventDelivery(home, environment); // prune ACKed local diagnostics
+        events = observations.map(entry => inbox.enqueueObservation(entry, {
+            ...host,
+            ...(startupRunId === undefined ? {} : { startupRunId })
+        }).event);
+        for (const event of events)
+            emittedEvents.set(event.id, {
+                home, taskId: event.taskId, roleName: event.observation.fence.roleName,
+                nativeSessionId: event.observation.fence.nativeSessionId,
+                terminal: ["turn.completed", "turn.failed", "turn.cancelled"].includes(event.observation.kind)
+            });
+    }
+    catch (error) {
+        deliveryFailure = deliveryFault("persistence", error);
+        throw error;
+    }
     // The immutable inbox is authoritative. During a release/update handover the
     // old Controller is draining and the replacement is not ready yet; leave the
     // entries for normal inbox replay instead of turning a healthy Provider Turn
     // into a transport failure.
     if (isForeignHandoverLockHeld(home))
         return;
-    for (const entry of observations) {
+    for (const entry of events) {
         let result;
         try {
-            result = await callController(home, "runtime.observation-apply", entry, {
+            result = await callController(home, "runtime.host-observation-apply", { eventId: entry.id }, {
                 // This is only an eager application hint after durable enqueue, not
                 // native admission. Bound it like the wake signal so a frozen
                 // Controller cannot serialize ten seconds of delay per tool event.
@@ -409,7 +434,10 @@ async function persistAndApply(home, observations, taskId, roleName) {
                     && ["CONTROLLER_NOT_RUNNING", "CONTROLLER_UNAVAILABLE", "CONTROLLER_TIMEOUT",
                         "CONTROLLER_DELIVERY_UNKNOWN"].includes(error.code)))
                 return;
-            throw error;
+            // The native fact is already durable. An incompatible/refusing
+            // Controller is a reporting fault, not Provider execution failure.
+            deliveryFailure = deliveryFault("controller", error);
+            return;
         }
         // A fast Provider can accept the initial AgentRun before the scheduler call
         // that launched this Host has returned and committed `turn.pushed`. The
@@ -417,8 +445,43 @@ async function persistAndApply(home, observations, taskId, roleName) {
         // `deferred` therefore means "retained for replay", not delivery failure.
         // The signal below schedules the replay after the transport transaction.
         if (result.outcome !== "applied" && result.outcome !== "deferred") {
-            throw new Error(`Structured Provider observation was not applied: ${result.outcome ?? "unknown"}.`);
+            deliveryFailure = deliveryFault("controller", `Structured Provider observation was rejected: ${result.outcome ?? "unknown"}. Event: ${entry.id}`);
+            return;
         }
     }
-    await signalController(home, taskId, roleName);
+    if (deliveryFailure?.stage === "controller")
+        deliveryFailure = undefined;
+    await signalController(home, hostTaskId(environment), requireIdentity(environment.YUI_ROLE, "Role"));
+}
+/** Capture only identities the Host actually received; the current Controller
+ * owns all TaskStore reads and resolves the exact attempt's Run at consumption. */
+function describeHostIdentity(environment, adapterId, nativeSessionId) {
+    if (environment.YUI_ADAPTER_ID !== adapterId)
+        throw new Error("Agent adapter id does not match.");
+    return {
+        taskId: hostTaskId(environment),
+        roleName: requireIdentity(environment.YUI_ROLE, "Role name"),
+        agentId: requireIdentity(environment.YUI_AGENT_ID, "Agent id"),
+        nativeSessionId: requireIdentity(nativeSessionId, "Native Session id")
+    };
+}
+function hostTaskId(environment) {
+    if (environment.YUI_SESSION_SCOPE === "global") {
+        if (environment.YUI_TASK_ID !== undefined)
+            throw new Error("Global Host must not carry a Task id.");
+        return undefined;
+    }
+    if (environment.YUI_SESSION_SCOPE !== "task")
+        throw new Error("Agent Host observation requires Task scope.");
+    return requireIdentity(environment.YUI_TASK_ID, "Task id");
+}
+export async function publishStructuredProviderConnection(input) {
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const fence = describeHostIdentity(input.environment, adapterId, input.nativeSessionId);
+    await persistAndApply(input.home, [observation({
+            kind: "host.observed", observedAt: new Date().toISOString(),
+            authority: "host", payload: { alive: true },
+            sequence: nextStructuredSequence(), ordinal: 0,
+            fence: { ...fence, driverId: builtinAgentDriverRegistry().requireByAdapterId(adapterId).id }
+        })], input.environment, input.connection, input.startupRunId);
 }

package/dist/coordination/workMailboxQueue.js

@@ -9,6 +9,11 @@ const LEGACY_ROLE_RUN_DISPATCH_REASONS = new Set([
 /** Atomically useful when called inside the caller's TaskStore transaction. */
 export function enqueueWork(store, target, reason, occurredAt, refs = [], metadata = {}) {
     const mailbox = store.getWorkMailbox(target) ?? createWorkMailbox(target);
+    // Archive is an admission boundary, not an acknowledgement of old input.
+    // Runtime cleanup mailboxes remain usable for exact-owner recovery.
+    if ((target.kind === "task" || target.kind === "role")
+        && store.getTask?.(target.taskId)?.status === "archived")
+        return mailbox;
     const queued = enqueueSignal(mailbox, {
         reason,
         refs,

package/dist/execution/workItemExecutionProjection.js

@@ -278,7 +278,7 @@ function projectNextAction(item, lanes, synthesis, mainRun, candidate) {
         return action("inspect-unknown", ["leader"], mainRun.runId === undefined ? [item.id] : [mainRun.runId]);
     }
     if (item.status === "open") {
-        return action("dispatch-work", ["leader"], [item.id]);
+        return action(item.assignee === undefined ? "execute-directly" : "dispatch-work", ["leader"], [item.id]);
     }
     return action("inspect-unknown", ["leader"], [item.id]);
 }

package/dist/executor/agentExecutor.js

@@ -342,6 +342,42 @@ export function updateTaskRoleProviderRuntime(set, binding, updatedAt) {
         updatedAt: requireDate(updatedAt, "Provider Runtime Binding timestamp")
     });
 }
+/**
+ * Bind a Global Role's Provider Runtime evidence, mirroring the Task Role
+ * writer (decision-3 §6/§9). Create-only: an existing distinct binding is a
+ * conflict, an identical one is idempotent. The Global set stays schemaVersion
+ * 5; only the optional providerBinding is added.
+ */
+export function bindGlobalRoleProviderRuntime(set, binding, updatedAt) {
+    validateRoleSessionSet(set);
+    const normalized = validateProviderRuntimeBinding(binding);
+    if (set.providerBinding != null) {
+        if (JSON.stringify(set.providerBinding) === JSON.stringify(normalized))
+            return set;
+        throw new Error("Global Role already has a Provider Runtime Binding.");
+    }
+    return validateRoleSessionSet({
+        ...set,
+        providerBinding: normalized,
+        updatedAt: requireDate(updatedAt, "Provider Runtime Binding timestamp")
+    });
+}
+/** In-place update of a Global Role's Provider Runtime binding; namespace and
+ * account scope are immutable, exactly as for a Task Role. */
+export function updateGlobalRoleProviderRuntime(set, binding, updatedAt) {
+    validateRoleSessionSet(set);
+    const normalized = validateProviderRuntimeBinding(binding);
+    if (set.providerBinding == null
+        || normalized.providerNamespace !== set.providerBinding.providerNamespace
+        || normalized.accountScope !== set.providerBinding.accountScope) {
+        throw new Error("Provider Runtime Binding identity cannot change in place.");
+    }
+    return validateRoleSessionSet({
+        ...set,
+        providerBinding: normalized,
+        updatedAt: requireDate(updatedAt, "Provider Runtime Binding timestamp")
+    });
+}
 /**
  * Detaches a confirmed-dead local Host without ending its resumable native
  * Session. Host connections are disposable execution
@@ -409,7 +445,7 @@ export function recordTaskRoleNativeTurnBoundary(set, input, completedAt) {
 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", "interrupts"]
         : [
             "schemaVersion",
             "owner",
@@ -428,10 +464,19 @@ export function validateRoleSessionSet(set) {
         if (set.schemaVersion !== 5) {
             throw new Error("Global Role session set schema version is invalid.");
         }
-        if (Object.hasOwn(set, "providerBinding")) {
-            throw new Error("Global Role session set must not contain Task Role lifecycle fields.");
+        const globalSet = set;
+        for (const [requestId, control] of Object.entries(globalSet.interrupts ?? {})) {
+            requireSafeIdentity(requestId, "Global interrupt request");
+            requireText(control.fingerprint, "Global interrupt fingerprint");
+            requireText(control.attemptId, "Global interrupt attempt");
+            requireText(control.nativeSessionId, "Global interrupt Session");
+            requireText(control.receiptId, "Global interrupt receipt");
+            if (control.receipt !== undefined
+                && !["interrupt-requested", "interrupt-not-active", "interrupt-unknown", "interrupt-unavailable"]
+                    .includes(control.receipt.state))
+                throw new Error("Global interrupt receipt is invalid.");
         }
-        const history = set.history;
+        const history = globalSet.history;
         if (history !== undefined) {
             for (const [ref, session] of Object.entries(history)) {
                 requireSafeIdentity(ref, "Operator session ref");
@@ -441,6 +486,21 @@ export function validateRoleSessionSet(set) {
                 }
             }
         }
+        // A Global Role now carries the same optional Provider Runtime Binding shape
+        // as a Task Role (decision-3 §6/§9). It stays absent on every legacy set;
+        // when present, it is the exact native control evidence a Global steer or
+        // interrupt targets, validated identically to the Task branch. A fabricated
+        // Task binding is never accepted here, and its presence never upgrades the
+        // schemaVersion these raw-JSON sets are read at.
+        if (Object.hasOwn(globalSet, "providerBinding") && globalSet.providerBinding != null) {
+            const providerBinding = validateProviderRuntimeBinding(globalSet.providerBinding);
+            const conversationId = currentProviderConversation(providerBinding).conversationId;
+            const session = [...Object.values(globalSet.sessions), ...Object.values(globalSet.history ?? {})]
+                .find(entry => entry.agentId === providerBinding.accountScope && entry.nativeSessionId === conversationId);
+            if (session !== undefined && providerBinding.providerNamespace !== builtinDriverIdForAdapter(session.adapterId)) {
+                throw new Error("Provider Runtime Binding namespace does not match the Agent adapter.");
+            }
+        }
     }
     else {
         if (set.schemaVersion !== 12) {

package/dist/executor/executorRegistry.js

@@ -177,6 +177,9 @@ export class ExecutorRegistry {
         return deliveryReport(outcome);
     }
     async notifyOperatorInputOnce(input) {
+        if (this.runtimePorts?.notifyOperatorInputOnce !== undefined) {
+            return this.runtimePorts.notifyOperatorInputOnce(input);
+        }
         const probe = this.readiness(input.adapterId, "operator");
         return this.tmux.sendRoleInputOnceIfReadyAsync === undefined
             ? this.tmux.sendRoleInputOnceIfReady("operator", input.roleName, input.receiptId, input.text, probe)