@zq-silk/yui 0.15.7 → 0.15.9

package/dist/scheduler/taskExecutionProjection.js

@@ -1,9 +1,11 @@
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
 import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from "../execution/executionHealth.js";
 import { buildTaskObservabilityProjection } from "./taskObservabilityProjection.js";
-import { isRoleTurnStalled, latestStallProgressAt } from "./roleTurnStall.js";
+import { isRoleRunStalled, latestStallProgressAt } from "./roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
 /**
@@ -17,7 +19,7 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         return null;
     const roles = store.listRoles?.(taskId) ?? [];
     const events = store.listEvents?.(taskId) ?? [];
-    const turns = operationalTaskRecords(store.listTurns?.(taskId) ?? [], events, "turn");
+    const runs = operationalTaskRecords(store.listRuns?.(taskId) ?? [], events, "run");
     const leaderMailbox = store.getWorkMailbox?.({
         kind: "role",
         taskId,
@@ -32,10 +34,14 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
     return projectTaskExecution({
         task,
         roles,
-        turns,
+        runs,
+        runDelivery: Object.fromEntries(runs.map((run) => {
+            const observed = store.getTaskRoleSessionSet?.(taskId, run.roleName)?.providerBinding?.run;
+            return [run.id, observed?.runId === run.id ? observed.status : "unobserved"];
+        })),
         executionGroups: store.listWorkItems === undefined && store.listReviewRounds === undefined
             ? []
-            : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? [], turns),
+            : collectExecutionGroups(store.listWorkItems?.(taskId) ?? [], store.listReviewRounds?.(taskId) ?? [], runs),
         workItems: store.listWorkItems?.(taskId) ?? [],
         ...(store.listContextSnapshots === undefined
             ? {}
@@ -67,22 +73,22 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
  * unchanged revision.
  */
 export function projectTaskExecutionFromFacts(facts) {
-    const turns = operationalTaskRecords(facts.turns, facts.events ?? [], "turn");
+    const runs = operationalTaskRecords(facts.runs, facts.events ?? [], "run");
     const executionGroups = facts.executionGroups
-        ?? collectExecutionGroups(facts.workItems ?? [], facts.reviewRounds ?? [], turns);
+        ?? collectExecutionGroups(facts.workItems ?? [], facts.reviewRounds ?? [], runs);
     return projectTaskExecution({
         ...facts,
-        turns,
+        runs,
         executionGroups
     });
 }
 export function projectTaskExecution(facts) {
-    const { task, roles, turns, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, roleSessions = [], executionGroups = [] } = facts;
+    const { task, roles, runs, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, roleSessions = [], executionGroups = [] } = facts;
     const now = facts.now ?? new Date();
     const groupSummaries = executionGroups.map((group) => {
         return summarizeExecutionGroupHealth({
             group,
-            turns,
+            runs,
             sessions: roleSessions,
             events,
             now,
@@ -103,7 +109,7 @@ export function projectTaskExecution(facts) {
     const observability = buildTaskObservabilityProjection({
         workItems,
         executionGroups: observabilityGroups,
-        turns,
+        runs,
         events,
         contextSnapshots: facts.contextSnapshots,
         sessionTokens,
@@ -115,24 +121,34 @@ export function projectTaskExecution(facts) {
         executionGroups: groupSummaries,
         observability
     });
-    const activeTurns = turns.filter((turn) => turn.status === "active");
-    const turnHasSession = (turn) => roleSessions.some((session) => (session.roleName === turn.roleName
-        && session.agentId === turn.effective.agentId
+    const activeRuns = runs.filter((run) => run.status === "active");
+    const deliveryOf = (run) => {
+        const known = facts.runDelivery?.[run.id];
+        if (known !== undefined && known !== "unobserved")
+            return known;
+        const observed = events.map(runtimeObservationFromTaskEvent).filter((event) => event?.fence.runId === run.id && event.authority !== "transport"
+            && ["turn.accepted", "turn.completed", "turn.failed", "turn.cancelled"].includes(event.kind)).at(-1);
+        return observed === undefined || observed === null ? "unobserved"
+            : observed.kind.slice("run.".length);
+    };
+    const runHasSession = (run) => roleSessions.some((session) => (session.roleName === run.roleName
+        && session.agentId === run.effective.agentId
         && session.status !== "ended"));
-    const activeTurnViews = activeTurns.map((turn) => ({
-        id: turn.id,
-        roleName: turn.roleName,
-        purpose: turn.purpose,
-        providerSession: turnHasSession(turn) ? "active" : "starting",
-        status: turn.status,
-        ...(turn.workItemId === undefined ? {} : { workItemId: turn.workItemId }),
-        ...(turn.reviewRoundId === undefined ? {} : { reviewRoundId: turn.reviewRoundId }),
-        ...(turn.executionGroupId === undefined ? {} : { executionGroupId: turn.executionGroupId }),
-        ...(turn.executionLaneId === undefined ? {} : { executionLaneId: turn.executionLaneId })
+    const activeRunViews = activeRuns.map((run) => ({
+        id: run.id,
+        roleName: run.roleName,
+        purpose: run.purpose,
+        providerSession: runHasSession(run) ? "active" : "starting",
+        status: run.status,
+        delivery: deliveryOf(run),
+        ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
+        ...(run.reviewRoundId === undefined ? {} : { reviewRoundId: run.reviewRoundId }),
+        ...(run.executionGroupId === undefined ? {} : { executionGroupId: run.executionGroupId }),
+        ...(run.executionLaneId === undefined ? {} : { executionLaneId: run.executionLaneId })
     }));
     const monitoring = task.executionGate.state === "stopped"
         || task.status === "completed"
-        || task.status === "retired"
+        || task.status === "cancelled"
         || task.status === "archived"
         ? "stopped"
         : "active";
@@ -147,7 +163,7 @@ export function projectTaskExecution(facts) {
                 reason: "execution-stopped",
                 monitoring,
                 failClosed: false,
-                activeTurns: activeTurnViews,
+                activeRuns: activeRunViews,
                 attention: [],
                 blockers: [],
                 pendingWakeup
@@ -163,7 +179,7 @@ export function projectTaskExecution(facts) {
             reason: "task-terminal",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention: [],
             blockers: [],
             pendingWakeup
@@ -172,7 +188,7 @@ export function projectTaskExecution(facts) {
     const attention = collectAttention({
         task,
         roles,
-        activeTurns,
+        activeRuns,
         events,
         leaderFailure,
         roleSessions,
@@ -180,18 +196,19 @@ export function projectTaskExecution(facts) {
     });
     const openInputs = inputRequests.filter((request) => request.status === "open");
     const blockers = collectBlockers(workItems, reviewRounds, integrations, openInputs, task);
-    const activeExecutionTurns = activeTurns.filter((turn) => turn.purpose === "execution");
-    const activeReviewTurns = activeTurns.filter((turn) => turn.purpose === "review");
-    const activeDelegatedExecutions = activeExecutionTurns.filter((turn) => (turn.roleName !== "leader"));
-    const healthyActiveTurns = activeTurns.filter((turn) => (turnHasSession(turn)
-        && !attention.some((item) => item.turnId === turn.id)));
-    const activeLeader = activeTurns.find((turn) => turn.roleName === "leader");
-    const pendingDeliveryTurns = activeTurns.filter((turn) => !turnHasSession(turn));
+    const activeExecutionRuns = activeRuns.filter((run) => run.purpose === "execution");
+    const activeReviewRuns = activeRuns.filter((run) => run.purpose === "review");
+    const activeDelegatedExecutions = activeExecutionRuns.filter((run) => (run.roleName !== "leader"));
+    const healthyActiveRuns = activeRuns.filter((run) => (deliveryOf(run) === "accepted"
+        && !attention.some((item) => item.runId === run.id)));
+    const activeLeader = activeRuns.find((run) => run.roleName === "leader");
+    const pendingDeliveryRuns = activeRuns.filter((run) => deliveryOf(run) !== "accepted");
     const hasPendingLeaderWork = pendingWakeup !== null
         || leaderMailbox?.pending !== null;
     const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure);
-    const failedWork = workItems.some((item) => item.status === "failed");
-    const candidateReady = workItems.some((item) => item.status === "awaiting_acceptance");
+    const failedWork = workItems.some((item) => item.status === "open"
+        && runs.filter((run) => run.workItemId === item.id).at(-1)?.status === "failed");
+    const candidateReady = workItems.some((item) => (item.status === "open" && item.currentCandidateId !== undefined));
     const blockedIntegration = integrations.some((attempt) => attempt.status === "blocked");
     const unresolvedIntegration = integrations.some((attempt) => (attempt.status === "running"
         || attempt.status === "validating"
@@ -202,19 +219,19 @@ export function projectTaskExecution(facts) {
         if (first === undefined)
             throw new Error("Task execution attention disappeared.");
         const progressingWithAttention = first.kind === "checkpoint-overdue"
-            && healthyActiveTurns.length > 0;
+            && healthyActiveRuns.length > 0;
         return render({
             task,
             status: progressingWithAttention ? "progressing-with-attention" : "attention",
             owner: first.owner,
             action: "inspect-attention",
             summary: progressingWithAttention
-                ? `${healthyActiveTurns.length} healthy active Turn(s) remain while ${first.summary}`
+                ? `${healthyActiveRuns.length} healthy active AgentRun(s) remain while ${first.summary}`
                 : first.summary,
             reason: progressingWithAttention ? "progressing-with-attention" : first.kind,
             monitoring,
             failClosed: hasLeaderMismatch || attention.some((item) => item.failClosed === true),
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -233,7 +250,7 @@ export function projectTaskExecution(facts) {
             reason: "open-input-request",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -249,11 +266,11 @@ export function projectTaskExecution(facts) {
             action: "recover-execution",
             summary: `Execution Lane ${laneRecovery.laneId} in ${laneRecovery.groupId}`
                 + ` requires ${laneRecovery.recovery}`
-                + (laneRecovery.turnId === undefined ? "." : ` for exact Turn ${laneRecovery.turnId}.`),
+                + (laneRecovery.runId === undefined ? "." : ` for exact AgentRun ${laneRecovery.runId}.`),
             reason: `execution-lane-${laneRecovery.recovery}`,
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -272,7 +289,7 @@ export function projectTaskExecution(facts) {
             reason: blockedIntegration ? "integration-blocked" : failedWork ? "work-failed" : "identity-mismatch",
             monitoring,
             failClosed: hasLeaderMismatch,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -289,24 +306,24 @@ export function projectTaskExecution(facts) {
             reason: leaderFailure === null ? "recovery-pending" : "leader-recovery-failed",
             monitoring,
             failClosed: leaderFailure !== null,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    const leaderDeliveryPending = pendingDeliveryTurns.some((turn) => turn.roleName === "leader");
+    const leaderDeliveryPending = pendingDeliveryRuns.some((run) => run.roleName === "leader");
     if (leaderDeliveryPending) {
         return render({
             task,
-            status: "recovering",
+            status: "waiting-on-agents",
             owner: "leader",
             action: "recover-leader",
-            summary: "The active Leader Turn is awaiting provider acceptance; delivery remains fail-closed.",
+            summary: `Leader execution record is open; admission is ${activeLeader === undefined ? "unobserved" : deliveryOf(activeLeader)}. This is not proof of Agent progress.`,
             reason: "delivery-pending",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -314,14 +331,14 @@ export function projectTaskExecution(facts) {
     }
     if (activeLeader !== undefined) {
         const concurrentExecutionCount = activeDelegatedExecutions.length;
-        const concurrentReviewCount = activeReviewTurns.length;
+        const concurrentReviewCount = activeReviewRuns.length;
         const concurrentSummary = [
             concurrentExecutionCount === 0
                 ? null
-                : `${concurrentExecutionCount} delegated execution Turn(s)`,
+                : `${concurrentExecutionCount} delegated execution AgentRun(s)`,
             concurrentReviewCount === 0
                 ? null
-                : `${concurrentReviewCount} Review Turn(s)`
+                : `${concurrentReviewCount} Review AgentRun(s)`
         ].filter((value) => value !== null).join(" and ");
         return render({
             task,
@@ -329,12 +346,12 @@ export function projectTaskExecution(facts) {
             owner: "leader",
             action: "advance-task",
             summary: concurrentSummary.length === 0
-                ? "Leader Turn is actively advancing the Task."
-                : `Leader Turn is actively advancing the Task alongside ${concurrentSummary}.`,
+                ? "Leader execution was accepted; its result and Task progress remain separate facts."
+                : `Leader execution was accepted alongside ${concurrentSummary}; Task progress remains a separate fact.`,
             reason: concurrentSummary.length === 0 ? "leader-turn-active" : "leader-and-agents-active",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -346,62 +363,62 @@ export function projectTaskExecution(facts) {
             status: "needs-leader-action",
             owner: "leader",
             action: "advance-task",
-            summary: "A durable Leader wake is pending; concurrent Turns remain visible but do not suppress it.",
+            summary: "A durable Leader wake is pending; concurrent AgentRuns remain visible but do not suppress it.",
             reason: "leader-wake-pending",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (pendingDeliveryTurns.length > 0) {
+    if (pendingDeliveryRuns.length > 0) {
         return render({
             task,
             status: "recovering",
             owner: "leader",
             action: "recover-execution",
-            summary: `${pendingDeliveryTurns.length} active delegated Turn(s) are awaiting provider acceptance; delivery remains fail-closed.`,
+            summary: `${pendingDeliveryRuns.length} active delegated AgentRun(s) are awaiting provider acceptance; delivery remains fail-closed.`,
             reason: "delivery-pending",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
     if (activeDelegatedExecutions.length > 0) {
-        const reviewSuffix = activeReviewTurns.length === 0
+        const reviewSuffix = activeReviewRuns.length === 0
             ? ""
-            : `; ${activeReviewTurns.length} Review Turn(s) are also active`;
+            : `; ${activeReviewRuns.length} Review AgentRun(s) are also active`;
         return render({
             task,
             status: "waiting-on-agents",
             owner: roleOwner(activeDelegatedExecutions[0].roleName),
             action: "wait-for-agents",
-            summary: `${activeDelegatedExecutions.length} delegated execution Turn(s) are active${reviewSuffix}.`,
+            summary: `${activeDelegatedExecutions.length} delegated execution AgentRun(s) are active${reviewSuffix}.`,
             reason: "delegated-work-active",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (activeReviewTurns.length > 0) {
+    if (activeReviewRuns.length > 0) {
         return render({
             task,
             status: "waiting-on-agents",
             owner: "reviewer",
             action: "wait-for-agents",
-            summary: `${activeReviewTurns.length} Review Turn(s) are evaluating frozen candidates; newer facts can still wake the Leader.`,
+            summary: `${activeReviewRuns.length} Review AgentRun(s) are evaluating frozen candidates; newer facts can still wake the Leader.`,
             reason: "review-active",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -421,7 +438,7 @@ export function projectTaskExecution(facts) {
                 : "integration-pending",
             monitoring,
             failClosed: false,
-            activeTurns: activeTurnViews,
+            activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
@@ -436,7 +453,7 @@ export function projectTaskExecution(facts) {
         reason: "no-executor",
         monitoring,
         failClosed: false,
-        activeTurns: activeTurnViews,
+        activeRuns: activeRunViews,
         attention,
         blockers,
         pendingWakeup
@@ -453,7 +470,7 @@ function projection(input) {
         reason: input.reason,
         monitoring: input.monitoring,
         failClosed: input.failClosed,
-        activeTurns: input.activeTurns,
+        activeRuns: input.activeRuns,
         executionGroups: input.executionGroups ?? [],
         observability: input.observability,
         attention: input.attention,
@@ -494,7 +511,7 @@ function collectExecutionGroups(workItems, reviewRounds, _turns) {
 }
 function collectAttention(input) {
     const result = [];
-    const { task, activeTurns, events, leaderFailure } = input;
+    const { task, activeRuns, events, leaderFailure } = input;
     if (leaderFailure !== null) {
         result.push({
             kind: "leader-recovery",
@@ -504,82 +521,57 @@ function collectAttention(input) {
             failClosed: true
         });
     }
-    for (const turn of activeTurns) {
-        const role = input.roles.find((candidate) => candidate.name === turn.roleName);
-        const session = input.roleSessions.find((candidate) => candidate.roleName === turn.roleName);
-        if (role !== undefined
-            && ((role.activeAgentId !== undefined && role.activeAgentId !== turn.effective?.agentId)
-                || (role.adapterId !== undefined && role.adapterId !== turn.effective?.adapterId))) {
-            result.push({
-                kind: "identity-mismatch",
-                id: `identity:${turn.id}`,
-                owner: "leader",
-                summary: `Turn ${turn.id} does not match the current ${turn.roleName} Agent/adapter fence.`,
-                turnId: turn.id,
-                roleName: turn.roleName,
-                failClosed: true
-            });
-        }
+    for (const run of activeRuns) {
+        const session = input.roleSessions.find((candidate) => candidate.roleName === run.roleName);
+        // Current Role selection is desired configuration, not the identity fence
+        // of a AgentRun already assigned. Only actual execution evidence can mismatch.
         if (session !== undefined
-            && (session.agentId !== turn.effective?.agentId || session.adapterId !== turn.effective?.adapterId)) {
+            && (session.agentId !== run.effective?.agentId || session.adapterId !== run.effective?.adapterId)) {
             result.push({
                 kind: "identity-mismatch",
-                id: `session:${turn.id}`,
+                id: `session:${run.id}`,
                 owner: "leader",
-                summary: `Turn ${turn.id} has a provider/session identity mismatch; monitoring fails closed.`,
-                turnId: turn.id,
-                roleName: turn.roleName,
+                summary: `AgentRun ${run.id} has a provider/session identity mismatch; monitoring fails closed.`,
+                runId: run.id,
+                roleName: run.roleName,
                 failClosed: true
             });
         }
-        if (isRoleTurnStalled(events, turn.id)) {
-            if (turn.roleName === "leader") {
-                const progressAt = latestStallProgressAt(events, turn.id) ?? "unknown";
+        if (isRoleRunStalled(events, run.id)) {
+            if (run.roleName === "leader") {
+                const progressAt = latestStallProgressAt(events, run.id) ?? "unknown";
                 result.push({
                     kind: "leader-stalled",
-                    id: `leader-stall:${turn.id}:${progressAt}`,
+                    id: `leader-stall:${run.id}:${progressAt}`,
                     owner: "operator",
-                    summary: `Leader Turn ${turn.id} has an unresolved no-progress attention.`,
-                    turnId: turn.id,
-                    roleName: turn.roleName
+                    summary: `Leader AgentRun ${run.id} has an unresolved no-progress attention.`,
+                    runId: run.id,
+                    roleName: run.roleName
                 });
             }
             else {
                 result.push({
                     kind: "checkpoint-overdue",
-                    id: `checkpoint-overdue:${turn.id}`,
+                    id: `checkpoint-overdue:${run.id}`,
                     owner: "leader",
-                    summary: `Delegated Turn ${turn.id} has an unresolved checkpoint-overdue signal.`,
-                    turnId: turn.id,
-                    roleName: turn.roleName
+                    summary: `Delegated AgentRun ${run.id} has an unresolved checkpoint-overdue signal.`,
+                    runId: run.id,
+                    roleName: run.roleName
                 });
             }
         }
     }
     for (const request of input.inputRequests.filter(({ status }) => status === "open")) {
         const requester = request.requester;
-        const turn = requester === undefined
-            ? undefined
-            : activeTurns.find(({ id }) => id === requester.turnId);
-        const role = requester === undefined
-            ? undefined
-            : input.roles.find(({ name }) => name === requester.roleName);
-        const session = requester === undefined
-            ? undefined
-            : input.roleSessions.find(({ roleName }) => roleName === requester.roleName);
-        if (turn === undefined
-            || turn.roleName !== "leader"
-            || requester === undefined
-            || turn.effective?.agentId !== requester.agentId
-            || (role?.adapterId !== undefined && role.adapterId !== turn.effective?.adapterId)
-            || (requester.nativeSessionId !== undefined
-                && session?.nativeSessionId !== requester.nativeSessionId)) {
+        // Origin is durable provenance, not a live execution lease. Questions
+        // remain answerable after their originating Run ends or Session changes.
+        if (requester === undefined || requester.taskId !== task.id || requester.roleName !== "leader") {
             result.push({
                 kind: "identity-mismatch",
                 id: `input:${request.id}`,
                 owner: "leader",
-                summary: `InputRequest ${request.id} does not match the active Leader Turn/session; it is held fail-closed.`,
-                ...(requester?.turnId === undefined ? {} : { turnId: requester.turnId }),
+                summary: `InputRequest ${request.id} has an invalid Task/Leader origin; it is held fail-closed.`,
+                ...(requester?.runId === undefined ? {} : { runId: requester.runId }),
                 roleName: "leader",
                 failClosed: true
             });
@@ -591,7 +583,7 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
     const blockers = [];
     const byId = new Map(workItems.map((item) => [item.id, item]));
     for (const item of workItems) {
-        if (item.status === "failed" || item.status === "awaiting_acceptance") {
+        if (item.status === "open" && item.currentCandidateId !== undefined) {
             blockers.push({
                 kind: "work",
                 id: item.id,
@@ -599,9 +591,9 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
                 summary: item.outcome ?? `WorkItem ${item.id} is ${item.status}.`
             });
         }
-        if (item.status === "pending" && (item.dependsOn ?? []).some((id) => {
+        if (item.status === "open" && (item.dependsOn ?? []).some((id) => {
             const status = byId.get(id)?.status;
-            return status !== "completed";
+            return status !== "accepted";
         })) {
             blockers.push({
                 kind: "work",
@@ -635,7 +627,11 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
             summary: request.question
         });
     }
-    if (task.status === "active" && task.cwd === undefined) {
+    // A Task activated with an empty environment plan owns no workspace and no
+    // cwd by design; only a Task that should own one is blocked by its absence.
+    if (task.status === "active"
+        && taskOwnsManagedWorkspace(task)
+        && task.cwd === undefined) {
         blockers.push({
             kind: "identity",
             id: `workspace:${task.id}`,