@zq-silk/yui 0.15.7 → 0.15.8

package/dist/controller/agentRuntimeObserver.js

@@ -5,7 +5,7 @@ const DEFAULT_MAX_CONCURRENT_SAMPLES = 8;
 const MAX_CONCURRENT_SAMPLES = 64;
 /**
  * Controller-owned, provider-independent sampler. Drivers own source parsing;
- * this component owns active-Turn discovery, cursor lifetime, canonical event
+ * this component owns active-AgentRun discovery, cursor lifetime, canonical event
  * creation, and low-latency mailbox wakes.
  */
 export class AgentRuntimeObserver {
@@ -72,8 +72,8 @@ export class AgentRuntimeObserver {
             let usages = sample.usages ?? [];
             if (state.usage === undefined) {
                 // Cumulative counters need a lower bound. An exact initial sample
-                // proves the complete Session-generation history even when the
-                // current Turn resumed that Session, so preserve every occurrence and
+                // proves the complete Session history even when the
+                // current AgentRun resumed that Session, so preserve every occurrence and
                 // anchor it at zero. A partial sample cannot prove the omitted request
                 // boundaries; retain its latest total as a partial baseline, plus the
                 // smallest ordered witness if the visible counter already rolled back.
@@ -251,43 +251,43 @@ export class AgentRuntimeObserver {
                 && task.executionGate.state === "enabled"));
         for (const task of activeTasks) {
             // A Task still incurs one O(E) event projection. Group those observations
-            // by Turn and sort each group once so every active Turn can reuse the same
+            // by AgentRun and sort each group once so every active AgentRun can reuse the same
             // ordered slice instead of repeatedly filtering/sorting all E events.
-            const observationsByTurnId = new Map();
+            const observationsByRunId = new Map();
             const taskObservations = [];
             for (const event of this.store.listEvents(task.id)) {
                 const observation = runtimeObservationFromTaskEvent(event);
-                const turnId = observation?.fence.turnId;
-                if (observation === null || turnId === undefined)
+                const runId = observation?.fence.runId;
+                if (observation === null || runId === undefined)
                     continue;
                 taskObservations.push(observation);
-                const grouped = observationsByTurnId.get(turnId);
+                const grouped = observationsByRunId.get(runId);
                 if (grouped === undefined) {
-                    observationsByTurnId.set(turnId, [observation]);
+                    observationsByRunId.set(runId, [observation]);
                 }
                 else {
                     grouped.push(observation);
                 }
             }
-            for (const observations of observationsByTurnId.values()) {
+            for (const observations of observationsByRunId.values()) {
                 observations.sort(compareObservations);
             }
             taskObservations.sort(compareObservations);
-            for (const run of this.store.listTurns(task.id)) {
+            for (const run of this.store.listRuns(task.id)) {
                 if (run.status !== "active"
-                    || this.store.getActiveTurn(task.id, run.roleName)?.id !== run.id)
+                    || this.store.getActiveRun(task.id, run.roleName)?.id !== run.id)
                     continue;
-                const observations = observationsByTurnId.get(run.id) ?? [];
+                const observations = observationsByRunId.get(run.id) ?? [];
                 const accepted = observations
                     .filter((observation) => observation.kind === "turn.accepted"
-                    && observation.fence.turnId === run.id
+                    && observation.fence.runId === run.id
                     && observation.fence.roleName === run.roleName
                     && observation.fence.agentId === run.effective.agentId
                     && observation.payload.observerSource !== undefined)
                     .at(-1);
                 const source = accepted?.payload.observerSource;
                 if (accepted === undefined || source === undefined
-                    || accepted.fence.taskId === undefined || accepted.fence.turnId === undefined)
+                    || accepted.fence.taskId === undefined || accepted.fence.runId === undefined)
                     continue;
                 try {
                     if (this.drivers.require(accepted.fence.driverId).runtime.observer === undefined)
@@ -297,14 +297,14 @@ export class AgentRuntimeObserver {
                     continue;
                 }
                 const fence = accepted.fence;
-                const generation = taskObservations.filter((observation) => (sessionRuntimeGenerationFenceMatches(fence, observation.fence)
+                const sessionObservations = taskObservations.filter((observation) => (sessionRuntimeFenceMatches(fence, observation.fence)
                     && observation.payload.sourceId === source.sourceId));
-                const persistedUsage = generation.filter((observation) => (observation.kind === "activity.observed"
+                const persistedUsage = sessionObservations.filter((observation) => (observation.kind === "activity.observed"
                     && observation.payload.usage !== undefined)).at(-1);
-                const persistedActivity = generation.filter((observation) => (observation.kind === "activity.observed"
+                const persistedActivity = sessionObservations.filter((observation) => (observation.kind === "activity.observed"
                     && observation.payload.activityId !== undefined
                     && observation.payload.usage === undefined)).at(-1);
-                const persistedHealth = generation.filter((observation) => (observation.kind === "observer.health"
+                const persistedHealth = sessionObservations.filter((observation) => (observation.kind === "observer.health"
                     && observation.payload.sourceId === source.sourceId)).at(-1);
                 const persistedUsageResume = persistedUsage === undefined
                     ? undefined
@@ -313,10 +313,9 @@ export class AgentRuntimeObserver {
                     key: JSON.stringify([
                         fence.taskId,
                         fence.roleName,
-                        fence.turnId,
+                        fence.runId,
                         fence.agentId,
                         fence.driverId,
-                        fence.runtimeGenerationId,
                         fence.nativeSessionId,
                         source.sourceId
                     ]),
@@ -462,19 +461,17 @@ function tokenObservationId(kind, fence, sourceId, value) {
         fence.roleName,
         fence.agentId,
         fence.driverId,
-        fence.runtimeGenerationId,
         fence.nativeSessionId ?? null,
         sourceId,
         value
     ])).digest("hex")}`;
 }
-function sessionRuntimeGenerationFenceMatches(expected, actual) {
+function sessionRuntimeFenceMatches(expected, actual) {
     for (const field of [
         "taskId",
         "roleName",
         "agentId",
         "driverId",
-        "runtimeGenerationId",
         "nativeSessionId"
     ]) {
         if (expected[field] !== actual[field])

package/dist/controller/capabilityBridge.js

@@ -1,7 +1,9 @@
 import { capabilitySchemaError } from "../kernel/capabilitySchema.js";
+import { SurfaceContributions } from "../surface/surfaceContributions.js";
 /** The same transport method is usable by CLI, Agent and an authenticated
  * Surface adapter. Credentials are an ingress envelope, never capability input. */
 export function createCapabilityDispatcher(capabilities) {
+    const surfaces = new SurfaceContributions(capabilities.registry);
     return async (method, value) => {
         const error = capabilitySchemaError({
             type: "object", required: ["taskId", "caller"],
@@ -12,12 +14,12 @@ export function createCapabilityDispatcher(capabilities) {
                     type: "object", required: ["scope"], additionalProperties: false,
                     properties: {
                         scope: { enum: ["user", "global", "task"] }, taskId: { type: "string" },
-                        role: { type: "string" }, agentId: { type: "string" }, adapterId: { type: "string" },
-                        runtimeGenerationId: { type: "string" }, nativeSessionId: { type: "string" },
-                        turnId: { type: "string" }, callerKey: { type: "string" }
+                        role: { type: "string" }, agentId: { type: "string" }, adapterId: { type: "string" }, nativeSessionId: { type: "string" },
+                        runId: { type: "string" }
                     }
                 },
                 query: { type: "string" },
+                surface: { enum: ["commands", "panels"] },
                 request: {
                     type: "object", required: ["name"], additionalProperties: false,
                     properties: {
@@ -37,11 +39,20 @@ export function createCapabilityDispatcher(capabilities) {
         if (method === "capability.search") {
             if (params.request !== undefined)
                 throw invalidParams("search accepts query, not request.");
-            result = { capabilities: capabilities.registry.search(context, params.query) };
+            if (params.surface !== undefined) {
+                if (params.query !== undefined)
+                    throw invalidParams("Surface listing does not accept query.");
+                result = params.surface === "commands"
+                    ? { commands: surfaces.listCommands(context) }
+                    : { panels: surfaces.listPanels(context) };
+            }
+            else
+                result = { capabilities: capabilities.registry.search(context, params.query) };
         }
         else {
-            if (params.query !== undefined || params.request === undefined)
-                throw invalidParams("describe/call requires request.");
+            if (params.query !== undefined || params.surface !== undefined || params.request === undefined) {
+                throw invalidParams("describe/call requires request, not query or surface.");
+            }
             if (method === "capability.describe")
                 result = capabilities.registry.describe(context, params.request);
             else if (method === "capability.call") {

package/dist/controller/clientRuntime.js

@@ -1,11 +1,11 @@
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { findLiveControllerProcessForHome } from "../core/controllerProcessIdentity.js";
+import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
 import { callController, ControllerClientError, readControllerDiscovery, stopOrphanedFileTaskController } from "../core/controllerClient.js";
-import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { FILE_TASK_CONTROLLER_PROTOCOL_VERSION } from "../core/protocol.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
 import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
-import { yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { hasRuntimeLifecycleWork } from "../runtime/lifecycleReservation.js";
 import { assertControllerStatusIdentity } from "../runtime/runtimeCoherence.js";
 import { EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES } from "./domainIdentity.js";
@@ -13,7 +13,6 @@ import { yuiVersionIdentity } from "../version.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
 import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
 import { CONTROLLER_SHUTDOWN_TIMEOUT_MS, LIFECYCLE_REQUEST_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
-import { FileTaskRuntimeIsolation } from "../runtime/taskRuntimeIsolation.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 const STARTUP_TIMEOUT_MS = 5_000;
 const POLL_INTERVAL_MS = 50;
@@ -24,7 +23,7 @@ const CONTROLLER_OPERATIONAL_ENVIRONMENT = [
     // The worker toggle changes process placement, not storage authority.
     "YUI_STORE_WORKER",
     // rr13/test: Forward the liveness seam so an integration test's Controller
-    // subprocess does not reap a saved active Leader Turn without a real tmux role.
+    // subprocess does not reap a saved active Leader AgentRun without a real tmux role.
     "YUI_TEST_ROLE_LIVENESS_PRESENT",
     ...EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES
 ];
@@ -68,7 +67,13 @@ export async function ensureFileTaskController(home, options = {}) {
     const timeoutMs = positive(options.startupTimeoutMs, STARTUP_TIMEOUT_MS, "startupTimeoutMs");
     const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
     const spawnController = options.spawnController ?? spawnDetachedFileTaskController;
-    spawnController(home, controllerSpawnEnvironment(home, options.environment ?? process.env));
+    // A readiness timeout is not exit evidence. Reuse the observable startup
+    // process for this exact Home rather than multiplying unready Controllers.
+    const existing = options.spawnController === undefined && options.call === undefined
+        ? findLiveControllerProcessForHome(readHomeFilesystemId(home))
+        : undefined;
+    const startupPid = existing?.pid
+        ?? spawnController(home, controllerSpawnEnvironment(home, options.environment ?? process.env));
     const deadline = Date.now() + timeoutMs;
     for (;;) {
         try {
@@ -80,7 +85,9 @@ export async function ensureFileTaskController(home, options = {}) {
             if (!isUnavailable(error))
                 throw error;
             if (Date.now() >= deadline) {
-                throw new Error(`Controller did not become ready within ${timeoutMs} ms.`, { cause: error });
+                throw new Error(`Controller did not become ready within ${timeoutMs} ms.`
+                    + (startupPid === undefined ? "" : ` Startup PID: ${startupPid}.`)
+                    + " Read current process state before retrying; timeout does not prove it stopped.", { cause: error });
             }
             await delay(pollMs);
         }
@@ -88,7 +95,7 @@ export async function ensureFileTaskController(home, options = {}) {
 }
 /** Start and await readiness for a captured Controller identity. */
 export async function ensureFileTaskControllerIdentity(home, identity, options = {}) {
-    assertExpectedControllerRuntimeGenerationIdentity(identity);
+    assertExpectedControllerRuntimeProcessIdentity(identity);
     const status = await ensureFileTaskController(home, {
         ...options,
         expectedVersion: identity.version
@@ -102,36 +109,36 @@ export async function ensureFileTaskControllerIdentity(home, identity, options =
     const actual = await call(home, "controller.identity", {}, {
         timeoutMs: options.requestTimeoutMs
     });
-    assertControllerRuntimeGenerationIdentity(actual, identity);
+    assertControllerRuntimeProcessIdentity(actual, identity);
     return status;
 }
-function assertExpectedControllerRuntimeGenerationIdentity(identity) {
+function assertExpectedControllerRuntimeProcessIdentity(identity) {
     if (typeof identity.executablePath !== "string"
         || identity.executablePath.length === 0
         || !Array.isArray(identity.args)
         || identity.args.some((arg) => typeof arg !== "string")
         || typeof identity.version !== "string"
         || identity.version.length === 0) {
-        throw new Error("Expected Controller runtime generation identity is malformed; refusing to start or accept a Controller.");
+        throw new Error("Expected Controller runtime identity is malformed; refusing to start or accept a Controller.");
     }
 }
-function assertControllerRuntimeGenerationIdentity(actual, expected) {
+function assertControllerRuntimeProcessIdentity(actual, expected) {
     if (!isJsonRecord(actual)) {
-        throw new Error("Authenticated Controller runtime generation identity is malformed; refusing to accept readiness.");
+        throw new Error("Authenticated Controller runtime identity is malformed; refusing to accept readiness.");
     }
     const actualArgs = actual.args;
     if (typeof actual.executablePath !== "string"
         || !Array.isArray(actualArgs)
         || actualArgs.some((arg) => typeof arg !== "string")
         || typeof actual.version !== "string") {
-        throw new Error("Authenticated Controller runtime generation identity is malformed; refusing to accept readiness.");
+        throw new Error("Authenticated Controller runtime identity is malformed; refusing to accept readiness.");
     }
     const argsMatch = actualArgs.length === expected.args.length
         && actualArgs.every((arg, index) => arg === expected.args[index]);
     if (actual.executablePath !== expected.executablePath
         || !argsMatch
         || actual.version !== expected.version) {
-        throw new Error("Authenticated Controller runtime generation identity does not match the captured executable, argv, and version; refusing readiness.");
+        throw new Error("Authenticated Controller runtime identity does not match the captured executable, argv, and version; refusing readiness.");
     }
 }
 function assertCompatibleControllerStatus(status, expectedVersion) {
@@ -166,10 +173,33 @@ function spawnDetachedFileTaskController(home, environment) {
         stdio: "ignore"
     });
     child.unref();
+    return child.pid;
 }
 /** Stops the per-home Controller and waits until its owned discovery is gone. */
 export async function stopFileTaskController(home, options = {}) {
-    const call = options.call ?? callController;
+    await waitForForeignHandover(home, options);
+    const physical = options.call === undefined
+        ? findLiveControllerProcessForHome(readHomeFilesystemId(home)) : undefined;
+    const expectedPid = options.expectedPid ?? physical?.pid;
+    const bounded = { ...options, requestTimeoutMs: options.requestTimeoutMs ?? 2000,
+        ...(expectedPid === undefined ? {} : { expectedPid }) };
+    try {
+        const result = await stopControllerGracefully(home, bounded);
+        if (result.stopped || options.call !== undefined)
+            return result;
+    }
+    catch (error) {
+        if (options.call !== undefined || !controllerRecoveryError(error))
+            throw error;
+    }
+    const stopped = await stopOrphanedFileTaskController(home, options.shutdownTimeoutMs ?? CONTROLLER_SHUTDOWN_TIMEOUT_MS, { force: true, ...(expectedPid === undefined ? {} : { expectedPid }),
+        ...(physical === undefined ? {} : { expectedProcessStartIdentity: physical.processStartIdentity }) });
+    return stopped === undefined ? { stopped: false, alreadyStopped: true } : { stopped: true, pid: stopped.pid };
+}
+async function stopControllerGracefully(home, options) {
+    const call = options.call ?? ((h, method, params) => callController(h, method, params, {
+        timeoutMs: options.requestTimeoutMs
+    }));
     const shutdownTimeoutMs = positive(options.shutdownTimeoutMs, CONTROLLER_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
     const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
     const expectedPid = options.expectedPid === undefined
@@ -178,6 +208,8 @@ export async function stopFileTaskController(home, options = {}) {
     const current = await readOptionalControllerStatus(home, call);
     const pid = controllerPid(current);
     if (expectedPid !== undefined && pid !== expectedPid) {
+        if (pid === undefined)
+            throw new ControllerClientError("CONTROLLER_UNAVAILABLE", `Controller ownership could not be queried for expected PID ${expectedPid}.`);
         throw new Error(`Controller ownership changed before fenced stop (expected PID ${expectedPid}, `
             + `found ${pid === undefined ? "none" : pid}).`);
     }
@@ -214,7 +246,7 @@ export async function stopFileTaskController(home, options = {}) {
                 break;
         }
         if (Date.now() >= deadline) {
-            throw new Error(`Controller did not stop within ${shutdownTimeoutMs} ms.`);
+            throw new ControllerClientError("CONTROLLER_TIMEOUT", `Controller did not stop within ${shutdownTimeoutMs} ms.`);
         }
         await delay(pollMs);
     }
@@ -225,41 +257,8 @@ export async function stopFileTaskController(home, options = {}) {
 }
 /** Restarts only the per-home Controller process; managed tmux sessions remain untouched. */
 export async function restartFileTaskController(home, options = {}) {
-    const call = options.call ?? callController;
-    const shutdownTimeoutMs = positive(options.shutdownTimeoutMs, CONTROLLER_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
-    const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
-    let current = null;
-    let previousPid;
-    try {
-        current = await readOptionalControllerStatus(home, call);
-        previousPid = controllerPid(current);
-    }
-    catch (error) {
-        if (options.call !== undefined || !isInvalidDiscovery(error))
-            throw error;
-        // A malformed current discovery record cannot authorize a protocol call.
-        // Exact process identity below may still fence and stop an orphaned owner.
-    }
-    if (!controllerRunning(current) && options.call === undefined) {
-        const orphan = await stopOrphanedFileTaskController(home, shutdownTimeoutMs);
-        if (orphan !== undefined)
-            previousPid = orphan.pid;
-    }
-    if (controllerRunning(current)) {
-        await callFileTaskController(home, "controller.stop", {}, options);
-        const deadline = Date.now() + shutdownTimeoutMs;
-        for (;;) {
-            const stillOwned = options.call === undefined
-                ? await ownedControllerDiscoveryExists(home, previousPid)
-                : controllerPid(await readOptionalControllerStatus(home, call)) === previousPid;
-            if (!stillOwned)
-                break;
-            if (Date.now() >= deadline) {
-                throw new Error(`Controller did not stop within ${shutdownTimeoutMs} ms.`);
-            }
-            await delay(pollMs);
-        }
-    }
+    const stopped = await stopFileTaskController(home, options);
+    const previousPid = stopped.pid;
     const started = await ensureFileTaskController(home, options);
     const pid = controllerPid(started);
     return {
@@ -268,6 +267,12 @@ export async function restartFileTaskController(home, options = {}) {
         ...(pid === undefined ? {} : { pid })
     };
 }
+function controllerRecoveryError(error) {
+    return error instanceof ControllerClientError && [
+        "CONTROLLER_TIMEOUT", "CONTROLLER_UNAVAILABLE", "CONTROLLER_DELIVERY_UNKNOWN",
+        "CONTROLLER_DISCOVERY_INVALID", "INVALID_RESPONSE", "CONTROLLER_NOT_RUNNING"
+    ].includes(error.code);
+}
 function controllerSpawnEnvironment(home, source) {
     const allowed = new Set(CONTROLLER_OPERATIONAL_ENVIRONMENT);
     try {
@@ -433,8 +438,8 @@ export class FileTaskWorkflowRuntime {
     async stopTaskRoleSessions(taskId, roleNames) {
         const targets = [];
         for (const roleName of [...new Set(roleNames)]) {
-            if (this.store.getActiveTurn(taskId, roleName) !== null) {
-                throw new Error(`Role has an active Turn: ${taskId}/${roleName}.`);
+            if (this.store.getActiveRun(taskId, roleName) !== null) {
+                throw new Error(`Role has an active AgentRun: ${taskId}/${roleName}.`);
             }
             const target = this.schedulerStore.enqueueRuntimeCleanup({
                 scope: "task",
@@ -464,11 +469,8 @@ export class FileTaskWorkflowRuntime {
             }
         }
     }
-    /** Stops only the exact idle Session observed by an Agent command. */
+    /** Explicitly stops the exact Session observed by an Agent command. */
     async stopExactTaskRoleSession(input) {
-        if (this.store.getActiveTurn(input.taskId, input.roleName) !== null) {
-            throw new Error(`Role has an active Turn: ${input.taskId}/${input.roleName}.`);
-        }
         const owner = {
             scope: "task",
             taskId: input.taskId,
@@ -479,9 +481,8 @@ export class FileTaskWorkflowRuntime {
             agentId: input.agentId,
             adapterId: input.adapterId,
             nativeSessionId: input.nativeSessionId,
-            ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
             sessionUpdatedAt: input.sessionUpdatedAt
-        });
+        }, true);
         if (target === null) {
             throw new Error(`Role Session changed before its exact stop was reserved: ${input.taskId}/${input.roleName}.`);
         }
@@ -492,14 +493,9 @@ export class FileTaskWorkflowRuntime {
         if (hasRuntimeLifecycleWork(this.store.getWorkMailbox(target))) {
             throw new Error(`Role runtime did not stop: ${input.taskId}/${input.roleName}.`);
         }
-        const session = this.store.getRoleSession(input.taskId, input.roleName);
-        if (session !== null
-            && session.status !== "ended"
-            && session.agentId === input.agentId
-            && session.adapterId === input.adapterId
-            && session.nativeSessionId === input.nativeSessionId) {
-            throw new Error(`Role runtime session is still active: ${input.taskId}/${input.roleName}.`);
-        }
+        // Cleanup completion proves the requested stop. A retained Message may
+        // already have started a successor on the same reusable conversation;
+        // its new active state must not retroactively turn this stop into failure.
     }
     /** Wait until every cancellation requested by Task execution stop is physically settled. */
     async stopTaskDurableJobs(taskId) {
@@ -563,7 +559,7 @@ export class FileTaskWorkflowRuntime {
         if (blockers.length === 0)
             return;
         throw new WorkspaceCleanupBlockedError("physical-resource-live", `task:${taskId}`, true, `Task archive blocked: ${blockers.length} owned physical resource(s) still live: `
-            + blockers.map((entry) => (`${entry.owner.roleName}/${entry.runtimeGenerationId}`
+            + blockers.map((entry) => (`${entry.owner.roleName}/${entry.nativeSessionId ?? "unknown-session"}`
                 + ` (pid ${entry.physical?.alive === true ? entry.physical.pid : "?"})`)).join("; "));
     }
     async stopGlobalRoleSession(roleName) {
@@ -622,27 +618,9 @@ export class FileTaskWorkflowRuntime {
         if (termination.outcome !== "stop-confirmed") {
             throw new Error(`Role runtime cleanup could not prove physical exit: ${runtimeOwnerLabel(candidate.owner)}; `
                 + termination.remaining
-                    .map(({ record, detail }) => `${record.runtimeGenerationId}: ${detail}`)
+                    .map(({ record, detail }) => `PID ${record.providerRoot.pid}: ${detail}`)
                     .join("; "));
         }
-        if (candidate.owner.scope === "task" && candidate.runtimeGenerationId !== undefined) {
-            const isolation = new FileTaskRuntimeIsolation({
-                runtimeRoot: `${this.home}.task-runtimes`,
-                controlPlane: {
-                    yuiHome: this.home,
-                    controllerSocketPath: controllerSocketPath(this.store.getHomeIdentity().homeId),
-                    tmuxNamespace: yuiTmuxServerName(this.home),
-                    globalInstallPaths: [process.execPath]
-                }
-            });
-            isolation.cleanupTaskLaunch({
-                taskId: candidate.owner.taskId,
-                runtimeGenerationId: candidate.runtimeGenerationId,
-                reason: this.store.getTask(candidate.owner.taskId)?.status === "completed"
-                    ? "completion"
-                    : "interruption"
-            });
-        }
         if (!this.schedulerStore.completeRuntimeCleanup(target, new Date())) {
             throw new Error(`Role runtime cleanup state changed before completion: ${runtimeOwnerLabel(candidate.owner)}.`);
         }
@@ -746,11 +724,6 @@ function isDefinitelyNotRunning(error) {
     const code = error.code;
     return code === "CONTROLLER_NOT_RUNNING";
 }
-function isInvalidDiscovery(error) {
-    if (typeof error !== "object" || error === null || !("code" in error))
-        return false;
-    return error.code === "CONTROLLER_DISCOVERY_INVALID";
-}
 async function readOptionalControllerStatus(home, call) {
     try {
         return await call(home, "controller.status", {});