@zq-silk/yui 0.13.8 → 0.13.9

package/dist/controller/runtime.js

@@ -555,9 +555,14 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
     const lifecycleTails = new Map();
     return async (method, params) => {
         if (method === "runtime.observation-apply") {
-            return {
-                outcome: schedulerStore.observeRuntimeObservation(createRuntimeObservation(params), new Date())
-            };
+            try {
+                return {
+                    outcome: schedulerStore.observeRuntimeObservation(createRuntimeObservation(params), new Date())
+                };
+            }
+            catch (error) {
+                throw applicationError("INVALID_PARAMS", error instanceof Error ? error.message : String(error));
+            }
         }
         if (method === "runtime.provider-turn-begin") {
             const value = providerTurnControlParams(params);
@@ -588,8 +593,10 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             const value = providerTurnControlParams(params);
             const status = params.status;
             const reason = params.reason;
+            const raw = params.raw;
             if ((status !== "rejected" && status !== "delivery-unknown")
-                || typeof reason !== "string" || reason.trim().length === 0) {
+                || typeof reason !== "string" || reason.trim().length === 0
+                || typeof raw !== "string" || raw.trim().length === 0) {
                 throw applicationError("INVALID_PARAMS", "Provider Turn resolution is invalid.");
             }
             schedulerStore.resolveAgentHostProviderTurnSubmission({
@@ -599,6 +606,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 attemptId: value.attemptId,
                 status,
                 reason,
+                raw,
                 now: value.now
             });
             return { recorded: true };
@@ -769,7 +777,6 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             validateLifecycleEnvironment(request.environment, agent);
             const session = sessions?.sessions[effective.agentId];
             const managedTurnDispatch = activeRun !== null && (activeRun.pushedAt === undefined
-                || activeRun.providerRetry?.state === "dispatching"
                 || activeRun.controlRequest?.state === "dispatching");
             // An ensure call may reattach the already-admitted Run to its existing
             // Conversation, but it may not manufacture a fresh Conversation without a

package/dist/controller/runtimeHookRunFence.js

@@ -87,19 +87,13 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
     }));
     const exactReservation = isRuntimeLaunchReservation(mailbox?.processing, launchId)
         && !hasRuntimeCleanupObligation(mailbox);
-    const executionRef = mailbox?.processing?.executionRef;
     const startupRunId = options.startupSession === undefined
         ? undefined
         : requireIdentity(runtime?.runId
-            ?? environment.YUI_RUN_ID
-            ?? (executionRef?.type === "run" && executionRef.taskId === taskId
-                ? executionRef.id
-                : undefined), "Run id");
+            ?? environment.YUI_RUN_ID, "Run id");
     const startupReservation = startupRunId !== undefined
         && exactReservation
-        && executionRef?.type === "run"
-        && executionRef.taskId === taskId
-        && executionRef.id === startupRunId;
+        && !hasRuntimeCleanupObligation(mailbox);
     const startupRun = startupRunId === undefined
         ? null
         : store.getAgentRun(taskId, startupRunId);
@@ -108,7 +102,7 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         && sessions !== null
         && startupReservation
         && startupRun?.mode === "new"
-        && (session.status === "stopped" || session.status === "broken");
+        && session.status === "ended";
     const preallocatedStartup = options.startupSession === "preallocated"
         && expectedNativeSessionId !== undefined
         && (session === undefined || replacementStartup)

package/dist/controller/runtimeLaunchCoordinator.js

@@ -89,42 +89,45 @@ export class RuntimeLaunchCoordinator {
         };
         const generationPrefix = `runtime-${expectedFingerprint}:generation:`;
         const proposedGenerationId = requireText(this.#createGenerationId(), "Launch generation id");
-        const proposedLaunchId = `${generationPrefix}${proposedGenerationId}`;
-        let runtimeIsolation = this.#preflightRuntimeIsolation(request, proposedLaunchId, proposedGenerationId, false);
+        let proposedLaunchId = `${generationPrefix}${proposedGenerationId}`;
+        let reusedConfirmedRunningHost = false;
+        if (request.mode === "resume" && request.hostActivationId !== undefined) {
+            if (!request.hostActivationId.startsWith(generationPrefix)) {
+                throw new Error("Session restore targets an incompatible Host activation.");
+            }
+            const inspection = await this.host.inspectOwner(request.owner);
+            if (inspection.state === "unavailable" || inspection.state === "starting") {
+                throw new RuntimeLaunchError(true, request.hostActivationId, `Host activation is temporarily ${inspection.state}: ${request.owner.roleName}.`);
+            }
+            if (inspection.state === "running") {
+                proposedLaunchId = request.hostActivationId;
+                reusedConfirmedRunningHost = true;
+            }
+        }
+        let runtimeIsolation = reusedConfirmedRunningHost
+            ? undefined
+            : this.#preflightRuntimeIsolation(request, proposedLaunchId, proposedGenerationId, false);
         let reservation = this.reservations.reserveRuntimeLaunch({
             owner: request.owner,
-            launchId: proposedLaunchId,
-            ...(request.runId === undefined ? {} : { runId: request.runId })
+            launchId: proposedLaunchId
         }, assertLaunchCurrent, this.#now());
-        let reusedConfirmedRunningHost = false;
         if (reservation.status === "existing") {
             if (!reservation.launchId.startsWith(generationPrefix)) {
                 this.#requireCleanup(request.owner);
                 throw new Error(`Runtime launch reservation belongs to stale Role or Agent state: ${request.owner.roleName}.`);
             }
-            const sameRunReservation = request.runId !== undefined
-                && reservation.runId === request.runId;
-            const differentRunReservation = request.runId !== undefined
-                && reservation.runId !== undefined
-                && reservation.runId !== request.runId;
             const inspection = await this.host.inspectOwner(request.owner);
             if (inspection.state === "unavailable" || inspection.state === "starting") {
-                if (sameRunReservation) {
-                    throw new RuntimeLaunchError(true, reservation.launchId, `Runtime is temporarily ${inspection.state}: ${request.runId}/${reservation.launchId}.`);
-                }
-                throw new Error(`Runtime launch reservation cannot yet be verified: ${request.owner.roleName}.`);
+                throw new RuntimeLaunchError(true, reservation.launchId, `Runtime is temporarily ${inspection.state}: ${request.owner.roleName}/${reservation.launchId}.`);
             }
             if (inspection.state === "stopped") {
-                if (sameRunReservation) {
-                    throw new RuntimeLaunchError(false, reservation.launchId, `Exact Run launch generation stopped before delivery: ${request.runId}/${reservation.launchId}.`);
-                }
                 const taskOwner = request.owner.scope === "task"
                     ? request.owner
                     : undefined;
                 let exactCleanupAttempted = false;
                 let completed = false;
                 try {
-                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, reservation.launchId, differentRunReservation ? reservation.runId : undefined, taskOwner !== undefined && this.#runtimeIsolation !== undefined
+                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, reservation.launchId, taskOwner !== undefined && this.#runtimeIsolation !== undefined
                         ? () => {
                             exactCleanupAttempted = true;
                             this.#cleanupTaskLaunch(taskOwner, reservation.launchId);
@@ -143,19 +146,15 @@ export class RuntimeLaunchCoordinator {
                 }
                 reservation = this.reservations.reserveRuntimeLaunch({
                     owner: request.owner,
-                    launchId: proposedLaunchId,
-                    ...(request.runId === undefined ? {} : { runId: request.runId })
+                    launchId: proposedLaunchId
                 }, assertLaunchCurrent, this.#now());
                 if (reservation.status !== "reserved") {
                     throw new Error("Runtime launch reservation could not be renewed.");
                 }
             }
             else {
-                if (differentRunReservation) {
-                    throw new Error(`Runtime launch reservation belongs to another Run whose host is still running: ${reservation.runId}.`);
-                }
                 reusedConfirmedRunningHost = true;
-                runtimeIsolation = this.#preflightRuntimeIsolation(request, reservation.launchId, reservation.launchId.slice(generationPrefix.length), true);
+                runtimeIsolation = undefined;
                 assertLaunchCurrent();
             }
         }
@@ -194,7 +193,7 @@ export class RuntimeLaunchCoordinator {
                         ? {}
                         : { environment: request.environment })
                 }, beforeHostStart === undefined ? undefined : observePreflight)
-                : await this.host.resume({
+                : await this.host.restore({
                     mode: "resume",
                     launchId,
                     owner: request.owner,
@@ -228,7 +227,7 @@ export class RuntimeLaunchCoordinator {
                 let exactCleanupAttempted = false;
                 let completed = false;
                 try {
-                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, launchId, undefined, runtimeIsolation === undefined
+                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, launchId, runtimeIsolation === undefined
                         ? undefined
                         : () => {
                             exactCleanupAttempted = true;
@@ -258,31 +257,28 @@ export class RuntimeLaunchCoordinator {
             throw error;
         }
         if (reusedConfirmedRunningHost && binding.hostCreated === true) {
-            if (request.runId !== undefined && reservation.runId === request.runId) {
-                throw new RuntimeLaunchError(false, launchId, `Exact Run launch generation was unexpectedly recreated: ${request.runId}/${launchId}.`);
-            }
             await this.#compensateStartedHost(request.owner, binding, launchId, runtimeIsolation, new Error(`Runtime host was recreated while recovering an existing generation: ${request.owner.roleName}.`));
         }
         try {
             assertLaunchCurrent();
-            if (persistence === "immediate" && binding.nativeSessionId !== undefined) {
-                this.reservations.recordReservedRuntimeNativeSession({
-                    owner: request.owner,
-                    launchId,
-                    agentId: request.agentId,
-                    adapterId: request.adapterId,
-                    nativeSessionId: binding.nativeSessionId,
-                    effective: request.effective
-                }, assertLaunchCurrent, this.#now());
-            }
-            else {
-                // Deferred scheduler persistence records a known native identity while
-                // retaining the reservation until exact Run delivery. Fresh Codex has
-                // no identity yet and keeps it until its matching generation Hook.
-                this.reservations.confirmRuntimeLaunchReservation({
-                    owner: request.owner,
-                    launchId
-                }, assertLaunchCurrent);
+            const reservationState = this.reservations.confirmRuntimeLaunchReservation({
+                owner: request.owner,
+                launchId
+            }, assertLaunchCurrent);
+            if (reservationState === "reserved") {
+                if (binding.nativeSessionId !== undefined) {
+                    this.reservations.recordReservedRuntimeNativeSession({
+                        owner: request.owner,
+                        launchId,
+                        agentId: request.agentId,
+                        adapterId: request.adapterId,
+                        nativeSessionId: binding.nativeSessionId,
+                        effective: request.effective
+                    }, assertLaunchCurrent, this.#now());
+                }
+                else if (!this.reservations.completeRuntimeLaunchReservation(request.owner, launchId)) {
+                    throw new Error("Runtime Host-start reservation changed before completion.");
+                }
             }
         }
         catch (error) {
@@ -366,7 +362,6 @@ export class RuntimeLaunchCoordinator {
         }
         return this.#runtimeIsolation.preflight({
             workspace: request.managedWorkspace,
-            ...(request.runId === undefined ? {} : { runId: request.runId }),
             launchId,
             generationId: requireText(generationId, "Launch generation id"),
             ...(request.runtimePolicy === undefined ? {} : { policy: request.runtimePolicy }),
@@ -419,9 +414,7 @@ function validateRuntimeLaunchPreflight(preflight, request, launchId) {
         || preflight.adapterId !== request.adapterId
         || !effectiveLaunchSnapshotsCompatible(preflight.effective, request.effective)
         || (request.mode === "resume"
-            && preflight.nativeSessionId !== request.nativeSessionId)
-        || (preflight.initialTurnRunId !== undefined
-            && preflight.initialTurnRunId !== request.runId)) {
+            && preflight.nativeSessionId !== request.nativeSessionId)) {
         throw new Error(`Session host pre-start launch fence does not match the requested runtime: ${request.owner.roleName}.`);
     }
 }
@@ -438,22 +431,6 @@ function requireMatchingRuntimeBinding(raw, request, launchId) {
         && (binding.owner.scope === "global"
             || (request.owner.scope === "task"
                 && binding.owner.taskId === request.owner.taskId));
-    if (binding.initialTurnRunId !== undefined
-        && binding.initialTurnRunId !== request.runId) {
-        throw new RuntimeBindingContractError(`Session host returned an initial structured Turn for another Run: ${request.owner.roleName}.`);
-    }
-    if (binding.initialTurnDeliveryUnknownRunId !== undefined
-        && binding.initialTurnDeliveryUnknownRunId !== request.runId) {
-        throw new RuntimeBindingContractError(`Session host returned a delivery-unknown initial structured Turn for another Run: ${request.owner.roleName}.`);
-    }
-    if (binding.initialTurnBusyRunId !== undefined
-        && binding.initialTurnBusyRunId !== request.runId) {
-        throw new RuntimeBindingContractError(`Session host returned a busy initial structured Turn for another Run: ${request.owner.roleName}.`);
-    }
-    if (binding.initialTurnRejectedRunId !== undefined
-        && binding.initialTurnRejectedRunId !== request.runId) {
-        throw new RuntimeBindingContractError(`Session host returned a rejected initial structured Turn for another Run: ${request.owner.roleName}.`);
-    }
     if (binding.launchId !== launchId
         || !ownerMatches
         || binding.agentId !== request.agentId

package/dist/controller/structuredProviderObservation.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { callController } from "../core/controllerClient.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { standardAgentError } from "../runtime/agentError.js";
 import { createRuntimeObservation, runtimeObservationSemanticKey } from "../runtime/runtimeObservation.js";
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
@@ -159,11 +160,23 @@ export async function publishStructuredProviderTerminal(input) {
         : kind === "turn.failed"
             ? {
                 failure: {
-                    code: "provider-structured-failure",
-                    ...(input.terminal.error === undefined
-                        ? {}
-                        : { details: input.terminal.error })
-                }
+                    error: standardAgentError({
+                        source: "provider",
+                        phase: "turn-execute",
+                        classification: driver.runtime.mapError({
+                            message: input.terminal.error ?? "Provider Turn failed.",
+                            raw: input.terminal.rawError
+                                ?? input.terminal.error
+                                ?? "Provider Turn failed without an error payload."
+                        }),
+                        message: input.terminal.error ?? "Provider Turn failed.",
+                        raw: input.terminal.rawError
+                            ?? input.terminal.error
+                            ?? "Provider Turn failed without an error payload.",
+                        inputDisposition: "accepted"
+                    })
+                },
+                summary: input.terminal.error ?? "Provider Turn failed."
             }
             : {};
     const terminalObservation = observation({

package/dist/coordination/workMailbox.js

@@ -157,7 +157,7 @@ function requireProcessing(mailbox, batchId) {
 }
 export function createWorkMailbox(target) {
     return {
-        schemaVersion: 2,
+        schemaVersion: 3,
         target: copyTarget(target),
         nextSequence: 1,
         processing: null,
@@ -173,8 +173,8 @@ export function createWorkMailbox(target) {
 export function validateWorkMailbox(value) {
     const mailbox = record(value, "WorkMailbox");
     exact(mailbox, ["schemaVersion", "target", "nextSequence", "processing", "pending", "inputDelivery"], "WorkMailbox");
-    if (mailbox.schemaVersion !== 2)
-        throw new Error("WorkMailbox must use schemaVersion 2");
+    if (mailbox.schemaVersion !== 3)
+        throw new Error("WorkMailbox must use schemaVersion 3");
     const target = parseTarget(mailbox.target);
     const nextSequence = requireInteger(mailbox.nextSequence, 1, "WorkMailbox nextSequence");
     const processing = mailbox.processing === null ? null : parseProcessing(mailbox.processing);
@@ -215,7 +215,7 @@ export function validateWorkMailbox(value) {
     if (inputDelivery !== null && target.kind !== "role" && target.kind !== "operator") {
         throw new Error("WorkMailbox inputDelivery requires a Role or Operator target");
     }
-    return { schemaVersion: 2, target, nextSequence, processing, pending, inputDelivery };
+    return { schemaVersion: 3, target, nextSequence, processing, pending, inputDelivery };
 }
 function parsePendingLanes(value) {
     const lanes = record(value, "WorkMailbox pending");

package/dist/execution/executionHealth.js

@@ -205,7 +205,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
         });
     }
     const exit = latestExactProcessExit(input.events, run, session);
-    const sessionDead = session?.status === "stopped" || session?.status === "broken";
+    const sessionDead = session?.status === "ended";
     if (sessionDead
         && exit !== null
         && isAbnormalExit(exit.classification)