@zq-silk/yui 0.13.8 → 0.13.9

package/dist/executor/agentExecutor.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
-import { currentProviderActivation, endProviderActivation, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
+import { currentProviderActivation, endProviderActivation, settleProviderTurn, settleProviderTurnSubmission, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
     const base = {
@@ -11,10 +11,10 @@ export function createRoleSessionSet(owner, activeAgentId, now) {
         updatedAt: now.toISOString()
     };
     return owner.scope === "global"
-        ? { ...base, schemaVersion: 3 }
+        ? { ...base, schemaVersion: 4 }
         : {
             ...base,
-            schemaVersion: 7,
+            schemaVersion: 8,
             inFlight: null,
             providerBinding: null
         };
@@ -28,7 +28,7 @@ export function activeRoleAgentSession(set) {
 /** The immutable snapshot that remains actual until its native process terminates. */
 export function activeLiveRoleAgentSession(set) {
     const session = activeRoleAgentSession(set);
-    return session === null || session.status === "stopped" || session.status === "broken"
+    return session === null || session.status === "ended"
         ? null
         : session;
 }
@@ -73,13 +73,13 @@ export function recordRoleAgentSession(set, input, now) {
         throw new Error(`Role Agent session effective launch cannot change: ${agentId}.`);
     }
     if (existing !== undefined && existing.nativeSessionId !== nativeSessionId
-        && existing.status !== "stopped" && existing.status !== "broken") {
+        && existing.status === "active") {
         throw new Error(`Live Role Agent native session cannot be replaced: ${agentId}.`);
     }
     const timestamp = now.toISOString();
     const continuing = existing?.nativeSessionId === nativeSessionId ? existing : undefined;
     const session = {
-        schemaVersion: 3,
+        schemaVersion: 4,
         agentId,
         adapterId,
         nativeSessionId,
@@ -91,6 +91,9 @@ export function recordRoleAgentSession(set, input, now) {
         policy: input.policy,
         effective: continuing?.effective ?? effective,
         status: input.status,
+        ...(input.status === "ended"
+            ? { endReason: input.endReason ?? continuing?.endReason ?? "stopped" }
+            : {}),
         recentCompletedTurnIds: continuing?.recentCompletedTurnIds ?? [],
         createdAt: continuing?.createdAt ?? timestamp,
         updatedAt: timestamp
@@ -127,7 +130,7 @@ export function replaceTaskRoleAgentSession(set, input, now) {
     if (existing === undefined || existing.nativeSessionId === input.nativeSessionId) {
         return recordRoleAgentSession(set, input, now);
     }
-    const terminalized = updateRoleAgentSessionStatus(set, input.agentId, "stopped", now);
+    const terminalized = updateRoleAgentSessionStatus(set, input.agentId, "ended", now, "stopped");
     return recordRoleAgentSession(terminalized, input, now);
 }
 /**
@@ -147,7 +150,7 @@ export function createRoleAgentSession(input, now) {
     const set = createRoleSessionSet({ scope: "global", roleName: "session-factory" }, agentId, now);
     return recordRoleAgentSession(set, input, now).sessions[agentId];
 }
-export function updateRoleAgentSessionStatus(set, agentId, status, now) {
+export function updateRoleAgentSessionStatus(set, agentId, status, now, endReason) {
     validateRoleSessionSet(set);
     const normalizedAgentId = requireSafeIdentity(agentId, "Agent id");
     if (!isAgentSessionStatus(status)) {
@@ -162,7 +165,12 @@ export function updateRoleAgentSessionStatus(set, agentId, status, now) {
         ...set,
         sessions: {
             ...set.sessions,
-            [normalizedAgentId]: { ...existing, status, updatedAt: timestamp }
+            [normalizedAgentId]: {
+                ...existing,
+                status,
+                ...(status === "ended" ? { endReason: endReason ?? "stopped" } : { endReason: undefined }),
+                updatedAt: timestamp
+            }
         },
         updatedAt: timestamp
     };
@@ -174,7 +182,7 @@ export function retireTaskRoleSessionsForWorkspace(set, now) {
     if (set.inFlight !== null) {
         throw new Error("Cannot retire a Task Role session with unsettled Run state.");
     }
-    const live = Object.values(set.sessions).find(({ status }) => status !== "stopped" && status !== "broken");
+    const live = Object.values(set.sessions).find(({ status }) => status === "active");
     if (live !== undefined) {
         throw new Error(`Task Role session must be stopped before workspace migration: ${live.agentId}.`);
     }
@@ -205,13 +213,18 @@ export function retireConfirmedAbsentInactiveTaskRolePlaceholders(set, now) {
     const sessions = Object.fromEntries(Object.entries(set.sessions).map(([agentId, session]) => {
         const isNeverStartedInactiveClaude = agentId !== set.activeAgentId
             && session.adapterId === "claude"
-            && (session.status === "reserved" || session.status === "ready")
+            && session.status === "active"
             && session.launchId === undefined
             && session.recentCompletedTurnIds.length === 0;
         if (!isNeverStartedInactiveClaude)
             return [agentId, session];
         changed = true;
-        return [agentId, { ...session, status: "broken", updatedAt: timestamp }];
+        return [agentId, {
+                ...session,
+                status: "ended",
+                endReason: "failed",
+                updatedAt: timestamp
+            }];
     }));
     if (!changed)
         return set;
@@ -231,7 +244,7 @@ export function rememberRoleAgentCompletedTurn(set, agentId, nativeSessionId, tu
     if (session.nativeSessionId !== requireText(nativeSessionId, "Native session id")) {
         throw new Error("Completed Turn native session does not match the Role Agent session.");
     }
-    const normalizedTurnId = requireSafeIdentity(turnId, "Turn id");
+    const normalizedTurnId = requireText(turnId, "Turn id");
     if (hasRecentTurnId(session.recentCompletedTurnIds, normalizedTurnId))
         return set;
     const recentCompletedTurnIds = rememberRecentTurnId(session.recentCompletedTurnIds, normalizedTurnId);
@@ -244,9 +257,6 @@ export function rememberRoleAgentCompletedTurn(set, agentId, nativeSessionId, tu
             ...set.sessions,
             [normalizedAgentId]: {
                 ...session,
-                status: session.status === "stopped" || session.status === "broken"
-                    ? session.status
-                    : "ready",
                 recentCompletedTurnIds,
                 updatedAt: timestamp
             }
@@ -268,13 +278,13 @@ export function roleAgentSessionResumeMode(set, agentId, desired) {
     // permits the normal fresh-generation path.
     if (typeof session.nativeSessionId !== "string"
         || session.nativeSessionId.trim().length === 0) {
-        if (session.status !== "stopped" && session.status !== "broken") {
+        if (session.status === "active") {
             throw new Error(`Role Agent session has no native Session identity: ${agentId}. `
                 + "Restore the exact native Session or explicitly stop it before starting a fresh Session.");
         }
         return "new";
     }
-    if (session.status === "stopped" || session.status === "broken") {
+    if (session.status === "ended") {
         return "new";
     }
     const compatible = set.owner.scope === "task"
@@ -314,28 +324,6 @@ export function bindTaskRoleRun(set, fence, preparedAt, mode) {
     };
     return validateRoleSessionSet(updated);
 }
-/** Re-fences the same active Run for an exact Provider retry without losing its Conversation. */
-export function prepareTaskRoleRunRedispatch(set, fence, preparedAt) {
-    validateRoleSessionSet(set);
-    const normalized = normalizeTaskRoleRunFence(fence);
-    if (set.inFlight === null
-        || set.inFlight.agentId !== normalized.agentId
-        || set.inFlight.runId !== normalized.runId) {
-        throw new Error("Provider retry does not match the in-flight Task Run.");
-    }
-    if (set.providerBinding !== null
-        && set.providerBinding.turn !== null
-        && ["submitting", "accepted", "running", "delivery-unknown"]
-            .includes(set.providerBinding.turn.status)) {
-        throw new Error("Provider retry cannot redispatch an unsettled Turn.");
-    }
-    const timestamp = requireDate(preparedAt, "Task Role retry preparedAt");
-    return validateRoleSessionSet({
-        ...set,
-        inFlight: { ...normalized, preparedAt: timestamp },
-        updatedAt: timestamp
-    });
-}
 export function bindTaskRoleProviderRuntime(set, binding, updatedAt) {
     validateRoleSessionSet(set);
     const normalized = validateProviderRuntimeBinding(binding);
@@ -365,33 +353,65 @@ export function updateTaskRoleProviderRuntime(set, binding, updatedAt) {
     });
 }
 /**
- * Records an exact local Host exit without forgetting the Provider
- * Conversation. The ended Activation releases writer authority, while the
- * current Conversation and any unsettled Turn remain durable recovery fences.
+ * Detaches a confirmed-dead local Host without ending its resumable native
+ * Session. The Host launch and Provider Activation are disposable execution
+ * facts; the native Session remains the durable continuation identity.
  */
-export function stopTaskRoleRuntimeAfterPhysicalExit(set, now) {
+export function detachRoleAgentSessionHost(set, now) {
     validateRoleSessionSet(set);
     const active = set.sessions[set.activeAgentId];
-    if (active === undefined)
-        return set;
-    const activation = set.providerBinding === null
-        ? null
-        : currentProviderActivation(set.providerBinding);
-    if (active.status === "stopped") {
-        if (activation !== null) {
-            throw new Error("Stopped Task Role Session cannot retain a live Provider Activation.");
-        }
+    if (active === undefined || active.status === "ended")
         return set;
+    const timestamp = requireDate(now, "Role Host detach timestamp");
+    const { launchId: _launchId, endReason: _endReason, ...session } = active;
+    let updated = validateRoleSessionSet({
+        ...set,
+        sessions: {
+            ...set.sessions,
+            [set.activeAgentId]: {
+                ...session,
+                status: "active",
+                updatedAt: timestamp
+            }
+        },
+        updatedAt: timestamp
+    });
+    if (updated.owner.scope !== "task")
+        return updated;
+    let taskSet = updated;
+    let binding = taskSet.providerBinding;
+    const turn = binding?.turn;
+    if (binding !== null && binding !== undefined && turn !== null && turn !== undefined
+        && ["accepted", "running"].includes(turn.status)) {
+        binding = settleProviderTurn(binding, {
+            turnId: turn.turnId,
+            status: "cancelled",
+            settledAt: timestamp,
+            reason: "runtime-physical-exit"
+        });
+        taskSet = updateTaskRoleProviderRuntime(taskSet, binding, now);
+    }
+    else if (binding !== null && binding !== undefined && turn !== null && turn !== undefined
+        && ["submitting", "delivery-unknown"].includes(turn.status)) {
+        binding = settleProviderTurnSubmission(binding, {
+            attemptId: turn.attemptId,
+            status: "rejected",
+            resolvedAt: timestamp,
+            reason: "runtime-physical-exit"
+        });
+        taskSet = updateTaskRoleProviderRuntime(taskSet, binding, now);
     }
-    let updated = updateRoleAgentSessionStatus(set, set.activeAgentId, "stopped", now);
+    const activation = binding === null
+        ? null
+        : currentProviderActivation(binding);
     if (activation !== null) {
-        updated = updateTaskRoleProviderRuntime(updated, endProviderActivation(updated.providerBinding, activation.activationId, {
+        taskSet = updateTaskRoleProviderRuntime(taskSet, endProviderActivation(binding, activation.activationId, {
             status: "ended",
             endedAt: now.toISOString(),
             reason: "runtime-physical-exit"
         }), now);
     }
-    return updated;
+    return taskSet;
 }
 export function markTaskRoleRunPushed(set, fence, pushedAt) {
     validateRoleSessionSet(set);
@@ -445,7 +465,7 @@ export function recordTaskRoleTurnBoundary(set, input, completedAt) {
     assertTaskRoleSessionSet(set);
     const agentId = requireSafeIdentity(input.agentId, "Agent id");
     const nativeSessionId = requireText(input.nativeSessionId, "Native session id");
-    const turnId = requireSafeIdentity(input.turnId, "Turn id");
+    const turnId = requireText(input.turnId, "Turn id");
     const session = set.sessions[agentId];
     if (session === undefined || session.nativeSessionId !== nativeSessionId) {
         throw new Error("Completed Turn has no matching Role Agent native session.");
@@ -456,16 +476,12 @@ export function recordTaskRoleTurnBoundary(set, input, completedAt) {
         throw new Error("Completed Turn Agent does not match the in-flight Run.");
     }
     const timestamp = requireDate(completedAt, "Turn completedAt");
-    const status = session.status === "stopped" || session.status === "broken"
-        ? session.status
-        : "ready";
     return validateRoleSessionSet({
         ...set,
         sessions: {
             ...set.sessions,
             [agentId]: {
                 ...session,
-                status,
                 recentCompletedTurnIds: rememberRecentTurnId(session.recentCompletedTurnIds, turnId),
                 updatedAt: timestamp
             }
@@ -535,7 +551,7 @@ export function settleTaskRoleCompletion(set, expected, settledAt) {
     assertTaskRoleSessionSet(set);
     const agentId = requireSafeIdentity(expected.agentId, "Agent id");
     const runId = requireSafeIdentity(expected.runId, "Run id");
-    const turnId = requireSafeIdentity(expected.turnId, "Turn id");
+    const turnId = requireText(expected.turnId, "Turn id");
     const inFlight = set.inFlight;
     if (inFlight === null || inFlight.agentId !== agentId || inFlight.runId !== runId) {
         throw new Error("Pending Turn completion does not match the in-flight Run.");
@@ -567,7 +583,7 @@ export function validateRoleSessionSet(set) {
         validateRoleAgentSession(session, agentId);
     }
     if (set.owner.scope === "global") {
-        if (set.schemaVersion !== 3) {
+        if (set.schemaVersion !== 4) {
             throw new Error("Global Role session set schema version is invalid.");
         }
         if (Object.hasOwn(set, "inFlight")
@@ -579,14 +595,14 @@ export function validateRoleSessionSet(set) {
             for (const [ref, session] of Object.entries(history)) {
                 requireSafeIdentity(ref, "Operator session ref");
                 validateRoleAgentSession(session);
-                if (session.status !== "stopped" && session.status !== "broken") {
+                if (session.status !== "ended") {
                     throw new Error(`Operator history session must be stopped: ${ref}.`);
                 }
             }
         }
     }
     else {
-        if (set.schemaVersion !== 7) {
+        if (set.schemaVersion !== 8) {
             throw new Error("Task Role session set schema version is invalid.");
         }
         if (!Object.hasOwn(set, "inFlight")
@@ -601,7 +617,7 @@ export function validateRoleSessionSet(set) {
             const identities = new Set();
             for (const session of taskSet.history) {
                 validateRoleAgentSession(session);
-                if (session.status !== "stopped" && session.status !== "broken") {
+                if (session.status !== "ended") {
                     throw new Error("Task Role session history must be terminal.");
                 }
                 const key = taskRoleSessionIdentity(session);
@@ -639,7 +655,7 @@ export function validateRoleSessionSet(set) {
     return set;
 }
 export function validateRoleAgentSession(session, expectedAgentId = session.agentId) {
-    if (session.schemaVersion !== 3) {
+    if (session.schemaVersion !== 4) {
         throw new Error(`Role Agent session schema version is invalid: ${expectedAgentId}.`);
     }
     const agentId = requireSafeIdentity(session.agentId, "Agent id");
@@ -677,6 +693,14 @@ export function validateRoleAgentSession(session, expectedAgentId = session.agen
     if (!isAgentSessionStatus(session.status)) {
         throw new Error(`Role Agent session status is invalid: ${agentId}.`);
     }
+    if (session.status === "active" && session.endReason !== undefined) {
+        throw new Error(`Active Role Agent session cannot have an end reason: ${agentId}.`);
+    }
+    if (session.status === "ended"
+        && session.endReason !== "stopped"
+        && session.endReason !== "failed") {
+        throw new Error(`Ended Role Agent session requires an end reason: ${agentId}.`);
+    }
     validateRecentTurnIds(session.recentCompletedTurnIds);
     requireText(session.createdAt, "Role Agent session creation timestamp");
     requireText(session.updatedAt, "Role Agent session update timestamp");
@@ -806,7 +830,7 @@ function normalizeOwner(owner) {
         };
 }
 function isAgentSessionStatus(value) {
-    return ["reserved", "ready", "running", "stopped", "broken"].includes(value);
+    return value === "active" || value === "ended";
 }
 function requireSafeIdentity(value, label) {
     const normalized = requireText(value, label);

package/dist/executor/executorRegistry.js

@@ -82,7 +82,10 @@ export class ExecutorRegistry {
                     : {
                         ...common,
                         mode: "resume",
-                        nativeSessionId: input.nativeSessionId
+                        nativeSessionId: input.nativeSessionId,
+                        ...(input.hostActivationId === undefined
+                            ? {}
+                            : { hostActivationId: input.hostActivationId })
                     }, "deferred", undefined, input.beforeHostStart);
             }
             else {
@@ -100,7 +103,7 @@ export class ExecutorRegistry {
                     });
                 binding = request.mode === "new"
                     ? await this.runtimePorts.sessionHost.start(request, input.beforeHostStart)
-                    : await this.runtimePorts.sessionHost.resume(request, input.beforeHostStart);
+                    : await this.runtimePorts.sessionHost.restore(request, input.beforeHostStart);
             }
             sessionStarted = binding.hostCreated === true;
             session = binding.nativeSessionId === undefined
@@ -109,7 +112,7 @@ export class ExecutorRegistry {
                     agentId: binding.agentId,
                     adapterId: binding.adapterId,
                     nativeSessionId: binding.nativeSessionId,
-                    status: "ready",
+                    status: "active",
                     effective: input.effective
                 };
         }
@@ -118,22 +121,6 @@ export class ExecutorRegistry {
             ...(binding === undefined ? {} : { launchId: binding.launchId }),
             sessionStarted,
             session,
-            ...(input.runId !== undefined
-                && ((binding?.initialTurnRunId === input.runId))
-                ? { turnAcceptedDuringLaunch: true }
-                : {}),
-            ...(input.runId !== undefined
-                && binding?.initialTurnDeliveryUnknownRunId === input.runId
-                ? { turnDeliveryUnknownDuringLaunch: true }
-                : {}),
-            ...(input.runId !== undefined
-                && binding?.initialTurnBusyRunId === input.runId
-                ? { turnBusyDuringLaunch: true }
-                : {}),
-            ...(input.runId !== undefined
-                && binding?.initialTurnRejectedRunId === input.runId
-                ? { turnRejectedDuringLaunch: true }
-                : {})
         };
         this.#prepared.set(delivery.deliveryId, {
             delivery,
@@ -362,7 +349,8 @@ function preparedDeliveryId(input) {
         input.effective,
         input.mode,
         input.runId ?? null,
-        input.nativeSessionId ?? null
+        input.nativeSessionId ?? null,
+        input.hostActivationId ?? null
     ])).digest("hex");
 }
 function hasText(value) {

package/dist/executor/fileRoleLaunchPlanner.js

@@ -10,11 +10,6 @@ import { activeRoleAgentBinding } from "../role/role.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
 import { materializeSessionBootstrap } from "../context/sessionBootstrapManifest.js";
-import { serializeRunBootstrapEnvelope, serializeRunHostRecoveryEnvelope } from "../context/runContextContract.js";
-import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
-import { serializeWorkflowOutcomeRequestEnvelope } from "../run/runControlRequest.js";
-import { prefixYuiTitleInput } from "../run/runIdentity.js";
-import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
 import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
@@ -302,7 +297,6 @@ export class FileRoleLaunchPlanner {
         if (runtimeIsolation !== undefined && (owner.scope !== "task"
             || runtimeIsolation.taskId !== owner.taskId
             || runtimeIsolation.workspace.root !== effectiveWorkspace
-            || runtimeIsolation.generation.runId !== input.runId
             || runtimeIsolation.generation.launchId !== input.launchId)) {
             throw new Error("Role launch does not match its Task runtime isolation descriptor.");
         }
@@ -478,41 +472,31 @@ export class FileRoleLaunchPlanner {
         if (owner.scope === "task" && (input.mode === "new" || input.mode === "resume")) {
             jobCallerKey = randomBytes(32).toString("hex");
         }
-        // Every managed launch for an unpushed Run owns that Run's first Provider
-        // write, whether it creates or resumes the native Conversation. Keeping
-        // resume on the same launch handshake prevents a durable AgentRun from
-        // existing without a corresponding Provider Turn.
+        // Session lifecycle and Turn submission are separate atomic operations.
+        // Planning only starts or restores the exact native Session; delivery
+        // submits the Run input after that Session fact is durable.
         if (managedControl && (managedRun === null || managedRun.status !== "active")) {
             throw new Error(`Managed Run is no longer active: ${input.runId}.`);
         }
-        const carriesInitialTurn = managedControl && (managedRun.pushedAt === undefined
-            || managedRun.providerRetry?.state === "dispatching"
-            || managedRun.controlRequest?.state === "dispatching");
         const providerAuthority = managedControl
             ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId, input.mode)
             : undefined;
-        const providerOwnedTurn = managedControl && !carriesInitialTurn
+        const providerOwnedTurn = managedControl && input.mode === "resume"
             ? this.#providerOwnedTurnForLaunch(owner.taskId, role.name, input.runId)
             : undefined;
         const providerNativeSessionId = binding.adapterId === "claude"
             ? preallocatedNativeSessionId
             : resumeNativeSessionId;
-        const initialTurn = carriesInitialTurn
-            ? {
-                attemptId: agentRunDeliveryReceiptId(managedRun),
-                boundedText: managedRunLaunchEnvelope(managedRun, input.mode, sessionContext.sessionManifestPath, sessionTitle)
-            }
-            : undefined;
         const providerControl = !managedControl
             ? undefined
-            : initialTurn === undefined
+            : input.mode === "resume"
                 ? {
                     schemaVersion: 1,
                     adapterId: binding.adapterId,
                     transport: managedCompiled.transport,
-                    kind: "ensure",
+                    kind: "restore",
                     mode: "resume",
-                    nativeSessionId: requireText(providerNativeSessionId, "Managed Provider ensure native session id"),
+                    nativeSessionId: requireText(providerNativeSessionId, "Managed Provider restore native session id"),
                     ...(sessionTitle === undefined ? {} : { sessionTitle }),
                     ...(managedCompiled.codexThread === undefined
                         ? {}
@@ -520,44 +504,24 @@ export class FileRoleLaunchPlanner {
                     ...(providerOwnedTurn === undefined ? {} : { ownedTurn: providerOwnedTurn }),
                     authority: providerAuthority
                 }
-                : resumeNativeSessionId === undefined
-                    ? {
-                        schemaVersion: 1,
-                        adapterId: binding.adapterId,
-                        transport: managedCompiled.transport,
-                        kind: "new",
-                        mode: "new",
-                        ...(providerNativeSessionId === undefined
-                            ? {}
-                            : { nativeSessionId: providerNativeSessionId }),
-                        ...(sessionTitle === undefined ? {} : { sessionTitle }),
-                        ...(managedCompiled.codexThread === undefined
-                            ? {}
-                            : { codexThread: managedCompiled.codexThread }),
-                        authority: providerAuthority,
-                        initialTurn
-                    }
-                    : {
-                        schemaVersion: 1,
-                        adapterId: binding.adapterId,
-                        transport: managedCompiled.transport,
-                        kind: "resume",
-                        mode: "resume",
-                        nativeSessionId: requireText(providerNativeSessionId, "Managed Provider resume native session id"),
-                        ...(sessionTitle === undefined ? {} : { sessionTitle }),
-                        ...(managedCompiled.codexThread === undefined
-                            ? {}
-                            : { codexThread: managedCompiled.codexThread }),
-                        authority: providerAuthority,
-                        initialTurn
-                    };
+                : {
+                    schemaVersion: 1,
+                    adapterId: binding.adapterId,
+                    transport: managedCompiled.transport,
+                    kind: "start",
+                    mode: "new",
+                    ...(providerNativeSessionId === undefined
+                        ? {}
+                        : { nativeSessionId: providerNativeSessionId }),
+                    ...(sessionTitle === undefined ? {} : { sessionTitle }),
+                    ...(managedCompiled.codexThread === undefined
+                        ? {}
+                        : { codexThread: managedCompiled.codexThread }),
+                    authority: providerAuthority
+                };
         const launch = {
             command,
             args,
-            ...(managedRun?.providerRetry !== undefined
-                && managedRun.providerRetry.state !== "dispatching"
-                ? { deferProviderStart: true }
-                : {}),
             ...(providerControl === undefined ? {} : { providerControl }),
             env: {
                 ...launchEnvironment,
@@ -612,10 +576,7 @@ export class FileRoleLaunchPlanner {
             },
             launch: ordinaryConversationLaunch,
             session,
-            ...(sessionTitle === undefined ? {} : { sessionTitle }),
-            ...(carriesInitialTurn && input.runId !== undefined
-                ? { initialTurnRunId: input.runId }
-                : {})
+            ...(sessionTitle === undefined ? {} : { sessionTitle })
         };
     }
     #providerAuthorityForLaunch(taskId, roleName, launchId, mode) {
@@ -705,33 +666,6 @@ export class FileRoleLaunchPlanner {
         return selectEnvironment(source, names);
     }
 }
-function managedRunLaunchEnvelope(run, mode, sessionManifestPath, title) {
-    const body = run.providerRetry?.state === "dispatching"
-        ? serializeProviderRetryEnvelope({
-            taskId: run.taskId,
-            runId: run.id,
-            roleName: run.roleName,
-            retry: run.providerRetry
-        })
-        : run.controlRequest?.state === "dispatching"
-            ? serializeWorkflowOutcomeRequestEnvelope({
-                taskId: run.taskId,
-                runId: run.id,
-                roleName: run.roleName,
-                request: run.controlRequest
-            })
-            : mode === "resume" && run.pushedAt !== undefined
-                ? serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope)
-                : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
-    const guided = [
-        `Yui Session Manifest: ${sessionManifestPath}`,
-        "Read the manifest and its matching Role Skill before using the yui CLI for this Task.",
-        body
-    ].join("\n");
-    return title === undefined
-        ? guided
-        : prefixYuiTitleInput(guided, title);
-}
 export function nativeAgentWorkspace(workspace) {
     return workspace.entries.length === 1
         ? workspace.entries[0].path
@@ -961,7 +895,7 @@ function readySession(agentId, adapterId, nativeSessionId, effective) {
         agentId,
         adapterId,
         nativeSessionId: requireText(nativeSessionId, "Native session id"),
-        status: "ready",
+        status: "active",
         effective
     };
 }

package/dist/executor/turnCompletion.js

@@ -22,7 +22,7 @@ export function createPendingTurnCompletion(input) {
         roleName: requireSafeIdentity(input.roleName, "Role name"),
         agentId: requireSafeIdentity(input.agentId, "Agent id"),
         nativeSessionId: requireText(input.nativeSessionId, "Native session id"),
-        turnId: requireSafeIdentity(input.turnId, "Turn id"),
+        turnId: requireText(input.turnId, "Turn id"),
         runId: requireSafeIdentity(input.runId, "Run id"),
         summary: requireText(input.summary, "Turn summary"),
         observedAt,
@@ -44,7 +44,7 @@ export function validatePendingTurnCompletion(value) {
         roleName: requireSafeIdentityValue(input.roleName, "Role name"),
         agentId: requireSafeIdentityValue(input.agentId, "Agent id"),
         nativeSessionId: requireTextValue(input.nativeSessionId, "Native session id"),
-        turnId: requireSafeIdentityValue(input.turnId, "Turn id"),
+        turnId: requireTextValue(input.turnId, "Turn id"),
         runId: requireSafeIdentityValue(input.runId, "Run id"),
         summary: requireTextValue(input.summary, "Turn summary"),
         observedAt,
@@ -58,7 +58,7 @@ export function validateRecentTurnIds(value, limit = DEFAULT_RECENT_TURN_ID_LIMI
     if (value.length > normalizedLimit) {
         throw new Error(`Recent Turn ids must not contain more than ${normalizedLimit} entries.`);
     }
-    const result = value.map((turnId) => requireSafeIdentityValue(turnId, "Recent Turn id"));
+    const result = value.map((turnId) => requireTextValue(turnId, "Recent Turn id"));
     if (new Set(result).size !== result.length) {
         throw new Error("Recent Turn ids must not contain duplicates.");
     }
@@ -67,7 +67,7 @@ export function validateRecentTurnIds(value, limit = DEFAULT_RECENT_TURN_ID_LIMI
 export function rememberRecentTurnId(recentTurnIds, turnId, limit = DEFAULT_RECENT_TURN_ID_LIMIT) {
     const normalizedLimit = requireLimit(limit);
     const existing = validateRecentTurnIds(recentTurnIds, normalizedLimit);
-    const normalizedTurnId = requireSafeIdentity(turnId, "Recent Turn id");
+    const normalizedTurnId = requireText(turnId, "Recent Turn id");
     return [
         ...existing.filter((candidate) => candidate !== normalizedTurnId),
         normalizedTurnId
@@ -75,7 +75,7 @@ export function rememberRecentTurnId(recentTurnIds, turnId, limit = DEFAULT_RECE
 }
 export function hasRecentTurnId(recentTurnIds, turnId) {
     const existing = validateRecentTurnIds(recentTurnIds);
-    return existing.includes(requireSafeIdentity(turnId, "Recent Turn id"));
+    return existing.includes(requireText(turnId, "Recent Turn id"));
 }
 function requireOrderedTimestamps(observedAt, dueAt) {
     if (Date.parse(dueAt) < Date.parse(observedAt)) {

package/dist/lifecycle/exactRunTerminalization.js

@@ -269,7 +269,7 @@ export function retireExactActiveAgentRun(store, input, now) {
             || providerTurn?.status === "failed"
             || providerTurn?.status === "cancelled"
             || providerTurn?.status === "rejected");
-    if (session?.status !== "stopped" && session?.status !== "broken" && !providerSettled) {
+    if (session?.status === "active" && !providerSettled) {
         return {
             disposition: "blocked",
             run: current,