@zq-silk/yui 0.15.7 → 0.15.8

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,298 +1,107 @@
-import { createTurnInput } from "../context/turnInputContract.js";
 import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
 import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
-import { createTurn } from "../turn/turn.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
-import { formatProviderDeliveryFailure, providerDeliveryFailureFacts, serializeAgentErrorRaw, innermostCauseName } from "../runtime/agentError.js";
+import { taskOwnsManagedWorkspace } from "../task/task.js";
+import { hasImmediateWakeReason } from "./wakeReason.js";
 export const LEADER_WAKE_AGGREGATION_MS = 60_000;
-export const LEADER_WAKE_FORCE_MS = 10 * 60_000;
-/**
- * Materializes durable Leader intent as a Turn. Provider lifecycle and
- * Turn submission are handled by processActiveRoleTurnDeliveries, so every
- * Role follows one launch, serialization, and failure path.
+/** Deliver a durable mailbox notification, not an implicit execution assignment.
+ * Acceptance settles only its claimed batch; no Agent report is required.
  */
 export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
-    const wakeups = selection === undefined || selection.full
-        ? store.listPendingWakeups().filter((wakeup) => !selection?.blockedTaskIds?.has(wakeup.taskId))
-        : [...selection.taskIds].flatMap((taskId) => {
-            if (selection.blockedTaskIds?.has(taskId))
-                return [];
-            const wakeup = store.getPendingWakeup(taskId);
-            return wakeup === null ? [] : [wakeup];
-        });
+    const wakeups = store.listPendingWakeups().filter((wake) => !selection?.blockedTaskIds?.has(wake.taskId)
+        && (selection === undefined || selection.full || selection.taskIds.has(wake.taskId)));
     for (const wakeup of wakeups) {
         const task = store.getTask(wakeup.taskId);
         const role = store.getRole(wakeup.taskId, "leader");
-        if (task === null
-            || task.status !== "active"
-            || task.executionGate.state !== "enabled"
-            || role === null) {
-            results.push({ taskId: wakeup.taskId, status: "skipped", reason: "unavailable" });
+        const base = { taskId: wakeup.taskId };
+        if (task == null || !["active", "draft"].includes(task.status) || task.executionGate.state !== "enabled" || role === null) {
+            results.push({ ...base, status: "skipped", reason: "unavailable" });
             continue;
         }
-        if (!isSchedulerTaskWorkspaceReady(task, store.getTaskWorkspace(task.id))) {
-            results.push({ taskId: task.id, status: "skipped", reason: "workspace-not-ready" });
+        if (!isSchedulerTaskWorkspaceReady(task, store.getTaskWorkspace(task.id), task.status === "draft" ? "planning" : "execution")) {
+            results.push({ ...base, status: "skipped", reason: "workspace-not-ready" });
             continue;
         }
-        if (store.hasOpenInputRequest(task.id)) {
-            results.push({ taskId: task.id, status: "skipped", reason: "waiting-input" });
+        if (!hasImmediateWakeReason(wakeup.reasons)
+            && now.getTime() - Date.parse(wakeup.firstRequestedAt) < LEADER_WAKE_AGGREGATION_MS) {
+            results.push({ ...base, status: "skipped", reason: "aggregating" });
             continue;
         }
-        const waitedMs = Math.max(0, now.getTime() - Date.parse(wakeup.firstRequestedAt));
-        if (waitedMs < LEADER_WAKE_AGGREGATION_MS) {
-            results.push({ taskId: task.id, status: "skipped", reason: "aggregating" });
+        if (task.status === "draft" && store.prepareDraftPlanning?.(task.id, now)) {
+            results.push({ ...base, status: "skipped", reason: "not-ready" });
             continue;
         }
-        const active = store.getActiveTurn(task.id, role.name);
-        const leaderTarget = { kind: "role", taskId: task.id, roleName: role.name };
-        const claimedSteer = store.getWorkMailbox(leaderTarget)?.processing;
-        if (claimedSteer?.owner.startsWith("leader-steer:") === true
-            && (active === null || claimedSteer.owner !== `leader-steer:${active.id}`)) {
-            store.releaseWorkMailbox(leaderTarget, claimedSteer.batchId);
-            results.push({ taskId: task.id, status: "skipped", reason: "state-changed" });
+        const sessions = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
+        const provider = sessions?.providerBinding;
+        if (provider?.authority.owner === "human" || provider?.authority.owner === "unknown") {
+            results.push({ ...base, status: "skipped", reason: "busy" });
             continue;
         }
-        if (active !== null) {
-            if (waitedMs >= LEADER_WAKE_FORCE_MS && active !== null) {
-                results.push(await forceLeaderSteer(store, delivery, task.id, role.name, active, now));
-                continue;
-            }
-            results.push({ taskId: task.id, status: "skipped", reason: "busy" });
+        // Claim inspection also settles a previously accepted receipt after a
+        // Controller restart, before checking whether that native execution is busy.
+        const notification = store.claimLeaderNotification(task.id, now);
+        if (notification === null) {
+            results.push({ ...base, status: "skipped", reason: "state-changed" });
+            continue;
+        }
+        if (notification.disposition !== "submit") {
+            results.push({ ...base, status: "skipped", reason: "not-ready",
+                ...(notification.disposition === "unknown" ? {
+                    error: `Notification acceptance is unknown; the fixed wake is retained and will not be replayed. `
+                        + `After establishing native quiescence, release only this claim with yui task wake resolve ${task.id} ${notification.wakeId} --reason <evidence>.`
+                } : {}) });
             continue;
         }
+        let attempted = false;
         try {
-            const reopening = wakeup.reasons.includes("task-reopened");
-            const existingSession = store.getRoleSession(task.id, role.name, reopening ? undefined : role.effective.agentId);
-            const compatible = existingSession !== null
-                && roleSessionMayContinue(existingSession.effective, role.effective);
-            if (hasNativeSession(existingSession)
-                && existingSession.status === "active"
-                && !compatible
-                && !reopening) {
-                throw new Error(`Leader Session is incompatible with desired effective launch: ${task.id}/${role.name}.`);
+            const session = store.getRoleSession(task.id, role.name, role.effective.agentId);
+            const effective = session?.status === "active" ? session.effective : role.effective;
+            if (session?.status === "active" && !roleSessionMayContinue(session.effective, role.effective)) {
+                throw new Error("Leader Session configuration changed; explicitly apply it before notification delivery.");
             }
-            const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
-            const mode = reopening && !compatible
-                ? "new"
-                : sessionSet === null
-                    ? hasNativeSession(existingSession) && existingSession.status === "active" && compatible
-                        ? "resume"
-                        : "new"
-                    : roleAgentSessionResumeMode(sessionSet, role.effective.agentId, role.effective);
-            const turnId = store.peekNextTurnId(task.id);
-            const envelope = store.getTaskWakeEnvelope?.(task.id) ?? null;
-            const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);
-            const input = createTurnInput({
-                source: leaderWakeInputSource(wakeup.reasons),
-                directive: [
-                    `Wake reasons: ${wakeup.reasons.join(", ")}.`,
-                    ...(envelope === null ? [] : [envelope.text.trim()]),
-                    `Load exact context for ${task.id}/${turnId}.`,
-                    "Read every referenced completed Worker or Reviewer Turn in full before deciding its disposition.",
-                    "Before ending this Turn, judge the affected WorkItems and Task; persist any lifecycle or result changes you establish.",
-                    "The final Turn response is evidence only and never updates WorkItem or Task state by itself."
-                ].join("\n"),
-                ...(contextSnapshot === undefined ? {} : { contextSnapshotRef: contextSnapshot.ref }),
-                deltaRefIds: contextSnapshot?.deltaRefIds ?? []
+            const mode = sessions === null ? "new"
+                : roleAgentSessionResumeMode(sessions, effective.agentId, effective);
+            const prepared = await delivery.prepareRoleSession({
+                taskId: task.id, roleName: role.name, agentId: effective.agentId,
+                adapterId: effective.adapterId, effective, workspace: effective.workspace.root,
+                ...(role.managedWorkspace === undefined ? {} : { managedWorkspace: role.managedWorkspace }),
+                ...(task.status === "draft" || !taskOwnsManagedWorkspace(task)
+                    ? { workspaceFree: true } : {}),
+                mode, ...(mode === "resume" && session?.nativeSessionId !== undefined
+                    ? { nativeSessionId: session.nativeSessionId } : {})
             });
-            const turn = createTurn(turnId, task.id, role.name, mode, input, now, {
-                ...(role.managedWorkspace === undefined ? {} : { workspace: role.managedWorkspace }),
-                effective: role.effective
+            const ready = await delivery.waitUntilReady(prepared);
+            attempted = true;
+            const outcome = await delivery.sendOnce({
+                delivery: ready, receiptId: notification.attemptId, notificationId: notification.wakeId,
+                text: [
+                    `Yui Task notification: task=${task.id} wake=${notification.wakeId}.`,
+                    `Read current context: yui task context ${task.id} --json.`,
+                    `Read the fixed notification window: yui task wake show ${task.id} ${notification.wakeId}.`,
+                    "Read referenced result Messages in full before deciding their disposition.",
+                    "Follow the Leader Skill to advance outstanding Task work from these durable facts, or record the exact decision/authority needed.",
+                    "This is a notification, not an execution assignment. No separate final report is required.",
+                    "Reading context is not an acknowledgement that its requirements have been implemented."
+                ].join("\n")
             });
-            const claim = store.saveLeaderDispatch({
-                task,
-                role,
-                turn,
-                session: reopening && !compatible ? null : existingSession,
-                wakeup,
-                ...(envelope === null ? {} : {
-                    wakeId: envelope.wakeId,
-                    wakeFromCursor: envelope.fromCursor
-                }),
-                now
-            });
-            results.push(claim === "claimed"
-                ? { taskId: task.id, turnId: turn.id, status: "dispatched" }
-                : { taskId: task.id, status: "skipped", reason: claim });
+            const accepted = outcome.status === "sent" || outcome.status === "already-sent";
+            const disposition = accepted ? "accepted"
+                : outcome.status === "delivery-unknown" ? "unknown"
+                    : outcome.status === "rejected" ? "rejected"
+                        : outcome.status === "pending" ? null : "deferred";
+            if (disposition !== null)
+                store.settleLeaderNotification(task.id, notification.attemptId, disposition, now, outcome.failure?.detail);
+            results.push({ ...base, status: accepted ? "dispatched" : "skipped", reason: accepted ? undefined : "not-ready" });
         }
         catch (error) {
-            results.push({
-                taskId: task.id,
-                status: "failed",
-                reason: "not-ready",
-                error: error instanceof Error ? error.message : String(error)
-            });
+            const detail = error instanceof Error ? error.message : String(error);
+            store.settleLeaderNotification(task.id, notification.attemptId, attempted ? "unknown" : "deferred", now, detail);
+            results.push({ ...base, status: "failed", reason: "not-ready", error: detail });
         }
-    }
-    return results;
-}
-function leaderWakeInputSource(reasons) {
-    if (reasons.length > 0 && reasons.every((reason) => reason === "user-message")) {
-        return { type: "yui", channel: "user-message" };
-    }
-    if (reasons.length > 0 && reasons.every((reason) => reason.startsWith("input-answered:"))) {
-        return { type: "yui", channel: "input-response" };
-    }
-    return { type: "yui", channel: "leader-wakeup" };
-}
-async function forceLeaderSteer(store, delivery, taskId, roleName, active, now) {
-    const target = { kind: "role", taskId, roleName };
-    const mailbox = store.getWorkMailbox(target);
-    const pending = mailbox?.pending;
-    const existing = mailbox?.processing;
-    if (existing === null || existing === undefined) {
-        if (pending === null || pending === undefined) {
-            return { taskId, turnId: active.id, status: "skipped", reason: "state-changed" };
+        finally {
+            delivery.forgetPrepared?.({ taskId: task.id, roleName: role.name });
         }
     }
-    const owner = `leader-steer:${active.id}`;
-    if (existing?.owner === owner) {
-        // A previous pass already claimed this input. If it could not settle the
-        // claim, delivery may have happened even when the Host has since restarted.
-        // Do not turn a mailbox read into an automatic Provider retry.
-        return {
-            taskId, turnId: active.id, status: "skipped", reason: "not-ready",
-            error: "The existing Leader steer attempt is unresolved; its mailbox claim and error evidence are preserved."
-        };
-    }
-    const batchId = existing?.batchId
-        ?? `leader-steer:${encodeURIComponent(taskId)}:${encodeURIComponent(active.id)}:${pending.fromSequence}-${pending.toSequence}`;
-    const claim = store.claimWorkMailbox({ target, batchId, owner, now });
-    if (claim.status === "empty") {
-        return { taskId, turnId: active.id, status: "skipped", reason: "state-changed" };
-    }
-    const processing = claim.processing;
-    if (processing.batchId !== batchId || processing.owner !== owner) {
-        return { taskId, turnId: active.id, status: "skipped", reason: "busy" };
-    }
-    const receiptId = `turn-input:${taskId}/${active.id}/${batchId}`;
-    let inputMayBeAccepted = false;
-    let inputAccepted = false;
-    let deliveryReturned = false;
-    let runtimeGenerationId;
-    try {
-        const sessions = store.getTaskRoleSessionSet?.(taskId, roleName) ?? null;
-        const session = sessions?.sessions[active.effective.agentId];
-        const binding = sessions?.providerBinding;
-        const providerTurn = binding?.turn;
-        const authority = binding?.authority;
-        if (session?.runtimeGenerationId === undefined || session.nativeSessionId === undefined
-            || providerTurn === null || providerTurn === undefined
-            || providerTurn.turnId !== active.id || providerTurn.nativeTurnId === undefined
-            || providerTurn.status !== "accepted"
-            || authority?.owner !== "controller" || authority.holderId === undefined) {
-            store.releaseWorkMailbox(target, batchId);
-            return { taskId, status: "failed", reason: "not-ready", error: "Active Leader Turn has no steerable Provider fence." };
-        }
-        const batch = processing.batch;
-        const envelope = store.getTaskWakeEnvelope?.(taskId) ?? null;
-        const referencedTurnIds = envelope?.referencedTurnIds ?? [];
-        const displayedTurnIds = referencedTurnIds.slice(0, 4);
-        const directive = [
-            `Aggregated Leader events: ${batch.reasons.join(", ")}.`,
-            `The first event arrived at ${batch.firstQueuedAt} and has waited at least 10 minutes while this Leader Turn remained active.`,
-            ...displayedTurnIds.map((turnId) => `Read the complete result: yui task turn show ${taskId}/${turnId}.`),
-            ...(referencedTurnIds.length > displayedTurnIds.length
-                ? [
-                    `${referencedTurnIds.length - displayedTurnIds.length} additional result Turns are listed in yui task wake show ${taskId} ${envelope.wakeId}.`
-                ]
-                : []),
-            "Process these events now and update durable Task or WorkItem facts when needed.",
-            "After the events are handled, continue the work you were doing before this interruption.",
-            `Load the current exact context for ${taskId}/${active.id}; the event batch may have grown while this input was delivered.`
-        ].join("\n");
-        const input = createTurnInput({
-            source: { type: "yui", channel: "leader-forced-wakeup" },
-            directive,
-            deltaRefIds: []
-        });
-        runtimeGenerationId = session.runtimeGenerationId;
-        inputMayBeAccepted = true;
-        const outcome = await delivery.steerOnce({
-            taskId,
-            roleName,
-            agentId: active.effective.agentId,
-            adapterId: active.effective.adapterId,
-            runtimeGenerationId: session.runtimeGenerationId,
-            nativeSessionId: session.nativeSessionId,
-            nativeTurnId: providerTurn.nativeTurnId,
-            authority: {
-                epoch: authority.epoch,
-                owner: "controller",
-                holderId: authority.holderId
-            },
-            receiptId,
-            text: directive
-        });
-        deliveryReturned = true;
-        inputAccepted = outcome.status === "sent" || outcome.status === "already-sent"
-            || outcome.failure?.inputDisposition === "accepted";
-        inputMayBeAccepted = outcome.status === "delivery-unknown" || inputAccepted;
-        if (outcome.status !== "sent" && outcome.status !== "already-sent") {
-            if (!inputMayBeAccepted)
-                store.releaseWorkMailbox(target, batchId);
-            const failure = outcome.failure;
-            if (failure !== undefined || outcome.status === "rejected" || outcome.status === "delivery-unknown") {
-                store.recordAgentError?.({
-                    taskId, roleName, turnId: active.id,
-                    source: "host",
-                    phase: failure?.phase ?? "turn-submit",
-                    message: failure === undefined ? `Leader steer ${outcome.status}.` : formatProviderDeliveryFailure(failure),
-                    raw: failure?.raw ?? serializeAgentErrorRaw(failure ?? outcome.status),
-                    inputDisposition: failure?.inputDisposition
-                        ?? (outcome.status === "delivery-unknown" ? "unknown" : "not-accepted"),
-                    ...providerDeliveryFailureFacts(failure),
-                    attemptId: receiptId
-                }, now);
-            }
-            return {
-                taskId,
-                turnId: active.id,
-                status: outcome.status === "busy" ? "skipped" : "failed",
-                reason: outcome.status === "busy" ? "busy" : "not-ready",
-                // Report the Host's cause when it supplied one; the bare status word
-                // alone cannot distinguish a rejection from a lost transport.
-                error: outcome.failure === undefined
-                    ? outcome.status
-                    : `${outcome.status}: ${formatProviderDeliveryFailure(outcome.failure)}`
-            };
-        }
-        const saved = store.saveLeaderSteer({ taskId, turnId: active.id, batchId, input, now });
-        if (saved !== "claimed")
-            store.releaseWorkMailbox(target, batchId);
-        return saved === "claimed"
-            ? { taskId, turnId: active.id, status: "steered" }
-            : { taskId, turnId: active.id, status: "skipped", reason: saved };
-    }
-    catch (error) {
-        // A transport exception (or failure after delivery) is not evidence that
-        // the input was unsubmitted. Preserve its exact mailbox attempt.
-        if (!inputMayBeAccepted)
-            store.releaseWorkMailbox(target, batchId);
-        store.recordAgentError?.({
-            taskId, roleName, turnId: active.id,
-            source: inputMayBeAccepted && !deliveryReturned ? "host" : "yui",
-            phase: "turn-submit",
-            message: error instanceof Error ? error.message : String(error),
-            raw: serializeAgentErrorRaw(error),
-            inputDisposition: inputAccepted ? "accepted" : inputMayBeAccepted ? "unknown" : "not-accepted",
-            ...(error instanceof Error ? { errorName: error.name } : {}),
-            causeName: innermostCauseName(error),
-            expectedRuntimeGenerationId: runtimeGenerationId,
-            attemptId: receiptId
-        }, now);
-        return {
-            taskId,
-            turnId: active.id,
-            status: "failed",
-            reason: "not-ready",
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-function hasNativeSession(session) {
-    return session !== null
-        && typeof session.nativeSessionId === "string"
-        && session.nativeSessionId.trim().length > 0;
+    return results;
 }

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -54,7 +54,7 @@ export async function processOperatorInputNotifications(store, delivery, selecti
             return attentions.map((attention) => skipped(attention, reason));
         }
         if (outcome === "sent")
-            store.markOperatorTurnStarted(now);
+            store.markOperatorRunStarted(now);
         store.completeWorkMailbox(targetMailbox, processing.batchId);
         return attentions.map((attention) => ({
             ...attentionIdentity(attention),

package/dist/scheduler/ports.js

@@ -1,7 +1,38 @@
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
-export function isSchedulerTaskWorkspaceReady(task, workspace) {
+import { taskOwnsManagedWorkspace } from "../task/task.js";
+/**
+ * Whether the Task's workspace state admits a launch.
+ *
+ * A Task that owns no managed workspace — activated with an empty environment
+ * plan, binding no Project — is admitted with no workspace record at all. The
+ * scheduler must not wait for a worktree that was deliberately never created.
+ * Every Task that does own one still needs the full ownership proof.
+ *
+ * A Draft planning conversation is a third case: the Task may already bind a
+ * Project, yet activation has not run, so no worktree exists or is owed. It is
+ * admitted with no workspace at all, and precisely because it has none it must
+ * never be handed one implicitly — workspace preparation keeps the strictly
+ * active selection, so a planning Draft never enters it.
+ */
+export function isSchedulerTaskWorkspaceReady(task, workspace, purpose) {
+    if (isSchedulerPlanningDraft(task, purpose)) {
+        return workspace === null || workspace === undefined;
+    }
+    if (!taskOwnsManagedWorkspace(task)) {
+        return workspace === null || workspace === undefined;
+    }
     return isTaskOwnedWorkspace(workspace, task.id, task.cwd, task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory })));
 }
+/**
+ * A Draft running a planning Turn: durable planning before activation.
+ *
+ * This is the single predicate every scheduler phase uses to tell that third
+ * case apart, so admitting planning never widens to "a Draft is active". The
+ * purpose comes from the durable Turn, never from a caller argument.
+ */
+export function isSchedulerPlanningDraft(task, purpose) {
+    return purpose === "planning" && task.status === "draft";
+}
 /** Resolves Tasks without a global scan for a dirty reconciliation pass. */
 export function selectedSchedulerTasks(store, selection) {
     if (selection === undefined || selection.full) {
@@ -19,20 +50,44 @@ export function selectedSchedulerTasks(store, selection) {
  * the durable active index, so terminal history never enters Role, delivery,
  * workspace, or liveness projections. Dirty passes keep their exact-key
  * semantics and simply discard a Task that is no longer active.
+ *
+ * With `includePlanningDrafts`, a Draft that already carries an active planning
+ * Turn is resolved too. Planning is durable work owed to a Role, so the phases
+ * that keep an admitted Turn converging — delivery, liveness, stall — must be
+ * able to see it, or a Draft planning Turn could be dispatched and then never
+ * re-delivered, resumed, or terminalized. The Draft is admitted only on the
+ * evidence of its own durable planning Turn: `listPlanningDraftTaskIds` reads
+ * the Turn, never the Task status alone, so an ordinary Draft with no planning
+ * Turn stays invisible exactly as before. Phases that act on execution facts
+ * (workspace preparation, integration, completion) keep the default and
+ * therefore keep seeing active Tasks only.
  */
-export function selectedActiveSchedulerTasks(store, selection) {
+export function selectedActiveSchedulerTasks(store, selection, options) {
+    const planningDrafts = options?.includePlanningDrafts === true;
+    const admits = (task) => {
+        if (task === null || task.executionGate.state !== "enabled")
+            return false;
+        if (task.status === "active")
+            return true;
+        return planningDrafts && hasActivePlanningRun(store, task);
+    };
     if (selection === undefined || selection.full) {
         const indexedTaskIds = store.listActiveTaskIds?.();
         if (indexedTaskIds === undefined) {
-            return store.listTasks().filter((task) => (task.status === "active"
-                && task.executionGate.state === "enabled"
-                && !selection?.blockedTaskIds?.has(task.id)));
+            return store.listTasks().filter((task) => (admits(task) && !selection?.blockedTaskIds?.has(task.id)));
         }
-        return [...indexedTaskIds].flatMap((taskId) => {
-            if (selection?.blockedTaskIds?.has(taskId))
+        // The active index is bounded and authoritative for active Tasks; planning
+        // Drafts come from their own bounded index rather than a full-history scan.
+        const taskIds = planningDrafts
+            ? [...indexedTaskIds, ...(store.listPlanningDraftTaskIds?.() ?? [])]
+            : [...indexedTaskIds];
+        const seen = new Set();
+        return taskIds.flatMap((taskId) => {
+            if (seen.has(taskId) || selection?.blockedTaskIds?.has(taskId))
                 return [];
+            seen.add(taskId);
             const task = store.getTask(taskId);
-            return task?.status === "active" && task.executionGate.state === "enabled" ? [task] : [];
+            return admits(task) ? [task] : [];
         });
     }
     const taskIds = selection.taskIds;
@@ -40,7 +95,23 @@ export function selectedActiveSchedulerTasks(store, selection) {
         if (selection.blockedTaskIds?.has(taskId))
             return [];
         const task = store.getTask(taskId);
-        return task?.status === "active" && task.executionGate.state === "enabled" ? [task] : [];
+        return admits(task) ? [task] : [];
+    });
+}
+/**
+ * Whether a Draft carries an active planning Turn on any of its Roles. Read
+ * from the durable active-Turn pointers, so a Draft is never admitted on its
+ * status alone.
+ */
+function hasActivePlanningRun(store, task) {
+    if (task.status !== "draft")
+        return false;
+    const roles = store.listRoles?.(task.id) ?? [];
+    return roles.some((role) => {
+        const run = store.getActiveRun?.(task.id, role.name) ?? null;
+        return run !== null
+            && run.status === "active"
+            && isSchedulerPlanningDraft(task, run.purpose);
     });
 }
 /** Resolves either every Role in a selected Task or only explicit Role keys. */

package/dist/scheduler/{roleTurnLiveness.js → roleRunLiveness.js}

@@ -1,19 +1,24 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
-import { currentRoleTurnProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleTurnStall.js";
+import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
+import { currentRoleRunProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
 /**
  * Lightweight liveness only. Pane/process loss is runtime-health evidence,
- * not an application-level outcome. The Turn stays active so native
+ * not an application-level outcome. The AgentRun stays active so native
  * child work or another observer can still contribute facts, while the stall
  * path raises bounded attention independently.
  * Process liveness is only a recovery signal. An absent pane/Host never proves
- * that the native Session or Turn ended; recover the same generation and
- * native identity when possible, otherwise preserve the active Turn.
+ * that the native Session or AgentRun ended; recover the same Session and
+ * native identity when possible, otherwise preserve the active AgentRun.
  */
-export async function reconcileExitedRoleTurns(store, delivery, now, selection, excludedTurnRefs = new Set(), liveStatuses, resourceEvidence, targetedInventory = selection !== undefined && !selection.full) {
+export async function reconcileExitedRoleRuns(store, delivery, now, selection, excludedRunRefs = new Set(), liveStatuses, resourceEvidence, targetedInventory = selection !== undefined && !selection.full) {
     const failed = [];
-    const candidates = selectedActiveSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
-        const run = store.getActiveTurn(task.id, role.name);
+    // A Draft planning Turn is an admitted Turn with a real Host, so liveness must
+    // resolve it too; otherwise a lost planning host would never be reaped.
+    const candidates = selectedActiveSchedulerTasks(store, selection, {
+        includePlanningDrafts: true
+    }).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
+        const run = store.getActiveRun(task.id, role.name);
         if (run === null)
             return [];
         const session = store.getRoleSession(task.id, role.name, run.effective.agentId);
@@ -27,9 +32,8 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
                     roleName: role.name,
                     agentId: run.effective.agentId,
                     adapterId: run.effective.adapterId,
-                    turnId: run.id,
+                    runId: run.id,
                     progressAt: run.createdAt,
-                    ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                     ...(session?.nativeSessionId === undefined
                         ? {}
                         : { nativeSessionId: session.nativeSessionId })
@@ -38,9 +42,9 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
     })));
     if (candidates.length === 0)
         return failed;
-    const eligible = candidates.filter(({ task, run }) => (!excludedTurnRefs.has(formatTaskRecordReference(task.id, run.id, "turn"))));
+    const eligible = candidates.filter(({ task, run }) => (!excludedRunRefs.has(formatTaskRecordReference(task.id, run.id, "run"))));
     // Full reconciliation builds one complete provider inventory for every
-    // active Turn, including delivery-uncertain and completion-pending Turns.
+    // active AgentRun, including delivery-uncertain and completion-pending AgentRuns.
     // The stall phase reuses that snapshot so one full pass never probes the
     // same pane twice. When targetedInventory is true, a dirty pass instead
     // uses exact probes below; stall reconciliation intentionally does not run
@@ -57,14 +61,13 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
                 ? [{
                         taskId: task.id,
                         roleName: role.name,
-                        turnId: run.id,
+                        runId: run.id,
                         agentId: run.effective.agentId,
                         adapterId: run.effective.adapterId,
-                        progressAt: currentRoleTurnProgressAt(store, task.id, role.name, run).progressAt,
+                        progressAt: currentRoleRunProgressAt(store, task.id, role.name, run).progressAt,
                         ...(session?.nativeSessionId === undefined
                             ? {}
                             : { nativeSessionId: session.nativeSessionId }),
-                        ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId })
                     }]
                 : []))
             : [], targetedInventory);
@@ -76,8 +79,8 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
         for (const [key, resource] of batchSnapshot.resources) {
             const candidate = candidates.find(({ task, role }) => (`${task.id}\0${role.name}` === key));
             if (candidate !== undefined) {
-                // Keep only the exact Turn key. A task/role or bare-Turn fallback can
-                // bridge an asynchronous sample from a prior generation.
+                // Keep only the exact AgentRun key. A task/role or bare-AgentRun fallback can
+                // bridge an asynchronous sample from a prior Session.
                 resourceEvidence.set(`${key}\0${candidate.run.id}`, resource);
             }
         }
@@ -93,8 +96,7 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
             store.saveRoleHostExitObservation?.({
                 taskId: task.id,
                 roleName: role.name,
-                turnId: run.id,
-                ...(session?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
+                runId: run.id,
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
@@ -110,7 +112,7 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
             delivery.forgetPrepared?.({
                 taskId: task.id,
                 roleName: role.name,
-                turnId: run.id
+                runId: run.id
             });
             const recovered = await delivery.prepareRoleSession({
                 taskId: task.id,
@@ -121,25 +123,21 @@ export async function reconcileExitedRoleTurns(store, delivery, now, selection,
                 workspace: run.effective.workspace.root,
                 ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
                 mode: "resume",
-                turnId: run.id,
+                runId: run.id,
                 nativeSessionId: session.nativeSessionId,
-                ...(session.runtimeGenerationId === undefined
-                    ? {}
-                    : { hostActivationId: session.runtimeGenerationId })
             });
-            store.saveRoleTurnPrepared({
+            store.saveRoleRunPrepared({
                 task,
                 role,
-                turn: run,
+                run: run,
                 session: recovered.session ?? session,
-                ...(recovered.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: recovered.runtimeGenerationId }),
                 now
             });
             liveStatuses?.set(`${task.id}\0${role.name}`, "present");
         }
         catch {
             // Absence plus an inconclusive local recovery attempt is still not a
-            // native Session death proof. Keep the exact Turn active for the next
+            // native Session death proof. Keep the exact AgentRun active for the next
             // bounded recovery pass and expose the blocked axis separately.
             store.queueTaskProgress(task.id, "host-missing-native-resume-pending", now);
         }
@@ -196,9 +194,7 @@ function exactBatchInventory(batch, candidates) {
     return { statuses, resources, hostExits };
 }
 function isResourceCandidate(task, run, now) {
-    if (task.status !== "active"
-        || task.executionGate.state !== "enabled"
-        || run.status !== "active") {
+    if (!runPurposeAdmitsTaskState(run.purpose, task) || run.status !== "active") {
         return false;
     }
     const createdAt = Date.parse(run.createdAt);