@zq-silk/yui 0.6.0 → 0.6.2

package/dist/controller/resourceInventoryLinux.js

@@ -1,24 +1,26 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, lstatSync, readFileSync, readdirSync } from "node:fs";
-import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import { activeLiveRoleAgentSession } from "../executor/agentExecutor.js";
 import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
 import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
 import { TmuxManager, yuiTmuxServerName } from "../tmux/tmuxManager.js";
+import { tmuxSocketDirectory, tmuxSocketEnvironment } from "../tmux/tmuxSocketEndpoint.js";
 import { readControllerDiscovery } from "../core/controllerClient.js";
 import { CONTROLLER_DISCOVERY_PATH } from "../core/protocol.js";
 import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { buildControllerResourceInventory } from "./resourceInventory.js";
 import { CONTROLLER_DOMAIN_PATH, EPHEMERAL_DOMAIN_GRACE_MS, ephemeralDomainFingerprint, readEphemeralDomainIdentity, readLinuxProcessStartIdentity } from "./domainIdentity.js";
+const LINUX_PROCESS_SCAN_BATCH_SIZE = 64;
+export const INVENTORY_EVENT_LOOP_TURN_BUDGET_MS = 25;
 export async function scanControllerResourceInventory(options) {
     const currentHome = resolve(options.currentHome);
     const environment = options.environment ?? process.env;
     const observedAt = (options.now ?? (() => new Date()))();
     const warnings = [];
     const activeSockets = readActiveUnixSocketPaths(warnings);
-    const processes = listLinuxProcesses(warnings)
+    const processes = (await listLinuxProcesses(warnings))
         .filter(({ pid }) => pid !== process.pid);
     const homes = new Set([currentHome]);
     if (options.scope === "all") {
@@ -27,22 +29,31 @@ export async function scanControllerResourceInventory(options) {
                 homes.add(process.yuiHome);
         }
     }
-    const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-    const rawTmuxArtifacts = listSocketArtifacts(join(tmpdir(), `tmux-${uid}`), /^yui-[a-f0-9]{24}$/u, "tmux-socket", activeSockets);
+    const tmuxDirectory = tmuxSocketDirectory(environment);
+    const listTmuxSocketArtifacts = options.listTmuxSocketArtifacts
+        ?? listSharedTmuxSocketArtifacts;
+    // scope=current owns exactly one YUI_HOME, so only its exact tmux server
+    // socket is observable. Enumerating the whole shared directory (readdir +
+    // lstat per entry) blocked the event loop for seconds under a large
+    // unrelated yui-* population and starved control commands. scope=all keeps
+    // the full cross-domain enumeration for global cleanup reporting.
+    const rawTmuxArtifacts = options.scope === "all"
+        ? listTmuxSocketArtifacts(tmuxDirectory, activeSockets)
+        : inspectExactTmuxSocket(currentHome, tmuxDirectory, activeSockets);
     const homeFacts = [];
     const associatedArtifacts = new Set();
     for (const home of [...homes].sort()) {
         const matchingProcesses = processes.filter(({ yuiHome }) => yuiHome === home);
         const state = loadHomeState(home, warnings, options);
         const domain = inspectRuntimeDomain(home, matchingProcesses, state.roles, state.storageStatus, observedAt);
-        const tmuxSocketPath = join(tmpdir(), `tmux-${uid}`, yuiTmuxServerName(home));
+        const tmuxSocketPath = join(tmuxDirectory, yuiTmuxServerName(home));
         const tmuxArtifact = rawTmuxArtifacts.find(({ path }) => path === tmuxSocketPath);
         if (tmuxArtifact !== undefined)
             associatedArtifacts.add(tmuxArtifact.path);
         const panes = options.panes !== undefined
             ? options.panes
             : tmuxArtifact?.active === true
-                ? inspectHomePanes(home, environment.YUI_TMUX_BIN ?? "tmux", warnings)
+                ? inspectHomePanes(home, environment, warnings)
                 : [];
         const discovery = await inspectDiscovery(home, matchingProcesses, activeSockets);
         if (discovery.status === "valid"
@@ -164,7 +175,7 @@ export function classifyRuntimeProcess(args, command) {
         return "agent";
     return "other";
 }
-function listLinuxProcesses(warnings) {
+async function listLinuxProcesses(warnings) {
     const uid = typeof process.getuid === "function" ? process.getuid() : 0;
     const clockTicks = readClockTicks();
     const uptimeMs = readSystemUptimeMs();
@@ -179,21 +190,21 @@ function listLinuxProcesses(warnings) {
         warnings.push(`Cannot enumerate Linux processes: ${message(error)}`);
         return [];
     }
-    return entries.flatMap((entryName) => {
+    const result = [];
+    await forEachInEventLoopBatches(entries, LINUX_PROCESS_SCAN_BATCH_SIZE, (entryName) => {
+        const pid = linuxProcessEntryPid(entryName);
+        if (pid === undefined)
+            return;
         try {
-            const pid = linuxProcessEntryPid(entryName);
-            if (pid === undefined)
-                return [];
             const status = readFileSync(`/proc/${pid}/status`, "utf8");
             const processUid = parseStatusNumber(status, "Uid");
-            if (processUid !== uid)
-                return [];
-            const parsed = parseLinuxProcessStat(readFileSync(`/proc/${pid}/stat`, "utf8"), clockTicks, uptimeMs);
-            const args = splitNullDelimited(readFileSync(`/proc/${pid}/cmdline`));
-            const command = readFileSync(`/proc/${pid}/comm`, "utf8").trim();
-            const yuiHome = readYuiHome(pid);
-            const io = readProcessIo(pid);
-            return [{
+            if (processUid === uid) {
+                const parsed = parseLinuxProcessStat(readFileSync(`/proc/${pid}/stat`, "utf8"), clockTicks, uptimeMs);
+                const args = splitNullDelimited(readFileSync(`/proc/${pid}/cmdline`));
+                const command = readFileSync(`/proc/${pid}/comm`, "utf8").trim();
+                const yuiHome = readYuiHome(pid);
+                const io = readProcessIo(pid);
+                result.push({
                     pid,
                     ppid: parsed.ppid,
                     uid: processUid,
@@ -206,14 +217,35 @@ function listLinuxProcesses(warnings) {
                     cpuTimeMs: parsed.cpuTimeMs,
                     ...(io === undefined ? {} : io),
                     ageMs: parsed.ageMs
-                }];
+                });
+            }
         }
         catch {
             // Processes commonly exit during a /proc scan. A point-in-time inventory
             // omits those races instead of turning them into persistent warnings.
-            return [];
         }
     });
+    return result;
+}
+/** Cooperatively visits synchronous inventory entries in bounded turns. */
+export async function forEachInEventLoopBatches(entries, batchSize, visit, timing = {}) {
+    if (!Number.isSafeInteger(batchSize) || batchSize < 1) {
+        throw new Error("Event-loop batch size must be a positive integer.");
+    }
+    const now = timing.now ?? (() => performance.now());
+    let turnStartedAt = now();
+    let entriesInTurn = 0;
+    for (let index = 0; index < entries.length; index += 1) {
+        visit(entries[index], index);
+        entriesInTurn += 1;
+        if (index + 1 < entries.length
+            && (entriesInTurn >= batchSize
+                || now() - turnStartedAt >= INVENTORY_EVENT_LOOP_TURN_BUDGET_MS)) {
+            await new Promise((resolve) => setImmediate(resolve));
+            turnStartedAt = now();
+            entriesInTurn = 0;
+        }
+    }
 }
 /**
  * Resolve one numeric /proc entry name without asking the filesystem for
@@ -304,28 +336,36 @@ function listSocketArtifacts(directory, pattern, artifactKind, activeSockets) {
         return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
             if (!pattern.test(entry.name))
                 return [];
-            const path = join(directory, entry.name);
-            let metadata;
-            try {
-                metadata = lstatSync(path);
-            }
-            catch {
-                return [];
-            }
-            if (!metadata.isSocket())
-                return [];
-            return [{
-                    artifactKind,
-                    path,
-                    active: activeSockets.has(path),
-                    fingerprint: statFingerprint(metadata)
-                }];
+            return inspectSocketArtifact(join(directory, entry.name), artifactKind, activeSockets);
         });
     }
     catch {
         return [];
     }
 }
+function listSharedTmuxSocketArtifacts(directory, activeSockets) {
+    return listSocketArtifacts(directory, /^yui-[a-f0-9]{24}$/u, "tmux-socket", activeSockets);
+}
+function inspectExactTmuxSocket(currentHome, tmuxDirectory, activeSockets) {
+    return inspectSocketArtifact(join(tmuxDirectory, yuiTmuxServerName(currentHome)), "tmux-socket", activeSockets);
+}
+function inspectSocketArtifact(path, artifactKind, activeSockets) {
+    let metadata;
+    try {
+        metadata = lstatSync(path);
+    }
+    catch {
+        return [];
+    }
+    if (!metadata.isSocket())
+        return [];
+    return [{
+            artifactKind,
+            path,
+            active: activeSockets.has(path),
+            fingerprint: statFingerprint(metadata)
+        }];
+}
 async function inspectDiscovery(home, processes, activeSockets) {
     const path = join(home, CONTROLLER_DISCOVERY_PATH);
     try {
@@ -576,9 +616,20 @@ function loadHomeState(home, warnings, options) {
         return { storageStatus: "invalid", roles: [] };
     }
 }
-function inspectHomePanes(home, tmuxBin, warnings) {
+function inspectHomePanes(home, environment, warnings) {
     try {
-        return new TmuxManager(tmuxBin, new NodeCommandExecutor(), {
+        const executor = new NodeCommandExecutor();
+        const commandEnvironment = tmuxSocketEnvironment(environment);
+        return new TmuxManager(environment.YUI_TMUX_BIN ?? "tmux", {
+            run: (command, args, options) => executor.run(command, args, {
+                ...options,
+                environment: {
+                    ...commandEnvironment,
+                    ...options?.environment,
+                    TMUX_TMPDIR: commandEnvironment.TMUX_TMPDIR
+                }
+            })
+        }, {
             yuiHome: home
         }).inspectRolePaneInventory();
     }

package/dist/controller/runtime.js

@@ -7,18 +7,21 @@ import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, YUI_M
 import { hasRuntimeCleanupObligation, runtimeLifecycleSignalKey, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { agentProcessReadinessProbe, ExecutorRegistry } from "../executor/executorRegistry.js";
 import { activeLiveRoleAgentSession, roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
-import { effectiveLaunchSnapshotsCompatible, resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
 import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
 import { SqliteTaskStore } from "../storage/sqliteStore.js";
-import { AsyncTaskStoreClient, resolveStoreWorkerEnabled } from "../storage/storeRpc.js";
+import { AsyncTaskStoreClient, resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
 import { TmuxManager, yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { FileTaskRuntimeIsolation, TmuxPromptPushAdapter, TmuxSessionHost } from "../runtime/index.js";
 import { startFileTaskController } from "./controller.js";
 import { FileSchedulerStoreAdapter } from "./fileSchedulerStoreAdapter.js";
+import { openSchedulerTelemetry } from "../telemetry/telemetryWiring.js";
+import { createFileArtifactPort, createLinuxProcessPort, DurableJobSupervisor } from "./jobSupervisor.js";
+import { createDurableJobControl } from "./jobControl.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
 import { AsyncRuntimeEventProcessor, FileRuntimeEventProcessor, createAsyncRuntimeObserver } from "./runtimeEventProcessor.js";
 import { RuntimeLaunchCoordinator } from "./runtimeLaunchCoordinator.js";
@@ -26,13 +29,52 @@ import { ephemeralDomainFromEnvironment, recordEphemeralTmuxTarget } from "./dom
 import { createEphemeralResourceReaper } from "./ephemeralResourceReaper.js";
 import { scanControllerResourceInventory } from "./resourceInventoryLinux.js";
 import { ResourceInventoryClient } from "./resourceInventoryRpc.js";
+import { createResourceAutoGc } from "../resources/autoResourceGc.js";
 import { createRuntimeResourceActivityTracker } from "./resourceInventory.js";
+import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
+/** Refreshes only the exact Task runtime generation folded by the event transaction. */
+export function refreshAppliedTaskRuntimeDescriptor(store, planner, input) {
+    if (input.launchId === undefined)
+        return;
+    const run = input.runId === undefined
+        ? null
+        : store.getAgentRun(input.taskId, input.runId);
+    if (input.runId !== undefined && run === null) {
+        throw new Error("Prepared Task runtime generation is not current.");
+    }
+    // A terminal completion has already settled this exact Run and no later
+    // prompt can use its descriptor. Acknowledge the applied provider fact
+    // without republishing a dead generation.
+    if (run !== null && run.status !== "active")
+        return;
+    const session = store.getTaskRoleSessionSet(input.taskId, input.roleName)
+        ?.sessions[input.agentId];
+    const effective = run?.effective ?? session?.effective;
+    if (effective === undefined
+        || session === undefined
+        || session.agentId !== input.agentId
+        || session.adapterId !== input.adapterId
+        || session.launchId !== input.launchId
+        || session.nativeSessionId !== input.nativeSessionId
+        || (run !== null && (run.roleName !== input.roleName
+            || run.effective.agentId !== input.agentId
+            || run.effective.adapterId !== input.adapterId))) {
+        throw new Error("Prepared Task runtime generation is not current.");
+    }
+    planner.refreshTaskRuntimeDescriptor({
+        ...input,
+        launchId: input.launchId,
+        workspace: effective.workspace.root
+    });
+}
 /** Production composition root for the lean FileTaskStore + tmux Controller. */
 export async function startFileTaskControllerRuntime(home, options = {}) {
-    // The persistence worker (task-21, work-item-5) is opt-in: YUI_STORE_BACKEND
-    // must be sqlite AND YUI_STORE_WORKER=1. The file store remains the default
-    // for CLI tools and tests; rollback is a config flip (§6).
-    const useWorker = resolveStoreWorkerEnabled(options.environment ?? process.env);
+    // The Home decides the backend (Issue 01): a layout-7 Home runs SQLite with
+    // the persistence worker on by default; YUI_STORE_WORKER=0/false forces the
+    // in-process SQLite connection. The non-worker path opens the Home-decided
+    // backend through the compatibility opener (SQLite for layout 7, file store
+    // with normalization for older layouts).
+    const useWorker = resolveStoreWorkerEnabledForHome(home, options.environment ?? process.env);
     const store = options.store
         ?? (useWorker
             // Transitional: the scheduler/planner still use a sync store. The worker
@@ -55,7 +97,8 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
     const inventoryClient = useWorker
         ? new ResourceInventoryClient()
         : undefined;
-    const schedulerStore = options.schedulerStore ?? new FileSchedulerStoreAdapter(store);
+    const schedulerStore = options.schedulerStore
+        ?? new FileSchedulerStoreAdapter(store, openSchedulerTelemetry(home, options.environment ?? process.env));
     const domainIdentity = options.domainIdentity
         ?? ephemeralDomainFromEnvironment(options.environment ?? process.env);
     const planner = options.planner ?? new FileRoleLaunchPlanner(home, store, {
@@ -73,7 +116,27 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                 }
             })
     });
-    const sessionHost = options.sessionHost ?? new TmuxSessionHost(planner, tmux);
+    const sessionOwners = new SessionOwnerReconciliation({
+        home,
+        store,
+        environment: options.environment,
+        tmux,
+        onWarning: options.onError
+    });
+    const sessionHost = options.sessionHost ?? new TmuxSessionHost(planner, tmux, {
+        onHostCreated: ({ binding, pane }) => {
+            sessionOwners.recordHostOwner({
+                owner: binding.owner,
+                agentId: binding.agentId,
+                adapterId: binding.adapterId,
+                launchId: binding.launchId,
+                ...(binding.nativeSessionId === undefined
+                    ? {}
+                    : { nativeSessionId: binding.nativeSessionId }),
+                ...(pane.pid === undefined ? {} : { panePid: pane.pid })
+            });
+        }
+    });
     const promptPush = options.promptPush
         ?? new TmuxPromptPushAdapter(tmux, agentProcessReadinessProbe);
     const runtimeIsolation = options.runtimeIsolation
@@ -95,7 +158,19 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             : {
                 inspectOwners: (owners) => sessionHost.inspectOwners(owners)
             }),
-        stopOwner: (owner) => (sessionHost.stopOwner(owner)),
+        stopOwner: (owner) => {
+            // Issue 03: the durable `stopped` transition is gated on physical
+            // exit proof. A blocked result keeps the Session non-terminal and
+            // preserves owner records for Operator recovery.
+            return sessionOwners.terminateOwner(owner).then((result) => {
+                if (result.outcome === "stop-blocked") {
+                    (options.onError ?? (() => undefined))(new Error(`Role runtime cleanup could not prove physical exit: ${result.remaining
+                        .map(({ record, detail }) => `${record.launchId}: ${detail}`)
+                        .join("; ")}`));
+                }
+                return result.outcome === "stop-confirmed";
+            });
+        },
         ...(runtimeIsolation.cleanupTaskLaunch === undefined
             ? {}
             : {
@@ -238,7 +313,61 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                         })
                     })
             }));
+    // Issue 10: automatic Resource GC. The runner self-skips unless
+    // resourcesGcMode=quarantine and resourcesGcAutoQuarantine=true, so wiring
+    // it unconditionally costs one config read per full pass when disabled.
+    const resourceAutoGc = options.resourceAutoGc
+        ?? createResourceAutoGc({
+            home,
+            store,
+            environment: options.environment
+        });
     const lifecycleDispatcher = createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, options.dispatcher, signalRuntimeCleanup, launchCoordinator, planner);
+    // f7/rr5: Share one inbox between the supervisor's terminal channel and
+    // the runtime event processor. When a Job reaches a terminal state, the
+    // supervisor enqueues a durable-job-terminal event; the processor drains
+    // it on the next pass, waking the Controller immediately instead of
+    // waiting for the poll interval.
+    const runtimeEventInbox = new FileRuntimeEventInbox(home);
+    const jobSupervisor = new DurableJobSupervisor({
+        store: schedulerStore,
+        process: createLinuxProcessPort(),
+        artifacts: createFileArtifactPort(home),
+        // rr6/f1: Bounded supervision wake. The supervisor signals the Controller
+        // after spawning a runner (queued→running adoption) and when a runner
+        // exits (terminal harvest), so a quick job converges without waiting for
+        // the recovery interval. Closes over runningRuntime, which is assigned
+        // once startFileTaskController resolves; a wake during shutdown is a
+        // no-op. The recovery interval stays the cross-restart fallback.
+        wake: (taskId) => {
+            try {
+                runningRuntime?.signal(`task:${taskId}`);
+            }
+            catch {
+                // Controller stopped; the recovery interval remains the fallback.
+            }
+        },
+        terminalEvents: {
+            deliverTerminalEvent(notice) {
+                try {
+                    runtimeEventInbox.enqueueDurableJobTerminal({
+                        scope: "task",
+                        taskId: notice.taskId,
+                        jobId: notice.jobId,
+                        status: notice.status,
+                        outcome: notice.outcome
+                    });
+                }
+                catch (error) {
+                    // Best-effort terminal channel: the terminal transition already
+                    // committed. A delivery failure must not fail the reconcile pass.
+                    (options.onError ?? (() => undefined))(error);
+                }
+            }
+        },
+        onError: options.onError
+    });
+    const jobControl = createDurableJobControl(store);
     const running = await startFileTaskController(home, schedulerStore, delivery, lifecycleDispatcher, {
         intervalMs: options.intervalMs
             ?? reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds),
@@ -248,7 +377,10 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         now: options.now,
         onError: options.onError,
         lifecycleHost,
+        jobSupervisor,
+        jobControl,
         ...(resourceReaper === undefined ? {} : { resourceReaper }),
+        resourceAutoGc,
         onExpiredEphemeralDomain: (domain) => {
             if (domain.yuiHome !== home)
                 return;
@@ -257,14 +389,14 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         workspacePreparer,
         runtimeEventProcessor: options.runtimeEventProcessor
             ?? (useWorker && asyncStoreClient !== undefined
-                ? new AsyncRuntimeEventProcessor(new FileRuntimeEventInbox(home), createAsyncRuntimeObserver((method, args) => asyncStoreClient.invokeObserver(method, args)), {
+                ? new AsyncRuntimeEventProcessor(runtimeEventInbox, createAsyncRuntimeObserver((method, args) => asyncStoreClient.invokeObserver(method, args)), {
                     onTaskRuntimeApplied: (input) => {
-                        planner.refreshTaskRuntimeDescriptor(input);
+                        refreshAppliedTaskRuntimeDescriptor(store, planner, input);
                     }
                 })
-                : new FileRuntimeEventProcessor(new FileRuntimeEventInbox(home), schedulerStore, {
+                : new FileRuntimeEventProcessor(runtimeEventInbox, schedulerStore, {
                     onTaskRuntimeApplied: (input) => {
-                        planner.refreshTaskRuntimeDescriptor(input);
+                        refreshAppliedTaskRuntimeDescriptor(store, planner, input);
                     }
                 })),
         domainIdentity,
@@ -280,6 +412,21 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
     });
     runningController = running;
     runningRuntime = running.runtime;
+    // Issue 03: read-only startup reconciliation. Surfaces durable/physical
+    // Session mismatches (including generations whose durable map was cleared)
+    // without changing stop or archive behavior. Cleanup stays an explicit
+    // Operator action in exact-owner-cleanup mode.
+    try {
+        const startupReport = sessionOwners.report();
+        if (startupReport.summary.livePhysicalRoots > 0) {
+            (options.onError ?? (() => undefined))(new Error(`Session reconciliation: ${startupReport.summary.livePhysicalRoots} `
+                + `live physical root(s) across ${startupReport.summary.owners} owner record(s); `
+                + "run `yui session reconcile --report` for details."));
+        }
+    }
+    catch (error) {
+        (options.onError ?? (() => undefined))(error);
+    }
     return {
         ...running,
         close: async () => {
@@ -391,7 +538,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 throw applicationError("INVALID_PARAMS", `Configured Agent does not match Role: ${effective.agentId}.`);
             }
             validateLifecycleEnvironment(request.environment, agent);
-            const mode = roleAgentSessionResumeMode(sessions, effective.agentId, effective);
+            const mode = roleAgentSessionResumeMode(sessions, effective.agentId, effective, managedWorkspace);
             const session = sessions?.sessions[effective.agentId];
             const owner = request.scope === "task"
                 ? { scope: "task", taskId: request.taskId, roleName: request.roleName }
@@ -513,7 +660,10 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
             || session.nativeSessionId !== request.nativeSessionId) {
             throw new Error(`Native session changed: ${request.owner.roleName}.`);
         }
-        if (!effectiveLaunchSnapshotsCompatible(session.effective, request.effective)) {
+        const sessionEffectiveCompatible = request.owner.scope === "task"
+            ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, request.effective, request.managedWorkspace)
+            : effectiveLaunchSnapshotsCompatible(session.effective, request.effective);
+        if (!sessionEffectiveCompatible) {
             throw new Error(`Native session effective launch changed: ${request.owner.roleName}.`);
         }
     }