@zq-silk/yui 0.15.9 → 0.15.11

package/dist/controller/runtimeHookRunFence.js

@@ -5,27 +5,66 @@ import { formatRunReceiptId } from "../task/taskRecordReference.js";
 import { currentProviderConversation, managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
 import { taskRoleRuntimeIdentity } from "../runtime/managedCaller.js";
 import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
+export class RuntimeHookRunFenceError extends Error {
+}
 /**
  * Resolve observations by Session and exact input identity. A startup Hook
  * may introduce a Session for an explicit new-Session AgentRun.
  */
-export function resolveRuntimeHookRunFence(environment, adapterId, payloadNativeSessionId, options = {}) {
+export function resolveRuntimeHookRunFence(environment, adapterId, payloadNativeSessionId, options = {}, currentStore) {
+    if (currentStore === undefined) {
+        const store = openCurrentTaskStore(requireIdentity(environment.YUI_HOME, "YUI_HOME"));
+        try {
+            return resolveRuntimeHookRunFence(environment, adapterId, payloadNativeSessionId, options, store);
+        }
+        finally {
+            store.close();
+        }
+    }
+    if (environment.YUI_SESSION_SCOPE === "global") {
+        if (environment.YUI_ADAPTER_ID !== adapterId)
+            throw new RuntimeHookRunFenceError("Global observation adapter mismatch.");
+        const roleName = requireIdentity(environment.YUI_ROLE, "Role name");
+        const agentId = requireIdentity(environment.YUI_AGENT_ID, "Agent id");
+        const workspace = requireIdentity(environment.YUI_WORKSPACE, "YUI workspace");
+        const nativeSessionId = requireIdentity(payloadNativeSessionId, "Provider session id");
+        const sessions = currentStore.getGlobalRoleSessionSet(roleName);
+        const role = currentStore.getGlobalRole(roleName);
+        const session = sessions?.sessions[agentId];
+        const turn = sessions?.providerBinding?.run;
+        if (role?.activeAgentId !== agentId || sessions?.activeAgentId !== agentId || session?.adapterId !== adapterId
+            || session.status === "ended"
+            || session.nativeSessionId !== nativeSessionId || session.effective.workspace.root !== workspace) {
+            throw new RuntimeHookRunFenceError("Global observation Session does not match durable state.");
+        }
+        if (options.attemptId !== undefined && turn?.attemptId !== options.attemptId
+            || options.nativeTurnId !== undefined && turn?.nativeTurnId !== undefined
+                && turn.nativeTurnId !== options.nativeTurnId) {
+            throw new RuntimeHookRunFenceError("Global observation does not match the exact current input.");
+        }
+        if (options.exactInput && (turn == null
+            || options.attemptId === undefined && (options.nativeTurnId === undefined || turn.nativeTurnId !== options.nativeTurnId)
+            || ["rejected", "deferred"].includes(turn.status))) {
+            throw new RuntimeHookRunFenceError("Global observation input has no exact execution binding.");
+        }
+        return { roleName, agentId, workspace, nativeSessionId,
+            ...(options.sessionOnly || turn == null ? {} : { receiptId: turn.attemptId }) };
+    }
     if (environment.YUI_SESSION_SCOPE !== "task") {
-        throw new Error("Runtime observation Hook requires a Task session scope.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook requires a Task session scope.");
     }
     if (environment.YUI_ADAPTER_ID !== adapterId) {
-        throw new Error(`Runtime observation Hook requires the ${adapterId} adapter.`);
+        throw new RuntimeHookRunFenceError(`Runtime observation Hook requires the ${adapterId} adapter.`);
     }
-    const home = requireIdentity(environment.YUI_HOME, "YUI_HOME");
     const taskId = requireIdentity(environment.YUI_TASK_ID, "Task id");
     const roleName = requireIdentity(environment.YUI_ROLE, "Role name");
     const agentId = requireIdentity(environment.YUI_AGENT_ID, "Agent id");
     const workspace = requireIdentity(environment.YUI_WORKSPACE, "YUI workspace");
     const nativeSessionId = requireIdentity(payloadNativeSessionId, "Provider session id");
-    const store = openCurrentTaskStore(home);
+    const store = currentStore;
     const task = store.getTask(taskId);
     if (task === null) {
-        throw new Error("Runtime observation Hook Task does not accept this lifecycle boundary.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook Task does not accept this lifecycle boundary.");
     }
     const role = store.getRole(taskId, roleName);
     const sessions = store.getTaskRoleSessionSet(taskId, roleName);
@@ -56,6 +95,14 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         taskId, roleName, agentId, nativeSessionId,
         continuationId: options.continuationId,
     }));
+    if (options.exactInput && acceptedBinding === null && !matchesProviderTurn) {
+        throw new RuntimeHookRunFenceError("Runtime observation Hook input has no exact accepted execution binding.");
+    }
+    if (options.startupRunId !== undefined && options.startupRunId !== activeRun?.id) {
+        // A historical Session can report terminal evidence, but its old startup
+        // must not bind a new Session under a successor's active Run.
+        throw new RuntimeHookRunFenceError("Runtime observation Hook startup does not match its exact launch Run.");
+    }
     // Collection of an exactly accepted terminal fact is not a new action by
     // the Role. A successor's active Agent or revoked execution permission
     // cannot erase the original AgentRun's evidence.
@@ -70,17 +117,26 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         && activeRun.purpose === "planning"
         && activeRun.roleName === roleName
         && runPurposeAdmitsTaskState(activeRun.purpose, task);
+    // Restoring the Draft Leader's existing planning Session needs no new Run.
+    // Admit its Session facts; the shared identity/workspace fence below still
+    // requires the exact current Session and never grants delivery authority.
+    const planningSessionObservation = options.sessionOnly === true
+        && task.status === "draft" && roleName === "leader"
+        && runPurposeAdmitsTaskState("planning", task)
+        && session?.status === "active"
+        && session.effective.executionAuthority === "planning";
     if (!(task.status === "active" && task.executionGate.state === "enabled")
         && !(task.status === "completed" && options.sessionOnly === true)
         && !planningObservation
+        && !planningSessionObservation
         && !existingExecutionObservation) {
-        throw new Error("Runtime observation Hook Task does not accept this lifecycle boundary.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook Task does not accept this lifecycle boundary.");
     }
     const runtimeIdentity = role === null ? null : taskRoleRuntimeIdentity(role, activeRun);
     if (!existingExecutionObservation && (runtimeIdentity === null || runtimeIdentity.agentId !== agentId
         || runtimeIdentity.adapterId !== adapterId
         || (sessions !== null && sessions.activeAgentId !== agentId))) {
-        throw new Error("Runtime observation Hook Role or Agent is not current.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook Role or Agent is not current.");
     }
     const lifecycleMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
         scope: "task",
@@ -97,7 +153,7 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
             || observedSession.adapterId !== adapterId
             || observedSession.nativeSessionId !== nativeSessionId
             || observedSession.effective.workspace.root !== workspace) {
-            throw new Error("Runtime observation Hook Session does not match durable state.");
+            throw new RuntimeHookRunFenceError("Runtime observation Hook Session does not match durable state.");
         }
         return {
             taskId,
@@ -146,7 +202,7 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         ? managedProviderTurnId(providerTurn) ?? undefined
         : undefined;
     if (options.terminal === true && acceptedBinding === null && registeredRunId === undefined) {
-        throw new Error("Runtime observation Hook terminal has no exact accepted execution binding.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook terminal has no exact accepted execution binding.");
     }
     const terminalRun = acceptedBinding !== null
         ? store.getRun(taskId, acceptedBinding.fence.runId)
@@ -166,7 +222,7 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         && !exactTerminal
         && registeredRunId === undefined
         && acceptedBinding === null) {
-        throw new Error("Runtime observation Hook has no matching durable in-flight AgentRun.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook has no matching durable in-flight AgentRun.");
     }
     const runId = acceptedBinding?.fence.runId
         ?? registeredRunId
@@ -181,21 +237,21 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         || run.roleName !== roleName
         || run.effective.agentId !== agentId
         || run.effective.adapterId !== adapterId) {
-        throw new Error("Runtime observation Hook AgentRun does not match durable active state.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook AgentRun does not match durable active state.");
     }
     if (run.effective.workspace.root !== workspace) {
-        throw new Error("Runtime observation Hook workspace does not match the durable AgentRun snapshot.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook workspace does not match the durable AgentRun snapshot.");
     }
     if (session !== undefined && acceptedBinding === null && !matchesProviderTurn && !replacementStartup && !resumedStartup) {
         if (session.adapterId !== adapterId
             || session.nativeSessionId !== nativeSessionId
             || session.effective.workspace.root !== workspace) {
-            throw new Error("Runtime observation Hook Session does not match durable state.");
+            throw new RuntimeHookRunFenceError("Runtime observation Hook Session does not match durable state.");
         }
     }
     else if (acceptedBinding === null && !matchesProviderTurn && (session === undefined || replacementStartup)) {
         if (!discoveredStartup && !preallocatedStartup) {
-            throw new Error("Runtime observation Hook has no matching new-Session intent.");
+            throw new RuntimeHookRunFenceError("Runtime observation Hook has no matching new-Session intent.");
         }
     }
     return {
@@ -230,7 +286,7 @@ function knownContinuationBinding(events, expected) {
         return null;
     if (matches.some((candidate) => candidate.fence.runId !== binding.fence.runId
         || candidate.fence.receiptId !== binding.fence.receiptId)) {
-        throw new Error("Runtime observation Hook continuation has conflicting durable AgentRun bindings.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook continuation has conflicting durable AgentRun bindings.");
     }
     return binding;
 }
@@ -260,17 +316,17 @@ function acceptedRunBinding(events, expected) {
             && candidate.fence.nativeTurnId !== expected.nativeTurnId)
         || candidate.fence.runId !== binding.fence.runId
         || candidate.fence.receiptId !== binding.fence.receiptId))) {
-        throw new Error("Runtime observation Hook native Turn has conflicting durable AgentRun bindings.");
+        throw new RuntimeHookRunFenceError("Runtime observation Hook native Turn has conflicting durable AgentRun bindings.");
     }
     return binding;
 }
 function requireIdentity(value, label) {
     if (typeof value !== "string" || value.includes("\0")) {
-        throw new Error(`${label} is required.`);
+        throw new RuntimeHookRunFenceError(`${label} is required.`);
     }
     const normalized = value.trim();
     if (normalized.length === 0 || normalized.length > 1_024) {
-        throw new Error(`${label} is invalid.`);
+        throw new RuntimeHookRunFenceError(`${label} is invalid.`);
     }
     return normalized;
 }

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]);
 }