@zq-silk/yui 0.14.1 → 0.14.2

package/dist/controller/runtimeLaunchCoordinator.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { createRuntimeBinding, RuntimeHostContentionError, RuntimeLaunchError } from "../runtime/index.js";
+import { createRuntimeBinding, RuntimeGenerationMismatchError, RuntimeHostContentionError, RuntimeLaunchError } from "../runtime/index.js";
 import { effectiveLaunchSnapshotsCompatible, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 class RuntimeBindingContractError extends Error {
     constructor(message, options) {
@@ -89,7 +89,7 @@ export class RuntimeLaunchCoordinator {
         };
         const generationPrefix = `runtime-${expectedFingerprint}:generation:`;
         const proposedGenerationId = requireText(this.#createGenerationId(), "Launch generation id");
-        let proposedLaunchId = `${generationPrefix}${proposedGenerationId}`;
+        let proposedRuntimeGenerationId = `${generationPrefix}${proposedGenerationId}`;
         let reusedConfirmedRunningHost = false;
         if (request.mode === "resume" && request.hostActivationId !== undefined) {
             if (!request.hostActivationId.startsWith(generationPrefix)) {
@@ -100,25 +100,25 @@ export class RuntimeLaunchCoordinator {
                 throw new RuntimeLaunchError(true, request.hostActivationId, `Host activation is temporarily ${inspection.state}: ${request.owner.roleName}.`);
             }
             if (inspection.state === "running") {
-                proposedLaunchId = request.hostActivationId;
+                proposedRuntimeGenerationId = request.hostActivationId;
                 reusedConfirmedRunningHost = true;
             }
         }
         let runtimeIsolation = reusedConfirmedRunningHost
             ? undefined
-            : this.#preflightRuntimeIsolation(request, proposedLaunchId, proposedGenerationId, false);
+            : this.#preflightRuntimeIsolation(request, proposedRuntimeGenerationId, proposedGenerationId, false);
         let reservation = this.reservations.reserveRuntimeLaunch({
             owner: request.owner,
-            launchId: proposedLaunchId
+            runtimeGenerationId: proposedRuntimeGenerationId
         }, assertLaunchCurrent, this.#now());
         if (reservation.status === "existing") {
-            if (!reservation.launchId.startsWith(generationPrefix)) {
+            if (!reservation.runtimeGenerationId.startsWith(generationPrefix)) {
                 this.#requireCleanup(request.owner);
                 throw new Error(`Runtime launch reservation belongs to stale Role or Agent state: ${request.owner.roleName}.`);
             }
             const inspection = await this.host.inspectOwner(request.owner);
             if (inspection.state === "unavailable" || inspection.state === "starting") {
-                throw new RuntimeLaunchError(true, reservation.launchId, `Runtime is temporarily ${inspection.state}: ${request.owner.roleName}/${reservation.launchId}.`);
+                throw new RuntimeLaunchError(true, reservation.runtimeGenerationId, `Runtime is temporarily ${inspection.state}: ${request.owner.roleName}/${reservation.runtimeGenerationId}.`);
             }
             if (inspection.state === "stopped") {
                 const taskOwner = request.owner.scope === "task"
@@ -127,10 +127,10 @@ export class RuntimeLaunchCoordinator {
                 let exactCleanupAttempted = false;
                 let completed = false;
                 try {
-                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, reservation.launchId, taskOwner !== undefined && this.#runtimeIsolation !== undefined
+                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, reservation.runtimeGenerationId, taskOwner !== undefined && this.#runtimeIsolation !== undefined
                         ? () => {
                             exactCleanupAttempted = true;
-                            this.#cleanupTaskLaunch(taskOwner, reservation.launchId);
+                            this.#cleanupTaskLaunch(taskOwner, reservation.runtimeGenerationId);
                         }
                         : undefined);
                 }
@@ -146,7 +146,7 @@ export class RuntimeLaunchCoordinator {
                 }
                 reservation = this.reservations.reserveRuntimeLaunch({
                     owner: request.owner,
-                    launchId: proposedLaunchId
+                    runtimeGenerationId: proposedRuntimeGenerationId
                 }, assertLaunchCurrent, this.#now());
                 if (reservation.status !== "reserved") {
                     throw new Error("Runtime launch reservation could not be renewed.");
@@ -158,13 +158,13 @@ export class RuntimeLaunchCoordinator {
                 assertLaunchCurrent();
             }
         }
-        const launchId = reservation.launchId;
+        const runtimeGenerationId = reservation.runtimeGenerationId;
         let preflightObserved = beforeHostStart === undefined;
         const observePreflight = (preflight) => {
             if (preflightObserved) {
                 throw new Error("Runtime host reported its pre-start launch fence more than once.");
             }
-            validateRuntimeLaunchPreflight(preflight, request, launchId);
+            validateRuntimeLaunchPreflight(preflight, request, runtimeGenerationId);
             preflightObserved = true;
             beforeHostStart?.(preflight);
         };
@@ -179,7 +179,7 @@ export class RuntimeLaunchCoordinator {
             const rawBinding = request.mode === "new"
                 ? await this.host.start({
                     mode: "new",
-                    launchId,
+                    runtimeGenerationId,
                     owner: request.owner,
                     agentId: request.agentId,
                     adapterId: request.adapterId,
@@ -195,7 +195,7 @@ export class RuntimeLaunchCoordinator {
                 }, beforeHostStart === undefined ? undefined : observePreflight)
                 : await this.host.restore({
                     mode: "resume",
-                    launchId,
+                    runtimeGenerationId,
                     owner: request.owner,
                     agentId: request.agentId,
                     adapterId: request.adapterId,
@@ -210,24 +210,28 @@ export class RuntimeLaunchCoordinator {
                         : { environment: request.environment }),
                     nativeSessionId: requireText(request.nativeSessionId, "Native session id")
                 }, beforeHostStart === undefined ? undefined : observePreflight);
-            binding = requireMatchingRuntimeBinding(rawBinding, request, launchId);
+            binding = requireMatchingRuntimeBinding(rawBinding, request, runtimeGenerationId);
             if (!preflightObserved) {
                 throw new Error("Runtime session host did not expose a pre-host-start launch fence.");
             }
         }
         catch (error) {
+            if (error instanceof RuntimeGenerationMismatchError) {
+                await this.#settleFailedStart(request, runtimeGenerationId, reusedConfirmedRunningHost, runtimeIsolation, true);
+                throw new RuntimeLaunchError(false, runtimeGenerationId, error.message, "generation-mismatch");
+            }
             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, launchId, error.message, error.reason);
+                throw new RuntimeLaunchError(true, runtimeGenerationId, error.message, error.reason);
             }
             if (error instanceof RuntimeHostContentionError
                 && !reusedConfirmedRunningHost) {
                 let exactCleanupAttempted = false;
                 let completed = false;
                 try {
-                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, launchId, runtimeIsolation === undefined
+                    completed = this.reservations.completeRuntimeLaunchReservation(request.owner, runtimeGenerationId, runtimeIsolation === undefined
                         ? undefined
                         : () => {
                             exactCleanupAttempted = true;
@@ -243,7 +247,7 @@ export class RuntimeLaunchCoordinator {
                     this.#requireCleanup(request.owner);
                     throw new Error("Busy managed runtime launch reservation changed during retry release.");
                 }
-                throw new RuntimeLaunchError(true, launchId, error.message, error instanceof RuntimeHostContentionError
+                throw new RuntimeLaunchError(true, runtimeGenerationId, error.message, error instanceof RuntimeHostContentionError
                     ? error.reason
                     : "previous-process");
             }
@@ -253,40 +257,40 @@ export class RuntimeLaunchCoordinator {
                 this.#requireCleanup(request.owner);
                 throw error;
             }
-            await this.#settleFailedStart(request, launchId, reusedConfirmedRunningHost, runtimeIsolation);
+            await this.#settleFailedStart(request, runtimeGenerationId, reusedConfirmedRunningHost, runtimeIsolation);
             throw error;
         }
         if (reusedConfirmedRunningHost && binding.hostCreated === true) {
-            await this.#compensateStartedHost(request.owner, binding, launchId, runtimeIsolation, new Error(`Runtime host was recreated while recovering an existing generation: ${request.owner.roleName}.`));
+            await this.#compensateStartedHost(request.owner, binding, runtimeGenerationId, runtimeIsolation, new Error(`Runtime host was recreated while recovering an existing generation: ${request.owner.roleName}.`));
         }
         try {
             assertLaunchCurrent();
             const reservationState = this.reservations.confirmRuntimeLaunchReservation({
                 owner: request.owner,
-                launchId
+                runtimeGenerationId
             }, assertLaunchCurrent);
             if (reservationState === "reserved") {
                 if (binding.nativeSessionId !== undefined) {
                     this.reservations.recordReservedRuntimeNativeSession({
                         owner: request.owner,
-                        launchId,
+                        runtimeGenerationId,
                         agentId: request.agentId,
                         adapterId: request.adapterId,
                         nativeSessionId: binding.nativeSessionId,
                         effective: request.effective
                     }, assertLaunchCurrent, this.#now());
                 }
-                else if (!this.reservations.completeRuntimeLaunchReservation(request.owner, launchId)) {
+                else if (!this.reservations.completeRuntimeLaunchReservation(request.owner, runtimeGenerationId)) {
                     throw new Error("Runtime Host-start reservation changed before completion.");
                 }
             }
         }
         catch (error) {
-            await this.#compensateStartedHost(request.owner, binding, launchId, runtimeIsolation, error);
+            await this.#compensateStartedHost(request.owner, binding, runtimeGenerationId, runtimeIsolation, error);
         }
         return binding;
     }
-    async #settleFailedStart(request, launchId, reusedConfirmedRunningHost, runtimeIsolation) {
+    async #settleFailedStart(request, runtimeGenerationId, reusedConfirmedRunningHost, runtimeIsolation, forceCleanup = false) {
         let inspection;
         try {
             inspection = await this.host.inspectOwner(request.owner);
@@ -294,7 +298,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)
+            if (!reusedConfirmedRunningHost || forceCleanup)
                 this.#requireCleanup(request.owner);
             return;
         }
@@ -308,16 +312,16 @@ export class RuntimeLaunchCoordinator {
                     throw new Error(`Task runtime launch failed and exact resource cleanup also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`, { cause: cleanupError });
                 }
             }
-            if (!this.#settleConfirmedStopped(request, launchId)) {
+            if (!this.#settleConfirmedStopped(request, runtimeGenerationId)) {
                 this.#requireCleanup(request.owner);
             }
             return;
         }
-        if (reusedConfirmedRunningHost)
+        if (reusedConfirmedRunningHost && !forceCleanup)
             return;
         this.#requireCleanup(request.owner);
     }
-    async #compensateStartedHost(owner, binding, launchId, runtimeIsolation, cause) {
+    async #compensateStartedHost(owner, binding, runtimeGenerationId, runtimeIsolation, cause) {
         try {
             await this.host.stop(binding);
         }
@@ -344,7 +348,7 @@ export class RuntimeLaunchCoordinator {
         if (!stopped
             || !this.reservations.settleStoppedRuntimeLaunch({
                 owner,
-                launchId,
+                runtimeGenerationId,
                 agentId: binding.agentId,
                 adapterId: binding.adapterId,
                 ...(binding.nativeSessionId === undefined
@@ -356,33 +360,33 @@ export class RuntimeLaunchCoordinator {
         const detail = cause instanceof Error ? cause.message : String(cause);
         throw new RuntimeLaunchStateChangedError(`Runtime launch was compensated after state changed: ${detail}`, { cause });
     }
-    #preflightRuntimeIsolation(request, launchId, generationId, allowExactActive) {
+    #preflightRuntimeIsolation(request, runtimeGenerationId, generationId, allowExactActive) {
         if (this.#runtimeIsolation === undefined || request.owner.scope !== "task") {
             return undefined;
         }
         return this.#runtimeIsolation.preflight({
             workspace: request.managedWorkspace,
-            launchId,
+            runtimeGenerationId,
             generationId: requireText(generationId, "Launch generation id"),
             ...(request.runtimePolicy === undefined ? {} : { policy: request.runtimePolicy }),
             ...(allowExactActive ? { allowExactActive: true } : {})
         });
     }
-    #cleanupTaskLaunch(owner, launchId) {
+    #cleanupTaskLaunch(owner, runtimeGenerationId) {
         const cleanupTaskLaunch = this.#runtimeIsolation?.cleanupTaskLaunch;
         if (cleanupTaskLaunch === undefined) {
             throw new Error("Exact Task runtime launch cleanup is unavailable.");
         }
         cleanupTaskLaunch.call(this.#runtimeIsolation, {
             taskId: owner.taskId,
-            launchId,
+            runtimeGenerationId,
             reason: "interruption"
         });
     }
-    #settleConfirmedStopped(request, launchId) {
+    #settleConfirmedStopped(request, runtimeGenerationId) {
         return this.reservations.settleStoppedRuntimeLaunch({
             owner: request.owner,
-            launchId,
+            runtimeGenerationId,
             agentId: request.agentId,
             adapterId: request.adapterId,
             ...(request.nativeSessionId === undefined
@@ -401,13 +405,13 @@ export class RuntimeLaunchCoordinator {
         }
     }
 }
-function validateRuntimeLaunchPreflight(preflight, request, launchId) {
+function validateRuntimeLaunchPreflight(preflight, request, runtimeGenerationId) {
     const ownerMatches = preflight.owner.scope === request.owner.scope
         && preflight.owner.roleName === request.owner.roleName
         && (preflight.owner.scope === "global"
             || (request.owner.scope === "task"
                 && preflight.owner.taskId === request.owner.taskId));
-    if (preflight.launchId !== launchId
+    if (preflight.runtimeGenerationId !== runtimeGenerationId
         || !ownerMatches
         || preflight.turnId !== request.turnId
         || preflight.agentId !== request.agentId
@@ -418,7 +422,7 @@ function validateRuntimeLaunchPreflight(preflight, request, launchId) {
         throw new Error(`Session host pre-start launch fence does not match the requested runtime: ${request.owner.roleName}.`);
     }
 }
-function requireMatchingRuntimeBinding(raw, request, launchId) {
+function requireMatchingRuntimeBinding(raw, request, runtimeGenerationId) {
     let binding;
     try {
         binding = createRuntimeBinding(raw);
@@ -431,7 +435,7 @@ function requireMatchingRuntimeBinding(raw, request, launchId) {
         && (binding.owner.scope === "global"
             || (request.owner.scope === "task"
                 && binding.owner.taskId === request.owner.taskId));
-    if (binding.launchId !== launchId
+    if (binding.runtimeGenerationId !== runtimeGenerationId
         || !ownerMatches
         || binding.agentId !== request.agentId
         || binding.adapterId !== request.adapterId

package/dist/controller/runtimeObservationHook.js

@@ -4,6 +4,7 @@ import { normalizeAgentDriverHookClassification } from "../runtime/agentDriver.j
 import { mapAgentDriverHooks } from "../runtime/agentDriverObservation.js";
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { formatTurnReceiptId } from "../task/taskRecordReference.js";
+import { boundedTurnFailureDiagnostic, transportAgentResult } from "../domain/agentResultTransport.js";
 import { FileRuntimeEventInbox, MAX_RUNTIME_EVENT_FILE_BYTES } from "./runtimeEventInbox.js";
 import { resolveRuntimeHookTurnFence } from "./runtimeHookTurnFence.js";
 /**
@@ -48,28 +49,34 @@ async function runGlobalRuntimeTurnHook(stdinJson, environment, call, now, depen
     }
     const home = requireIdentity(environment.YUI_HOME, "YUI_HOME");
     const roleName = requireIdentity(environment.YUI_ROLE, "Role name");
-    new FileRuntimeEventInbox(home, () => now).enqueueTurnCompleted({
+    new FileRuntimeEventInbox(home, () => now).enqueueTurnTerminal({
         scope: "global",
         roleName,
         agentId: requireIdentity(environment.YUI_AGENT_ID, "Agent id"),
         adapterId: "claude",
-        launchId: requireIdentity(environment.YUI_LAUNCH_ID, "Launch id"),
+        runtimeGenerationId: requireIdentity(environment.YUI_RUNTIME_GENERATION_ID, "Runtime generation id"),
         nativeSessionId,
         nativeTurnId: optionalIdentity(driver.runtime.nativeTurnId(nativeHook)) ?? occurrenceId,
         ...(environment.YUI_SESSION_TITLE === undefined
             ? {}
             : { title: requireIdentity(environment.YUI_SESSION_TITLE, "Session title") }),
-        summary: globalHookSummary(payload, hookEventName)
+        providerStatus: hookEventName === "Stop" ? "completed" : "failed",
+        outcome: globalHookOutcome(payload, hookEventName)
     });
     await call(home, "scheduler.signal", { key: runtimeLifecycleSignalKey({ scope: "global", roleName }) }, { timeoutMs: 100 }).catch(() => { });
 }
-function globalHookSummary(payload, hookEventName) {
-    for (const field of ["last_assistant_message", "summary", "message", "error"]) {
-        const value = payload[field];
-        if (typeof value === "string" && value.trim().length > 0)
-            return value.trim();
+function globalHookOutcome(payload, hookEventName) {
+    if (hookEventName === "Stop") {
+        return transportAgentResult(payload.last_assistant_message);
     }
-    return hookEventName === "Stop" ? "Native Turn completed." : "Native Turn failed.";
+    const diagnostic = [payload.error, payload.error_details]
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .join("\n");
+    return {
+        status: "failed",
+        failureReason: "runtime-failed",
+        diagnostic: boundedTurnFailureDiagnostic(diagnostic)
+    };
 }
 export function parseRuntimeObservationHook(stdinJson, environment, now = new Date(), dependencies = {}) {
     const payload = parseObject(stdinJson);
@@ -113,10 +120,9 @@ export function parseRuntimeObservationHook(stdinJson, environment, now = new Da
             turnId: fence.turnId,
             agentId: fence.agentId,
             driverId,
-            launchId: fence.launchId,
-            sessionGenerationId: fence.launchId,
+            runtimeGenerationId: fence.runtimeGenerationId,
             conversationId: fence.nativeSessionId,
-            activationId: fence.launchId,
+            activationId: fence.runtimeGenerationId,
             nativeSessionId: fence.nativeSessionId,
             nativeTurnId: nativeTurnId ?? fence.turnId,
             receiptId: fence.receiptId ?? formatTurnReceiptId(fence.taskId, fence.turnId)

package/dist/controller/sessionNotify.js

@@ -1,25 +1,30 @@
 import { callController } from "../core/controllerClient.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
+import { transportAgentResult } from "../domain/agentResultTransport.js";
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { setCodexThreadName } from "../execution/codexThreadNaming.js";
 import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
-const NO_FINAL_ASSISTANT_MESSAGE_SUMMARY = "Native Turn completed without a final assistant message.";
 /** Hidden CLI entrypoint used by Codex's structured notify hook. */
 export async function runSessionNotifyCommand(payloadArgument, environment = process.env, call, setThreadName = setCodexThreadName) {
     const params = parseCodexSessionNotification(payloadArgument, environment);
     const home = requireText(environment.YUI_HOME, "YUI_HOME");
-    const enqueued = new FileRuntimeEventInbox(home).enqueueTurnCompleted({
+    // A Codex process outlives its Turn, so the notify envelope cannot say which
+    // Turn or runtime generation is current. Durable Session state answers both;
+    // the envelope's runtime generation id is used only before a Session has been projected.
+    const current = currentNotifyGeneration(home, params);
+    const enqueued = new FileRuntimeEventInbox(home).enqueueTurnTerminal({
         scope: params.scope,
         ...(params.scope === "task" ? { taskId: params.taskId } : {}),
         roleName: params.roleName,
         agentId: params.agentId,
         adapterId: params.adapterId,
-        launchId: params.launchId,
+        ...(current.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: current.runtimeGenerationId }),
         nativeSessionId: params.nativeSessionId,
         nativeTurnId: params.nativeTurnId,
-        ...(params.turnId === undefined ? {} : { turnId: params.turnId }),
+        ...(current.turnId === undefined ? {} : { turnId: current.turnId }),
         ...(params.title === undefined ? {} : { title: params.title }),
-        summary: params.lastAssistantMessage
+        providerStatus: "completed",
+        outcome: params.outcome
     });
     // The durable write is authoritative. This short socket call is only a
     // wake-up hint and never starts or waits for a Controller process.
@@ -35,12 +40,36 @@ export async function runSessionNotifyCommand(payloadArgument, environment = pro
                 roleName: params.roleName
             })
     }, { timeoutMs: 100 }).catch(() => { });
-    if (enqueued.created && shouldSetThreadName(home, params)) {
+    if (enqueued.created && shouldSetThreadName(home, params, current.turnId)) {
         const request = threadNameRequest(params, environment);
         if (request !== null)
             await setThreadName(request).catch(() => { });
     }
 }
+/**
+ * Reads the durable runtime generation and active Turn for the notifying
+ * Session. The envelope's runtime generation id only applies before Yui has projected a
+ * Session for this Role, which is the one moment durable state cannot answer.
+ */
+function currentNotifyGeneration(home, params) {
+    if (params.scope !== "task" || params.taskId === undefined) {
+        return params.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: params.runtimeGenerationId };
+    }
+    try {
+        const store = openCurrentTaskStore(home);
+        const session = store.getTaskRoleSessionSet(params.taskId, params.roleName)
+            ?.sessions[params.agentId];
+        const activeTurn = store.getActiveTurn(params.taskId, params.roleName);
+        const runtimeGenerationId = session?.runtimeGenerationId ?? params.runtimeGenerationId;
+        return {
+            ...(runtimeGenerationId === undefined ? {} : { runtimeGenerationId }),
+            ...(activeTurn === null ? {} : { turnId: activeTurn.id })
+        };
+    }
+    catch {
+        return params.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: params.runtimeGenerationId };
+    }
+}
 export function parseCodexSessionNotification(payloadArgument, environment) {
     const payload = parseObject(payloadArgument, "Codex notify payload");
     if (payload.type !== "agent-turn-complete") {
@@ -48,10 +77,7 @@ export function parseCodexSessionNotification(payloadArgument, environment) {
     }
     const nativeSessionId = requireText(payload["thread-id"], "Codex thread-id");
     const nativeTurnId = requireText(payload["turn-id"], "Codex turn-id");
-    const lastAssistantMessage = requireAssistantMessage(payload["last-assistant-message"]);
-    const turnId = environment.YUI_TURN_ID === undefined
-        ? undefined
-        : requireText(environment.YUI_TURN_ID, "YUI_TURN_ID");
+    const outcome = transportAgentResult(payload["last-assistant-message"]);
     const title = environment.YUI_SESSION_TITLE === undefined
         ? undefined
         : requireText(environment.YUI_SESSION_TITLE, "YUI_SESSION_TITLE");
@@ -64,12 +90,13 @@ export function parseCodexSessionNotification(payloadArgument, environment) {
         roleName: requireText(environment.YUI_ROLE, "YUI_ROLE"),
         agentId: requireText(environment.YUI_AGENT_ID, "YUI_AGENT_ID"),
         adapterId: requireCodexAdapter(environment.YUI_ADAPTER_ID),
-        launchId: requireText(environment.YUI_LAUNCH_ID, "YUI_LAUNCH_ID"),
+        ...(environment.YUI_RUNTIME_GENERATION_ID === undefined
+            ? {}
+            : { runtimeGenerationId: requireText(environment.YUI_RUNTIME_GENERATION_ID, "YUI_RUNTIME_GENERATION_ID") }),
         nativeSessionId,
         nativeTurnId,
-        ...(turnId === undefined ? {} : { turnId }),
         ...(title === undefined ? {} : { title }),
-        lastAssistantMessage
+        outcome
     };
     return scope === "task"
         ? {
@@ -106,26 +133,14 @@ function requireText(value, label) {
         throw new Error(`${label} is invalid.`);
     return text;
 }
-function requireAssistantMessage(value) {
-    if (value === null)
-        return NO_FINAL_ASSISTANT_MESSAGE_SUMMARY;
-    if (typeof value !== "string" || value.includes("\0")) {
-        throw new Error("Codex last assistant message is required.");
-    }
-    const text = value.trim();
-    if (text.length === 0 || Buffer.byteLength(text) > 524_288) {
-        throw new Error("Codex last assistant message is invalid.");
-    }
-    return text;
-}
-function shouldSetThreadName(home, params) {
+function shouldSetThreadName(home, params, turnId) {
     if (params.scope !== "task"
         || params.title === undefined
-        || params.turnId === undefined)
+        || turnId === undefined)
         return false;
     try {
         const store = openCurrentTaskStore(home);
-        return store.getTurn(params.taskId, params.turnId)?.mode === "new";
+        return store.getTurn(params.taskId, turnId)?.mode === "new";
     }
     catch {
         return false;

package/dist/controller/sessionOwnerReconciliation.js

@@ -26,11 +26,11 @@ export class SessionOwnerReconciliation {
     /**
      * Persists the exact physical owner identity after a host created a new
      * Provider process. The Provider root is attributed by the exact
-     * YUI_LAUNCH_ID environment fence; the tmux pane PID is only a weaker
+     * YUI_RUNTIME_GENERATION_ID environment fence; the tmux pane PID is only a weaker
      * fallback when the fence cannot be read.
      */
     recordHostOwner(input) {
-        const discovered = discoverProviderRootByLaunchEnv(input.launchId);
+        const discovered = discoverProviderRootByLaunchEnv(input.runtimeGenerationId);
         const fallback = discovered === undefined && input.panePid !== undefined
             ? readLinuxProcessIdentity(input.panePid)
             : undefined;
@@ -38,7 +38,7 @@ export class SessionOwnerReconciliation {
             ? undefined
             : { pid: fallback.pid, identity: fallback });
         if (root === undefined) {
-            this.#onWarning(`Session owner identity could not attribute a Provider root for launch ${input.launchId}; `
+            this.#onWarning(`Session owner identity could not attribute a Provider root for launch ${input.runtimeGenerationId}; `
                 + "no owner record was written.");
             return;
         }
@@ -52,7 +52,7 @@ export class SessionOwnerReconciliation {
             },
             agentId: input.agentId,
             adapterId: input.adapterId,
-            launchId: input.launchId,
+            runtimeGenerationId: input.runtimeGenerationId,
             ...(input.nativeSessionId === undefined
                 ? {}
                 : { nativeSessionId: input.nativeSessionId }),
@@ -98,7 +98,7 @@ export class SessionOwnerReconciliation {
                     return undefined;
                 }
             },
-            lastStopOutcome: (taskId, roleName, launchId) => (lastSessionTerminationOutcome(this.#store, taskId, roleName, launchId)),
+            lastStopOutcome: (taskId, roleName, runtimeGenerationId) => (lastSessionTerminationOutcome(this.#store, taskId, roleName, runtimeGenerationId)),
             now: new Date()
         });
     }
@@ -130,7 +130,7 @@ export class SessionOwnerReconciliation {
                     return false;
                 }
             },
-            listLaunchFencedProcesses: (launchId) => listLaunchFencedProcesses(launchId),
+            listLaunchFencedProcesses: (runtimeGenerationId) => listLaunchFencedProcesses(runtimeGenerationId),
             signalProcess: (pid, signal) => process.kill(pid, signal),
             signalProcessGroup: (processGroupId, signal) => {
                 try {
@@ -148,23 +148,23 @@ export class SessionOwnerReconciliation {
         const result = await terminateSessionOwners(owner, records, ports, options);
         if (result.outcome === "stop-confirmed") {
             for (const record of result.confirmed) {
-                this.#store.removeSessionOwner(record.launchId);
-                removeRuntimeStopReceipt(this.#home, record.launchId);
+                this.#store.removeSessionOwner(record.runtimeGenerationId);
+                removeRuntimeStopReceipt(this.#home, record.runtimeGenerationId);
             }
         }
         return result;
     }
     #recordTerminationEvent(event) {
         const owner = event.owner;
-        if (event.stage === "stop-requested" && event.launchId !== undefined) {
-            writeRuntimeStopReceipt(this.#home, event.launchId, event.at);
+        if (event.stage === "stop-requested" && event.runtimeGenerationId !== undefined) {
+            writeRuntimeStopReceipt(this.#home, event.runtimeGenerationId, event.at);
         }
         if (owner.scope !== "task")
             return;
         try {
             this.#store.saveEvent(owner.taskId, createTaskEvent(this.#store.nextEventId(owner.taskId), owner.taskId, "runtime.session-termination", {
                 roleName: owner.roleName,
-                launchId: event.launchId ?? "",
+                runtimeGenerationId: event.runtimeGenerationId ?? "",
                 nativeSessionId: event.nativeSessionId ?? "",
                 outcome: event.stage,
                 ...(event.detail === undefined ? {} : { detail: event.detail })
@@ -175,7 +175,7 @@ export class SessionOwnerReconciliation {
         }
     }
 }
-/** Projects every durable Role session generation for reconciliation. */
+/** Projects every durable Role runtime generation for reconciliation. */
 export function durableSessionFacts(store) {
     const facts = [];
     for (const task of store.listTasks()) {
@@ -187,7 +187,7 @@ export function durableSessionFacts(store) {
                     roleName: set.owner.roleName,
                     agentId,
                     adapterId: session.adapterId,
-                    ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+                    ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                     ...(session.nativeSessionId === undefined
                         ? {}
                         : { nativeSessionId: session.nativeSessionId }),
@@ -202,7 +202,7 @@ export function durableSessionFacts(store) {
                     roleName: set.owner.roleName,
                     agentId: history.agentId,
                     adapterId: history.adapterId,
-                    ...(history.launchId === undefined ? {} : { launchId: history.launchId }),
+                    ...(history.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: history.runtimeGenerationId }),
                     ...(history.nativeSessionId === undefined
                         ? {}
                         : { nativeSessionId: history.nativeSessionId }),
@@ -219,7 +219,7 @@ export function durableSessionFacts(store) {
                 roleName: set.owner.roleName,
                 agentId,
                 adapterId: session.adapterId,
-                ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
@@ -234,7 +234,7 @@ export function durableSessionFacts(store) {
                 roleName: set.owner.roleName,
                 agentId: session.agentId,
                 adapterId: session.adapterId,
-                ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
@@ -297,7 +297,7 @@ export function observeSessionOwnerPhysical(record) {
     };
 }
 /** Reads the latest termination outcome recorded for one generation. */
-export function lastSessionTerminationOutcome(store, taskId, roleName, launchId) {
+export function lastSessionTerminationOutcome(store, taskId, roleName, runtimeGenerationId) {
     if (taskId === undefined)
         return undefined;
     let latest;
@@ -306,10 +306,10 @@ export function lastSessionTerminationOutcome(store, taskId, roleName, launchId)
             continue;
         if (event.payload.roleName !== roleName)
             continue;
-        if (launchId !== ""
-            && event.payload.launchId !== undefined
-            && event.payload.launchId !== ""
-            && event.payload.launchId !== launchId) {
+        if (runtimeGenerationId !== ""
+            && event.payload.runtimeGenerationId !== undefined
+            && event.payload.runtimeGenerationId !== ""
+            && event.payload.runtimeGenerationId !== runtimeGenerationId) {
             continue;
         }
         latest = event.payload.outcome;