@zq-silk/yui 0.15.7 → 0.15.8

package/dist/controller/runtime.js

@@ -2,8 +2,8 @@ import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeout
 import { resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { controllerSocketPath } from "../core/controllerEndpoint.js";
-import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
-import { hasRuntimeCleanupObligation, runtimeLifecycleSignalKey, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { agentProcessReadinessProbe, ExecutorRegistry } from "../executor/executorRegistry.js";
 import { activeLiveRoleAgentSession, roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { roleSessionMayContinue, effectiveLaunchConfig, resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
@@ -18,15 +18,20 @@ import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
 import { TmuxManager, yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { AgentHostPromptPushAdapter, FileTaskRuntimeIsolation, TmuxSessionHost, ProviderContinuationReconciliationService } from "../runtime/index.js";
 import { startFileTaskController } from "./controller.js";
-import { AgentHostProviderTurnFenceError, FileSchedulerStoreAdapter } from "./fileSchedulerStoreAdapter.js";
+import { AgentHostProviderTurnFenceError, AgentHostProviderSessionBusyError, FileSchedulerStoreAdapter } from "./fileSchedulerStoreAdapter.js";
 import { openSchedulerTelemetry } from "../telemetry/telemetryWiring.js";
 import { createFileArtifactPort, createLinuxProcessPort, DurableJobSupervisor } from "./jobSupervisor.js";
 import { authorizeJobStart } from "./jobControl.js";
 import { createKernelPorts } from "../kernel/kernelPorts.js";
 import { createCapabilityDispatcher } from "./capabilityBridge.js";
+import { createControllerWeb } from "../web/controllerWeb.js";
+import { createWebTaskSurface } from "../web/webTaskSurface.js";
+import { SurfaceContributions } from "../surface/surfaceContributions.js";
+import { TmuxWebTerminalService } from "../web/tmuxWebTerminal.js";
+import { FileTaskWorkflowRuntime } from "./clientRuntime.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
 import { AgentRuntimeObserver } from "./agentRuntimeObserver.js";
-import { AsyncRuntimeEventProcessor, FileRuntimeEventProcessor, createAsyncRuntimeObserver, } from "./runtimeEventProcessor.js";
+import { AsyncRuntimeEventProcessor, FileRuntimeEventProcessor, createAsyncRuntimeObserver } from "./runtimeEventProcessor.js";
 import { RuntimeLaunchCoordinator } from "./runtimeLaunchCoordinator.js";
 import { ephemeralDomainFromEnvironment, recordEphemeralTmuxTarget } from "./domainIdentity.js";
 import { createEphemeralResourceReaper } from "./ephemeralResourceReaper.js";
@@ -42,18 +47,22 @@ import { appendGlobalProcessExitObservation } from "../runtime/globalProcessExit
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { createTaskEvent } from "../event/taskEvent.js";
+import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
+import { taskOwnsManagedWorkspace } from "../task/task.js";
 /** Production composition root for the current SQLite TaskStore + tmux Controller. */
 export async function startFileTaskControllerRuntime(home, options = {}) {
     // The current Home always uses SQLite. The persistence worker is enabled by
     // default; YUI_STORE_WORKER=0/false keeps the same database in-process.
     const useWorker = resolveStoreWorkerEnabledForHome(home, options.environment ?? process.env);
-    const store = options.store
-        ?? (useWorker
+    const ownedStore = options.store === undefined
+        ? (useWorker
             // The worker owns the event-processing hot path while the scheduler uses
             // the synchronous connection. Both point at the same WAL database and
             // serialize via BEGIN IMMEDIATE + busy_timeout.
             ? new SqliteTaskStore(home)
-            : openCurrentTaskStore(home));
+            : openCurrentTaskStore(home))
+        : undefined;
+    const store = options.store ?? ownedStore;
     const homeId = store.getHomeIdentity().homeId;
     const durableConfig = store.getConfig();
     // When the worker backend is active, the db-touching observer folds run in
@@ -70,445 +79,470 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
     const inventoryClient = useWorker
         ? new ResourceInventoryClient()
         : undefined;
-    const schedulerStore = options.schedulerStore
-        ?? new FileSchedulerStoreAdapter(store, openSchedulerTelemetry(home, store.getConfig()));
-    const domainIdentity = options.domainIdentity
-        ?? ephemeralDomainFromEnvironment(options.environment ?? process.env);
-    const planner = options.planner ?? new FileRoleLaunchPlanner(home, store, {
-        environment: options.environment
-    });
-    const tmux = options.tmux ?? new TmuxManager(resolveTmuxBin(durableConfig.tmuxBin), new NodeCommandExecutor(), {
-        yuiHome: home,
-        historyLimit: resolveTmuxHistoryLimit(durableConfig.tmuxHistoryLimit),
-        ...(domainIdentity === undefined
-            ? {}
-            : {
-                onRoleTargetRecorded: (target) => {
-                    if (!recordEphemeralTmuxTarget(home, domainIdentity.token, target)) {
-                        throw new Error(`Ephemeral tmux target fence could not be recorded: ${target}.`);
+    let closeKernel = async () => { };
+    let closeWeb = async () => { };
+    try {
+        const schedulerStore = options.schedulerStore
+            ?? new FileSchedulerStoreAdapter(store, openSchedulerTelemetry(home, store.getConfig()));
+        const domainIdentity = options.domainIdentity
+            ?? ephemeralDomainFromEnvironment(options.environment ?? process.env);
+        const planner = options.planner ?? new FileRoleLaunchPlanner(home, store, {
+            environment: options.environment
+        });
+        const tmux = options.tmux ?? new TmuxManager(resolveTmuxBin(durableConfig.tmuxBin), new NodeCommandExecutor(), {
+            yuiHome: home,
+            historyLimit: resolveTmuxHistoryLimit(durableConfig.tmuxHistoryLimit),
+            ...(domainIdentity === undefined
+                ? {}
+                : {
+                    onRoleTargetRecorded: (target) => {
+                        if (!recordEphemeralTmuxTarget(home, domainIdentity.token, target)) {
+                            throw new Error(`Ephemeral tmux target fence could not be recorded: ${target}.`);
+                        }
                     }
-                }
-            })
-    });
-    const sessionOwners = new SessionOwnerReconciliation({
-        home,
-        store,
-        environment: options.environment,
-        tmux,
-        onWarning: options.onError
-    });
-    // The runtime inbox is also the low-latency discovery source during a
-    // scheduler-owned launch. Waiting only for the post-pass durable projection
-    // would deadlock behind the same pass that is currently starting the host.
-    const runtimeEventInbox = new FileRuntimeEventInbox(home);
-    const catalogs = options.catalogs
-        ?? new AgentConfigurationCatalogService(home, {
-            environment: options.environment ?? process.env
+                })
+        });
+        const sessionOwners = new SessionOwnerReconciliation({
+            home,
+            store,
+            environment: options.environment,
+            tmux,
+            nativeConnection: (taskId, roleName) => planner.planNativeControl(taskId, roleName),
+            onWarning: options.onError
         });
-    const sessionHost = options.sessionHost ?? new TmuxSessionHost(planner, tmux, {
-        validateLaunch: async (request) => {
-            const agent = store.getConfiguredAgent(request.agentId);
-            if (agent === null)
-                return;
-            const resolved = await catalogs.resolve({
-                agent,
-                cwd: request.workspace,
-                config: effectiveLaunchConfig(request.effective)
+        // The runtime inbox is also the low-latency discovery source during a
+        // scheduler-owned launch. Waiting only for the post-pass durable projection
+        // would deadlock behind the same pass that is currently starting the host.
+        const runtimeEventInbox = new FileRuntimeEventInbox(home);
+        const catalogs = options.catalogs
+            ?? new AgentConfigurationCatalogService(home, {
+                environment: options.environment ?? process.env
             });
-            validateAgentLaunchConfiguration(resolved.catalog, effectiveLaunchConfig(request.effective));
-        },
-        waitForNativeSession: async (request, signal) => {
-            const owner = request.owner;
-            if (owner.scope !== "task") {
-                throw new Error("Native session discovery requires a Task runtime owner.");
-            }
-            while (!signal.aborted) {
-                const session = schedulerStore.getRoleSession(owner.taskId, owner.roleName, request.agentId);
-                if (session !== null
-                    && session.runtimeGenerationId === request.runtimeGenerationId
-                    && typeof session.nativeSessionId === "string"
-                    && session.nativeSessionId.trim().length > 0) {
-                    return session.nativeSessionId;
+        const sessionHost = options.sessionHost ?? new TmuxSessionHost(planner, tmux, {
+            validateLaunch: async (request) => {
+                const agent = store.getConfiguredAgent(request.agentId);
+                if (agent === null)
+                    return;
+                const resolved = await catalogs.resolve({
+                    agent,
+                    cwd: request.workspace,
+                    config: effectiveLaunchConfig(request.effective)
+                });
+                validateAgentLaunchConfiguration(resolved.catalog, effectiveLaunchConfig(request.effective));
+            },
+            waitForNativeSession: async (request, signal) => {
+                const owner = request.owner;
+                if (owner.scope !== "task") {
+                    throw new Error("Native session discovery requires a Task runtime owner.");
                 }
-                for (const event of runtimeEventInbox.list()) {
-                    if (event.type === "runtime-observation"
-                        && event.observation.kind === "session.started"
-                        && event.observation.fence.taskId === owner.taskId
-                        && event.observation.fence.roleName === owner.roleName
-                        && event.observation.fence.agentId === request.agentId
-                        && event.observation.fence.runtimeGenerationId === request.runtimeGenerationId
-                        && typeof event.observation.fence.nativeSessionId === "string"
-                        && event.observation.fence.nativeSessionId.trim().length > 0) {
-                        return event.observation.fence.nativeSessionId;
+                while (!signal.aborted) {
+                    const session = schedulerStore.getRoleSession(owner.taskId, owner.roleName, request.agentId);
+                    if (session !== null && session.status === "active"
+                        && session.adapterId === request.adapterId
+                        && typeof session.nativeSessionId === "string" && session.nativeSessionId.trim().length > 0) {
+                        return session.nativeSessionId;
+                    }
+                    for (const event of runtimeEventInbox.list()) {
+                        if (event.type === "runtime-observation" && event.observation.kind === "session.started"
+                            && event.observation.fence.taskId === owner.taskId
+                            && event.observation.fence.roleName === owner.roleName
+                            && event.observation.fence.agentId === request.agentId
+                            && event.observation.fence.runId === request.runId
+                            && typeof event.observation.fence.nativeSessionId === "string"
+                            && event.observation.fence.nativeSessionId.trim().length > 0) {
+                            return event.observation.fence.nativeSessionId;
+                        }
                     }
+                    await abortableDelay(50, signal);
                 }
-                await abortableDelay(50, signal);
-            }
-            throw new Error("Native session discovery was aborted.");
-        },
-        inactivityTimeoutMs: resolveAgentLaunchInactivityTimeoutSeconds(durableConfig.agentLaunchInactivityTimeoutSeconds) * 1_000,
-        onHostCreated: ({ binding, pane }) => {
-            sessionOwners.recordHostOwner({
-                owner: binding.owner,
-                agentId: binding.agentId,
-                adapterId: binding.adapterId,
-                runtimeGenerationId: binding.runtimeGenerationId,
-                ...(binding.nativeSessionId === undefined
-                    ? {}
-                    : { nativeSessionId: binding.nativeSessionId }),
-                ...(pane.pid === undefined ? {} : { panePid: pane.pid })
-            });
-        }
-    });
-    const promptPush = options.promptPush
-        ?? new AgentHostPromptPushAdapter(home);
-    const runtimeIsolation = options.runtimeIsolation
-        ?? new FileTaskRuntimeIsolation({
-            // A sibling of the exact control Home keeps provider data/cache/tmp out
-            // of both the shared control plane and every managed Git workspace.
-            runtimeRoot: `${resolve(home)}.task-runtimes`,
-            controlPlane: {
-                yuiHome: home,
-                controllerSocketPath: controllerSocketPath(homeId),
-                tmuxNamespace: yuiTmuxServerName(home),
-                globalInstallPaths: [process.execPath]
+                throw new Error("Native session discovery was aborted.");
+            },
+            inactivityTimeoutMs: resolveAgentLaunchInactivityTimeoutSeconds(durableConfig.agentLaunchInactivityTimeoutSeconds) * 1_000,
+            onHostCreated: ({ binding, pane }) => {
+                sessionOwners.recordHostOwner({
+                    owner: binding.owner,
+                    agentId: binding.agentId,
+                    adapterId: binding.adapterId,
+                    ...(binding.nativeSessionId === undefined
+                        ? {}
+                        : { nativeSessionId: binding.nativeSessionId }),
+                    ...(pane.pid === undefined ? {} : { panePid: pane.pid })
+                });
             }
         });
-    const lifecycleHost = {
-        inspectOwner: (owner) => (sessionHost.inspectOwner(owner)),
-        ...(sessionHost.inspectOwners === undefined
-            ? {}
-            : {
-                inspectOwners: (owners) => sessionHost.inspectOwners(owners)
-            }),
-        stopOwner: (owner) => {
-            // Issue 03: the durable `stopped` transition is gated on physical
-            // exit proof. A blocked result keeps the Session non-terminal and
-            // preserves owner records for Operator recovery.
-            return sessionOwners.terminateOwner(owner).then((result) => {
-                if (result.outcome === "stop-blocked") {
-                    (options.onError ?? (() => undefined))(new Error(`Role runtime cleanup could not prove physical exit: ${result.remaining
-                        .map(({ record, detail }) => `${record.runtimeGenerationId}: ${detail}`)
-                        .join("; ")}`));
+        const promptPush = options.promptPush
+            ?? new AgentHostPromptPushAdapter(home);
+        const runtimeIsolation = options.runtimeIsolation
+            ?? new FileTaskRuntimeIsolation({
+                // A sibling of the exact control Home keeps provider data/cache/tmp out
+                // of both the shared control plane and every managed Git workspace.
+                runtimeRoot: `${resolve(home)}.task-runtimes`,
+                controlPlane: {
+                    yuiHome: home,
+                    controllerSocketPath: controllerSocketPath(homeId),
+                    tmuxNamespace: yuiTmuxServerName(home),
+                    globalInstallPaths: [process.execPath]
                 }
-                return result.outcome === "stop-confirmed";
             });
-        },
-        ...(runtimeIsolation.cleanupTaskLaunch === undefined
-            ? {}
-            : {
-                cleanupTaskLaunch: (input) => runtimeIsolation.cleanupTaskLaunch(input)
-            })
-    };
-    const resourceActivity = createRuntimeResourceActivityTracker();
-    let runningRuntime;
-    let runningController;
-    const signalRuntimeCleanup = (target) => {
-        runningRuntime?.signal(runtimeLifecycleSignalKey(target.kind === "role-runtime"
-            ? {
-                scope: "task",
-                taskId: target.taskId,
-                roleName: target.roleName
-            }
-            : { scope: "global", roleName: target.roleName }));
-    };
-    const launchCoordinator = new RuntimeLaunchCoordinator(schedulerStore, sessionHost, {
-        ...(options.now === undefined ? {} : { now: options.now }),
-        assertCurrent: (request) => {
-            assertRuntimeLaunchRequestCurrent(store, request);
-        },
-        onCleanupRequired: signalRuntimeCleanup,
-        runtimeIsolation
-    });
-    // One inventory scan per scheduler pass. When the inventory worker is active
-    // the blocking /proc scan runs there; otherwise it runs on the main thread.
-    const scanInventory = (panes) => inventoryClient !== undefined
-        ? inventoryClient.scan({
-            currentHome: home,
-            scope: "current",
-            panes,
-            ...(options.environment === undefined
-                ? {}
-                : { environment: options.environment })
-        })
-        : scanControllerResourceInventory({
-            currentHome: home,
-            scope: "current",
-            panes,
-            tmuxBin: resolveTmuxBin(store.getConfig().tmuxBin),
-            ...(options.environment === undefined
+        const lifecycleHost = {
+            inspectOwner: (owner) => (sessionHost.inspectOwner(owner)),
+            ...(sessionHost.inspectOwners === undefined
                 ? {}
-                : { environment: options.environment })
+                : {
+                    inspectOwners: (owners) => sessionHost.inspectOwners(owners)
+                }),
+            stopOwner: (owner) => {
+                // Issue 03: the durable `stopped` transition is gated on physical
+                // exit proof. A blocked result keeps the Session non-terminal and
+                // preserves owner records for Operator recovery.
+                return sessionOwners.terminateOwner(owner).then((result) => {
+                    if (result.outcome === "stop-blocked") {
+                        (options.onError ?? (() => undefined))(new Error(`Role runtime cleanup could not prove physical exit: ${result.remaining
+                            .map(({ record, detail }) => `PID ${record.providerRoot.pid}: ${detail}`)
+                            .join("; ")}`));
+                    }
+                    return result.outcome === "stop-confirmed";
+                });
+            },
+        };
+        const resourceActivity = createRuntimeResourceActivityTracker();
+        let runningRuntime;
+        let runningController;
+        const launchCoordinator = new RuntimeLaunchCoordinator(schedulerStore, sessionHost, {
+            ...(options.now === undefined ? {} : { now: options.now }),
+            assertCurrent: (request) => {
+                assertRuntimeLaunchRequestCurrent(store, request);
+            },
+            runtimeIsolation
         });
-    const delivery = options.delivery ?? new ExecutorRegistry(planner, tmux, agentProcessReadinessProbe, {
-        sessionHost,
-        promptPush,
-        launchCoordinator,
-        roleResourceInventory: async (panes, inputs) => {
-            const inventory = await scanInventory(panes);
-            return inventory.resources.flatMap((resource) => {
-                if (resource.kind !== "agent-session")
-                    return [];
-                const owner = resource.owner;
-                if (owner.kind !== "task-role")
-                    return [];
-                const active = resource.state === "running" || resource.state === "current";
-                const input = inputs.find((candidate) => (candidate.taskId === owner.taskId
-                    && candidate.roleName === owner.roleName));
-                if (input === undefined)
-                    return [];
-                const identity = owner.turnId === undefined
-                    || owner.adapterId === undefined
-                    || (owner.nativeSessionId === undefined && owner.runtimeGenerationId === undefined)
-                    || (owner.nativeSessionId !== undefined && owner.nativeSessionId.trim().length === 0)
-                    || (owner.runtimeGenerationId !== undefined && owner.runtimeGenerationId.trim().length === 0)
-                    ? undefined
-                    : {
-                        taskId: owner.taskId,
-                        roleName: owner.roleName,
-                        turnId: owner.turnId,
-                        agentId: owner.agentId,
-                        adapterId: owner.adapterId,
-                        ...(owner.nativeSessionId === undefined
-                            ? {}
-                            : { nativeSessionId: owner.nativeSessionId }),
-                        ...(owner.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: owner.runtimeGenerationId })
-                    };
-                const changed = !active || input.turnId === undefined
-                    ? false
-                    : resourceActivity({
-                        taskId: input.taskId,
-                        roleName: input.roleName,
-                        turnId: input.turnId,
-                        agentId: input.agentId,
-                        adapterId: input.adapterId,
-                        ...(input.nativeSessionId === undefined
-                            ? {}
-                            : { nativeSessionId: input.nativeSessionId }),
-                        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId })
-                    }, resource);
-                return [{
-                        taskId: owner.taskId,
-                        roleName: owner.roleName,
-                        resource: {
-                            observedAt: inventory.observedAt,
-                            active,
-                            changed: active && changed,
-                            ...(identity === undefined ? {} : { identity }),
-                            ...(input.progressAt === undefined ? {} : { progressAt: input.progressAt }),
-                            cpuTimeMs: resource.cpuTimeMs,
-                            ...(resource.ioReadBytes === undefined
-                                ? {}
-                                : { ioReadBytes: resource.ioReadBytes }),
-                            ...(resource.ioWriteBytes === undefined
-                                ? {}
-                                : { ioWriteBytes: resource.ioWriteBytes }),
-                            rssBytes: resource.rssBytes
-                        }
-                    }];
-            });
-        }
-    });
-    const workspacePreparer = options.workspacePreparer
-        ?? new FileTaskWorkspacePreparer(home, store);
-    const resourceReaper = options.resourceReaper
-        ?? (domainIdentity === undefined
-            ? undefined
-            : createEphemeralResourceReaper({
+        // One inventory scan per scheduler pass. When the inventory worker is active
+        // the blocking /proc scan runs there; otherwise it runs on the main thread.
+        const scanInventory = (panes) => inventoryClient !== undefined
+            ? inventoryClient.scan({
+                currentHome: home,
+                scope: "current",
+                panes,
+                ...(options.environment === undefined
+                    ? {}
+                    : { environment: options.environment })
+            })
+            : scanControllerResourceInventory({
                 currentHome: home,
-                // The detached Controller owns one YUI_HOME. Keep automatic
-                // recovery bounded to that domain; cross-home cleanup remains an
-                // explicit `controller cleanup --all` inventory operation.
                 scope: "current",
-                environment: options.environment,
+                panes,
                 tmuxBin: resolveTmuxBin(store.getConfig().tmuxBin),
-                // When the worker backend is active, the reaper's scan runs in the
-                // inventory worker too (same cadence, same inventory shape).
-                ...(inventoryClient === undefined
+                ...(options.environment === undefined
                     ? {}
-                    : {
-                        scan: () => inventoryClient.scan({
-                            currentHome: home,
-                            scope: "current",
-                            ...(options.environment === undefined
+                    : { environment: options.environment })
+            });
+        const delivery = options.delivery ?? new ExecutorRegistry(planner, tmux, agentProcessReadinessProbe, {
+            sessionHost,
+            promptPush,
+            launchCoordinator,
+            roleResourceInventory: async (panes, inputs) => {
+                const inventory = await scanInventory(panes);
+                return inventory.resources.flatMap((resource) => {
+                    if (resource.kind !== "agent-session")
+                        return [];
+                    const owner = resource.owner;
+                    if (owner.kind !== "task-role")
+                        return [];
+                    const active = resource.state === "running" || resource.state === "current";
+                    const input = inputs.find((candidate) => (candidate.taskId === owner.taskId
+                        && candidate.roleName === owner.roleName));
+                    if (input === undefined)
+                        return [];
+                    const identity = owner.runId === undefined || owner.adapterId === undefined || (owner.nativeSessionId === undefined) || (owner.nativeSessionId !== undefined && owner.nativeSessionId.trim().length === 0)
+                        ? undefined
+                        : {
+                            taskId: owner.taskId,
+                            roleName: owner.roleName,
+                            runId: owner.runId,
+                            agentId: owner.agentId,
+                            adapterId: owner.adapterId,
+                            ...(owner.nativeSessionId === undefined
+                                ? {}
+                                : { nativeSessionId: owner.nativeSessionId }),
+                        };
+                    const changed = !active || input.runId === undefined
+                        ? false
+                        : resourceActivity({
+                            taskId: input.taskId,
+                            roleName: input.roleName,
+                            runId: input.runId,
+                            agentId: input.agentId,
+                            adapterId: input.adapterId,
+                            ...(input.nativeSessionId === undefined
                                 ? {}
-                                : { environment: options.environment })
+                                : { nativeSessionId: input.nativeSessionId }),
+                        }, resource);
+                    return [{
+                            taskId: owner.taskId,
+                            roleName: owner.roleName,
+                            resource: {
+                                observedAt: inventory.observedAt,
+                                active,
+                                changed: active && changed,
+                                ...(identity === undefined ? {} : { identity }),
+                                ...(input.progressAt === undefined ? {} : { progressAt: input.progressAt }),
+                                cpuTimeMs: resource.cpuTimeMs,
+                                ...(resource.ioReadBytes === undefined
+                                    ? {}
+                                    : { ioReadBytes: resource.ioReadBytes }),
+                                ...(resource.ioWriteBytes === undefined
+                                    ? {}
+                                    : { ioWriteBytes: resource.ioWriteBytes }),
+                                rssBytes: resource.rssBytes
+                            }
+                        }];
+                });
+            }
+        });
+        const workspacePreparer = options.workspacePreparer
+            ?? new FileTaskWorkspacePreparer(home, store);
+        const resourceReaper = options.resourceReaper
+            ?? (domainIdentity === undefined
+                ? undefined
+                : createEphemeralResourceReaper({
+                    currentHome: home,
+                    // The detached Controller owns one YUI_HOME. Keep automatic
+                    // recovery bounded to that domain; cross-home cleanup remains an
+                    // explicit `controller cleanup --all` inventory operation.
+                    scope: "current",
+                    environment: options.environment,
+                    tmuxBin: resolveTmuxBin(store.getConfig().tmuxBin),
+                    // When the worker backend is active, the reaper's scan runs in the
+                    // inventory worker too (same cadence, same inventory shape).
+                    ...(inventoryClient === undefined
+                        ? {}
+                        : {
+                            scan: () => inventoryClient.scan({
+                                currentHome: home,
+                                scope: "current",
+                                ...(options.environment === undefined
+                                    ? {}
+                                    : { environment: options.environment })
+                            })
                         })
-                    })
-            }));
-    // Issue 10: automatic Resource GC. The runner self-skips unless
-    // resourcesGcMode=quarantine and resourcesGcAutoQuarantine=true, so wiring
-    // it unconditionally costs one config read per full pass when disabled.
-    const resourceAutoGc = options.resourceAutoGc
-        ?? createResourceAutoGc({
-            home,
-            store,
-            environment: options.environment
+                }));
+        // Issue 10: automatic Resource GC. The runner self-skips unless
+        // resourcesGcMode=quarantine and resourcesGcAutoQuarantine=true, so wiring
+        // it unconditionally costs one config read per full pass when disabled.
+        const resourceAutoGc = options.resourceAutoGc
+            ?? createResourceAutoGc({
+                home,
+                store,
+                environment: options.environment
+            });
+        const lifecycleDispatcher = createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, options.dispatcher, launchCoordinator, planner);
+        // Process-exit observations are persisted by the Agent Host before socket
+        // delivery. Drain them while this Controller is still the only storage
+        // writer and before it begins accepting new work after a handover.
+        await replayRuntimeProcessExitOutbox(home, async (observation) => {
+            await lifecycleDispatcher("runtime.process-exit-observe", observation);
         });
-    const lifecycleDispatcher = createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, options.dispatcher, signalRuntimeCleanup, launchCoordinator, planner);
-    // Process-exit observations are persisted by the Agent Host before socket
-    // delivery. Drain them while this Controller is still the only storage
-    // writer and before it begins accepting new work after a handover.
-    await replayRuntimeProcessExitOutbox(home, async (observation) => {
-        await lifecycleDispatcher("runtime.process-exit-observe", observation);
-    });
-    // f7/rr5: This same inbox feeds the supervisor's terminal channel and the
-    // runtime event processor. When a Job reaches a terminal state, the
-    // supervisor enqueues a durable-job-terminal event; the processor drains it
-    // on the next pass, waking the Controller immediately instead of waiting for
-    // the poll interval.
-    const kernel = createKernelPorts(store, createLinuxProcessPort(), (taskId) => {
-        runningRuntime?.signal(`task:${taskId}`);
-    });
-    const jobSupervisor = new DurableJobSupervisor({
-        store: schedulerStore,
-        process: kernel.runner,
-        artifacts: createFileArtifactPort(home),
-        authorizeStart: (job) => authorizeJobStart(store, job),
-        // rr6/f1: Bounded supervision wake. The supervisor signals the Controller
-        // after spawning a runner (queued→running adoption) and when a runner
-        // exits (terminal harvest), so a quick job converges without waiting for
-        // the recovery interval. Closes over runningRuntime, which is assigned
-        // once startFileTaskController resolves; a wake during shutdown is a
-        // no-op. The recovery interval stays the cross-restart fallback.
-        wake: (taskId) => {
-            try {
-                runningRuntime?.signal(`task:${taskId}`);
-            }
-            catch {
-                // Controller stopped; the recovery interval remains the fallback.
-            }
-        },
-        terminalEvents: {
-            deliverTerminalEvent(notice) {
+        // f7/rr5: This same inbox feeds the supervisor's terminal channel and the
+        // runtime event processor. When a Job reaches a terminal state, the
+        // supervisor enqueues a durable-job-terminal event; the processor drains it
+        // on the next pass, waking the Controller immediately instead of waiting for
+        // the poll interval.
+        const kernel = createKernelPorts(store, createLinuxProcessPort(), (taskId) => {
+            runningRuntime?.signal(`task:${taskId}`);
+        });
+        closeKernel = () => kernel.close();
+        const webWorkflow = new FileTaskWorkflowRuntime(home, store, schedulerStore, planner, tmux, workspacePreparer, {
+            environment: options.environment ?? process.env, onError: options.onError
+        });
+        const webSurface = createWebTaskSurface(store, { runtime: {
+                notifyStateChanged: (taskId) => runningRuntime?.signal(`task:${taskId}`),
+                notifyMailboxChanged: (target) => {
+                    if (target.kind === "role")
+                        runningRuntime?.signal(`role:${target.taskId}/${target.roleName}`);
+                    else if (target.kind === "task")
+                        runningRuntime?.signal(`task:${target.taskId}`);
+                },
+                reconcileTask: (taskId) => runningRuntime?.signal(`task:${taskId}`)
+            }, yuiHome: home });
+        const surfaces = new SurfaceContributions(kernel.capabilities.registry);
+        const web = createControllerWeb(store, {
+            surface: webSurface,
+            answerInput: async ({ taskId, inputId, answer }) => webSurface.answer(taskId, inputId, answer),
+            panels: {
+                list: (taskId) => surfaces.listPanels(kernel.capabilities.authenticateWebQuery(taskId)),
+                read: (taskId, ref, input) => surfaces.readPanel(kernel.capabilities.authenticateWebQuery(taskId), ref, input)
+            },
+            terminal: new TmuxWebTerminalService({
+                yuiHome: home, tmuxBin: resolveTmuxBin(store.getConfig().tmuxBin), tmux,
+                prepareGlobalRole: (roleName) => webWorkflow.prepareGlobalRoleEnter(roleName),
+                environment: options.environment ?? process.env, onError: options.onError
+            })
+        });
+        closeWeb = () => web.close();
+        const jobSupervisor = new DurableJobSupervisor({
+            store: schedulerStore,
+            process: kernel.runner,
+            artifacts: createFileArtifactPort(home),
+            authorizeStart: (job) => authorizeJobStart(store, job),
+            // rr6/f1: Bounded supervision wake. The supervisor signals the Controller
+            // after spawning a runner (queued→running adoption) and when a runner
+            // exits (terminal harvest), so a quick job converges without waiting for
+            // the recovery interval. Closes over runningRuntime, which is assigned
+            // once startFileTaskController resolves; a wake during shutdown is a
+            // no-op. The recovery interval stays the cross-restart fallback.
+            wake: (taskId) => {
                 try {
-                    runtimeEventInbox.enqueueDurableJobTerminal({
-                        scope: "task",
-                        taskId: notice.taskId,
-                        jobId: notice.jobId,
-                        status: notice.status,
-                        outcome: notice.outcome
-                    });
+                    runningRuntime?.signal(`task:${taskId}`);
                 }
-                catch (error) {
-                    // Best-effort terminal channel: the terminal transition already
-                    // committed. A delivery failure must not fail the reconcile pass.
-                    (options.onError ?? (() => undefined))(error);
+                catch {
+                    // Controller stopped; the recovery interval remains the fallback.
                 }
-            }
-        },
-        onError: options.onError
-    });
-    const jobControl = kernel.jobs;
-    const continuationReconciler = options.continuationMetadata === undefined
-        ? undefined
-        : new ProviderContinuationReconciliationService(store, schedulerStore, options.continuationMetadata);
-    const running = await startFileTaskController(home, schedulerStore, delivery, lifecycleDispatcher, {
-        intervalMs: options.intervalMs
-            ?? reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds),
-        signalWindowMs: options.signalWindowMs,
-        taskConcurrency: options.taskConcurrency
-            ?? resolveControllerTaskConcurrency(durableConfig.controllerTaskConcurrency),
-        deliveryRetryMs: options.deliveryRetryMs,
-        deliveryRetryLimit: options.deliveryRetryLimit,
-        deliveryTimeoutMs: options.deliveryTimeoutMs
-            ?? resolveDeliveryTimeoutSeconds(durableConfig.deliveryTimeoutSeconds) * 1_000,
-        stallWindowMs: options.stallWindowMs
-            ?? resolveRuntimeHealth(durableConfig.runtimeHealth).stallWindowMs,
-        diagnosticAfterMs: options.diagnosticAfterMs
-            ?? resolveRuntimeHealth(durableConfig.runtimeHealth).diagnosticAfterMs,
-        now: options.now,
-        onError: options.onError,
-        lifecycleHost,
-        jobSupervisor,
-        jobControl,
-        capabilityDispatcher: createCapabilityDispatcher(kernel.capabilities),
-        ...(continuationReconciler === undefined ? {} : { continuationReconciler }),
-        ...(resourceReaper === undefined ? {} : { resourceReaper }),
-        resourceAutoGc,
-        onExpiredEphemeralDomain: (domain) => {
-            if (domain.yuiHome !== home)
-                return;
-            void runningController?.close().catch(options.onError ?? (() => undefined));
-        },
-        workspacePreparer,
-        runtimeEventProcessor: options.runtimeEventProcessor
-            ?? (useWorker && asyncStoreClient !== undefined
-                ? new AsyncRuntimeEventProcessor(runtimeEventInbox, createAsyncRuntimeObserver((method, args) => asyncStoreClient.invokeObserver(method, args)))
-                : new FileRuntimeEventProcessor(runtimeEventInbox, schedulerStore)),
-        runtimeObserver: options.runtimeObserver
-            ?? new AgentRuntimeObserver(store, runtimeEventInbox),
-        domainIdentity,
-        ...(options.configuration !== undefined
-            ? { configuration: options.configuration }
-            : options.intervalMs === undefined
-                ? {
-                    configuration: {
-                        reconciliationIntervalMs: () => reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds)
+            },
+            terminalEvents: {
+                deliverTerminalEvent(notice) {
+                    try {
+                        runtimeEventInbox.enqueueDurableJobTerminal({
+                            scope: "task",
+                            taskId: notice.taskId,
+                            jobId: notice.jobId,
+                            status: notice.status,
+                            outcome: notice.outcome
+                        });
+                    }
+                    catch (error) {
+                        // Best-effort terminal channel: the terminal transition already
+                        // committed. A delivery failure must not fail the reconcile pass.
+                        (options.onError ?? (() => undefined))(error);
                     }
                 }
-                : {})
-    });
-    runningController = running;
-    runningRuntime = running.runtime;
-    // Issue 03: read-only startup reconciliation. Surfaces durable/physical
-    // Session mismatches (including generations whose durable map was cleared)
-    // without changing stop or archive behavior. Cleanup stays an explicit
-    // Operator action in exact-owner-cleanup mode.
-    try {
-        const startupReport = sessionOwners.report();
-        if (startupReport.summary.livePhysicalRoots > 0) {
-            (options.onError ?? (() => undefined))(new Error(`Session reconciliation: ${startupReport.summary.livePhysicalRoots} `
-                + `live physical root(s) across ${startupReport.summary.owners} owner record(s); `
-                + "run `yui session reconcile --report` for details."));
+            },
+            onError: options.onError
+        });
+        const jobControl = kernel.jobs;
+        const continuationReconciler = options.continuationMetadata === undefined
+            ? undefined
+            : new ProviderContinuationReconciliationService(store, schedulerStore, options.continuationMetadata);
+        const running = await startFileTaskController(home, schedulerStore, delivery, (method, params) => method === "web.start" || method === "web.stop" || method === "web.status"
+            ? web.dispatch(method, params) : lifecycleDispatcher(method, params), {
+            intervalMs: options.intervalMs
+                ?? reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds),
+            signalWindowMs: options.signalWindowMs,
+            taskConcurrency: options.taskConcurrency
+                ?? resolveControllerTaskConcurrency(durableConfig.controllerTaskConcurrency),
+            deliveryRetryMs: options.deliveryRetryMs,
+            deliveryRetryLimit: options.deliveryRetryLimit,
+            deliveryTimeoutMs: options.deliveryTimeoutMs
+                ?? resolveDeliveryTimeoutSeconds(durableConfig.deliveryTimeoutSeconds) * 1_000,
+            stallWindowMs: options.stallWindowMs
+                ?? resolveRuntimeHealth(durableConfig.runtimeHealth).stallWindowMs,
+            diagnosticAfterMs: options.diagnosticAfterMs
+                ?? resolveRuntimeHealth(durableConfig.runtimeHealth).diagnosticAfterMs,
+            now: options.now,
+            onError: options.onError,
+            lifecycleHost,
+            jobSupervisor,
+            jobControl,
+            capabilityDispatcher: createCapabilityDispatcher(kernel.capabilities),
+            ...(continuationReconciler === undefined ? {} : { continuationReconciler }),
+            ...(resourceReaper === undefined ? {} : { resourceReaper }),
+            resourceAutoGc,
+            onExpiredEphemeralDomain: (domain) => {
+                if (domain.yuiHome !== home)
+                    return;
+                void runningController?.close().catch(options.onError ?? (() => undefined));
+            },
+            workspacePreparer,
+            runtimeEventProcessor: options.runtimeEventProcessor
+                ?? (useWorker && asyncStoreClient !== undefined
+                    ? new AsyncRuntimeEventProcessor(runtimeEventInbox, createAsyncRuntimeObserver((method, args) => asyncStoreClient.invokeObserver(method, args)))
+                    : new FileRuntimeEventProcessor(runtimeEventInbox, schedulerStore)),
+            runtimeObserver: options.runtimeObserver
+                ?? new AgentRuntimeObserver(store, runtimeEventInbox),
+            domainIdentity,
+            ...(options.configuration !== undefined
+                ? { configuration: options.configuration }
+                : options.intervalMs === undefined
+                    ? {
+                        configuration: {
+                            reconciliationIntervalMs: () => reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds)
+                        }
+                    }
+                    : {})
+        });
+        runningController = running;
+        runningRuntime = running.runtime;
+        // Issue 03: read-only startup reconciliation. Surfaces durable/physical
+        // Session mismatches (including generations whose durable map was cleared)
+        // without changing stop or archive behavior. Cleanup stays an explicit
+        // Operator action in exact-owner-cleanup mode.
+        try {
+            const startupReport = sessionOwners.report();
+            if (startupReport.summary.livePhysicalRoots > 0) {
+                (options.onError ?? (() => undefined))(new Error(`Session reconciliation: ${startupReport.summary.livePhysicalRoots} `
+                    + `live physical root(s) across ${startupReport.summary.owners} owner record(s); `
+                    + "run `yui session reconcile --report` for details."));
+            }
+        }
+        catch (error) {
+            (options.onError ?? (() => undefined))(error);
         }
+        let resourceClose;
+        const closeResources = () => {
+            resourceClose ??= Promise.all([
+                web.close(),
+                kernel.close(),
+                asyncStoreClient?.close() ?? Promise.resolve(),
+                inventoryClient?.close() ?? Promise.resolve()
+            ]).then(() => undefined).finally(() => {
+                ownedStore?.close();
+            });
+            return resourceClose;
+        };
+        const closed = running.closed.then(closeResources);
+        return {
+            ...running,
+            kernel,
+            closed,
+            close: async () => {
+                try {
+                    await running.close();
+                }
+                finally {
+                    // RPC-driven Controller stops resolve `running.closed` without calling
+                    // this wrapper. Share one cleanup promise so both lifecycle paths
+                    // release the worker connections before the process can linger.
+                    await closeResources();
+                }
+            },
+            store,
+            schedulerStore,
+            planner,
+            tmux,
+            delivery,
+            sessionHost,
+            promptPush,
+            runtimeIsolation,
+            workspacePreparer
+        };
     }
     catch (error) {
-        (options.onError ?? (() => undefined))(error);
-    }
-    let resourceClose;
-    const closeResources = () => {
-        resourceClose ??= Promise.all([
-            kernel.close(),
+        // The socket may never have opened. Startup failure must still release
+        // this attempt's workers/instances instead of leaving an uncallable process.
+        await Promise.allSettled([
+            closeWeb(),
+            closeKernel(),
             asyncStoreClient?.close() ?? Promise.resolve(),
             inventoryClient?.close() ?? Promise.resolve()
-        ]).then(() => undefined);
-        return resourceClose;
-    };
-    const closed = running.closed.then(closeResources);
-    return {
-        ...running,
-        kernel,
-        closed,
-        close: async () => {
-            try {
-                await running.close();
-            }
-            finally {
-                // RPC-driven Controller stops resolve `running.closed` without calling
-                // this wrapper. Share one cleanup promise so both lifecycle paths
-                // release the worker connections before the process can linger.
-                await closeResources();
-            }
-        },
-        store,
-        schedulerStore,
-        planner,
-        tmux,
-        delivery,
-        sessionHost,
-        promptPush,
-        runtimeIsolation,
-        workspacePreparer
-    };
+        ]);
+        ownedStore?.close();
+        throw error;
+    }
 }
-export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, fallback, onCleanupRequired, sharedLaunchCoordinator, environmentRefresher) {
+export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, fallback, sharedLaunchCoordinator, environmentRefresher) {
     const launchCoordinator = sharedLaunchCoordinator
         ?? new RuntimeLaunchCoordinator(schedulerStore, sessionHost, {
             assertCurrent: (request) => {
                 assertRuntimeLaunchRequestCurrent(store, request);
             },
-            onCleanupRequired
         });
     const lifecycleTails = new Map();
     return async (method, params) => {
@@ -528,9 +562,8 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 schedulerStore.beginAgentHostProviderTurn({
                     taskId: value.taskId,
                     roleName: value.roleName,
-                    ...(value.turnId === undefined ? {} : { turnId: value.turnId }),
+                    ...(value.runId === undefined ? {} : { runId: value.runId }),
                     agentId: value.agentId,
-                    runtimeGenerationId: value.runtimeGenerationId,
                     nativeSessionId: value.nativeSessionId,
                     attemptId: value.attemptId,
                     authorityEpoch: value.authorityEpoch,
@@ -540,6 +573,8 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 });
             }
             catch (error) {
+                if (error instanceof AgentHostProviderSessionBusyError)
+                    throw error;
                 if (error instanceof AgentHostProviderTurnFenceError) {
                     throw applicationError("INVALID_PARAMS", error.message);
                 }
@@ -552,7 +587,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             const status = params.status;
             const reason = params.reason;
             const raw = params.raw;
-            if ((status !== "rejected" && status !== "delivery-unknown")
+            if ((status !== "rejected" && status !== "deferred" && status !== "delivery-unknown")
                 || typeof reason !== "string" || reason.trim().length === 0
                 || typeof raw !== "string" || raw.trim().length === 0) {
                 throw applicationError("INVALID_PARAMS", "Provider Turn resolution is invalid.");
@@ -560,7 +595,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             schedulerStore.resolveAgentHostProviderTurnSubmission({
                 taskId: value.taskId,
                 roleName: value.roleName,
-                ...(value.turnId === undefined ? {} : { turnId: value.turnId }),
+                ...(value.runId === undefined ? {} : { runId: value.runId }),
                 attemptId: value.attemptId,
                 status,
                 reason,
@@ -571,9 +606,9 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
         }
         if (method === "runtime.process-exit-observe") {
             const observation = validateRuntimeProcessExitObservation(params);
-            const run = observation.taskId === undefined || observation.turnId === undefined
+            const run = observation.taskId === undefined || observation.runId === undefined
                 ? null
-                : store.getTurn(observation.taskId, observation.turnId);
+                : store.getRun(observation.taskId, observation.runId);
             const globalRole = observation.taskId === undefined
                 ? store.getGlobalRole(observation.roleName)
                 : null;
@@ -582,31 +617,29 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             const driver = adapterId === undefined
                 ? null
                 : builtinAgentDriverRegistry().findByAdapterId(adapterId);
-            const turnTerminalObserved = observation.taskId !== undefined
-                && observation.turnId !== undefined
+            const runTerminalObserved = observation.taskId !== undefined
+                && observation.runId !== undefined
                 && store.listEvents(observation.taskId).some((event) => {
                     const runtime = runtimeObservationFromTaskEvent(event);
                     return runtime !== null
-                        && runtime.fence.turnId === observation.turnId
+                        && runtime.fence.runId === observation.runId
                         && ["turn.completed", "turn.failed", "turn.cancelled"].includes(runtime.kind)
                         && Date.parse(runtime.receivedAt) <= Date.parse(observation.observedAt);
                 });
-            const turnFailureObserved = observation.taskId !== undefined
-                && observation.turnId !== undefined
-                && store.listEvents(observation.taskId).some((event) => {
-                    const runtime = runtimeObservationFromTaskEvent(event);
-                    return runtime !== null
-                        && runtime.fence.turnId === observation.turnId
-                        && runtime.fence.runtimeGenerationId === observation.runtimeGenerationId
-                        && runtime.kind === "turn.failed"
-                        && Date.parse(runtime.receivedAt) <= Date.parse(observation.observedAt);
-                });
+            const runFailureObserved = observation.taskId !== undefined && observation.runId !== undefined && store.listEvents(observation.taskId).some((event) => {
+                const runtime = runtimeObservationFromTaskEvent(event);
+                return runtime !== null
+                    && runtime.fence.runId === observation.runId
+                    && runtime.fence.nativeSessionId === observation.nativeSessionId
+                    && runtime.kind === "turn.failed"
+                    && Date.parse(runtime.receivedAt) <= Date.parse(observation.observedAt);
+            });
             const classification = classifyRuntimeProcessExit(observation, {
                 ...(driver === null
                     ? {}
                     : { childLifecycle: driver.capabilities.lifecycle.providerProcess }),
-                turnTerminalObserved,
-                turnFailureObserved
+                runTerminalObserved,
+                runFailureObserved
             });
             if (observation.taskId === undefined) {
                 const recorded = appendGlobalProcessExitObservation(store.rootDirectory(), observation, classification);
@@ -624,7 +657,6 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                     observationId: observation.observationId,
                     processKind: observation.processKind,
                     roleName: observation.roleName,
-                    runtimeGenerationId: observation.runtimeGenerationId,
                     observedAt: observation.observedAt,
                     classification,
                     observation: JSON.stringify(observation)
@@ -637,16 +669,14 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             if (params === null || typeof params !== "object" || Array.isArray(params)) {
                 throw applicationError("INVALID_PARAMS", "Launch redemption params are invalid.");
             }
-            const runtimeGenerationId = params.runtimeGenerationId;
             const ticket = params.ticket;
             const hostPid = params.hostPid;
-            if (typeof runtimeGenerationId !== "string" || typeof ticket !== "string"
-                || !Number.isSafeInteger(hostPid) || hostPid <= 0) {
+            if (typeof ticket !== "string" || !Number.isSafeInteger(hostPid) || hostPid <= 0) {
                 throw applicationError("INVALID_PARAMS", "Launch redemption identity is invalid.");
             }
             // The launch payload is validated at reservation time and every member
             // of its discriminated Provider-control union is JSON serializable.
-            return launchBrokerForHome(store.rootDirectory()).redeem(runtimeGenerationId, ticket);
+            return launchBrokerForHome(store.rootDirectory()).redeem(ticket);
         }
         if (method === "runtime.replace-agent-environment") {
             if (environmentRefresher === undefined) {
@@ -680,13 +710,31 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             const task = request.scope === "task"
                 ? store.getTask(request.taskId)
                 : null;
+            // Resolve the admitted Turn first: its purpose decides which Task
+            // lifecycle and workspace fences apply. A Draft Leader planning Turn runs
+            // without a Task workspace; every delivery Turn keeps the full fence.
+            const activeRun = request.scope === "task"
+                ? store.getActiveRun(request.taskId, request.roleName)
+                : null;
+            if (request.scope === "task" && activeRun === null) {
+                throw applicationError("INVALID_PARAMS", "Task Role runtime attachment requires an admitted active Turn; it cannot create an empty Provider Conversation.");
+            }
             if (request.scope === "task"
-                && (task?.status !== "active" || task.executionGate.state !== "enabled")) {
+                && (task === null || !runPurposeAdmitsTaskState(activeRun.purpose, task))) {
                 throw applicationError("INVALID_PARAMS", task === null
                     ? `Task not found: ${request.taskId}.`
                     : `Task execution is not enabled: ${request.taskId}.`);
             }
-            if (request.scope === "task" && task !== null) {
+            const planningDraft = request.scope === "task"
+                && activeRun?.purpose === "planning"
+                && task?.status === "draft";
+            // A Task activated with an empty environment plan owns no managed
+            // workspace, so there is nothing to prove ready. Every Task that does own
+            // one keeps the full ownership fence.
+            if (request.scope === "task"
+                && task !== null
+                && !planningDraft
+                && taskOwnsManagedWorkspace(task)) {
                 const taskWorkspace = store.getTaskWorkspace(task.id);
                 if (!isTaskOwnedWorkspace(taskWorkspace, task.id, task.cwd, task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory })))) {
                     throw new Error(`Task workspace is not ready: ${task.id}.`);
@@ -708,20 +756,24 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                     ? `Role not found: ${request.taskId}/${request.roleName}.`
                     : `Global Role not found: ${request.roleName}.`);
             }
-            const activeTurn = request.scope === "task"
-                ? store.getActiveTurn(request.taskId, request.roleName)
-                : null;
-            if (request.scope === "task" && activeTurn === null) {
-                throw applicationError("INVALID_PARAMS", "Task Role runtime attachment requires an admitted active Turn; it cannot create an empty Provider Conversation.");
-            }
             const managedWorkspace = request.scope === "task"
-                ? activeTurn?.workspace
+                ? activeRun?.workspace
                     ?? currentDesiredManagedWorkspace(store, request.taskId, request.roleName)
                 : undefined;
+            // Distinguish "this Task owns no workspace by design" from "the
+            // authoritative workspace is missing". Only the former may launch without
+            // one. Two cases qualify: an empty plan binding no Project, and a Draft
+            // planning conversation, which may bind a Project but has not activated, so
+            // no worktree exists or is owed. Without the planning term a Project-bound
+            // Draft fails closed on a workspace activation was never asked to create.
+            const workspaceFree = request.scope === "task"
+                && managedWorkspace === undefined
+                && task !== null
+                && (planningDraft || !taskOwnsManagedWorkspace(task));
             const sessions = request.scope === "task"
                 ? store.getTaskRoleSessionSet(request.taskId, request.roleName)
                 : store.getGlobalRoleSessionSet(request.roleName);
-            const effective = activeTurn?.effective
+            const effective = activeRun?.effective
                 ?? activeLiveRoleAgentSession(sessions)?.effective
                 ?? resolveRuntimeDesiredEffective(store, request, role);
             const binding = role.agentBindings[effective.agentId];
@@ -734,12 +786,12 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             }
             validateLifecycleEnvironment(request.environment, agent);
             const session = sessions?.sessions[effective.agentId];
-            // An ensure call may reattach the already-admitted Turn to its existing
+            // An ensure call may reattach the already-admitted AgentRun to its existing
             // Conversation, but it may not manufacture a fresh Conversation without a
-            // pending managed Turn. Fresh replacement remains owned by Turn dispatch.
-            const mode = activeTurn === null
+            // pending managed AgentRun. Fresh replacement remains owned by AgentRun dispatch.
+            const mode = activeRun === null
                 ? roleAgentSessionResumeMode(sessions, effective.agentId, effective)
-                : session?.nativeSessionId === undefined ? activeTurn.mode : "resume";
+                : session?.nativeSessionId === undefined ? activeRun.mode : "resume";
             if (request.scope === "task" && mode === "resume"
                 && (session?.nativeSessionId === undefined
                     || session.nativeSessionId.trim().length === 0)) {
@@ -755,7 +807,8 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 effective,
                 workspace: effective.workspace.root,
                 ...(managedWorkspace === undefined ? {} : { managedWorkspace }),
-                ...(activeTurn === null ? {} : { turnId: activeTurn.id }),
+                ...(workspaceFree ? { workspaceFree: true } : {}),
+                ...(activeRun === null ? {} : { runId: activeRun.id }),
                 ...(request.environment === undefined
                     ? {}
                     : { environment: request.environment })
@@ -768,7 +821,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                     nativeSessionId: session.nativeSessionId
                 };
             const assertCurrent = () => assertRuntimeLaunchRequestCurrent(store, launchRequest);
-            const runtimeBinding = await launchCoordinator.prepare(launchRequest, "immediate", assertCurrent);
+            const runtimeBinding = await launchCoordinator.prepare(launchRequest, assertCurrent);
             return {
                 ensured: true,
                 sessionStarted: runtimeBinding.hostCreated === true,
@@ -794,7 +847,7 @@ function resolveRuntimeDesiredEffective(store, request, role) {
     }
     const taskRole = role;
     const item = store.listWorkItems(request.taskId).find((candidate) => (candidate.assignee === request.roleName
-        && !["completed", "failed", "retired"].includes(candidate.status))) ?? null;
+        && !["accepted", "retired"].includes(candidate.status))) ?? null;
     const workspace = (item === null
         ? store.getTaskWorkspace(request.taskId)
         : store.getWorkItemWorkspace(request.taskId, item.id))
@@ -802,24 +855,28 @@ function resolveRuntimeDesiredEffective(store, request, role) {
         ?? undefined;
     return resolveEffectiveLaunch({
         role: taskRole,
-        purpose: "execution",
+        purpose: store.getTask(request.taskId)?.status === "draft" && request.roleName === "leader"
+            ? "planning" : "execution",
         ...(workspace === undefined ? {} : { workspace }),
         ...(item === null ? {} : { workItemWriteProjectIds: item.writeProjectIds })
     });
 }
 function assertRuntimeLaunchRequestCurrent(store, request) {
-    let activeTurn = null;
+    let activeRun = null;
     if (request.owner.scope === "task") {
         const task = store.getTask(request.owner.taskId);
-        if (task === null
-            || task.status !== "active"
-            || task.executionGate.state !== "enabled") {
+        if (task === null) {
             throw new Error(`Task is no longer active: ${request.owner.taskId}.`);
         }
-        activeTurn = store.getActiveTurn(request.owner.taskId, request.owner.roleName);
-        if (request.turnId !== undefined
-            && activeTurn?.id !== request.turnId) {
-            throw new Error(`Role Turn is no longer current: ${request.turnId}.`);
+        activeRun = store.getActiveRun(request.owner.taskId, request.owner.roleName);
+        const purpose = activeRun?.purpose
+            ?? (task.status === "draft" && request.owner.roleName === "leader" ? "planning" : "execution");
+        if (!runPurposeAdmitsTaskState(purpose, task)) {
+            throw new Error(`Task is no longer active: ${request.owner.taskId}.`);
+        }
+        if (request.runId !== undefined
+            && activeRun?.id !== request.runId) {
+            throw new Error(`Role AgentRun is no longer current: ${request.runId}.`);
         }
     }
     const role = request.owner.scope === "task"
@@ -831,8 +888,8 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
     const sessions = request.owner.scope === "task"
         ? store.getTaskRoleSessionSet(request.owner.taskId, request.owner.roleName)
         : store.getGlobalRoleSessionSet(request.owner.roleName);
-    const expectedEffective = request.owner.scope === "task" && request.turnId !== undefined
-        ? activeTurn?.effective
+    const expectedEffective = request.owner.scope === "task" && request.runId !== undefined
+        ? activeRun?.effective
         : activeLiveRoleAgentSession(sessions)?.effective
             ?? currentDesiredEffective(store, request, role);
     if (expectedEffective === undefined
@@ -843,7 +900,7 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
         throw new Error(`Role launch state changed: ${request.owner.roleName}.`);
     }
     if (request.owner.scope === "task" && request.managedWorkspace !== undefined) {
-        const expectedWorkspace = activeTurn?.workspace
+        const expectedWorkspace = activeRun?.workspace
             ?? currentDesiredManagedWorkspace(store, request.owner.taskId, request.owner.roleName);
         if (expectedWorkspace === undefined
             || !sameManagedWorkspaceIdentity(expectedWorkspace, request.managedWorkspace)) {
@@ -868,13 +925,6 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
             || session.nativeSessionId !== request.nativeSessionId) {
             throw new Error(`Native session changed: ${request.owner.roleName}.`);
         }
-        // The Role's durable Session record is the only authority for which Host
-        // activation may be restored. Targeting anything else would revive a
-        // historical activation.
-        if (request.hostActivationId !== undefined
-            && session.runtimeGenerationId !== request.hostActivationId) {
-            throw new Error(`Session restore does not target the Role's current Host activation: ${request.owner.roleName}.`);
-        }
         if (!roleSessionMayContinue(session.effective, request.effective)) {
             throw new Error(`Native session cannot continue under this launch: ${request.owner.roleName}.`);
         }
@@ -885,7 +935,7 @@ function currentDesiredEffective(store, request, role) {
         return resolveEffectiveLaunch({ role: role, purpose: "execution" });
     }
     const item = store.listWorkItems(request.owner.taskId).find((candidate) => (candidate.assignee === request.owner.roleName
-        && !["completed", "failed", "retired"].includes(candidate.status))) ?? null;
+        && !["accepted", "retired"].includes(candidate.status))) ?? null;
     const workspace = (item === null
         ? store.getTaskWorkspace(request.owner.taskId)
         : store.getWorkItemWorkspace(request.owner.taskId, item.id))
@@ -893,14 +943,15 @@ function currentDesiredEffective(store, request, role) {
         ?? undefined;
     return resolveEffectiveLaunch({
         role: role,
-        purpose: "execution",
+        purpose: store.getTask(request.owner.taskId)?.status === "draft" && request.owner.roleName === "leader"
+            ? "planning" : "execution",
         ...(workspace === undefined ? {} : { workspace }),
         ...(item === null ? {} : { workItemWriteProjectIds: item.writeProjectIds })
     });
 }
 function currentDesiredManagedWorkspace(store, taskId, roleName) {
     const item = store.listWorkItems(taskId).find((candidate) => (candidate.assignee === roleName
-        && !["completed", "failed", "retired"].includes(candidate.status))) ?? null;
+        && !["accepted", "retired"].includes(candidate.status))) ?? null;
     return (item === null
         ? store.getTaskWorkspace(taskId)
         : store.getWorkItemWorkspace(taskId, item.id))
@@ -1044,7 +1095,7 @@ function validateEnvironmentRefreshSources(store, refresh) {
             throw applicationError("INVALID_PARAMS", `Runtime native Agent environment source is not declared: ${name}.`);
         }
     }
-    const allowedNative = new Set(["CODEX_HOME", "CLAUDE_CONFIG_DIR"]);
+    const allowedNative = new Set(NATIVE_AGENT_ENVIRONMENT_NAMES);
     if (refresh.nativeNames.some((name) => !allowedNative.has(name))) {
         throw applicationError("INVALID_PARAMS", "Runtime native Agent environment scope is invalid.");
     }
@@ -1074,9 +1125,8 @@ function providerTurnControlParams(params) {
     return {
         taskId: requiredParam(value.taskId),
         roleName: requiredParam(value.roleName),
-        ...(value.turnId === undefined ? {} : { turnId: requiredParam(value.turnId) }),
+        ...(value.runId === undefined ? {} : { runId: requiredParam(value.runId) }),
         agentId: requiredParam(value.agentId),
-        runtimeGenerationId: requiredParam(value.runtimeGenerationId),
         nativeSessionId: requiredParam(value.nativeSessionId),
         attemptId: requiredParam(value.attemptId),
         authorityEpoch: authorityEpoch,