@zq-silk/yui 0.6.16 → 0.7.1

package/dist/controller/jobControl.js

@@ -12,6 +12,7 @@ import { createHash } from "node:crypto";
 import { resolve, sep } from "node:path";
 import { acknowledgeUnknownDurableJob, createDurableJob, durableJobIdempotencyKey, isDurableJobTerminal, requestDurableJobCancel, retryDurableJobIdempotencyKey } from "../job/durableJob.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 export function createDurableJobControl(store) {
     return {
         startJob(params, now) {
@@ -350,7 +351,7 @@ function assertLeaderActionRun(store, taskId, assertion) {
     if (sessions === null
         || sessions.inFlight === null
         || sessions.inFlight.runId !== run.id
-        || sessions.inFlight.receiptId !== expectedReceipt) {
+        || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run)) {
         throw jobControlError("UNAUTHORIZED", "job.acknowledge Leader Run is not in flight.");
     }
 }

package/dist/controller/runtime.js

@@ -34,6 +34,12 @@ import { ResourceInventoryClient } from "./resourceInventoryRpc.js";
 import { createResourceAutoGc } from "../resources/autoResourceGc.js";
 import { createRuntimeResourceActivityTracker } from "./resourceInventory.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
+import { launchBrokerForHome } from "../runtime/launchBroker.js";
+import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
+import { appendGlobalProcessExitObservation } from "../runtime/globalProcessExitStore.js";
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { createTaskEvent } from "../event/taskEvent.js";
 /** Refreshes only the exact Task runtime generation folded by the event transaction. */
 export function refreshAppliedTaskRuntimeDescriptor(store, planner, input) {
     if (input.launchId === undefined)
@@ -521,6 +527,83 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
         });
     const lifecycleTails = new Map();
     return async (method, params) => {
+        if (method === "runtime.process-exit-observe") {
+            const observation = validateRuntimeProcessExitObservation(params);
+            const run = observation.taskId === undefined || observation.runId === undefined
+                ? null
+                : store.getAgentRun(observation.taskId, observation.runId);
+            const globalRole = observation.taskId === undefined
+                ? store.getGlobalRole(observation.roleName)
+                : null;
+            const adapterId = run?.effective.adapterId
+                ?? globalRole?.agentBindings[globalRole.activeAgentId]?.adapterId;
+            const driver = adapterId === undefined
+                ? null
+                : builtinAgentDriverRegistry().findByAdapterId(adapterId);
+            const turnTerminalObserved = observation.taskId !== undefined
+                && observation.runId !== undefined
+                && store.listEvents(observation.taskId).some((event) => {
+                    const runtime = runtimeObservationFromTaskEvent(event);
+                    return runtime !== null
+                        && 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.runId !== undefined
+                && store.listEvents(observation.taskId).some((event) => {
+                    const runtime = runtimeObservationFromTaskEvent(event);
+                    return runtime !== null
+                        && runtime.fence.runId === observation.runId
+                        && runtime.fence.launchId === observation.launchId
+                        && 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
+            });
+            if (observation.taskId === undefined) {
+                const recorded = appendGlobalProcessExitObservation(store.rootDirectory(), observation, classification);
+                return { recorded, scope: "global", classification };
+            }
+            const recorded = store.transaction((tx) => {
+                if (tx.getTask(observation.taskId) === null) {
+                    throw applicationError("INVALID_PARAMS", `Task not found: ${observation.taskId}.`);
+                }
+                const duplicate = tx.listEvents(observation.taskId).some((event) => (event.type === "runtime.process-exit-observed"
+                    && event.payload.observationId === observation.observationId));
+                if (duplicate)
+                    return false;
+                tx.saveEvent(observation.taskId, createTaskEvent(tx.nextEventId(observation.taskId), observation.taskId, "runtime.process-exit-observed", {
+                    observationId: observation.observationId,
+                    processKind: observation.processKind,
+                    roleName: observation.roleName,
+                    launchId: observation.launchId,
+                    observedAt: observation.observedAt,
+                    classification,
+                    observation: JSON.stringify(observation)
+                }, new Date(observation.observedAt)));
+                return true;
+            });
+            return { recorded, classification };
+        }
+        if (method === "runtime.launch-redeem") {
+            if (params === null || typeof params !== "object" || Array.isArray(params)) {
+                throw applicationError("INVALID_PARAMS", "Launch redemption params are invalid.");
+            }
+            const launchId = params.launchId;
+            const ticket = params.ticket;
+            const hostPid = params.hostPid;
+            if (typeof launchId !== "string" || typeof ticket !== "string"
+                || !Number.isSafeInteger(hostPid) || hostPid <= 0) {
+                throw applicationError("INVALID_PARAMS", "Launch redemption identity is invalid.");
+            }
+            return launchBrokerForHome(store.rootDirectory()).redeem(launchId, ticket);
+        }
         if (method === "runtime.replace-agent-environment") {
             if (environmentRefresher === undefined) {
                 throw applicationError("METHOD_NOT_FOUND", "Controller method was not found.");

package/dist/controller/runtimeHookRunFence.js

@@ -3,7 +3,7 @@ import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecyc
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactTaskRuntimeEnvironment, exactControlPlaneDigest, parseExactControlPlaneDescriptor, refreshReusedTaskRuntimeDescriptorSource } from "../runtime/exactControlPlane.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 /**
  * Resolves turn identity from the current durable in-flight fence. The one
  * exception is a Driver-declared startup Session Hook, which can arrive before
@@ -98,6 +98,9 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         && executionRef?.type === "run"
         && executionRef.taskId === taskId
         && executionRef.id === startupRunId;
+    const startupRun = startupRunId === undefined
+        ? null
+        : store.getAgentRun(taskId, startupRunId);
     const preallocatedStartup = options.startupSession === "preallocated"
         && expectedNativeSessionId !== undefined
         && session === undefined
@@ -137,7 +140,8 @@ export function resolveRuntimeHookRunFence(environment, adapterId, payloadNative
         && inFlight !== null
         && inFlight !== undefined
         && (inFlight.runId !== startupRunId
-            || inFlight.receiptId !== formatAgentRunReceiptId(taskId, startupRunId))) {
+            || startupRun === null
+            || inFlight.receiptId !== agentRunDeliveryReceiptId(startupRun))) {
         throw new Error("Runtime observation Hook has no matching durable in-flight Run.");
     }
     const runId = acceptedBinding?.fence.runId

package/dist/controller/sessionOwnerReconciliation.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { createSessionOwnerIdentity, discoverProviderRootByLaunchEnv, isLinuxProcessLive, listLaunchFencedProcesses, listOwnedProcessTree, readLinuxProcessIdentity, reconcileSessionOwners, terminateSessionOwners } from "../runtime/index.js";
+import { removeRuntimeStopReceipt, writeRuntimeStopReceipt } from "../runtime/runtimeStopReceipt.js";
 import { tmuxSocketDirectory } from "../tmux/tmuxSocketEndpoint.js";
 import { yuiTmuxServerName, yuiTmuxSessionName, yuiTmuxTarget } from "../tmux/tmuxManager.js";
 /**
@@ -148,12 +149,16 @@ export class SessionOwnerReconciliation {
         if (result.outcome === "stop-confirmed") {
             for (const record of result.confirmed) {
                 this.#store.removeSessionOwner(record.launchId);
+                removeRuntimeStopReceipt(this.#home, record.launchId);
             }
         }
         return result;
     }
     #recordTerminationEvent(event) {
         const owner = event.owner;
+        if (event.stage === "stop-requested" && event.launchId !== undefined) {
+            writeRuntimeStopReceipt(this.#home, event.launchId, event.at);
+        }
         if (owner.scope !== "task")
             return;
         try {

package/dist/coordination/workMailbox.js

@@ -121,22 +121,26 @@ function appendUnique(existing, incoming, keyOf) {
     }
     return result;
 }
-function mergeBatches(earlier, later) {
+function mergeBatches(left, right) {
     const merged = {
-        fromSequence: earlier.fromSequence,
-        toSequence: later.toSequence,
-        reasons: appendUnique(earlier.reasons, later.reasons, (reason) => reason),
-        refs: appendUnique(earlier.refs, later.refs, mailboxEntityRefKey),
-        requestCount: earlier.requestCount + later.requestCount,
-        firstQueuedAt: earlier.firstQueuedAt,
-        lastQueuedAt: later.lastQueuedAt,
-        sources: appendUnique(earlier.sources, later.sources, (source) => source),
-        dedupeKeys: appendUnique(earlier.dedupeKeys, later.dedupeKeys, (key) => key),
-        deliveryModes: appendUnique(earlier.deliveryModes, later.deliveryModes, (mode) => mode),
-        ...((earlier.highestFactRevision ?? later.highestFactRevision) === undefined
+        fromSequence: Math.min(left.fromSequence, right.fromSequence),
+        toSequence: Math.max(left.toSequence, right.toSequence),
+        reasons: appendUnique(left.reasons, right.reasons, (reason) => reason),
+        refs: appendUnique(left.refs, right.refs, mailboxEntityRefKey),
+        requestCount: left.requestCount + right.requestCount,
+        firstQueuedAt: Date.parse(left.firstQueuedAt) <= Date.parse(right.firstQueuedAt)
+            ? left.firstQueuedAt
+            : right.firstQueuedAt,
+        lastQueuedAt: Date.parse(left.lastQueuedAt) >= Date.parse(right.lastQueuedAt)
+            ? left.lastQueuedAt
+            : right.lastQueuedAt,
+        sources: appendUnique(left.sources, right.sources, (source) => source),
+        dedupeKeys: appendUnique(left.dedupeKeys, right.dedupeKeys, (key) => key),
+        deliveryModes: appendUnique(left.deliveryModes, right.deliveryModes, (mode) => mode),
+        ...((left.highestFactRevision ?? right.highestFactRevision) === undefined
             ? {}
             : {
-                highestFactRevision: Math.max(earlier.highestFactRevision ?? 0, later.highestFactRevision ?? 0)
+                highestFactRevision: Math.max(left.highestFactRevision ?? 0, right.highestFactRevision ?? 0)
             })
     };
     return merged;
@@ -196,17 +200,16 @@ export function validateWorkMailbox(value) {
         pending.userCorrection,
         inputDelivery?.batch
     ].filter((batch) => batch !== null && batch !== undefined);
+    const activeDedupeKeys = new Set();
     for (const batch of batches) {
         if (batch.toSequence >= nextSequence) {
             throw new Error("WorkMailbox batch sequence must be lower than nextSequence");
         }
-    }
-    const ranges = batches
-        .map((batch) => [batch.fromSequence, batch.toSequence])
-        .sort((left, right) => left[0] - right[0]);
-    for (let index = 1; index < ranges.length; index += 1) {
-        if (ranges[index - 1][1] >= ranges[index][0]) {
-            throw new Error("WorkMailbox batch sequences overlap");
+        for (const dedupeKey of batch.dedupeKeys) {
+            if (activeDedupeKeys.has(dedupeKey)) {
+                throw new Error("WorkMailbox active batches share a dedupe key");
+            }
+            activeDedupeKeys.add(dedupeKey);
         }
     }
     if (inputDelivery !== null && target.kind !== "role" && target.kind !== "operator") {
@@ -304,8 +307,8 @@ function parseBatch(value, label) {
     const fromSequence = requireInteger(batch.fromSequence, 1, `${label} fromSequence`);
     const toSequence = requireInteger(batch.toSequence, fromSequence, `${label} toSequence`);
     const requestCount = requireInteger(batch.requestCount, 1, `${label} requestCount`);
-    if (requestCount !== toSequence - fromSequence + 1) {
-        throw new Error(`${label} requestCount does not match its sequence range`);
+    if (requestCount > toSequence - fromSequence + 1) {
+        throw new Error(`${label} requestCount exceeds its sequence envelope`);
     }
     const reasons = requireStringArray(batch.reasons, `${label} reasons`);
     if (reasons.length === 0)

package/dist/executor/agentAdapter.js

@@ -126,7 +126,7 @@ class CodexAdapter extends BaseAdapter {
             "--config",
             `projects={${JSON.stringify(resolve(input.workspace))}={trust_level="trusted"}}`
         ];
-        const instructions = [
+        const instructions = input.sessionManifestPath === undefined ? [
             input.developerInstructions,
             ...(input.skills === undefined || input.skills.length === 0
                 ? []
@@ -134,7 +134,9 @@ class CodexAdapter extends BaseAdapter {
                     "Yui Role Skills are available at the paths below. Before performing work governed by one, read and follow its SKILL.md on demand; do not treat this list as a user message.",
                     ...input.skills.map((skill) => `- ${skill.id}: ${skill.path}/SKILL.md`)
                 ])
-        ].filter((value) => value !== undefined && value.trim().length > 0);
+        ].filter((value) => value !== undefined && value.trim().length > 0) : [
+            `Yui managed Session. Read and follow the Session Manifest at ${input.sessionManifestPath} (digest ${input.sessionManifestDigest ?? "unknown"}). Load each Skill and Role Profile by its manifest path before acting; Task content is available only through the manifest's exact Context API.`
+        ];
         if (instructions.length === 0)
             return workspaceTrust;
         const nativeInstructions = input.codexDeveloperInstructions
@@ -236,6 +238,9 @@ class ClaudeAdapter extends BaseAdapter {
             };
     }
     launchContextArgs(input) {
+        if (input.sessionManifestPath !== undefined) {
+            return ["--append-system-prompt-file", input.sessionManifestPath];
+        }
         const sections = [
             input.developerInstructions,
             ...(input.skills ?? []).map((skill) => [

package/dist/executor/agentExecutor.js

@@ -412,6 +412,29 @@ export function recordObservedTaskRoleCompletion(set, completion) {
         turnId: observed.turnId
     }, new Date(observed.observedAt));
 }
+/**
+ * Rebinds the same active Run to a bounded control-input receipt while keeping
+ * its observed native Turn completion unsettled. No new Run fence is created.
+ */
+export function rebindTaskRoleRunControlReceipt(set, input, now) {
+    validateRoleSessionSet(set);
+    assertTaskRoleSessionSet(set);
+    const inFlight = set.inFlight;
+    if (inFlight === null
+        || inFlight.agentId !== input.agentId
+        || inFlight.runId !== input.runId) {
+        throw new Error("Workflow outcome control request does not match the unsettled Run.");
+    }
+    const timestamp = requireDate(now, "Workflow outcome control receipt timestamp");
+    return validateRoleSessionSet({
+        ...set,
+        inFlight: {
+            ...inFlight,
+            receiptId: requireSafeIdentity(input.receiptId, "Workflow outcome control receipt id")
+        },
+        updatedAt: timestamp
+    });
+}
 export function clearTaskRoleRun(set, fence, clearedAt) {
     validateRoleSessionSet(set);
     assertTaskRoleSessionSet(set);

package/dist/executor/effectiveLaunch.js

@@ -1,6 +1,8 @@
 import { isDeepStrictEqual } from "node:util";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
+import { roleSessionKind } from "../context/roleSessionContext.js";
+import { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, sessionManifestCompatibilityDigest } from "../context/sessionProtocolIdentity.js";
 export function resolveEffectiveLaunch(input) {
     validateDesiredRole(input.role);
     const binding = input.role.agentBindings[input.role.activeAgentId];
@@ -15,6 +17,10 @@ export function resolveEffectiveLaunch(input) {
         writeProjectIds,
         workspace,
         context: snapshotContext(input.role),
+        contextProtocolVersion: SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION,
+        sessionManifestCompatibilityDigest: sessionManifestCompatibilityDigest(input.role.name, roleSessionKind(input.role, "taskId" in input.role
+            ? { scope: "task", taskId: input.role.taskId }
+            : { scope: "global" }, input.purpose), input.role),
         ...(input.purpose === "review"
             ? {
                 reviewRoundId: identity(input.reviewRoundId ?? "", "ReviewRound id"),
@@ -152,6 +158,18 @@ export function validateEffectiveLaunchSnapshot(snapshot) {
         identity(snapshot.reviewRoundId, "Effective ReviewRound id");
         commit(snapshot.reviewBaseCommit, "Effective review base commit");
     }
+    if (snapshot.contextProtocolVersion !== undefined
+        && snapshot.contextProtocolVersion !== SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION) {
+        throw new Error("Effective launch context protocol version is unsupported.");
+    }
+    if (snapshot.sessionManifestCompatibilityDigest !== undefined
+        && !/^[a-f0-9]{64}$/u.test(snapshot.sessionManifestCompatibilityDigest)) {
+        throw new Error("Effective launch Session Manifest compatibility digest is invalid.");
+    }
+    if ((snapshot.contextProtocolVersion === undefined)
+        !== (snapshot.sessionManifestCompatibilityDigest === undefined)) {
+        throw new Error("Effective launch Context protocol compatibility identity is incomplete.");
+    }
     validateWorkspace(snapshot.workspace);
     cloneContext(snapshot.context);
     const config = effectiveLaunchConfigUnchecked(snapshot);
@@ -204,6 +222,12 @@ function snapshotFromConfig(input) {
         writeProjectIds: [...input.writeProjectIds],
         workspace: cloneWorkspace(input.workspace),
         context: cloneContext(input.context),
+        ...(input.contextProtocolVersion === undefined
+            ? {}
+            : { contextProtocolVersion: input.contextProtocolVersion }),
+        ...(input.sessionManifestCompatibilityDigest === undefined
+            ? {}
+            : { sessionManifestCompatibilityDigest: input.sessionManifestCompatibilityDigest }),
         ...review
     };
     const snapshot = config.adapterId === "codex"

package/dist/executor/executorRegistry.js

@@ -337,11 +337,17 @@ export class ExecutorRegistry {
         return inputs.map((input) => {
             const key = `${input.taskId}\0${input.roleName}`;
             const resource = resources.get(key);
+            const deadPane = inventory.find((pane) => (pane.taskId === input.taskId && pane.roleName === input.roleName && pane.dead));
             return {
                 taskId: input.taskId,
                 roleName: input.roleName,
                 status: present.has(key) ? "present" : "absent",
-                ...(resource === undefined ? {} : { resource })
+                ...(resource === undefined ? {} : { resource }),
+                ...(deadPane === undefined
+                    ? {}
+                    : { hostExit: {
+                            ...(deadPane.deadStatus === undefined ? {} : { deadStatus: deadPane.deadStatus })
+                        } })
             };
         });
     }

package/dist/executor/fileRoleLaunchPlanner.js

@@ -7,7 +7,10 @@ import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/a
 import { NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment } from "../agent/launchEnvironment.js";
 import { activeRoleAgentBinding } from "../role/role.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
-import { compileRoleSessionContext } from "../context/roleSessionContext.js";
+import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
+import { materializeSessionBootstrap } from "../context/sessionBootstrapManifest.js";
+import { serializeRunBootstrapEnvelope, serializeRunHostRecoveryEnvelope } from "../context/runContextContract.js";
+import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
 import { inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
@@ -285,15 +288,27 @@ export class FileRoleLaunchPlanner {
             ? {}
             : taskRuntimeIsolationEnvironment(runtimeIsolation));
         const baseSessionContext = compileRoleSessionContext(this.home, launchRole, owner, sessionPolicy);
-        const sessionContext = owner.scope === "task"
-            ? {
-                ...baseSessionContext,
-                developerInstructions: [
-                    baseSessionContext.developerInstructions,
-                    renderExactControlPlaneInstructions(this.#controlPlane)
-                ].join("\n")
-            }
-            : baseSessionContext;
+        const bootstrap = materializeSessionBootstrap({
+            yuiHome: this.home,
+            role: launchRole,
+            owner,
+            roleKind: roleSessionKind(launchRole, owner, sessionPolicy.purpose),
+            skills: baseSessionContext.skills,
+            controlPlane: this.#controlPlane
+        });
+        if (effective.contextProtocolVersion !== bootstrap.manifest.schemaVersion
+            || effective.sessionManifestCompatibilityDigest
+                !== bootstrap.manifest.compatibilityDigest) {
+            throw new Error("Effective launch Context protocol identity does not match the materialized Session Manifest.");
+        }
+        const sessionContext = {
+            ...baseSessionContext,
+            developerInstructions: `Read and follow the exact Yui Session Manifest at ${bootstrap.manifestPath}.`,
+            managedContextFile: bootstrap.manifestPath,
+            sessionManifestPath: bootstrap.manifestPath,
+            sessionManifestDigest: bootstrap.manifest.digest,
+            sessionCliPath: bootstrap.sessionCliPath
+        };
         const codexConfig = binding.config.adapterId === "codex"
             ? inspectCodexLaunchConfig({
                 environment: {
@@ -327,7 +342,7 @@ export class FileRoleLaunchPlanner {
         const roleConfig = binding.config.adapterId === "claude"
             && owner.scope === "task"
             && input.runId !== undefined
-            ? managedClaudeControlPlaneConfig(binding.config, owner.taskId, managedRun?.workItemId, input.runId, this.#controlPlane)
+            ? managedClaudeControlPlaneConfig(binding.config, owner.taskId, managedRun?.workItemId, input.runId, this.#controlPlane, sessionContext.sessionCliPath)
             : binding.config;
         const effectiveConfig = withNativeProjectDirectories(roleConfig, nativeAdditionalDirectories(effective.workspace, agentWorkspace));
         const compileInput = {
@@ -360,8 +375,17 @@ export class FileRoleLaunchPlanner {
                 nativeSessionId: resumeNativeSessionId
             })
             : adapter.compileNew(compileInput);
-        if (owner.scope === "task" && sessionContext.managedContextFile !== undefined) {
-            this.#resourceRegistrar().registerSessionContext(sessionContext.managedContextFile, { home: resolve(this.home), taskId: owner.taskId, basis: "descriptor" });
+        for (const path of [
+            bootstrap.manifestPath,
+            bootstrap.sessionCliPath,
+            bootstrap.roleProfilePath,
+            bootstrap.descriptorPath
+        ]) {
+            this.#resourceRegistrar().registerSessionContext(path, {
+                home: resolve(this.home),
+                ...(owner.scope === "task" ? { taskId: owner.taskId } : {}),
+                basis: "descriptor"
+            });
         }
         let args = [...compiled.argv];
         let command = configured.command;
@@ -384,8 +408,9 @@ export class FileRoleLaunchPlanner {
                 args = addCodexLifecycleHooks(args, launchMode, this.#cliPath);
                 // End option parsing before the opaque prompt so a wakeup beginning
                 // with '-' can never be reinterpreted as a Codex CLI flag.
-                if (managedRun.pushedAt === undefined)
-                    args.push("--", managedRun.input);
+                if (managedRun.pushedAt === undefined) {
+                    args.push("--", managedRunLaunchEnvelope(managedRun, input.mode));
+                }
             }
             session = launchMode === "resume"
                 ? readySession(input.agentId, binding.adapterId, resumeNativeSessionId, effective)
@@ -412,16 +437,8 @@ export class FileRoleLaunchPlanner {
         const managedClaudeRun = binding.adapterId === "claude"
             && owner.scope === "task"
             && input.runId !== undefined;
-        if (managedClaudeRun) {
-            command = process.execPath;
-            args = [
-                this.#cliPath,
-                "internal",
-                "managed-claude-run",
-                "--",
-                configured.command,
-                ...args
-            ];
+        if (managedClaudeRun && (managedRun === null || managedRun.status !== "active")) {
+            throw new Error(`Managed Claude Run is no longer active: ${input.runId}.`);
         }
         const runtimeDescriptor = owner.scope === "task"
             ? createExactTaskRuntimeDescriptor({
@@ -455,6 +472,18 @@ export class FileRoleLaunchPlanner {
         const launch = {
             command,
             args,
+            ...(managedRun?.providerRetry !== undefined
+                && managedRun.providerRetry.state !== "dispatching"
+                ? { deferProviderStart: true }
+                : {}),
+            ...(managedClaudeRun
+                ? {
+                    providerInput: {
+                        kind: "stdin-json-user-message",
+                        boundedText: managedRunLaunchEnvelope(managedRun, input.mode)
+                    }
+                }
+                : {}),
             env: {
                 ...launchEnvironment,
                 YUI_HOME: resolve(this.home),
@@ -465,6 +494,8 @@ export class FileRoleLaunchPlanner {
                 YUI_ADAPTER_ID: configured.adapterId,
                 YUI_DRIVER_ID: driver.id,
                 YUI_WORKSPACE: effectiveWorkspace,
+                YUI_SESSION_MANIFEST: sessionContext.sessionManifestPath,
+                YUI_SESSION_CLI: sessionContext.sessionCliPath,
                 ...(jobCallerKey === undefined ? {} : { YUI_JOB_CALLER_KEY: jobCallerKey }),
                 ...(runtimeDescriptor === undefined
                     ? {}
@@ -490,7 +521,8 @@ export class FileRoleLaunchPlanner {
                 ...(session === null
                     ? {}
                     : { YUI_NATIVE_SESSION_ID: session.nativeSessionId })
-            }
+            },
+            childLifecycle: driver.capabilities.lifecycle.providerProcess
         };
         const scopedLaunch = owner.scope === "task"
             ? this.#applyWorkspaceScope(owner.taskId, role, launch, workspaceOverride)
@@ -547,6 +579,19 @@ export class FileRoleLaunchPlanner {
         return selectEnvironment(source, names);
     }
 }
+function managedRunLaunchEnvelope(run, mode) {
+    if (run.providerRetry?.state === "dispatching") {
+        return serializeProviderRetryEnvelope({
+            taskId: run.taskId,
+            runId: run.id,
+            roleName: run.roleName,
+            retry: run.providerRetry
+        });
+    }
+    return mode === "resume" && run.pushedAt !== undefined
+        ? serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope)
+        : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
+}
 export function nativeAgentWorkspace(workspace) {
     return workspace.entries.length === 1
         ? workspace.entries[0].path
@@ -629,11 +674,12 @@ function ensureManagedClaudeLifecyclePlugin(home, cliPath) {
     }, null, 2)}\n`);
     return root;
 }
-function managedClaudeControlPlaneConfig(config, taskId, workItemId, runId, controlPlane) {
+function managedClaudeControlPlaneConfig(config, taskId, workItemId, runId, controlPlane, sessionCliPath) {
     if (config.permission.strategy !== "configured")
         return config;
     const exact = exactControlPlaneCommandPrefix(controlPlane);
     const managed = [
+        `Bash(${sessionCliPath} task run context ${taskId}/${runId}:*)`,
         `Bash(${exact} --json task context ${taskId})`,
         `Bash(${exact} --json task work list ${taskId})`,
         ...(workItemId === undefined

package/dist/lifecycle/exactRunTerminalization.js

@@ -7,10 +7,9 @@ import { updateRoleStatus } from "../role/role.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
 import { reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
-import { failAgentRun, withYieldReceipt, yieldAgentRun } from "../run/agentRun.js";
+import { agentRunDeliveryReceiptId, failAgentRun, withYieldReceipt, yieldAgentRun } from "../run/agentRun.js";
 import { createYieldReceipt } from "../run/yieldReceipt.js";
 import { recordExecutionLaneResult } from "../execution/executionGroup.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { clearMatchingLeaderStallAttention, latestRunDurableProgressAt, RUN_RECOVERY_APPLIED_EVENT, RUN_RECOVERY_REQUESTED_EVENT } from "../scheduler/roleRunStall.js";
 import { markTaskWakeConsumed } from "../scheduler/taskWake.js";
@@ -466,7 +465,7 @@ function recoverExactAgentRunInTransaction(store, input) {
         roleName: input.roleName,
         agentId: input.agentId,
         runId: input.runId,
-        receiptId: formatAgentRunReceiptId(input.taskId, input.runId),
+        receiptId: agentRunDeliveryReceiptId(current),
         ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
         ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
         outcome: { status: "failed", summary: input.reason }

package/dist/lifecycle/providerErrorClass.js

@@ -51,9 +51,13 @@ const SESSION_DEAD_PATTERNS = [
     { pattern: /session (has )?ended/iu, label: "session-ended" },
     { pattern: /session (is )?dead/iu, label: "session-dead" },
     { pattern: /session terminated/iu, label: "session-terminated" },
-    { pattern: /process exited/iu, label: "process-exited" },
-    { pattern: /pane (is )?dead/iu, label: "pane-dead" },
-    { pattern: /target session/iu, label: "target-session" }
+];
+const CONTEXT_CAPACITY_PATTERNS = [
+    { pattern: /maximum context length/iu, label: "maximum-context-length" },
+    { pattern: /context length exceeded/iu, label: "context-length-exceeded" },
+    { pattern: /context window (is )?(full|exceeded)/iu, label: "context-window-exceeded" },
+    { pattern: /prompt (is )?too long/iu, label: "prompt-too-long" },
+    { pattern: /too many tokens/iu, label: "too-many-tokens" }
 ];
 const POLICY_DENIED_PATTERNS = [
     { pattern: /cyber[_-]?policy/iu, label: "cyber-policy" },
@@ -112,6 +116,7 @@ const TRANSPORT_UNCERTAIN_PATTERNS = [
 const CLASS_TABLE = [
     { errorClass: "session-dead", patterns: SESSION_DEAD_PATTERNS },
     { errorClass: "policy-denied", patterns: POLICY_DENIED_PATTERNS },
+    { errorClass: "context-capacity", patterns: CONTEXT_CAPACITY_PATTERNS },
     { errorClass: "invalid-request", patterns: INVALID_REQUEST_PATTERNS },
     { errorClass: "transient-provider", patterns: TRANSIENT_PROVIDER_PATTERNS },
     { errorClass: "transport-uncertain", patterns: TRANSPORT_UNCERTAIN_PATTERNS }