@zq-silk/yui 0.12.0 → 0.12.1

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,20 +1,14 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
-import { prefixYuiTitleInput } from "../run/runIdentity.js";
-import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
-import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
-import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
-import { serializeWorkflowOutcomeRequestEnvelope } from "../run/runControlRequest.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
@@ -109,9 +103,14 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
             let preparedSession = existingSession;
             let preStartFencePersisted = false;
             let deliveryAttempted = false;
-            let providerSubmissionBegun = false;
             try {
-                const nativeSessionId = run.mode === "resume"
+                // Workflow-outcome control is always another Turn on the already-bound
+                // Conversation. Provider retry alone may carry an exact missing-
+                // Conversation decision and therefore retains its explicit new mode.
+                const launchMode = run.controlRequest?.state === "dispatching"
+                    ? "resume"
+                    : run.mode;
+                const nativeSessionId = launchMode === "resume"
                     ? requireResumeSession(role, run.effective, existingSession)
                     : undefined;
                 prepared = await delivery.prepareRoleSession({
@@ -124,12 +123,12 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     ...(run.workspace === undefined
                         ? {}
                         : { managedWorkspace: run.workspace }),
-                    mode: run.mode,
+                    mode: launchMode,
                     runId: run.id,
                     ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
                     beforeHostStart: (preflight) => {
                         persistPreStartFence(store, task, role, run, existingSession, preflight, now);
-                        preparedSession = preflightSession(role, run.effective, existingSession, run.mode, preflight);
+                        preparedSession = preflightSession(role, run.effective, existingSession, launchMode, preflight);
                         preStartFencePersisted = true;
                     }
                 });
@@ -177,20 +176,32 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     now
                 });
                 if (ready.prepared.turnRejectedDuringLaunch === true) {
-                    delivery.forgetPrepared?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        ...(ready.prepared.launchId === undefined
-                            ? {}
-                            : { launchId: ready.prepared.launchId })
+                    const persisted = store.saveRoleRunDeliveryFailure({
+                        ...roleRunDeliveryFailure(run, processing.batchId, session, ready.prepared.launchId),
+                        summary: `Provider conclusively rejected the exact initial 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,
                         roleName: role.name,
                         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;
                 }
@@ -252,171 +263,10 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     });
                     continue;
                 }
-                // Pre-input readiness gate. For an adapter whose capability proves a
-                // native event fires before the first prompt (e.g. Claude SessionStart),
-                // a freshly-started host must not be pushed until that provider-ready
-                // fact has been folded. Unsupported adapters (e.g. Codex) have no
-                // pre-input event, so their push proceeds and acceptance is confirmed
-                // only by the later exact provider-accepted fold. The gate reads the
-                // adapter capability and the durable ready projection — never a sleep,
-                // screen scrape, or pane/PID inference — and fails closed for a
-                // supported adapter whose readiness cannot be confirmed.
-                if (ready.prepared.sessionStarted
-                    && builtinAgentDriverRegistry().requireByAdapterId(run.effective.adapterId)
-                        .capabilities.observation.preInputReadiness === "exact"
-                    && !providerReadyForPush(store, {
-                        taskId: task.id,
-                        roleName: role.name,
-                        agentId: run.effective.agentId,
-                        ...(ready.prepared.launchId === undefined ? {} : { launchId: ready.prepared.launchId }),
-                        ...(session?.nativeSessionId === undefined
-                            ? {}
-                            : { nativeSessionId: session.nativeSessionId })
-                    })) {
-                    results.push({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        status: "skipped",
-                        reason: "not-ready"
-                    });
-                    continue;
-                }
-                if (session === null || session.launchId === undefined
-                    || !hasText(session.nativeSessionId)
-                    || store.beginRoleRunProviderTurn?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        agentId: run.effective.agentId,
-                        launchId: session.launchId,
-                        nativeSessionId: session.nativeSessionId,
-                        attemptId: receiptId,
-                        now
-                    }) !== true) {
-                    throw new Error("Provider Turn intent could not be durably fenced before delivery.");
-                }
-                providerSubmissionBegun = true;
-                deliveryAttempted = true;
-                const launchText = run.controlRequest?.state === "dispatching"
-                    ? serializeWorkflowOutcomeRequestEnvelope({
-                        taskId: task.id,
-                        runId: run.id,
-                        roleName: role.name,
-                        request: run.controlRequest
-                    })
-                    : run.providerRetry?.state === "dispatching"
-                        ? serializeProviderRetryEnvelope({
-                            taskId: task.id,
-                            runId: run.id,
-                            roleName: role.name,
-                            retry: run.providerRetry
-                        })
-                        : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
-                const outcome = await delivery.sendOnce({
-                    delivery: ready,
-                    receiptId,
-                    text: prefixYuiTitleInput(launchText, resolveTaskRoleSessionTitle(session.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,
-                        roleName: role.name,
-                        runId: run.id,
-                        status: "skipped",
-                        reason: outcome === "busy" ? "not-ready" : "runtime-unavailable",
-                        terminalFailure: roleRunDeliveryFailure(run, processing.batchId, session, ready.prepared.launchId)
-                    });
-                    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,
-                        roleName: role.name,
-                        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,
-                        ...(ready.prepared.launchId === undefined
-                            ? {}
-                            : { launchId: ready.prepared.launchId }),
-                        now
-                    });
-                    results.push({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        status: "skipped",
-                        reason: "delivery-uncertain"
-                    });
-                    continue;
-                }
-                const status = outcome === "sent" ? "delivered" : "already-delivered";
-                store.saveRoleRunDelivery({
-                    task,
-                    role,
-                    run,
-                    session,
-                    ...(ready.prepared.launchId === undefined
-                        ? {}
-                        : { launchId: ready.prepared.launchId }),
-                    now
-                });
-                results.push({ taskId: task.id, roleName: role.name, runId: run.id, status });
+                throw new Error("Managed Provider launch completed without an initial Turn outcome.");
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                if (providerSubmissionBegun) {
-                    store.resolveRoleRunProviderSubmission?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        attemptId: receiptId,
-                        status: "delivery-unknown",
-                        reason: message,
-                        now
-                    });
-                }
                 // Scheduler single-flight backpressure: the Role runtime lifecycle
                 // lane was busy when the launch was reserved. The Run stays
                 // active-unpushed and its mailbox claim is retained; the next pass
@@ -953,11 +803,6 @@ function validateRoleSession(role, effective, existing, mode, session) {
     if (!compatible) {
         throw new Error(`Ready Role session effective snapshot changed: ${role.taskId}/${role.name}.`);
     }
-    if (existing?.nativeSessionId !== undefined
-        && effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, effective)
-        && session.nativeSessionId !== existing.nativeSessionId) {
-        throw new Error(`Ready Role session changed the fixed native session id: ${role.taskId}/${role.name}.`);
-    }
     if (mode === "resume" && session.nativeSessionId !== existing?.nativeSessionId) {
         throw new Error(`Role resume changed the fixed native session id: ${role.taskId}/${role.name}.`);
     }
@@ -972,13 +817,3 @@ function validateRoleSession(role, effective, existing, mode, session) {
 function hasText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
-/**
- * Fail-closed readiness check for a supported-readiness adapter's first push.
- * When the store cannot answer (no implementation), the push is held rather than
- * proceeding blind — a supported adapter must have a proven provider-ready fold.
- */
-function providerReadyForPush(store, input) {
-    if (store.isRoleGenerationProviderReady === undefined)
-        return false;
-    return store.isRoleGenerationProviderReady(input);
-}

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,13 +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, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.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
@@ -68,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;
@@ -125,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);
@@ -260,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;
             }
@@ -328,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

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";
@@ -50,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;
@@ -437,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;
@@ -475,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,
@@ -507,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))
@@ -563,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 [];
         }
     }
@@ -575,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 [];
         }
     }
@@ -588,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
@@ -608,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
@@ -812,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))