@zq-silk/yui 0.15.3 → 0.15.6

package/dist/controller/runtimeEventProcessor.js

@@ -39,6 +39,22 @@ export class FileRuntimeEventProcessor {
                 offset = wave.nextOffset;
                 if (wave.candidates.length === 0)
                     continue;
+                if (ownsResultTransaction(wave.candidates[0].event)) {
+                    // Terminal preparation may inspect external workspace resources.
+                    // Its observer owns the atomic result commit after that inspection;
+                    // never enclose preparation in the cross-Task batch transaction.
+                    const candidate = wave.candidates[0];
+                    try {
+                        stateTransactions += 1;
+                        const failure = this.finalizeOne(this.foldOne(candidate, now), acknowledgedEventIds, deferred);
+                        if (failure !== undefined)
+                            recordDrainFailure(failure, failed, failedTaskIds);
+                    }
+                    catch (error) {
+                        recordDrainFailure(candidateDrainFailure(candidate.event, error), failed, failedTaskIds);
+                    }
+                    continue;
+                }
                 try {
                     stateTransactions += 1;
                     const folded = this.observer.withRuntimeEventTransaction(() => (wave.candidates.map((candidate) => this.foldOne(candidate, now))));
@@ -131,8 +147,9 @@ export class FileRuntimeEventProcessor {
         if (taskId !== undefined) {
             const task = this.observer.getTask(taskId);
             if (task === null
-                || task.status !== "active"
-                || task.executionGate.state !== "enabled")
+                || task.status === "archived"
+                || (!["turn.completed", "turn.failed", "turn.cancelled"].includes(event.observation.kind)
+                    && (task.status !== "active" || task.executionGate.state !== "enabled")))
                 return "obsolete";
         }
         return this.observer.observeRuntimeObservation?.(event.observation, now) ?? "obsolete";
@@ -452,15 +469,24 @@ function selectTaskOrderedWave(candidates, offset, failedTaskIds) {
             nextOffset += 1;
             continue;
         }
+        if (ownsResultTransaction(candidate.event) && selected.length > 0)
+            break;
         if (taskId !== undefined && selectedTaskIds.has(taskId))
             break;
         selected.push(candidate);
         if (taskId !== undefined)
             selectedTaskIds.add(taskId);
         nextOffset += 1;
+        if (ownsResultTransaction(candidate.event))
+            break;
     }
     return { candidates: selected, nextOffset };
 }
+function ownsResultTransaction(event) {
+    return event.type === "native-turn-terminal"
+        || (event.type === "runtime-observation"
+            && ["turn.completed", "turn.failed", "turn.cancelled"].includes(event.observation.kind));
+}
 function recordDrainFailure(failure, failed, failedTaskIds) {
     failed.push(failure);
     if (failure.scope === "task")
@@ -588,8 +614,9 @@ export class AsyncRuntimeEventProcessor {
         if (taskId !== undefined) {
             const task = await this.observer.getTask(taskId);
             if (task === null
-                || task.status !== "active"
-                || task.executionGate.state !== "enabled")
+                || task.status === "archived"
+                || (!["turn.completed", "turn.failed", "turn.cancelled"].includes(event.observation.kind)
+                    && (task.status !== "active" || task.executionGate.state !== "enabled")))
                 return "obsolete";
         }
         const outcome = (await this.observer.observeRuntimeObservation?.(event.observation, now))

package/dist/controller/runtimeHookTurnFence.js

@@ -26,22 +26,56 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
     const nativeSessionId = requireIdentity(payloadNativeSessionId, "Provider session id");
     const store = openCurrentTaskStore(home);
     const task = store.getTask(taskId);
-    if (task === null
-        || (!(task.status === "active" && task.executionGate.state === "enabled")
-            && !(task.status === "completed" && (options.terminal === true || options.sessionOnly === true)))) {
+    if (task === null) {
         throw new Error("Runtime observation Hook Task does not accept this lifecycle boundary.");
     }
     const role = store.getRole(taskId, roleName);
-    if (role === null || role.activeAgentId !== agentId) {
-        throw new Error("Runtime observation Hook Role or Agent is not current.");
-    }
     const sessions = store.getTaskRoleSessionSet(taskId, roleName);
-    if (sessions !== null && sessions.activeAgentId !== agentId) {
-        throw new Error("Runtime observation Hook Session Agent is not current.");
-    }
     const session = sessions?.sessions[agentId];
+    const executionSession = session?.nativeSessionId === nativeSessionId
+        ? session
+        : sessions?.history?.find((entry) => (entry.agentId === agentId && entry.nativeSessionId === nativeSessionId));
     const activeTurn = store.getActiveTurn(taskId, roleName);
     const providerTurn = sessions?.providerBinding?.turn;
+    // An input belongs to the Activation recorded at registration, even after
+    // detach or a successor Host launch. "Current activation" is not its owner.
+    const activation = providerTurn?.activationId === undefined
+        ? undefined
+        : sessions?.providerBinding?.activations.find((entry) => entry.activationId === providerTurn.activationId);
+    const matchesProviderTurn = providerTurn !== null
+        && providerTurn !== undefined
+        && executionSession?.adapterId === adapterId
+        && executionSession.effective.workspace.root === workspace
+        && activation?.conversationId === nativeSessionId
+        && ((options.attemptId !== undefined && providerTurn.attemptId === options.attemptId)
+            || (options.nativeTurnId !== undefined && providerTurn.nativeTurnId === options.nativeTurnId))
+        && (options.attemptId === undefined || providerTurn.attemptId === options.attemptId)
+        && (options.nativeTurnId === undefined || providerTurn.nativeTurnId === undefined
+            || providerTurn.nativeTurnId === options.nativeTurnId);
+    const acceptedTurn = acceptedTurnBinding(store.listEvents(taskId), {
+        taskId, roleName, agentId, nativeSessionId,
+        ...(options.nativeTurnId === undefined ? {} : { nativeTurnId: options.nativeTurnId }),
+        ...(options.attemptId === undefined ? {} : { attemptId: options.attemptId })
+    });
+    const acceptedBinding = acceptedTurn ?? (options.continuationId === undefined ? null : knownContinuationBinding(store.listEvents(taskId), {
+        taskId, roleName, agentId, nativeSessionId,
+        continuationId: options.continuationId,
+        continuationGeneration: options.continuationGeneration ?? 1
+    }));
+    // 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 Turn's evidence.
+    const existingExecutionObservation = (options.terminal === true || options.attemptId !== undefined)
+        && (acceptedBinding !== null || matchesProviderTurn);
+    if (!(task.status === "active" && task.executionGate.state === "enabled")
+        && !(task.status === "completed" && options.sessionOnly === true)
+        && !existingExecutionObservation) {
+        throw new Error("Runtime observation Hook Task does not accept this lifecycle boundary.");
+    }
+    if (!existingExecutionObservation && (role === null || role.activeAgentId !== agentId
+        || (sessions !== null && sessions.activeAgentId !== agentId))) {
+        throw new Error("Runtime observation Hook Role or Agent is not current.");
+    }
     // Launch generation and Turn are durable facts, never envelope facts. A
     // native pane outlives both, so anything it inherited at launch is stale for
     // every later generation; the Session's own record (or the in-flight launch
@@ -54,22 +88,25 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
     const reservedRuntimeGenerationId = isRuntimeLaunchReservation(lifecycleMailbox?.processing)
         ? lifecycleMailbox?.processing?.batchId
         : undefined;
-    const runtimeGenerationId = requireIdentity(session?.runtimeGenerationId ?? reservedRuntimeGenerationId, "Runtime generation id");
-    const durableTurnId = activeTurn?.id
-        ?? managedProviderTurnId(providerTurn)
-        ?? undefined;
-    const directProviderTurn = providerTurn !== null
-        && providerTurn !== undefined
-        && providerTurn.turnId === undefined
-        && ((options.attemptId !== undefined && providerTurn.attemptId === options.attemptId)
-            || (options.nativeTurnId !== undefined && providerTurn.nativeTurnId === options.nativeTurnId));
+    // Startup has a fresh process envelope and must prove the exact persisted
+    // launch. Existing/late execution events instead retain their old binding.
+    const reservedStartup = options.startupSession !== undefined
+        && activeTurn !== null
+        && reservedRuntimeGenerationId !== undefined
+        && environment.YUI_RUNTIME_GENERATION_ID === reservedRuntimeGenerationId
+        && !hasRuntimeCleanupObligation(lifecycleMailbox);
+    const runtimeGenerationId = requireIdentity(acceptedBinding?.fence.runtimeGenerationId
+        ?? (matchesProviderTurn ? activation.activationId : undefined)
+        ?? (reservedStartup ? reservedRuntimeGenerationId : session?.runtimeGenerationId), "Runtime generation id");
+    const directProviderTurn = matchesProviderTurn && providerTurn.turnId === undefined;
     const sessionOnlyObservation = options.sessionOnly === true && activeTurn === null;
-    if (directProviderTurn || sessionOnlyObservation) {
-        if (session === undefined
-            || session.adapterId !== adapterId
-            || session.runtimeGenerationId !== runtimeGenerationId
-            || session.nativeSessionId !== nativeSessionId
-            || session.effective.workspace.root !== workspace) {
+    if (acceptedBinding === null && (directProviderTurn || sessionOnlyObservation)) {
+        const observedSession = directProviderTurn ? executionSession : session;
+        if (observedSession === undefined
+            || observedSession.adapterId !== adapterId
+            || (!directProviderTurn && observedSession.runtimeGenerationId !== runtimeGenerationId)
+            || observedSession.nativeSessionId !== nativeSessionId
+            || observedSession.effective.workspace.root !== workspace) {
             throw new Error("Runtime observation Hook Session does not match durable state.");
         }
         return {
@@ -82,35 +119,19 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
             workspace
         };
     }
-    const activationReceiptId = providerTurn !== null
-        && providerTurn !== undefined
-        && managedProviderTurnId(providerTurn) === activeTurn?.id
+    const activationReceiptId = matchesProviderTurn
         ? providerTurn.attemptId
-        : activeTurn === null ? undefined : formatTurnReceiptId(taskId, activeTurn.id);
-    const acceptedTurn = options.nativeTurnId === undefined
-        ? null
-        : acceptedTurnBinding(store.listEvents(taskId), {
-            taskId,
-            roleName,
-            agentId,
-            nativeSessionId,
-            nativeTurnId: options.nativeTurnId
-        });
-    const acceptedBinding = acceptedTurn ?? (options.continuationId === undefined ? null : knownContinuationBinding(store.listEvents(taskId), {
-        taskId,
-        roleName,
-        agentId,
-        nativeSessionId,
-        continuationId: options.continuationId,
-        continuationGeneration: options.continuationGeneration ?? 1
-    }));
+        : providerTurn !== null
+            && providerTurn !== undefined
+            && managedProviderTurnId(providerTurn) === activeTurn?.id
+            ? providerTurn.attemptId
+            : activeTurn === null ? undefined : formatTurnReceiptId(taskId, activeTurn.id);
     const mailbox = lifecycleMailbox;
     const exactReservation = isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId)
         && !hasRuntimeCleanupObligation(mailbox);
-    const startupTurnId = options.startupSession === undefined
-        ? undefined
-        : requireIdentity(durableTurnId, "Turn id");
+    const startupTurnId = reservedStartup ? activeTurn.id : undefined;
     const startupReservation = startupTurnId !== undefined
+        && reservedStartup
         && exactReservation
         && !hasRuntimeCleanupObligation(mailbox);
     const startupTurn = startupTurnId === undefined
@@ -122,6 +143,12 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
         && startupReservation
         && startupTurn?.mode === "new"
         && session.status === "ended";
+    const resumedStartup = startupReservation
+        && startupTurn?.mode === "resume"
+        && session !== undefined
+        && session.adapterId === adapterId
+        && session.nativeSessionId === nativeSessionId
+        && session.effective.workspace.root === workspace;
     // The startup mode itself says whether Yui preallocated the native Session
     // id or the Provider reports it. A preallocated startup is proven against
     // Yui's deterministic runtime generation identity, which is stronger than comparing a
@@ -133,14 +160,17 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
     const discoveredStartup = options.startupSession === "discovered"
         && (session === undefined || replacementStartup)
         && startupReservation;
-    const terminalTurnId = options.terminal === true && acceptedBinding === null
-        ? requireIdentity(durableTurnId, "Turn id")
+    const registeredTurnId = acceptedBinding === null && matchesProviderTurn
+        ? managedProviderTurnId(providerTurn) ?? undefined
         : undefined;
+    if (options.terminal === true && acceptedBinding === null && registeredTurnId === undefined) {
+        throw new Error("Runtime observation Hook terminal has no exact accepted execution binding.");
+    }
     const terminalTurn = acceptedBinding !== null
         ? store.getTurn(taskId, acceptedBinding.fence.turnId)
-        : terminalTurnId === undefined
+        : registeredTurnId === undefined
             ? null
-            : store.getTurn(taskId, terminalTurnId);
+            : store.getTurn(taskId, registeredTurnId);
     const exactTerminal = terminalTurn !== null
         && terminalTurn.status !== "active"
         && terminalTurn.roleName === roleName
@@ -150,21 +180,24 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
     if (activeTurn === null
         && !preallocatedStartup
         && !discoveredStartup
+        && !resumedStartup
         && !exactTerminal
+        && registeredTurnId === undefined
         && acceptedBinding === null) {
         throw new Error("Runtime observation Hook has no matching durable in-flight Turn.");
     }
     const turnId = acceptedBinding?.fence.turnId
+        ?? registeredTurnId
         ?? activeTurn?.id
-        ?? startupTurnId
-        ?? terminalTurnId;
+        ?? startupTurnId;
     const effectiveRuntimeGenerationId = acceptedBinding?.fence.runtimeGenerationId ?? runtimeGenerationId;
-    const turn = acceptedBinding !== null || exactTerminal
+    const turn = acceptedBinding !== null || registeredTurnId !== undefined
         ? terminalTurn
         : store.getActiveTurn(taskId, roleName);
     if (turn === null
         || turn.id !== turnId
-        || (acceptedBinding === null && !exactTerminal && turn.status !== "active")
+        || (acceptedBinding === null && registeredTurnId === undefined && !exactTerminal && turn.status !== "active")
+        || turn.roleName !== roleName
         || turn.effective.agentId !== agentId
         || turn.effective.adapterId !== adapterId) {
         throw new Error("Runtime observation Hook Turn does not match durable active state.");
@@ -172,7 +205,7 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
     if (turn.effective.workspace.root !== workspace) {
         throw new Error("Runtime observation Hook workspace does not match the durable Turn snapshot.");
     }
-    if (session !== undefined && acceptedBinding === null && !replacementStartup) {
+    if (session !== undefined && acceptedBinding === null && !matchesProviderTurn && !replacementStartup && !resumedStartup) {
         if (session.adapterId !== adapterId
             || session.runtimeGenerationId !== effectiveRuntimeGenerationId
             || session.nativeSessionId !== nativeSessionId
@@ -180,7 +213,7 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
             throw new Error("Runtime observation Hook Session does not match its durable generation.");
         }
     }
-    else if (acceptedBinding === null && (session === undefined || replacementStartup)) {
+    else if (acceptedBinding === null && !matchesProviderTurn && (session === undefined || replacementStartup)) {
         if (!discoveredStartup && !preallocatedStartup) {
             throw new Error("Runtime observation Hook launch is not durably reserved.");
         }
@@ -225,15 +258,18 @@ function knownContinuationBinding(events, expected) {
     return binding;
 }
 function acceptedTurnBinding(events, expected) {
+    if (expected.nativeTurnId === undefined && expected.attemptId === undefined)
+        return null;
     const matches = events
         .map(runtimeObservationFromTaskEvent)
         .filter((observation) => observation !== null
-        && observation.kind === "turn.accepted"
+        && ["turn.accepted", "turn.completed", "turn.failed", "turn.cancelled"].includes(observation.kind)
         && observation.fence.taskId === expected.taskId
         && observation.fence.roleName === expected.roleName
         && observation.fence.agentId === expected.agentId
         && observation.fence.nativeSessionId === expected.nativeSessionId
-        && observation.fence.nativeTurnId === expected.nativeTurnId
+        && ((expected.attemptId !== undefined && observation.fence.receiptId === expected.attemptId)
+            || (expected.nativeTurnId !== undefined && observation.fence.nativeTurnId === expected.nativeTurnId))
         && observation.fence.turnId !== undefined)
         .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
         || (left.sequence ?? -1) - (right.sequence ?? -1)
@@ -242,9 +278,12 @@ function acceptedTurnBinding(events, expected) {
     const binding = matches.at(-1) ?? null;
     if (binding === null)
         return null;
-    if (matches.some((candidate) => candidate.fence.turnId !== binding.fence.turnId
+    if (matches.some((candidate) => ((expected.attemptId !== undefined && candidate.fence.receiptId !== expected.attemptId)
+        || (expected.nativeTurnId !== undefined && candidate.fence.nativeTurnId !== undefined
+            && candidate.fence.nativeTurnId !== expected.nativeTurnId)
+        || candidate.fence.turnId !== binding.fence.turnId
         || candidate.fence.runtimeGenerationId !== binding.fence.runtimeGenerationId
-        || candidate.fence.receiptId !== binding.fence.receiptId)) {
+        || candidate.fence.receiptId !== binding.fence.receiptId))) {
         throw new Error("Runtime observation Hook native Turn has conflicting durable Turn bindings.");
     }
     return binding;

package/dist/controller/runtimeLaunchCoordinator.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { createRuntimeBinding, RuntimeGenerationMismatchError, RuntimeHostContentionError, RuntimeLaunchError } from "../runtime/index.js";
+import { createRuntimeBinding, RuntimeGenerationMismatchError, RuntimeHostContentionError, RuntimeHostUnavailableError, RuntimeLaunchError } from "../runtime/index.js";
 import { sameEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 class RuntimeBindingContractError extends Error {
     constructor(message, options) {
@@ -76,8 +76,9 @@ export class RuntimeLaunchCoordinator {
         if (request.owner.scope === "global" && request.managedWorkspace !== undefined) {
             throw new Error("A global runtime cannot use a Task ManagedWorkspace.");
         }
+        let currentRequest = request;
         const assertLaunchCurrent = () => {
-            this.#assertCurrent?.(request);
+            this.#assertCurrent?.(currentRequest);
             assertCurrent?.();
         };
         const proposedGenerationId = requireText(this.#createGenerationId(), "Launch generation id");
@@ -155,8 +156,20 @@ export class RuntimeLaunchCoordinator {
                 throw new Error("Runtime host reported its pre-start launch fence more than once.");
             }
             validateRuntimeLaunchPreflight(preflight, request, runtimeGenerationId);
+            this.reservations.confirmRuntimeLaunchReservation({
+                owner: request.owner,
+                runtimeGenerationId
+            }, assertLaunchCurrent);
             preflightObserved = true;
             beforeHostStart?.(preflight);
+            // The pre-start persistence callback hands the fixed native Session to
+            // this reserved activation. From here on, fence against that exact new
+            // identity, not the historical Host we originally set out to restore.
+            // Do not accept both identities: a later change back is stale as well.
+            if (request.mode === "resume" && request.hostActivationId !== undefined) {
+                currentRequest = { ...request, hostActivationId: runtimeGenerationId };
+            }
+            assertLaunchCurrent();
         };
         let binding;
         try {
@@ -206,15 +219,21 @@ export class RuntimeLaunchCoordinator {
             }
         }
         catch (error) {
+            if (error instanceof RuntimeHostUnavailableError) {
+                // A failed reused attachment provides no authority to detach its
+                // native Conversation or schedule owner-wide physical cleanup.
+                throw error;
+            }
             if (error instanceof RuntimeGenerationMismatchError) {
-                await this.#settleFailedStart(request, runtimeGenerationId, reusedConfirmedRunningHost, runtimeIsolation, true);
-                throw new RuntimeLaunchError(false, runtimeGenerationId, error.message, "generation-mismatch");
+                // The observed Host is not the requested activation. Neither killing
+                // it nor scheduling owner-wide cleanup is justified by that conflict.
+                throw new RuntimeLaunchError(false, runtimeGenerationId, error.message, "generation-mismatch", { cause: error });
             }
             if (error instanceof RuntimeHostContentionError && reusedConfirmedRunningHost) {
                 // The exact recovered generation remains authoritative. A late human
                 // writer is transient backpressure and must not settle, clean, or
                 // terminalize that reservation.
-                throw new RuntimeLaunchError(true, runtimeGenerationId, error.message, error.reason);
+                throw new RuntimeLaunchError(true, runtimeGenerationId, error.message, error.reason, { cause: error });
             }
             if (error instanceof RuntimeHostContentionError
                 && !reusedConfirmedRunningHost) {
@@ -239,7 +258,7 @@ export class RuntimeLaunchCoordinator {
                 }
                 throw new RuntimeLaunchError(true, runtimeGenerationId, error.message, error instanceof RuntimeHostContentionError
                     ? error.reason
-                    : "previous-process");
+                    : "previous-process", { cause: error });
             }
             if (error instanceof RuntimeBindingContractError) {
                 // Never pass an untrusted hostRef to stop(). Reconcile the requested
@@ -251,7 +270,7 @@ export class RuntimeLaunchCoordinator {
             throw error;
         }
         if (reusedConfirmedRunningHost && binding.hostCreated === true) {
-            await this.#compensateStartedHost(request.owner, binding, runtimeGenerationId, runtimeIsolation, new Error(`Runtime host was recreated while recovering an existing generation: ${request.owner.roleName}.`));
+            await this.#compensateStartedHost(request.owner, binding, runtimeGenerationId, runtimeIsolation, reusedConfirmedRunningHost, new Error(`Runtime host was recreated while recovering an existing generation: ${request.owner.roleName}.`));
         }
         try {
             assertLaunchCurrent();
@@ -276,11 +295,11 @@ export class RuntimeLaunchCoordinator {
             }
         }
         catch (error) {
-            await this.#compensateStartedHost(request.owner, binding, runtimeGenerationId, runtimeIsolation, error);
+            await this.#compensateStartedHost(request.owner, binding, runtimeGenerationId, runtimeIsolation, reusedConfirmedRunningHost, error);
         }
         return binding;
     }
-    async #settleFailedStart(request, runtimeGenerationId, reusedConfirmedRunningHost, runtimeIsolation, forceCleanup = false) {
+    async #settleFailedStart(request, runtimeGenerationId, reusedConfirmedRunningHost, runtimeIsolation) {
         let inspection;
         try {
             inspection = await this.host.inspectOwner(request.owner);
@@ -288,7 +307,7 @@ export class RuntimeLaunchCoordinator {
         catch {
             // A rebind/preflight failure did not create the already-confirmed host.
             // Preserve its generation when the follow-up probe is merely unknown.
-            if (!reusedConfirmedRunningHost || forceCleanup)
+            if (!reusedConfirmedRunningHost)
                 this.#requireCleanup(request.owner);
             return;
         }
@@ -307,11 +326,18 @@ export class RuntimeLaunchCoordinator {
             }
             return;
         }
-        if (reusedConfirmedRunningHost && !forceCleanup)
+        if (reusedConfirmedRunningHost)
             return;
         this.#requireCleanup(request.owner);
     }
-    async #compensateStartedHost(owner, binding, runtimeGenerationId, runtimeIsolation, cause) {
+    async #compensateStartedHost(owner, binding, runtimeGenerationId, runtimeIsolation, reusedConfirmedRunningHost, cause) {
+        if (reusedConfirmedRunningHost && binding.hostCreated !== true) {
+            // Reattaching an existing activation gives this launch no ownership of
+            // it. A fresh activation inside a persistent Host is different: this
+            // launch still owns its startup and isolation cleanup even when the
+            // physical Host did not need to be created.
+            throw new RuntimeLaunchStateChangedError(`Runtime launch state changed while reusing a Host: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        }
         try {
             await this.host.stop(binding);
         }

package/dist/controller/runtimeObservationHook.js

@@ -18,6 +18,8 @@ export async function runRuntimeObservationHookCommand(stdinJson, environment =
         return;
     }
     const parsed = parseRuntimeObservationHook(stdinJson, environment, now, dependencies);
+    if (parsed.observations.length === 0)
+        return;
     const inbox = new FileRuntimeEventInbox(parsed.home);
     for (const observation of parsed.observations)
         inbox.enqueueObservation(observation);
@@ -84,6 +86,20 @@ export function parseRuntimeObservationHook(stdinJson, environment, now = new Da
     const driverId = requireIdentity(environment.YUI_DRIVER_ID, "Agent Driver id");
     const driver = drivers.require(driverId);
     const hookEventName = requireIdentity(payload.hook_event_name, "Agent Driver Hook event name");
+    if (environment.YUI_SESSION_SCOPE === "task" && driver.adapterId === "claude"
+        && environment.YUI_ADAPTER_ID === "claude") {
+        // Existing native Conversations may retain an old Yui observer plugin.
+        // Only the managed stream owns execution facts: Hooks do not expose its
+        // input attempt, and associating them with the currently active Turn can
+        // steal a successor's result. This observer is not a permission handler;
+        // Claude's configured tool policy and other user plugins remain intact.
+        return {
+            home: requireIdentity(environment.YUI_HOME, "YUI_HOME"),
+            taskId: requireIdentity(environment.YUI_TASK_ID, "Task id"),
+            roleName: requireIdentity(environment.YUI_ROLE, "Role name"),
+            observations: Object.freeze([])
+        };
+    }
     const receivedAt = now.toISOString();
     const sequence = (dependencies.sequence ?? monotonicSequence)();
     const occurrenceId = `${receivedAt}:${sequence}`;
@@ -124,7 +140,7 @@ export function parseRuntimeObservationHook(stdinJson, environment, now = new Da
             conversationId: fence.nativeSessionId,
             activationId: fence.runtimeGenerationId,
             nativeSessionId: fence.nativeSessionId,
-            nativeTurnId: nativeTurnId ?? fence.turnId,
+            ...(nativeTurnId === undefined ? {} : { nativeTurnId }),
             receiptId: fence.receiptId ?? formatTurnReceiptId(fence.taskId, fence.turnId)
         },
         payload

package/dist/controller/structuredProviderObservation.js

@@ -8,6 +8,7 @@ import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
 import { resolveRuntimeHookTurnFence } from "./runtimeHookTurnFence.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 let structuredSequence = 0;
 export async function publishStructuredProviderStarted(input) {
     if (input.started.clientOwned)
@@ -58,39 +59,25 @@ export async function publishStructuredProviderAccepted(input) {
         driverId: driver.id,
         runtimeGenerationId: fence.runtimeGenerationId,
         conversationId: input.receipt.conversationId,
-        activationId: requireIdentity(input.activationId, "Provider Activation id"),
+        activationId: executionActivationId(input.home, fence, input.activationId, input.receipt.nativeSessionId),
         nativeSessionId: input.receipt.nativeSessionId,
-        nativeTurnId: input.receipt.nativeTurnId,
+        ...(input.receipt.nativeTurnId === undefined ? {} : {
+            nativeTurnId: input.receipt.nativeTurnId
+        }),
         // The structured Host owns the exact input attempt identity. Runtime
         // descriptor receipts name the Turn bootstrap and must not overwrite a
         // continuation or human-takeover Turn.
         receiptId: input.receipt.attemptId
     };
     const baseSequence = nextStructuredSequence();
+    // Opening owns the Session/Activation lifecycle. A receipt arriving after
+    // its terminal must not reopen either lifecycle as an acceptance side effect.
     const observations = [observation({
-            kind: startupSession === "preallocated" ? "session.ready" : "session.started",
-            observedAt,
-            sequence: baseSequence,
-            ordinal: 0,
-            fence: commonFence
-        }), observation({
-            kind: "conversation.observed",
-            observedAt,
-            sequence: baseSequence,
-            ordinal: 1,
-            fence: commonFence,
-            payload: { recoverability: "recoverable" }
-        }), observation({
-            kind: "activation.started",
-            observedAt,
-            sequence: baseSequence,
-            ordinal: 2,
-            fence: commonFence
-        }), observation({
             kind: "turn.accepted",
+            authority: input.receipt.acceptance === "transport" ? "transport" : "provider-structured",
             observedAt,
             sequence: baseSequence,
-            ordinal: 3,
+            ordinal: 0,
             fence: commonFence
         })];
     await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
@@ -215,6 +202,7 @@ export async function publishStructuredProviderTerminal(input) {
     const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.terminal.nativeSessionId, {
         terminal: true,
         nativeTurnId: input.terminal.nativeTurnId,
+        attemptId: input.terminal.attemptId,
         ...(input.terminal.clientOwned ? {} : { sessionOnly: true })
     });
     const kind = input.terminal.status === "completed"
@@ -226,7 +214,9 @@ export async function publishStructuredProviderTerminal(input) {
             ...(input.terminal.input === undefined ? {} : { input: input.terminal.input }),
             ...(transported.status === "completed"
                 ? { output: transported.output }
-                : { resultTransportDiagnostic: transported.diagnostic })
+                : transported.failureReason === "runtime-failed"
+                    ? { resultTransportDiagnostic: transported.diagnostic }
+                    : {})
         }
         : kind === "turn.failed"
             ? {
@@ -264,10 +254,14 @@ export async function publishStructuredProviderTerminal(input) {
             driverId: driver.id,
             runtimeGenerationId: fence.runtimeGenerationId,
             conversationId: input.terminal.conversationId,
-            activationId: requireIdentity(input.activationId, "Provider Activation id"),
+            activationId: executionActivationId(input.home, fence, input.activationId, input.terminal.nativeSessionId),
             nativeSessionId: input.terminal.nativeSessionId,
-            nativeTurnId: input.terminal.nativeTurnId,
-            ...(fence.receiptId === undefined ? {} : { receiptId: fence.receiptId })
+            ...(input.terminal.nativeTurnId === undefined ? {} : {
+                nativeTurnId: input.terminal.nativeTurnId
+            }),
+            ...(input.terminal.attemptId === undefined
+                ? fence.receiptId === undefined ? {} : { receiptId: fence.receiptId }
+                : { receiptId: input.terminal.attemptId })
         },
         payload
     });
@@ -312,7 +306,7 @@ function observation(input) {
         eventId,
         semanticKey: runtimeObservationSemanticKey(partial),
         kind: input.kind,
-        authority: "provider-structured",
+        authority: input.authority ?? "provider-structured",
         receivedAt: new Date().toISOString(),
         observedAt: input.observedAt,
         sequence: input.sequence,
@@ -336,6 +330,24 @@ function requireIdentity(value, label) {
     }
     return value.trim();
 }
+function executionActivationId(home, fence, sourceActivationId, nativeSessionId) {
+    const sourceId = requireIdentity(sourceActivationId, "Provider Activation id");
+    const store = openCurrentTaskStore(home);
+    try {
+        const binding = store.getTaskRoleSessionSet(fence.taskId, fence.roleName)?.providerBinding;
+        const source = binding?.activations.find(entry => entry.activationId === sourceId);
+        const original = binding?.activations.find(entry => entry.activationId === fence.runtimeGenerationId);
+        if (source?.conversationId !== nativeSessionId || original?.conversationId !== nativeSessionId) {
+            throw new Error("Structured execution observation source does not belong to its native Conversation.");
+        }
+        // A reattached collector can observe the old execution, but its current
+        // attachment must not replace that execution's durable Activation identity.
+        return original.activationId;
+    }
+    finally {
+        store.close();
+    }
+}
 async function persistAndApply(home, observations, taskId, roleName) {
     const inbox = new FileRuntimeEventInbox(home);
     for (const entry of observations)

package/dist/core/controllerClient.js

@@ -20,6 +20,11 @@ export function controllerCallMayHaveApplied(error) {
         && [
             "CONTROLLER_TIMEOUT",
             "CONTROLLER_UNAVAILABLE",
+            // Raised only after the request write began, so the Controller may well
+            // have committed it. Omitting it reported a genuinely unknown outcome as
+            // a definite failure, which is the one classification callers must not
+            // make: it invites treating possibly-applied work as never applied.
+            "CONTROLLER_DELIVERY_UNKNOWN",
             "INVALID_RESPONSE"
         ].includes(error.code);
 }