@zq-silk/yui 0.11.3 → 0.12.1

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,14 +1,12 @@
 import { createAgentRun } from "../run/agentRun.js";
-import { createRunAssignment, serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
+import { createRunAssignment } from "../context/runContextContract.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
-import { prefixYuiTitleInput } from "../run/runIdentity.js";
-import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.js";
-import { createLeaderRecoveryNotification } from "./operatorNotification.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
+import { roleSessionDispatchModeWithConversationSwitch } from "../runtime/conversationSwitch.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
     const wakeups = selection === undefined || selection.full
@@ -69,7 +67,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
         let effectiveSession = existingSession;
         let claimed = false;
         let deliveryAttempted = false;
-        let providerSubmissionBegun = false;
         let run = null;
         let prepared;
         let preStartFencePersisted = false;
@@ -114,7 +111,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const compatibleSession = existingSession !== null
                 && (reopening
                     ? effectiveLaunchSnapshotsCompatible(existingSession.effective, role.effective)
-                    : effectiveLaunchSnapshotsCompatibleForTaskMain(existingSession.effective, role.effective, role.managedWorkspace));
+                    : effectiveLaunchSnapshotsCompatibleForTaskSession(existingSession.effective, role.effective));
             const reopenIdentityDrift = reopening
                 && hasNativeSession(existingSession)
                 && !compatibleSession;
@@ -126,23 +123,15 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const resumableSession = hasNativeSession(existingSession)
                 && existingSession.status !== "stopped"
                 && existingSession.status !== "broken";
-            // Quick Win (EXE-03): a resume Run that failed before durable Provider
-            // acceptance must not be retried against the same native Session.  The
-            // Session is proven unusable for this delivery; the next launch must be
-            // a fresh Session after exact cleanup/reset.  The guard only applies
-            // while the failed resume Run is the *latest* Run for the Role: once a
-            // newer Run exists (the fresh-Session launch), the historical failure
-            // is stale and must not permanently disable resume for the Role.
-            const latestRoleRun = store.listAgentRuns?.(task.id)
-                ?.filter((run) => run.roleName === role.name)
-                .at(-1);
-            const failedResumeWithoutAcceptance = latestRoleRun !== undefined
-                && latestRoleRun.mode === "resume"
-                && latestRoleRun.status === "failed"
-                && latestRoleRun.deliveredAt === undefined;
-            const mode = resumableSession && compatibleSession && !failedResumeWithoutAcceptance
-                ? "resume"
-                : "new";
+            // A failed or quiet Run is not proof that its Provider Conversation is
+            // unusable. Keep resuming the same identity unless an explicit switch
+            // request (or exact terminal/missing evidence) authorizes a fresh one.
+            const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
+            const mode = reopenIdentityDrift
+                ? "new"
+                : sessionSet === null
+                    ? resumableSession && compatibleSession ? "resume" : "new"
+                    : roleSessionDispatchModeWithConversationSwitch(sessionSet, store.listEvents?.(task.id) ?? [], store.getWorkMailbox({ kind: "role", taskId: task.id, roleName: role.name }), role.name, role.effective.agentId, role.effective);
             const runId = store.peekNextAgentRunId(task.id);
             const wakeEnvelope = resolveLeaderWakeEnvelope(store, task.id);
             const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);
@@ -261,19 +250,42 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 now
             });
             if (ready.prepared.turnRejectedDuringLaunch === true) {
-                delivery.forgetPrepared?.({
+                const persisted = store.saveRoleRunDeliveryFailure({
                     taskId: task.id,
                     roleName: role.name,
+                    agentId: run.effective.agentId,
+                    adapterId: run.effective.adapterId,
                     runId: run.id,
+                    mailboxBatchId: formatAgentRunReceiptId(task.id, run.id),
+                    ...(effectiveSession?.nativeSessionId === undefined
+                        ? {}
+                        : { nativeSessionId: effectiveSession.nativeSessionId }),
                     ...(ready.prepared.launchId === undefined
                         ? {}
-                        : { launchId: ready.prepared.launchId })
+                        : { launchId: ready.prepared.launchId }),
+                    summary: `Provider conclusively rejected the exact initial Leader Run input: ${run.id}.`,
+                    cleanupRequired: false,
+                    now
                 });
+                if (persisted === "failed") {
+                    delivery.forgetPrepared?.({
+                        taskId: task.id,
+                        roleName: role.name,
+                        runId: run.id,
+                        ...(ready.prepared.launchId === undefined
+                            ? {}
+                            : { launchId: ready.prepared.launchId })
+                    });
+                }
                 results.push({
                     taskId: task.id,
                     runId: run.id,
-                    status: "skipped",
-                    reason: "not-ready"
+                    status: persisted === "failed" ? "failed" : "skipped",
+                    reason: "provider-rejected",
+                    terminalized: persisted === "failed",
+                    ...(persisted === "failed"
+                        ? {}
+                        : { error: "Run state changed while recording exact Provider rejection." })
                 });
                 continue;
             }
@@ -329,118 +341,11 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 results.push({ taskId: task.id, runId: run.id, status: "dispatched" });
                 continue;
             }
-            const receiptId = formatAgentRunReceiptId(task.id, run.id);
-            if (effectiveSession === null || effectiveSession.launchId === undefined
-                || !hasNativeSession(effectiveSession)
-                || store.beginRoleRunProviderTurn?.({
-                    taskId: task.id,
-                    roleName: role.name,
-                    runId: run.id,
-                    agentId: run.effective.agentId,
-                    launchId: effectiveSession.launchId,
-                    nativeSessionId: effectiveSession.nativeSessionId,
-                    attemptId: receiptId,
-                    now
-                }) !== true) {
-                throw new Error("Provider Turn intent could not be durably fenced before delivery.");
-            }
-            providerSubmissionBegun = true;
-            deliveryAttempted = true;
-            const outcome = await delivery.sendOnce({
-                delivery: ready,
-                receiptId,
-                text: prefixYuiTitleInput(serializeRunBootstrapEnvelope(run.bootstrapEnvelope), resolveTaskRoleSessionTitle(effectiveSession.title, task, role.name))
-            });
-            if (outcome === "busy" || outcome === "unavailable") {
-                store.resolveRoleRunProviderSubmission?.({
-                    taskId: task.id,
-                    roleName: role.name,
-                    runId: run.id,
-                    attemptId: receiptId,
-                    status: "rejected",
-                    reason: outcome === "busy"
-                        ? "Agent Host was busy before Provider mutation."
-                        : "Agent Host was unavailable before Provider mutation.",
-                    now
-                });
-                providerSubmissionBegun = false;
-                results.push({
-                    taskId: task.id,
-                    runId: run.id,
-                    status: "skipped",
-                    reason: "not-ready"
-                });
-                continue;
-            }
-            if (outcome === "rejected") {
-                store.resolveRoleRunProviderSubmission?.({
-                    taskId: task.id,
-                    roleName: role.name,
-                    runId: run.id,
-                    attemptId: receiptId,
-                    status: "rejected",
-                    reason: "Provider returned an exact negative acknowledgement.",
-                    now
-                });
-                providerSubmissionBegun = false;
-                results.push({ taskId: task.id, runId: run.id, status: "skipped", reason: "not-ready" });
-                continue;
-            }
-            if (outcome === "delivery-unknown") {
-                store.resolveRoleRunProviderSubmission?.({
-                    taskId: task.id,
-                    roleName: role.name,
-                    runId: run.id,
-                    attemptId: receiptId,
-                    status: "delivery-unknown",
-                    reason: "Provider Turn delivery is ambiguous; automatic retry is fenced.",
-                    now
-                });
-                providerSubmissionBegun = false;
-                store.saveRoleRunDelivery({
-                    task,
-                    role,
-                    run,
-                    session: effectiveSession,
-                    ...(ready.prepared.launchId === undefined
-                        ? {}
-                        : { launchId: ready.prepared.launchId }),
-                    now
-                });
-                results.push({
-                    taskId: task.id,
-                    runId: run.id,
-                    status: "skipped",
-                    reason: "delivery-uncertain"
-                });
-                continue;
-            }
-            store.saveRoleRunDelivery({
-                task,
-                role,
-                run,
-                session: effectiveSession,
-                ...(ready.prepared.launchId === undefined
-                    ? {}
-                    : { launchId: ready.prepared.launchId }),
-                now
-            });
-            results.push({ taskId: task.id, runId: run.id, status: "dispatched" });
+            throw new Error("Managed Provider launch completed without an initial Turn outcome.");
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
             const message = `Leader dispatch failed: ${detail}`;
-            if (providerSubmissionBegun && run !== null) {
-                store.resolveRoleRunProviderSubmission?.({
-                    taskId: task.id,
-                    roleName: role.name,
-                    runId: run.id,
-                    attemptId: formatAgentRunReceiptId(task.id, run.id),
-                    status: "delivery-unknown",
-                    reason: detail,
-                    now
-                });
-            }
             if (claimed && run !== null) {
                 // Scheduler single-flight backpressure: the Role runtime lifecycle
                 // lane was busy when the launch was reserved. The claimed Run stays
@@ -504,7 +409,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     session: effectiveSession,
                     claimed: { run, wakeup },
                     failure: recordLeaderFailure(task.id, effectiveSession?.nativeSessionId ?? "(unregistered)", message, now, store.getLeaderFailure(task.id)),
-                    notification: createLeaderRecoveryNotification(task.id, message, now, store.getOperatorNotification(task.id)),
                     now
                 });
                 if (failureResult === "state-changed") {
@@ -535,7 +439,7 @@ function validateReadySession(role, effective, existing, mode, session) {
         throw new Error(`Ready session belongs to another Agent: ${session.agentId}.`);
     }
     const compatible = mode === "resume"
-        ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, effective, role.managedWorkspace)
+        ? effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, effective)
         : effectiveLaunchSnapshotsCompatible(session.effective, effective);
     if (!compatible) {
         throw new Error("Ready Leader session effective snapshot changed.");

package/dist/scheduler/operatorEvent.js

@@ -0,0 +1,34 @@
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+export const LEADER_ATTENTION_REQUIRED_EVENT = "leader.attention-required";
+/** The sole Task-event boundary into the global Operator mailbox. */
+export function enqueueOperatorEvent(store, event, reason, now) {
+    enqueueWork(store, { kind: "operator" }, reason, now, [
+        { type: "event", taskId: event.taskId, id: event.id }
+    ], {
+        source: "task-event",
+        dedupeKey: `operator-event:${event.taskId}:${event.id}`,
+        deliveryMode: "followup",
+        lane: "normal"
+    });
+}
+/** Routes one Role fact to its supervisor without exposing Provider details to Operator code. */
+export function routeRoleEvent(store, event, roleName, reason, now) {
+    if (roleName === "leader") {
+        enqueueOperatorEvent(store, event, reason, now);
+        return;
+    }
+    enqueueWork(store, { kind: "role", taskId: event.taskId, roleName: "leader" }, reason, now, [{ type: "event", taskId: event.taskId, id: event.id }], {
+        source: "task-event",
+        dedupeKey: `leader-event:${event.taskId}:${event.id}`,
+        deliveryMode: "followup",
+        lane: "normal"
+    });
+}
+/** Records the semantic boundary used when a Leader can no longer continue. */
+export function recordLeaderAttentionRequired(store, input) {
+    const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, LEADER_ATTENTION_REQUIRED_EVENT, { ...(input.payload ?? {}), reason: input.reason }, input.now);
+    store.saveEvent(input.taskId, event);
+    enqueueOperatorEvent(store, event, "leader-attention-required", input.now);
+    return event;
+}

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -1,4 +1,4 @@
-import { createInputRequestOperatorPresentation, createLeaderRecoveryOperatorPresentation, createLeaderStallOperatorPresentation, createTaskTerminalOperatorPresentation } from "../interaction/operatorPresentation.js";
+import { createOperatorBatchPresentation } from "../interaction/operatorPresentation.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 export async function processOperatorInputNotifications(store, delivery, selection, now = new Date()) {
     if (selection !== undefined && !selection.full && !selection.operator)
@@ -19,18 +19,18 @@ export async function processOperatorInputNotifications(store, delivery, selecti
     if (claim.status === "empty")
         return [];
     const processing = claim.processing;
-    const requests = processing.batch.refs
-        .flatMap((ref) => ref.type === "input"
-        ? [store.getInputRequest(ref.taskId, ref.id)]
-        : [])
-        .filter((request) => request !== null && request.status === "open")
-        .map((request) => ({ kind: "input", request }));
-    const notifications = processing.batch.refs
-        .filter((ref) => ref.type === "task")
-        .map((ref) => store.getOperatorNotification(ref.id))
-        .filter((notification) => notification !== null)
-        .map((notification) => ({ kind: "notification", notification }));
-    const attentions = deduplicateAttention([...requests, ...notifications]);
+    const attentions = deduplicateAttention(processing.batch.refs.flatMap((ref) => {
+        if (ref.type === "input") {
+            const request = store.getInputRequest(ref.taskId, ref.id);
+            return request !== null && request.status === "open"
+                ? [{ kind: "input", request }]
+                : [];
+        }
+        if (ref.type !== "event" || store.listEvents === undefined)
+            return [];
+        const event = store.listEvents(ref.taskId).find(({ id }) => id === ref.id);
+        return event === undefined ? [] : [{ kind: "event", event }];
+    }));
     if (attentions.length === 0) {
         store.completeWorkMailbox(targetMailbox, processing.batchId);
         return [];
@@ -41,58 +41,35 @@ export async function processOperatorInputNotifications(store, delivery, selecti
         store.releaseWorkMailbox(targetMailbox, processing.batchId);
         return attentions.map((attention) => skipped(attention, reason));
     }
-    const results = [];
-    for (const [index, attention] of attentions.entries()) {
-        try {
-            const presentation = createAttentionPresentation(attention, store);
-            const outcome = await delivery.notifyOperatorInputOnce({
-                ...target,
-                receiptId: presentation.receiptId,
-                text: presentation.text
-            });
-            if (outcome === "unavailable") {
-                store.releaseWorkMailbox(targetMailbox, processing.batchId);
-                results.push(skipped(attention, "operator-unavailable"));
-                results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-unavailable"))));
-                break;
-            }
-            else if (outcome === "not-ready") {
-                store.releaseWorkMailbox(targetMailbox, processing.batchId);
-                results.push(skipped(attention, "operator-not-ready"));
-                results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
-                break;
-            }
-            else {
-                results.push({
-                    ...attentionIdentity(attention),
-                    status: outcome
-                });
-                if (outcome === "sent") {
-                    if (index === attentions.length - 1) {
-                        store.completeWorkMailbox(targetMailbox, processing.batchId);
-                    }
-                    else {
-                        store.releaseWorkMailbox(targetMailbox, processing.batchId);
-                    }
-                    results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
-                    break;
-                }
-            }
-        }
-        catch (error) {
+    try {
+        const presentation = createOperatorBatchPresentation(processing.batchId, attentions.map(toPresentationItem));
+        const outcome = await delivery.notifyOperatorInputOnce({
+            ...target,
+            receiptId: presentation.receiptId,
+            text: presentation.text
+        });
+        if (outcome === "unavailable" || outcome === "not-ready") {
             store.releaseWorkMailbox(targetMailbox, processing.batchId);
-            results.push({
-                ...attentionIdentity(attention),
-                status: "failed",
-                error: error instanceof Error ? error.message : String(error)
-            });
-            break;
+            const reason = outcome === "unavailable" ? "operator-unavailable" : "operator-not-ready";
+            return attentions.map((attention) => skipped(attention, reason));
         }
-    }
-    if (results.length > 0 && results.every((result) => result.status === "already-sent")) {
+        if (outcome === "sent")
+            store.markOperatorTurnStarted(now);
         store.completeWorkMailbox(targetMailbox, processing.batchId);
+        return attentions.map((attention) => ({
+            ...attentionIdentity(attention),
+            status: outcome
+        }));
+    }
+    catch (error) {
+        store.releaseWorkMailbox(targetMailbox, processing.batchId);
+        const detail = error instanceof Error ? error.message : String(error);
+        return attentions.map((attention) => ({
+            ...attentionIdentity(attention),
+            status: "failed",
+            error: detail
+        }));
     }
-    return results;
 }
 function skipped(attention, reason) {
     return {
@@ -102,45 +79,28 @@ function skipped(attention, reason) {
     };
 }
 function attentionIdentity(attention) {
-    if (attention.kind === "input") {
-        return { inputRequestId: attention.request.id, taskId: attention.request.taskId };
-    }
-    if (attention.notification.type === "leader-recovery-failed") {
-        return {
-            recoveryTaskId: attention.notification.taskId,
-            taskId: attention.notification.taskId
-        };
-    }
-    if (attention.notification.type === "leader-stalled") {
-        return {
-            stallTaskId: attention.notification.taskId,
-            taskId: attention.notification.taskId
+    return attention.kind === "input"
+        ? {
+            sourceKind: "input",
+            sourceId: attention.request.id,
+            taskId: attention.request.taskId
+        }
+        : {
+            sourceKind: "event",
+            sourceId: attention.event.id,
+            taskId: attention.event.taskId
         };
-    }
-    return {
-        terminalTaskId: attention.notification.taskId,
-        taskId: attention.notification.taskId
-    };
 }
-function createAttentionPresentation(attention, store) {
-    if (attention.kind === "input") {
-        return createInputRequestOperatorPresentation(attention.request, store.getPresentationContext());
-    }
-    if (attention.notification.type === "leader-recovery-failed") {
-        return createLeaderRecoveryOperatorPresentation(attention.notification);
-    }
-    return attention.notification.type === "leader-stalled"
-        ? createLeaderStallOperatorPresentation(attention.notification)
-        : createTaskTerminalOperatorPresentation(attention.notification);
+function toPresentationItem(attention) {
+    return attention.kind === "input"
+        ? { kind: "input-request", request: attention.request }
+        : { kind: "task-event", event: attention.event };
 }
 function deduplicateAttention(attentions) {
     const seen = new Set();
     return attentions.filter((attention) => {
-        const key = attention.kind === "input"
-            ? `input:${attention.request.taskId}:${attention.request.id}`
-            : attention.notification.type === "leader-stalled"
-                ? `stall:${attention.notification.taskId}:${attention.notification.runId}:${attention.notification.progressAt}`
-                : `recovery:${attention.notification.taskId}:${attention.notification.createdAt}`;
+        const identity = attentionIdentity(attention);
+        const key = `${identity.sourceKind}:${identity.taskId}:${identity.sourceId}`;
         if (seen.has(key))
             return false;
         seen.add(key);

package/dist/scheduler/roleRunStall.js

@@ -12,6 +12,7 @@ export const DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS = RUNTIME_DIAGNOSTIC_AFTER_
 export const RUN_PROGRESS_EVENT = "run.progress";
 export const RUN_STALLED_EVENT = "run.stalled";
 export const RUN_RECOVERED_EVENT = "run.recovered";
+export const RUN_DIAGNOSTIC_FINISHED_EVENT = "runtime.diagnostic-finished";
 /** Structured, non-Message recovery evidence written by an explicit Leader. */
 export const RUN_RECOVERY_REQUESTED_EVENT = "run.recovery-requested";
 export const RUN_RECOVERY_APPLIED_EVENT = "run.recovery-applied";
@@ -30,20 +31,6 @@ const ACTIVITY_EVENT_TYPES = new Set([
     "integration.completed",
     "integration.failed"
 ]);
-/**
- * Clear only the Operator projection raised for this exact Leader Run. A
- * later Run (or a recovery notification of another kind) must remain intact;
- * callers use this helper from every supported recovery/terminalization path
- * so attention cleanup cannot drift between CLI and runtime code.
- */
-export function clearMatchingLeaderStallAttention(store, taskId, runId) {
-    const notification = store.getOperatorNotification(taskId);
-    if (notification?.type !== "leader-stalled" || notification.runId !== runId) {
-        return false;
-    }
-    store.clearOperatorNotification(taskId);
-    return true;
-}
 /**
  * One pure projection used by every Role. Resource activity is retained only
  * as exact-generation diagnostic evidence; it never changes the durable
@@ -64,10 +51,7 @@ export function projectRoleRunHealth(input) {
     const idleMs = evaluation.idleMs;
     const candidateStart = input.deliveredAt ?? input.createdAt;
     const candidateAge = input.now.getTime() - Date.parse(candidateStart);
-    const candidate = Number.isFinite(candidateAge)
-        && (input.deliveredAt === undefined
-            ? candidateAge >= windowMs
-            : candidateAge >= diagnosticAfterMs);
+    const candidate = Number.isFinite(candidateAge) && candidateAge >= windowMs;
     const providerAcceptance = input.providerAcceptance
         ?? (input.deliveredAt === undefined ? "ambiguous" : "accepted");
     const hostLiveness = input.hostLiveness;
@@ -451,6 +435,8 @@ export function isRoleRunStalled(events, runId) {
         if (event.payload.runId !== runId)
             continue;
         if (event.type === RUN_STALLED_EVENT) {
+            if (event.payload.status === "diagnostic-only")
+                continue;
             if (stalled === undefined
                 || Date.parse(event.createdAt) > Date.parse(stalled.createdAt)) {
                 stalled = event;
@@ -489,8 +475,9 @@ export function isRoleRunStalled(events, runId) {
 /**
  * Low-frequency health pass for active Task Role Runs. An unaccepted Run is
  * watched as delivery-stalled after the reasonable delivery window; an
- * accepted Run enters the workflow-stall candidate scan after ten minutes,
- * while the actual no-progress threshold remains thirty minutes.
+ * accepted Run is displayed as checkpoint-overdue after fifteen minutes, but
+ * this scheduler performs no runtime inspection until the thirty-minute
+ * diagnostic window is due.
  * Leader Runs are only persisted when classification reaches truly-stalled —
  * healthy downstream work, open user input, and recent own progress remain
  * structured waiting/working facts. No branch sends terminal bytes, retries,
@@ -521,14 +508,43 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
                 session: store.getRoleSession(task.id, role.name, run.effective.agentId)
             }];
     })));
-    const stallCandidates = candidates.filter(({ run }) => isStallCandidate(run, now, windowMs, diagnosticAfterMs));
+    const eventsByTask = new Map();
+    const diagnosticEvents = (taskId) => {
+        const existing = eventsByTask.get(taskId);
+        if (existing !== undefined)
+            return existing;
+        const events = store.listEvents?.(taskId) ?? [];
+        eventsByTask.set(taskId, events);
+        return events;
+    };
+    const cadenceCandidates = candidates.filter(({ task, run }) => isStallCandidate(run, now, windowMs, latestRunEventTime(diagnosticEvents(task.id), RUN_DIAGNOSTIC_FINISHED_EVENT, run.id)));
+    const stallCandidates = cadenceCandidates.filter(({ task, role, run }) => {
+        const progressFacts = foldPortPresent
+            ? store.getRunProgressFacts?.(task.id, run.id)
+            : undefined;
+        const progressAt = currentRoleRunProgressAt(store, task.id, role.name, run, foldPortPresent ? undefined : diagnosticEvents(task.id), progressFacts).progressAt;
+        return isStallCandidate(run, now, windowMs, latestRunEventTime(diagnosticEvents(task.id), RUN_DIAGNOSTIC_FINISHED_EVENT, run.id), progressAt);
+    });
     if (stallCandidates.length === 0)
         return [];
+    const diagnosticStartedAt = now.toISOString();
+    const finishDiagnostics = (outcome) => {
+        for (const { task, role, run } of stallCandidates) {
+            store.recordRoleRunDiagnostic?.({
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id,
+                startedAt: diagnosticStartedAt,
+                outcome,
+                now
+            });
+        }
+    };
     const stallCandidateKeys = new Set(stallCandidates.map(({ task, role }) => (`${task.id}\0${role.name}`)));
     const observed = new Map();
     // Recent active Runs are known healthy enough for Leader classification from
     // their exact acceptance/creation boundary, but are deliberately not read
-    // from tmux or Event history until the 10-minute execution candidate window.
+    // from tmux or Event history until the 30-minute diagnostic window.
     for (const candidate of candidates) {
         const key = `${candidate.task.id}\0${candidate.role.name}`;
         if (stallCandidateKeys.has(key))
@@ -577,7 +593,9 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         }
         catch {
             // Health inspection is advisory. Unknown host state must leave the exact
-            // Run/Session fence untouched and let the next full pass retry.
+            // Run/Session fence untouched. Closing this window schedules the next
+            // bounded diagnostic thirty minutes later instead of hot-looping.
+            finishDiagnostics("observation-error");
             return [];
         }
     }
@@ -589,6 +607,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         catch {
             // A malformed/partial provider snapshot is not evidence of a stall.
             // Leave all fences untouched and let the next full pass retry.
+            finishDiagnostics("observation-error");
             return [];
         }
     }
@@ -602,8 +621,10 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         const key = `${candidate.task.id}\0${candidate.role.name}`;
         let live;
         try {
-            if (liveStatuses !== undefined && !liveStatuses.has(key))
+            if (liveStatuses !== undefined && !liveStatuses.has(key)) {
+                finishDiagnostics("observation-error");
                 return [];
+            }
             live = liveStatuses !== undefined
                 ? liveStatuses.get(key)
                 : byRole === null
@@ -622,6 +643,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             // Without a complete live snapshot, especially for downstream Runs,
             // Leader classification would be unsafe. Treat the whole advisory pass
             // as unknown instead of escalating a false stall.
+            finishDiagnostics("observation-error");
             return [];
         }
         // A missing process is handled by the existing fenced liveness pass. This
@@ -826,18 +848,18 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             });
         }
     }
+    finishDiagnostics("observed");
     return raised;
 }
-function isStallCandidate(run, now, windowMs, diagnosticAfterMs) {
+function isStallCandidate(run, now, windowMs, lastDiagnosticFinishedAt, latestProgressAt) {
     const startAt = run.deliveredAt ?? run.createdAt;
-    const ageMs = now.getTime() - Date.parse(startAt);
+    const baseline = [startAt, lastDiagnosticFinishedAt, latestProgressAt]
+        .filter((value) => (value !== undefined && Number.isFinite(Date.parse(value))))
+        .reduce((latest, value) => (Date.parse(value) > Date.parse(latest) ? value : latest));
+    const ageMs = now.getTime() - Date.parse(baseline);
     if (!Number.isFinite(ageMs))
         return false;
-    // Undelivered Runs are watched for a delivery stall on the same reasonable
-    // window, but they never enter workflow-stall candidate filtering.
-    return run.deliveredAt === undefined
-        ? ageMs >= windowMs
-        : ageMs >= diagnosticAfterMs;
+    return ageMs >= windowMs;
 }
 function classifyLeaderStall(store, taskId, observed, now, windowMs) {
     if (store.hasOpenInputRequest(taskId))