@zq-silk/yui 0.16.1 → 1.0.0-alpha

package/dist/controller/providerRetryDelivery.js

@@ -6,9 +6,10 @@ import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { redactAgentErrorText } from "../runtime/agentError.js";
 import { AGENT_HOST_CONTROL_PROTOCOL, agentHostControlSocketPath, inspectAgentHostSocket, sendAgentHostRunControl } from "../runtime/agentHost.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { cancelProviderRetry, providerRetryAttemptId, providerRetryPending } from "../runtime/providerRetry.js";
+import { cancelProviderRetry, providerRetryAttemptId, providerRetryPending, providerRetryProjection } from "../runtime/providerRetry.js";
 import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { retryIntentBlocker } from "./providerRetryAdmission.js";
+import { recordGlobalRuntimeAttention } from "./globalRuntimeAttention.js";
 /** Hooks in the existing Controller pass and nearest-deadline timer. SQLite's
  * current Provider input is the only pending intent; nothing is queued here. */
 export function createProviderRetryHooks(home, store, ports = {}) {
@@ -45,8 +46,11 @@ export function createProviderRetryHooks(home, store, ports = {}) {
             save({ ...current, providerBinding: exhausted
                     ? { ...cancelled, retry: { ...cancelled.retry, status: "exhausted" } } : cancelled });
             const owner = set.owner;
-            if (owner.scope === "global")
-                settleGlobalRetryInput(store, owner.roleName, load(owner)?.providerBinding, new Date(at));
+            if (owner.scope === "global") {
+                const stopped = load(owner)?.providerBinding;
+                settleGlobalRetryInput(store, owner.roleName, stopped, new Date(at));
+                recordGlobalRuntimeAttention(store, owner.roleName, `${binding.retry.chainId}:stopped`, providerRetryProjection(stopped), new Date(at));
+            }
             if (owner.scope === "task") {
                 const event = createTaskEvent(store.nextEventId(owner.taskId), owner.taskId, "provider.retry-stopped", {
                     roleName: owner.roleName, chainId: binding.retry.chainId, reason
@@ -86,131 +90,144 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                     inspectedUnknown.delete(id);
             for (const set of current) {
                 const owner = set.owner;
-                const binding = set.providerBinding;
-                const retry = binding.retry;
-                const at = now(retry);
-                const scoped = { ...(owner.scope === "task" ? { taskId: owner.taskId } : {}), roleName: owner.roleName };
-                const session = set.sessions[set.activeAgentId];
-                const blocker = retryIntentBlocker(store, scoped, retry);
-                if (blocker !== undefined && blocker !== "background-work-unsettled") {
-                    stop(set, blocker, at);
-                    continue;
-                }
-                if (binding.retryDisabled && retry.successorAutomatic !== false || binding.authority.owner !== "controller"
-                    || binding.authority.epoch !== retry.authorityEpoch
-                    || currentProviderConversation(binding).conversationId !== retry.nativeSessionId
-                    || session?.status !== "active" || session.nativeSessionId !== retry.nativeSessionId
-                    || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget(owner)))) {
-                    stop(set, "session-or-authority-changed", at);
-                    continue;
-                }
-                // Never replay an admitted attempt. Existing exact runtime queries and
-                // terminal ingress resolve it, even across Controller restart.
-                if (retry.status === "in-flight") {
-                    if (binding.run?.status === "delivery-unknown" && retry.currentAttemptId !== undefined
-                        && !inspectedUnknown.has(retry.currentAttemptId)) {
-                        inspectedUnknown.add(retry.currentAttemptId);
-                        let detail;
-                        try {
-                            const host = await inspect({ home, ...scoped, scope: owner.scope });
-                            detail = host.nativeSessionId === retry.nativeSessionId && host.attemptId === retry.currentAttemptId
-                                ? `Exact Host query: ${host.state}; awaiting original canonical Provider evidence.`
-                                : "Host query did not prove the original Session/input identity; no replay.";
-                        }
-                        catch (error) {
-                            detail = `Original Host query unavailable; no replay: ${redactAgentErrorText(error instanceof Error ? error.message : String(error))}`;
-                        }
-                        store.transaction(() => {
-                            const latest = load(owner);
-                            if (latest === null || latest.providerBinding == null || latest.providerBinding.run === null
-                                || latest.providerBinding.run.attemptId !== retry.currentAttemptId
-                                || latest.providerBinding.run.status !== "delivery-unknown")
-                                return;
-                            save({ ...latest, providerBinding: { ...latest.providerBinding,
-                                    retry: { ...latest.providerBinding.retry, reason: detail } } });
-                            if (owner.scope === "task") {
-                                const event = createTaskEvent(store.nextEventId(owner.taskId), owner.taskId, "provider.retry-unconfirmed", {
-                                    roleName: owner.roleName, attemptId: retry.currentAttemptId, nativeSessionId: retry.nativeSessionId, detail
-                                }, new Date(at));
-                                store.saveEvent(owner.taskId, event);
-                                enqueueWork(store, owner.roleName === "leader" ? { kind: "operator" }
-                                    : { kind: "role", taskId: owner.taskId, roleName: "leader" }, "provider-retry-needs-attention", new Date(at), [{ type: "event", taskId: owner.taskId, id: event.id }]);
-                            }
-                        });
-                    }
-                    continue;
-                }
-                if (retry.successorAutomatic !== false && at >= Date.parse(retry.deadline)) {
-                    stop(set, "deadline-exhausted", at, true);
-                    continue;
-                }
-                if (at < Date.parse(retry.nextEligibleAt) || blocker !== undefined || binding.goal?.status === "active")
-                    continue;
-                if (binding.run?.attemptId !== retry.failedAttemptId) {
-                    stop(set, "superseded-input", at);
-                    continue;
-                }
                 try {
-                    if (owner.scope === "task" && retry.previousRunId !== undefined) {
-                        if (retry.successorRunId !== undefined || retry.successorReviewRoundId !== undefined)
-                            continue;
-                        const previous = store.getRun(owner.taskId, retry.previousRunId);
-                        if (previous?.status === "active")
-                            continue; // ordinary rejected-delivery terminal fold
-                        if (previous?.status !== "failed") {
-                            stop(set, "run-no-longer-failed", at);
-                            continue;
-                        }
-                        const actualTaskReviewCandidate = await ports.snapshotTaskCandidate?.(previous);
-                        store.transaction(() => {
-                            const latest = load(owner)?.providerBinding?.retry;
-                            if (latest?.chainId !== retry.chainId || latest.failedAttemptId !== retry.failedAttemptId
-                                || latest.status !== "waiting")
-                                return;
-                            const reason = retryIntentBlocker(store, scoped, latest);
-                            if (reason !== undefined)
-                                throw new Error(reason);
-                            runTaskCommand(["run", "retry", `${owner.taskId}/${previous.id}`], store, {
-                                now: () => new Date(at), environment: {}, providerRetryChainId: retry.chainId,
-                                ...(actualTaskReviewCandidate === undefined ? {} : { actualTaskReviewCandidate })
+                    const binding = set.providerBinding;
+                    const retry = binding.retry;
+                    const at = now(retry);
+                    const scoped = { ...(owner.scope === "task" ? { taskId: owner.taskId } : {}), roleName: owner.roleName };
+                    const session = set.sessions[set.activeAgentId];
+                    const blocker = retryIntentBlocker(store, scoped, retry);
+                    if (blocker !== undefined && blocker !== "background-work-unsettled") {
+                        stop(set, blocker, at);
+                        continue;
+                    }
+                    if (binding.retryDisabled && retry.successorAutomatic !== false || binding.authority.owner !== "controller"
+                        || binding.authority.epoch !== retry.authorityEpoch
+                        || currentProviderConversation(binding).conversationId !== retry.nativeSessionId
+                        || session?.status !== "active" || session.nativeSessionId !== retry.nativeSessionId
+                        || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget(owner)))) {
+                        stop(set, "session-or-authority-changed", at);
+                        continue;
+                    }
+                    // Never replay an admitted attempt. Existing exact runtime queries and
+                    // terminal ingress resolve it, even across Controller restart.
+                    if (retry.status === "in-flight") {
+                        if (binding.run?.status === "delivery-unknown" && retry.currentAttemptId !== undefined
+                            && !inspectedUnknown.has(retry.currentAttemptId)) {
+                            inspectedUnknown.add(retry.currentAttemptId);
+                            let detail;
+                            try {
+                                const host = await inspect({ home, ...scoped, scope: owner.scope });
+                                detail = host.nativeSessionId === retry.nativeSessionId && host.attemptId === retry.currentAttemptId
+                                    ? `Exact Host query: ${host.state}; awaiting original canonical Provider evidence.`
+                                    : "Host query did not prove the original Session/input identity; no replay.";
+                            }
+                            catch (error) {
+                                detail = `Original Host query unavailable; no replay: ${redactAgentErrorText(error instanceof Error ? error.message : String(error))}`;
+                            }
+                            store.transaction(() => {
+                                const latest = load(owner);
+                                if (latest === null || latest.providerBinding == null || latest.providerBinding.run === null
+                                    || latest.providerBinding.run.attemptId !== retry.currentAttemptId
+                                    || latest.providerBinding.run.status !== "delivery-unknown")
+                                    return;
+                                save({ ...latest, providerBinding: { ...latest.providerBinding,
+                                        retry: { ...latest.providerBinding.retry, reason: detail } } });
+                                if (owner.scope === "global") {
+                                    recordGlobalRuntimeAttention(store, owner.roleName, `${retry.currentAttemptId}:unconfirmed`, providerRetryProjection(load(owner)?.providerBinding), new Date(at));
+                                }
+                                if (owner.scope === "task") {
+                                    const event = createTaskEvent(store.nextEventId(owner.taskId), owner.taskId, "provider.retry-unconfirmed", {
+                                        roleName: owner.roleName, attemptId: retry.currentAttemptId, nativeSessionId: retry.nativeSessionId, detail
+                                    }, new Date(at));
+                                    store.saveEvent(owner.taskId, event);
+                                    enqueueWork(store, owner.roleName === "leader" ? { kind: "operator" }
+                                        : { kind: "role", taskId: owner.taskId, roleName: "leader" }, "provider-retry-needs-attention", new Date(at), [{ type: "event", taskId: owner.taskId, id: event.id }]);
+                                }
                             });
-                        });
+                        }
+                        continue;
                     }
-                    else {
-                        const original = retry.input.kind === "text" ? retry.input.text
-                            : retry.input.kind === "wake"
-                                ? `Yui Task notification: task=${retry.input.taskId} wake=${retry.input.wakeId}.\nRead current Task context and that fixed wake window, including original Messages in full. This is not an execution assignment.`
-                                : retry.input.kind === "message"
-                                    ? `Yui Global Message: role=${retry.input.roleName} message=${retry.input.messageId}.\nRead your Session Context and referenced original Message in full.`
-                                    : undefined;
-                        if (original === undefined) {
-                            stop(set, "original-input-unavailable", at);
-                            continue;
+                    if (retry.successorAutomatic !== false && at >= Date.parse(retry.deadline)) {
+                        stop(set, "deadline-exhausted", at, true);
+                        continue;
+                    }
+                    if (at < Date.parse(retry.nextEligibleAt) || blocker !== undefined || binding.goal?.status === "active")
+                        continue;
+                    if (binding.run?.attemptId !== retry.failedAttemptId) {
+                        stop(set, "superseded-input", at);
+                        continue;
+                    }
+                    try {
+                        if (owner.scope === "task" && retry.previousRunId !== undefined) {
+                            if (retry.successorRunId !== undefined || retry.successorReviewRoundId !== undefined)
+                                continue;
+                            const previous = store.getRun(owner.taskId, retry.previousRunId);
+                            if (previous?.status === "active")
+                                continue; // ordinary rejected-delivery terminal fold
+                            if (previous?.status !== "failed") {
+                                stop(set, "run-no-longer-failed", at);
+                                continue;
+                            }
+                            const actualTaskReviewCandidate = await ports.snapshotTaskCandidate?.(previous);
+                            store.transaction(() => {
+                                const latest = load(owner)?.providerBinding?.retry;
+                                if (latest?.chainId !== retry.chainId || latest.failedAttemptId !== retry.failedAttemptId
+                                    || latest.status !== "waiting")
+                                    return;
+                                const reason = retryIntentBlocker(store, scoped, latest);
+                                if (reason !== undefined)
+                                    throw new Error(reason);
+                                runTaskCommand(["run", "retry", `${owner.taskId}/${previous.id}`], store, {
+                                    now: () => new Date(at), environment: {}, providerRetryChainId: retry.chainId,
+                                    ...(actualTaskReviewCandidate === undefined ? {} : { actualTaskReviewCandidate })
+                                });
+                            });
                         }
-                        const result = await (ports.submit ?? sendAgentHostRunControl)({
-                            home, ...scoped, scope: owner.scope,
-                            control: {
-                                protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "submit-turn", nativeSessionId: retry.nativeSessionId,
-                                authority: { epoch: binding.authority.epoch, owner: "controller", holderId: binding.authority.holderId },
-                                run: { attemptId: providerRetryAttemptId(retry), boundedText: original }
+                        else {
+                            const original = retry.input.kind === "text" ? retry.input.text
+                                : retry.input.kind === "wake"
+                                    ? `Yui Task notification: task=${retry.input.taskId} wake=${retry.input.wakeId}.\nRead current Task context and that fixed wake window, including original Messages in full. This is not an execution assignment.`
+                                    : retry.input.kind === "message"
+                                        ? `Yui Global Message: role=${retry.input.roleName} message=${retry.input.messageId}.\nRead your Session Context and referenced original Message in full.`
+                                        : undefined;
+                            if (original === undefined) {
+                                stop(set, "original-input-unavailable", at);
+                                continue;
+                            }
+                            const result = await (ports.submit ?? sendAgentHostRunControl)({
+                                home, ...scoped, scope: owner.scope,
+                                control: {
+                                    protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "submit-turn", nativeSessionId: retry.nativeSessionId,
+                                    authority: { epoch: binding.authority.epoch, owner: "controller", holderId: binding.authority.holderId },
+                                    run: { attemptId: providerRetryAttemptId(retry), boundedText: original }
+                                }
+                            });
+                            // Durable settlement belongs to Host/Controller ingress. In
+                            // particular a lost response is never a reason to replay.
+                            if (result.outcome === "rejected" && result.failure?.registrationDisposition === "not-committed"
+                                && result.failure.errorName !== "ProviderTurnBusyError") {
+                                stop(set, result.failure.detail, at);
                             }
-                        });
-                        // Durable settlement belongs to Host/Controller ingress. In
-                        // particular a lost response is never a reason to replay.
-                        if (result.outcome === "rejected" && result.failure?.registrationDisposition === "not-committed"
-                            && result.failure.errorName !== "ProviderTurnBusyError") {
-                            stop(set, result.failure.detail, at);
                         }
                     }
+                    catch (error) {
+                        // A send failure may have applied. A durable submitting/unknown
+                        // identity fences it; do not manufacture a successor to uncertainty.
+                        const latest = load(owner);
+                        if (latest?.providerBinding?.run?.attemptId === retry.failedAttemptId) {
+                            stop(set, error instanceof Error ? error.message : String(error), at);
+                        }
+                        throw error;
+                    }
                 }
                 catch (error) {
-                    // A send failure may have applied. A durable submitting/unknown
-                    // identity fences it; do not manufacture a successor to uncertainty.
-                    const latest = load(owner);
-                    if (latest?.providerBinding?.run?.attemptId === retry.failedAttemptId) {
-                        stop(set, error instanceof Error ? error.message : String(error), at);
-                    }
-                    ports.onError?.(error);
+                    const failure = new Error(`Provider retry failed for ${owner.scope === "task" ? owner.taskId : "global"}/${owner.roleName}: `
+                        + `${error instanceof Error ? error.message : String(error)}. `
+                        + "Inspect the current attempt; failed observation does not authorize replay.", { cause: error });
+                    if (ports.onError === undefined)
+                        throw failure;
+                    ports.onError(failure);
                 }
             }
         }

package/dist/controller/runtime.js

@@ -10,7 +10,6 @@ import { effectiveLaunchConfig, resolveEffectiveLaunch, roleSessionMayContinue }
 import { agentProcessReadinessProbe, ExecutorRegistry } from "../executor/executorRegistry.js";
 import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
 import { createKernelPorts } from "../kernel/kernelPorts.js";
-import { createGlobalRoleMessage } from "../message/message.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { createResourceAutoGc } from "../resources/autoResourceGc.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
@@ -117,7 +116,7 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             store,
             environment: options.environment,
             tmux,
-            nativeConnection: (taskId, roleName) => planner.planNativeControl(taskId, roleName),
+            nativeConnection: (owner) => planner.planNativeControl(owner),
             onWarning: options.onError
         });
         // The runtime inbox is also the low-latency discovery source during a
@@ -252,31 +251,6 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             sessionHost,
             promptPush,
             launchCoordinator,
-            notifyOperatorInputOnce: async (input) => {
-                // The original attention mailbox remains pending until this one
-                // Global Message has an actual Provider receipt. Never inject keys
-                // into a busy Host console and mistake that for accepted attention.
-                const message = store.transaction(tx => {
-                    const requestId = `operator-notice:${encodeURIComponent(input.receiptId)}`;
-                    const previous = tx.listGlobalRoleMessages("operator").find(entry => (entry.inputControl ?? entry.interruptThen?.reusedInput)?.requestId === requestId);
-                    if (previous !== undefined)
-                        return previous;
-                    const sessions = tx.getGlobalRoleSessionSet("operator");
-                    const session = sessions?.sessions[sessions.activeAgentId];
-                    if (session?.status !== "active" || sessions?.providerBinding == null)
-                        return null;
-                    const created = { ...createGlobalRoleMessage(tx.nextGlobalRoleMessageId(), "operator", input.text, "system", { type: "system" }, new Date(), { inputControl: { action: "queue", requestId } }),
-                        deliveryTarget: { agentId: session.agentId, nativeSessionId: session.nativeSessionId } };
-                    tx.saveGlobalRoleMessage(created);
-                    return created;
-                });
-                if (message === null)
-                    return "unavailable";
-                if (message.delivery?.via === "provider")
-                    return "already-sent";
-                runningRuntime?.signal("global-role:operator");
-                return "not-ready";
-            },
             roleResourceInventory: async (panes, inputs) => {
                 const inventory = await scanInventory(panes);
                 return inventory.resources.flatMap((resource) => {
@@ -457,7 +431,7 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         const jobControl = kernel.jobs;
         const continuationReconciler = options.continuationMetadata === undefined
             ? undefined
-            : new ProviderContinuationReconciliationService(store, schedulerStore, options.continuationMetadata);
+            : new ProviderContinuationReconciliationService(store, schedulerStore, options.continuationMetadata, options.onError);
         const running = await startFileTaskController(home, schedulerStore, delivery, (method, params) => method === "task.role-capabilities"
             ? readTaskAgentCapabilities(store, catalogs, params)
             : method === "web.start" || method === "web.stop" || method === "web.status"

package/dist/controller/sessionOwnerReconciliation.js

@@ -1,11 +1,12 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { createTaskEvent } from "../event/taskEvent.js";
+import { createGlobalRoleMessage } from "../message/message.js";
 import { createSessionOwnerIdentity, isLinuxProcessLive, listOwnedProcessTree, readLinuxProcessIdentity, reconcileSessionOwners, terminateSessionOwners } from "../runtime/index.js";
 import { sessionOwnerProcessKey } from "../runtime/sessionOwnerIdentity.js";
 import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostCancelControl } from "../runtime/agentHost.js";
 import { settleProviderTurn, cancelQuiescentProviderInput, clearProviderGoal } from "../runtime/providerRuntimeIdentity.js";
-import { updateTaskRoleProviderRuntime, taskRoleControlTarget } from "../executor/agentExecutor.js";
+import { updateTaskRoleProviderRuntime, updateGlobalRoleProviderRuntime, roleSessionControlTarget } from "../executor/agentExecutor.js";
 import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
 import { stopCodexNativeSession } from "../runtime/nativeSessionControl.js";
 import { routeRoleEvent } from "../scheduler/operatorEvent.js";
@@ -34,8 +35,8 @@ export class SessionOwnerReconciliation {
         this.#tmux = deps.tmux;
         this.#onWarning = deps.onWarning ?? (() => undefined);
         this.#cancelInput = deps.cancelInput ?? sendAgentHostCancelControl;
-        this.#nativeConnection = deps.nativeConnection ?? ((taskId, roleName) => new FileRoleLaunchPlanner(this.#home, this.#store, { environment: this.#environment })
-            .planNativeControl(taskId, roleName));
+        this.#nativeConnection = deps.nativeConnection ?? ((owner) => new FileRoleLaunchPlanner(this.#home, this.#store, { environment: this.#environment })
+            .planNativeControl(owner));
         this.#stopNative = deps.stopNative ?? stopCodexNativeSession;
     }
     /**
@@ -173,33 +174,36 @@ export class SessionOwnerReconciliation {
         };
     }
     async #quiesceInput(owner) {
-        if (owner.scope !== "task")
-            return;
-        if (runtimeCleanupDisposition(this.#store.getWorkMailbox(runtimeLifecycleTarget(owner))) === "detach-host")
+        const disposition = runtimeCleanupDisposition(this.#store.getWorkMailbox(runtimeLifecycleTarget(owner)));
+        if (disposition === "detach-host")
             return;
-        const set = this.#store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+        const set = owner.scope === "task"
+            ? this.#store.getTaskRoleSessionSet(owner.taskId, owner.roleName)
+            : this.#store.getGlobalRoleSessionSet(owner.roleName);
         const binding = set?.providerBinding;
         const input = binding?.run;
         const unsettled = input != null && ["submitting", "accepted", "delivery-unknown"].includes(input.status);
         const hasGoal = binding?.goal != null && binding.goal.status !== "complete";
-        const selected = taskRoleControlTarget(set);
+        const selected = roleSessionControlTarget(set);
         if (set == null || (!unsettled && !hasGoal && selected?.adapterId !== "codex"))
             return;
         if (selected === undefined) {
             throw new Error("Cannot identify the native execution to stop.");
         }
-        const request = this.#store.listEvents(owner.taskId).filter(event => ["runtime.session-replacement-requested", "runtime.session-stop-requested"].includes(event.type)
+        const request = owner.scope === "task" ? this.#store.listEvents(owner.taskId).filter(event => ["runtime.session-replacement-requested", "runtime.session-stop-requested"].includes(event.type)
             && event.payload.roleName === owner.roleName
-            && event.payload.nativeSessionId === selected.nativeSessionId).at(-1);
-        const operatorStop = this.#store.getTask(owner.taskId)?.executionGate.state === "stopped"
-            || (request !== undefined && ["user", "operator"].includes(request.payload.requestedBy));
+            && event.payload.nativeSessionId === selected.nativeSessionId).at(-1) : undefined;
+        const operatorStop = owner.scope === "global"
+            ? disposition === "end-session" || disposition === "replace-session"
+            : this.#store.getTask(owner.taskId)?.executionGate.state === "stopped"
+                || (request !== undefined && ["user", "operator"].includes(request.payload.requestedBy));
         if (binding?.authority.owner === "human" && !operatorStop) {
             throw new Error("This native Session is under human control; Operator/user must request its stop or replacement.");
         }
         let terminal;
         try {
             const result = unsettled && binding?.authority.owner === "controller" && binding.authority.holderId !== undefined ? await this.#cancelInput({
-                home: this.#home, scope: "task", taskId: owner.taskId, roleName: owner.roleName,
+                home: this.#home, ...owner,
                 control: {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "cancel",
                     nativeSessionId: selected.nativeSessionId,
@@ -220,7 +224,7 @@ export class SessionOwnerReconciliation {
         }
         if (terminal === undefined || hasGoal || selected.adapterId === "codex") {
             if (selected.adapterId === "codex") {
-                await this.#stopNative(this.#nativeConnection(owner.taskId, owner.roleName), {
+                await this.#stopNative(this.#nativeConnection(owner), {
                     conversationId: selected.nativeSessionId,
                     nativeTurnId: unsettled && terminal === undefined ? input?.nativeTurnId : undefined,
                     clearGoal: true
@@ -237,7 +241,7 @@ export class SessionOwnerReconciliation {
                 }
                 else if (selected.status !== "ended"
                     || records.some(ownerRootIsLive)
-                    || this.#tmux?.probeRoleStatus(owner.taskId, owner.roleName) !== "exited") {
+                    || this.#tmux?.probeRoleStatus(owner.scope === "task" ? owner.taskId : "operator", owner.roleName) !== "exited") {
                     throw new Error("Native process custody is unavailable; inspect the exact local execution before reusing its workspace.");
                 }
             }
@@ -246,9 +250,12 @@ export class SessionOwnerReconciliation {
             }
         }
         this.#store.transaction(tx => {
-            const current = tx.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+            const current = owner.scope === "task"
+                ? tx.getTaskRoleSessionSet(owner.taskId, owner.roleName)
+                : tx.getGlobalRoleSessionSet(owner.roleName);
             const provider = current?.providerBinding;
             if (current == null || provider?.run?.attemptId !== input?.attemptId
+                || provider?.run?.nativeTurnId !== input?.nativeTurnId
                 || (selected.fromBinding
                     ? current.providerBinding?.conversations.find(entry => entry.status === "current")?.conversationId
                     : current.sessions[current.activeAgentId]?.nativeSessionId) !== selected.nativeSessionId
@@ -268,15 +275,26 @@ export class SessionOwnerReconciliation {
                 }
                 if (hasGoal || selected.adapterId === "codex")
                     stopped = clearProviderGoal(stopped);
-                tx.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(current, stopped, now));
-                tx.saveEvent(owner.taskId, createTaskEvent(tx.nextEventId(owner.taskId), owner.taskId, "runtime.input-stop-confirmed", {
-                    roleName: owner.roleName, ...(input == null ? {} : { attemptId: input.attemptId }),
-                    nativeSessionId: selected.nativeSessionId, status: stopped.run?.status ?? "quiescent",
-                    evidence: terminal === undefined ? "native-resource-inspection" : "native-terminal",
-                    ...(input?.nativeTurnId === undefined ? {} : { nativeTurnId: input.nativeTurnId })
-                }, now));
+                if (owner.scope === "global") {
+                    tx.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(current, stopped, now));
+                    if (unsettled || hasGoal)
+                        tx.saveGlobalRoleMessage(createGlobalRoleMessage(tx.nextGlobalRoleMessageId(), owner.roleName, `Explicit Session stop confirmed: ${JSON.stringify({
+                            nativeSessionId: selected.nativeSessionId, attemptId: input?.attemptId,
+                            nativeTurnId: input?.nativeTurnId, status: stopped.run?.status ?? "quiescent",
+                            evidence: terminal === undefined ? "native-resource-inspection" : "native-terminal"
+                        })}`, "system", { type: "system" }, now));
+                }
+                else {
+                    tx.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(current, stopped, now));
+                    tx.saveEvent(owner.taskId, createTaskEvent(tx.nextEventId(owner.taskId), owner.taskId, "runtime.input-stop-confirmed", {
+                        roleName: owner.roleName, ...(input == null ? {} : { attemptId: input.attemptId }),
+                        nativeSessionId: selected.nativeSessionId, status: stopped.run?.status ?? "quiescent",
+                        evidence: terminal === undefined ? "native-resource-inspection" : "native-terminal",
+                        ...(input?.nativeTurnId === undefined ? {} : { nativeTurnId: input.nativeTurnId })
+                    }, now));
+                }
             }
-            else if (selected.adapterId === "codex") {
+            else if (selected.adapterId === "codex" && owner.scope === "task") {
                 tx.saveEvent(owner.taskId, createTaskEvent(tx.nextEventId(owner.taskId), owner.taskId, "runtime.input-stop-confirmed", {
                     roleName: owner.roleName, nativeSessionId: selected.nativeSessionId,
                     status: "quiescent", evidence: "native-resource-inspection"

package/dist/controller/structuredProviderObservation.js

@@ -14,6 +14,33 @@ 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();
+/** Retained in the existing Host Inbox; it never settles a Turn or a resource. */
+export async function publishStructuredProviderDiagnostic(input) {
+    const diagnostic = input.diagnostic;
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const owner = describeHostIdentity(input.environment, adapterId, diagnostic.nativeSessionId);
+    const failure = diagnostic.failure;
+    await persistAndApply(input.home, [observation({
+            kind: diagnostic.attemptId === undefined ? "conversation.observed" : "observer.health",
+            sequence: nextStructuredSequence(), ordinal: 0,
+            observedAt: new Date().toISOString(),
+            fence: {
+                ...owner, driverId: builtinAgentDriverRegistry().requireByAdapterId(adapterId).id,
+                nativeSessionId: diagnostic.nativeSessionId, conversationId: diagnostic.nativeSessionId,
+                ...(diagnostic.attemptId === undefined ? {} : { receiptId: diagnostic.attemptId }),
+                ...(diagnostic.nativeTurnId === undefined ? {} : { nativeTurnId: diagnostic.nativeTurnId })
+            },
+            payload: {
+                ...(diagnostic.attemptId === undefined ? { recoverability: "unknown" } : {}),
+                sourceId: failure.phase === "host-stop" ? "host-cleanup" : "provider-channel",
+                observerStatus: "unavailable", observerDetail: failure.detail,
+                failure: { error: standardAgentError({
+                        source: "host", phase: failure.phase, message: failure.detail, raw: failure.raw ?? failure.detail,
+                        inputDisposition: failure.inputDisposition, sessionDisposition: failure.sessionDisposition
+                    }) }
+            }
+        })], input.environment);
+}
 /** A live transport observation, independent of Provider state and Run truth. */
 export function structuredProviderEventDelivery(home, environment, nativeSessionId) {
     try {
@@ -354,7 +381,7 @@ function observation(input) {
         payload: input.payload ?? {}
     };
     return createRuntimeObservation({
-        schemaVersion: 4,
+        schemaVersion: 1,
         eventId,
         semanticKey: runtimeObservationSemanticKey(partial),
         kind: input.kind,