@zq-silk/yui 2.16.0 → 2.17.0

package/dist/controller/globalInputDelivery.js

@@ -1,3 +1,4 @@
+import { isEnabled } from "../role/availability.js";
 import { sendAgentHostRunControl, reconcileAgentHostTurn, AGENT_HOST_CONTROL_PROTOCOL } from "../runtime/agentHost.js";
 import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
@@ -25,14 +26,6 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
             if (sessions !== null && selected?.status !== "active"
                 && !(role.jobOwner && selected === undefined))
                 continue;
-            if (sessions?.providerBinding?.retry !== undefined && !providerRetryPending(sessions.providerBinding)) {
-                store.transaction(tx => settleGlobalRetryInput(tx, role.name, tx.getGlobalRoleSessionSet(role.name)?.providerBinding, new Date()));
-                pending = store.queryGlobalRoleMessages(role.name, { pending: true, unclaimed: true, limit: 64 }).messages;
-                if (pending.length === 0)
-                    continue;
-            }
-            if (providerRetryPending(sessions?.providerBinding))
-                continue;
             let current = sessions?.providerBinding?.run;
             const bindingBefore = sessions?.providerBinding;
             if (options.reconcile && current != null
@@ -95,6 +88,19 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
                 if (pending.length === 0)
                     continue;
             }
+            // Availability blocks new work, not observation of the original writer's
+            // exact terminal. Re-read after the asynchronous reconciliation above.
+            const currentRole = store.getGlobalRole(role.name);
+            if (currentRole === null || !isEnabled(currentRole))
+                continue;
+            if (sessions?.providerBinding?.retry !== undefined && !providerRetryPending(sessions.providerBinding)) {
+                store.transaction(tx => settleGlobalRetryInput(tx, role.name, tx.getGlobalRoleSessionSet(role.name)?.providerBinding, new Date()));
+                pending = store.queryGlobalRoleMessages(role.name, { pending: true, unclaimed: true, limit: 64 }).messages;
+                if (pending.length === 0)
+                    continue;
+            }
+            if (providerRetryPending(sessions?.providerBinding))
+                continue;
             const recovery = globalInboxRecovery(store, role.name, options.now ?? new Date());
             const recovering = recovery !== undefined && recovery.inbox === undefined && recovery.delivery === undefined
                 && recovery.notDelivered === undefined && recovery.control === undefined;

package/dist/controller/providerRetryAdmission.js

@@ -1,3 +1,4 @@
+import { assertRoleEnabled, isEnabled } from "../role/availability.js";
 import { admitProviderRetry, cancelProviderRetry, providerRetryAttemptId, providerRetryPending } from "../runtime/providerRetry.js";
 import { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
@@ -20,6 +21,8 @@ export function ownedProviderInput(input) {
 export function retryIntentBlocker(store, input, retry) {
     if (input.taskId === undefined) {
         const role = store.getGlobalRole(input.roleName);
+        if (role !== null && !isEnabled(role))
+            return "role-disabled";
         const sessions = store.getGlobalRoleSessionSet(input.roleName);
         if (role === null || sessions?.activeAgentId !== role.activeAgentId)
             return "role-changed";
@@ -38,6 +41,8 @@ export function retryIntentBlocker(store, input, retry) {
         || task.executionGate.state !== "enabled")
         return "task-execution-stopped";
     const role = store.getRole(input.taskId, input.roleName);
+    if (role !== null && !isEnabled(role))
+        return "role-disabled";
     const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
     if (role === null || sessions?.activeAgentId !== role.activeAgentId)
         return "role-changed";
@@ -54,6 +59,10 @@ export function retryIntentBlocker(store, input, retry) {
 /** Shared by automatic recovery and every ordinary Host submit. The native
  * writer CAS remains the only grant; a scheduled successor is not a grant. */
 export function admitOwnedProviderInput(store, binding, input) {
+    const role = input.taskId === undefined ? store.getGlobalRole(input.roleName)
+        : store.getRole(input.taskId, input.roleName);
+    if (role !== null)
+        assertRoleEnabled(role);
     const retry = binding.retry;
     const sameReviewSuccessor = retry?.successorReviewRoundId !== undefined && input.taskId !== undefined && input.runId !== undefined
         && store.getRun(input.taskId, input.runId)?.reviewRoundId === retry.successorReviewRoundId;

package/dist/controller/providerRetryDelivery.js

@@ -1,4 +1,5 @@
 import { performance } from "node:perf_hooks";
+import { isEnabled } from "../role/availability.js";
 import { runTaskCommand } from "../commands/taskCommands.js";
 import { routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { createTaskEvent } from "../event/taskEvent.js";
@@ -64,12 +65,19 @@ export function createProviderRetryHooks(home, store, ports = {}) {
     const key = (set) => set.owner.scope === "task"
         ? `role:${encodeURIComponent(set.owner.taskId)}/${encodeURIComponent(set.owner.roleName)}`
         : `global-role:${encodeURIComponent(set.owner.roleName)}`;
+    const disabled = (set) => {
+        const role = set.owner.scope === "task"
+            ? store.getRole(set.owner.taskId, set.owner.roleName) : store.getGlobalRole(set.owner.roleName);
+        return role !== null && !isEnabled(role);
+    };
     return {
         deadlines() {
             return store.listProviderRetrySessions().flatMap(set => {
                 const retry = set.providerBinding.retry;
                 if (retry.status !== "waiting")
                     return [];
+                if (disabled(set))
+                    return [];
                 // Busy or already-queued work awaits the next ordinary pass without a
                 // zero-delay timer loop. Waiting never consumes an execution attempt.
                 const wall = (ports.now ?? (() => new Date()))().getTime();
@@ -97,6 +105,10 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                     const scoped = { ...(owner.scope === "task" ? { taskId: owner.taskId } : {}), roleName: owner.roleName };
                     const session = set.sessions[set.activeAgentId];
                     const blocker = retryIntentBlocker(store, scoped, retry);
+                    // Configuration pause neither settles input nor cancels an already
+                    // admitted attempt. Normal ingress still records its exact terminal.
+                    if (blocker === "role-disabled")
+                        continue;
                     if (blocker !== undefined && blocker !== "background-work-unsettled") {
                         stop(set, blocker, at);
                         continue;
@@ -175,6 +187,10 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                                     || latest.status !== "waiting")
                                     return;
                                 const reason = retryIntentBlocker(store, scoped, latest);
+                                // Snapshotting yields to configuration changes. Apply the same
+                                // pause semantics as the pre-await check, without settling intent.
+                                if (reason === "role-disabled")
+                                    return;
                                 if (reason !== undefined)
                                     throw new Error(reason);
                                 runTaskCommand(["run", "retry", `${owner.taskId}/${previous.id}`], store, {

package/dist/controller/runtime.js

@@ -2,6 +2,7 @@ import { isDeepStrictEqual } from "node:util";
 import { prepareNativeHostSteer } from "./nativeHostInput.js";
 import { archiveLeaderTask } from "../task/leaderArchive.js";
 import { TaskWorkspaceCoordinator } from "../repository/taskWorkspaceCoordinator.js";
+import { assertRoleEnabled, RoleDisabledError } from "../role/availability.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
 import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveRuntimeHealth, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
@@ -740,6 +741,17 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 });
             }
             catch (error) {
+                if (error instanceof RoleDisabledError) {
+                    const turn = (value.taskId === undefined
+                        ? store.getGlobalRoleSessionSet(value.roleName)
+                        : store.getTaskRoleSessionSet(value.taskId, value.roleName))?.providerBinding?.run;
+                    // The admission transaction rolled back. Only a new, unregistered
+                    // input may use the existing temporary-backpressure wire contract.
+                    // A matching prior registration remains fenced, never a fresh retry.
+                    if (turn?.attemptId !== value.attemptId) {
+                        throw applicationError("SESSION_BUSY", error.message);
+                    }
+                }
                 if (error instanceof AgentHostProviderSessionBusyError)
                     throw error;
                 if (error instanceof AgentHostProviderTurnFenceError) {
@@ -960,6 +972,7 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
                 ? activeRun?.workspace
                     ?? currentDesiredManagedWorkspace(store, request.taskId, request.roleName)
                 : undefined;
+            assertRoleEnabled(role);
             // Only Draft planning may launch without an adopted delivery workspace.
             const workspaceFree = request.scope === "task"
                 && managedWorkspace === undefined
@@ -1082,6 +1095,7 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
     if (role === null) {
         throw new Error(`Role no longer exists: ${request.owner.roleName}.`);
     }
+    assertRoleEnabled(role);
     const sessions = request.owner.scope === "task"
         ? store.getTaskRoleSessionSet(request.owner.taskId, request.owner.roleName)
         : store.getGlobalRoleSessionSet(request.owner.roleName);

package/dist/controller/runtimeLaunchCoordinator.js

@@ -92,7 +92,9 @@ export class RuntimeLaunchCoordinator {
             ...(request.runId === undefined ? {} : { runId: request.runId }),
             ...(request.environment === undefined ? {} : { environment: request.environment })
         };
-        const callback = beforeHostStart === undefined ? undefined : observePreflight;
+        // Even without a startup-facts consumer, recheck after asynchronous Host
+        // validation and immediately before creating the process.
+        const callback = beforeHostStart === undefined ? () => assertLaunchCurrent() : observePreflight;
         if (request.mode === "resume" && !request.nativeSessionId) {
             throw new Error("Restoring a Session requires its native session id.");
         }

package/dist/executor/fileRoleLaunchPlanner.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
+import { assertRoleEnabled } from "../role/availability.js";
 import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/agent.js";
 import { NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment } from "../agent/launchEnvironment.js";
 import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
@@ -106,6 +107,7 @@ export class FileRoleLaunchPlanner {
         const role = this.store.getRole(input.taskId, input.roleName);
         if (role === null)
             throw new Error(`Role not found: ${input.taskId}/${input.roleName}.`);
+        assertRoleEnabled(role);
         const activeRun = this.store.getActiveRun(task.id, role.name);
         if (input.runId !== undefined && activeRun?.id !== input.runId) {
             throw new Error(`Role AgentRun is no longer current: ${input.runId}.`);
@@ -226,6 +228,7 @@ export class FileRoleLaunchPlanner {
         const role = this.store.getGlobalRole(input.roleName);
         if (role === null)
             throw new Error(`Global Role not found: ${input.roleName}.`);
+        assertRoleEnabled(role);
         const sessionSet = this.store.getGlobalRoleSessionSet(role.name);
         if (activeLiveRoleAgentSession(sessionSet) !== null && sessionSet?.providerBinding == null) {
             throw new Error("Global Role has an unmanaged live Session. Stop that exact Session before opening controlled input; it will not be silently replaced.");

package/dist/message/messageContinuation.js

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
+import { isEnabled } from "../role/availability.js";
 import { createRun } from "../agentRun/agentRun.js";
 import { createRunInput } from "../context/runInputContract.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot } from "../context/contextSnapshot.js";
@@ -90,6 +91,9 @@ export function messageAssignmentBlocker(store, message) {
 }
 /** Starting another Run additionally requires the reviewed candidate to remain current. */
 export function messageContinuationBlocker(store, message) {
+    const role = message.recipient === undefined ? null : store.getRole(message.taskId, message.recipient.roleName);
+    if (role !== null && !isEnabled(role))
+        return "role-disabled";
     const invalid = messageAssignmentBlocker(store, message);
     if (invalid !== undefined)
         return invalid;

package/dist/output/rolePresentation.js

@@ -1,3 +1,4 @@
+import { isEnabled, roleDisabledReason } from "../role/availability.js";
 import { activeRoleAgentSession } from "../executor/agentExecutor.js";
 import { effectiveRoleForLaunch } from "../executor/effectiveLaunch.js";
 import { defaultTableWidth, renderTable } from "./table.js";
@@ -49,6 +50,8 @@ export function renderRoleDetails(title, role, input) {
     ];
     const overview = [
         `  Kind             ${input.kind}`,
+        `  Enabled          ${isEnabled(role)}`,
+        ...(!isEnabled(role) ? [`  Availability     ${roleDisabledReason(role)}`] : []),
         `  Active Agent     ${role.activeAgentId}`,
         `  Workspace        ${role.workspace}`,
         ...("taskId" in role ? [

package/dist/profile/agentProfile.js

@@ -1,3 +1,4 @@
+import { validateEnabled } from "../role/availability.js";
 import { cloneJson, normalizedUniqueText, optionalText, requireIdentity, requirePositiveInteger, requireTimestamp } from "../domain/validation.js";
 export const BUILTIN_PROFILE_IDS = Object.freeze([
     "worker",
@@ -31,6 +32,7 @@ export function updateAgentProfile(profile, patch, now) {
     return validateAgentProfile(candidate);
 }
 export function validateAgentProfile(profile) {
+    validateEnabled(profile.enabled);
     if (profile.schemaVersion !== 1) {
         throw new Error("AgentProfile must use schemaVersion 1.");
     }
@@ -82,7 +84,9 @@ export function builtinAgentProfileInputs() {
     ];
 }
 function normalizeInput(input) {
+    validateEnabled(input.enabled);
     return {
+        enabled: input.enabled ?? true,
         defaultAccess: validatedAccess(input.defaultAccess ?? "read"),
         ...(input.description === undefined
             ? {}
@@ -98,6 +102,10 @@ function normalizeInput(input) {
 }
 function normalizePatch(patch) {
     const result = {};
+    if (patch.enabled !== undefined) {
+        validateEnabled(patch.enabled);
+        result.enabled = patch.enabled;
+    }
     if (Object.hasOwn(patch, "defaultAccess")) {
         result.defaultAccess = validatedAccess(patch.defaultAccess);
     }

package/dist/profile/agentProfileRuntime.js

@@ -1,3 +1,4 @@
+import { isEnabled, roleDisabledReason } from "../role/availability.js";
 import { createRoleAgentBinding } from "../role/role.js";
 /** The single read model for persisted Profile intent and current runtime. */
 export function resolveAgentProfileView(profile, store) {
@@ -13,7 +14,12 @@ export function resolveAgentProfileView(profile, store) {
  * dormant, and overlays its own model/effort; another Agent starts from its
  * provider defaults.
  */
-export function resolveAgentProfileRuntime(profile, store) {
+export function resolveAgentProfileRuntime(profile, store, options = {}) {
+    if (!options.configurationOnly && !isEnabled(profile))
+        return {
+            status: "unavailable", source: profile.runtime.source,
+            reason: `Agent Profile ${profile.id} is disabled. Use yui config profile enable ${profile.id}. Existing Task bindings are unchanged.`
+        };
     if (profile.runtime.source === "global-worker") {
         const worker = store.getGlobalRole("worker");
         if (worker === null) {
@@ -23,6 +29,11 @@ export function resolveAgentProfileRuntime(profile, store) {
                 reason: "Global Role worker is not configured."
             };
         }
+        if (!options.configurationOnly && !isEnabled(worker))
+            return {
+                status: "unavailable", source: "global-worker", workerRevision: worker.launchRevision,
+                reason: roleDisabledReason(worker)
+            };
         const binding = worker.agentBindings[worker.activeAgentId];
         if (binding === undefined) {
             return {
@@ -66,6 +77,10 @@ export function resolveAgentProfileRuntime(profile, store) {
     }
     const worker = store.getGlobalRole("worker");
     const workerBinding = worker?.agentBindings[agent.id];
+    if (!options.configurationOnly && worker !== null && workerBinding !== undefined && !isEnabled(worker)) {
+        return { status: "unavailable", source: "explicit",
+            reason: `Profile copies the matching Worker binding. ${roleDisabledReason(worker)}` };
+    }
     if (workerBinding !== undefined && workerBinding.adapterId !== agent.adapterId) {
         return {
             status: "unavailable",

package/dist/review/reviewDecision.js

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
+import { isEnabled, roleDisabledReason } from "../role/availability.js";
 import { isCompletedTaskReviewEvidence } from "./reviewAcceptance.js";
 import { projectReviewerAvailability } from "./reviewerAvailability.js";
 /** Read-only facts for Leader judgment; this projection never blocks an action. */
@@ -43,6 +44,11 @@ export function projectReviewDecision(input) {
         ])].sort();
     const reviewers = reviewerNames.map((reviewerRoleName) => {
         const role = roles.find(({ name }) => name === reviewerRoleName);
+        const applicable = role ?? store.getGlobalRole(reviewerRoleName);
+        if (applicable !== null && !isEnabled(applicable))
+            return {
+                reviewerRoleName, status: "unavailable", retryable: false, reason: roleDisabledReason(applicable)
+            };
         if (role === undefined && store.getGlobalRole(reviewerRoleName) === null) {
             return {
                 reviewerRoleName,

package/dist/role/availability.js

@@ -0,0 +1,28 @@
+/** Additive configuration: valid older records remain enabled. This is not
+ * Session state, launch configuration drift, or permission to stop a writer. */
+export function isEnabled(value) {
+    return value.enabled !== false;
+}
+export function validateEnabled(value) {
+    if (value !== undefined && typeof value !== "boolean") {
+        throw new Error("Enabled must be a boolean.");
+    }
+}
+export function parseEnabled(value) {
+    if (value !== "true" && value !== "false")
+        throw new Error("--enabled must be true or false.");
+    return value === "true";
+}
+export function roleDisabledReason(role) {
+    const target = role.taskId === undefined ? `config role enable ${role.name}`
+        : `task role enable ${role.taskId} ${role.name}`;
+    return `Role ${role.taskId === undefined ? "" : `${role.taskId}/`}${role.name} is disabled. `
+        + `Use yui ${target} to allow new execution; existing execution is not stopped.`;
+}
+export class RoleDisabledError extends Error {
+    name = "RoleDisabledError";
+}
+export function assertRoleEnabled(role) {
+    if (!isEnabled(role))
+        throw new RoleDisabledError(roleDisabledReason(role));
+}

package/dist/role/role.js

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
+import { assertRoleEnabled, validateEnabled } from "./availability.js";
 import { requireKnownFields } from "../domain/validation.js";
 import { jobScopeKey } from "../job/jobDefinition.js";
 import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
@@ -44,10 +45,12 @@ export function createGlobalRole(name, bindings, activeAgentId, workspace, now,
 }
 export function copyGlobalRoleToTaskRole(globalRole, taskId, now, name = globalRole.name) {
     validateGlobalRole(globalRole);
+    assertRoleEnabled(globalRole);
     const timestamp = now.toISOString();
     return validateTaskRole({
         ...cloneProfile(globalRole),
         schemaVersion: 1,
+        enabled: true,
         launchRevision: 1,
         defaultAccess: globalRole.defaultAccess,
         taskId: requireSafeIdentity(taskId, "Task id"),
@@ -219,6 +222,7 @@ function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile,
     const timestamp = now.toISOString();
     return {
         ...cloneProfile(profile),
+        enabled: true,
         launchRevision: 1,
         defaultAccess,
         name: requireSafeIdentity(name, "Role name"),
@@ -230,6 +234,7 @@ function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile,
     };
 }
 function validateRoleOwner(role) {
+    validateEnabled(role.enabled);
     if (role.schemaVersion !== 1) {
         throw new Error("Role schema version is invalid.");
     }
@@ -298,6 +303,7 @@ function assertSessionOwnerMatchesRole(role, sessions) {
 }
 function cloneRolePatch(patch) {
     return {
+        ...(patch.enabled === undefined ? {} : { enabled: patch.enabled }),
         ...(patch.name === undefined ? {} : { name: requireSafeIdentity(patch.name, "Role name") }),
         ...(patch.activeAgentId === undefined
             ? {}

package/dist/runtime/codexNativeAccess.js

@@ -18,13 +18,23 @@ export function createCodexNativeAccess(threadId, initialized, channel, openingM
     const listeners = new Set();
     let configuration = initialConfiguration;
     let observedAt = new Date().toISOString();
-    const observed = () => typeof configuration?.model !== "string"
-        ? unknownAgentRunConfiguration("No confirmed native model response. Reconnect to restore the fixed launch configuration.")
+    // A start/resume response confirms configuration at that instant, not the
+    // current Turn or later changes made by another client. Keep its timestamp;
+    // consumers must not describe repeated reads as fresh native observations.
+    const observed = () => typeof configuration?.model !== "string" || !configuration.model.trim()
+        ? unknownAgentRunConfiguration("No confirmed native configuration response. Current model and reasoning effort are unknown.")
         : {
             status: "observed", observedAt,
             handshake: { status: "unsupported", reason: "Model reported by Codex thread/start or thread/resume; not a capability handshake." },
             requested: [],
-            axes: [{ key: "model", category: "model", current: { status: "observed", value: configuration.model }, offered: [] }]
+            axes: [
+                { key: "model", category: "model", current: { status: "observed", value: configuration.model }, offered: [] },
+                { key: "reasoningEffort", category: "effort",
+                    current: typeof configuration.reasoningEffort === "string" && configuration.reasoningEffort.trim()
+                        ? { status: "observed", value: configuration.reasoningEffort }
+                        : { status: "unobserved", reason: "The native response did not confirm reasoning effort." },
+                    offered: [] }
+            ]
         };
     const observe = (message) => {
         const params = message.params;
@@ -86,9 +96,16 @@ export function createCodexNativeAccess(threadId, initialized, channel, openingM
                 if (params.threadId !== threadId)
                     throw new Error("Select the existing Session; new/forked Threads are not supported here.");
                 const page = params.initialTurnsPage;
-                configuration = await channel.request("thread/resume", { threadId,
+                // A failed/uncertain resume cannot leave the earlier confirmation
+                // looking valid. Do not retry this potentially applied operation.
+                configuration = undefined;
+                const result = await channel.request("thread/resume", { threadId,
                     ...(typeof params.excludeTurns === "boolean" ? { excludeTurns: params.excludeTurns } : {}),
                     ...(page ? { initialTurnsPage: { ...page, limit: Math.min(40, typeof page.limit === "number" && page.limit > 0 ? page.limit : 40) } } : {}) });
+                if (result.thread?.id !== threadId) {
+                    throw new Error("Native resume did not confirm the selected Thread.");
+                }
+                configuration = result;
                 observedAt = new Date().toISOString();
                 return configuration;
             }

package/dist/runtime/tmuxAdapters.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { RoleDisabledError } from "../role/availability.js";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { providerDeliveryFailureFrom } from "./agentError.js";
@@ -189,6 +190,8 @@ export class TmuxSessionHost {
                 : this.planner.planGlobalRole(input);
         }
         catch (error) {
+            if (error instanceof RoleDisabledError)
+                throw error;
             throw toRuntimeLaunchFailure(error, "validation", {
                 cwd: request.workspace,
                 agentId: request.agentId
@@ -206,6 +209,8 @@ export class TmuxSessionHost {
                 await this.#validateLaunch(request);
             }
             catch (error) {
+                if (error instanceof RoleDisabledError)
+                    throw error;
                 throw toRuntimeLaunchFailure(error, "validation", launchContext);
             }
         }

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { isEnabled, roleDisabledReason, RoleDisabledError } from "../role/availability.js";
 import { serializeRunInputEnvelope } from "../context/runInputContract.js";
 import { readRunContextSnapshot } from "../context/runContextPack.js";
 import { roleSessionMayContinue, sameEffectiveLaunch } from "../executor/effectiveLaunch.js";
@@ -37,6 +38,8 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
 }
 async function deliverActiveRun(store, delivery, task, role, run, now) {
     const base = { taskId: task.id, roleName: role.name, runId: run.id };
+    if (!isEnabled(role))
+        return { ...base, status: "skipped", reason: "not-ready", error: roleDisabledReason(role) };
     if (!isSchedulerTaskWorkspaceReady(task, store.getTaskWorkspace(task.id), run.purpose)) {
         return { ...base, status: "skipped", reason: "workspace-not-ready" };
     }
@@ -231,6 +234,12 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        // A configuration pause before submission preserves the original intent.
+        // After submission, the existing unknown-effect fence still owns recovery.
+        if (!submitted && error instanceof RoleDisabledError) {
+            forget(delivery, task.id, role.name, run.id);
+            return { ...base, status: "skipped", reason: "not-ready", error: message };
+        }
         // Preserve the structured cause alongside the readable diagnosis.
         const causeName = innermostCauseName(error);
         store.recordAgentError({

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,4 +1,5 @@
 import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
+import { isEnabled, roleDisabledReason, RoleDisabledError } from "../role/availability.js";
 import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { hasImmediateWakeReason } from "./wakeReason.js";
@@ -22,6 +23,10 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             results.push({ ...base, status: "skipped", reason: "unavailable" });
             continue;
         }
+        if (!isEnabled(role)) {
+            results.push({ ...base, status: "skipped", reason: "unavailable", error: roleDisabledReason(role) });
+            continue;
+        }
         if (!isSchedulerTaskWorkspaceReady(task, store.getTaskWorkspace(task.id), task.status === "draft" ? "planning" : "execution")) {
             results.push({ ...base, status: "skipped", reason: "workspace-not-ready" });
             continue;
@@ -104,9 +109,11 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             // permits another automatic launch. A config/auth/executable failure
             // needs correction; an exception after submit cannot authorize replay.
             const retryable = error instanceof RuntimeLifecycleBusyError
+                || error instanceof RoleDisabledError
                 || (error instanceof RuntimeLaunchError && error.retryable);
             store.settleLeaderNotification(task.id, notification.attemptId, attempted ? "unknown" : retryable ? "deferred" : "rejected", now, detail, { effective, raw: detail, phase: attempted ? "turn-submit" : "session-start" });
-            results.push({ ...base, status: "failed", reason: "not-ready", error: detail });
+            results.push({ ...base, status: !attempted && error instanceof RoleDisabledError ? "skipped" : "failed",
+                reason: "not-ready", error: detail });
         }
         finally {
             delivery.forgetPrepared?.({ taskId: task.id, roleName: role.name });

package/dist/scheduler/roleRunLiveness.js

@@ -1,3 +1,4 @@
+import { isEnabled } from "../role/availability.js";
 import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
 import { selectedActiveSchedulerTasks, selectedSchedulerRoles } from "./ports.js";
@@ -104,6 +105,8 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
                 observedAt: now
             });
         }
+        if (!isEnabled(role))
+            continue;
         if (session?.nativeSessionId === undefined) {
             store.queueTaskProgress(task.id, "host-missing-native-resume-unproven", now);
             continue;

package/dist/storage/sqliteSchema.js

@@ -243,6 +243,16 @@ const MINOR_UPGRADES = Object.freeze([{
         targetChecksum: CURRENT_SCHEMA_CHECKSUM,
         sql: "",
         dataMigration: "project-sync-clock"
+    }, {
+        fromVersion: "1.21",
+        toVersion: "1.22",
+        name: "role-profile-availability",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Optional enabled flag; absence means enabled. Preserve all historical
+        // Role/Profile bytes, frozen contexts and Session snapshots.
+        sql: ""
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.21";
+export const CURRENT_STORAGE_VERSION = "1.22";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {