@zq-silk/yui 0.13.9 → 0.14.0

package/dist/runtime/exactControlPlane.js

@@ -3,11 +3,9 @@ import { readFileSync, realpathSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { callController as defaultCallController } from "../core/controllerClient.js";
 import { inspectStorageSchema } from "../storage/storageSchema.js";
-import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
 import { yuiVersionIdentity } from "../version.js";
 import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "./lifecycleReservation.js";
 import { nativeSessionIdForLaunch } from "./preallocatedNativeSession.js";
-import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 export const EXACT_CONTROL_ARGUMENT = "--yui-control";
 export const YUI_CONTROL_PLANE_DESCRIPTOR = "YUI_CONTROL_PLANE_DESCRIPTOR";
@@ -37,7 +35,7 @@ export function createExactTaskRuntimeDescriptor(input) {
         agentId: requireIdentity(input.agentId, "Agent id"),
         adapterId: requireAdapter(input.adapterId),
         workspace: canonicalPath(input.workspace),
-        ...(input.runId === undefined ? {} : { runId: requireIdentity(input.runId, "Run id") }),
+        ...(input.turnId === undefined ? {} : { turnId: requireIdentity(input.turnId, "Turn id") }),
         ...(input.launchId === undefined
             ? {}
             : { launchId: requireIdentity(input.launchId, "Launch id") }),
@@ -79,7 +77,7 @@ export function parseExactTaskRuntimeDescriptor(value) {
         agentId: requireText(record.agentId, "Agent id"),
         adapterId: requireAdapter(record.adapterId),
         workspace: requireText(record.workspace, "Task runtime workspace"),
-        ...(record.runId === undefined ? {} : { runId: requireText(record.runId, "Run id") }),
+        ...(record.turnId === undefined ? {} : { turnId: requireText(record.turnId, "Turn id") }),
         ...(record.launchId === undefined
             ? {}
             : { launchId: requireText(record.launchId, "Launch id") }),
@@ -91,7 +89,7 @@ export function parseExactTaskRuntimeDescriptor(value) {
 export function exactControlPlaneDigest(descriptor) {
     return createHash("sha256").update(serializeExactDescriptor(descriptor)).digest("hex");
 }
-/** Stable per Task/Role/Agent location; volatile Run/launch/native fields are content. */
+/** Stable per Task/Role/Agent location; volatile Turn/launch/native fields are content. */
 export function exactTaskRuntimeDescriptorPath(home, descriptor) {
     const validated = createExactTaskRuntimeDescriptor(descriptor);
     const digest = createHash("sha256").update(JSON.stringify([
@@ -153,15 +151,7 @@ export async function assertExactControlPlanePreflight(input, options = {}) {
     assertContinuityIdentity("Local CLI", descriptor.identity, localIdentity);
     const storage = (options.inspectStorage ?? inspectStorageSchema)(descriptor.yuiHome);
     if (storage.status !== "current") {
-        const exactRecordOnlyOlder = storage.status === "unsupported"
-            && storage.incompatibleComponent === "record"
-            && storage.direction === "older"
-            && storage.currentLayoutVersion === descriptor.identity.storageLayoutVersion
-            && storage.currentAggregateSchemaVersion === descriptor.identity.aggregateSchemaVersion;
-        if (!exactRecordOnlyOlder) {
-            throw new Error(`Exact control-plane storage is not current: ${storage.status}.`);
-        }
-        (options.openCompatibleStore ?? openCompatibleFileTaskStore)(descriptor.yuiHome).getConfig();
+        throw new Error(`Exact control-plane storage is not current: ${storage.status}.`);
     }
     if (storage.currentLayoutVersion !== descriptor.identity.storageLayoutVersion) {
         throw new Error("Exact control-plane storage layout does not match its frozen descriptor "
@@ -176,7 +166,7 @@ export async function assertExactControlPlanePreflight(input, options = {}) {
     // A frozen descriptor authenticates the command that created it; it no
     // longer pins the Home's deployment pointer for the lifetime of a Session.
     // Continuity is the protocol/storage contract checked above and the durable
-    // Task/Role/Run identity checked below. This lets a compatible Controller or
+    // Task/Role/Turn identity checked below. This lets a compatible Controller or
     // active release advance without invalidating a still-current Session.
     if (options.checkController !== false) {
         const call = options.callController ?? defaultCallController;
@@ -202,15 +192,7 @@ export async function assertCompatibleControlPlanePreflight(input, options = {})
     const identity = validateVersionIdentity(options.identity ?? yuiVersionIdentity());
     const storage = (options.inspectStorage ?? inspectStorageSchema)(home);
     if (storage.status !== "current") {
-        const compatibleRecordOnlyOlder = storage.status === "unsupported"
-            && storage.incompatibleComponent === "record"
-            && storage.direction === "older"
-            && storage.currentLayoutVersion === identity.storageLayoutVersion
-            && storage.currentAggregateSchemaVersion === identity.aggregateSchemaVersion;
-        if (!compatibleRecordOnlyOlder) {
-            throw new Error(`Managed control-plane storage is not current: ${storage.status}.`);
-        }
-        (options.openCompatibleStore ?? openCompatibleFileTaskStore)(home).getConfig();
+        throw new Error(`Managed control-plane storage is not current: ${storage.status}.`);
     }
     if (storage.currentLayoutVersion !== identity.storageLayoutVersion) {
         throw new Error("Managed control-plane storage layout is incompatible "
@@ -257,9 +239,9 @@ export function assertExactTaskRuntimeEnvironment(runtimeSource, environment, ex
     assertSamePath(runtime.workspace, requireText(environment.YUI_WORKSPACE, "YUI_WORKSPACE"), "Task runtime workspace");
     // A reused native pane retains its original process environment. Volatile
     // identity therefore comes only from the atomically published descriptor
-    // plus durable state, never from stale ambient Run/launch/native variables.
+    // plus durable state, never from stale ambient Turn/launch/native variables.
     if (!resolved.fromFile) {
-        assertOptionalEnvironment(runtime.runId, environment.YUI_RUN_ID, "Run id");
+        assertOptionalEnvironment(runtime.turnId, environment.YUI_TURN_ID, "Turn id");
         assertOptionalEnvironment(runtime.launchId, environment.YUI_LAUNCH_ID, "Launch id");
         assertOptionalEnvironment(runtime.nativeSessionId, environment.YUI_NATIVE_SESSION_ID, "Native session id");
     }
@@ -277,18 +259,18 @@ export function assertExactTaskRuntimeState(runtime, store, options = {}) {
     if (role === null || role.activeAgentId !== runtime.agentId) {
         throw new Error("Exact Task runtime Role or Agent is not current.");
     }
-    const run = store.getActiveAgentRun(runtime.taskId, runtime.roleName);
-    if (runtime.runId === undefined) {
+    const run = store.getActiveTurn(runtime.taskId, runtime.roleName);
+    if (runtime.turnId === undefined) {
         if (run !== null)
-            throw new Error("Exact Task runtime Run is not current.");
+            throw new Error("Exact Task runtime Turn is not current.");
     }
     else if (run === null
-        || run.id !== runtime.runId
+        || run.id !== runtime.turnId
         || run.status !== "active"
         || run.effective.agentId !== runtime.agentId
         || run.effective.adapterId !== runtime.adapterId
         || canonicalPath(run.effective.workspace.root) !== runtime.workspace) {
-        throw new Error("Exact Task runtime Run is not current.");
+        throw new Error("Exact Task runtime Turn is not current.");
     }
     const sessions = store.getTaskRoleSessionSet(runtime.taskId, runtime.roleName);
     const session = sessions?.sessions[runtime.agentId];
@@ -317,13 +299,6 @@ export function assertExactTaskRuntimeState(runtime, store, options = {}) {
         && runtime.nativeSessionId !== undefined
         && (session === undefined || terminalSessionReplacementReservation)
         && runtime.nativeSessionId === nativeSessionIdForLaunch(preallocated.yuiHome, runtime.launchId, runtime.agentId, runtime.adapterId);
-    const preallocatedBeforeInFlightProjection = exactPreallocatedReservation
-        && (sessions?.inFlight === null || sessions?.inFlight === undefined);
-    if (runtime.runId !== undefined && (sessions?.inFlight?.agentId !== runtime.agentId
-        || sessions.inFlight.runId !== runtime.runId
-        || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run)) && !preallocatedBeforeInFlightProjection) {
-        throw new Error("Exact Task runtime in-flight Run fence is not current.");
-    }
     if (runtime.launchId === undefined || (!reservation && !sessionLaunch)) {
         throw new Error("Exact Task runtime launch fence is not current.");
     }
@@ -372,10 +347,10 @@ export function refreshExactTaskRuntimeDescriptorSource(source, home, store) {
     return refreshed;
 }
 /**
- * Advances a reused Hook's own exact source to the current durable Run/launch
+ * Advances a reused Hook's own exact source to the current durable Turn/launch
  * generation before the volatile fence. The stable identity (control digest,
  * Task, Role, Agent, adapter, workspace) and the native Session are preserved;
- * only the volatile Run/launch fields advance. A source may never jump to a
+ * only the volatile Turn/launch fields advance. A source may never jump to a
  * replacement native Session.
  */
 export function refreshReusedTaskRuntimeDescriptorSource(source, home, store, current) {
@@ -385,7 +360,7 @@ export function refreshReusedTaskRuntimeDescriptorSource(source, home, store, cu
     }
     const previous = resolved.descriptor;
     if (previous.nativeSessionId === undefined) {
-        if (previous.runId !== current.runId || previous.launchId !== current.launchId) {
+        if (previous.turnId !== current.turnId || previous.launchId !== current.launchId) {
             throw new Error("Task runtime descriptor source cannot bind a native Session from another generation.");
         }
         return refreshExactTaskRuntimeDescriptorSource(source, home, store);
@@ -395,7 +370,7 @@ export function refreshReusedTaskRuntimeDescriptorSource(source, home, store, cu
     }
     const refreshed = createExactTaskRuntimeDescriptor({
         ...previous,
-        runId: current.runId,
+        turnId: current.turnId,
         launchId: current.launchId,
         nativeSessionId: current.nativeSessionId
     });

package/dist/runtime/firstProgressAdvisory.js

@@ -12,7 +12,7 @@ export function projectFirstProgressAdvisory(input) {
         ? []
         : [
             ...input.events
-                .filter((event) => typeof event.payload.leaderRunId === "string")
+                .filter((event) => typeof event.payload.leaderTurnId === "string")
                 .map((event) => ({ at: event.createdAt, ref: `event:${event.id}` })),
             ...input.workItems
                 .filter((item) => item.status !== "retired")

package/dist/runtime/index.js

@@ -4,7 +4,7 @@ export { projectSessionTokenMetrics, resolveSessionTokenIdentity, unobservedSess
 export { createRuntimeBinding } from "./runtimeBinding.js";
 export { normalizeRuntimeOwner } from "./runtimeOwner.js";
 export { createSessionLaunchRequest } from "./sessionLaunchRequest.js";
-export { createPendingTurnCompletion, DEFAULT_RECENT_TURN_ID_LIMIT, hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
+export { DEFAULT_RECENT_TURN_ID_LIMIT, hasRecentTurnId, rememberRecentTurnId, validateRecentTurnIds } from "./recentTurnIds.js";
 export { RuntimeHostContentionError, RuntimeLaunchError } from "./ports.js";
 export { AgentHostPromptPushAdapter, TmuxSessionHost } from "./tmuxAdapters.js";
 export { FileTaskRuntimeIsolation, YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR, YUI_TASK_RUNTIME_SERVICE_NAMESPACE, assertTaskRuntimeIsolationPreflight, createTaskRuntimeIsolationDescriptor, parseTaskRuntimeIsolationDescriptor, planTaskRuntimeCleanup, taskRuntimeIsolationEnvironment, taskRuntimeIsolationFingerprint } from "./taskRuntimeIsolation.js";
@@ -14,7 +14,7 @@ export { formatRuntimeLaunchDiagnostic, redactLaunchArgument, redactLaunchText,
 export { DEFAULT_FORCED_GRACE_MS, DEFAULT_GRACEFUL_GRACE_MS, terminateSessionOwners } from "./sessionTerminationGuard.js";
 export { ProviderContinuationReconciliationService } from "./providerContinuationReconciliationService.js";
 export { codexNotificationBoundary, codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime } from "./codexAppServerRuntime.js";
-export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
+export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, managedProviderTurnId, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
 export { FencedProviderControl } from "./providerControl.js";
 export { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 export { reconcileSessionOwners } from "./sessionReconciliation.js";

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 Run summaries. */
+/** A bounded, single-line, secret-redacted launch failure for Turn 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 Run could not start: ${fields.join(" ")}`;
+    return `Role Turn could not start: ${fields.join(" ")}`;
 }
 export function redactLaunchArgument(value) {
     return tail(redactLaunchText(value), MAX_ARGUMENT_CHARS);

package/dist/runtime/lifecycleReservation.js

@@ -6,9 +6,9 @@ export const RUNTIME_HOST_DETACH_REQUIRED_REASON = "runtime-host-detach-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/Run must be retried after the lane
- * settles. It is never grounds to terminalize a Run, because the contention
- * happens before (or outside) any semantic Run launch.
+ * 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.
  */
 export class RuntimeLifecycleBusyError extends Error {
     name = "RuntimeLifecycleBusyError";
@@ -48,7 +48,7 @@ export function hasRuntimeCleanupObligation(mailbox) {
 /** Explicit Session end dominates a coalesced physical Host detach request. */
 export function runtimeCleanupDisposition(mailbox) {
     const reasons = [
-        ...(mailbox?.pending.normal?.reasons ?? []),
+        ...(mailbox?.pending?.reasons ?? []),
         ...(!isRuntimeLaunchReservation(mailbox?.processing)
             ? mailbox?.processing?.batch.reasons ?? []
             : [])

package/dist/runtime/processExitObservation.js

@@ -8,7 +8,7 @@ export function validateRuntimeProcessExitObservation(observation) {
     optionalIdentity(observation.providerProcessInstanceId, "providerProcessInstanceId");
     optionalIdentity(observation.taskId, "taskId");
     identity(observation.roleName, "roleName");
-    optionalIdentity(observation.runId, "runId");
+    optionalIdentity(observation.turnId, "turnId");
     identity(observation.launchId, "launchId");
     optionalIdentity(observation.nativeSessionId, "nativeSessionId");
     if (observation.processKind !== "agent-host" && observation.processKind !== "provider-child") {

package/dist/runtime/processExitOutbox.js

@@ -50,39 +50,7 @@ export async function replayRuntimeProcessExitOutbox(home, submit) {
                 throw error;
         });
     }
-    // One-generation bridge for observations written by an Agent Host that was
-    // already running before this release. New writers use one immutable file
-    // per observation above, so they never share an append/unlink boundary.
-    for (const name of entries.filter(isLegacyOutboxEntry).sort()) {
-        const path = join(directory, name);
-        let raw;
-        try {
-            raw = await readFile(path, "utf8");
-        }
-        catch (error) {
-            // The old writer removes its own append log only after the Controller
-            // acknowledges delivery. If it won that race, there is nothing to replay.
-            if (error.code === "ENOENT")
-                continue;
-            throw error;
-        }
-        // Only consume newline-terminated records. A legacy writer can be between
-        // append bytes and its trailing newline while this snapshot is read.
-        const completeLength = raw.lastIndexOf("\n") + 1;
-        const lines = raw.slice(0, completeLength).split("\n").filter(Boolean);
-        for (const line of lines) {
-            await submit(validateRuntimeProcessExitObservation(JSON.parse(line)));
-        }
-        // Deliberately leave the legacy path in place. A pre-upgrade Agent Host may
-        // already hold an append descriptor for this inode; renaming/unlinking it
-        // would let a later append disappear into an unlinked file. The old writer
-        // removes the path after a successful direct submission. Otherwise the
-        // durable file remains for the next idempotent replay.
-    }
 }
 function outboxDirectory(home) {
     return resolve(join(home, "runtime", "agent-host-outbox"));
 }
-function isLegacyOutboxEntry(name) {
-    return name.endsWith(".jsonl");
-}

package/dist/runtime/promptEnvelope.js

@@ -1,15 +1,15 @@
 import { requireText, requireTimestamp } from "./validation.js";
-import { formatAgentRunReceiptId, formatInputRequestReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
+import { formatTurnReceiptId, formatInputRequestReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
 export function createPromptEnvelope(input) {
-    if (input.source.kind !== "agent-run"
-        && input.source.kind !== "run-input"
+    if (input.source.kind !== "turn"
+        && input.source.kind !== "turn-input"
         && input.source.kind !== "input-request") {
         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" : "agentRun");
+    }, input.source.kind === "input-request" ? "inputRequest" : "turn");
     const id = requireQualifiedReceiptId(input.id, input.source.kind, source.taskId, source.localId);
     return {
         id,
@@ -23,14 +23,14 @@ export function createPromptEnvelope(input) {
     };
 }
 function requireQualifiedReceiptId(value, kind, taskId, localId) {
-    const expected = kind === "agent-run"
-        ? formatAgentRunReceiptId(taskId, localId)
+    const expected = kind === "turn"
+        ? formatTurnReceiptId(taskId, localId)
         : kind === "input-request"
             ? formatInputRequestReceiptId(taskId, localId)
-            : `agent-input:${taskId}/${localId}/`;
-    if (kind === "run-input") {
+            : `turn-input:${taskId}/${localId}/`;
+    if (kind === "turn-input") {
         if (!value.startsWith(expected)
-            || !/^(normal|user-correction):[1-9]\d*-[1-9]\d*$/.test(value.slice(expected.length))) {
+            || !/^[1-9]\d*$/.test(value.slice(expected.length))) {
             throw new Error("Prompt envelope id does not match its source.");
         }
         return value;

package/dist/runtime/providerContinuation.js

@@ -14,7 +14,7 @@ export function createProviderContinuation(input) {
         schemaVersion: 1,
         taskId: text(input.taskId, "Task id"),
         roleName: text(input.roleName, "Role name"),
-        runId: text(input.runId, "Run id"),
+        turnId: text(input.turnId, "Turn id"),
         identity: validateProviderContinuationIdentity(input.identity),
         ...(input.parentContinuationId === undefined
             ? {}
@@ -152,7 +152,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.runId, "Run id");
+    text(value.turnId, "Turn id");
     validateProviderContinuationIdentity(value.identity);
     if (!["active", "quiescent", "unknown"].includes(value.execution)) {
         throw new Error("Provider Continuation execution is invalid.");

package/dist/runtime/providerContinuationReconciliationService.js

@@ -100,7 +100,7 @@ function groupDetachedContinuations(continuations, observations) {
             && observation.fence.continuationId === continuation.identity.continuationId
             && observation.fence.continuationGeneration === continuation.identity.generation));
         // A projected continuation without its original durable fence cannot be
-        // safely attached to a live Run. Keep ownership conservative and let the
+        // safely attached to a live Turn. Keep ownership conservative and let the
         // malformed identity remain visible instead of synthesizing a receipt.
         if (source === undefined)
             continue;
@@ -149,7 +149,7 @@ function reconciliationObservation(continuation, sourceFence, now) {
             ...sourceFence,
             taskId: continuation.taskId,
             roleName: continuation.roleName,
-            runId: continuation.runId,
+            turnId: continuation.turnId,
             agentId: continuation.identity.accountScope,
             driverId: continuation.identity.providerNamespace,
             conversationId: continuation.identity.conversationId,

package/dist/runtime/providerRuntimeIdentity.js

@@ -1,7 +1,7 @@
 export function createProviderRuntimeBinding(input) {
     const startedAt = timestamp(input.startedAt, "Provider Activation startedAt");
     return validateProviderRuntimeBinding({
-        schemaVersion: 3,
+        schemaVersion: 5,
         providerNamespace: identity(input.providerNamespace, "Provider namespace"),
         accountScope: identity(input.accountScope, "Provider account scope"),
         currentConversationEpoch: 1,
@@ -25,9 +25,25 @@ export function createProviderRuntimeBinding(input) {
             holderId: input.activationId,
             changedAt: startedAt
         },
-        turn: null
+        turn: null,
+        goal: null
     });
 }
+export function updateProviderGoal(raw, goal) {
+    const binding = validateProviderRuntimeBinding(raw);
+    const normalized = validateProviderGoal(goal);
+    return validateProviderRuntimeBinding({ ...binding, goal: normalized });
+}
+export function clearProviderGoal(raw) {
+    const binding = validateProviderRuntimeBinding(raw);
+    return binding.goal === null
+        ? binding
+        : validateProviderRuntimeBinding({ ...binding, goal: null });
+}
+/** Only active means the Provider is expected to continue autonomously. */
+export function providerGoalContinues(goal) {
+    return goal?.status === "active";
+}
 export function currentProviderAuthority(binding) {
     return validateProviderRuntimeBinding(binding).authority;
 }
@@ -146,12 +162,14 @@ export function transferProviderAuthority(raw, input) {
 }
 export function beginProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
-    const runId = identity(input.runId, "Run id");
     const attemptId = identity(input.attemptId, "Provider input attempt id");
-    if (binding.turn?.runId === runId
-        && binding.turn.attemptId === attemptId
-        && binding.turn.authorityEpoch === input.authorityEpoch
-        && binding.turn.status === "submitting") {
+    const turnId = input.turnId === undefined ? undefined : identity(input.turnId, "Turn id");
+    const currentTurn = binding.turn;
+    if (currentTurn !== null
+        && currentTurn.turnId === turnId
+        && currentTurn.attemptId === attemptId
+        && currentTurn.authorityEpoch === input.authorityEpoch
+        && currentTurn.status === "submitting") {
         return binding;
     }
     if (binding.authority.epoch !== input.authorityEpoch
@@ -166,7 +184,7 @@ export function beginProviderTurn(raw, input) {
     return validateProviderRuntimeBinding({
         ...binding,
         turn: {
-            runId,
+            ...(turnId === undefined ? {} : { turnId }),
             attemptId,
             authorityEpoch: input.authorityEpoch,
             status: "submitting",
@@ -189,7 +207,7 @@ export function acceptProviderTurn(raw, input) {
         turn: {
             ...turn,
             status: "accepted",
-            turnId: identity(input.turnId, "Provider Turn id"),
+            nativeTurnId: identity(input.nativeTurnId, "Provider native Turn id"),
             updatedAt: acceptedAt
         }
     });
@@ -255,9 +273,9 @@ export function settleProviderTurnSubmission(raw, input) {
 export function settleProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     const turn = binding.turn;
-    const turnId = identity(input.turnId, "Provider Turn id");
-    if (turn === null || turn.turnId !== turnId
-        || (turn.status !== "accepted" && turn.status !== "running")) {
+    const nativeTurnId = identity(input.nativeTurnId, "Provider native Turn id");
+    if (turn === null || turn.nativeTurnId !== nativeTurnId
+        || turn.status !== "accepted") {
         throw new Error("Provider Turn settlement does not match the current Turn.");
     }
     const settledAt = orderedTurnTimestamp(turn, input.settledAt, "Provider Turn settledAt");
@@ -302,10 +320,10 @@ export function supersedeProviderConversation(raw, input) {
         }
         : entry);
     const turn = binding.turn !== null
-        && ["submitting", "accepted", "running", "delivery-unknown"].includes(binding.turn.status)
+        && ["submitting", "accepted", "delivery-unknown"].includes(binding.turn.status)
         ? {
             ...binding.turn,
-            status: binding.turn.turnId === undefined ? "rejected" : "failed",
+            status: binding.turn.nativeTurnId === undefined ? "rejected" : "failed",
             updatedAt: switchedAt,
             terminalReason
         }
@@ -338,12 +356,13 @@ export function supersedeProviderConversation(raw, input) {
             holderId: input.activationId,
             changedAt: switchedAt
         },
-        turn
+        turn,
+        goal: null
     });
 }
 export function validateProviderRuntimeBinding(value) {
-    if (value.schemaVersion !== 3)
-        throw new Error("Provider Runtime Binding schemaVersion must be 3.");
+    if (value.schemaVersion !== 5)
+        throw new Error("Provider Runtime Binding schemaVersion must be 5.");
     identity(value.providerNamespace, "Provider namespace");
     identity(value.accountScope, "Provider account scope");
     integer(value.currentConversationEpoch, 1, "Current Provider Conversation epoch");
@@ -447,16 +466,45 @@ export function validateProviderRuntimeBinding(value) {
         throw new Error("Provider Runtime Binding requires Turn state.");
     if (value.turn !== null)
         validateProviderTurn(value.turn, value.authority.epoch);
+    if (!Object.hasOwn(value, "goal"))
+        throw new Error("Provider Runtime Binding requires Goal state.");
+    if (value.goal !== null)
+        validateProviderGoal(value.goal);
     return value;
 }
+function validateProviderGoal(goal) {
+    if (![
+        "active",
+        "paused",
+        "blocked",
+        "usage-limited",
+        "budget-limited",
+        "complete"
+    ].includes(goal.status)) {
+        throw new Error("Provider Goal status is invalid.");
+    }
+    const normalized = {
+        status: goal.status,
+        objective: identity(goal.objective, "Provider Goal objective"),
+        updatedAt: timestamp(goal.updatedAt, "Provider Goal updatedAt"),
+        ...(goal.nativeTurnId === undefined
+            ? {}
+            : { nativeTurnId: identity(goal.nativeTurnId, "Provider Goal native Turn id") }),
+        ...(goal.tokenBudget === undefined
+            ? {}
+            : { tokenBudget: integer(goal.tokenBudget, 1, "Provider Goal token budget") })
+    };
+    return Object.freeze(normalized);
+}
 function validateProviderTurn(turn, currentAuthorityEpoch) {
-    identity(turn.runId, "Run id");
+    if (turn.turnId !== undefined)
+        identity(turn.turnId, "Turn id");
     identity(turn.attemptId, "Provider input attempt id");
     integer(turn.authorityEpoch, 1, "Provider Turn authority epoch");
     if (turn.authorityEpoch > currentAuthorityEpoch) {
         throw new Error("Provider Turn authority epoch is ahead of current authority.");
     }
-    if (!["submitting", "accepted", "running", "completed", "failed", "cancelled", "rejected", "delivery-unknown"]
+    if (!["submitting", "accepted", "completed", "failed", "cancelled", "rejected", "delivery-unknown"]
         .includes(turn.status)) {
         throw new Error("Provider Turn status is invalid.");
     }
@@ -465,12 +513,16 @@ function validateProviderTurn(turn, currentAuthorityEpoch) {
     if (Date.parse(turn.updatedAt) < Date.parse(turn.submittedAt)) {
         throw new Error("Provider Turn updatedAt is earlier than submittedAt.");
     }
-    const hasAcceptedIdentity = turn.status === "accepted" || turn.status === "running"
+    const hasAcceptedIdentity = turn.status === "accepted"
         || turn.status === "completed" || turn.status === "failed" || turn.status === "cancelled";
     if (hasAcceptedIdentity)
-        identity(turn.turnId, "Provider Turn id");
-    else if (turn.turnId !== undefined)
-        throw new Error("Unaccepted Provider Turn cannot have a Turn id.");
+        identity(turn.nativeTurnId, "Provider native Turn id");
+    else if (turn.nativeTurnId !== undefined) {
+        throw new Error("Unaccepted Provider Turn cannot have a native Turn id.");
+    }
+}
+export function managedProviderTurnId(turn) {
+    return turn?.turnId ?? null;
 }
 function requireProviderTurn(binding, attemptId, status) {
     const id = identity(attemptId, "Provider input attempt id");
@@ -487,7 +539,7 @@ function orderedTurnTimestamp(turn, value, label) {
     return normalized;
 }
 function providerTurnIsActive(turn) {
-    return turn !== null && ["submitting", "accepted", "running", "delivery-unknown"]
+    return turn !== null && ["submitting", "accepted", "delivery-unknown"]
         .includes(turn.status);
 }
 function currentActivationUnchecked(binding) {

package/dist/runtime/recentTurnIds.js

@@ -0,0 +1,38 @@
+import { requireText } from "./validation.js";
+export const DEFAULT_RECENT_TURN_ID_LIMIT = 32;
+export function validateRecentTurnIds(value, limit = DEFAULT_RECENT_TURN_ID_LIMIT) {
+    const normalizedLimit = requireLimit(limit);
+    if (!Array.isArray(value))
+        throw new Error("Recent Turn ids must be an array.");
+    if (value.length > normalizedLimit) {
+        throw new Error(`Recent Turn ids must not contain more than ${normalizedLimit} entries.`);
+    }
+    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.");
+    }
+    return result;
+}
+export function rememberRecentTurnId(recentTurnIds, turnId, limit = DEFAULT_RECENT_TURN_ID_LIMIT) {
+    const normalizedLimit = requireLimit(limit);
+    const existing = validateRecentTurnIds(recentTurnIds, normalizedLimit);
+    const normalizedTurnId = requireText(turnId, "Recent Turn id");
+    return [
+        ...existing.filter((candidate) => candidate !== normalizedTurnId),
+        normalizedTurnId
+    ].slice(-normalizedLimit);
+}
+export function hasRecentTurnId(recentTurnIds, turnId) {
+    return validateRecentTurnIds(recentTurnIds).includes(requireText(turnId, "Recent Turn id"));
+}
+function requireTextValue(value, label) {
+    if (typeof value !== "string")
+        throw new Error(`${label} is invalid.`);
+    return requireText(value, label);
+}
+function requireLimit(value) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error("Recent Turn id limit must be a positive integer.");
+    }
+    return value;
+}

package/dist/runtime/runtimeContinuationProjection.js

@@ -32,10 +32,10 @@ export function projectProviderContinuations(events) {
 export function blockingProviderContinuations(events) {
     return projectProviderContinuations(events).filter((entry) => (continuationOwnsWriterUmbrella(entry) || entry.identityConflict));
 }
-/** Exact Run-scoped writer fence shared by terminalization and retry paths. */
+/** Exact Turn-scoped writer fence shared by terminalization and retry paths. */
 export function runOwnsBlockingProviderContinuation(events, owner) {
     return blockingProviderContinuations(events).some((continuation) => (continuation.taskId === owner.taskId
         && continuation.roleName === owner.roleName
-        && continuation.runId === owner.runId
+        && continuation.turnId === owner.turnId
         && continuation.identity.accountScope === owner.agentId));
 }

package/dist/runtime/runtimeHealthPolicy.js

@@ -5,7 +5,7 @@
  * The layers are deliberately time-based and conservative: short silence is
  * normal for high-reasoning-effort turns, large reviews, and tool waits.
  * Time-based layers authorize display hints and coalesced read-only diagnosis
- * only. They never reset a Run or replace a Provider Conversation.
+ * only. They never reset a Turn or replace a Provider Session.
  */
 /** Runtime silence after which a live turn is surfaced as "quiet" (hint only). */
 export const RUNTIME_QUIET_AFTER_MS = 5 * 60_000;