@zq-silk/yui 0.6.9 → 0.6.11

package/dist/executor/agentExecutor.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
+import { validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
+import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
     const base = {
         owner: normalizeOwner(owner),
@@ -12,9 +14,9 @@ export function createRoleSessionSet(owner, activeAgentId, now) {
         ? { ...base, schemaVersion: 3 }
         : {
             ...base,
-            schemaVersion: 4,
+            schemaVersion: 5,
             inFlight: null,
-            pendingTurnCompletion: null
+            providerBinding: null
         };
 }
 export function activeRoleAgentSession(set) {
@@ -157,8 +159,7 @@ export function updateRoleAgentSessionStatus(set, agentId, status, now) {
 }
 export function retireTaskRoleSessionsForWorkspace(set, now) {
     validateRoleSessionSet(set);
-    if (set.inFlight !== null
-        || set.pendingTurnCompletion !== null) {
+    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");
@@ -183,7 +184,7 @@ export function retireTaskRoleSessionsForWorkspace(set, now) {
  */
 export function retireConfirmedAbsentInactiveTaskRolePlaceholders(set, now) {
     validateRoleSessionSet(set);
-    if (set.inFlight !== null || set.pendingTurnCompletion !== null) {
+    if (set.inFlight !== null) {
         throw new Error("Cannot retire a Task Role placeholder with unsettled Run state.");
     }
     const timestamp = now.toISOString();
@@ -278,9 +279,6 @@ export function bindTaskRoleRun(set, fence, preparedAt) {
     if (normalized.agentId !== set.activeAgentId) {
         throw new Error("Task Role Run Agent does not match the active Agent.");
     }
-    if (set.pendingTurnCompletion !== null) {
-        throw new Error("Task Role session set has an unsettled Turn completion.");
-    }
     if (set.inFlight !== null) {
         if (sameRunFence(set.inFlight, normalized))
             return set;
@@ -294,6 +292,38 @@ export function bindTaskRoleRun(set, fence, preparedAt) {
     };
     return validateRoleSessionSet(updated);
 }
+export function bindTaskRoleProviderRuntime(set, binding, updatedAt) {
+    validateRoleSessionSet(set);
+    const normalized = validateProviderRuntimeBinding(binding);
+    if (set.inFlight === null || set.inFlight.runId !== normalized.runId) {
+        throw new Error("Provider Runtime Binding does not match the in-flight Run.");
+    }
+    if (set.providerBinding !== null) {
+        if (JSON.stringify(set.providerBinding) === JSON.stringify(normalized))
+            return set;
+        throw new Error("Task Role already has a Provider Runtime Binding.");
+    }
+    return validateRoleSessionSet({
+        ...set,
+        providerBinding: normalized,
+        updatedAt: requireDate(updatedAt, "Provider Runtime Binding timestamp")
+    });
+}
+export function updateTaskRoleProviderRuntime(set, binding, updatedAt) {
+    validateRoleSessionSet(set);
+    const normalized = validateProviderRuntimeBinding(binding);
+    if (set.providerBinding === null
+        || normalized.runId !== set.providerBinding.runId
+        || normalized.providerNamespace !== set.providerBinding.providerNamespace
+        || normalized.accountScope !== set.providerBinding.accountScope) {
+        throw new Error("Provider Runtime Binding identity cannot change in place.");
+    }
+    return validateRoleSessionSet({
+        ...set,
+        providerBinding: normalized,
+        updatedAt: requireDate(updatedAt, "Provider Runtime Binding timestamp")
+    });
+}
 export function markTaskRoleRunPushed(set, fence, pushedAt) {
     validateRoleSessionSet(set);
     assertTaskRoleSessionSet(set);
@@ -332,38 +362,55 @@ export function markTaskRoleRunDelivered(set, fence, deliveredAt) {
     };
     return validateRoleSessionSet(updated);
 }
-export function recordObservedTaskRoleCompletion(set, completion) {
+/**
+ * Records a provider Turn boundary without changing the durable Yui Run.
+ *
+ * A native session may finish one foreground Turn while provider-owned
+ * subagents, mailbox work, or later user corrections still belong to the same
+ * application-level Run.  Only an explicit Yui workflow outcome may clear the
+ * Run fence; this transition merely makes the native session available for a
+ * subsequent input and remembers the provider Turn idempotently.
+ */
+export function recordTaskRoleTurnBoundary(set, input, completedAt) {
     validateRoleSessionSet(set);
     assertTaskRoleSessionSet(set);
-    const observed = validatePendingTurnCompletion(completion);
-    assertCompletionOwner(set, observed);
-    const session = set.sessions[observed.agentId];
-    if (session !== undefined && session.nativeSessionId !== observed.nativeSessionId) {
-        throw new Error("Observed Turn native session does not match the Role Agent session.");
+    const agentId = requireSafeIdentity(input.agentId, "Agent id");
+    const nativeSessionId = requireText(input.nativeSessionId, "Native session id");
+    const turnId = requireSafeIdentity(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.");
     }
-    if (session?.recentCompletedTurnIds.includes(observed.turnId) === true)
+    if (session.recentCompletedTurnIds.includes(turnId))
         return set;
-    if (set.pendingTurnCompletion !== null) {
-        if (samePendingTurnCompletion(set.pendingTurnCompletion, observed))
-            return set;
-        throw new Error("Task Role session set already has a pending Turn completion.");
-    }
-    const inFlight = set.inFlight;
-    if (inFlight === null) {
-        throw new Error("Observed Turn has no matching in-flight Run.");
-    }
-    if (inFlight.agentId !== observed.agentId || inFlight.runId !== observed.runId) {
-        throw new Error("Observed Turn Run does not match the in-flight Run.");
+    if (set.inFlight !== null && set.inFlight.agentId !== agentId) {
+        throw new Error("Completed Turn Agent does not match the in-flight Run.");
     }
-    if (inFlight.pushedAt === undefined) {
-        throw new Error("Observed Turn Run must be pushed before completion is recorded.");
-    }
-    const updated = {
+    const timestamp = requireDate(completedAt, "Turn completedAt");
+    const status = session.status === "stopped" || session.status === "broken"
+        ? session.status
+        : "ready";
+    return validateRoleSessionSet({
         ...set,
-        pendingTurnCompletion: observed,
-        updatedAt: observed.observedAt
-    };
-    return validateRoleSessionSet(updated);
+        sessions: {
+            ...set.sessions,
+            [agentId]: {
+                ...session,
+                status,
+                recentCompletedTurnIds: rememberRecentTurnId(session.recentCompletedTurnIds, turnId),
+                updatedAt: timestamp
+            }
+        },
+        updatedAt: timestamp
+    });
+}
+export function recordObservedTaskRoleCompletion(set, completion) {
+    const observed = validatePendingTurnCompletion(completion);
+    return recordTaskRoleTurnBoundary(set, {
+        agentId: observed.agentId,
+        nativeSessionId: observed.nativeSessionId,
+        turnId: observed.turnId
+    }, new Date(observed.observedAt));
 }
 export function clearTaskRoleRun(set, fence, clearedAt) {
     validateRoleSessionSet(set);
@@ -373,23 +420,10 @@ export function clearTaskRoleRun(set, fence, clearedAt) {
     if (Date.parse(timestamp) < Date.parse(inFlight.preparedAt)) {
         throw new Error("Task Role Run clearedAt must not be earlier than preparedAt.");
     }
-    const pending = set.pendingTurnCompletion;
-    const session = set.sessions[inFlight.agentId];
-    const sessions = pending !== null && session !== undefined
-        ? {
-            ...set.sessions,
-            [inFlight.agentId]: {
-                ...session,
-                recentCompletedTurnIds: rememberRecentTurnId(session.recentCompletedTurnIds, pending.turnId),
-                updatedAt: timestamp
-            }
-        }
-        : set.sessions;
     const updated = {
         ...set,
-        sessions,
         inFlight: null,
-        pendingTurnCompletion: null,
+        providerBinding: null,
         updatedAt: timestamp
     };
     return validateRoleSessionSet(updated);
@@ -402,18 +436,9 @@ export function clearTaskRoleRun(set, fence, clearedAt) {
 export function terminalizeTaskRoleRunSession(set, fence, terminalAt) {
     validateRoleSessionSet(set);
     const inFlight = set.inFlight;
-    const pending = set.pendingTurnCompletion;
-    let updated = pending !== null
-        && pending.agentId === fence.agentId
-        && pending.runId === fence.runId
-        ? settleTaskRoleCompletion(set, {
-            agentId: fence.agentId,
-            runId: fence.runId,
-            turnId: pending.turnId
-        }, terminalAt)
-        : inFlight === null
-            ? set
-            : clearTaskRoleRun(set, fence, terminalAt);
+    let updated = inFlight === null
+        ? set
+        : clearTaskRoleRun(set, fence, terminalAt);
     const session = updated.sessions[updated.activeAgentId];
     if (session?.status === "running") {
         updated = updateRoleAgentSessionStatus(updated, updated.activeAgentId, "ready", terminalAt);
@@ -441,7 +466,7 @@ export function resetTaskRoleSession(set, now) {
         sessions,
         ...(history === undefined ? {} : { history }),
         inFlight: null,
-        pendingTurnCompletion: null,
+        providerBinding: null,
         updatedAt: timestamp
     });
 }
@@ -451,38 +476,27 @@ export function settleTaskRoleCompletion(set, expected, settledAt) {
     const agentId = requireSafeIdentity(expected.agentId, "Agent id");
     const runId = requireSafeIdentity(expected.runId, "Run id");
     const turnId = requireSafeIdentity(expected.turnId, "Turn id");
-    const pending = set.pendingTurnCompletion;
-    if (pending === null)
-        throw new Error("Task Role session set has no pending Turn completion.");
-    if (pending.agentId !== agentId
-        || pending.runId !== runId
-        || pending.turnId !== turnId) {
-        throw new Error("Pending Turn completion does not match the expected Turn.");
-    }
     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.");
     }
     const session = set.sessions[agentId];
-    if (session === undefined || session.nativeSessionId !== pending.nativeSessionId) {
-        throw new Error("Pending Turn completion has no matching Role Agent native session.");
+    if (session === undefined || !session.recentCompletedTurnIds.includes(turnId)) {
+        throw new Error("Turn completion has not been observed for the Role Agent session.");
     }
     const timestamp = requireDate(settledAt, "Turn settledAt");
-    if (Date.parse(timestamp) < Date.parse(pending.observedAt)) {
-        throw new Error("Turn settledAt must not be earlier than observedAt.");
-    }
     const updated = {
         ...set,
         sessions: {
             ...set.sessions,
             [agentId]: {
                 ...session,
-                recentCompletedTurnIds: rememberRecentTurnId(session.recentCompletedTurnIds, pending.turnId),
+                recentCompletedTurnIds: session.recentCompletedTurnIds,
                 updatedAt: timestamp
             }
         },
         inFlight: null,
-        pendingTurnCompletion: null,
+        providerBinding: null,
         updatedAt: timestamp
     };
     return validateRoleSessionSet(updated);
@@ -498,7 +512,7 @@ export function validateRoleSessionSet(set) {
             throw new Error("Global Role session set schema version is invalid.");
         }
         if (Object.hasOwn(set, "inFlight")
-            || Object.hasOwn(set, "pendingTurnCompletion")) {
+            || Object.hasOwn(set, "providerBinding")) {
             throw new Error("Global Role session set must not contain Task Role lifecycle fields.");
         }
         const history = set.history;
@@ -513,11 +527,11 @@ export function validateRoleSessionSet(set) {
         }
     }
     else {
-        if (set.schemaVersion !== 4) {
+        if (set.schemaVersion !== 5) {
             throw new Error("Task Role session set schema version is invalid.");
         }
         if (!Object.hasOwn(set, "inFlight")
-            || !Object.hasOwn(set, "pendingTurnCompletion")) {
+            || !Object.hasOwn(set, "providerBinding")) {
             throw new Error("Task Role session set must contain its Turn fence.");
         }
         const taskSet = set;
@@ -546,28 +560,22 @@ export function validateRoleSessionSet(set) {
         const inFlight = taskSet.inFlight === null
             ? null
             : validateTaskRoleInFlight(taskSet.inFlight);
-        const pending = taskSet.pendingTurnCompletion === null
+        const providerBinding = taskSet.providerBinding === null
             ? null
-            : validatePendingTurnCompletion(taskSet.pendingTurnCompletion);
-        if (inFlight === null && pending !== null) {
-            throw new Error("Pending Turn completion requires an in-flight Run.");
-        }
+            : validateProviderRuntimeBinding(taskSet.providerBinding);
         if (inFlight !== null && inFlight.agentId !== set.activeAgentId) {
             throw new Error("Task Role in-flight Run Agent must be active.");
         }
-        if (pending !== null) {
-            assertCompletionOwner(taskSet, pending);
-            if (inFlight?.agentId !== pending.agentId
-                || inFlight.runId !== pending.runId
-                || inFlight.pushedAt === undefined) {
-                throw new Error("Pending Turn completion must match a pushed in-flight Run.");
+        if (providerBinding !== null) {
+            if (inFlight === null || providerBinding.runId !== inFlight.runId) {
+                throw new Error("Provider Runtime Binding must match the in-flight Run.");
             }
-            const session = taskSet.sessions[pending.agentId];
+            const session = taskSet.sessions[inFlight.agentId];
             if (session === undefined) {
-                throw new Error("Pending Turn completion has no Role Agent session.");
+                throw new Error("Provider Runtime Binding has no active Role Agent session.");
             }
-            if (session.nativeSessionId !== pending.nativeSessionId) {
-                throw new Error("Pending Turn native session does not match the Role Agent session.");
+            if (providerBinding.providerNamespace !== builtinDriverIdForAdapter(session.adapterId)) {
+                throw new Error("Provider Runtime Binding namespace does not match the Agent adapter.");
             }
         }
     }

package/dist/executor/executorRegistry.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { createPromptEnvelope, createSessionLaunchRequest } from "../runtime/index.js";
+import { createPromptEnvelope, createRuntimeBinding, createSessionLaunchRequest } from "../runtime/index.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 /**
  * rr13/test: Test-only liveness seam. Integration tests that spawn a real
  * Controller subprocess cannot inject a fake TmuxDeliveryPort, and a saved
@@ -25,6 +26,9 @@ export class ExecutorRegistry {
         this.readiness = readiness;
         this.runtimePorts = runtimePorts;
     }
+    canRouteProviderInput(adapterId) {
+        return adapterId === "codex" && this.runtimePorts?.providerInputRouting !== undefined;
+    }
     async prepareRoleSession(input) {
         if (input.mode === "resume" && !hasText(input.nativeSessionId)) {
             throw new Error("Role session resume requires a native session id.");
@@ -173,7 +177,7 @@ export class ExecutorRegistry {
                 envelope: createPromptEnvelope({
                     id: input.receiptId,
                     source: {
-                        kind: "agent-run",
+                        kind: input.receiptId === formatAgentRunReceiptId(input.delivery.prepared.taskId, runId) ? "agent-run" : "run-input",
                         taskId: input.delivery.prepared.taskId,
                         localId: runId
                     },
@@ -192,6 +196,47 @@ export class ExecutorRegistry {
         }
         return outcome;
     }
+    async routeProviderInput(input) {
+        const prepared = this.requirePrepared(input.delivery.prepared);
+        if (prepared.binding === undefined || this.runtimePorts?.providerInputRouting === undefined) {
+            return "unavailable";
+        }
+        try {
+            return await this.runtimePorts.providerInputRouting.route({
+                binding: prepared.binding,
+                attemptId: input.attemptId,
+                mode: input.mode,
+                text: input.text,
+                fence: input.fence
+            });
+        }
+        finally {
+            // A routed mutation is fenced by its durable inputDelivery, not by this
+            // process-local preparation. Never let a later Turn reuse a cached
+            // Activation binding after this attempt (including an unknown result).
+            this.#prepared.delete(input.delivery.prepared.deliveryId);
+        }
+    }
+    async reconcileProviderInput(input) {
+        if (this.runtimePorts?.providerInputRouting === undefined) {
+            return "unavailable";
+        }
+        return this.runtimePorts.providerInputRouting.reconcile({
+            binding: createRuntimeBinding({
+                id: `metadata:${input.taskId}:${input.roleName}:${input.launchId}`,
+                launchId: input.launchId,
+                owner: { scope: "task", taskId: input.taskId, roleName: input.roleName },
+                agentId: input.agentId,
+                adapterId: input.adapterId,
+                hostRef: "metadata-only",
+                hostCreated: false,
+                nativeSessionId: input.nativeSessionId
+            }),
+            attemptId: input.attemptId,
+            mode: input.mode,
+            fence: input.fence
+        });
+    }
     async notifyOperatorInputOnce(input) {
         const probe = this.readiness(input.adapterId, "operator");
         return this.tmux.sendRoleInputOnceIfReadyAsync === undefined

package/dist/executor/fileRoleLaunchPlanner.js

@@ -384,7 +384,8 @@ export class FileRoleLaunchPlanner {
                 args = addCodexLifecycleHooks(args, launchMode, this.#cliPath);
                 // End option parsing before the opaque prompt so a wakeup beginning
                 // with '-' can never be reinterpreted as a Codex CLI flag.
-                args.push("--", managedRun.input);
+                if (managedRun.pushedAt === undefined)
+                    args.push("--", managedRun.input);
             }
             session = launchMode === "resume"
                 ? readySession(input.agentId, binding.adapterId, resumeNativeSessionId, effective)
@@ -503,7 +504,8 @@ export class FileRoleLaunchPlanner {
             },
             launch: scopedLaunch,
             session,
-            ...((binding.adapterId === "codex" || managedClaudeRun) && input.runId !== undefined
+            ...((binding.adapterId === "codex" && managedRun?.pushedAt === undefined
+                || managedClaudeRun) && input.runId !== undefined
                 ? { initialPromptRunId: input.runId }
                 : {})
         };

package/dist/lifecycle/exactRunTerminalization.js

@@ -253,7 +253,7 @@ export function terminalizeExactTaskRun(store, input, now) {
         }
         else {
             const mailboxSettlement = settleExactWorkExecution(store, roleTarget, { type: "run", taskId: run.taskId, id: run.id });
-            if (mailboxSettlement === "absent" && isReview) {
+            if (mailboxSettlement === "absent" && isReview && run.deliveredAt === undefined) {
                 return obsolete(run, "review-mailbox-missing");
             }
         }
@@ -545,12 +545,6 @@ function matchesSessionFence(sessions, input) {
         if (session?.nativeSessionId !== input.nativeSessionId)
             return false;
     }
-    const pending = sessions.pendingTurnCompletion;
-    if (pending !== null && (pending.agentId !== input.agentId
-        || pending.runId !== input.runId
-        || (input.nativeSessionId !== undefined
-            && pending.nativeSessionId !== input.nativeSessionId)))
-        return false;
     const inFlight = sessions.inFlight;
     return inFlight === null || (inFlight.agentId === input.agentId
         && inFlight.runId === input.runId

package/dist/repository/taskWorkspaceCoordinator.js

@@ -1,6 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
 import { retireConfirmedAbsentInactiveTaskRolePlaceholders } from "../executor/agentExecutor.js";
 import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "./projectMaintenanceLock.js";
 import { WorkspaceCleanupBlockedError } from "./taskWorkspacePreparer.js";
@@ -148,6 +149,7 @@ export class TaskWorkspaceCoordinator {
             if (task.status !== "completed" && task.status !== "retired") {
                 throw new Error(`Task must be completed or retired before archive cleanup: ${task.id}.`);
             }
+            this.#assertNoProviderContinuationWriters(task.id);
             const managedWorkspaces = [...this.store.listManagedWorkspaces(task.id)]
                 .sort((left, right) => managedWorkspaceKey(left.owner)
                 .localeCompare(managedWorkspaceKey(right.owner)));
@@ -314,6 +316,13 @@ export class TaskWorkspaceCoordinator {
         if (current === null || !isDeepStrictEqual(current, expected)) {
             throw new WorkspaceCleanupBlockedError("task-changed", `task:${expected.id}`, true, `Task changed during archive cleanup: ${expected.id}.`);
         }
+        this.#assertNoProviderContinuationWriters(expected.id);
+    }
+    #assertNoProviderContinuationWriters(taskId) {
+        const blockers = blockingProviderContinuations(this.store.listEvents(taskId));
+        if (blockers.length > 0) {
+            throw new WorkspaceCleanupBlockedError("active-run", `task:${taskId}`, true, `Task has Provider continuations that may still write its Workspace: ${taskId}.`);
+        }
     }
     #assertWorkItemRuntimeQuiescent(item) {
         const activeRun = this.store.listAgentRuns(item.taskId)
@@ -367,10 +376,6 @@ export class TaskWorkspaceCoordinator {
             if (sessions?.inFlight !== null && sessions?.inFlight !== undefined) {
                 throw new Error(`Role has unsettled Run state: ${taskId}/${roleName}.`);
             }
-            if (sessions?.pendingTurnCompletion !== null
-                && sessions?.pendingTurnCompletion !== undefined) {
-                throw new Error(`Role has unsettled Run state: ${taskId}/${roleName}.`);
-            }
             if (this.store.getWorkMailbox !== undefined && hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget({ scope: "task", taskId, roleName })))) {
                 throw new Error(`Role has unsettled runtime lifecycle state: ${taskId}/${roleName}.`);
             }

package/dist/runtime/agentDriver.js

@@ -13,6 +13,18 @@ const DELIVERY_MODES = [
     "best-effort",
     "host-only"
 ];
+function requireCapabilityObject(value, label) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`Agent Driver ${label} capabilities must be an object.`);
+    }
+    return value;
+}
+function evidenceQuality(value, label) {
+    if (value !== "exact" && value !== "partial" && value !== "unavailable") {
+        throw new Error(`${label} capability is invalid.`);
+    }
+    return value;
+}
 export function validateAgentDriverCapabilities(input) {
     if (input === null || typeof input !== "object" || Array.isArray(input)) {
         throw new Error("Agent Driver capabilities must be an object.");
@@ -56,6 +68,28 @@ export function validateAgentDriverCapabilities(input) {
     if (!DELIVERY_MODES.includes(observation.delivery)) {
         throw new Error("Agent Driver delivery capability is invalid.");
     }
+    const conversation = requireCapabilityObject(input.conversation, "conversation");
+    evidenceQuality(conversation.persistentIdentity, "Provider Conversation identity");
+    evidenceQuality(conversation.readback, "Provider Conversation readback");
+    if (typeof conversation.crossProcessResume !== "boolean") {
+        throw new Error("Agent Driver Conversation resume capability must be boolean.");
+    }
+    const inputRouting = requireCapabilityObject(input.input, "input");
+    if (typeof inputRouting.startTurn !== "boolean"
+        || !["fenced", "unavailable"].includes(String(inputRouting.steer))
+        || !["fenced", "unavailable"].includes(String(inputRouting.inject))
+        || !["exact", "unavailable"].includes(String(inputRouting.acceptance))
+        || !["exact", "unavailable"].includes(String(inputRouting.idempotency))) {
+        throw new Error("Agent Driver input routing capabilities are invalid.");
+    }
+    const descendants = requireCapabilityObject(input.descendants, "descendants");
+    evidenceQuality(descendants.lineage, "Provider descendant lineage");
+    evidenceQuality(descendants.detachedQuery, "Provider detached descendant query");
+    evidenceQuality(descendants.resultRouting, "Provider descendant result routing");
+    const bounded = requireCapabilityObject(input.bounded, "bounded");
+    if (typeof bounded.structuredTerminal !== "boolean") {
+        throw new Error("Agent Driver bounded terminal capability must be boolean.");
+    }
     return Object.freeze({
         surfaces: Object.freeze(surfaces),
         control: Object.freeze({
@@ -65,6 +99,24 @@ export function validateAgentDriverCapabilities(input) {
             interrupt: control.interrupt,
             stop: control.stop
         }),
+        conversation: Object.freeze({
+            persistentIdentity: conversation.persistentIdentity,
+            crossProcessResume: conversation.crossProcessResume,
+            readback: conversation.readback
+        }),
+        input: Object.freeze({
+            startTurn: inputRouting.startTurn,
+            steer: inputRouting.steer,
+            inject: inputRouting.inject,
+            acceptance: inputRouting.acceptance,
+            idempotency: inputRouting.idempotency
+        }),
+        descendants: Object.freeze({
+            lineage: descendants.lineage,
+            detachedQuery: descendants.detachedQuery,
+            resultRouting: descendants.resultRouting
+        }),
+        bounded: Object.freeze({ structuredTerminal: bounded.structuredTerminal }),
         observation: Object.freeze({
             sessionIdentity: observation.sessionIdentity,
             sessionBootstrap: observation.sessionBootstrap,
@@ -83,17 +135,19 @@ export function managedRuntimeAdmission(capabilities) {
     const missing = [];
     if (!actual.control.start)
         missing.push("start");
-    if (!actual.control.resume)
+    if (!actual.control.resume || !actual.conversation.crossProcessResume)
         missing.push("resume");
-    if (!actual.control.sendTurn)
+    if (!actual.control.sendTurn || !actual.input.startTurn)
         missing.push("send-turn");
     if (!actual.control.interrupt)
         missing.push("interrupt");
     if (!actual.control.stop)
         missing.push("stop");
-    if (actual.observation.sessionIdentity !== "exact")
+    if (actual.observation.sessionIdentity !== "exact"
+        || actual.conversation.persistentIdentity !== "exact")
         missing.push("exact-session-identity");
-    if (actual.observation.promptAcceptance !== "exact")
+    if (actual.observation.promptAcceptance !== "exact"
+        || actual.input.acceptance !== "exact")
         missing.push("exact-prompt-acceptance");
     if (actual.observation.turnLifecycle !== "exact")
         missing.push("exact-turn-lifecycle");
@@ -101,6 +155,17 @@ export function managedRuntimeAdmission(capabilities) {
         ? Object.freeze({ admitted: true })
         : Object.freeze({ admitted: false, missing: Object.freeze(missing) });
 }
+export function boundedRuntimeAdmission(capabilities) {
+    const actual = validateAgentDriverCapabilities(capabilities);
+    const missing = [];
+    if (!actual.control.start)
+        missing.push("start");
+    if (!actual.bounded.structuredTerminal)
+        missing.push("structured-terminal");
+    return missing.length === 0
+        ? Object.freeze({ admitted: true })
+        : Object.freeze({ admitted: false, missing: Object.freeze(missing) });
+}
 export class AgentDriverRegistry {
     #drivers = new Map();
     #driverIdsByAdapter = new Map();
@@ -194,8 +259,22 @@ export function normalizeAgentDriverHookClassification(input) {
     if (input.terminal !== undefined && typeof input.terminal !== "boolean") {
         throw new Error("Agent Driver Hook terminal classification is invalid.");
     }
+    if (input.continuationId !== undefined) {
+        requireText(input.continuationId, "Agent Driver Hook continuation id");
+        if (!Number.isSafeInteger(input.continuationGeneration)
+            || input.continuationGeneration < 1) {
+            throw new Error("Agent Driver Hook continuation generation is invalid.");
+        }
+    }
+    else if (input.continuationGeneration !== undefined) {
+        throw new Error("Agent Driver Hook continuation generation requires an id.");
+    }
     return Object.freeze({
         ...(input.startupSession === undefined ? {} : { startupSession: input.startupSession }),
+        ...(input.continuationId === undefined ? {} : {
+            continuationId: input.continuationId,
+            continuationGeneration: input.continuationGeneration
+        }),
         terminal: input.terminal ?? false
     });
 }