@zq-silk/yui 0.7.1 → 0.8.2

package/dist/config/yuiConfig.js

@@ -1,10 +1,13 @@
 import { supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
-import { PROVIDER_RETRY_MAX_WINDOW_MS } from "../run/providerRetry.js";
-import { DEFAULT_RUN_CAP, DEFAULT_TELEMETRY_MODE, DEFAULT_TERMINAL_KEEP, MAX_RUN_CAP } from "../telemetry/telemetryConfig.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;
 export const MIN_RECONCILIATION_INTERVAL_SECONDS = 5;
 export const MAX_RECONCILIATION_INTERVAL_SECONDS = 300;
 export const DEFAULT_RESOURCES_GC_MODE = "report";
+export const DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS = 24;
+export const MIN_RESOURCES_QUARANTINE_TTL_HOURS = 1;
+export const MAX_RESOURCES_QUARANTINE_TTL_HOURS = 720;
 /**
  * Resolves the Resource GC mode. `report` (default) only reports candidates;
  * `quarantine` allows `yui resources gc --apply` to quarantine releasable
@@ -29,6 +32,9 @@ export function resolveResourcesGcAutoQuarantine(value) {
         return value;
     throw new TypeError("resourcesGcAutoQuarantine must be a boolean.");
 }
+export function resolveResourcesQuarantineTtlHours(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, MIN_RESOURCES_QUARANTINE_TTL_HOURS, MAX_RESOURCES_QUARANTINE_TTL_HOURS, "resourcesQuarantineTtlHours");
+}
 /**
  * Resolves the durable Yui setting used for low-frequency recovery
  * reconciliation. Normal durable state changes wake the Controller through
@@ -72,6 +78,9 @@ export function resolveLeaderNextActionMode(value) {
 // ── 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;
@@ -122,21 +131,27 @@ export function resolveProviderRetryAdapters(value) {
     }
     return adapters;
 }
-export function resolveProviderRetryMaxWindowMs(value) {
+export function resolveProviderRetryDelaysSeconds(value) {
     if (value === undefined || value === null)
-        return PROVIDER_RETRY_MAX_WINDOW_MS;
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-        throw new TypeError("providerRetryMaxWindowMs must be a positive integer.");
+        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.`);
     }
-    return value;
-}
-export function resolveYieldReceiptReplay(value) {
-    if (value === undefined || value === null)
-        return true;
-    if (typeof value !== "boolean") {
-        throw new TypeError("yieldReceiptReplay must be a boolean.");
+    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 value;
+    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) {
@@ -147,29 +162,13 @@ export function resolveTmuxBin(value) {
     }
     return value.trim();
 }
-export function resolveGitBin(value) {
-    if (value === undefined || value === null)
-        return "git";
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new TypeError("gitBin must be a non-empty string.");
-    }
-    return value.trim();
-}
 // ── Telemetry ─────────────────────────────────────────────────────────────
-const TELEMETRY_MODES = ["legacy", "dual", "bounded"];
-export function resolveTelemetryMode(value) {
+export function resolveTelemetryEnabled(value) {
     if (value === undefined || value === null)
-        return DEFAULT_TELEMETRY_MODE;
-    if (typeof value !== "string") {
-        throw new TypeError("telemetryMode must be legacy, dual, or bounded.");
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length === 0)
-        return DEFAULT_TELEMETRY_MODE;
-    if (!TELEMETRY_MODES.includes(normalized)) {
-        throw new TypeError(`telemetryMode must be one of ${TELEMETRY_MODES.join(", ")}; got ${JSON.stringify(normalized)}.`);
-    }
-    return normalized;
+        return false;
+    if (typeof value !== "boolean")
+        throw new TypeError("telemetryEnabled must be a boolean.");
+    return value;
 }
 export function resolveTelemetryTerminalKeep(value) {
     if (value === undefined || value === null)
@@ -190,6 +189,43 @@ export function resolveTelemetryRunCap(value) {
     }
     return value;
 }
+// ── Runtime and workflow policy ───────────────────────────────────────────
+export const DEFAULT_CONTROLLER_TASK_CONCURRENCY = 4;
+export const MAX_CONTROLLER_TASK_CONCURRENCY = 32;
+export const DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS = 300;
+export const DEFAULT_DELIVERY_TIMEOUT_SECONDS = 120;
+export const DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS = 3;
+export const DEFAULT_TMUX_HISTORY_LIMIT = 100_000;
+export function resolveRuntimeHealth(configured) {
+    if (configured === undefined || configured === null)
+        return DEFAULT_RUNTIME_HEALTH_POLICY;
+    if (typeof configured !== "object" || Array.isArray(configured)) {
+        throw new TypeError("runtimeHealth must be an object.");
+    }
+    const value = configured;
+    const quietAfterMs = resolveBoundedPositiveInteger(value.quietAfterSeconds, DEFAULT_RUNTIME_HEALTH_POLICY.quietAfterMs / 1_000, 30, 86_400, "runtimeHealth.quietAfterSeconds") * 1_000;
+    const diagnosticAfterMs = resolveBoundedPositiveInteger(value.diagnosticAfterSeconds, DEFAULT_RUNTIME_HEALTH_POLICY.diagnosticAfterMs / 1_000, 30, 86_400, "runtimeHealth.diagnosticAfterSeconds") * 1_000;
+    const stallWindowMs = resolveBoundedPositiveInteger(value.stallAfterSeconds, DEFAULT_RUNTIME_HEALTH_POLICY.stallWindowMs / 1_000, 60, 604_800, "runtimeHealth.stallAfterSeconds") * 1_000;
+    if (!(quietAfterMs < diagnosticAfterMs && diagnosticAfterMs < stallWindowMs)) {
+        throw new TypeError("runtimeHealth thresholds must be ordered quietAfterSeconds < diagnosticAfterSeconds < stallAfterSeconds.");
+    }
+    return Object.freeze({ quietAfterMs, diagnosticAfterMs, stallWindowMs });
+}
+export function resolveControllerTaskConcurrency(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_CONTROLLER_TASK_CONCURRENCY, 1, MAX_CONTROLLER_TASK_CONCURRENCY, "controllerTaskConcurrency");
+}
+export function resolveAgentLaunchInactivityTimeoutSeconds(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, 15, 3_600, "agentLaunchInactivityTimeoutSeconds");
+}
+export function resolveDeliveryTimeoutSeconds(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_DELIVERY_TIMEOUT_SECONDS, 5, 600, "deliveryTimeoutSeconds");
+}
+export function resolveLeaderSemanticBudgetTurns(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, 1, 20, "leaderSemanticBudgetTurns");
+}
+export function resolveTmuxHistoryLimit(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_TMUX_HISTORY_LIMIT, 1_000, 1_000_000, "tmuxHistoryLimit");
+}
 /**
  * Issue 04 (context token budget): thresholds for one native Session
  * generation's observed per-request input peak, measured in tokens. When the
@@ -231,3 +267,12 @@ export function resolveContextBudget(configured) {
     }
     return { softTokens, hardTokens };
 }
+function resolveBoundedPositiveInteger(value, fallback, minimum, maximum, label) {
+    if (value === undefined || value === null)
+        return fallback;
+    if (typeof value !== "number" || !Number.isSafeInteger(value)
+        || value < minimum || value > maximum) {
+        throw new TypeError(`${label} must be an integer from ${minimum} to ${maximum}.`);
+    }
+    return value;
+}

package/dist/context/sessionBootstrapManifest.js

@@ -53,7 +53,7 @@ export function materializeSessionBootstrap(input) {
         roleProfileRef: { digest: profileDigest, path: roleProfilePath },
         contextProtocol: input.owner.scope === "global"
             ? {
-                loadCommand: `\"${sessionCliPath}\" role context \"$YUI_ROLE\" --json`
+                loadCommand: `\"${sessionCliPath}\" session context \"$YUI_ROLE\" --json`
             }
             : {
                 loadCommand: `\"${sessionCliPath}\" task run context \"$YUI_TASK_ID/<run-id>\" --json`,

package/dist/controller/clientRuntime.js

@@ -29,8 +29,6 @@ const CONTROLLER_OPERATIONAL_ENVIRONMENT = [
     // rr13/test: Forward the liveness seam so an integration test's Controller
     // subprocess does not reap a saved active Leader Run without a real tmux role.
     "YUI_TEST_ROLE_LIVENESS_PRESENT",
-    // Issue 02: agent-signal-driven launch monitoring is Controller-owned.
-    "YUI_LAUNCH_INACTIVITY_TIMEOUT_MS",
     ...EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES
 ];
 /**

package/dist/controller/controller.js

@@ -4,7 +4,7 @@ import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
 import { processActiveRoleRunDeliveries } from "../scheduler/activeRoleRunDelivery.js";
 import { selectedActiveSchedulerTasks, selectedSchedulerRoles, selectedSchedulerTasks } from "../scheduler/ports.js";
 import { reconcileExitedRoleRuns } from "../scheduler/roleRunLiveness.js";
-import { DEFAULT_STALL_WINDOW_MS, reconcileStalledRoleRuns } from "../scheduler/roleRunStall.js";
+import { DEFAULT_STALL_WINDOW_MS, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, reconcileStalledRoleRuns } from "../scheduler/roleRunStall.js";
 import { repairOrphanedActiveTasks } from "../scheduler/activeTaskProgress.js";
 import { processOperatorInputNotifications } from "../scheduler/operatorInputNotificationProcessor.js";
 import { startControllerServer } from "../core/controllerServer.js";
@@ -22,6 +22,7 @@ const DEFAULT_SIGNAL_WINDOW_MS = 100;
 const DEFAULT_RUNTIME_OBSERVER_INTERVAL_MS = 1_000;
 const DEFAULT_DELIVERY_RETRY_MS = 250;
 const DEFAULT_DELIVERY_RETRY_LIMIT = 60;
+const DEFAULT_DELIVERY_TIMEOUT_MS = 120_000;
 const DEFAULT_TASK_ORCHESTRATION_RETRY_LIMIT = 2;
 const DEFAULT_TASK_CONCURRENCY = 4;
 const MAX_TASK_CONCURRENCY = 32;
@@ -44,7 +45,7 @@ const ZERO_DRAIN_METRICS = Object.freeze({
  * Runs one lean scheduler pass. Due native Turn completions are folded before
  * liveness, so a valid Hook boundary fences destructive process reconciliation.
  */
-export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer, scope = { kind: "full" }, includeOperator = true, runtimeCleanupOutcomes = [], lifecycleHost, stallWindowMs = DEFAULT_STALL_WINDOW_MS, maintenanceFence, onMaintenanceFenceDefer, blockedTaskIds = new Set(), inputDeliveryRecoveryCutoff) {
+export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer, scope = { kind: "full" }, includeOperator = true, runtimeCleanupOutcomes = [], lifecycleHost, stallWindowMs = DEFAULT_STALL_WINDOW_MS, maintenanceFence, onMaintenanceFenceDefer, blockedTaskIds = new Set(), inputDeliveryRecoveryCutoff, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS) {
     const compiledSelection = compileReconcileSelection(scope);
     const selection = includeOperator
         ? { ...compiledSelection, blockedTaskIds }
@@ -112,7 +113,7 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
         const resourceEvidence = new Map();
         const failedRunRefs = await reconcileExitedRoleRuns(store, delivery, now, roleSelection, unsettledRunRefs, liveStatuses, resourceEvidence, scope.kind === "dirty");
         await controlEventLoopTurn();
-        await reconcileStalledRoleRuns(store, delivery, now, roleSelection, stallWindowMs, liveStatuses, resourceEvidence);
+        await reconcileStalledRoleRuns(store, delivery, now, roleSelection, stallWindowMs, liveStatuses, resourceEvidence, diagnosticAfterMs);
         await controlEventLoopTurn();
         await reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now, selection.blockedTaskIds);
         const selectedInputTaskIds = selectedTaskIdsForBoundedPass(store, selection);
@@ -794,9 +795,12 @@ export class FileTaskController {
     #workspacePreparer;
     #deliveryRetryMs;
     #deliveryRetryLimit;
+    #mailboxDeliveryRetryLimit;
+    #deliveryTimeoutMs;
     #taskOrchestrationRetryLimit;
     #taskConcurrency;
     #stallWindowMs;
+    #diagnosticAfterMs;
     #runtimeEventProcessor;
     #runtimeObserver;
     #runtimeObserverIntervalMs;
@@ -845,9 +849,14 @@ export class FileTaskController {
         this.#workspacePreparer = options.workspacePreparer;
         this.#deliveryRetryMs = positiveInteger(options.deliveryRetryMs, DEFAULT_DELIVERY_RETRY_MS, "Controller delivery retry delay");
         this.#deliveryRetryLimit = positiveInteger(options.deliveryRetryLimit, DEFAULT_DELIVERY_RETRY_LIMIT, "Controller delivery retry limit");
+        this.#deliveryTimeoutMs = positiveInteger(options.deliveryTimeoutMs, DEFAULT_DELIVERY_TIMEOUT_MS, "Controller delivery timeout");
+        this.#mailboxDeliveryRetryLimit = options.deliveryRetryLimit === undefined
+            ? Math.max(this.#deliveryRetryLimit, Math.ceil(this.#deliveryTimeoutMs / this.#deliveryRetryMs) + 2)
+            : this.#deliveryRetryLimit;
         this.#taskOrchestrationRetryLimit = positiveInteger(options.taskOrchestrationRetryLimit, DEFAULT_TASK_ORCHESTRATION_RETRY_LIMIT, "Controller Task orchestration retry limit");
         this.#taskConcurrency = boundedPositiveInteger(options.taskConcurrency, DEFAULT_TASK_CONCURRENCY, MAX_TASK_CONCURRENCY, "Controller Task concurrency");
         this.#stallWindowMs = positiveInteger(options.stallWindowMs, DEFAULT_STALL_WINDOW_MS, "Controller Run stall window");
+        this.#diagnosticAfterMs = positiveInteger(options.diagnosticAfterMs, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, "Controller Run diagnostic threshold");
         this.#runtimeEventProcessor = options.runtimeEventProcessor;
         this.#runtimeObserver = options.runtimeObserver;
         this.#runtimeObserverIntervalMs = positiveInteger(options.runtimeObserverIntervalMs, DEFAULT_RUNTIME_OBSERVER_INTERVAL_MS, "Controller runtime observer interval");
@@ -1109,7 +1118,7 @@ export class FileTaskController {
                     // processes Leader wakeups.
                     this.#jobSupervisor?.reconcile(this.#now());
                     if (scope.kind === "full") {
-                        result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, runtimeFailedTaskIds, this.#startedAt);
+                        result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, runtimeFailedTaskIds, this.#startedAt, this.#diagnosticAfterMs);
                     }
                     else {
                         const dirtyPass = await this.#runDirtySchedulerPass(scope, runtimeCleanupOutcomes, runtimeFailedTaskIds);
@@ -1207,7 +1216,7 @@ export class FileTaskController {
         const taskScopes = partition.taskScopes.filter((taskScope) => (!blockedTaskIds.has(taskScope.taskId)));
         const orderedResults = [];
         if (partition.globalKeys.length > 0) {
-            orderedResults.push(await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: partition.globalKeys }, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt));
+            orderedResults.push(await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: partition.globalKeys }, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt, this.#diagnosticAfterMs));
         }
         if (taskScopes.length === 0
             || this.#stopped
@@ -1240,7 +1249,7 @@ export class FileTaskController {
                     if (this.#stopped || this.#pendingFull)
                         continue;
                     try {
-                        taskResults[selected.index] = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: selected.taskScope.keys }, false, taskCleanupOutcomes[selected.index], this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt);
+                        taskResults[selected.index] = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: selected.taskScope.keys }, false, taskCleanupOutcomes[selected.index], this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt, this.#diagnosticAfterMs);
                         this.#clearTaskPassRetry(selected.taskScope.taskId);
                     }
                     catch (error) {
@@ -1576,10 +1585,12 @@ export class FileTaskController {
             return;
         }
         const attempts = previous?.attempts ?? 0;
+        const startedAtMs = previous?.startedAtMs ?? this.#now().getTime();
         const retryLimit = key.startsWith("task:")
             ? this.#taskOrchestrationRetryLimit
-            : this.#deliveryRetryLimit;
-        if (attempts >= retryLimit) {
+            : this.#mailboxDeliveryRetryLimit;
+        const remainingMs = this.#deliveryTimeoutMs - (this.#now().getTime() - startedAtMs);
+        if (attempts >= retryLimit || remainingMs <= 0) {
             if (key === "operator")
                 this.#operatorStartupRetryArmed = false;
             this.#terminalizePreparedAfterRetryExhaustion(key, identity, stableTerminalFailure);
@@ -1588,11 +1599,12 @@ export class FileTaskController {
         this.#deliveryRetryAttempts.set(key, {
             identity,
             attempts: attempts + 1,
+            startedAtMs,
             ...(stableTerminalFailure === undefined
                 ? {}
                 : { terminalFailure: stableTerminalFailure })
         });
-        const delayMs = Math.min(2_000, this.#deliveryRetryMs * (2 ** Math.min(attempts, 3)));
+        const delayMs = Math.min(remainingMs, 2_000, this.#deliveryRetryMs * (2 ** Math.min(attempts, 3)));
         const timer = setTimeout(() => {
             this.#deliveryRetryTimers.delete(key);
             if (!this.#stopped)