@zq-silk/yui 0.10.0 → 0.11.0

package/dist/repository/taskBaseFreshness.js

@@ -61,11 +61,29 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
     const task = requireTask(store, taskId);
     const git = options.git ?? newGitWorkspace();
     const workspace = store.getTaskWorkspace(taskId);
+    // Collect active Run workspace snapshots once so every Project entry can
+    // report whether a live Run is pinned to a different commit.
+    const activeRuns = store.listAgentRuns(taskId)
+        .filter((run) => run.status === "active" && run.workspace !== undefined);
     const entries = await Promise.all(task.projectBindings.map(async (binding) => {
         const project = requireProject(store, binding.projectId);
         const entry = workspace === null ? undefined : workspaceProjectEntry(workspace, project.id);
         const baseCommit = await resolveBaseCommit(git, project, binding, entry);
         const workspacePath = entry?.path ?? project.path;
+        let physicalHead;
+        try {
+            physicalHead = (await git.inspect(workspacePath)).baseCommit;
+        }
+        catch {
+            physicalHead = undefined;
+        }
+        // Find the first active Run whose workspace snapshot covers this Project.
+        const runSnapshot = activeRuns.find((run) => {
+            if (run.workspace === undefined)
+                return false;
+            const runEntry = workspaceProjectEntry(run.workspace, project.id);
+            return runEntry !== undefined;
+        });
         const provenance = latestBaseProvenance(store.listEvents(taskId), project.id);
         const tracked = await resolveTracked(git, project, workspacePath, options.refresh === true);
         const status = await classifyStatus(git, workspacePath, project, baseCommit, tracked);
@@ -80,6 +98,13 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
             source: tracked?.source ?? (project.remoteUrl === undefined ? "not-applicable" : "compatibility-projection"),
             workspacePath,
             workspaceClean,
+            ...(physicalHead === undefined ? {} : { physicalHead }),
+            ...(runSnapshot?.workspace === undefined
+                ? {}
+                : {
+                    runSnapshotCommit: workspaceProjectEntry(runSnapshot.workspace, project.id)?.baseCommit,
+                    runSnapshotRunId: runSnapshot.id
+                }),
             ...(tracked === undefined ? {} : {
                 trackedRef: tracked.ref,
                 trackedCommit: tracked.commit,
@@ -136,7 +161,7 @@ export function renderTaskBaseFreshnessReport(report) {
         `Task base freshness: ${report.taskId} (source: ${report.refreshed ? "remote refresh" : "local tracking"})`
     ];
     for (const entry of report.entries) {
-        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
+        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  physical HEAD: ${entry.physicalHead ?? "-"}`, `  Run snapshot: ${entry.runSnapshotCommit ?? "-"}${entry.runSnapshotRunId === undefined ? "" : ` (${entry.runSnapshotRunId})`}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
         if (entry.risk !== undefined)
             lines.push(`  risk: ${entry.risk}`);
         if (entry.error !== undefined)

package/dist/repository/taskWorkspacePreparer.js

@@ -1028,7 +1028,7 @@ export class FileTaskWorkspacePreparer {
             : this.store.getReviewRound(taskId, lineage.reviewRoundId)?.executionGroup;
         const lane = group?.lanes.find(({ id }) => id === executionLaneId);
         if (group === undefined
-            || lane === undefined || !["completed", "failed", "yielded"].includes(lane.status)) {
+            || lane === undefined || !["completed", "failed", "yielded", "skipped"].includes(lane.status)) {
             throw new Error(`Execution Lane is not terminally resolved: ${taskId}/${executionLaneId}.`);
         }
         const workspace = this.store.listManagedWorkspaces(taskId).find(({ owner }) => (owner.type === "execution-lane"
@@ -1895,6 +1895,22 @@ export class FileTaskWorkspacePreparer {
     }
     async #rebuildTaskWorkspaceLocked(task, options) {
         if (task.workspaceIdentity !== undefined) {
+            // Quick Win (EXE-08): an identity-bearing Task cannot silently "resume"
+            // when --latest is requested.  The resume branch only cleans legacy
+            // refs and reclaims orphans; it never re-pins the baseline.  Reporting
+            // success here would manufacture a split-brain state where the physical
+            // Task branch moves but the binding, ManagedWorkspace, and Run snapshot
+            // stay on the old commit.  Refuse explicitly and point at the correct
+            // tools instead.
+            if (options.latestRemote === true) {
+                throw new Error(`Task ${task.id} already owns a workspace identity; `
+                    + "`task rebuild --latest` cannot re-pin its baseline in place. "
+                    + "Use `yui task base status " + task.id + "` to inspect the current "
+                    + "binding, ManagedWorkspace, physical HEAD, and Run snapshot. "
+                    + "For an Active Task, integrate upstream changes through the "
+                    + "normal Leader-driven integration path; for a Draft Task with no "
+                    + "execution evidence, recreate the Task workspace.");
+            }
             const current = this.store.getTaskWorkspace(task.id);
             if (current !== null && current.owner.type === "task") {
                 await ensureWorkspaceView(current.root, current.entries);

package/dist/review/reviewRound.js

@@ -138,7 +138,7 @@ export function finishReviewRound(round, status, summary, now, result = {}) {
  * returns to pending so infrastructure retries do not manufacture a new
  * semantic ReviewRound or duplicate findings.
  */
-export function retryTaskReviewRound(round) {
+export function retryTaskReviewRound(round, executionLaneId) {
     validateReviewRound(round);
     if ((round.scope ?? "work-item") !== "task") {
         throw new Error(`Only a Task-final ReviewRound can be retried in place: ${round.id}.`);
@@ -148,7 +148,7 @@ export function retryTaskReviewRound(round) {
     }
     const retryExecutionGroup = round.executionGroup === undefined
         ? undefined
-        : retryReviewExecutionGroup(round);
+        : retryReviewExecutionGroup(round, executionLaneId);
     return validateReviewRound({
         schemaVersion: round.schemaVersion,
         id: round.id,
@@ -186,11 +186,32 @@ export function retryTaskReviewRound(round) {
         createdAt: round.createdAt
     });
 }
-function retryReviewExecutionGroup(round) {
+/** Keep a running panel Round active while retrying only its exact failed Lane. */
+export function retryRunningReviewExecutionLane(round, executionLaneId, runId, now) {
+    validateReviewRound(round);
+    if (round.status !== "running" || round.executionGroup === undefined) {
+        throw new Error(`ReviewRound ${round.id} has no running ExecutionGroup.`);
+    }
+    const lane = round.executionGroup.lanes.find(({ id }) => id === executionLaneId);
+    if (lane === undefined || lane.status !== "failed" || lane.runId !== runId) {
+        throw new Error(`Review retry does not target the current failed Lane attempt: `
+            + `${round.executionGroup.id}/${executionLaneId}/${runId}.`);
+    }
+    return updateReviewExecutionGroup(round, retryReviewExecutionGroup(round, executionLaneId, now));
+}
+function retryReviewExecutionGroup(round, executionLaneId, retryAt) {
     const previous = round.executionGroup;
-    const attemptTime = Date.parse(round.endedAt ?? round.createdAt);
-    const now = new Date(attemptTime);
-    const lanes = previous.lanes.map((lane) => (resetReviewExecutionLane(previous, lane.id, now)));
+    if (executionLaneId !== undefined) {
+        const exactLane = previous.lanes.find(({ id }) => id === executionLaneId);
+        if (exactLane === undefined || exactLane.status !== "failed") {
+            throw new Error(`Review retry Lane is not failed: ${previous.id}/${executionLaneId}.`);
+        }
+    }
+    const now = retryAt ?? new Date(Date.parse(round.endedAt ?? round.createdAt));
+    const lanes = previous.lanes.map((lane) => (lane.status === "failed"
+        && (executionLaneId === undefined || lane.id === executionLaneId)
+        ? resetReviewExecutionLane(previous, lane.id, now)
+        : lane));
     return validateExecutionGroup({
         ...previous,
         lanes,

package/dist/run/agentRun.js

@@ -175,8 +175,8 @@ export function validateAgentRun(run) {
         }
     }
     if (run.purpose === "review") {
-        if (run.workItemId === undefined || run.reviewRoundId === undefined) {
-            throw new Error("A review Agent run requires WorkItem and ReviewRound references.");
+        if (run.reviewRoundId === undefined) {
+            throw new Error("A review Agent run requires a ReviewRound reference.");
         }
         if (run.workspace === undefined
             || !((run.workspace.owner.type === "review-round"

package/dist/run/recoveryProjection.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
+import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
 export const RUN_RECOVERY_ACTIONS = [
     "diagnose",
     "retry",
@@ -25,6 +26,20 @@ export function readRunRecoveryFacts(store, taskId, runId) {
         latestProviderObservation: latestRunProviderObservation(store.listEvents(taskId), runId)
     };
 }
+/**
+ * Resolve the exact live-Run recovery plans referenced by Lane health. Failed
+ * terminal Lanes use `task run retry` directly and therefore need no live-Run
+ * recovery projection here.
+ */
+export function projectExecutionLaneRunRecoveries(store, taskId, groups) {
+    const runIds = new Set(actionableExecutionLaneRecoveries(groups).flatMap((lane) => (lane.runId === undefined || lane.recovery === "retry-new-agent-run"
+        ? []
+        : [lane.runId])));
+    return [...runIds].flatMap((runId) => {
+        const facts = readRunRecoveryFacts(store, taskId, runId);
+        return facts === null ? [] : [projectRunRecovery(facts)];
+    });
+}
 /**
  * Latest Provider observation for a Run. Provider timestamps are evidence:
  * they explain why a stale fence was supplied but never authorize recovery.

package/dist/runtime/runtimeContinuationProjection.js

@@ -32,3 +32,10 @@ export function projectProviderContinuations(events) {
 export function blockingProviderContinuations(events) {
     return projectProviderContinuations(events).filter((entry) => (continuationOwnsWriterUmbrella(entry) || entry.identityConflict));
 }
+/** Exact Run-scoped writer fence shared by terminalization and retry paths. */
+export function runOwnsBlockingProviderContinuation(events, owner) {
+    return blockingProviderContinuations(events).some((continuation) => (continuation.taskId === owner.taskId
+        && continuation.roleName === owner.roleName
+        && continuation.runId === owner.runId
+        && continuation.identity.accountScope === owner.agentId));
+}

package/dist/runtime/tmuxAdapters.js

@@ -281,11 +281,14 @@ export class TmuxSessionHost {
             return binding;
         }
         const broker = launchBrokerForHome(yuiHome);
+        const sessionManifest = planned.launch.env.YUI_SESSION_MANIFEST;
         const frozenControlPlane = planned.launch.env[YUI_CONTROL_PLANE_DESCRIPTOR];
         const frozenTaskRuntime = planned.launch.env[YUI_TASK_RUNTIME_DESCRIPTOR];
         if (request.owner.scope === "task" && request.runId !== undefined
-            && (frozenControlPlane === undefined || frozenTaskRuntime === undefined)) {
-            throw new Error("Managed Task Agent Host launch is missing its frozen control descriptors.");
+            && (sessionManifest === undefined
+                || frozenControlPlane === undefined
+                || frozenTaskRuntime === undefined)) {
+            throw new Error("Managed Task Agent Host launch is missing its Session Manifest or frozen control descriptors.");
         }
         const reservation = broker.reserve(Object.freeze({
             schemaVersion: 1,
@@ -324,6 +327,9 @@ export class TmuxSessionHost {
                 ...(planned.launch.env.YUI_WORKSPACE === undefined
                     ? {}
                     : { YUI_WORKSPACE: planned.launch.env.YUI_WORKSPACE }),
+                ...(sessionManifest === undefined
+                    ? {}
+                    : { YUI_SESSION_MANIFEST: sessionManifest }),
                 ...(frozenControlPlane === undefined
                     ? {}
                     : { [YUI_CONTROL_PLANE_DESCRIPTOR]: frozenControlPlane }),

package/dist/scheduler/actionability.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
+import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { isDurableJobTerminal } from "../job/durableJob.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+import { executionStageSpendClosed, observedExecutionResourceUsage, projectExecutionStageResources } from "../execution/resourceBroker.js";
 /**
  * Canonical SHA-256 digest over the normalized actionable facts. Pure and
  * deterministic: the same facts always produce the same digest regardless of
@@ -19,6 +21,92 @@ export function computeActionabilityDigest(input) {
 }
 const TERMINAL_WORK_ITEM_STATUSES = new Set(["completed", "retired"]);
 const CONSUMED_INTEGRATION_STATUSES = new Set(["committed", "superseded"]);
+/** Exact durable Broker queue shared by admission and wake actionability. */
+export function projectQueuedResourceLaneIdentities(store, now) {
+    return store.listActiveTaskIds().flatMap((taskId) => {
+        const taskRuns = store.listAgentRuns(taskId);
+        const taskEvents = store.listEvents(taskId);
+        const workItemLanes = store.listWorkItems(taskId).flatMap((item) => {
+            if (item.status !== "running")
+                return [];
+            const group = currentWorkItemExecutionGroup(item);
+            if (group === undefined || group.resolution !== undefined)
+                return [];
+            if (group.stage !== undefined) {
+                const resources = projectExecutionStageResources({
+                    group,
+                    stageGroups: item.executionGroups,
+                    usage: observedExecutionResourceUsage({
+                        group,
+                        stageGroups: item.executionGroups,
+                        runs: taskRuns,
+                        events: taskEvents
+                    }),
+                    now
+                });
+                if (executionStageSpendClosed(resources))
+                    return [];
+            }
+            return group.lanes.flatMap((lane) => {
+                if (lane.status !== "pending"
+                    || lane.effective === undefined
+                    || lane.runId !== undefined)
+                    return [];
+                return [{
+                        taskId,
+                        workItemId: item.id,
+                        executionGroupId: group.id,
+                        executionLaneId: lane.id,
+                        providerId: lane.effective.adapterId,
+                        agentId: lane.effective.agentId,
+                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
+                        requestedAt: lane.updatedAt
+                    }];
+            });
+        });
+        const reviewLanes = store.listReviewRounds(taskId).flatMap((round) => {
+            if (round.status !== "pending" && round.status !== "running")
+                return [];
+            const group = round.executionGroup;
+            if (group === undefined || group.resolution !== undefined)
+                return [];
+            return group.lanes.flatMap((lane) => {
+                if (lane.status !== "pending"
+                    || lane.effective === undefined
+                    || lane.runId !== undefined)
+                    return [];
+                return [{
+                        taskId,
+                        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+                        executionGroupId: group.id,
+                        executionLaneId: lane.id,
+                        providerId: lane.effective.adapterId,
+                        agentId: lane.effective.agentId,
+                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
+                        requestedAt: lane.updatedAt
+                    }];
+            });
+        });
+        return [...workItemLanes, ...reviewLanes];
+    });
+}
+/**
+ * True only when the Task still owns a Resource-Broker-queued Lane that a
+ * later Leader dispatch may start. Terminal owners retain their immutable
+ * Group history, but can never reserve live queue capacity.
+ */
+export function hasDispatchableQueuedResourceLane(store, taskId) {
+    const workItemGroups = (store.listWorkItems?.(taskId) ?? [])
+        .filter(({ status }) => status === "running")
+        .flatMap(({ executionGroups }) => executionGroups);
+    const reviewGroups = (store.listReviewRounds?.(taskId) ?? [])
+        .filter(({ status }) => status === "pending" || status === "running")
+        .flatMap(({ executionGroup }) => executionGroup === undefined ? [] : [executionGroup]);
+    return [...workItemGroups, ...reviewGroups].some((group) => (group.resolution === undefined
+        && group.lanes.some((lane) => (lane.status === "pending"
+            && lane.effective !== undefined
+            && lane.runId === undefined))));
+}
 /**
  * Fold a Task's durable records into the normalized actionable facts. This
  * function only reads; it never starts a Controller, queues a wake, writes a
@@ -41,7 +129,7 @@ const CONSUMED_INTEGRATION_STATUSES = new Set(["committed", "superseded"]);
  * an unchanged blocker, read-only status requests, and waits already owned by
  * an active Worker/Reviewer/Job (the active-Run facts above capture ownership).
  */
-export function collectTaskActionability(store, taskId) {
+export function collectTaskActionability(store, taskId, now = new Date()) {
     const task = store.getTask(taskId);
     if (task === null) {
         throw new Error(`Task not found for actionability projection: ${taskId}.`);
@@ -59,15 +147,93 @@ export function collectTaskActionability(store, taskId) {
             ].join("|")
         });
     }
-    for (const item of store.listWorkItems?.(taskId) ?? []) {
+    const workItems = store.listWorkItems?.(taskId) ?? [];
+    const reviewRounds = store.listReviewRounds?.(taskId) ?? [];
+    for (const item of workItems) {
         if (TERMINAL_WORK_ITEM_STATUSES.has(item.status))
             continue;
         facts.push({
             key: `work-item:${item.id}`,
             value: `${item.status}|${item.updatedAt}`
         });
+        for (const group of item.executionGroups) {
+            if (group.resolution !== undefined || group.stage?.resources === undefined)
+                continue;
+            facts.push({
+                key: `resource-deadline:${group.id}`,
+                value: now.getTime() >= Date.parse(group.stage.resources.deadlineAt)
+                    ? "reached"
+                    : "open"
+            });
+        }
+    }
+    // A Resource-Broker-queued Lane is durable but deliberately has no active
+    // Run. Include the global capacity and fair-queue projection only for Tasks
+    // that are actually queued, so either capacity or an older reservation being
+    // released changes their digest without polling or a second scheduler.
+    const queueProjectionAvailable = store.listActiveTaskIds !== undefined
+        && store.listWorkItems !== undefined
+        && store.listReviewRounds !== undefined
+        && store.listEvents !== undefined;
+    const queuedResourceLanes = queueProjectionAvailable
+        ? projectQueuedResourceLaneIdentities({
+            listActiveTaskIds: () => store.listActiveTaskIds(),
+            listAgentRuns: (candidateTaskId) => store.listAgentRuns(candidateTaskId),
+            listWorkItems: (candidateTaskId) => store.listWorkItems(candidateTaskId),
+            listReviewRounds: (candidateTaskId) => store.listReviewRounds(candidateTaskId),
+            listEvents: (candidateTaskId) => store.listEvents(candidateTaskId)
+        }, now)
+        : [];
+    const hasQueuedResourceLane = queueProjectionAvailable
+        ? queuedResourceLanes.some((lane) => lane.taskId === taskId)
+        : hasDispatchableQueuedResourceLane(store, taskId);
+    if (hasQueuedResourceLane && store.listActiveTaskIds !== undefined) {
+        const activeResourceScopes = store.listActiveTaskIds().flatMap((activeTaskId) => (operationalTaskRecords(store.listAgentRuns(activeTaskId), store.listEvents?.(activeTaskId) ?? [], "agent-run").flatMap((run) => (run.status !== "active"
+            || run.executionGroupId === undefined
+            || run.executionLaneId === undefined
+            ? []
+            : [
+                "home",
+                `task:${activeTaskId}`,
+                ...(run.workItemId === undefined
+                    ? []
+                    : [`work-item:${activeTaskId}/${run.workItemId}`]),
+                `group:${activeTaskId}/${run.executionGroupId}`,
+                `provider:${run.effective.adapterId}`,
+                `agent:${run.effective.agentId}`,
+                `model:${run.effective.adapterId}/${run.effective.model ?? "default"}`
+            ]))));
+        const activeResourceCounts = new Map();
+        for (const scope of activeResourceScopes) {
+            activeResourceCounts.set(scope, (activeResourceCounts.get(scope) ?? 0) + 1);
+        }
+        facts.push({
+            key: "resource-broker:active-capacity",
+            value: [...activeResourceCounts]
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([scope, count]) => `${scope}=${count}`)
+                .join("|")
+        });
+        if (queueProjectionAvailable) {
+            facts.push({
+                key: "resource-broker:fair-queue",
+                value: queuedResourceLanes
+                    .map((lane) => [
+                    lane.requestedAt,
+                    lane.taskId,
+                    lane.workItemId ?? "",
+                    lane.executionGroupId,
+                    lane.executionLaneId,
+                    lane.providerId,
+                    lane.agentId,
+                    lane.model ?? "default"
+                ].join("|"))
+                    .sort()
+                    .join("\n")
+            });
+        }
     }
-    for (const round of store.listReviewRounds?.(taskId) ?? []) {
+    for (const round of reviewRounds) {
         if (round.status === "completed")
             continue;
         facts.push({

package/dist/scheduler/activeTaskProgress.js

@@ -2,7 +2,7 @@ import { selectedActiveSchedulerTasks, isSchedulerTaskWorkspaceReady } from "./p
 import { queueLeaderWakeup } from "./wakeupQueue.js";
 import { wakeReason } from "./wakeReason.js";
 import { projectTaskExecution } from "./taskExecutionProjection.js";
-import { collectTaskActionability, computeActionabilityDigest, decideOrphanWake } from "./actionability.js";
+import { collectTaskActionability, computeActionabilityDigest, decideOrphanWake, hasDispatchableQueuedResourceLane } from "./actionability.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 /**
  * Repairs an active Task that has no durable owner capable of advancing it.
@@ -26,6 +26,7 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             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({
@@ -37,19 +38,23 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             leaderFailure: store.getLeaderFailure(task.id),
             operatorNotification: store.getOperatorNotification(task.id)
         });
-        if (hasInFlightTurn
+        const queuedAlongsideActiveSibling = hasDispatchableQueuedResourceLane(store, task.id)
+            && !activeRuns.some(({ roleName }) => roleName === "leader")
+            && activeRuns.some(({ roleName }) => roleName !== "leader")
+            && projection.status === "waiting-on-agents";
+        if ((queuedAlongsideActiveSibling ? hasLeaderInFlightTurn : hasInFlightTurn)
             || store.hasOpenInputRequest(task.id)
             || store.getLeaderFailure(task.id) !== null
             || store.getOperatorNotification(task.id) !== null
-            || projection.status !== "needs-leader-action"
+            || (projection.status !== "needs-leader-action" && !queuedAlongsideActiveSibling)
             || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {
             continue;
         }
-        // Issue 05: digest-based admission. Only the "no-executor" orphan path
-        // reaches here; every other needs-leader-action state already has a
-        // durable owner (candidate, integration, or pending wake) and is exempt.
-        if (projection.reason === "no-executor") {
-            if (admitOrphanWake(store, task.id) === "suppress")
+        // Digest admission covers both an ownerless Task and a resource-queued
+        // Task with active siblings. The latter wakes only when capacity/deadline
+        // actionability changes, so repeated full scans remain silent.
+        if (projection.reason === "no-executor" || queuedAlongsideActiveSibling) {
+            if (admitOrphanWake(store, task.id, now) === "suppress")
                 continue;
         }
         const taskWorkspace = store.getTaskWorkspace(task.id);
@@ -76,10 +81,10 @@ export function repairOrphanedActiveTasks(store, now, selection) {
  * `"suppress"` without writing anything when the digest is unchanged since
  * the last waiting/blocked Leader Run. Computation errors fail open.
  */
-function admitOrphanWake(store, taskId) {
+function admitOrphanWake(store, taskId, now) {
     let digest;
     try {
-        const input = collectTaskActionability(store, taskId);
+        const input = collectTaskActionability(store, taskId, now);
         digest = computeActionabilityDigest(input);
     }
     catch (error) {

package/dist/scheduler/leaderWakeupProcessor.js

@@ -126,7 +126,23 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const resumableSession = hasNativeSession(existingSession)
                 && existingSession.status !== "stopped"
                 && existingSession.status !== "broken";
-            const mode = resumableSession && compatibleSession ? "resume" : "new";
+            // 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";
             const runId = store.peekNextAgentRunId(task.id);
             const wakeEnvelope = resolveLeaderWakeEnvelope(store, task.id);
             const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);