@zq-silk/yui 0.6.16 → 0.7.1

package/dist/runtime/tmuxAdapters.js

@@ -1,10 +1,13 @@
 import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
 import { createRuntimeBinding } from "./runtimeBinding.js";
 import { normalizeRuntimeOwner } from "./runtimeOwner.js";
-import { RuntimeHostContentionError, RuntimeLaunchError } from "./ports.js";
-import { toRuntimeLaunchFailure, hasFatalLaunchOutput } from "./launchDiagnostics.js";
-import { builtinAgentDriverRegistry } from "./builtinAgentDrivers.js";
+import { RuntimeHostContentionError } from "./ports.js";
+import { toRuntimeLaunchFailure } from "./launchDiagnostics.js";
 import { requireSafeIdentity } from "./validation.js";
+import { launchBrokerForHome } from "./launchBroker.js";
+import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostLaunchControl } from "./agentHost.js";
 const DEFAULT_INACTIVITY_TIMEOUT_MS = 300_000;
 /**
  * Runtime lifecycle adapter for the current tmux host. The returned hostRef is
@@ -163,16 +166,74 @@ export class TmuxSessionHost {
         if (writableHumanAttached) {
             throw new RuntimeHostContentionError("writable-client", `A writable human is attached to ${request.owner.taskId}/${request.owner.roleName}.`);
         }
-        if (request.owner.scope === "task"
-            && request.adapterId === "claude"
-            && request.runId !== undefined
-            && await probeRoleStatus(this.tmux, hostId, request.owner.roleName) === "running") {
-            // Managed Claude is process-per-Run. A live Role window here belongs to
-            // an earlier process (or to recovery of the exact reserved Run); never
-            // plan, persist pre-start state, or inject input into it. The coordinator
-            // decides between same-generation recovery and a retry after natural
-            // exit from the durable reservation identity.
-            return createRuntimeBinding({
+        const input = {
+            roleName: request.owner.roleName,
+            agentId: request.agentId,
+            adapterId: request.adapterId,
+            effective: request.effective,
+            launchId: request.launchId,
+            mode: request.mode,
+            ...(request.runId === undefined ? {} : { runId: request.runId }),
+            ...(request.runtimeIsolation === undefined
+                ? {}
+                : { runtimeIsolation: request.runtimeIsolation }),
+            ...(request.environment === undefined
+                ? {}
+                : { environment: request.environment }),
+            ...(request.mode === "resume" ? { nativeSessionId: request.nativeSessionId } : {})
+        };
+        const planned = request.owner.scope === "task"
+            ? this.planner.plan({ taskId: request.owner.taskId, ...input })
+            : this.planner.planGlobalRole(input);
+        if (planned.role.name !== request.owner.roleName) {
+            throw new Error("Planned Role does not match the runtime owner.");
+        }
+        if (planned.role.workspace !== request.workspace) {
+            throw new Error("Planned Role workspace does not match the runtime request.");
+        }
+        const launchContext = diagnosticContext(request, planned);
+        if (this.#validateLaunch !== undefined) {
+            try {
+                await this.#validateLaunch(request);
+            }
+            catch (error) {
+                throw toRuntimeLaunchFailure(error, "validation", launchContext);
+            }
+        }
+        const plannedNativeSessionId = planned.session?.nativeSessionId;
+        if (request.mode === "resume"
+            && plannedNativeSessionId !== undefined
+            && plannedNativeSessionId !== request.nativeSessionId) {
+            throw new Error("Planned native session does not match the resume request.");
+        }
+        const nativeSessionId = plannedNativeSessionId
+            ?? (request.mode === "resume" ? request.nativeSessionId : undefined);
+        beforeHostStart?.({
+            owner: request.owner,
+            launchId: request.launchId,
+            ...(request.runId === undefined ? {} : { runId: request.runId }),
+            agentId: request.agentId,
+            adapterId: request.adapterId,
+            effective: request.effective,
+            ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
+            ...(planned.initialPromptRunId === undefined
+                ? {}
+                : { initialPromptRunId: planned.initialPromptRunId })
+        });
+        const yuiHome = planned.launch.env.YUI_HOME;
+        const childLifecycle = planned.launch.childLifecycle;
+        // Custom/legacy planners do not yet expose the Agent Host contract. Keep
+        // their direct launch behavior for compatibility while all built-in
+        // managed Roles use the persistent Host below.
+        if (yuiHome === undefined || childLifecycle === undefined) {
+            let hostCreated;
+            try {
+                hostCreated = await ensureRoleWindow(this.tmux, hostId, planned.role, planned.launch);
+            }
+            catch (error) {
+                throw toRuntimeLaunchFailure(error, "host-start", launchContext);
+            }
+            let binding = createRuntimeBinding({
                 id: bindingId,
                 launchId: request.launchId,
                 owner: request.owner,
@@ -183,31 +244,99 @@ export class TmuxSessionHost {
                     hostId,
                     roleName: request.owner.roleName
                 }),
-                hostCreated: false,
-                ...(request.mode === "resume"
-                    ? { nativeSessionId: request.nativeSessionId }
-                    : {})
+                hostCreated,
+                ...(hostCreated && planned.initialPromptRunId !== undefined
+                    ? { initialPromptRunId: planned.initialPromptRunId }
+                    : {}),
+                ...(nativeSessionId === undefined ? {} : { nativeSessionId })
             });
-        }
-        const { planned, nativeSessionId } = planManagedLaunch(this.planner, request, beforeHostStart);
-        const launchContext = diagnosticContext(request, planned);
-        if (this.#validateLaunch !== undefined) {
-            try {
-                await this.#validateLaunch(request);
-            }
-            catch (error) {
-                throw toRuntimeLaunchFailure(error, "validation", launchContext);
+            if (hostCreated) {
+                const pane = await inspectRolePane(this.tmux, hostId, request.owner.roleName);
+                if (pane?.dead === true) {
+                    await deadHostLaunchFailure(this.tmux, hostId, request.owner.roleName, pane, launchContext);
+                }
+                if (request.mode === "new"
+                    && request.owner.scope === "task"
+                    && request.runId !== undefined
+                    && planned.initialPromptRunId === request.runId
+                    && this.#waitForNativeSession !== undefined) {
+                    binding = createRuntimeBinding({
+                        ...binding,
+                        nativeSessionId: await this.waitForNativeSessionDiscovery(request, hostId, launchContext)
+                    });
+                }
+                if (pane !== undefined)
+                    this.#onHostCreated?.({ binding, pane });
             }
+            return binding;
         }
-        // Process creation is last: every local invariant has already passed.
+        const broker = launchBrokerForHome(yuiHome);
+        const reservation = broker.reserve(Object.freeze({
+            schemaVersion: 1,
+            launchId: request.launchId,
+            command: planned.launch.command,
+            args: [...planned.launch.args],
+            environment: { ...planned.launch.env },
+            cwd: planned.role.cwd ?? planned.role.workspace,
+            childLifecycle,
+            startMode: planned.launch.deferProviderStart === true ? "idle" : "provider",
+            ...(planned.launch.providerInput === undefined
+                ? {}
+                : { providerInput: planned.launch.providerInput })
+        }));
+        const hostLaunch = {
+            command: process.execPath,
+            args: [
+                fileURLToPath(new URL("../cli.js", import.meta.url)),
+                "internal",
+                "agent-host",
+                reservation.launchId,
+                reservation.ticket
+            ],
+            env: {
+                YUI_HOME: resolve(yuiHome),
+                YUI_SESSION_SCOPE: request.owner.scope,
+                ...(request.owner.scope === "task" ? { YUI_TASK_ID: request.owner.taskId } : {}),
+                YUI_ROLE: request.owner.roleName,
+                YUI_LAUNCH_ID: request.launchId
+            }
+        };
         let hostCreated;
+        let providerChildLaunched = false;
+        let launchPromptAlreadySubmitted = false;
         try {
-            hostCreated = await ensureRoleWindow(this.tmux, hostId, planned.role, planned.launch);
+            hostCreated = await ensureRoleWindow(this.tmux, hostId, planned.role, hostLaunch);
+            providerChildLaunched = hostCreated && planned.launch.deferProviderStart !== true;
+            if (!hostCreated) {
+                const controlResult = await sendAgentHostLaunchControl({
+                    home: yuiHome,
+                    scope: request.owner.scope,
+                    ...(request.owner.scope === "task" ? { taskId: request.owner.taskId } : {}),
+                    roleName: request.owner.roleName,
+                    control: {
+                        protocol: AGENT_HOST_CONTROL_PROTOCOL,
+                        type: "launch",
+                        launchId: reservation.launchId,
+                        ticket: reservation.ticket
+                    }
+                });
+                if (controlResult !== "accepted") {
+                    broker.revoke(request.launchId);
+                    launchPromptAlreadySubmitted = controlResult === "active-same-launch";
+                    if (childLifecycle === "per-turn" && controlResult === "active-other-launch") {
+                        throw new RuntimeHostContentionError("provider-child-active", `The persistent Agent Host for ${request.owner.roleName} still owns another Provider turn.`);
+                    }
+                }
+                else {
+                    providerChildLaunched = planned.launch.deferProviderStart !== true;
+                }
+            }
         }
         catch (error) {
-            throw toRuntimeLaunchFailure(error, "host-start", launchContext);
+            broker.revoke(request.launchId);
+            throw error;
         }
-        if (hostCreated
+        if (providerChildLaunched
             && request.owner.scope === "task"
             && planned.launch.env.YUI_JOB_CALLER_KEY !== undefined
             && this.planner.commitTaskCallerKey !== undefined) {
@@ -218,7 +347,7 @@ export class TmuxSessionHost {
                 callerKey: planned.launch.env.YUI_JOB_CALLER_KEY
             });
         }
-        let binding = createRuntimeBinding({
+        const binding = createRuntimeBinding({
             id: bindingId,
             launchId: request.launchId,
             owner: request.owner,
@@ -230,218 +359,66 @@ export class TmuxSessionHost {
                 roleName: request.owner.roleName
             }),
             hostCreated,
-            ...(hostCreated && planned.initialPromptRunId !== undefined
+            ...(providerChildLaunched && hostCreated && planned.initialPromptRunId !== undefined
                 ? { initialPromptRunId: planned.initialPromptRunId }
                 : {}),
+            ...((launchPromptAlreadySubmitted || (providerChildLaunched && !hostCreated))
+                && planned.initialPromptRunId !== undefined
+                ? { launchPromptUncertainRunId: planned.initialPromptRunId }
+                : {}),
             ...(nativeSessionId === undefined ? {} : { nativeSessionId })
         });
-        if (hostCreated) {
-            let pane;
-            try {
-                pane = await inspectRolePane(this.tmux, hostId, request.owner.roleName);
-            }
-            catch (error) {
-                throw toRuntimeLaunchFailure(error, "host-started", launchContext);
-            }
-            if (pane === undefined) {
-                throw toRuntimeLaunchFailure(new Error("Managed host pane could not be inspected after creation."), "host-started", launchContext);
-            }
-            this.#onHostCreated?.({ binding, pane });
-            if (pane.dead) {
-                await deadHostLaunchFailure(this.tmux, hostId, request.owner.roleName, pane, launchContext);
-            }
-            if (requiresNativeSessionDiscovery(request, planned, this.#waitForNativeSession)) {
-                const discoveredNativeSessionId = await this.waitForNativeSessionDiscovery(request, hostId, launchContext, pane);
-                binding = createRuntimeBinding({
-                    ...binding,
-                    nativeSessionId: discoveredNativeSessionId
-                });
-            }
-            this.#onHostCreated?.({ binding, pane });
+        if (hostCreated && this.#onHostCreated !== undefined) {
+            const pane = await inspectRolePane(this.tmux, hostId, request.owner.roleName);
+            if (pane !== undefined)
+                this.#onHostCreated({ binding, pane });
         }
         return binding;
     }
-    async waitForNativeSessionDiscovery(request, hostId, context, pane) {
-        if (this.#waitForNativeSession === undefined) {
-            throw new Error("Native session discovery is not configured.");
-        }
+    async waitForNativeSessionDiscovery(request, hostId, context) {
         const controller = new AbortController();
         const discovery = this.#waitForNativeSession(request, controller.signal);
-        // The losing branch of the race rejects when the controller aborts; keep
-        // that rejection handled so a settled launch does not surface it later.
         discovery.catch(() => undefined);
+        let stopped = false;
+        let lastContent = "";
+        let lastActivityAt = Date.now();
+        const monitor = (async () => {
+            while (!stopped) {
+                await new Promise((resolve) => setTimeout(resolve, Math.min(1_000, this.#inactivityTimeoutMs)));
+                const pane = await inspectRolePane(this.tmux, hostId, request.owner.roleName);
+                if (pane?.dead === true) {
+                    await deadHostLaunchFailure(this.tmux, hostId, request.owner.roleName, pane, context);
+                }
+                const content = this.tmux.captureRolePane?.(hostId, request.owner.roleName, 80) ?? "";
+                if (content !== lastContent) {
+                    lastContent = content;
+                    lastActivityAt = Date.now();
+                }
+                if (Date.now() - lastActivityAt >= this.#inactivityTimeoutMs) {
+                    throw new Error(`Agent produced no signal for ${this.#inactivityTimeoutMs}ms. `
+                        + "The process is alive but emitted no lifecycle hook, output, or exit.");
+                }
+            }
+            throw new Error("Native session discovery monitor stopped.");
+        })();
+        monitor.catch(() => undefined);
         try {
-            return await Promise.race([
-                discovery,
-                this.monitorPaneSignals(request, hostId, context, controller.signal)
-            ]);
+            return await Promise.race([discovery, monitor]);
         }
         catch (error) {
             try {
                 await stopExactRole(this.tmux, hostId, request.owner.roleName);
             }
             catch {
-                // The launch failure below is authoritative; durable owner cleanup
-                // remains responsible for a Provider that rejected immediate stop.
+                // Preserve the discovery failure; durable cleanup owns later retries.
             }
-            throw toRuntimeLaunchFailure(error, "native-session-discovery", {
-                ...context,
-                pane
-            });
+            throw toRuntimeLaunchFailure(error, "native-session-discovery", context);
         }
         finally {
+            stopped = true;
             controller.abort();
         }
     }
-    /**
-     * Monitors the managed pane for agent-emitted signals while native session
-     * discovery is pending. The agent's own behavior drives the outcome:
-     *
-     * - Pane death → failure with exit status and stderr (the agent exited).
-     * - Fatal output (auth, config, executable errors) → failure with the
-     *   agent's own error text.
-     * - No signal at all (no hook, no output change, no exit) for the
-     *   inactivity window → backstop failure.
-     *
-     * There is no fixed wall-clock timeout: a slow-but-active agent is never
-     * killed merely for taking too long to start.
-     */
-    async monitorPaneSignals(request, hostId, context, signal) {
-        let lastContent = "";
-        let lastActivityAt = Date.now();
-        while (!signal.aborted) {
-            await abortableDelay(PANE_SIGNAL_POLL_MS, signal);
-            let pane;
-            try {
-                pane = await inspectRolePane(this.tmux, hostId, request.owner.roleName);
-            }
-            catch {
-                // A tmux inspection hiccup must not fabricate a Provider death; the
-                // inactivity backstop remains the safety net.
-                continue;
-            }
-            if (pane !== undefined && pane.dead) {
-                await deadHostLaunchFailure(this.tmux, hostId, request.owner.roleName, pane, context);
-            }
-            let content = "";
-            try {
-                content = this.tmux.captureRolePane?.(hostId, request.owner.roleName, 80) ?? "";
-            }
-            catch {
-                // Capture is best-effort; pane death and hooks remain authoritative.
-            }
-            if (content !== lastContent) {
-                lastContent = content;
-                lastActivityAt = Date.now();
-                if (hasFatalLaunchOutput(content)) {
-                    throw toRuntimeLaunchFailure(new Error("Agent emitted a fatal error before native session discovery completed."), "native-session-discovery", {
-                        ...context,
-                        ...(pane !== undefined ? { pane } : {}),
-                        stderrTail: content
-                    });
-                }
-            }
-            if (Date.now() - lastActivityAt >= this.#inactivityTimeoutMs) {
-                throw new Error(`Agent produced no signal for ${this.#inactivityTimeoutMs}ms. `
-                    + "The process is alive but emitted no lifecycle hook, output, or exit.");
-            }
-        }
-        throw new Error("Native session discovery was aborted.");
-    }
-}
-function requiresNativeSessionDiscovery(request, planned, wait) {
-    return request.mode === "new"
-        && request.owner.scope === "task"
-        && request.runId !== undefined
-        && planned.initialPromptRunId === request.runId
-        && wait !== undefined
-        && builtinAgentDriverRegistry()
-            .requireByAdapterId(request.adapterId)
-            .capabilities.observation.sessionBootstrap === "discovered";
-}
-function positiveInteger(value, label) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new Error(`${label} must be a positive integer.`);
-    }
-    return value;
-}
-const PANE_SIGNAL_POLL_MS = 1_000;
-function abortableDelay(milliseconds, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal.aborted) {
-            reject(new Error("Native session discovery was aborted."));
-            return;
-        }
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(new Error("Native session discovery was aborted."));
-        };
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, milliseconds);
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function planManagedLaunch(planner, request, beforeHostStart) {
-    try {
-        const input = {
-            roleName: request.owner.roleName,
-            agentId: request.agentId,
-            adapterId: request.adapterId,
-            effective: request.effective,
-            launchId: request.launchId,
-            mode: request.mode,
-            ...(request.runId === undefined ? {} : { runId: request.runId }),
-            ...(request.runtimeIsolation === undefined
-                ? {}
-                : { runtimeIsolation: request.runtimeIsolation }),
-            ...(request.environment === undefined
-                ? {}
-                : { environment: request.environment }),
-            ...(request.mode === "resume" ? { nativeSessionId: request.nativeSessionId } : {})
-        };
-        const planned = request.owner.scope === "task"
-            ? planner.plan({ taskId: request.owner.taskId, ...input })
-            : planner.planGlobalRole(input);
-        if (planned.role.name !== request.owner.roleName) {
-            throw new Error("Planned Role does not match the runtime owner.");
-        }
-        if (planned.role.workspace !== request.workspace) {
-            throw new Error("Planned Role workspace does not match the runtime request.");
-        }
-        const plannedNativeSessionId = planned.session?.nativeSessionId;
-        if (request.mode === "resume"
-            && plannedNativeSessionId !== undefined
-            && plannedNativeSessionId !== request.nativeSessionId) {
-            throw new Error("Planned native session does not match the resume request.");
-        }
-        const nativeSessionId = plannedNativeSessionId
-            ?? (request.mode === "resume" ? request.nativeSessionId : undefined);
-        beforeHostStart?.({
-            owner: request.owner,
-            launchId: request.launchId,
-            ...(request.runId === undefined ? {} : { runId: request.runId }),
-            agentId: request.agentId,
-            adapterId: request.adapterId,
-            effective: request.effective,
-            ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
-            ...(planned.initialPromptRunId === undefined
-                ? {}
-                : { initialPromptRunId: planned.initialPromptRunId })
-        });
-        return { planned, nativeSessionId };
-    }
-    catch (error) {
-        if (error instanceof RuntimeLaunchError
-            || error instanceof RuntimeHostContentionError) {
-            throw error;
-        }
-        throw toRuntimeLaunchFailure(error, "validation", {
-            agentId: request.agentId,
-            cwd: request.workspace
-        });
-    }
 }
 function diagnosticContext(request, planned) {
     return {
@@ -490,6 +467,12 @@ async function ensureRoleWindow(tmux, hostId, role, launch) {
         ? tmux.ensureRoleWindow(hostId, role, launch)
         : tmux.ensureRoleWindowAsync(hostId, role, launch);
 }
+function positiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return value;
+}
 async function probeRoleStatus(tmux, hostId, roleName) {
     return tmux.probeRoleStatusAsync === undefined
         ? tmux.probeRoleStatus(hostId, roleName)

package/dist/scheduler/activeRoleRunDelivery.js

@@ -3,6 +3,7 @@ import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { markYuiRunInput } from "../run/runIdentity.js";
 import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
@@ -11,6 +12,9 @@ import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
+import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
+import { serializeWorkflowOutcomeRequestEnvelope } from "../run/runControlRequest.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
@@ -32,7 +36,10 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
             // re-push guard keys on pushedAt (transport), not deliveredAt (provider
             // acceptance): a pushed-but-unaccepted Run must never be pushed twice —
             // no duplicate Enter while acceptance is still pending.
-            if (run === null || run.pushedAt !== undefined)
+            if (run === null
+                || (run.pushedAt !== undefined
+                    && run.providerRetry?.state !== "dispatching"
+                    && run.controlRequest?.state !== "dispatching"))
                 continue;
             const taskWorkspace = store.getTaskWorkspace(task.id);
             if (!isSchedulerTaskWorkspaceReady(task, taskWorkspace)) {
@@ -64,7 +71,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 continue;
             }
             const existingSession = store.getRoleSession(task.id, role.name, run.effective.agentId);
-            const receiptId = formatAgentRunReceiptId(task.id, run.id);
+            const receiptId = agentRunDeliveryReceiptId(run);
             const target = { kind: "role", taskId: task.id, roleName: role.name };
             const claim = store.claimWorkMailbox({
                 target,
@@ -229,7 +236,21 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 const outcome = await delivery.sendOnce({
                     delivery: ready,
                     receiptId,
-                    text: run.input
+                    text: run.controlRequest?.state === "dispatching"
+                        ? serializeWorkflowOutcomeRequestEnvelope({
+                            taskId: task.id,
+                            runId: run.id,
+                            roleName: role.name,
+                            request: run.controlRequest
+                        })
+                        : run.providerRetry?.state === "dispatching"
+                            ? serializeProviderRetryEnvelope({
+                                taskId: task.id,
+                                runId: run.id,
+                                roleName: role.name,
+                                retry: run.providerRetry
+                            })
+                            : serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
                 });
                 if (outcome === "busy" || outcome === "unavailable") {
                     results.push({

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,12 +1,10 @@
 import { createAgentRun } from "../run/agentRun.js";
-import { markYuiRunInput } from "../run/runIdentity.js";
-import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { createRunAssignment, serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.js";
 import { createLeaderRecoveryNotification } from "./operatorNotification.js";
-import { evaluateSessionContextBudget } from "../context/sessionContextBudget.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
@@ -122,52 +120,21 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 && existingSession.status !== "stopped" && existingSession.status !== "broken") {
                 throw new Error(`Leader Session is incompatible with desired effective launch: ${task.id}/${role.name}.`);
             }
-            // Issue 04: a native Session generation whose observed per-request
-            // input peak crossed the hard context budget is retired before dispatch
-            // so the wake starts a fresh generation instead of waiting for
-            // provider-side auto-compaction. Durable Task records are the checkpoint;
-            // the bounded snapshot below re-establishes working context.
-            let contextBudgetAdvisory;
-            if (hasNativeSession(existingSession)
-                && compatibleSession
-                && existingSession.status !== "stopped"
-                && existingSession.status !== "broken"
-                && typeof store.listEvents === "function"
-                && typeof store.getContextBudget === "function"
-                && typeof store.rolloverTaskRoleSessionForContextBudget === "function") {
-                const budget = evaluateSessionContextBudget(store.listEvents(task.id), {
-                    taskId: task.id,
-                    roleName: role.name,
-                    ...(existingSession.nativeSessionId === undefined
-                        ? {}
-                        : { nativeSessionId: existingSession.nativeSessionId }),
-                    ...(existingSession.launchId === undefined
-                        ? {}
-                        : { launchId: existingSession.launchId })
-                }, store.getContextBudget());
-                if (budget.state === "hard") {
-                    const rollover = store.rolloverTaskRoleSessionForContextBudget({
-                        taskId: task.id,
-                        roleName: role.name,
-                        peakTokens: budget.peakTokens,
-                        hardTokens: budget.budget.hardTokens,
-                        now
-                    });
-                    if (rollover !== null) {
-                        existingSession = null;
-                        effectiveSession = null;
-                        contextBudgetAdvisory = `Previous Session generation ${rollover.retiredNativeSessionId ?? "unknown"} was retired at the hard context budget (peak ${budget.peakTokens} >= ${budget.budget.hardTokens} tokens). This wake starts a fresh generation; durable Task records preserve all state.`;
-                    }
-                }
-                else if (budget.state === "soft") {
-                    contextBudgetAdvisory = `Session context budget advisory: observed per-request input peak ${budget.peakTokens} tokens crossed the soft threshold (${budget.budget.softTokens}). Durable Yui records are the checkpoint; a fresh generation starts automatically at the hard threshold (${budget.budget.hardTokens}).`;
-                }
-            }
             const mode = hasNativeSession(existingSession) && compatibleSession ? "resume" : "new";
             const runId = store.peekNextAgentRunId(task.id);
             const wakeEnvelope = resolveLeaderWakeEnvelope(store, task.id);
-            const input = markYuiRunInput(leaderWakeupInput(task.id, runId, wakeEnvelope, contextBudgetAdvisory), runId, taskRoleSessionTitle(task, role.name));
-            run = createAgentRun(runId, task.id, role.name, mode, input, now, {
+            const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);
+            const assignment = createRunAssignment({
+                runId,
+                roleName: role.name,
+                purpose: "execution",
+                action: "leader-wake",
+                subject: { taskId: task.id },
+                directive: leaderWakeupInput(task.id, runId, wakeup.reasons),
+                ...(contextSnapshot === undefined ? {} : { contextSnapshotRef: contextSnapshot.ref }),
+                deltaRefIds: contextSnapshot?.deltaRefIds ?? []
+            });
+            run = createAgentRun(runId, task.id, role.name, mode, assignment, now, {
                 ...(role.managedWorkspace === undefined
                     ? {}
                     : { workspace: role.managedWorkspace }),
@@ -300,7 +267,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const outcome = await delivery.sendOnce({
                 delivery: ready,
                 receiptId: formatAgentRunReceiptId(task.id, run.id),
-                text: input
+                text: serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
             });
             if (outcome === "busy" || outcome === "unavailable") {
                 results.push({
@@ -490,18 +457,9 @@ function resolveLeaderWakeEnvelope(store, taskId) {
         return null;
     return store.getTaskWakeEnvelope(taskId);
 }
-function leaderWakeupInput(taskId, runId, wakeEnvelope, contextBudgetAdvisory) {
-    const lines = [
-        "Follow the injected yui-leader Skill for this Yui wakeup.",
-        `Current Leader Run: ${runId}.`,
+function leaderWakeupInput(taskId, runId, reasons) {
+    return [
         `For every Leader decision, milestone, or Work Item lifecycle command that is meaningful progress, carry this exact current-turn assertion on that command: YUI_LEADER_ACTION_RUN_ID=${runId} YUI_LEADER_ACTION_RECEIPT_ID=${formatAgentRunReceiptId(taskId, runId)}. The native Session environment may retain an older YUI_RUN_ID/launch; never copy those values, and never reuse this assertion after the turn changes.`,
-        ...(contextBudgetAdvisory === undefined ? [] : [contextBudgetAdvisory]),
-        ...(wakeEnvelope === null
-            ? [`Read the authoritative context with yui task context ${taskId}.`]
-            : [
-                "Wake envelope (Issue 04):",
-                wakeEnvelope.text
-            ]),
-    ];
-    return lines.join("\n");
+        `Wake reasons: ${reasons.join(", ")}. Load exact context for ${taskId}/${runId}.`
+    ].join("\n");
 }