@zq-silk/yui 0.13.6 → 0.13.8

package/dist/role/role.js

@@ -19,19 +19,22 @@ export function createRole(taskId, name, bindings, activeAgentId, workspace, now
     const owner = createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess);
     return validateTaskRole({
         ...owner,
-        taskId: requireSafeIdentity(taskId, "Task id"),
-        status: "idle"
+        schemaVersion: 4,
+        taskId: requireSafeIdentity(taskId, "Task id")
     });
 }
 export function createGlobalRole(name, bindings, activeAgentId, workspace, now, profile = {}, defaultAccess = "write") {
-    return createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess);
+    return validateGlobalRole({
+        ...createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess),
+        schemaVersion: 3
+    });
 }
 export function copyGlobalRoleToTaskRole(globalRole, taskId, now, name = globalRole.name) {
     validateGlobalRole(globalRole);
     const timestamp = now.toISOString();
     return validateTaskRole({
         ...cloneProfile(globalRole),
-        schemaVersion: 3,
+        schemaVersion: 4,
         launchRevision: 1,
         defaultAccess: globalRole.defaultAccess,
         taskId: requireSafeIdentity(taskId, "Task id"),
@@ -39,7 +42,6 @@ export function copyGlobalRoleToTaskRole(globalRole, taskId, now, name = globalR
         activeAgentId: globalRole.activeAgentId,
         agentBindings: cloneBindings(globalRole.agentBindings),
         workspace: globalRole.workspace,
-        status: "idle",
         createdAt: timestamp,
         updatedAt: timestamp
     });
@@ -76,12 +78,6 @@ export function updateRole(role, patch, now) {
         : role.launchRevision + 1;
     return validateTaskRole(updated);
 }
-export function updateRoleStatus(role, status, now) {
-    validateTaskRole(role);
-    if (!isRoleStatus(status))
-        throw new Error(`Role status is invalid: ${status}.`);
-    return { ...role, status, updatedAt: now.toISOString() };
-}
 export function switchActiveRoleAgent(role, sessions, targetAgentId, runtime, now) {
     validateRoleOwner(role);
     const normalizedTarget = requireSafeIdentity(targetAgentId, "Target Agent id");
@@ -175,8 +171,6 @@ export function validateGlobalRole(role) {
 }
 export function validateTaskRole(role) {
     requireSafeIdentity(role.taskId, "Task id");
-    if (!isRoleStatus(role.status))
-        throw new Error(`Role status is invalid: ${role.status}.`);
     return validateRoleOwner(role);
 }
 function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess) {
@@ -189,9 +183,8 @@ function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile,
         mappedBindings[binding.agentId] = binding;
     }
     const timestamp = now.toISOString();
-    return validateGlobalRole({
+    return {
         ...cloneProfile(profile),
-        schemaVersion: 3,
         launchRevision: 1,
         defaultAccess,
         name: requireSafeIdentity(name, "Role name"),
@@ -200,11 +193,13 @@ function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile,
         workspace: requireText(workspace, "Role workspace"),
         createdAt: timestamp,
         updatedAt: timestamp
-    });
+    };
 }
 function validateRoleOwner(role) {
-    if (role.schemaVersion !== 3)
+    const expectedSchemaVersion = "taskId" in role ? 4 : 3;
+    if (role.schemaVersion !== expectedSchemaVersion) {
         throw new Error("Role schema version is invalid.");
+    }
     if (!Number.isSafeInteger(role.launchRevision) || role.launchRevision < 1) {
         throw new Error("Role launch revision must be a positive integer.");
     }
@@ -333,6 +328,3 @@ function requireText(value, label) {
         throw new Error(`${label} is required.`);
     return normalized;
 }
-function isRoleStatus(value) {
-    return ["idle", "running", "detached", "exited", "failed"].includes(value);
-}

package/dist/runtime/agentHost.js

@@ -145,7 +145,7 @@ export async function runAgentHost(input) {
             providerControl: {
                 schemaVersion: 1,
                 adapterId: "codex",
-                transport: "codex-app-server",
+                transport: "codex-app-server-proxy",
                 kind: "ensure",
                 mode: "resume",
                 nativeSessionId: disconnectedSession.nativeSessionId,
@@ -257,7 +257,7 @@ export async function runAgentHost(input) {
                     ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
                     ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
                     ...exitAuthority,
-                    detail: "Codex App Server disconnected; starting a replacement process."
+                    detail: "Codex App Server proxy disconnected; attaching a replacement client."
                 }));
                 await reconnectCodexClient(providerSession, currentPayload);
                 return;

package/dist/runtime/builtinAgentDrivers.js

@@ -121,7 +121,8 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
             }),
             observation: Object.freeze({
                 ...STRUCTURED_CLI_CAPABILITIES.observation,
-                // Managed Codex uses its Yui-owned App Server event stream.
+                // Managed Codex uses its Yui-owned proxy subscription to the shared
+                // App Server event stream.
                 // Turn lifecycle is exact; Yui does not install per-thread Hooks merely
                 // to manufacture tool/wait/usage observations.
                 operations: Object.freeze([]),

package/dist/runtime/index.js

@@ -14,7 +14,7 @@ export { formatRuntimeLaunchDiagnostic, redactLaunchArgument, redactLaunchText,
 export { DEFAULT_FORCED_GRACE_MS, DEFAULT_GRACEFUL_GRACE_MS, terminateSessionOwners } from "./sessionTerminationGuard.js";
 export { ProviderContinuationReconciliationService } from "./providerContinuationReconciliationService.js";
 export { codexNotificationBoundary, codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime } from "./codexAppServerRuntime.js";
-export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rebindProviderRuntimeRun, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
+export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
 export { FencedProviderControl } from "./providerControl.js";
 export { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 export { decideProviderRecovery } from "./providerRecoveryDecision.js";

package/dist/runtime/launchBroker.js

@@ -86,7 +86,7 @@ function validateProviderControl(control) {
     if (control.adapterId !== "codex" && control.adapterId !== "claude") {
         throw new Error("Agent Host Provider control adapter is invalid.");
     }
-    if ((control.adapterId === "codex" && control.transport !== "codex-app-server")
+    if ((control.adapterId === "codex" && control.transport !== "codex-app-server-proxy")
         || (control.adapterId === "claude" && control.transport !== "claude-stream-json")) {
         throw new Error("Agent Host Provider control transport does not match its adapter.");
     }

package/dist/runtime/providerRuntimeIdentity.js

@@ -1,10 +1,9 @@
 export function createProviderRuntimeBinding(input) {
     const startedAt = timestamp(input.startedAt, "Provider Activation startedAt");
     return validateProviderRuntimeBinding({
-        schemaVersion: 2,
+        schemaVersion: 3,
         providerNamespace: identity(input.providerNamespace, "Provider namespace"),
         accountScope: identity(input.accountScope, "Provider account scope"),
-        runId: identity(input.runId, "Run id"),
         currentConversationEpoch: 1,
         conversations: [{
                 conversationId: identity(input.conversationId, "Provider Conversation id"),
@@ -40,17 +39,6 @@ export function currentProviderActivation(binding) {
     const conversation = currentProviderConversation(binding);
     return [...binding.activations].reverse().find((entry) => (entry.conversationId === conversation.conversationId && entry.status === "active")) ?? null;
 }
-/** Rebinds the live Conversation state to the next Yui Run without resetting authority. */
-export function rebindProviderRuntimeRun(raw, runId) {
-    const binding = validateProviderRuntimeBinding(raw);
-    if (providerTurnIsActive(binding.turn)) {
-        throw new Error("Provider Runtime cannot bind another Run while a Turn is unsettled.");
-    }
-    return validateProviderRuntimeBinding({
-        ...binding,
-        runId: identity(runId, "Run id")
-    });
-}
 export function startProviderActivation(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     if (currentProviderActivation(binding) !== null) {
@@ -158,8 +146,10 @@ export function transferProviderAuthority(raw, input) {
 }
 export function beginProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
+    const runId = identity(input.runId, "Run id");
     const attemptId = identity(input.attemptId, "Provider input attempt id");
-    if (binding.turn?.attemptId === attemptId
+    if (binding.turn?.runId === runId
+        && binding.turn.attemptId === attemptId
         && binding.turn.authorityEpoch === input.authorityEpoch
         && binding.turn.status === "submitting") {
         return binding;
@@ -176,6 +166,7 @@ export function beginProviderTurn(raw, input) {
     return validateProviderRuntimeBinding({
         ...binding,
         turn: {
+            runId,
             attemptId,
             authorityEpoch: input.authorityEpoch,
             status: "submitting",
@@ -350,11 +341,10 @@ export function supersedeProviderConversation(raw, input) {
     });
 }
 export function validateProviderRuntimeBinding(value) {
-    if (value.schemaVersion !== 2)
-        throw new Error("Provider Runtime Binding schemaVersion must be 2.");
+    if (value.schemaVersion !== 3)
+        throw new Error("Provider Runtime Binding schemaVersion must be 3.");
     identity(value.providerNamespace, "Provider namespace");
     identity(value.accountScope, "Provider account scope");
-    identity(value.runId, "Run id");
     integer(value.currentConversationEpoch, 1, "Current Provider Conversation epoch");
     if (!Array.isArray(value.conversations) || value.conversations.length === 0) {
         throw new Error("Provider Runtime Binding requires a Conversation.");
@@ -459,6 +449,7 @@ export function validateProviderRuntimeBinding(value) {
     return value;
 }
 function validateProviderTurn(turn, currentAuthorityEpoch) {
+    identity(turn.runId, "Run id");
     identity(turn.attemptId, "Provider input attempt id");
     integer(turn.authorityEpoch, 1, "Provider Turn authority epoch");
     if (turn.authorityEpoch > currentAuthorityEpoch) {

package/dist/runtime/structuredProviderHost.js

@@ -1,9 +1,12 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { Duplex } from "node:stream";
+import WebSocket from "ws";
 import { CodexAppServerRequestError, CodexAppServerRuntime, codexAppServerErrorIsMissing } from "./codexAppServerRuntime.js";
 import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 import { YUI_VERSION } from "../version.js";
 const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
+const CODEX_PROXY_HANDSHAKE_TIMEOUT_MS = 10_000;
 export class ProviderDeliveryUnknownError extends Error {
     attemptId;
     name = "ProviderDeliveryUnknownError";
@@ -73,27 +76,57 @@ export async function startStructuredProviderSession(payload, input = {}) {
         throw error;
     }
 }
-class JsonLineChannel {
+class CodexProxyWebSocketChannel {
     child;
     mirror;
     #pending = new Map();
     #listeners = new Set();
-    #buffer = "";
     #nextId = 1;
     #closedError;
+    #ready = false;
+    #readyPromise;
+    #resolveReady;
+    #rejectReady;
+    #webSocket;
     constructor(child, mirror) {
         this.child = child;
         this.mirror = mirror;
-        child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => this.#receive(chunk));
+        let resolveReady;
+        let rejectReady;
+        this.#readyPromise = new Promise((resolvePromise, reject) => {
+            resolveReady = resolvePromise;
+            rejectReady = reject;
+        });
+        this.#resolveReady = resolveReady;
+        this.#rejectReady = rejectReady;
+        const transport = new ChildProcessDuplex(child);
+        this.#webSocket = new WebSocket("ws://localhost/rpc", {
+            createConnection: () => transport,
+            handshakeTimeout: CODEX_PROXY_HANDSHAKE_TIMEOUT_MS,
+            maxPayload: PROVIDER_MESSAGE_MAX_BYTES,
+            perMessageDeflate: false
+        });
+        this.#webSocket.once("open", () => {
+            this.#ready = true;
+            this.#resolveReady();
+        });
+        this.#webSocket.on("message", (data, isBinary) => this.#receive(data, isBinary));
+        this.#webSocket.on("error", (error) => this.#close(error));
+        this.#webSocket.once("close", (code, reason) => this.#close(new Error(`Codex App Server proxy WebSocket closed (code=${code}, reason=${reason.toString() || "none"}).`)));
         child.once("error", (error) => this.#close(error));
         child.once("close", (code, signal) => this.#close(new Error(`Provider process exited before replying (code=${code ?? "none"}, signal=${signal ?? "none"}).`)));
     }
+    static async connect(child, mirror) {
+        const channel = new CodexProxyWebSocketChannel(child, mirror);
+        await channel.#readyPromise;
+        return channel;
+    }
     onMessage(listener) {
         this.#listeners.add(listener);
         return () => this.#listeners.delete(listener);
     }
     async request(method, params) {
+        await this.#readyPromise;
         if (this.#closedError !== undefined)
             throw this.#closedError;
         const id = String(this.#nextId++);
@@ -120,6 +153,136 @@ class JsonLineChannel {
     async notify(method, params) {
         await this.send({ method, ...(params === undefined ? {} : { params }) });
     }
+    async send(message) {
+        await this.#readyPromise;
+        if (this.#closedError !== undefined)
+            throw this.#closedError;
+        const encoded = JSON.stringify(message);
+        if (Buffer.byteLength(encoded, "utf8") > PROVIDER_MESSAGE_MAX_BYTES) {
+            throw new Error("Provider request exceeds its message bound.");
+        }
+        await new Promise((resolvePromise, reject) => {
+            this.#webSocket.send(encoded, (error) => {
+                if (error === undefined || error === null)
+                    resolvePromise();
+                else
+                    reject(error);
+            });
+        });
+    }
+    #receive(data, isBinary) {
+        const encoded = Buffer.isBuffer(data)
+            ? data
+            : data instanceof ArrayBuffer
+                ? Buffer.from(data)
+                : Buffer.concat(data);
+        if (isBinary || encoded.byteLength > PROVIDER_MESSAGE_MAX_BYTES) {
+            this.#close(new Error(isBinary
+                ? "Provider returned an unsupported binary WebSocket message."
+                : "Provider response message exceeds its bound."));
+            terminateProcessGroup(this.child, "SIGTERM");
+            return;
+        }
+        const text = encoded.toString("utf8");
+        this.mirror("stdout", `${text}\n`);
+        let message;
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+                return;
+            message = parsed;
+        }
+        catch {
+            return;
+        }
+        const id = requestId(message.id);
+        const pending = id === undefined ? undefined : this.#pending.get(id);
+        if (pending !== undefined) {
+            clearTimeout(pending.timer);
+            this.#pending.delete(id);
+            const error = object(message.error);
+            if (error !== null) {
+                pending.reject(new CodexAppServerRequestError(typeof error.code === "number" || typeof error.code === "string"
+                    ? error.code
+                    : "UNKNOWN", typeof error.message === "string" ? error.message : "Provider request failed.", error.data));
+            }
+            else {
+                pending.resolve(object(message.result) ?? {});
+            }
+            return;
+        }
+        for (const listener of this.#listeners)
+            listener(message);
+    }
+    #close(error) {
+        if (this.#closedError !== undefined)
+            return;
+        this.#closedError = error;
+        if (!this.#ready)
+            this.#rejectReady(error);
+        for (const pending of this.#pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.#pending.clear();
+        if (this.child.exitCode === null && this.child.signalCode === null) {
+            terminateProcessGroup(this.child, "SIGTERM");
+        }
+    }
+}
+class ChildProcessDuplex extends Duplex {
+    child;
+    connecting = false;
+    constructor(child) {
+        super();
+        this.child = child;
+        child.stdout.on("data", (chunk) => {
+            if (!this.push(chunk))
+                child.stdout.pause();
+        });
+        child.stdout.once("end", () => this.push(null));
+        child.once("error", (error) => this.destroy(error));
+        child.once("close", () => this.destroy());
+    }
+    _read() {
+        this.child.stdout.resume();
+    }
+    _write(chunk, encoding, callback) {
+        this.child.stdin.write(chunk, encoding, callback);
+    }
+    _final(callback) {
+        this.child.stdin.end(callback);
+    }
+    setNoDelay() {
+        return this;
+    }
+    setKeepAlive() {
+        return this;
+    }
+    setTimeout(_timeout, callback) {
+        if (callback !== undefined)
+            this.once("timeout", callback);
+        return this;
+    }
+}
+class JsonLineChannel {
+    child;
+    mirror;
+    #listeners = new Set();
+    #buffer = "";
+    #closedError;
+    constructor(child, mirror) {
+        this.child = child;
+        this.mirror = mirror;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => this.#receive(chunk));
+        child.once("error", (error) => this.#close(error));
+        child.once("close", (code, signal) => this.#close(new Error(`Provider process exited (code=${code ?? "none"}, signal=${signal ?? "none"}).`)));
+    }
+    onMessage(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
     async send(message) {
         if (this.#closedError !== undefined)
             throw this.#closedError;
@@ -152,45 +315,21 @@ class JsonLineChannel {
             this.#buffer = this.#buffer.slice(newline + 1);
             if (line.length === 0)
                 continue;
-            let message;
             try {
                 const parsed = JSON.parse(line);
                 if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
                     continue;
-                message = parsed;
+                for (const listener of this.#listeners)
+                    listener(parsed);
             }
             catch {
                 continue;
             }
-            const id = requestId(message.id);
-            const pending = id === undefined ? undefined : this.#pending.get(id);
-            if (pending !== undefined) {
-                clearTimeout(pending.timer);
-                this.#pending.delete(id);
-                const error = object(message.error);
-                if (error !== null) {
-                    pending.reject(new CodexAppServerRequestError(typeof error.code === "number" || typeof error.code === "string"
-                        ? error.code
-                        : "UNKNOWN", typeof error.message === "string" ? error.message : "Provider request failed.", error.data));
-                }
-                else {
-                    pending.resolve(object(message.result) ?? {});
-                }
-                continue;
-            }
-            for (const listener of this.#listeners)
-                listener(message);
         }
     }
     #close(error) {
-        if (this.#closedError !== undefined)
-            return;
-        this.#closedError = error;
-        for (const pending of this.#pending.values()) {
-            clearTimeout(pending.timer);
-            pending.reject(error);
-        }
-        this.#pending.clear();
+        if (this.#closedError === undefined)
+            this.#closedError = error;
     }
 }
 class CodexStructuredProviderSession {
@@ -214,7 +353,7 @@ class CodexStructuredProviderSession {
         this.onTerminal = onTerminal;
     }
     static async open(child, exit, processInstanceId, payload, control, onTerminal, mirror) {
-        const channel = new JsonLineChannel(child, mirror);
+        const channel = await CodexProxyWebSocketChannel.connect(child, mirror);
         const openingMessages = [];
         const stopOpeningBuffer = channel.onMessage((message) => openingMessages.push(message));
         await channel.request("initialize", {

package/dist/runtime/tmuxAdapters.js

@@ -347,7 +347,7 @@ export class TmuxSessionHost {
                     : { [YUI_TASK_RUNTIME_DESCRIPTOR]: frozenTaskRuntime })
             }
         };
-        let hostCreated;
+        let hostCreated = false;
         let providerAcknowledged = false;
         let providerDeliveryUnknown = false;
         let providerBusy = false;
@@ -420,6 +420,14 @@ export class TmuxSessionHost {
         }
         catch (error) {
             broker.revoke(request.launchId);
+            if (hostCreated && !providerDispatchObserved) {
+                try {
+                    await stopExactRole(this.tmux, hostId, request.owner.roleName);
+                }
+                catch (stopError) {
+                    throw new Error(`Managed Provider launch failed and its disposable Agent Host could not be stopped: ${stopError instanceof Error ? stopError.message : String(stopError)}`, { cause: stopError });
+                }
+            }
             throw error;
         }
         if (providerDispatchObserved

package/dist/scheduler/activeRoleRunDelivery.js

@@ -497,17 +497,9 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         };
     }
     // Managed input has one write path: a new structured Turn at a settled
-    // boundary. Corrections retain their priority while the current Turn runs.
+    // boundary. AgentHost owns Provider serialization; a busy send releases the
+    // claim and leaves the durable correction pending for the next pass.
     const mode = "followup";
-    if (session.status === "running") {
-        return {
-            taskId: task.id,
-            roleName: role.name,
-            runId: run.id,
-            status: "skipped",
-            reason: "not-ready"
-        };
-    }
     if (writer === null) {
         return {
             taskId: task.id,

package/dist/scheduler/activeTaskProgress.js

@@ -25,8 +25,6 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             const run = store.getActiveAgentRun(task.id, role.name);
             return run === null ? [] : [run];
         });
-        const hasInFlightTurn = roles.some((role) => store.hasInFlightTurn(task.id, role.name));
-        const hasLeaderInFlightTurn = store.hasInFlightTurn(task.id, "leader");
         const leaderTarget = { kind: "role", taskId: task.id, roleName: "leader" };
         const leaderMailbox = store.getWorkMailbox(leaderTarget);
         const projection = projectTaskExecution({
@@ -41,8 +39,7 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             && !activeRuns.some(({ roleName }) => roleName === "leader")
             && activeRuns.some(({ roleName }) => roleName !== "leader")
             && projection.status === "waiting-on-agents";
-        if ((queuedAlongsideActiveSibling ? hasLeaderInFlightTurn : hasInFlightTurn)
-            || store.hasOpenInputRequest(task.id)
+        if (store.hasOpenInputRequest(task.id)
             || store.getLeaderFailure(task.id) !== null
             || (projection.status !== "needs-leader-action" && !queuedAlongsideActiveSibling)
             || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {

package/dist/scheduler/leaderWakeupProcessor.js

@@ -42,11 +42,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             results.push({ taskId: task.id, status: "skipped", reason: "busy" });
             continue;
         }
-        if (typeof store.hasInFlightTurn === "function"
-            && store.hasInFlightTurn(task.id, role.name)) {
-            results.push({ taskId: task.id, status: "skipped", reason: "busy" });
-            continue;
-        }
         const reopening = wakeup.reasons.includes("task-reopened");
         let existingSession = store.getRoleSession(task.id, role.name, reopening ? undefined : role.effective.agentId);
         let effectiveSession = existingSession;

package/dist/scheduler/roleRunStall.js

@@ -786,7 +786,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             continue;
         const evidenceKey = [
             kind,
-            stallEvidenceKey(candidate.role.status, candidate.session?.status),
+            stallEvidenceKey(candidate.session?.status),
             classification,
             ...(candidate.role.name === "leader"
                 ? [leaderStallEvidence(store, candidate.task.id, observed, now, windowMs)]
@@ -1001,8 +1001,8 @@ function leaderStallEvidence(store, taskId, observed, now, windowMs) {
                 : "recent";
     return `downstream=active:${active},healthy:${healthy},stalled:${stalled}:leader-mailbox=${pendingAge},leader-processing=${processingAge}`;
 }
-function stallEvidenceKey(roleStatus, sessionStatus) {
-    return `live-pane-no-progress:role=${roleStatus}:session=${sessionStatus ?? "unknown"}`;
+function stallEvidenceKey(sessionStatus) {
+    return `live-pane-no-progress:session=${sessionStatus ?? "unknown"}`;
 }
 function exactLiveStatuses(statuses, candidates) {
     const expected = new Set(candidates.map(({ task, role }) => `${task.id}\0${role.name}`));