@zq-silk/yui 0.15.11 → 0.16.0

package/dist/runtime/taskUsageMetrics.js

@@ -0,0 +1,275 @@
+import { builtinDriverIdForAdapter } from "./builtinAgentDrivers.js";
+import { isRuntimeTokenEvidence, runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
+import { projectSessionTokenObservations, unobservedSessionTokenMetrics } from "./sessionTokenMetrics.js";
+/**
+ * Pure lifetime projection. No transcript reads, collection, persistence,
+ * lifecycle decisions, guessed Run identities, or cumulative counter allocation.
+ */
+export function projectTaskUsageMetrics(input) {
+    const now = input.now ?? new Date();
+    const events = input.events.filter((event) => event.taskId === input.task.id);
+    const observations = events.flatMap((event) => {
+        const observation = runtimeObservationFromTaskEvent(event);
+        return observation !== null
+            && observation.fence.taskId === input.task.id
+            && Date.parse(observation.receivedAt) <= now.getTime()
+            ? [observation] : [];
+    }).sort(compare);
+    const runs = new Map(input.runs.filter((run) => run.taskId === input.task.id).map((run) => [run.id, run]));
+    const inScope = (observation) => {
+        if (input.workItemId === undefined)
+            return true;
+        const run = exactRun(observation, runs);
+        return run?.workItemId === input.workItemId;
+    };
+    const scoped = observations.filter(inScope);
+    const buckets = new Map();
+    for (const observation of observations) {
+        const identity = sessionIdentity(observation);
+        if (identity === null)
+            continue;
+        const key = identityKey(identity);
+        const bucket = buckets.get(key) ?? { identity, observations: [] };
+        bucket.observations.push(observation);
+        buckets.set(key, bucket);
+    }
+    const resourceOwners = new Map();
+    for (const { identity, observations: all } of buckets.values()) {
+        if (!all.some((observation) => !child(observation) && usageAuthority(observation)))
+            continue;
+        const resource = resourceKey(identity);
+        const owners = resourceOwners.get(resource) ?? new Set();
+        owners.add(identity.roleName);
+        resourceOwners.set(resource, owners);
+    }
+    const sessions = [...buckets.values()]
+        .sort((a, b) => identityKey(a.identity).localeCompare(identityKey(b.identity)))
+        .flatMap(({ identity, observations: all }) => {
+        if (!all.some(inScope))
+            return [];
+        const main = all.filter((observation) => !child(observation) && usageAuthority(observation));
+        const evidence = main.filter(isRuntimeTokenEvidence);
+        const metrics = projectSessionTokenObservations(main, identity);
+        let displayedMetrics = input.workItemId === undefined ? metrics : unobservedSessionTokenMetrics(identity);
+        const reasons = [];
+        if (all.some(child))
+            reasons.push("child-usage-overlap-unproven");
+        if (evidence.some(({ payload }) => payload.observationQuality === "partial"
+            || payload.observationQuality === "unavailable"))
+            reasons.push("source-coverage-partial");
+        let tokens = attributableTokens(evidence, metrics);
+        if (input.workItemId !== undefined) {
+            // Establish semantics and request ownership before filtering. Filtering
+            // first could hide a mixed stream or allocate a revised request twice.
+            if (metrics.cumulativeTotal.status !== "observed") {
+                tokens = metric(null, ["session-usage-unavailable"]);
+            }
+            else if (evidence.some(({ payload }) => payload.usage?.semantics === "cumulative-session")) {
+                tokens = metric(null, ["cumulative-not-allocatable-to-work-item"]);
+            }
+            else {
+                const requests = new Map();
+                for (const observation of evidence) {
+                    if (observation.payload.usage?.semantics !== "request-context")
+                        continue;
+                    const key = observation.payload.activityId ?? observation.semanticKey;
+                    requests.set(key, [...(requests.get(key) ?? []), observation]);
+                }
+                const selected = [];
+                for (const versions of requests.values()) {
+                    if (!versions.some(inScope))
+                        continue;
+                    const owners = new Set(versions.map((observation) => exactRun(observation, runs)?.id));
+                    if (owners.size !== 1 || owners.has(undefined) || !versions.every(inScope)) {
+                        reasons.push("request-run-attribution-conflict");
+                    }
+                    else {
+                        selected.push(...versions);
+                    }
+                }
+                displayedMetrics = projectSessionTokenObservations(selected, identity);
+                const subtotal = displayedMetrics.cumulativeTotal;
+                tokens = metric(subtotal.status === "observed" ? subtotal.totalTokens : null, subtotal.status === "observed" ? [] : ["no-attributable-request-usage"]);
+            }
+        }
+        if ((resourceOwners.get(resourceKey(identity))?.size ?? 0) > 1) {
+            tokens = metric(null, ["native-session-role-overlap"]);
+            displayedMetrics = unobservedSessionTokenMetrics(identity);
+        }
+        tokens = metric(tokens.value, [...tokens.reasons, ...reasons]);
+        return [{
+                identity,
+                semantics: [...new Set(evidence.flatMap(({ payload }) => payload.usage === undefined ? [] : [payload.usage.semantics]))].sort(),
+                sources: [...new Set(evidence.map(({ authority, payload }) => payload.observerSource?.sourceId ?? authority))].sort(),
+                observedThrough: all.filter(inScope).at(-1).receivedAt,
+                tokens,
+                metrics: displayedMetrics
+            }];
+    });
+    const reasons = [];
+    if (scoped.some((observation) => sessionIdentity(observation) === null))
+        reasons.push("session-identity-missing");
+    for (const run of runs.values()) {
+        if (input.workItemId !== undefined && run.workItemId !== input.workItemId)
+            continue;
+        if (!observations.some((observation) => exactRun(observation, runs)?.id === run.id
+            && usageAuthority(observation) && isRuntimeTokenEvidence(observation)))
+            reasons.push("run-usage-unobserved");
+    }
+    const tokenValues = sessions.flatMap(({ tokens }) => tokens.value === null ? [] : [tokens.value]);
+    const sum = safeSum(tokenValues);
+    const tokens = metric(tokenValues.length === 0 ? null : sum, [...reasons, ...sessions.flatMap(({ tokens }) => tokens.reasons),
+        ...(sum === null ? ["counter-overflow"] : []),
+        ...(sessions.length === 0 ? ["no-token-evidence"] : [])]);
+    const operations = new Map();
+    for (const observation of observations) {
+        const identity = sessionIdentity(observation);
+        const { nativeTurnId } = observation.fence;
+        if (!usageAuthority(observation) || child(observation) || identity === null || nativeTurnId === undefined
+            || !observation.kind.startsWith("operation.")
+            || observation.payload.operation !== "tool" || observation.payload.operationId === undefined)
+            continue;
+        const key = JSON.stringify([resourceKey(identity), nativeTurnId, observation.payload.operationId]);
+        const versions = operations.get(key) ?? [];
+        versions.push(observation);
+        operations.set(key, versions);
+    }
+    const toolCount = [...operations.values()].filter((versions) => {
+        if (input.workItemId === undefined)
+            return true;
+        const owners = new Set(versions.map((observation) => exactRun(observation, runs)?.id));
+        return owners.size === 1 && !owners.has(undefined) && versions.every(inScope);
+    }).length;
+    return {
+        scope: "task-lifetime", taskId: input.task.id,
+        ...(input.workItemId === undefined ? {} : { workItemId: input.workItemId }),
+        observedThrough: scoped.at(-1)?.receivedAt ?? null,
+        tokens,
+        toolCalls: metric(toolCount === 0 ? null : toolCount, ["tool-history-compacted"]),
+        elapsedSeconds: input.workItemId === undefined
+            ? taskElapsed(input.task, events, now) : metric(null, ["work-item-lifecycle-not-task-elapsed"]),
+        executionSeconds: executionDuration(scoped, now),
+        coverage: {
+            basis: "task-fenced-observations",
+            observedSessions: sessions.length,
+            tokenSessions: tokenValues.length,
+            completeness: "observed-sources-only"
+        },
+        sessions
+    };
+}
+function attributableTokens(evidence, metrics) {
+    const total = metrics.cumulativeTotal;
+    if (total.status !== "observed")
+        return metric(null, ["session-usage-unavailable"]);
+    const cumulative = evidence.filter(({ payload }) => payload.usage?.semantics === "cumulative-session");
+    if (cumulative.length === 0)
+        return metric(total.totalTokens);
+    const first = cumulative[0].payload.usage;
+    const baseline = first.inputTokens + first.outputTokens;
+    if (baseline === 0)
+        return metric(total.totalTokens);
+    // session.started also occurs on resume: it cannot prove a fresh counter.
+    // A nonzero first counter may predate this Task, so exclude it. A single
+    // snapshot does not prove even a zero delta.
+    return cumulative.length < 2
+        ? metric(null, ["nonzero-session-baseline"])
+        : metric(total.totalTokens - baseline, ["nonzero-session-baseline"]);
+}
+function exactRun(observation, runs) {
+    const { fence } = observation;
+    const run = fence.runId === undefined ? undefined : runs.get(fence.runId);
+    if (run === undefined || fence.nativeSessionId === undefined || run.roleName !== fence.roleName
+        || run.effective.agentId !== fence.agentId)
+        return undefined;
+    try {
+        return builtinDriverIdForAdapter(run.effective.adapterId) === fence.driverId ? run : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sessionIdentity({ fence }) {
+    return fence.taskId === undefined || fence.nativeSessionId === undefined ? null : {
+        taskId: fence.taskId, roleName: fence.roleName, agentId: fence.agentId,
+        driverId: fence.driverId, nativeSessionId: fence.nativeSessionId
+    };
+}
+function identityKey(identity) {
+    return JSON.stringify([identity.taskId, identity.roleName, identity.agentId, identity.driverId, identity.nativeSessionId]);
+}
+function resourceKey(identity) {
+    return JSON.stringify([identity.agentId, identity.driverId, identity.nativeSessionId]);
+}
+function child({ fence }) {
+    return fence.continuationId !== undefined || fence.parentContinuationId !== undefined;
+}
+function usageAuthority(observation) {
+    return observation.authority === "provider-structured" || observation.authority === "driver-inferred";
+}
+function compare(left, right) {
+    return left.receivedAt.localeCompare(right.receivedAt)
+        || (left.sequence ?? -1) - (right.sequence ?? -1)
+        || (left.ordinal ?? -1) - (right.ordinal ?? -1)
+        || left.eventId.localeCompare(right.eventId);
+}
+function metric(value, reasons = []) {
+    return {
+        value, status: value === null ? "unknown" : reasons.length === 0 ? "known" : "partial",
+        reasons: [...new Set(reasons)].sort()
+    };
+}
+function safeSum(values) {
+    const sum = values.reduce((a, b) => a + b, 0);
+    return Number.isSafeInteger(sum) && sum >= 0 ? sum : null;
+}
+function taskElapsed(task, events, now) {
+    const terminal = task.status === "completed"
+        || task.status === "cancelled" || task.status === "archived";
+    const cancelledAt = events.filter((event) => event.type === "task.cancelled")
+        .map(({ createdAt }) => createdAt).sort().at(-1);
+    const end = terminal ? task.completedAt ?? task.retiredAt ?? cancelledAt : now.toISOString();
+    const elapsed = end === undefined ? NaN : (Date.parse(end) - Date.parse(task.createdAt)) / 1000;
+    return Number.isFinite(elapsed) && elapsed >= 0
+        ? metric(elapsed) : metric(null, ["task-lifecycle-time-missing"]);
+}
+function executionDuration(observations, now) {
+    const turns = new Map();
+    for (const observation of observations) {
+        const identity = sessionIdentity(observation);
+        const { nativeTurnId } = observation.fence;
+        if (identity === null || nativeTurnId === undefined || child(observation) || !usageAuthority(observation))
+            continue;
+        const resource = resourceKey(identity);
+        const key = JSON.stringify([resource, nativeTurnId]);
+        const turn = turns.get(key) ?? { resource };
+        const time = Date.parse(observation.observedAt ?? observation.receivedAt);
+        if (observation.kind === "turn.accepted")
+            turn.start = Math.min(turn.start ?? time, time);
+        if (["turn.completed", "turn.failed", "turn.cancelled"].includes(observation.kind)) {
+            turn.end = Math.max(turn.end ?? time, time);
+        }
+        turns.set(key, turn);
+    }
+    const intervals = new Map();
+    for (const turn of turns.values()) {
+        if (turn.start === undefined || turn.end === undefined || turn.end < turn.start || turn.end > now.getTime())
+            continue;
+        intervals.set(turn.resource, [...(intervals.get(turn.resource) ?? []), [turn.start, turn.end]]);
+    }
+    let milliseconds = 0;
+    for (const ranges of intervals.values()) {
+        ranges.sort((a, b) => a[0] - b[0]);
+        let end = -Infinity;
+        for (const range of ranges) {
+            milliseconds += Math.max(0, range[1] - Math.max(end, range[0]));
+            end = Math.max(end, range[1]);
+        }
+    }
+    return metric(intervals.size === 0 ? null : milliseconds / 1000, ["native-turn-history-compacted"]);
+}
+/** CLI/audit formatting shares the same metric contract; Web localizes labels. */
+export function formatUsageMetric(metric, suffix = "") {
+    return metric.value === null ? `unknown (${metric.reasons.join(", ")})`
+        : `${metric.value}${suffix}${metric.status === "partial" ? ` (partial: ${metric.reasons.join(", ")})` : ""}`;
+}

package/dist/runtime/tmuxAdapters.js

@@ -1,14 +1,14 @@
 import { randomUUID } from "node:crypto";
-import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
-import { createRuntimeBinding } from "./runtimeBinding.js";
-import { normalizeRuntimeOwner } from "./runtimeOwner.js";
-import { RuntimeHostContentionError, RuntimeHostUnavailableError, promptPushOutcome } from "./ports.js";
+import { fileURLToPath } from "node:url";
 import { providerDeliveryFailureFrom } from "./agentError.js";
+import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostLaunchControl, sendAgentHostRunControl, sendAgentHostSteerControl, waitForAgentHostLaunchAck } from "./agentHost.js";
+import { launchBrokerForHome } from "./launchBroker.js";
 import { toRuntimeLaunchFailure } from "./launchDiagnostics.js";
+import { RuntimeHostContentionError, RuntimeHostUnavailableError, promptPushOutcome } from "./ports.js";
+import { createRuntimeBinding } from "./runtimeBinding.js";
+import { normalizeRuntimeOwner } from "./runtimeOwner.js";
 import { requireSafeIdentity } from "./validation.js";
-import { launchBrokerForHome } from "./launchBroker.js";
-import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostLaunchControl, sendAgentHostRunControl, sendAgentHostSteerControl, waitForAgentHostLaunchAck } from "./agentHost.js";
 const DEFAULT_INACTIVITY_TIMEOUT_MS = 300_000;
 /**
  * Runtime lifecycle adapter for the current tmux host. The returned hostRef is
@@ -656,8 +656,6 @@ async function killRole(tmux, hostId, roleName) {
     await tmux.killRoleAsync(hostId, roleName);
 }
 async function stopExactRole(tmux, hostId, roleName) {
-    if (await probeRoleStatus(tmux, hostId, roleName) !== "running")
-        return;
     try {
         await killRole(tmux, hostId, roleName);
     }

package/dist/scheduler/activeRoleRunDelivery.js

@@ -25,7 +25,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
     for (const task of selectedActiveSchedulerTasks(store, selection, {
         includePlanningDrafts: true
     })) {
-        store.prepareMessageContinuations?.(task.id, now);
+        store.prepareMessageContinuations(task.id, now);
         for (const role of selectedSchedulerRoles(store, task.id, selection)) {
             const run = store.getActiveRun(task.id, role.name);
             if (run === null)
@@ -49,8 +49,20 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
         roleName: role.name,
         runId: run.id
     });
-    const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
+    const sessionSet = store.getTaskRoleSessionSet(task.id, role.name);
     const binding = sessionSet?.providerBinding ?? null;
+    if (binding?.retry !== undefined && (binding.retry.successorRunId === run.id
+        || binding.retry.successorReviewRoundId !== undefined && binding.retry.successorReviewRoundId === run.reviewRoundId)
+        && ["cancelled", "exhausted", "needs-attention"].includes(binding.retry.status)
+        && binding.run?.runId !== run.id) {
+        return failRunDelivery(store, run, now, "runtime-failed", `Scheduled Provider retry ${binding.retry.status}: ${binding.retry.reason ?? "not admitted"}`);
+    }
+    if (binding?.retry?.status === "waiting"
+        && (binding.retry.successorRunId === run.id || binding.retry.successorReviewRoundId !== undefined
+            && binding.retry.successorReviewRoundId === run.reviewRoundId)
+        && now.getTime() < Date.parse(binding.retry.nextEligibleAt)) {
+        return { ...base, status: "skipped", reason: "not-ready" };
+    }
     const observedRun = binding?.run ?? null;
     const initialAttemptId = formatRunReceiptId(task.id, run.id);
     const currentProviderTurn = managedProviderTurnId(observedRun) === run.id ? observedRun : null;
@@ -85,7 +97,7 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
         // report. Keep the exact input fenced; never submit it again.
         return { ...base, status: "skipped", reason: "delivery-uncertain", error: reason };
     }
-    const lastSubmitError = (store.listEvents?.(task.id) ?? []).filter((event) => event.type === "runtime.agent-error" && event.payload.runId === run.id
+    const lastSubmitError = store.listEvents(task.id).filter((event) => event.type === "runtime.agent-error" && event.payload.runId === run.id
         && event.payload.roleName === role.name && event.payload.phase === "turn-submit").at(-1);
     if (currentProviderTurn === null && lastSubmitError?.payload.inputDisposition === "unknown") {
         return { ...base, status: "skipped", reason: "delivery-uncertain", error: lastSubmitError.payload.message };
@@ -102,7 +114,7 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
     // The first attempted admission may already have opened this fixed native
     // Session. A busy retry resumes it; it does not repeat the original launch.
     const preparedHere = existingSession?.nativeSessionId !== undefined
-        && (store.listEvents?.(task.id) ?? []).some((event) => event.type === "run.session-prepared"
+        && store.listEvents(task.id).some((event) => event.type === "run.session-prepared"
             && event.payload.runId === run.id && event.payload.nativeSessionId === existingSession.nativeSessionId);
     const mode = (currentProviderTurn?.status === "deferred" || preparedHere) && existingSession?.nativeSessionId !== undefined
         ? "resume" : run.mode;
@@ -171,7 +183,7 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
         }
         if (outcome.status === "busy" || outcome.status === "unavailable") {
             if (outcome.status === "busy" && outcome.failure?.inputDisposition === "not-accepted") {
-                store.recordAgentError?.({ taskId: task.id, roleName: role.name, runId: run.id,
+                store.recordAgentError({ taskId: task.id, roleName: role.name, runId: run.id,
                     source: "host", phase: "turn-submit", message: outcome.failure.detail,
                     raw: outcome.failure.raw ?? serializeAgentErrorRaw(outcome.failure),
                     inputDisposition: "not-accepted", ...providerDeliveryFailureFacts(outcome.failure),
@@ -196,7 +208,7 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
                 : formatProviderDeliveryFailure(failure);
             // This path is the common Provider write failure and previously left no
             // durable fact at all, so the cause was unrecoverable after the fact.
-            store.recordAgentError?.({
+            store.recordAgentError({
                 taskId: task.id,
                 roleName: role.name,
                 runId: run.id,
@@ -226,7 +238,7 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
         const message = error instanceof Error ? error.message : String(error);
         // Preserve the structured cause alongside the readable diagnosis.
         const causeName = innermostCauseName(error);
-        store.recordAgentError?.({
+        store.recordAgentError({
             taskId: task.id,
             roleName: role.name,
             runId: run.id,

package/dist/scheduler/leaderWakeupProcessor.js

@@ -3,6 +3,10 @@ import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { hasImmediateWakeReason } from "./wakeReason.js";
+import { providerRetryPending } from "../runtime/providerRetry.js";
+import { RuntimeLaunchError } from "../runtime/ports.js";
+import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
+import { redactAgentErrorText } from "../runtime/agentError.js";
 export const LEADER_WAKE_AGGREGATION_MS = 60_000;
 /** Deliver a durable mailbox notification, not an implicit execution assignment.
  * Acceptance settles only its claimed batch; no Agent report is required.
@@ -28,12 +32,16 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             results.push({ ...base, status: "skipped", reason: "aggregating" });
             continue;
         }
-        if (task.status === "draft" && store.prepareDraftPlanning?.(task.id, now)) {
+        if (task.status === "draft" && store.prepareDraftPlanning(task.id, now)) {
             results.push({ ...base, status: "skipped", reason: "not-ready" });
             continue;
         }
-        const sessions = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
+        const sessions = store.getTaskRoleSessionSet(task.id, role.name);
         const provider = sessions?.providerBinding;
+        if (providerRetryPending(provider)) {
+            results.push({ ...base, status: "skipped", reason: "not-ready" });
+            continue;
+        }
         if (provider?.authority.owner === "human" || provider?.authority.owner === "unknown") {
             results.push({ ...base, status: "skipped", reason: "busy" });
             continue;
@@ -50,13 +58,17 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 ...(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>.`
+                } : notification.disposition === "rejected" ? {
+                    error: `Notification was rejected; inspect yui task wake show ${task.id} ${notification.wakeId}. `
+                        + `After correcting the cause, retry with yui task wake retry ${task.id} ${notification.wakeId} --reason <correction>.`
                 } : {}) });
             continue;
         }
         let attempted = false;
+        let effective = role.effective;
         try {
             const session = store.getRoleSession(task.id, role.name, role.effective.agentId);
-            const effective = session?.status === "active" ? session.effective : role.effective;
+            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.");
             }
@@ -91,12 +103,18 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     : outcome.status === "rejected" ? "rejected"
                         : outcome.status === "pending" ? null : "deferred";
             if (disposition !== null)
-                store.settleLeaderNotification(task.id, notification.attemptId, disposition, now, outcome.failure?.detail);
+                store.settleLeaderNotification(task.id, notification.attemptId, disposition, now, outcome.failure?.detail, { effective, raw: outcome.failure?.raw ?? outcome.failure?.detail ?? `Notification ${disposition}.`,
+                    phase: "turn-submit" });
             results.push({ ...base, status: accepted ? "dispatched" : "skipped", reason: accepted ? undefined : "not-ready" });
         }
         catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            store.settleLeaderNotification(task.id, notification.attemptId, attempted ? "unknown" : "deferred", now, detail);
+            const detail = redactAgentErrorText(error instanceof Error ? error.message : String(error));
+            // Match explicit AgentRun admission: only positive, typed backpressure
+            // permits another automatic launch. A config/auth/executable failure
+            // needs correction; an exception after submit cannot authorize replay.
+            const retryable = error instanceof RuntimeLifecycleBusyError
+                || (error instanceof RuntimeLaunchError && error.retryable);
+            store.settleLeaderNotification(task.id, notification.attemptId, attempted ? "unknown" : retryable ? "deferred" : "rejected", now, detail, { effective, raw: detail, phase: attempted ? "turn-submit" : "session-start" });
             results.push({ ...base, status: "failed", reason: "not-ready", error: detail });
         }
         finally {

package/dist/scheduler/operatorEvent.js

@@ -1,31 +1,23 @@
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createTaskEvent } from "../event/taskEvent.js";
-import { queueLeaderWakeup } from "./wakeupQueue.js";
 export const LEADER_ATTENTION_REQUIRED_EVENT = "leader.attention-required";
-/** The sole Task-event boundary into the global Operator mailbox. */
-export function enqueueOperatorEvent(store, event, reason, now) {
-    if (store.getTask?.(event.taskId)?.status === "archived")
+/** One event, one supervisor signal; the Leader wake is this mailbox's projection. */
+export function enqueueSupervisorEvent(store, event, recipient, reason, now) {
+    if (store.getTask(event.taskId)?.status === "archived")
         return;
-    enqueueWork(store, { kind: "operator" }, reason, now, [
+    const target = recipient === "operator" ? { kind: "operator" }
+        : { kind: "role", taskId: event.taskId, roleName: "leader" };
+    enqueueWork(store, target, reason, now, [
         { type: "event", taskId: event.taskId, id: event.id }
-    ], {
-        source: "task-event",
-        dedupeKey: `operator-event:${event.taskId}:${event.id}`
-    });
+    ], { source: "task-event", dedupeKey: `${recipient}-event:${event.taskId}:${event.id}` });
+}
+/** The sole Task-event boundary into the global Operator mailbox. */
+export function enqueueOperatorEvent(store, event, reason, now) {
+    enqueueSupervisorEvent(store, event, "operator", reason, now);
 }
 /** Routes one Role fact to its supervisor without exposing Provider details to Operator code. */
 export function routeRoleEvent(store, event, roleName, reason, now) {
-    if (store.getTask?.(event.taskId)?.status === "archived")
-        return;
-    if (roleName === "leader") {
-        enqueueOperatorEvent(store, event, reason, now);
-        return;
-    }
-    enqueueWork(store, { kind: "role", taskId: event.taskId, roleName: "leader" }, reason, now, [{ type: "event", taskId: event.taskId, id: event.id }], {
-        source: "task-event",
-        dedupeKey: `leader-event:${event.taskId}:${event.id}`
-    });
-    queueLeaderWakeup(store, event.taskId, reason, now);
+    enqueueSupervisorEvent(store, event, roleName === "leader" ? "operator" : "leader", reason, now);
 }
 /** Records the semantic boundary used when a Leader can no longer continue. */
 export function recordLeaderAttentionRequired(store, input) {

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -26,7 +26,7 @@ export async function processOperatorInputNotifications(store, delivery, selecti
                 ? [{ kind: "input", request }]
                 : [];
         }
-        if (ref.type !== "event" || store.listEvents === undefined)
+        if (ref.type !== "event")
             return [];
         const event = store.listEvents(ref.taskId).find(({ id }) => id === ref.id);
         return event === undefined ? [] : [{ kind: "event", event }];

package/dist/scheduler/ports.js

@@ -1,5 +1,5 @@
-import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 import { taskOwnsManagedWorkspace } from "../task/task.js";
+import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 /**
  * Whether the Task's workspace state admits a launch.
  *
@@ -72,14 +72,11 @@ export function selectedActiveSchedulerTasks(store, selection, options) {
         return planningDrafts && hasActivePlanningRun(store, task);
     };
     if (selection === undefined || selection.full) {
-        const indexedTaskIds = store.listActiveTaskIds?.();
-        if (indexedTaskIds === undefined) {
-            return store.listTasks().filter((task) => (admits(task) && !selection?.blockedTaskIds?.has(task.id)));
-        }
+        const indexedTaskIds = store.listActiveTaskIds();
         // 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, ...store.listPlanningDraftTaskIds()]
             : [...indexedTaskIds];
         const seen = new Set();
         return taskIds.flatMap((taskId) => {
@@ -106,9 +103,9 @@ export function selectedActiveSchedulerTasks(store, selection, options) {
 function hasActivePlanningRun(store, task) {
     if (task.status !== "draft")
         return false;
-    const roles = store.listRoles?.(task.id) ?? [];
+    const roles = store.listRoles(task.id);
     return roles.some((role) => {
-        const run = store.getActiveRun?.(task.id, role.name) ?? null;
+        const run = store.getActiveRun(task.id, role.name);
         return run !== null
             && run.status === "active"
             && isSchedulerPlanningDraft(task, run.purpose);

package/dist/scheduler/roleRunLiveness.js

@@ -1,6 +1,6 @@
-import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
-import { formatTaskRecordReference } from "../task/taskRecordReference.js";
 import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
+import { formatTaskRecordReference } from "../task/taskRecordReference.js";
+import { selectedActiveSchedulerTasks, selectedSchedulerRoles } from "./ports.js";
 import { currentRoleRunProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
 /**
  * Lightweight liveness only. Pane/process loss is runtime-health evidence,
@@ -85,7 +85,7 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
             }
         }
     }
-    for (const { task, role, run, session, inspection } of eligible) {
+    for (const { task, role, run, session } of eligible) {
         const status = batchSnapshot.statuses.get(`${task.id}\0${role.name}`);
         if (status === undefined)
             throw new Error("Role liveness snapshot is incomplete.");
@@ -93,7 +93,7 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
             continue;
         const hostExit = batchSnapshot.hostExits.get(`${task.id}\0${role.name}`);
         if (hostExit !== undefined) {
-            store.saveRoleHostExitObservation?.({
+            store.saveRoleHostExitObservation({
                 taskId: task.id,
                 roleName: role.name,
                 runId: run.id,