@zq-silk/yui 0.13.8 → 0.13.9

package/dist/config/yuiConfig.js

@@ -1,4 +1,3 @@
-import { supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
 import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP, MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
 import { DEFAULT_RUNTIME_HEALTH_POLICY } from "../runtime/runtimeHealthPolicy.js";
 export const DEFAULT_RECONCILIATION_INTERVAL_SECONDS = 120;
@@ -75,84 +74,6 @@ export function resolveLeaderNextActionMode(value) {
     }
     return normalized;
 }
-// ── Issue 01: Provider retry ──────────────────────────────────────────────
-export const PROVIDER_RETRY_MODES = ["off", "shadow", "enforce"];
-export const DEFAULT_PROVIDER_RETRY_MODE = "enforce";
-export const DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS = Object.freeze([2, 5, 15]);
-export const DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS = 600;
-export const MAX_PROVIDER_RETRY_ATTEMPTS = 10;
-export function resolveProviderRetryMode(value) {
-    if (value === undefined || value === null)
-        return DEFAULT_PROVIDER_RETRY_MODE;
-    if (typeof value !== "string") {
-        throw new TypeError("providerRetryMode must be off, shadow, or enforce.");
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length === 0)
-        return DEFAULT_PROVIDER_RETRY_MODE;
-    if (!PROVIDER_RETRY_MODES.includes(normalized)) {
-        throw new TypeError("providerRetryMode must be off, shadow, or enforce.");
-    }
-    return normalized;
-}
-/**
- * Resolves the adapter list. `["all"]` or undefined means every supported
- * adapter; an empty array disables in-place retry.
- */
-export function resolveProviderRetryAdapters(value) {
-    if (value === undefined || value === null) {
-        return [...supportedAgentAdapterIds()];
-    }
-    if (!Array.isArray(value)) {
-        throw new TypeError("providerRetryAdapters must be an array of adapter ids.");
-    }
-    const supported = new Set(supportedAgentAdapterIds());
-    const adapters = [];
-    for (const raw of value) {
-        if (typeof raw !== "string") {
-            throw new TypeError("providerRetryAdapters entries must be strings.");
-        }
-        const token = raw.trim().toLowerCase();
-        if (token === "all") {
-            for (const adapter of supportedAgentAdapterIds()) {
-                if (!adapters.includes(adapter))
-                    adapters.push(adapter);
-            }
-            continue;
-        }
-        if (!/^[a-z0-9][a-z0-9._-]*$/u.test(token)) {
-            throw new TypeError(`Invalid Provider retry adapter: ${token}.`);
-        }
-        if (!supported.has(token)) {
-            throw new TypeError(`Unknown Provider retry adapter: ${token}.`);
-        }
-        if (!adapters.includes(token))
-            adapters.push(token);
-    }
-    return adapters;
-}
-export function resolveProviderRetryDelaysSeconds(value) {
-    if (value === undefined || value === null)
-        return [...DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS];
-    if (!Array.isArray(value) || value.length < 1 || value.length > MAX_PROVIDER_RETRY_ATTEMPTS) {
-        throw new TypeError(`providerRetryDelaysSeconds must contain 1-${MAX_PROVIDER_RETRY_ATTEMPTS} positive integers.`);
-    }
-    const delays = value.map((entry) => {
-        if (typeof entry !== "number" || !Number.isSafeInteger(entry) || entry < 1 || entry > 600) {
-            throw new TypeError("providerRetryDelaysSeconds entries must be integers from 1 to 600.");
-        }
-        return entry;
-    });
-    for (let index = 1; index < delays.length; index += 1) {
-        if (delays[index] < delays[index - 1]) {
-            throw new TypeError("providerRetryDelaysSeconds must be ordered from shortest to longest.");
-        }
-    }
-    return delays;
-}
-export function resolveProviderRetryMaxWindowSeconds(value) {
-    return resolveBoundedPositiveInteger(value, DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS, 1, Number.MAX_SAFE_INTEGER, "providerRetryMaxWindowSeconds");
-}
 // ── Executable paths ──────────────────────────────────────────────────────
 export function resolveTmuxBin(value) {
     if (value === undefined || value === null)

package/dist/controller/clientRuntime.js

@@ -466,11 +466,48 @@ export class FileTaskWorkflowRuntime {
                 throw new Error(`Role runtime did not stop: ${target.taskId}/${target.roleName}.`);
             }
             const session = this.store.getRoleSession(target.taskId, target.roleName);
-            if (session !== null && session.status !== "stopped") {
+            if (session !== null && session.status !== "ended") {
                 throw new Error(`Role runtime session is still active: ${target.taskId}/${target.roleName}.`);
             }
         }
     }
+    /** Stops only the exact idle Session observed by an Agent command. */
+    async stopExactTaskRoleSession(input) {
+        if (this.store.getActiveAgentRun(input.taskId, input.roleName) !== null) {
+            throw new Error(`Role has an active Run: ${input.taskId}/${input.roleName}.`);
+        }
+        const owner = {
+            scope: "task",
+            taskId: input.taskId,
+            roleName: input.roleName
+        };
+        const target = this.schedulerStore.enqueueRuntimeCleanup(owner, new Date(), {
+            owner,
+            agentId: input.agentId,
+            adapterId: input.adapterId,
+            nativeSessionId: input.nativeSessionId,
+            ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+            sessionUpdatedAt: input.sessionUpdatedAt
+        });
+        if (target === null) {
+            throw new Error(`Role Session changed before its exact stop was reserved: ${input.taskId}/${input.roleName}.`);
+        }
+        await callFileTaskController(this.home, "scheduler.scan", {}, {
+            ...this.clientOptions,
+            requestTimeoutMs: LIFECYCLE_REQUEST_TIMEOUT_MS
+        });
+        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}.`);
+        }
+    }
     /** Wait until every cancellation requested by Task execution stop is physically settled. */
     async stopTaskDurableJobs(taskId) {
         const deadline = Date.now() + LIFECYCLE_REQUEST_TIMEOUT_MS;
@@ -506,7 +543,7 @@ export class FileTaskWorkflowRuntime {
                 + activeJobs.map(({ id }) => id).join(", "));
         }
         const liveSessions = this.store.listRoleSessionSets(taskId).flatMap((sessions) => (Object.values(sessions.sessions)
-            .filter((session) => session.status !== "stopped" && session.status !== "broken")
+            .filter((session) => session.status === "active")
             .map((session) => `${sessions.owner.roleName}/${session.agentId}/${session.status}`)));
         if (liveSessions.length > 0) {
             throw new WorkspaceCleanupBlockedError("physical-resource-live", `task:${taskId}`, true, `Task physical resources are not released: current Role Session state is still live: `
@@ -556,7 +593,7 @@ export class FileTaskWorkflowRuntime {
         }
         const sessions = this.store.getGlobalRoleSessionSet(roleName);
         const active = sessions?.sessions[sessions.activeAgentId];
-        if (active !== undefined && active.status !== "stopped") {
+        if (active !== undefined && active.status !== "ended") {
             throw new Error(`Global Role runtime session is still active: ${roleName}.`);
         }
     }

package/dist/controller/controller.js

@@ -57,6 +57,11 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
     // event-loop turn. Give already-written requests a poll boundary before the
     // next durable phase; later phases retain their existing CAS fences.
     await controlEventLoopTurn();
+    // A dormant Session may still name a Host that disappeared after its last
+    // Provider Turn. Detach that disposable Host before claiming the next Run,
+    // so retained Agent intent restores the same Session instead of first
+    // connecting to a known-dead control socket.
+    await reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now, blockedTaskIds);
     const failedCleanupRoles = await processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost, scope, now, runtimeCleanupOutcomes, blockedTaskIds);
     const roleSelection = selectionWithoutFailedCleanupRoles(store, selection, failedCleanupRoles);
     const availableWakeupSelection = () => (leaderWakeFence?.() === true
@@ -79,7 +84,6 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
         // Issue 04: reopen due in-place Provider retries on their original
         // Sessions before delivery, so the existing delivery path re-pushes the
         // exact same input in this same pass.
-        resolveDueProviderRetries(store, roleSelection, now);
         const activeRunDeliveries = await processActiveRoleRunDeliveries(store, delivery, now, roleSelection, inputDeliveryRecoveryCutoff);
         await controlEventLoopTurn();
         const unsettledRunRefs = new Set(activeRunDeliveries.flatMap((result) => (result.reason === "delivery-uncertain" || result.terminalFailure !== undefined
@@ -253,10 +257,10 @@ function queueSelectedCompletedTaskRuntimeCleanups(store, selection, now) {
     }
 }
 function schedulerSessionRequiresRuntimeCleanup(session) {
-    if (session === null || session.status === "stopped" || session.status === "broken") {
+    if (session === null || session.status === "ended") {
         return false;
     }
-    return session.status === "running" || session.launchId !== undefined;
+    return session.launchId !== undefined;
 }
 async function processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost, scope, now, outcomes, blockedTaskIds = new Set()) {
     const targets = selectedRuntimeLifecycleTargets(store, scope, blockedTaskIds);
@@ -351,14 +355,18 @@ async function processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost
     return failedRoles;
 }
 async function reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now, blockedTaskIds = new Set()) {
-    if (scope.kind !== "full"
-        || lifecycleHost === undefined
-        || store.listDormantRuntimeOwners === undefined
-        || store.markRuntimeOwnerStopped === undefined) {
+    if (lifecycleHost === undefined
+        || store.listDormantRuntimeOwners === undefined) {
         return;
     }
-    const candidates = store.listDormantRuntimeOwners().filter((candidate) => (candidate.owner.scope !== "task"
-        || !blockedTaskIds.has(candidate.owner.taskId)));
+    const selectedOwners = scope.kind === "full"
+        ? undefined
+        : new Set(selectedRuntimeLifecycleTargets(store, scope, blockedTaskIds)
+            .map((target) => runtimeOwnerIdentity(runtimeOwner(target))));
+    const candidates = store.listDormantRuntimeOwners().filter((candidate) => ((candidate.owner.scope !== "task"
+        || !blockedTaskIds.has(candidate.owner.taskId))
+        && (selectedOwners === undefined
+            || selectedOwners.has(runtimeOwnerIdentity(candidate.owner)))));
     if (candidates.length === 0)
         return;
     const owners = candidates.map((candidate) => candidate.owner);
@@ -391,17 +399,12 @@ async function reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, sco
     for (const candidate of candidates) {
         if (byOwner.get(runtimeOwnerIdentity(candidate.owner))?.state
             === "stopped") {
-            if (candidate.owner.scope === "task"
-                && candidate.launchId !== undefined) {
+            if (candidate.launchId !== undefined) {
                 // The exact launch-owned resources must settle through the durable
-                // cleanup lane before its Session fact becomes stopped. The candidate
-                // is passed back as the CAS fence so a concurrent Hook/launch cannot
-                // redirect cleanup to a newer generation.
-                store.enqueueRuntimeCleanup?.(candidate.owner, now, candidate);
-                continue;
-            }
-            if (store.markRuntimeOwnerStopped(candidate, now)) {
-                forgetPreparedRuntimeOwner(delivery, candidate.owner);
+                // cleanup lane before its Host fact is detached. The resumable Session
+                // remains active; the candidate is the CAS fence against a concurrent
+                // Hook or replacement launch.
+                store.enqueueRuntimeHostDetach?.(candidate.owner, now, candidate);
             }
         }
     }
@@ -419,20 +422,6 @@ function runtimeOwnerIdentity(owner) {
         ? `task\0${owner.taskId}\0${owner.roleName}`
         : `global\0${owner.roleName}`;
 }
-/**
- * Issue 04: reopens due in-place Provider retries on their original Native
- * Sessions before the active-run delivery pass, so the existing delivery
- * path re-pushes the exact same input in the same pass. A Run whose Session
- * is proven dead terminalizes with a replacement blocker instead.
- */
-function resolveDueProviderRetries(store, selection, now) {
-    if (typeof store.resolveDueProviderRetries !== "function")
-        return;
-    const selectedTaskIds = selectedTaskIdsForBoundedPass(store, selection);
-    if (selectedTaskIds?.size === 0)
-        return;
-    store.resolveDueProviderRetries(now, selectedTaskIds);
-}
 function selectedTaskIdsForBoundedPass(store, selection) {
     if (!selection.full) {
         if ((selection.blockedTaskIds?.size ?? 0) === 0)
@@ -1445,25 +1434,13 @@ export class FileTaskController {
         }
         if (this.#stopped)
             return;
-        const deadlines = [
-            ...this.store.listOpenInputRequests()
-                .flatMap((request) => request.policy.kind === "recommended"
-                ? [{
-                        key: `task:${encodeURIComponent(request.taskId)}`,
-                        at: Date.parse(request.policy.timeoutAt)
-                    }]
-                : []),
-            // Issue 04 durable in-place retry timer: arm the Controller wake at the
-            // earliest dispatch/deadline wake. Scheduled retries re-push on their
-            // original Session; in-flight retries only wake at the episode deadline.
-            // The projection is durable, so a restart resumes the lineage.
-            ...(typeof this.store.listPendingProviderRetries === "function"
-                ? this.store.listPendingProviderRetries()
-                : []).map((retry) => ({
-                key: `role:${encodeURIComponent(retry.taskId)}/${encodeURIComponent(retry.roleName)}`,
-                at: Date.parse(retry.dueAt)
-            }))
-        ];
+        const deadlines = this.store.listOpenInputRequests()
+            .flatMap((request) => request.policy.kind === "recommended"
+            ? [{
+                    key: `task:${encodeURIComponent(request.taskId)}`,
+                    at: Date.parse(request.policy.timeoutAt)
+                }]
+            : []);
         const nearest = nearestDeadlineBatch(deadlines);
         if (nearest === null)
             return;