@zq-silk/yui 0.15.7 → 0.15.8

package/dist/controller/{runtimeHookTurnFence.js → runtimeHookRunFence.js}

@@ -1,17 +1,15 @@
 import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
-import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { formatTurnReceiptId } from "../task/taskRecordReference.js";
-import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
+import { formatRunReceiptId } from "../task/taskRecordReference.js";
+import { currentProviderConversation, managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
+import { taskRoleRuntimeIdentity } from "../runtime/managedCaller.js";
+import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 /**
- * Resolves turn identity from the current durable in-flight fence. The one
- * exception is a Driver-declared startup Session Hook, which can arrive before
- * Session projection and is fenced by the exact Turn-bound launch reservation.
- * Preallocated identities are additionally checked against Yui's deterministic
- * runtime generation identity. The immutable event is revalidated by the inbox fold.
+ * Resolve observations by Session and exact input identity. A startup Hook
+ * may introduce a Session for an explicit new-Session AgentRun.
  */
-export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativeSessionId, options = {}) {
+export function resolveRuntimeHookRunFence(environment, adapterId, payloadNativeSessionId, options = {}) {
     if (environment.YUI_SESSION_SCOPE !== "task") {
         throw new Error("Runtime observation Hook requires a Task session scope.");
     }
@@ -35,76 +33,68 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
     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 activeRun = store.getActiveRun(taskId, roleName);
+    const providerTurn = sessions?.providerBinding?.run;
     const matchesProviderTurn = providerTurn !== null
         && providerTurn !== undefined
+        && providerTurn.status !== "rejected" && providerTurn.status !== "deferred"
         && executionSession?.adapterId === adapterId
         && executionSession.effective.workspace.root === workspace
-        && activation?.conversationId === nativeSessionId
+        && sessions?.providerBinding != null
+        && currentProviderConversation(sessions.providerBinding).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), {
+    const acceptedRun = acceptedRunBinding(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), {
+    const acceptedBinding = acceptedRun ?? (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.
+    // cannot erase the original AgentRun's evidence.
     const existingExecutionObservation = (options.terminal === true || options.attemptId !== undefined)
         && (acceptedBinding !== null || matchesProviderTurn);
+    // A Draft's planning Turn runs before activation by design, so it never has an
+    // active execution lifecycle to admit it here. Admission is delegated to the
+    // one shared invariant that already pairs a Turn purpose with a Task state, so
+    // a Draft still cannot produce execution observations while the planning
+    // conversation can report its own runtime.
+    const planningObservation = activeRun !== null
+        && activeRun.purpose === "planning"
+        && activeRun.roleName === roleName
+        && runPurposeAdmitsTaskState(activeRun.purpose, task);
     if (!(task.status === "active" && task.executionGate.state === "enabled")
         && !(task.status === "completed" && options.sessionOnly === true)
+        && !planningObservation
         && !existingExecutionObservation) {
         throw new Error("Runtime observation Hook Task does not accept this lifecycle boundary.");
     }
-    if (!existingExecutionObservation && (role === null || role.activeAgentId !== agentId
+    const runtimeIdentity = role === null ? null : taskRoleRuntimeIdentity(role, activeRun);
+    if (!existingExecutionObservation && (runtimeIdentity === null || runtimeIdentity.agentId !== agentId
+        || runtimeIdentity.adapterId !== adapterId
         || (sessions !== null && sessions.activeAgentId !== agentId))) {
         throw new Error("Runtime observation Hook Role or Agent is not current.");
     }
-    // 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
-    // reservation during startup) is the only current answer.
     const lifecycleMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
         scope: "task",
         taskId,
         roleName
     }));
-    const reservedRuntimeGenerationId = isRuntimeLaunchReservation(lifecycleMailbox?.processing)
-        ? lifecycleMailbox?.processing?.batchId
-        : undefined;
-    // 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;
+    const directProviderTurn = matchesProviderTurn && providerTurn.runId === undefined;
+    const sessionOnlyObservation = options.sessionOnly === true
+        || (options.startupSession === undefined && options.terminal !== true
+            && acceptedBinding === null && !matchesProviderTurn);
     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.");
@@ -113,119 +103,108 @@ export function resolveRuntimeHookTurnFence(environment, adapterId, payloadNativ
             taskId,
             roleName,
             agentId,
-            runtimeGenerationId,
             ...(directProviderTurn ? { receiptId: providerTurn.attemptId } : {}),
             nativeSessionId,
             workspace
         };
     }
-    const activationReceiptId = matchesProviderTurn
+    const inputReceiptId = matchesProviderTurn
         ? providerTurn.attemptId
         : providerTurn !== null
             && providerTurn !== undefined
-            && managedProviderTurnId(providerTurn) === activeTurn?.id
+            && managedProviderTurnId(providerTurn) === activeRun?.id
             ? providerTurn.attemptId
-            : activeTurn === null ? undefined : formatTurnReceiptId(taskId, activeTurn.id);
-    const mailbox = lifecycleMailbox;
-    const exactReservation = isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId)
-        && !hasRuntimeCleanupObligation(mailbox);
-    const startupTurnId = reservedStartup ? activeTurn.id : undefined;
-    const startupReservation = startupTurnId !== undefined
-        && reservedStartup
-        && exactReservation
-        && !hasRuntimeCleanupObligation(mailbox);
-    const startupTurn = startupTurnId === undefined
+            : activeRun === null ? undefined : formatRunReceiptId(taskId, activeRun.id);
+    const startupRunId = options.startupSession === undefined ? undefined : activeRun?.id;
+    const startupIntent = startupRunId !== undefined
+        && !hasRuntimeCleanupObligation(lifecycleMailbox);
+    const startupRun = startupRunId === undefined
         ? null
-        : store.getTurn(taskId, startupTurnId);
+        : store.getRun(taskId, startupRunId);
     const replacementStartup = options.startupSession !== undefined
         && session !== undefined
         && sessions !== null
-        && startupReservation
-        && startupTurn?.mode === "new"
+        && startupIntent
+        && startupRun?.mode === "new"
         && session.status === "ended";
-    const resumedStartup = startupReservation
-        && startupTurn?.mode === "resume"
+    const resumedStartup = startupIntent
+        && startupRun?.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
-    // value the launch envelope carried.
+    // New Session identity is provided by the native adapter, not a launch token.
     const preallocatedStartup = options.startupSession === "preallocated"
         && (session === undefined || replacementStartup)
-        && startupReservation
-        && nativeSessionId === nativeSessionIdForLaunch(home, runtimeGenerationId, agentId, adapterId);
+        && startupIntent
+        && startupRun?.mode === "new";
     const discoveredStartup = options.startupSession === "discovered"
         && (session === undefined || replacementStartup)
-        && startupReservation;
-    const registeredTurnId = acceptedBinding === null && matchesProviderTurn
+        && startupIntent
+        && startupRun?.mode === "new";
+    const registeredRunId = acceptedBinding === null && matchesProviderTurn
         ? managedProviderTurnId(providerTurn) ?? undefined
         : undefined;
-    if (options.terminal === true && acceptedBinding === null && registeredTurnId === undefined) {
+    if (options.terminal === true && acceptedBinding === null && registeredRunId === undefined) {
         throw new Error("Runtime observation Hook terminal has no exact accepted execution binding.");
     }
-    const terminalTurn = acceptedBinding !== null
-        ? store.getTurn(taskId, acceptedBinding.fence.turnId)
-        : registeredTurnId === undefined
+    const terminalRun = acceptedBinding !== null
+        ? store.getRun(taskId, acceptedBinding.fence.runId)
+        : registeredRunId === undefined
             ? null
-            : store.getTurn(taskId, registeredTurnId);
-    const exactTerminal = terminalTurn !== null
-        && terminalTurn.status !== "active"
-        && terminalTurn.roleName === roleName
-        && terminalTurn.effective.agentId === agentId
-        && terminalTurn.effective.adapterId === adapterId
+            : store.getRun(taskId, registeredRunId);
+    const exactTerminal = terminalRun !== null
+        && terminalRun.status !== "active"
+        && terminalRun.roleName === roleName
+        && terminalRun.effective.agentId === agentId
+        && terminalRun.effective.adapterId === adapterId
         && session !== undefined;
-    if (activeTurn === null
+    if (activeRun === null
         && !preallocatedStartup
         && !discoveredStartup
         && !resumedStartup
         && !exactTerminal
-        && registeredTurnId === undefined
+        && registeredRunId === undefined
         && acceptedBinding === null) {
-        throw new Error("Runtime observation Hook has no matching durable in-flight Turn.");
+        throw new Error("Runtime observation Hook has no matching durable in-flight AgentRun.");
     }
-    const turnId = acceptedBinding?.fence.turnId
-        ?? registeredTurnId
-        ?? activeTurn?.id
-        ?? startupTurnId;
-    const effectiveRuntimeGenerationId = acceptedBinding?.fence.runtimeGenerationId ?? runtimeGenerationId;
-    const turn = acceptedBinding !== null || registeredTurnId !== undefined
-        ? terminalTurn
-        : store.getActiveTurn(taskId, roleName);
-    if (turn === null
-        || turn.id !== turnId
-        || (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.");
+    const runId = acceptedBinding?.fence.runId
+        ?? registeredRunId
+        ?? activeRun?.id
+        ?? startupRunId;
+    const run = acceptedBinding !== null || registeredRunId !== undefined
+        ? terminalRun
+        : store.getActiveRun(taskId, roleName);
+    if (run === null
+        || run.id !== runId
+        || (acceptedBinding === null && registeredRunId === undefined && !exactTerminal && run.status !== "active")
+        || run.roleName !== roleName
+        || run.effective.agentId !== agentId
+        || run.effective.adapterId !== adapterId) {
+        throw new Error("Runtime observation Hook AgentRun does not match durable active state.");
     }
-    if (turn.effective.workspace.root !== workspace) {
-        throw new Error("Runtime observation Hook workspace does not match the durable Turn snapshot.");
+    if (run.effective.workspace.root !== workspace) {
+        throw new Error("Runtime observation Hook workspace does not match the durable AgentRun snapshot.");
     }
     if (session !== undefined && acceptedBinding === null && !matchesProviderTurn && !replacementStartup && !resumedStartup) {
         if (session.adapterId !== adapterId
-            || session.runtimeGenerationId !== effectiveRuntimeGenerationId
             || session.nativeSessionId !== nativeSessionId
             || session.effective.workspace.root !== workspace) {
-            throw new Error("Runtime observation Hook Session does not match its durable generation.");
+            throw new Error("Runtime observation Hook Session does not match durable state.");
         }
     }
     else if (acceptedBinding === null && !matchesProviderTurn && (session === undefined || replacementStartup)) {
         if (!discoveredStartup && !preallocatedStartup) {
-            throw new Error("Runtime observation Hook launch is not durably reserved.");
+            throw new Error("Runtime observation Hook has no matching new-Session intent.");
         }
     }
     return {
         taskId,
         roleName,
         agentId,
-        runtimeGenerationId: effectiveRuntimeGenerationId,
-        turnId,
+        runId,
         ...(acceptedBinding?.fence.receiptId === undefined
-            ? activationReceiptId === undefined ? {} : { receiptId: activationReceiptId }
+            ? inputReceiptId === undefined ? {} : { receiptId: inputReceiptId }
             : { receiptId: acceptedBinding.fence.receiptId }),
         nativeSessionId,
         workspace
@@ -241,8 +220,7 @@ function knownContinuationBinding(events, expected) {
         && observation.fence.agentId === expected.agentId
         && observation.fence.nativeSessionId === expected.nativeSessionId
         && observation.fence.continuationId === expected.continuationId
-        && observation.fence.continuationGeneration === expected.continuationGeneration
-        && observation.fence.turnId !== undefined)
+        && observation.fence.runId !== undefined)
         .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
         || (left.sequence ?? -1) - (right.sequence ?? -1)
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
@@ -250,14 +228,13 @@ function knownContinuationBinding(events, expected) {
     const binding = matches.at(-1) ?? null;
     if (binding === null)
         return null;
-    if (matches.some((candidate) => candidate.fence.turnId !== binding.fence.turnId
-        || candidate.fence.runtimeGenerationId !== binding.fence.runtimeGenerationId
+    if (matches.some((candidate) => candidate.fence.runId !== binding.fence.runId
         || candidate.fence.receiptId !== binding.fence.receiptId)) {
-        throw new Error("Runtime observation Hook continuation has conflicting durable Turn bindings.");
+        throw new Error("Runtime observation Hook continuation has conflicting durable AgentRun bindings.");
     }
     return binding;
 }
-function acceptedTurnBinding(events, expected) {
+function acceptedRunBinding(events, expected) {
     if (expected.nativeTurnId === undefined && expected.attemptId === undefined)
         return null;
     const matches = events
@@ -270,7 +247,7 @@ function acceptedTurnBinding(events, expected) {
         && observation.fence.nativeSessionId === expected.nativeSessionId
         && ((expected.attemptId !== undefined && observation.fence.receiptId === expected.attemptId)
             || (expected.nativeTurnId !== undefined && observation.fence.nativeTurnId === expected.nativeTurnId))
-        && observation.fence.turnId !== undefined)
+        && observation.fence.runId !== undefined)
         .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
         || (left.sequence ?? -1) - (right.sequence ?? -1)
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
@@ -281,10 +258,9 @@ function acceptedTurnBinding(events, expected) {
     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.runId !== binding.fence.runId
         || candidate.fence.receiptId !== binding.fence.receiptId))) {
-        throw new Error("Runtime observation Hook native Turn has conflicting durable Turn bindings.");
+        throw new Error("Runtime observation Hook native Turn has conflicting durable AgentRun bindings.");
     }
     return binding;
 }