@zq-silk/yui 0.11.3 → 0.12.1

package/dist/executor/agentExecutor.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, effectiveLaunchSnapshotsCompatibleForTaskReview, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
-import { rebindProviderRuntimeRun, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
+import { currentProviderActivation, endProviderActivation, rebindProviderRuntimeRun, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
     const base = {
@@ -69,7 +69,7 @@ export function recordRoleAgentSession(set, input, now) {
     if (existing !== undefined && existing.nativeSessionId === nativeSessionId
         && !effectiveLaunchSnapshotsCompatible(existing.effective, effective)
         && !(set.owner.scope === "task"
-            && effectiveLaunchSnapshotsCompatibleForTaskReview(existing.effective, effective))) {
+            && effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, effective))) {
         throw new Error(`Role Agent session effective launch cannot change: ${agentId}.`);
     }
     if (existing !== undefined && existing.nativeSessionId !== nativeSessionId
@@ -120,6 +120,20 @@ export function recordRoleAgentSession(set, input, now) {
     validateRoleSessionSet(updated);
     return updated;
 }
+/**
+ * Atomically archives the quiescent old native Session and binds the Provider
+ * Conversation selected by an already-authorized switch. Authorization is
+ * deliberately owned by the Controller caller, not inferred here.
+ */
+export function replaceTaskRoleAgentSessionForConversationSwitch(set, input, now) {
+    validateRoleSessionSet(set);
+    const existing = set.sessions[input.agentId];
+    if (existing === undefined || existing.nativeSessionId === input.nativeSessionId) {
+        return recordRoleAgentSession(set, input, now);
+    }
+    const terminalized = updateRoleAgentSessionStatus(set, input.agentId, "stopped", now);
+    return recordRoleAgentSession(terminalized, input, now);
+}
 /**
  * Session titles and previews can originate in native Agent output. Keep them
  * single-line and inert before they are persisted or rendered in a terminal.
@@ -179,25 +193,6 @@ export function retireTaskRoleSessionsForWorkspace(set, now) {
         updatedAt: timestamp
     });
 }
-/**
- * Clears the Provider transport identity after its physical runtime is proven
- * stopped, without retiring workspace-bound Session records. Workspace
- * retirement remains a separate, stricter transaction after every supported
- * placeholder has been terminalized.
- */
-export function clearTaskRoleProviderRuntimeForCleanup(set, now) {
-    validateRoleSessionSet(set);
-    if (set.inFlight !== null) {
-        throw new Error("Cannot clear a Task Role Provider runtime with unsettled Run state.");
-    }
-    if (set.providerBinding === null)
-        return set;
-    return validateRoleSessionSet({
-        ...set,
-        providerBinding: null,
-        updatedAt: requireDate(now, "Provider Runtime cleanup timestamp")
-    });
-}
 /**
  * Terminalizes only the aggregate-16 Claude placeholder shape after the
  * caller has fenced the Task store and proved that the exact Role has no live
@@ -264,7 +259,7 @@ export function rememberRoleAgentCompletedTurn(set, agentId, nativeSessionId, tu
     };
     return validateRoleSessionSet(updated);
 }
-export function roleAgentSessionResumeMode(set, agentId, desired, workspace) {
+export function roleAgentSessionResumeMode(set, agentId, desired) {
     if (set === null)
         return "new";
     validateRoleSessionSet(set);
@@ -287,7 +282,7 @@ export function roleAgentSessionResumeMode(set, agentId, desired, workspace) {
         return "new";
     }
     const compatible = set.owner.scope === "task"
-        ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, desired, workspace)
+        ? effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, desired)
         : effectiveLaunchSnapshotsCompatible(session.effective, desired);
     if (compatible)
         return "resume";
@@ -307,7 +302,10 @@ export function bindTaskRoleRun(set, fence, preparedAt, mode) {
         throw new Error("Task Role session set already has an in-flight Run.");
     }
     const timestamp = requireDate(preparedAt, "Task Role Run preparedAt");
-    const providerBinding = mode === "resume" && set.providerBinding !== null
+    // A fresh Conversation is a two-phase replacement: keep the old binding as
+    // current evidence until the new Provider session is observed and atomically
+    // superseded. Homes with no prior Conversation still start from null.
+    const providerBinding = set.providerBinding !== null
         ? rebindProviderRuntimeRun(set.providerBinding, normalized.runId)
         : null;
     const updated = {
@@ -372,6 +370,35 @@ export function updateTaskRoleProviderRuntime(set, binding, updatedAt) {
         updatedAt: requireDate(updatedAt, "Provider Runtime Binding timestamp")
     });
 }
+/**
+ * Records an exact local Host exit without forgetting the Provider
+ * Conversation. The ended Activation releases writer authority, while the
+ * current Conversation and any unsettled Turn remain durable recovery fences.
+ */
+export function stopTaskRoleRuntimeAfterPhysicalExit(set, now) {
+    validateRoleSessionSet(set);
+    const active = set.sessions[set.activeAgentId];
+    if (active === undefined)
+        return set;
+    const activation = set.providerBinding === null
+        ? null
+        : currentProviderActivation(set.providerBinding);
+    if (active.status === "stopped") {
+        if (activation !== null) {
+            throw new Error("Stopped Task Role Session cannot retain a live Provider Activation.");
+        }
+        return set;
+    }
+    let updated = updateRoleAgentSessionStatus(set, set.activeAgentId, "stopped", now);
+    if (activation !== null) {
+        updated = updateTaskRoleProviderRuntime(updated, endProviderActivation(updated.providerBinding, activation.activationId, {
+            status: "ended",
+            endedAt: now.toISOString(),
+            reason: "runtime-physical-exit"
+        }), now);
+    }
+    return updated;
+}
 export function markTaskRoleRunPushed(set, fence, pushedAt) {
     validateRoleSessionSet(set);
     assertTaskRoleSessionSet(set);
@@ -515,31 +542,6 @@ export function terminalizeTaskRoleRunSession(set, fence, terminalAt) {
     }
     return updated;
 }
-/**
- * Resets the current native generation after its active Run is terminal.
- * The Controller separately owns verified process cleanup.
- */
-export function resetTaskRoleSession(set, now) {
-    validateRoleSessionSet(set);
-    const timestamp = requireDate(now, "Task Role Session reset timestamp");
-    const current = set.sessions[set.activeAgentId];
-    const sessions = { ...set.sessions };
-    delete sessions[set.activeAgentId];
-    const history = current === undefined
-        ? set.history
-        : [
-            ...(set.history ?? []),
-            { ...current, status: "broken", updatedAt: timestamp }
-        ];
-    return validateRoleSessionSet({
-        ...set,
-        sessions,
-        ...(history === undefined ? {} : { history }),
-        inFlight: null,
-        providerBinding: null,
-        updatedAt: timestamp
-    });
-}
 export function settleTaskRoleCompletion(set, expected, settledAt) {
     validateRoleSessionSet(set);
     assertTaskRoleSessionSet(set);

package/dist/executor/effectiveLaunch.js

@@ -79,50 +79,20 @@ export function effectiveLaunchSnapshotsCompatible(existing, desired) {
     return isDeepStrictEqual(withoutDesiredRevision(existing), withoutDesiredRevision(desired));
 }
 /**
- * A Task-owned main workspace is a mutable checkout: Integration advances its
- * durable Git heads while an idle native Session keeps the immutable launch
- * configuration with which it started. A later Run may resume that exact
- * Session only when the current durable Task workspace proves that every
- * non-commit workspace identity and every other launch field is unchanged.
- * A Task-final Reviewer workspace is also mutable between semantic Rounds: it
- * keeps one Role-owned physical identity while its frozen commits and Round
- * identity advance. WorkItem and ExecutionLane workspaces remain strict.
+ * Task Role Sessions keep one physical workspace while Run-scoped facts move.
+ * Candidate commits, ReviewRound identity and desired-revision bookkeeping do
+ * not define a native Session. Agent, adapter, permission, model, sandbox,
+ * manifest, Role context and physical workspace identity still do.
  */
-export function effectiveLaunchSnapshotsCompatibleForTaskMain(existing, desired, workspace) {
+export function effectiveLaunchSnapshotsCompatibleForTaskSession(existing, desired) {
     if (effectiveLaunchSnapshotsCompatible(existing, desired))
         return true;
     validateEffectiveLaunchSnapshot(existing);
     validateEffectiveLaunchSnapshot(desired);
-    if (workspace === null || workspace === undefined)
+    if ((existing.reviewRoundId === undefined) !== (desired.reviewRoundId === undefined)) {
         return false;
-    validateManagedWorkspace(workspace);
-    const durableWorkspace = {
-        root: workspace.root,
-        entries: workspace.entries.map((entry) => ({ ...entry }))
-    };
-    if (!isDeepStrictEqual(desired.workspace, durableWorkspace))
-        return false;
-    if (workspace.owner.type === "review-round") {
-        return effectiveLaunchSnapshotsCompatibleForTaskReview(existing, desired);
     }
-    if (workspace.owner.type !== "task")
-        return false;
-    return isDeepStrictEqual(taskMainCompatibleSnapshot(existing), taskMainCompatibleSnapshot(desired));
-}
-/**
- * Same Task Reviewer Role, same stable physical workspace and launch policy,
- * but a new semantic ReviewRound and frozen head. The native Session keeps its
- * conversation; each AgentRun still records the new exact Round snapshot.
- */
-export function effectiveLaunchSnapshotsCompatibleForTaskReview(existing, desired) {
-    validateEffectiveLaunchSnapshot(existing);
-    validateEffectiveLaunchSnapshot(desired);
-    if (existing.reviewRoundId === undefined
-        || existing.reviewBaseCommit === undefined
-        || desired.reviewRoundId === undefined
-        || desired.reviewBaseCommit === undefined)
-        return false;
-    return isDeepStrictEqual(taskReviewCompatibleSnapshot(existing), taskReviewCompatibleSnapshot(desired));
+    return isDeepStrictEqual(taskSessionCompatibleSnapshot(existing), taskSessionCompatibleSnapshot(desired));
 }
 /** Preserves a fixed Session's launch configuration while freezing fresh Task-main Git facts. */
 export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
@@ -139,17 +109,7 @@ export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
         }
     });
 }
-function taskMainCompatibleSnapshot(snapshot) {
-    const { sourceDesiredRevision: _sourceDesiredRevision, workspace, ...launch } = snapshot;
-    return {
-        ...launch,
-        workspace: {
-            root: workspace.root,
-            entries: workspace.entries.map(({ baseCommit: _baseCommit, ...entry }) => entry)
-        }
-    };
-}
-function taskReviewCompatibleSnapshot(snapshot) {
+function taskSessionCompatibleSnapshot(snapshot) {
     const { sourceDesiredRevision: _sourceDesiredRevision, reviewRoundId: _reviewRoundId, reviewBaseCommit: _reviewBaseCommit, workspace, ...launch } = snapshot;
     return {
         ...launch,

package/dist/executor/fileRoleLaunchPlanner.js

@@ -1,4 +1,5 @@
 import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -11,20 +12,23 @@ import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessi
 import { materializeSessionBootstrap } from "../context/sessionBootstrapManifest.js";
 import { serializeRunBootstrapEnvelope, serializeRunHostRecoveryEnvelope } from "../context/runContextContract.js";
 import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
+import { serializeWorkflowOutcomeRequestEnvelope } from "../run/runControlRequest.js";
 import { prefixYuiTitleInput } from "../run/runIdentity.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
 import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { classifyWorkspacePreflight, formatWorkspacePreflightError } from "./workspacePreflightClassification.js";
 import { activeLiveRoleAgentSession } from "./agentExecutor.js";
-import { effectiveLaunchSnapshotsCompatibleForTaskMain, effectiveLaunchSnapshotsCompatible, effectiveRoleForLaunch, resolveEffectiveLaunch } from "./effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatibleForTaskSession, effectiveLaunchSnapshotsCompatible, effectiveRoleForLaunch, resolveEffectiveLaunch } from "./effectiveLaunch.js";
 import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactTaskRuntimeState, createExactControlPlaneDescriptor, createExactTaskRuntimeDescriptor, exactControlPlaneDigest, exactTaskRuntimeDescriptorPath, serializeExactDescriptor } from "../runtime/exactControlPlane.js";
 import { detectRunningRelease } from "../release/runtimeRelease.js";
 import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment } from "../runtime/taskRuntimeIsolation.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { builtinAgentDriverRegistry, builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { managedRuntimeAdmission } from "../runtime/agentDriver.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { freshConversationLaunchAllowed } from "../runtime/conversationSwitch.js";
+import { currentProviderActivation } from "../runtime/providerRuntimeIdentity.js";
 import { assertCodexLaunchOverridesAvailable, inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 /** Builds managed native Agent launches from the authoritative Task records. */
 export class FileRoleLaunchPlanner {
@@ -35,6 +39,7 @@ export class FileRoleLaunchPlanner {
     #nativeAgentEnvironment;
     #createNativeSessionId;
     #cliPath;
+    #inspectWorkspacePhysicalState;
     #controlPlane;
     #resourceRegistrarValue;
     constructor(home, store, options = {}) {
@@ -51,6 +56,8 @@ export class FileRoleLaunchPlanner {
         this.#agentEnvironment = this.#selectConfiguredAgentEnvironment(sourceEnvironment);
         this.#nativeAgentEnvironment = this.#selectConfiguredNativeEnvironment(sourceEnvironment);
         this.#createNativeSessionId = options.createNativeSessionId ?? randomUUID;
+        this.#inspectWorkspacePhysicalState = options.inspectWorkspacePhysicalState
+            ?? inspectWorkspacePhysicalState;
         this.#cliPath = canonicalPath(options.cliPath
             ?? fileURLToPath(new URL("../cli.js", import.meta.url)));
         // Internal callbacks retain one exact command identity for receipt fencing.
@@ -143,7 +150,7 @@ export class FileRoleLaunchPlanner {
         const main = this.store.getTaskWorkspace(task.id);
         // Quick Win (EXE-04/EXE-08): classify workspace preflight failures so
         // split-brain state is never reported as a transient Provider failure.
-        const preflight = classifyWorkspacePreflight(this.store, task, input.roleName, activeRun === null ? null : { id: activeRun.id, workspace: activeRun.workspace });
+        const preflight = classifyWorkspacePreflight(this.store, task, input.roleName, activeRun === null ? null : { id: activeRun.id, workspace: activeRun.workspace }, this.#inspectWorkspacePhysicalState);
         if (preflight !== null) {
             throw new Error(formatWorkspacePreflightError(preflight));
         }
@@ -215,11 +222,25 @@ export class FileRoleLaunchPlanner {
         const existing = sessionSet?.sessions[effective.agentId];
         const compatibleExisting = existing !== undefined
             && (input.mode === "resume"
-                ? effectiveLaunchSnapshotsCompatibleForTaskMain(existing.effective, effective, runWorkspace ?? workspace)
+                ? effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, effective)
                 : effectiveLaunchSnapshotsCompatible(existing.effective, effective));
         if (input.mode === "resume" && !compatibleExisting) {
             throw new Error(`Task Role resume effective snapshot drifted: ${task.id}/${role.name}.`);
         }
+        if (input.mode === "new" && sessionSet !== null
+            && !freshConversationLaunchAllowed({
+                sessions: sessionSet,
+                events: this.store.listEvents(task.id),
+                mailbox: this.store.getWorkMailbox({
+                    kind: "role",
+                    taskId: task.id,
+                    roleName: role.name
+                }),
+                roleName: role.name,
+                ...(input.runId === undefined ? {} : { candidateRunId: input.runId })
+            })) {
+            throw new Error(`Fresh Provider Conversation is not authorized: ${task.id}/${role.name}.`);
+        }
         return this.#compile(role, input, { scope: "task", taskId: task.id }, resolveTaskRoleSessionTitle(input.mode === "resume" ? existing?.title : undefined, task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
             purpose: activeRun?.purpose ?? "execution"
         });
@@ -322,9 +343,6 @@ export class FileRoleLaunchPlanner {
         const managedRun = owner.scope === "task" && input.runId !== undefined
             ? this.store.getAgentRun(owner.taskId, input.runId)
             : null;
-        const managedSessionSet = owner.scope === "task" && input.runId !== undefined
-            ? this.store.getTaskRoleSessionSet(owner.taskId, role.name)
-            : null;
         const driver = builtinAgentDriverRegistry().require(builtinDriverIdForAdapter(configured.adapterId));
         if (owner.scope === "task" && input.runId !== undefined) {
             const admission = managedRuntimeAdmission(driver.capabilities);
@@ -401,6 +419,9 @@ export class FileRoleLaunchPlanner {
         let args = [...compiled.argv];
         let command = configured.command;
         let session;
+        if (binding.adapterId === "claude" && (managedControl || owner.scope === "global")) {
+            args.push("--plugin-dir", ensureClaudeLifecyclePlugin(this.home, this.#cliPath));
+        }
         if (binding.adapterId === "codex") {
             // Global/interactive Codex sessions still use notify for presentation.
             // Managed Runs use the structured Driver Hook as their sole lifecycle
@@ -423,8 +444,6 @@ export class FileRoleLaunchPlanner {
                 : null;
         }
         else if (launchMode === "new") {
-            if (managedControl)
-                args.push("--plugin-dir", ensureManagedClaudeLifecyclePlugin(this.home, this.#cliPath));
             const nativeSessionId = requireText(preallocatedNativeSessionId, "Native session id");
             if (!managedControl)
                 args.push("--session-id", nativeSessionId);
@@ -433,9 +452,6 @@ export class FileRoleLaunchPlanner {
             session = readySession(input.agentId, binding.adapterId, nativeSessionId, effective);
         }
         else {
-            if (managedControl) {
-                args.push("--plugin-dir", ensureManagedClaudeLifecyclePlugin(this.home, this.#cliPath));
-            }
             session = readySession(input.agentId, binding.adapterId, resumeNativeSessionId, effective);
         }
         const managedClaudeRun = binding.adapterId === "claude"
@@ -465,45 +481,74 @@ export class FileRoleLaunchPlanner {
         if (runtimeDescriptor !== undefined && runtimeDescriptorSource !== undefined) {
             this.#writeExactTaskRuntimeDescriptor(runtimeDescriptor, runtimeDescriptorSource);
         }
-        // rr13/rr26: Generate a per-Session DurableJob caller key for every
-        // task-scope launch, including resume.  Resume/ensure may reuse a live
-        // host, so its candidate hash is committed by TmuxSessionHost only when
-        // hostCreated=true; otherwise the live process keeps its existing key.
+        // Generate a candidate per-Provider-process DurableJob caller key for
+        // every task-scope launch. A reused live Conversation keeps the key that
+        // its process inherited; a new Host or a Conversation replacement commits
+        // the fresh candidate only after Provider dispatch is observed.
         let jobCallerKey;
         if (owner.scope === "task" && (input.mode === "new" || input.mode === "resume")) {
             jobCallerKey = randomBytes(32).toString("hex");
         }
-        const carriesInitialTurn = managedControl
-            && managedRun?.pushedAt === undefined
-            && (managedSessionSet?.providerBinding === null
-                || managedSessionSet?.providerBinding === undefined);
+        // Every managed launch for an unpushed Run owns that Run's first Provider
+        // write, whether it creates or resumes the native Conversation. Keeping
+        // resume on the same launch handshake prevents a durable AgentRun from
+        // existing without a corresponding Provider Turn.
+        if (managedControl && (managedRun === null || managedRun.status !== "active")) {
+            throw new Error(`Managed Run is no longer active: ${input.runId}.`);
+        }
+        const carriesInitialTurn = managedControl && (managedRun.pushedAt === undefined
+            || managedRun.providerRetry?.state === "dispatching"
+            || managedRun.controlRequest?.state === "dispatching");
         const providerAuthority = managedControl
-            ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId)
+            ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId, input.mode)
             : undefined;
         const providerNativeSessionId = binding.adapterId === "claude"
             ? preallocatedNativeSessionId
             : resumeNativeSessionId;
-        const providerControl = managedControl
+        const initialTurn = carriesInitialTurn
             ? {
-                schemaVersion: 1,
-                adapterId: binding.adapterId,
-                transport: managedCompiled.transport,
-                mode: resumeNativeSessionId === undefined ? "new" : "resume",
-                ...(providerNativeSessionId === undefined
-                    ? {}
-                    : { nativeSessionId: providerNativeSessionId }),
-                ...(sessionTitle === undefined ? {} : { sessionTitle }),
-                authority: providerAuthority,
-                ...(carriesInitialTurn
-                    ? {
-                        initialTurn: {
-                            attemptId: formatAgentRunReceiptId(owner.taskId, input.runId),
-                            boundedText: managedRunLaunchEnvelope(managedRun, input.mode, sessionTitle)
-                        }
-                    }
-                    : {})
+                attemptId: agentRunDeliveryReceiptId(managedRun),
+                boundedText: managedRunLaunchEnvelope(managedRun, input.mode, sessionTitle)
             }
             : undefined;
+        const providerControl = !managedControl
+            ? undefined
+            : initialTurn === undefined
+                ? {
+                    schemaVersion: 1,
+                    adapterId: binding.adapterId,
+                    transport: managedCompiled.transport,
+                    kind: "ensure",
+                    mode: "resume",
+                    nativeSessionId: requireText(providerNativeSessionId, "Managed Provider ensure native session id"),
+                    ...(sessionTitle === undefined ? {} : { sessionTitle }),
+                    authority: providerAuthority
+                }
+                : resumeNativeSessionId === undefined
+                    ? {
+                        schemaVersion: 1,
+                        adapterId: binding.adapterId,
+                        transport: managedCompiled.transport,
+                        kind: "new",
+                        mode: "new",
+                        ...(providerNativeSessionId === undefined
+                            ? {}
+                            : { nativeSessionId: providerNativeSessionId }),
+                        ...(sessionTitle === undefined ? {} : { sessionTitle }),
+                        authority: providerAuthority,
+                        initialTurn
+                    }
+                    : {
+                        schemaVersion: 1,
+                        adapterId: binding.adapterId,
+                        transport: managedCompiled.transport,
+                        kind: "resume",
+                        mode: "resume",
+                        nativeSessionId: requireText(providerNativeSessionId, "Managed Provider resume native session id"),
+                        ...(sessionTitle === undefined ? {} : { sessionTitle }),
+                        authority: providerAuthority,
+                        initialTurn
+                    };
         const launch = {
             command,
             args,
@@ -571,13 +616,26 @@ export class FileRoleLaunchPlanner {
                 : {})
         };
     }
-    #providerAuthorityForLaunch(taskId, roleName, launchId) {
+    #providerAuthorityForLaunch(taskId, roleName, launchId, mode) {
         const activationId = requireText(launchId, "Managed Provider Activation id");
         const binding = this.store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding;
         if (binding === null || binding === undefined) {
             return { epoch: 1, owner: "controller", holderId: activationId };
         }
         if (binding.authority.owner === "controller") {
+            if (mode === "new") {
+                const activation = currentProviderActivation(binding);
+                if (activation === null || binding.authority.holderId !== activation.activationId) {
+                    throw new Error(`Provider Activation is not exact: ${taskId}/${roleName}.`);
+                }
+                // An actor-requested switch first ends the idle old Activation (+1)
+                // and then binds the replacement Activation (+1).
+                return {
+                    epoch: binding.authority.epoch + 2,
+                    owner: "controller",
+                    holderId: activationId
+                };
+            }
             return {
                 epoch: binding.authority.epoch,
                 owner: "controller",
@@ -641,9 +699,16 @@ function managedRunLaunchEnvelope(run, mode, title) {
             roleName: run.roleName,
             retry: run.providerRetry
         })
-        : mode === "resume" && run.pushedAt !== undefined
-            ? serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope)
-            : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
+        : run.controlRequest?.state === "dispatching"
+            ? serializeWorkflowOutcomeRequestEnvelope({
+                taskId: run.taskId,
+                runId: run.id,
+                roleName: run.roleName,
+                request: run.controlRequest
+            })
+            : mode === "resume" && run.pushedAt !== undefined
+                ? serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope)
+                : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
     return title === undefined
         ? body
         : prefixYuiTitleInput(body, title);
@@ -698,11 +763,11 @@ function workspaceScopeEnvironment(environment, workspace) {
         ])))
     };
 }
-function ensureManagedClaudeLifecyclePlugin(home, cliPath) {
+function ensureClaudeLifecyclePlugin(home, cliPath) {
     const root = join(resolve(home), "runtime", "claude-lifecycle-plugin");
     writeTextFileAtomically(join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify({
         name: "yui-runtime-lifecycle",
-        description: "Yui-owned exact Run lifecycle transport",
+        description: "Yui-owned native lifecycle transport",
         version: "1.0.0"
     }, null, 2)}\n`);
     const command = {
@@ -766,6 +831,25 @@ function canonicalPath(path) {
         return absolute;
     }
 }
+const inspectWorkspacePhysicalState = (entry) => {
+    const headResult = spawnSync("git", ["-C", entry.path, "rev-parse", "HEAD"], { encoding: "utf8", shell: false, timeout: 5_000 });
+    if (headResult.error !== undefined || headResult.status !== 0) {
+        throw new Error(`Managed workspace physical HEAD could not be inspected: ${entry.projectId} @ ${entry.path}.`);
+    }
+    const physicalCommit = headResult.stdout.trim().toLowerCase();
+    if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/u.test(physicalCommit)) {
+        throw new Error(`Managed workspace physical HEAD is invalid: ${entry.projectId}.`);
+    }
+    const ancestorResult = spawnSync("git", ["-C", entry.path, "merge-base", "--is-ancestor", entry.baseCommit, physicalCommit], { encoding: "utf8", shell: false, timeout: 5_000 });
+    if (ancestorResult.error !== undefined
+        || (ancestorResult.status !== 0 && ancestorResult.status !== 1)) {
+        throw new Error(`Managed workspace lineage could not be inspected: ${entry.projectId} @ ${entry.path}.`);
+    }
+    return {
+        physicalCommit,
+        recordedBaseIsAncestor: ancestorResult.status === 0
+    };
+};
 function shellQuote(value) {
     return `'${value.replaceAll("'", "'\"'\"'")}'`;
 }

package/dist/executor/workspacePreflightClassification.js

@@ -21,7 +21,7 @@ function ownerLabel(owner) {
  * This is a read-only check: it never mutates Git state, creates Sessions, or
  * writes recovery records.
  */
-export function classifyWorkspacePreflight(store, task, roleName, activeRun) {
+export function classifyWorkspacePreflight(store, task, roleName, activeRun, inspectPhysical) {
     const main = store.getTaskWorkspace(task.id);
     const bindings = task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory }));
     // 1. Owner validation: the Task main workspace must be a durable,
@@ -83,6 +83,27 @@ export function classifyWorkspacePreflight(store, task, roleName, activeRun) {
             };
         }
     }
+    // 3. Physical validation: committed work may advance a managed branch, so
+    // HEAD need not equal its recorded base. It must, however, still descend
+    // from that immutable boundary. A reset/repoint outside the lineage is
+    // physical drift and must fail before Provider launch.
+    if (inspectPhysical !== undefined) {
+        const effective = activeRun?.workspace ?? main;
+        for (const entry of effective.entries) {
+            const physical = inspectPhysical(entry);
+            if (!physical.recordedBaseIsAncestor) {
+                return {
+                    kind: "physical-drift",
+                    reason: `Managed workspace physical HEAD left its recorded lineage: ${task.id}/${roleName}.`,
+                    taskId: task.id,
+                    roleName,
+                    projectId: entry.projectId,
+                    expectedCommit: entry.baseCommit,
+                    physicalCommit: physical.physicalCommit
+                };
+            }
+        }
+    }
     return null;
 }
 /**
@@ -108,7 +129,7 @@ export function formatWorkspacePreflightError(classification) {
                 + "` to inspect the split state, then repair or re-sync the workspace.");
             break;
         case "physical-drift":
-            lines.push(`  Project ${classification.projectId}: expected ${classification.expectedCommit}, physical HEAD is ${classification.physicalCommit}.`);
+            lines.push(`  Project ${classification.projectId}: recorded base ${classification.expectedCommit}, physical HEAD is ${classification.physicalCommit}.`);
             lines.push("  The physical workspace has drifted from the recorded baseline.");
             lines.push("  Use `yui task base status " + classification.taskId + "` to inspect the drift.");
             break;