@zq-silk/yui 0.2.0 → 0.4.2

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,16 +1,29 @@
 import { createAgentRun } from "../run/agentRun.js";
+import { markYuiRunInput } from "../run/runIdentity.js";
+import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { effectiveLaunchSnapshotsCompatible } from "../executor/effectiveLaunch.js";
+import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.js";
 import { createLeaderRecoveryNotification } from "./operatorNotification.js";
-export async function processLeaderWakeups(store, delivery, now) {
+import { isSchedulerTaskWorkspaceReady } from "./ports.js";
+export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
-    for (const wakeup of store.listPendingWakeups()) {
+    const wakeups = selection === undefined || selection.full
+        ? store.listPendingWakeups()
+        : [...selection.taskIds].flatMap((taskId) => {
+            const wakeup = store.getPendingWakeup(taskId);
+            return wakeup === null ? [] : [wakeup];
+        });
+    for (const wakeup of wakeups) {
         const task = store.getTask(wakeup.taskId);
         const role = store.getRole(wakeup.taskId, "leader");
         if (task === null || task.status !== "active" || role === null) {
             results.push({ taskId: wakeup.taskId, status: "skipped", reason: "unavailable" });
             continue;
         }
-        if (task.repositoryId !== undefined && task.cwd === undefined) {
+        const taskWorkspace = store.getTaskWorkspace(task.id);
+        if (!isSchedulerTaskWorkspaceReady(task, taskWorkspace)) {
             results.push({ taskId: task.id, status: "skipped", reason: "workspace-not-ready" });
             continue;
         }
@@ -23,73 +36,290 @@ export async function processLeaderWakeups(store, delivery, now) {
             continue;
         }
         // This check deliberately precedes every tmux operation. A pending wake is
-        // durable state, not text that may be injected into a busy Agent composer.
+        // durable state, not text that may be injected into a busy Agent process.
         if (store.getActiveAgentRun(task.id, role.name) !== null) {
             results.push({ taskId: task.id, status: "skipped", reason: "busy" });
             continue;
         }
-        const existingSession = store.getRoleSession(task.id, role.name);
+        if (typeof store.hasInFlightTurn === "function"
+            && store.hasInFlightTurn(task.id, role.name)) {
+            results.push({ taskId: task.id, status: "skipped", reason: "busy" });
+            continue;
+        }
+        const reopening = wakeup.reasons.includes("task-reopened");
+        const existingSession = store.getRoleSession(task.id, role.name, reopening ? undefined : role.effective.agentId);
         let effectiveSession = existingSession;
         let claimed = false;
+        let deliveryAttempted = false;
         let run = null;
+        let prepared;
+        let preStartFencePersisted = false;
         try {
-            const mode = hasNativeSession(existingSession) ? "resume" : "new";
-            const input = leaderWakeupInput(task.id, wakeup.reasons, store.getTaskBrief(task.id), store.listDecisions(task.id), store.listMilestones(task.id));
-            run = createAgentRun(store.nextAgentRunId(task.id), task.id, role.name, mode, input, now);
-            const prepared = await delivery.prepareRoleSession({
+            if (existingSession !== null && !hasNativeSession(existingSession)) {
+                const sessionIsTerminal = existingSession.status === "stopped"
+                    || existingSession.status === "broken";
+                if (!sessionIsTerminal) {
+                    // An opaque live Session has no provider identity that can be safely
+                    // rebound. A host absence observation is not a verified stop; keep
+                    // the wake durable until an explicit exact cleanup/reset settles it.
+                    if (existingSession.launchId !== undefined) {
+                        await delivery.inspectRole({
+                            taskId: task.id,
+                            roleName: role.name,
+                            agentId: existingSession.agentId,
+                            adapterId: existingSession.adapterId
+                        });
+                    }
+                    results.push({
+                        taskId: task.id,
+                        status: "skipped",
+                        reason: "recovery-blocked"
+                    });
+                    continue;
+                }
+                if (hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget({
+                    scope: "task",
+                    taskId: task.id,
+                    roleName: role.name
+                })))) {
+                    // A stopped/broken Session is eligible for a fresh mode only after
+                    // its exact runtime cleanup/reservation lane has settled.
+                    results.push({
+                        taskId: task.id,
+                        status: "skipped",
+                        reason: "recovery-blocked"
+                    });
+                    continue;
+                }
+            }
+            const compatibleSession = existingSession !== null
+                && effectiveLaunchSnapshotsCompatible(existingSession.effective, role.effective);
+            const reopenIdentityDrift = reopening
+                && hasNativeSession(existingSession)
+                && !compatibleSession;
+            if (hasNativeSession(existingSession) && !compatibleSession
+                && !reopenIdentityDrift
+                && existingSession.status !== "stopped" && existingSession.status !== "broken") {
+                throw new Error(`Leader Session is incompatible with desired effective launch: ${task.id}/${role.name}.`);
+            }
+            const mode = hasNativeSession(existingSession) && compatibleSession ? "resume" : "new";
+            const runId = store.peekNextAgentRunId(task.id);
+            const input = markYuiRunInput(leaderWakeupInput(task.id, runId, wakeup.reasons, task.projectBindings), runId, taskRoleSessionTitle(task, role.name));
+            run = createAgentRun(runId, task.id, role.name, mode, input, now, {
+                ...(role.managedWorkspace === undefined
+                    ? {}
+                    : { workspace: role.managedWorkspace }),
+                effective: role.effective
+            });
+            const claim = store.saveLeaderDispatch({
+                task,
+                role,
+                run,
+                // An incompatible reopened generation is intentionally not rebound to
+                // a new native host. Keep the old fixed Session as evidence while
+                // claiming a short-lived Run so the existing failure path can record a
+                // durable, retryable recovery obligation before any provider call.
+                session: reopenIdentityDrift ? null : existingSession,
+                wakeup,
+                now
+            });
+            if (claim !== "claimed") {
+                results.push({ taskId: task.id, status: "skipped", reason: claim });
+                continue;
+            }
+            claimed = true;
+            if (reopenIdentityDrift) {
+                throw new Error(`Leader reopen refused after effective launch identity drift: ${task.id}/${role.name}.`);
+            }
+            prepared = await delivery.prepareRoleSession({
                 taskId: task.id,
                 roleName: role.name,
-                agentId: role.activeAgentId,
-                adapterId: role.adapterId,
+                agentId: role.effective.agentId,
+                adapterId: role.effective.adapterId,
+                effective: role.effective,
+                workspace: role.effective.workspace.root,
+                ...(run.workspace === undefined
+                    ? {}
+                    : { managedWorkspace: run.workspace }),
                 mode,
-                ...(mode === "resume" ? { nativeSessionId: existingSession.nativeSessionId } : {})
+                runId: run.id,
+                ...(mode === "resume" ? { nativeSessionId: existingSession.nativeSessionId } : {}),
+                beforeHostStart: (preflight) => {
+                    persistPreStartFence(store, task, role, run, existingSession, mode, preflight, now);
+                    effectiveSession = preflightSession(run.effective, existingSession, mode, preflight);
+                    preStartFencePersisted = true;
+                }
             });
+            // A fresh Codex host may already carry the exact Run prompt in its
+            // launch argv. Once preparation returns that transport fact, any
+            // later readiness or aggregate-write failure is delivery uncertainty,
+            // not a launch failure: preserve the Run and its reservation for the
+            // matching provider Hook instead of terminalizing it.
+            deliveryAttempted = prepared.inputSubmittedAtLaunch === true;
+            // Persist the exact preparation fence before waiting on provider
+            // readiness. A pre-input lifecycle Hook may fire during that wait; it
+            // must be able to resolve this Run/Session/launch generation from durable
+            // state rather than an in-memory delivery object. Fresh providers that
+            // discover their native Session later intentionally persist `null`.
+            if (!preStartFencePersisted) {
+                const preparedFenceSession = prepared.session === undefined
+                    ? existingSession
+                    : validateReadySession(run.effective, existingSession, mode, prepared.session);
+                effectiveSession = preparedFenceSession;
+                store.saveRoleRunPrepared({
+                    task,
+                    role,
+                    run,
+                    session: preparedFenceSession,
+                    ...(prepared.launchId === undefined ? {} : { launchId: prepared.launchId }),
+                    now
+                });
+            }
             const ready = await delivery.waitUntilReady(prepared);
+            deliveryAttempted = deliveryAttempted
+                || ready.prepared.inputSubmittedAtLaunch === true;
             const latestTask = store.getTask(task.id);
             if (latestTask === null || latestTask.status !== "active") {
+                delivery.forgetPrepared?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    ...(prepared.launchId === undefined
+                        ? {}
+                        : { launchId: prepared.launchId })
+                });
                 results.push({ taskId: task.id, status: "skipped", reason: "unavailable" });
                 continue;
             }
-            effectiveSession = validateReadySession(role.activeAgentId, existingSession, mode, ready.session);
-            const claim = store.saveLeaderDispatch({ task, role, run, session: effectiveSession, wakeup, now });
-            if (claim !== "claimed") {
-                results.push({ taskId: task.id, status: "skipped", reason: claim });
+            effectiveSession = validateReadySession(run.effective, existingSession, mode, ready.session);
+            store.saveRoleRunPrepared({
+                task,
+                role,
+                run,
+                session: effectiveSession,
+                ...(ready.prepared.launchId === undefined
+                    ? {}
+                    : { launchId: ready.prepared.launchId }),
+                now
+            });
+            if (ready.prepared.inputSubmittedAtLaunch === true) {
+                // A fresh Codex command may carry the exact first prompt in its launch
+                // argv. That is transport evidence only: the matching Provider Hook
+                // still owns Run acceptance. Persist the push fence without writing a
+                // second terminal prompt, then leave the reservation for the async
+                // SessionStart/UserPromptSubmit fold.
+                store.saveRoleRunDelivery({
+                    task,
+                    role,
+                    run,
+                    session: effectiveSession,
+                    ...(ready.prepared.launchId === undefined
+                        ? {}
+                        : { launchId: ready.prepared.launchId }),
+                    now
+                });
+                delivery.forgetPrepared?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    ...(ready.prepared.launchId === undefined
+                        ? {}
+                        : { launchId: ready.prepared.launchId })
+                });
+                results.push({ taskId: task.id, runId: run.id, status: "dispatched" });
                 continue;
             }
-            claimed = true;
-            await delivery.sendOnce({
+            deliveryAttempted = true;
+            const outcome = await delivery.sendOnce({
                 delivery: ready,
-                receiptId: `agent-run:${run.id}`,
+                receiptId: formatAgentRunReceiptId(task.id, run.id),
                 text: input
             });
-            store.saveRoleRunDelivery({ task, role, run, session: effectiveSession, now });
-            results.push({ taskId: task.id, status: "dispatched" });
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            const message = `Leader dispatch failed: ${detail}`;
-            store.saveLeaderDispatchFailure({
+            if (outcome === "busy" || outcome === "unavailable") {
+                results.push({
+                    taskId: task.id,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "not-ready"
+                });
+                continue;
+            }
+            store.saveRoleRunDelivery({
                 task,
                 role,
+                run,
                 session: effectiveSession,
-                failure: recordLeaderFailure(task.id, effectiveSession?.nativeSessionId ?? "(unregistered)", message, now, store.getLeaderFailure(task.id)),
-                notification: createLeaderRecoveryNotification(task.id, message, now, store.getOperatorNotification(task.id)),
-                ...(claimed && run !== null ? { claimed: { run, wakeup } } : {}),
+                ...(ready.prepared.launchId === undefined
+                    ? {}
+                    : { launchId: ready.prepared.launchId }),
                 now
             });
-            results.push({ taskId: task.id, status: "failed", error: message });
+            results.push({ taskId: task.id, runId: run.id, status: "dispatched" });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const message = `Leader dispatch failed: ${detail}`;
+            if (claimed && run !== null) {
+                // Once delivery begins, a send may have succeeded even when receipt
+                // observation or the aggregate write failed. Preserve the exact
+                // durable Run and let receipt-backed active delivery recover it.
+                if (deliveryAttempted) {
+                    results.push({
+                        taskId: task.id,
+                        runId: run.id,
+                        status: "failed",
+                        reason: "delivery-uncertain",
+                        error: message
+                    });
+                    continue;
+                }
+                delivery.forgetPrepared?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    ...(prepared?.launchId === undefined
+                        ? {}
+                        : { launchId: prepared.launchId })
+                });
+                const failureResult = store.saveLeaderDispatchFailure({
+                    task,
+                    role,
+                    session: effectiveSession,
+                    claimed: { run, wakeup },
+                    failure: recordLeaderFailure(task.id, effectiveSession?.nativeSessionId ?? "(unregistered)", message, now, store.getLeaderFailure(task.id)),
+                    notification: createLeaderRecoveryNotification(task.id, message, now, store.getOperatorNotification(task.id)),
+                    now
+                });
+                if (failureResult === "state-changed") {
+                    results.push({ taskId: task.id, status: "skipped", reason: "state-changed" });
+                }
+                else {
+                    results.push({ taskId: task.id, runId: run.id, status: "failed", error: message });
+                }
+                continue;
+            }
+            results.push({
+                taskId: task.id,
+                runId: run?.id,
+                status: "failed",
+                reason: "not-ready",
+                error: message
+            });
         }
     }
     return results;
 }
-function validateReadySession(activeAgentId, existing, mode, session) {
+function validateReadySession(effective, existing, mode, session) {
     if (mode === "new" && session === null)
         return null;
     if (session === null)
         throw new Error("Leader resume returned no fixed native session.");
-    if (session.agentId !== activeAgentId) {
+    if (session.agentId !== effective.agentId || session.adapterId !== effective.adapterId) {
         throw new Error(`Ready session belongs to another Agent: ${session.agentId}.`);
     }
+    if (!effectiveLaunchSnapshotsCompatible(session.effective, effective)) {
+        throw new Error("Ready Leader session effective snapshot changed.");
+    }
     if (!hasNativeSession(session)) {
         throw new Error("Ready Leader session has no native session id.");
     }
@@ -98,46 +328,57 @@ function validateReadySession(activeAgentId, existing, mode, session) {
     }
     return { ...session, status: "running" };
 }
+function persistPreStartFence(store, task, role, run, existingSession, mode, preflight, now) {
+    if (preflight.owner.scope !== "task"
+        || preflight.owner.taskId !== task.id
+        || preflight.owner.roleName !== role.name
+        || preflight.runId !== run.id
+        || preflight.launchId.trim().length === 0) {
+        throw new Error(`Pre-start launch fence changed the Leader Run: ${task.id}/${role.name}.`);
+    }
+    const session = preflightSession(run.effective, existingSession, mode, preflight);
+    store.saveRoleRunPrepared({
+        task,
+        role,
+        run,
+        session,
+        launchId: preflight.launchId,
+        now
+    });
+}
+function preflightSession(effective, existing, mode, preflight) {
+    const session = preflight.nativeSessionId === undefined
+        ? null
+        : {
+            agentId: preflight.agentId,
+            adapterId: preflight.adapterId,
+            nativeSessionId: preflight.nativeSessionId,
+            launchId: preflight.launchId,
+            status: "ready",
+            effective: preflight.effective
+        };
+    return validateReadySession(effective, existing, mode, session);
+}
 function hasNativeSession(session) {
     return session !== null &&
         typeof session.nativeSessionId === "string" &&
         session.nativeSessionId.trim().length > 0;
 }
-function leaderWakeupInput(taskId, reasons, brief, decisions, milestones) {
+function leaderWakeupInput(taskId, runId, reasons, projectBindings) {
     const lines = [
-        `Yui wakeup reasons: ${reasons.join(", ")}.`
+        "Follow the injected yui-leader Skill for this Yui wakeup.",
+        `Current Leader Run: ${runId}.`,
+        `For every Leader decision, milestone, or Work Item lifecycle command that is meaningful progress, carry this exact current-turn assertion on that command: YUI_LEADER_ACTION_RUN_ID=${runId} YUI_LEADER_ACTION_RECEIPT_ID=${formatAgentRunReceiptId(taskId, runId)}. The native Session environment may retain an older YUI_RUN_ID/launch; never copy those values, and never reuse this assertion after the turn changes.`,
+        `Yui wakeup reasons: ${reasons.join(", ")}.`,
+        `Read the authoritative context with yui task context ${taskId}.`,
+        "Keep the context layers separate: Yui Core owns durable identity, lifecycle, access, workspace, and exact-yield safety; the generic role Skill owns portable collaboration behavior; Project Policy/Knowledge owns project-specific build, test, migration, release, and review rules; the Task Contract owns this Task's objective, scope, acceptance, and evidence.",
+        "For role-run-stalled or runtime-health attention, diagnose from the exact Run/Event/Session and related WorkItem/Review/Integration records. Preserve the current fence and write a Task Message only for a new root cause, impact, recovery action, acceptance decision, or user-relevant conclusion; an unchanged healthy wait is zero Message.",
+        projectBindings.length === 0
+            ? "This Task has no bound Project Policy; do not invent repository-specific rules."
+            : `Project Policy references: ${projectBindings.map((binding) => `${binding.directory} (${binding.projectId})`).join(", ")}. Read each with yui project show <project>, then yui project knowledge list <project> and yui project knowledge show <project> <knowledge>.`,
+        "Use narrower Task message, WorkItem, decision, milestone, and input commands only when a specific record needs closer inspection.",
+        `When the requested outcome is finished and there are no active Worker Runs or unresolved inputs, complete the Task with yui task complete ${taskId} --summary-file - and a quoted heredoc containing the final outcome and evidence.`,
+        `Before ending this turn, if the Task was not completed and no InputRequest terminalized this Run, release the active fence with yui task run yield ${runId} --summary-file - and a quoted heredoc containing the current result or waiting state. In particular, yield before waiting for Worker results; do not end the native turn while this Run remains active. The yield command must be the final tool action: after it succeeds, stop immediately and do not inspect, poll, accept, or perform further work in the same native turn.`
     ];
-    if (brief !== null) {
-        lines.push(`Objective: ${brief.objective}`);
-        if (brief.boundaries.length > 0) {
-            lines.push("Boundaries:");
-            for (const boundary of brief.boundaries) {
-                lines.push(`  - ${boundary}`);
-            }
-        }
-        if (brief.currentFocus.trim().length > 0) {
-            lines.push(`Current focus: ${brief.currentFocus}`);
-        }
-        if (brief.leaderSummary.trim().length > 0) {
-            lines.push(`Leader summary: ${brief.leaderSummary}`);
-        }
-    }
-    const activeDecisions = decisions.filter((d) => d.status === "active").slice(-3);
-    if (activeDecisions.length > 0) {
-        lines.push("Active decisions:");
-        for (const decision of activeDecisions) {
-            lines.push(`  - ${decision.title}: ${decision.rationale}`);
-        }
-    }
-    const recentMilestones = [...milestones]
-        .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
-        .slice(0, 3);
-    if (recentMilestones.length > 0) {
-        lines.push("Recent milestones:");
-        for (const milestone of recentMilestones) {
-            lines.push(`  - ${milestone.title}`);
-        }
-    }
-    lines.push(`Inspect yui task context ${taskId}, which includes open and recently resolved input requests; then continue Leader stewardship. Use narrower show/list commands only when one record needs closer inspection.`);
     return lines.join("\n");
 }

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -1,85 +1,148 @@
-export async function processOperatorInputNotifications(store, delivery) {
-    const requests = store.listOpenInputRequests();
-    if (requests.length === 0)
+import { createInputRequestOperatorPresentation, createLeaderRecoveryOperatorPresentation, createLeaderStallOperatorPresentation, createTaskTerminalOperatorPresentation } from "../interaction/operatorPresentation.js";
+export async function processOperatorInputNotifications(store, delivery, selection, now = new Date()) {
+    if (selection !== undefined && !selection.full && !selection.operator)
         return [];
+    const targetMailbox = { kind: "operator" };
+    const mailbox = store.getWorkMailbox(targetMailbox);
+    if (mailbox === null || (mailbox.pending === null && mailbox.processing === null))
+        return [];
+    const pending = mailbox.pending;
+    const claim = store.claimWorkMailbox({
+        target: targetMailbox,
+        batchId: pending === null
+            ? "operator-recovery"
+            : `operator:${pending.fromSequence}-${pending.toSequence}`,
+        owner: "controller",
+        now
+    });
+    if (claim.status === "empty")
+        return [];
+    const processing = claim.processing;
+    const requests = processing.batch.refs
+        .flatMap((ref) => ref.type === "input"
+        ? [store.getInputRequest(ref.taskId, ref.id)]
+        : [])
+        .filter((request) => request !== null && request.status === "open")
+        .map((request) => ({ kind: "input", request }));
+    const notifications = processing.batch.refs
+        .filter((ref) => ref.type === "task")
+        .map((ref) => store.getOperatorNotification(ref.id))
+        .filter((notification) => notification !== null)
+        .map((notification) => ({ kind: "notification", notification }));
+    const attentions = deduplicateAttention([...requests, ...notifications]);
+    if (attentions.length === 0) {
+        store.completeWorkMailbox(targetMailbox, processing.batchId);
+        return [];
+    }
     const target = store.getOperatorDeliveryTarget();
     if (target === null || delivery.notifyOperatorInputOnce === undefined) {
         const reason = target === null ? "operator-unavailable" : "delivery-unsupported";
-        return requests.map((request) => skipped(request, reason));
+        store.releaseWorkMailbox(targetMailbox, processing.batchId);
+        return attentions.map((attention) => skipped(attention, reason));
     }
     const results = [];
-    for (const [index, request] of requests.entries()) {
+    for (const [index, attention] of attentions.entries()) {
         try {
+            const presentation = createAttentionPresentation(attention, store);
             const outcome = await delivery.notifyOperatorInputOnce({
                 ...target,
-                receiptId: `input-request:${request.id}`,
-                text: renderOperatorInputNotification(request)
+                receiptId: presentation.receiptId,
+                text: presentation.text
             });
             if (outcome === "unavailable") {
-                results.push(skipped(request, "operator-unavailable"));
-                results.push(...requests.slice(index + 1).map((pending) => (skipped(pending, "operator-unavailable"))));
+                store.releaseWorkMailbox(targetMailbox, processing.batchId);
+                results.push(skipped(attention, "operator-unavailable"));
+                results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-unavailable"))));
                 break;
             }
             else if (outcome === "not-ready") {
-                results.push(skipped(request, "operator-not-ready"));
-                results.push(...requests.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
+                store.releaseWorkMailbox(targetMailbox, processing.batchId);
+                results.push(skipped(attention, "operator-not-ready"));
+                results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
                 break;
             }
             else {
                 results.push({
-                    inputRequestId: request.id,
-                    taskId: request.taskId,
+                    ...attentionIdentity(attention),
                     status: outcome
                 });
                 if (outcome === "sent") {
-                    results.push(...requests.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
+                    if (index === attentions.length - 1) {
+                        store.completeWorkMailbox(targetMailbox, processing.batchId);
+                    }
+                    else {
+                        store.releaseWorkMailbox(targetMailbox, processing.batchId);
+                    }
+                    results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
                     break;
                 }
             }
         }
         catch (error) {
+            store.releaseWorkMailbox(targetMailbox, processing.batchId);
             results.push({
-                inputRequestId: request.id,
-                taskId: request.taskId,
+                ...attentionIdentity(attention),
                 status: "failed",
                 error: error instanceof Error ? error.message : String(error)
             });
+            break;
         }
     }
+    if (results.length > 0 && results.every((result) => result.status === "already-sent")) {
+        store.completeWorkMailbox(targetMailbox, processing.batchId);
+    }
     return results;
 }
-function renderOperatorInputNotification(request) {
-    const recommendedChoiceKey = request.policy.kind === "recommended"
-        ? request.policy.recommendedChoiceKey
-        : undefined;
-    const recommendedChoice = recommendedChoiceKey === undefined
-        ? undefined
-        : request.choices.find((choice) => choice.key === recommendedChoiceKey);
-    return [
-        "A Task Leader is waiting for user input. Present this question to the user; do not answer it yourself.",
-        `Task: ${request.taskId}`,
-        `Input: ${request.id}`,
-        `Question: ${request.question}`,
-        ...(request.choices.length === 0
-            ? ["Answer type: free text"]
-            : ["Choices:", ...request.choices.map((choice) => `  ${choice.key}: ${choice.label}`)]),
-        ...(request.policy.kind === "required"
-            ? ["Decision policy: user response required; there is no automatic fallback."]
-            : [
-                `Agent recommendation: ${recommendedChoice.key}: ${recommendedChoice.label}`,
-                `Automatic fallback after: ${request.policy.timeoutAt}`
-            ]),
-        `Inspect: yui task input show ${request.id}`,
-        request.choices.length === 0
-            ? `After the user replies: yui task input answer ${request.id} --text "<answer>"`
-            : `After the user chooses: yui task input answer ${request.id} --choice <key>`
-    ].join("\n");
-}
-function skipped(request, reason) {
+function skipped(attention, reason) {
     return {
-        inputRequestId: request.id,
-        taskId: request.taskId,
+        ...attentionIdentity(attention),
         status: "skipped",
         reason
     };
 }
+function attentionIdentity(attention) {
+    if (attention.kind === "input") {
+        return { inputRequestId: attention.request.id, taskId: attention.request.taskId };
+    }
+    if (attention.notification.type === "leader-recovery-failed") {
+        return {
+            recoveryTaskId: attention.notification.taskId,
+            taskId: attention.notification.taskId
+        };
+    }
+    if (attention.notification.type === "leader-stalled") {
+        return {
+            stallTaskId: attention.notification.taskId,
+            taskId: attention.notification.taskId
+        };
+    }
+    return {
+        terminalTaskId: attention.notification.taskId,
+        taskId: attention.notification.taskId
+    };
+}
+function createAttentionPresentation(attention, store) {
+    if (attention.kind === "input") {
+        return createInputRequestOperatorPresentation(attention.request, store.getPresentationContext());
+    }
+    if (attention.notification.type === "leader-recovery-failed") {
+        return createLeaderRecoveryOperatorPresentation(attention.notification);
+    }
+    return attention.notification.type === "leader-stalled"
+        ? createLeaderStallOperatorPresentation(attention.notification)
+        : createTaskTerminalOperatorPresentation(attention.notification);
+}
+function deduplicateAttention(attentions) {
+    const seen = new Set();
+    return attentions.filter((attention) => {
+        const key = attention.kind === "input"
+            ? `input:${attention.request.taskId}:${attention.request.id}`
+            : attention.notification.type === "leader-stalled"
+                ? `stall:${attention.notification.taskId}:${attention.notification.runId}:${attention.notification.progressAt}`
+                : `recovery:${attention.notification.taskId}:${attention.notification.createdAt}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}