@zq-silk/yui 0.6.16 → 0.7.0

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/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 }

package/dist/observability/executionAudit.js

@@ -63,7 +63,7 @@ function directorySizeBytes(path) {
     }
     return total;
 }
-const WAKE_REASON_PATTERN = /Yui wakeup reasons: ([^\n.]+)/u;
+const WAKE_REASON_PATTERN = /Wake reasons: ([^\n.]+)/u;
 function inWindow(createdAt, options) {
     const time = Date.parse(createdAt);
     if (!Number.isFinite(time))
@@ -207,6 +207,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             providerRetries: section,
             workItems: section,
             storage: section,
+            runtimeProtocol: section,
             topLongRunning: section
         };
     }
@@ -314,7 +315,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                     if (!inWindow(run.createdAt, options))
                         continue;
                     leaderRuns += 1;
-                    const match = WAKE_REASON_PATTERN.exec(run.input);
+                    const match = WAKE_REASON_PATTERN.exec(run.assignment.directive ?? "");
                     if (match === null)
                         continue;
                     withWakeReasons += 1;
@@ -705,6 +706,89 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             return failed(error);
         }
     })();
+    const runtimeProtocol = (() => {
+        try {
+            const protocolVersions = new Map();
+            const manifestDigests = new Set();
+            const retryStates = new Map();
+            const exitClassifications = new Map();
+            const usageSemantics = new Map();
+            let activeRetryEpisodes = 0;
+            let activeConsecutiveFailures = 0;
+            let activeDispatchedRetries = 0;
+            let retryClassifiedEvents = 0;
+            let retryDispatchedEvents = 0;
+            let retryRecoveredEvents = 0;
+            let retryExhaustedEvents = 0;
+            let contextCapacityFailures = 0;
+            let processExitObservations = 0;
+            let compactionEvents = 0;
+            for (const taskId of taskIds) {
+                for (const run of store.listAgentRuns(taskId)) {
+                    if (!inWindow(run.createdAt, options))
+                        continue;
+                    const version = String(run.effective.contextProtocolVersion ?? "legacy");
+                    protocolVersions.set(version, (protocolVersions.get(version) ?? 0) + 1);
+                    if (run.effective.sessionManifestCompatibilityDigest !== undefined) {
+                        manifestDigests.add(run.effective.sessionManifestCompatibilityDigest);
+                    }
+                    if (run.providerRetry !== undefined) {
+                        activeRetryEpisodes += 1;
+                        retryStates.set(run.providerRetry.state, (retryStates.get(run.providerRetry.state) ?? 0) + 1);
+                        activeConsecutiveFailures += run.providerRetry.consecutiveFailures;
+                        activeDispatchedRetries += run.providerRetry.dispatchedRetries;
+                    }
+                }
+                for (const event of store.listEvents(taskId)) {
+                    if (!inWindow(event.createdAt, options))
+                        continue;
+                    if (event.type === "runtime.provider-retry-classified")
+                        retryClassifiedEvents += 1;
+                    else if (event.type === "runtime.provider-retry-dispatched")
+                        retryDispatchedEvents += 1;
+                    else if (event.type === "runtime.provider-retry-recovered")
+                        retryRecoveredEvents += 1;
+                    else if (event.type === "runtime.provider-retry-exhausted")
+                        retryExhaustedEvents += 1;
+                    else if (event.type === "runtime.context-capacity-failure")
+                        contextCapacityFailures += 1;
+                    else if (event.type === "runtime.process-exit-observed") {
+                        processExitObservations += 1;
+                        const classification = event.payload.classification ?? "unknown";
+                        exitClassifications.set(classification, (exitClassifications.get(classification) ?? 0) + 1);
+                    }
+                    const observation = runtimeObservationFromTaskEvent(event);
+                    const semantics = observation?.payload.usage?.semantics;
+                    if (semantics !== undefined) {
+                        usageSemantics.set(semantics, (usageSemantics.get(semantics) ?? 0) + 1);
+                    }
+                    if (event.type === "runtime.compaction-started"
+                        || event.type === "runtime.compaction-completed")
+                        compactionEvents += 1;
+                }
+            }
+            return ok({
+                contextProtocolVersions: Object.fromEntries(protocolVersions),
+                manifestCompatibilityDigests: manifestDigests.size,
+                activeRetryEpisodes,
+                activeRetryStates: Object.fromEntries(retryStates),
+                activeConsecutiveFailures,
+                activeDispatchedRetries,
+                retryClassifiedEvents,
+                retryDispatchedEvents,
+                retryRecoveredEvents,
+                retryExhaustedEvents,
+                contextCapacityFailures,
+                processExitObservations,
+                processExitClassifications: Object.fromEntries(exitClassifications),
+                usageSemantics: Object.fromEntries(usageSemantics),
+                compactionEvents
+            });
+        }
+        catch (error) {
+            return failed(error);
+        }
+    })();
     const topLongRunning = (() => {
         try {
             const entries = [];
@@ -751,6 +835,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         providerRetries,
         workItems,
         storage,
+        runtimeProtocol,
         topLongRunning
     };
 }