@zq-silk/yui 0.15.6 → 0.15.8

package/dist/runtime/launchDiagnostics.js

@@ -22,7 +22,7 @@ const MAX_DETAIL_CHARS = 1_000;
 const SECRET_VALUE_PATTERN = /(api[_-]?key|access[_-]?token|refresh[_-]?token|secret|password|passwd|cookie|authorization)(\s*[=:]\s*)([^\s,;]+)/gi;
 // Word boundary keeps "task-5-…" workspace paths from being mistaken for keys.
 const OPENAI_KEY_PATTERN = /\bsk-[A-Za-z0-9_-]{6,}/gu;
-/** A bounded, single-line, secret-redacted launch failure for Turn summaries. */
+/** A bounded, single-line, secret-redacted launch failure for AgentRun summaries. */
 export class RuntimeLaunchFailure extends Error {
     diagnostic;
     name = "RuntimeLaunchFailure";
@@ -84,7 +84,7 @@ export function formatRuntimeLaunchDiagnostic(diagnostic) {
     }
     if (diagnostic.hint !== undefined)
         fields.push(`hint=${JSON.stringify(diagnostic.hint)}`);
-    return `Role Turn could not start: ${fields.join(" ")}`;
+    return `Role AgentRun could not start: ${fields.join(" ")}`;
 }
 export function redactLaunchArgument(value) {
     return tail(redactLaunchText(value), MAX_ARGUMENT_CHARS);

package/dist/runtime/lifecycleReservation.js

@@ -1,14 +1,14 @@
 import { mailboxHasWork } from "../coordination/workMailbox.js";
 export const RUNTIME_LIFECYCLE_OWNER = "runtime-lifecycle";
-export const RUNTIME_LAUNCH_RESERVED_REASON = "runtime-launch-reserved";
 export const RUNTIME_CLEANUP_REQUIRED_REASON = "runtime-cleanup-required";
 export const RUNTIME_HOST_DETACH_REQUIRED_REASON = "runtime-host-detach-required";
+export const RUNTIME_SESSION_REPLACE_REQUIRED_REASON = "runtime-session-replace-required";
 /**
- * A Role runtime lifecycle lane already holds an in-flight operation (a
- * launch reservation or a cleanup obligation). This is scheduler
- * backpressure: the equivalent wake/Turn must be retried after the lane
- * settles. It is never grounds to terminalize a Turn, because the contention
- * happens before (or outside) any semantic Turn launch.
+ * A Role runtime lifecycle lane already holds an explicit cleanup obligation.
+ * This is scheduler
+ * backpressure: the equivalent wake/AgentRun must be retried after the lane
+ * settles. It is never grounds to terminalize a AgentRun, because the contention
+ * happens before (or outside) any semantic AgentRun launch.
  */
 export class RuntimeLifecycleBusyError extends Error {
     name = "RuntimeLifecycleBusyError";
@@ -33,15 +33,6 @@ export function runtimeLifecycleSignalKey(owner) {
         ? `role:${encodeURIComponent(owner.taskId)}/${encodeURIComponent(owner.roleName)}`
         : `global-role:${encodeURIComponent(owner.roleName)}`;
 }
-export function isRuntimeLaunchReservation(processing, runtimeGenerationId) {
-    return processing?.owner === RUNTIME_LIFECYCLE_OWNER
-        && processing.batch.reasons.length === 1
-        && processing.batch.reasons[0] === RUNTIME_LAUNCH_RESERVED_REASON
-        && (runtimeGenerationId === undefined || processing.batchId === runtimeGenerationId);
-}
-export function hasRuntimeLaunchReservation(mailbox) {
-    return isRuntimeLaunchReservation(mailbox?.processing);
-}
 export function hasRuntimeCleanupObligation(mailbox) {
     return runtimeCleanupDisposition(mailbox) !== null;
 }
@@ -49,10 +40,10 @@ export function hasRuntimeCleanupObligation(mailbox) {
 export function runtimeCleanupDisposition(mailbox) {
     const reasons = [
         ...(mailbox?.pending?.reasons ?? []),
-        ...(!isRuntimeLaunchReservation(mailbox?.processing)
-            ? mailbox?.processing?.batch.reasons ?? []
-            : [])
+        ...(mailbox?.processing?.batch.reasons ?? [])
     ];
+    if (reasons.includes(RUNTIME_SESSION_REPLACE_REQUIRED_REASON))
+        return "replace-session";
     if (reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON))
         return "end-session";
     if (reasons.includes(RUNTIME_HOST_DETACH_REQUIRED_REASON))
@@ -61,6 +52,7 @@ export function runtimeCleanupDisposition(mailbox) {
 }
 export function isRuntimeCleanupReason(reason) {
     return reason === RUNTIME_CLEANUP_REQUIRED_REASON
+        || reason === RUNTIME_SESSION_REPLACE_REQUIRED_REASON
         || reason === RUNTIME_HOST_DETACH_REQUIRED_REASON;
 }
 export function hasRuntimeLifecycleWork(mailbox) {

package/dist/runtime/managedCaller.js

@@ -1,7 +1,7 @@
-import { createHash } from "node:crypto";
 import { activeRoleAgentBinding } from "../role/role.js";
-/** Per-process credential injected at native Session launch. */
-export const MANAGED_CALLER_KEY_ENV = "YUI_JOB_CALLER_KEY";
+import { currentProviderConversation } from "./providerRuntimeIdentity.js";
+/** Native Session identity supplied by the Agent transport. */
+export const MANAGED_NATIVE_SESSION_ENV = "YUI_NATIVE_SESSION_ID";
 /**
  * A managed Session presented valid self-identity but is no longer the current
  * runtime of its Task Role. This is a bounded diagnosis rather than a bare
@@ -25,12 +25,12 @@ export function managedTaskSessionIdentity(environment) {
         throw new ManagedRuntimeDriftError("Managed Task Session identity is incomplete: YUI_TASK_ID and YUI_ROLE are required.");
     }
     const workspace = identity(env.YUI_WORKSPACE);
-    const callerKey = identity(env[MANAGED_CALLER_KEY_ENV]);
+    const nativeSessionId = identity(env.CODEX_THREAD_ID ?? env[MANAGED_NATIVE_SESSION_ENV]);
     return Object.freeze({
         taskId,
         roleName,
         ...(workspace === undefined ? {} : { workspace }),
-        ...(callerKey === undefined ? {} : { callerKey })
+        ...(nativeSessionId === undefined ? {} : { nativeSessionId })
     });
 }
 /**
@@ -52,6 +52,29 @@ export function requireManagedTaskCaller(store, environment) {
     }
     return caller;
 }
+export function resolveManagedTaskReader(store, environment) {
+    const self = managedTaskSessionIdentity(environment);
+    if (self === undefined)
+        return undefined;
+    try {
+        return requireCurrentRuntime(store, self);
+    }
+    catch (error) {
+        const set = store.getTaskRoleSessionSet(self.taskId, self.roleName);
+        const session = [...Object.values(set?.sessions ?? {}), ...(set?.history ?? [])]
+            .find(candidate => candidate.nativeSessionId === self.nativeSessionId
+            && (self.workspace === undefined || candidate.effective.workspace.root === self.workspace));
+        if (session === undefined) {
+            const binding = set?.providerBinding;
+            if (binding == null || currentProviderConversation(binding).conversationId !== self.nativeSessionId)
+                throw error;
+            return { taskId: self.taskId, roleName: self.roleName, nativeSessionId: self.nativeSessionId };
+        }
+        return Object.freeze({
+            taskId: self.taskId, roleName: self.roleName, nativeSessionId: session.nativeSessionId
+        });
+    }
+}
 /**
  * The current runtime authority for one Task Role, or undefined. Used by
  * command authorization that must not fail the whole invocation, only decline
@@ -71,36 +94,57 @@ export function currentManagedRuntime(store, environment, taskId, roleName) {
         return undefined;
     return caller;
 }
+/** Select execution identity, not a credential or grant. Workers retain their
+ * active Assignment; Leader management follows the current Role selection. */
+export function taskRoleRuntimeIdentity(role, activeRun) {
+    const effective = role.name !== "leader" && activeRun?.status === "active"
+        ? activeRun.effective
+        : undefined;
+    return {
+        agentId: effective?.agentId ?? role.activeAgentId,
+        adapterId: effective?.adapterId ?? activeRoleAgentBinding(role).adapterId
+    };
+}
 function requireCurrentRuntime(store, self) {
     const role = store.getRole(self.taskId, self.roleName);
     if (role === null) {
         throw new ManagedRuntimeDriftError(`This managed Session belongs to ${self.taskId}/${self.roleName}, which no longer exists. `
             + "A new Session must be launched to act on this Task.");
     }
-    const agentId = role.activeAgentId;
-    if (self.callerKey === undefined) {
-        throw new ManagedRuntimeDriftError(`This managed Session carries no ${MANAGED_CALLER_KEY_ENV}, so it cannot be recognized `
+    const activeRun = store.getActiveRun(self.taskId, self.roleName);
+    const { agentId, adapterId } = taskRoleRuntimeIdentity(role, activeRun);
+    const sessions = store.getTaskRoleSessionSet(self.taskId, self.roleName);
+    const session = sessions?.sessions[agentId];
+    if (self.nativeSessionId === undefined) {
+        throw new ManagedRuntimeDriftError(`This managed Session carries no native session id, so it cannot be recognized `
             + `as the current runtime of ${self.taskId}/${self.roleName}.`);
     }
-    const expectedHash = store.getJobCallerKeyHash(self.taskId, self.roleName, agentId);
-    if (expectedHash === null
-        || createHash("sha256").update(self.callerKey).digest("hex") !== expectedHash) {
+    if (role.name === "leader" && store.listEvents(self.taskId).some((event) => event.type === "role.agent-bound" && event.payload.role === role.name
+        && event.payload.revokedNativeSessionId === self.nativeSessionId)) {
+        throw new ManagedRuntimeDriftError("This Leader native Session's management authority was explicitly revoked.");
+    }
+    if (sessions?.activeAgentId !== agentId || session === undefined || session.status !== "active"
+        || session.nativeSessionId !== self.nativeSessionId
+        || session.adapterId !== adapterId
+        || (self.workspace !== undefined && self.workspace !== session.effective.workspace.root)) {
         throw new ManagedRuntimeDriftError(`This managed Session is no longer the current runtime of ${self.taskId}/${self.roleName} `
-            + `(the Role now runs Agent ${agentId}). Its native Session was replaced or its Role was `
-            + "rebound, so its durable caller key no longer matches. Nothing was changed. Read the "
+            + `(the authorized runtime uses Agent ${agentId}). Its native Session was replaced or its Role was `
+            + "rebound, so its native session id no longer matches. Nothing was changed. Read the "
             + `current state with \`yui task show ${self.taskId}\`; acting requires the Session Yui `
             + "launched for the current runtime.");
     }
-    const activeTurn = store.getActiveTurn(self.taskId, self.roleName);
     return Object.freeze({
         taskId: self.taskId,
         roleName: self.roleName,
         agentId,
-        adapterId: activeRoleAgentBinding(role).adapterId,
+        adapterId,
+        nativeSessionId: session.nativeSessionId,
+        executionAuthority: session.effective.executionAuthority,
         ...(self.workspace === undefined ? {} : { workspace: self.workspace }),
-        ...(activeTurn === null || activeTurn.status !== "active"
+        ...(activeRun === null || activeRun.status !== "active"
+            || activeRun.effective.agentId !== agentId
             ? {}
-            : { currentTurnId: activeTurn.id })
+            : { currentRunId: activeRun.id })
     });
 }
 function identity(value) {

package/dist/runtime/nativeSessionControl.js

@@ -0,0 +1,102 @@
+import { openCodexInteractiveConnection } from "./structuredProviderHost.js";
+import { CodexAppServerRuntime, codexAppServerErrorIsMissing, codexClientInitialization } from "./codexAppServerRuntime.js";
+import { realpathSync } from "node:fs";
+import { isAbsolute } from "node:path";
+/** A disposable metadata/control client, not an Agent Session or a new Run.
+ * Never calls thread/start, thread/resume or turn/start. A lost Host cannot be
+ * the only way to stop an existing native execution. */
+export async function stopCodexNativeSession(launch, input, connect = openCodexInteractiveConnection) {
+    const channel = await connect(launch);
+    try {
+        const initialized = await channel.request("initialize", codexClientInitialization());
+        await channel.notify("initialized");
+        if (launch.expectedAccountHome !== undefined && !isAbsolute(launch.expectedAccountHome)) {
+            throw new Error("Recorded native account Home is invalid.");
+        }
+        const actualHome = typeof initialized.codexHome === "string" && isAbsolute(initialized.codexHome)
+            ? initialized.codexHome : undefined;
+        const sameAccount = launch.expectedAccountHome !== undefined && actualHome !== undefined
+            && accountPath(launch.expectedAccountHome) === accountPath(actualHome);
+        if (launch.expectedAccountHome !== undefined && actualHome !== undefined && !sameAccount) {
+            throw new Error("Native recovery connected to a different account Home; restore the recorded connection.");
+        }
+        const runtime = new CodexAppServerRuntime(channel);
+        const latestTurn = async () => {
+            const page = await channel.request("thread/turns/list", {
+                threadId: input.conversationId, limit: 1, sortDirection: "desc", itemsView: "notLoaded"
+            });
+            return Array.isArray(page.data) ? page.data[0] : undefined;
+        };
+        const read = async () => {
+            try {
+                return await runtime.readConversation(input.conversationId, { includeTurns: false });
+            }
+            catch (error) {
+                if (codexAppServerErrorIsMissing(error) && sameAccount)
+                    return null;
+                throw error;
+            }
+        };
+        let snapshot = await read();
+        if (snapshot === null)
+            return;
+        if (input.clearGoal && await runtime.readGoal(input.conversationId) !== null) {
+            await channel.request("thread/goal/clear", { threadId: input.conversationId });
+        }
+        let active = snapshot.activeTurnId ?? input.nativeTurnId;
+        if (snapshot.status === "active" && active === undefined) {
+            // Receipt loss does not justify loading an unbounded transcript or
+            // guessing which Turn ran. Ask for one metadata-only native record.
+            const latest = await latestTurn();
+            if (latest?.status === "inProgress" && typeof latest.id === "string")
+                active = latest.id;
+        }
+        if (snapshot.status === "active" && active !== undefined) {
+            if (input.nativeTurnId !== undefined && snapshot.activeTurnId !== undefined && active !== input.nativeTurnId) {
+                throw new Error("The native conversation has a different active Turn; inspect its owner before stopping it.");
+            }
+            const interrupted = await runtime.interruptTurn({ conversationId: input.conversationId, turnId: active });
+            if (interrupted !== "interrupted") {
+                snapshot = await read();
+                if (snapshot?.status === "active")
+                    throw new Error("The exact native Turn could not be stopped; another execution may be active.");
+            }
+        }
+        const deadline = Date.now() + 8000;
+        for (;;) {
+            snapshot = await read();
+            if (snapshot === null || snapshot.status === "notLoaded")
+                return;
+            // A native error can leave the Thread in systemError after its Turn
+            // failed. Prove the exact latest Turn is terminal, then drain any
+            // background tools; the diagnostic label must not prevent replacement.
+            const errorTurn = snapshot.status === "systemError" ? await latestTurn() : undefined;
+            const erroredAndTerminal = errorTurn !== undefined && typeof errorTurn.id === "string"
+                && ["completed", "failed", "interrupted"].includes(errorTurn.status);
+            if (snapshot.status === "systemError" && !erroredAndTerminal) {
+                throw new Error("Native systemError has no proven terminal latest Turn; inspect native execution before replacing it.");
+            }
+            if (snapshot.status === "idle" || erroredAndTerminal) {
+                await channel.request("thread/backgroundTerminals/clean", { threadId: input.conversationId });
+                const terminals = await channel.request("thread/backgroundTerminals/list", { threadId: input.conversationId, limit: 1 });
+                if (Array.isArray(terminals.data) && terminals.data.length === 0 && terminals.nextCursor == null)
+                    return;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Native conversation ${input.conversationId} is not confirmed quiescent (${snapshot.status}).`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+    finally {
+        channel.close();
+    }
+}
+function accountPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}

package/dist/runtime/ports.js

@@ -1,43 +1,28 @@
-/** A persisted launch is either temporarily unavailable or permanently lost. */
+/** A Session launch may be temporarily unavailable or fail with a diagnosis. */
 export class RuntimeLaunchError extends Error {
     retryable;
-    runtimeGenerationId;
     reason;
     name = "RuntimeLaunchError";
-    constructor(retryable, runtimeGenerationId, message, reason, options) {
+    constructor(retryable, message, reason, options) {
         super(message, options);
         this.retryable = retryable;
-        this.runtimeGenerationId = runtimeGenerationId;
         this.reason = reason;
     }
 }
 /** A host-side contention check that occurs before planning or process start. */
-export class RuntimeHostContentionError extends Error {
+export class RuntimeHostContentionError extends RuntimeLaunchError {
     reason;
     name = "RuntimeHostContentionError";
     constructor(reason, message) {
-        super(message);
+        super(true, message, reason);
         this.reason = reason;
     }
 }
-/** A reused Agent Host acknowledged a different runtime generation. */
-export class RuntimeGenerationMismatchError extends Error {
-    expectedRuntimeGenerationId;
-    observedRuntimeGenerationId;
-    hostState;
-    name = "RuntimeGenerationMismatchError";
-    constructor(expectedRuntimeGenerationId, observedRuntimeGenerationId, hostState, message) {
-        super(message);
-        this.expectedRuntimeGenerationId = expectedRuntimeGenerationId;
-        this.observedRuntimeGenerationId = observedRuntimeGenerationId;
-        this.hostState = hostState;
-    }
-}
 /** A reused Host reported an unusable state; this operation did not create it. */
 export class RuntimeHostUnavailableError extends RuntimeLaunchError {
     hostState;
-    constructor(runtimeGenerationId, hostState, message, options) {
-        super(false, runtimeGenerationId, message, undefined, options);
+    constructor(hostState, message, options) {
+        super(false, message, undefined, options);
         this.hostState = hostState;
     }
 }

package/dist/runtime/processExitObservation.js

@@ -9,8 +9,7 @@ export function validateRuntimeProcessExitObservation(observation) {
     optionalIdentity(observation.providerProcessInstanceId, "providerProcessInstanceId");
     optionalIdentity(observation.taskId, "taskId");
     identity(observation.roleName, "roleName");
-    optionalIdentity(observation.turnId, "turnId");
-    identity(observation.runtimeGenerationId, "runtimeGenerationId");
+    optionalIdentity(observation.runId, "runId");
     optionalIdentity(observation.nativeSessionId, "nativeSessionId");
     if (observation.processKind !== "agent-host" && observation.processKind !== "provider-child") {
         throw new Error("Runtime process kind is invalid.");
@@ -26,22 +25,24 @@ export function validateRuntimeProcessExitObservation(observation) {
     if (!Number.isFinite(Date.parse(observation.observedAt))) {
         throw new Error("Runtime process observedAt is invalid.");
     }
-    optionalIdentity(observation.stopReceiptId, "stopReceiptId");
+    if (observation.stopRequested !== undefined && typeof observation.stopRequested !== "boolean") {
+        throw new Error("stopRequested must be boolean.");
+    }
     optionalIdentity(observation.lastProviderEventId, "lastProviderEventId");
     optionalIdentity(observation.diagnosticTailRef, "diagnosticTailRef");
     return Object.freeze({ ...observation });
 }
 export function classifyRuntimeProcessExit(observation, input) {
     validateRuntimeProcessExitObservation(observation);
-    if (observation.stopReceiptId !== undefined)
-        return "yui-requested-stop";
-    if (observation.processKind === "provider-child" && input.turnFailureObserved === true) {
+    if (observation.stopRequested === true)
+        return "stop-requested";
+    if (observation.processKind === "provider-child" && input.runFailureObserved === true) {
         return "provider-turn-failed";
     }
     if (observation.processKind === "provider-child"
         && input.childLifecycle === "per-turn"
         && observation.exitCode === 0
-        && input.turnTerminalObserved === true) {
+        && input.runTerminalObserved === true) {
         return "expected-per-turn-exit";
     }
     if ((observation.exitCode !== undefined && observation.exitCode !== 0)

package/dist/runtime/promptEnvelope.js

@@ -1,15 +1,16 @@
 import { requireText, requireTimestamp } from "./validation.js";
-import { formatTurnReceiptId, formatInputRequestReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
+import { formatRunReceiptId, formatInputRequestReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
 export function createPromptEnvelope(input) {
-    if (input.source.kind !== "turn"
+    if (input.source.kind !== "run"
         && input.source.kind !== "turn-input"
-        && input.source.kind !== "input-request") {
+        && input.source.kind !== "input-request" && input.source.kind !== "notification") {
         throw new Error("Prompt source kind is invalid.");
     }
     const source = validateTaskRecordReference({
         taskId: input.source.taskId,
         localId: input.source.localId
-    }, input.source.kind === "input-request" ? "inputRequest" : "turn");
+    }, input.source.kind === "input-request" ? "inputRequest"
+        : input.source.kind === "notification" ? "taskWake" : "run");
     const id = requireQualifiedReceiptId(input.id, input.source.kind, source.taskId, source.localId);
     return {
         id,
@@ -23,8 +24,15 @@ export function createPromptEnvelope(input) {
     };
 }
 function requireQualifiedReceiptId(value, kind, taskId, localId) {
-    const expected = kind === "turn"
-        ? formatTurnReceiptId(taskId, localId)
+    if (kind === "notification") {
+        const prefix = `notification:${taskId}/${localId}/`;
+        if (!value.startsWith(prefix) || !/^[a-zA-Z0-9-]+$/.test(value.slice(prefix.length))) {
+            throw new Error("Notification attempt does not match its wake.");
+        }
+        return value;
+    }
+    const expected = kind === "run"
+        ? formatRunReceiptId(taskId, localId)
         : kind === "input-request"
             ? formatInputRequestReceiptId(taskId, localId)
             : `turn-input:${taskId}/${localId}/`;
@@ -35,6 +43,9 @@ function requireQualifiedReceiptId(value, kind, taskId, localId) {
         }
         return value;
     }
+    if (kind === "run" && value.startsWith(`${expected}/attempt/`)
+        && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value.slice(`${expected}/attempt/`.length)))
+        return value;
     if (value !== expected)
         throw new Error("Prompt envelope id does not match its source.");
     return expected;

package/dist/runtime/providerContinuation.js

@@ -4,9 +4,7 @@ export function providerContinuationKey(identity) {
         normalized.providerNamespace,
         normalized.accountScope,
         normalized.conversationId,
-        normalized.activationId,
-        normalized.continuationId,
-        normalized.generation
+        normalized.continuationId
     ].join("\u0000");
 }
 export function createProviderContinuation(input) {
@@ -14,7 +12,7 @@ export function createProviderContinuation(input) {
         schemaVersion: 1,
         taskId: text(input.taskId, "Task id"),
         roleName: text(input.roleName, "Role name"),
-        turnId: text(input.turnId, "Turn id"),
+        runId: text(input.runId, "AgentRun id"),
         identity: validateProviderContinuationIdentity(input.identity),
         ...(input.parentContinuationId === undefined
             ? {}
@@ -152,7 +150,7 @@ export function validateProviderContinuation(value) {
         throw new Error("Provider Continuation schemaVersion must be 1.");
     text(value.taskId, "Task id");
     text(value.roleName, "Role name");
-    text(value.turnId, "Turn id");
+    text(value.runId, "AgentRun id");
     validateProviderContinuationIdentity(value.identity);
     if (!["active", "quiescent", "unknown"].includes(value.execution)) {
         throw new Error("Provider Continuation execution is invalid.");
@@ -203,11 +201,7 @@ export function validateProviderContinuationIdentity(value) {
     text(value.providerNamespace, "Provider namespace");
     text(value.accountScope, "Provider account scope");
     text(value.conversationId, "Provider Conversation id");
-    text(value.activationId, "Provider Activation id");
     text(value.continuationId, "Provider Continuation id");
-    if (!Number.isSafeInteger(value.generation) || value.generation < 1) {
-        throw new Error("Provider Continuation generation is invalid.");
-    }
     return value;
 }
 function validateProviderReport(value) {

package/dist/runtime/providerContinuationReconciliationService.js

@@ -89,18 +89,11 @@ function groupDetachedContinuations(continuations, observations) {
         const key = [
             continuation.identity.providerNamespace,
             continuation.identity.accountScope,
-            continuation.identity.conversationId,
-            continuation.identity.activationId
+            continuation.identity.conversationId
         ].join("\u0000");
-        const source = [...observations].reverse().find((observation) => (observation.kind.startsWith("continuation.")
-            && observation.fence.driverId === continuation.identity.providerNamespace
-            && observation.fence.agentId === continuation.identity.accountScope
-            && observation.fence.conversationId === continuation.identity.conversationId
-            && observation.fence.activationId === continuation.identity.activationId
-            && observation.fence.continuationId === continuation.identity.continuationId
-            && observation.fence.continuationGeneration === continuation.identity.generation));
+        const source = [...observations].reverse().find((observation) => (observation.kind.startsWith("continuation.") && observation.fence.driverId === continuation.identity.providerNamespace && observation.fence.agentId === continuation.identity.accountScope && observation.fence.conversationId === continuation.identity.conversationId && observation.fence.continuationId === continuation.identity.continuationId));
         // A projected continuation without its original durable fence cannot be
-        // safely attached to a live Turn. Keep ownership conservative and let the
+        // safely attached to a live AgentRun. Keep ownership conservative and let the
         // malformed identity remain visible instead of synthesizing a receipt.
         if (source === undefined)
             continue;
@@ -149,14 +142,12 @@ function reconciliationObservation(continuation, sourceFence, now) {
             ...sourceFence,
             taskId: continuation.taskId,
             roleName: continuation.roleName,
-            turnId: continuation.turnId,
+            runId: continuation.runId,
             agentId: continuation.identity.accountScope,
             driverId: continuation.identity.providerNamespace,
             conversationId: continuation.identity.conversationId,
-            activationId: continuation.identity.activationId,
             nativeSessionId: continuation.identity.conversationId,
             continuationId: continuation.identity.continuationId,
-            continuationGeneration: continuation.identity.generation,
             ...(continuation.parentContinuationId === undefined
                 ? {}
                 : { parentContinuationId: continuation.parentContinuationId })

package/dist/runtime/providerControl.js

@@ -1,4 +1,4 @@
-import { currentProviderActivation, currentProviderAuthority, currentProviderConversation, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
+import { currentProviderAuthority, currentProviderConversation, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
 /**
  * Applies the durable single-writer fence before any Provider mutation. The
  * Adapter never receives authority to infer or repair identity.
@@ -33,13 +33,8 @@ export class FencedProviderControl {
         const normalized = validateProviderRuntimeBinding(binding);
         this.#assertNamespace(normalized);
         const conversation = currentProviderConversation(normalized);
-        const activation = currentProviderActivation(normalized);
         const authority = currentProviderAuthority(normalized);
-        if (conversation.conversationId !== fence.conversationId
-            || activation?.activationId !== fence.activationId
-            || authority.epoch !== fence.authorityEpoch
-            || authority.owner !== fence.authorityOwner
-            || authority.holderId !== fence.holderId) {
+        if (conversation.conversationId !== fence.conversationId || authority.epoch !== fence.authorityEpoch || authority.owner !== fence.authorityOwner || authority.holderId !== fence.holderId) {
             throw new Error("Provider writer fence is stale.");
         }
     }