@zq-silk/yui 2.5.0 → 2.7.1

package/dist/nativeAgent/session/backends.js

@@ -1,4 +1,4 @@
-import Database from 'better-sqlite3';
+import Database from "../../sqlite/driver.js";
 import { randomUUID } from 'node:crypto';
 import { isAbsolute, resolve } from 'node:path';
 import { existsSync, lstatSync } from 'node:fs';

package/dist/observability/runtimeIdentity.js

@@ -12,7 +12,7 @@ import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { join } from "node:path";
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "../storage/storageVersions.js";
 import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";

package/dist/resources/sqliteResourceRegistry.js

@@ -13,7 +13,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { validateSqliteSchema } from "../storage/sqliteSchema.js";
 import { emptyResourceRegistry, parseResourceRegistryState } from "./resourceRegistry.js";
 import { RESOURCE_REGISTRY_SCHEMA_VERSION } from "./resourceTypes.js";

package/dist/runtime/agentHost.js

@@ -93,6 +93,9 @@ export async function runAgentHost(input) {
     let activeRunPayload;
     let lastTerminalPayload;
     let lastTerminal;
+    // One exact direct Turn witnessed by this Endpoint under its original fence.
+    // This is recovery evidence, never ownership of the Desktop client's input.
+    let directObservation;
     let activeRunAttemptId;
     let activeNativeTurnId;
     let codexClientAttachedAt;
@@ -166,6 +169,7 @@ export async function runAgentHost(input) {
     const handleStarted = (started, observedPayload = sessionPayload) => {
         if (started.clientOwned || observedPayload === undefined)
             return;
+        const observedAuthority = authority === undefined ? undefined : { ...authority };
         updateSnapshot(hostSnapshot("busy", {
             adapterId: observedPayload.providerControl?.adapterId,
             processInstanceId: session?.processInstanceId,
@@ -175,6 +179,22 @@ export async function runAgentHost(input) {
             ...authorityFields()
         }));
         void enqueueSerialized(async () => {
+            // Desktop can start another Turn before the Controller's periodic pass.
+            // Persist the previous exact terminal before replacing its bounded cache
+            // or publishing the new start. Never clear the newer native writer.
+            const previous = directObservation;
+            if (previous?.terminal !== undefined && authority !== undefined
+                && sameProviderAuthorityFence(previous.authority, authority)
+                && previous.started.nativeSessionId === session?.nativeSessionId) {
+                await publishStructuredProviderTerminal({
+                    home: input.home, environment: previous.payload.environment, terminal: previous.terminal
+                });
+            }
+            if (session !== undefined && started.nativeSessionId === session.nativeSessionId
+                && started.conversationId === session.conversationId && observedAuthority !== undefined
+                && authority !== undefined && sameProviderAuthorityFence(observedAuthority, authority)) {
+                directObservation = { started, payload: observedPayload, authority: observedAuthority };
+            }
             await publishStructuredProviderStarted({
                 home: input.home,
                 environment: observedPayload.environment,
@@ -194,6 +214,14 @@ export async function runAgentHost(input) {
             // AgentRun audit record. It has no WorkItem ownership and no managed input
             // fence; the runtime observer records only visible input/output.
             void enqueueSerialized(async () => {
+                const direct = directObservation;
+                if (direct !== undefined && authority !== undefined
+                    && sameProviderAuthorityFence(direct.authority, authority)
+                    && direct.started.nativeSessionId === terminal.nativeSessionId
+                    && direct.started.conversationId === terminal.conversationId
+                    && direct.started.nativeTurnId === terminal.nativeTurnId) {
+                    direct.terminal = terminal;
+                }
                 await publishStructuredProviderTerminal({
                     home: input.home,
                     environment: busyPayload.environment,
@@ -274,6 +302,7 @@ export async function runAgentHost(input) {
                     conversationId: terminal.conversationId,
                     ...authorityFields()
                 }));
+                signalRoleMailbox(input.home, currentPayload);
                 promptHuman();
             }
             catch (error) {
@@ -621,6 +650,7 @@ export async function runAgentHost(input) {
                 await recordProviderConnection(input.home, next, started.session);
                 lastTerminalPayload = undefined;
                 lastTerminal = undefined;
+                directObservation = undefined;
                 // Recoverable means a later process can rebind this Conversation by
                 // its native id. The Endpoint answers that from the Driver capability
                 // or, where the protocol settles it per connection, from what this
@@ -1157,6 +1187,51 @@ export async function runAgentHost(input) {
             }
             return controlResult("accepted", { ...snapshot, nativeTui: !!nativeTui });
         }
+        if (request.type === "reconcile-turn") {
+            if (session === undefined || session.nativeSessionId !== request.nativeSessionId
+                || authority === undefined || !sameProviderAuthorityFence(authority, request.authority)) {
+                throw new Error("Terminal reconciliation targets a different Session or authority.");
+            }
+            const direct = directObservation;
+            const directMatch = direct?.terminal !== undefined
+                && request.nativeTurnId !== undefined
+                && request.attemptId === `direct:${request.nativeTurnId}`
+                && direct.started.nativeTurnId === request.nativeTurnId
+                && direct.started.nativeSessionId === request.nativeSessionId
+                && sameProviderAuthorityFence(direct.authority, request.authority);
+            const terminal = directMatch ? direct.terminal : lastTerminal;
+            const terminalPayload = directMatch ? direct.payload : lastTerminalPayload;
+            if (terminal === undefined || terminalPayload === undefined
+                || terminal.nativeSessionId !== request.nativeSessionId
+                || !directMatch && (terminal.clientOwned !== true || terminal.attemptId !== request.attemptId)
+                || request.nativeTurnId !== undefined && terminal.nativeTurnId !== request.nativeTurnId) {
+                return { ...controlResult("status", snapshot), reconciliation: "unobserved" };
+            }
+            // Serialize with submission/terminal persistence. The original Host and
+            // original launch envelope remain the observer, including the full result.
+            await enqueueSerialized(async () => {
+                if (session?.nativeSessionId !== request.nativeSessionId || authority === undefined
+                    || !sameProviderAuthorityFence(authority, request.authority)
+                    || directMatch && directObservation !== direct) {
+                    throw new Error("Session changed before terminal reconciliation.");
+                }
+                await publishStructuredProviderTerminal({
+                    home: input.home, environment: terminalPayload.environment, terminal
+                });
+                if (!directMatch && activeRunAttemptId === terminal.attemptId) {
+                    activeRunPayload = undefined;
+                    activeRunAttemptId = undefined;
+                    activeNativeTurnId = undefined;
+                    updateSnapshot(hostSnapshot(session.inspect().activeNativeTurnId === undefined ? "idle" : "busy", {
+                        adapterId: session.adapterId, processInstanceId: session.processInstanceId,
+                        nativeSessionId: session.nativeSessionId, conversationId: session.conversationId,
+                        ...authorityFields()
+                    }));
+                }
+                signalRoleMailbox(input.home, terminalPayload);
+            });
+            return { ...controlResult("status", snapshot), reconciliation: "terminal-republished" };
+        }
         if (request.type === "status") {
             // Read the Agent's configuration at answer time, not from the stored
             // snapshot. The Agent may have changed it since the last state
@@ -1461,6 +1536,11 @@ export async function inspectAgentHost(input) {
     });
     return result.snapshot;
 }
+export async function reconcileAgentHostTurn(input) {
+    // Periodic observation must not hold the scheduler behind an unavailable Host.
+    // A timeout is only an observation failure, never permission to submit again.
+    return exchangeAgentHostControl(agentHostControlSocketPath(input), input.control, 1_000);
+}
 export async function waitForAgentHostLaunchAck(input) {
     const deadline = Date.now() + (input.timeoutMs ?? AGENT_HOST_READY_TIMEOUT_MS);
     let lastError;
@@ -1616,7 +1696,7 @@ export async function openAgentHostControl(home, payload, snapshot, dispatch) {
                         ...result,
                         snapshot: {
                             ...result.snapshot,
-                            ...(payload.environment.YUI_SESSION_SCOPE !== "task" ? {} : {
+                            ...(!["task", "global"].includes(payload.environment.YUI_SESSION_SCOPE ?? "") ? {} : {
                                 eventDelivery: structuredProviderEventDelivery(home, payload.environment, result.snapshot.nativeSessionId)
                             })
                         }
@@ -1691,7 +1771,8 @@ function boundControlResponse(result) {
     // visible through an otherwise successful status request.
     result = {
         ...controlResult(result.outcome, validateSnapshot(result.snapshot), result.failure === undefined ? undefined : providerDeliveryFailure(result.failure)),
-        ...(result.cancellation === undefined ? {} : { cancellation: result.cancellation })
+        ...(result.cancellation === undefined ? {} : { cancellation: result.cancellation }),
+        ...(result.reconciliation === undefined ? {} : { reconciliation: result.reconciliation })
     };
     if (withinControlBound(result))
         return result;
@@ -1709,29 +1790,29 @@ function boundControlResponse(result) {
     };
     // Never make an omitted option list look like a complete empty enumeration.
     if (result.snapshot.runConfiguration?.status === "observed") {
-        result = controlResult(result.outcome, validateSnapshot({
-            ...result.snapshot,
-            runConfiguration: unknownAgentRunConfiguration("The Agent's reported configuration is too large for the Agent Host "
-                + "control response, so it could not be carried in full and none of it "
-                + "is shown rather than part of it.")
-        }), result.failure);
+        result = { ...result, ...controlResult(result.outcome, validateSnapshot({
+                ...result.snapshot,
+                runConfiguration: unknownAgentRunConfiguration("The Agent's reported configuration is too large for the Agent Host "
+                    + "control response, so it could not be carried in full and none of it "
+                    + "is shown rather than part of it.")
+            }), result.failure) };
         if (withinControlBound(result))
             return result;
     }
-    let bounded = controlResult(result.outcome, {
-        ...result.snapshot,
-        ...(result.snapshot.detail === undefined ? {} : { detail: clip(result.snapshot.detail, 1200) })
-    }, result.failure === undefined ? undefined : { ...result.failure, detail: clip(result.failure.detail, 1200) });
+    let bounded = { ...result, ...controlResult(result.outcome, {
+            ...result.snapshot,
+            ...(result.snapshot.detail === undefined ? {} : { detail: clip(result.snapshot.detail, 1200) })
+        }, result.failure === undefined ? undefined : { ...result.failure, detail: clip(result.failure.detail, 1200) }) };
     const raw = bounded.failure?.raw;
     if (withinControlBound(bounded) || raw === undefined)
         return bounded;
     let chars = raw.length;
     while (!withinControlBound(bounded) && chars > 0) {
         chars = Math.floor(chars / 2);
-        bounded = controlResult(bounded.outcome, bounded.snapshot, {
-            ...bounded.failure,
-            raw: clip(raw, chars)
-        });
+        bounded = { ...bounded, ...controlResult(bounded.outcome, bounded.snapshot, {
+                ...bounded.failure,
+                raw: clip(raw, chars)
+            }) };
     }
     return bounded;
 }
@@ -1764,6 +1845,14 @@ function validateControl(control) {
     }
     if (control.type === "status")
         return Object.freeze({ ...control });
+    if (control.type === "reconcile-turn") {
+        validateIdentity(control.nativeSessionId, "native Session id");
+        validateIdentity(control.attemptId, "Provider input attempt id");
+        if (control.nativeTurnId !== undefined)
+            validateIdentity(control.nativeTurnId, "native Turn id");
+        validateProviderAuthorityFence(control.authority);
+        return Object.freeze({ ...control });
+    }
     if (control.type === "native-open" || control.type === "native-respond" || control.type === "native-model") {
         validateIdentity(control.nativeSessionId, "native Session id");
         if (control.type === "native-model" && (typeof control.model !== "string"

package/dist/runtime/builtinAgentErrorMappers.js

@@ -26,7 +26,7 @@ function mapClaudeDisplayError(input) {
 }
 /** Provider-specific Codex failure recognition. */
 export function mapCodexAgentError(input) {
-    return withTransientEvidence(mapCodexDisplayError(input), input);
+    return withTransientEvidence(mapCodexDisplayError(input), input, true);
 }
 function mapCodexDisplayError(input) {
     const text = `${input.message}\n${input.raw}`;
@@ -208,7 +208,7 @@ function sessionUnavailable(code) {
 }
 /** Replay qualification is stricter than the readable, best-effort category.
  * Never promote a number occurring in provider prose to submission safety. */
-function structuredTransientError(input) {
+function structuredTransientError(input, codex) {
     if (/insufficient[_ -]quota|quota.{0,25}(exhaust|exceed)|billing[_ -]hard[_ -]limit|usageLimitExceeded|credits?.{0,20}(exhaust|insufficient)/iu.test(`${input.message}\n${input.raw}`))
         return { category: "access", code: "provider.quota-exhausted", retryable: false };
     const nodes = [];
@@ -228,7 +228,8 @@ function structuredTransientError(input) {
     catch { /* Display classification may still use prose. */ }
     const codes = nodes.flatMap(n => [n.code, n.type, n.error, n.codexErrorInfo]).filter(v => typeof v === "string");
     if (codes.some(c => ["authentication_error", "permission_error", "invalid_api_key", "invalid_model",
-        "model_not_found", "usage_limit_exceeded", "insufficient_quota"].includes(c))) {
+        "model_not_found", "usage_limit_exceeded", "insufficient_quota"].includes(c))
+        || codex && nodes.some(n => ["usageLimitExceeded", "unauthorized", "badRequest"].includes(String(n.codexErrorInfo)))) {
         return { category: "access", code: "provider.access-denied", retryable: false };
     }
     const statuses = nodes.flatMap(n => [n.httpStatusCode, n.statusCode, n.status]).filter(v => typeof v === "number");
@@ -240,6 +241,9 @@ function structuredTransientError(input) {
     if (statuses.includes(429) || codes.includes("rate_limit_error") || nativeCode === "rate_limit_error") {
         result = recoverable("rate-limit", "provider.rate-limit");
     }
+    else if (codex && nodes.some(n => n.codexErrorInfo === "serverOverloaded")) {
+        result = recoverable("availability", "provider.model-capacity");
+    }
     else if (statuses.some(s => [500, 502, 503, 504].includes(s))
         || codes.some(c => ["server_error", "overloaded_error"].includes(c))
         || ["server_error", "overloaded_error"].includes(nativeCode)) {
@@ -277,8 +281,8 @@ function structuredTransientError(input) {
 }
 /** Add positive evidence without renaming established diagnostics or letting
  * a transient nested cause override a known fatal Session/request failure. */
-function withTransientEvidence(base, input) {
-    const evidence = structuredTransientError(input);
+function withTransientEvidence(base, input, codex = false) {
+    const evidence = structuredTransientError(input, codex);
     if (evidence === undefined)
         return base;
     const possiblyTransient = ["rate-limit", "availability", "transport", "unknown"].includes(base.category);

package/dist/runtime/providerRetry.js

@@ -3,6 +3,44 @@ export const PROVIDER_RETRY_BUDGET_MS = 600_000;
 export function providerRetryPending(binding) {
     return binding?.retry?.status === "waiting" || binding?.retry?.status === "in-flight";
 }
+/** An explicit Run retry can carry exact failed-input proof even when the
+ * error did not qualify for automation. This does not grant automatic replay:
+ * the shared admission and native latest-Turn/quiescence checks still apply. */
+export function providerRunRetry(binding, runId, at) {
+    const turn = binding.run;
+    const nativeSessionId = binding.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId;
+    if (turn?.runId !== runId || !["failed", "rejected", "deferred"].includes(turn.status)
+        || binding.authority.owner !== "controller" || turn.authorityEpoch !== binding.authority.epoch
+        || nativeSessionId === undefined)
+        return undefined;
+    const previous = binding.retry;
+    if (previous?.previousRunId === runId && previous.status !== "recovered"
+        && previous.failedAttemptId === turn.attemptId
+        && previous.authorityEpoch === binding.authority.epoch
+        && previous.nativeSessionId === nativeSessionId)
+        return previous;
+    const failure = turn.failure;
+    if (turn.status !== "failed" || turn.nativeTurnId === undefined || turn.input === undefined
+        || turn.retrySupported !== true || failure?.error.inputDisposition !== "accepted"
+        || failure.error.sessionDisposition !== "recoverable")
+        return undefined;
+    // A manual attempt can cancel automation when its error changes character.
+    // Refresh its failed-Turn proof without granting the same input a new budget.
+    const continuing = previous?.status !== "recovered" && previous?.currentAttemptId === turn.attemptId
+        && previous.authorityEpoch === binding.authority.epoch && previous.nativeSessionId === nativeSessionId;
+    return {
+        policyVersion: 1, chainId: continuing ? previous.chainId : turn.attemptId, status: "waiting",
+        input: continuing ? previous.input : turn.input, nativeSessionId, authorityEpoch: binding.authority.epoch,
+        attempts: continuing ? previous.attempts : 0,
+        transportSequence: continuing ? previous.transportSequence : 0,
+        startedAt: continuing ? previous.startedAt : iso(at), intentAt: iso(at),
+        deadline: continuing ? previous.deadline : iso(at + PROVIDER_RETRY_BUDGET_MS),
+        nextEligibleAt: iso(at), updatedAt: iso(at),
+        failedAttemptId: turn.attemptId, failureAttemptId: turn.attemptId,
+        failedNativeTurnId: turn.nativeTurnId, previousRunId: runId,
+        failureRef: failure.ref, error: failure.error, successorAutomatic: false
+    };
+}
 /** Called only in the transaction recording the exact failed/rejected input. */
 export function recordProviderFailure(binding, input) {
     let turn = binding.run;

package/dist/runtime/taskSessions.js

@@ -0,0 +1,240 @@
+import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
+import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { projectRuntimeTaskEvents, classifyRuntimeHealth } from "../runtime/runtimeProjection.js";
+import { DEFAULT_RUNTIME_HEALTH_POLICY } from "../runtime/runtimeHealthPolicy.js";
+import { providerRetryProjection } from "../runtime/providerRetry.js";
+/** Read-only presentation of the selected native connections, never an AgentRun
+ * count. Foreground facts are fenced to the exact input; retained continuations
+ * stay attached to their original input and are not counted as extra Sessions.
+ * No live probe, timers, persistence or recovery actions are introduced here. */
+export function projectTaskSessions(input) {
+    const policy = input.policy ?? DEFAULT_RUNTIME_HEALTH_POLICY;
+    const sessions = [];
+    const seen = new Map();
+    const selectedIdentities = new Set();
+    const observationIdentity = (fence) => JSON.stringify([fence.roleName, fence.agentId, fence.driverId, fence.nativeSessionId]);
+    const observations = input.events.map(event => ({ event, observation: runtimeObservationFromTaskEvent(event) }))
+        .filter(entry => entry.event.taskId === input.taskId && entry.observation?.fence.taskId === input.taskId);
+    for (const set of input.sessionSets) {
+        if (set.owner.scope !== "task" || set.owner.taskId !== input.taskId)
+            continue;
+        const session = set.sessions[set.activeAgentId];
+        const binding = set.providerBinding;
+        const conversation = binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch && c.status === "current");
+        // Replacement can leave an empty set. That is absence, not uncertain
+        // execution; retained child facts are still discovered below.
+        if (!session && !conversation && !binding?.run)
+            continue;
+        const nativeSessionId = session?.nativeSessionId ?? conversation?.conversationId ?? null;
+        const identity = JSON.stringify([binding?.providerNamespace ?? session?.adapterId,
+            binding?.accountScope ?? set.activeAgentId, nativeSessionId ?? set.owner.roleName]);
+        const prior = seen.get(identity);
+        if (prior !== undefined) {
+            if (sessions[prior].roleName !== set.owner.roleName)
+                sessions[prior] = {
+                    ...sessions[prior], group: "unknown", reason: "Multiple Roles name this native Session; inspect ownership."
+                };
+            continue;
+        }
+        seen.set(identity, sessions.length);
+        const turn = binding?.run;
+        let driverId = null;
+        if (session) {
+            try {
+                driverId = builtinDriverIdForAdapter(session.adapterId);
+            }
+            catch { /* Unsupported native observation remains explicitly unknown. */ }
+        }
+        const row = {
+            taskId: input.taskId, roleName: set.owner.roleName, agentId: set.activeAgentId,
+            driverId,
+            nativeSessionId, attemptId: turn?.attemptId ?? null, nativeTurnId: turn?.nativeTurnId ?? null,
+            runId: turn?.runId ?? null, group: "unknown", reason: "Current native input is not observable.",
+            layer: null, lastActivityAt: null, semanticProgressAt: input.semanticProgressAt ?? null,
+            sourceUpdatedAt: turn?.updatedAt ?? session?.updatedAt ?? set.updatedAt,
+            waitingReason: null, operations: [], background: []
+        };
+        if (!session || driverId === null) {
+            sessions.push(row);
+            continue;
+        }
+        const fence = { taskId: input.taskId, roleName: set.owner.roleName,
+            agentId: session.agentId, driverId, nativeSessionId: session.nativeSessionId };
+        selectedIdentities.add(observationIdentity(fence));
+        const sessionFacts = observations.filter(({ observation }) => Object.entries(fence).every(([key, value]) => observation.fence[key] === value));
+        // Each Run's continuation fold has its own authority. Foreground operations
+        // from older inputs must not make the current input look active.
+        const groups = new Map();
+        for (const { event, observation } of sessionFacts) {
+            const runId = observation.fence.runId;
+            const group = groups.get(runId) ?? [];
+            group.push(event);
+            groups.set(runId, group);
+        }
+        const background = backgroundForRuns(fence, session.createdAt, groups);
+        if (!binding || !conversation || conversation.conversationId !== session.nativeSessionId) {
+            sessions.push({ ...row, background });
+            continue;
+        }
+        if (!turn) {
+            const sessionEvents = sessionFacts.filter(({ observation }) => {
+                const f = observation.fence;
+                return f.runId === undefined && f.nativeTurnId === undefined
+                    && f.receiptId === undefined && f.continuationId === undefined;
+            }).map(entry => entry.event);
+            const projection = projectRuntimeTaskEvents(fence, session.createdAt, sessionEvents);
+            const ready = session.status !== "ended" && projection.session === "ready"
+                && projection.host !== "exited" && projection.run === "none"
+                && projection.observer.status !== "unavailable" && projection.observer.status !== "degraded"
+                && projection.goal !== "active" && binding.goal?.status !== "active"
+                && Object.keys(projection.operations).length === 0;
+            sessions.push({ ...row, background, ...(background.length ? {
+                    group: "background", reason: "Retained background execution is not settled."
+                } : session.status === "ended" || projection.session === "ended" ? {
+                    group: "stopped", reason: "The selected Session ended with no submitted native input."
+                } : ready ? {
+                    group: "idle", reason: "The selected Session is ready with no submitted native input."
+                } : {}) });
+            continue;
+        }
+        const exactEvents = sessionFacts.filter(({ observation }) => {
+            const observed = observation;
+            const f = observed.fence;
+            if (f.continuationId !== undefined || f.runId !== turn.runId)
+                return false;
+            if (f.receiptId === undefined && f.nativeTurnId === undefined
+                && ["host.observed", "session.ended", "session.failed", "observer.health"].includes(observed.kind)) {
+                return observed.receivedAt >= turn.submittedAt;
+            }
+            if (f.receiptId !== undefined && f.receiptId !== turn.attemptId)
+                return false;
+            if (f.nativeTurnId !== undefined && f.nativeTurnId !== turn.nativeTurnId)
+                return false;
+            return f.receiptId === turn.attemptId
+                || (turn.nativeTurnId !== undefined && f.nativeTurnId === turn.nativeTurnId);
+        }).map(entry => entry.event);
+        const projection = projectRuntimeTaskEvents({
+            ...fence, ...(turn.runId ? { runId: turn.runId } : {}),
+            receiptId: turn.attemptId, ...(turn.nativeTurnId ? { nativeTurnId: turn.nativeTurnId } : {})
+        }, turn.submittedAt, exactEvents);
+        const health = classifyRuntimeHealth({ projection, now: input.now, policy,
+            semanticProgressAt: input.semanticProgressAt ?? turn.submittedAt });
+        const retry = providerRetryProjection(binding);
+        let group;
+        let reason = health.reason;
+        if (turn.status === "delivery-unknown") {
+            group = "unknown";
+            reason = "Original input delivery is unknown; do not replay it.";
+        }
+        else if (session.status === "ended") {
+            group = background.length ? "background" : "stopped";
+            reason = "The selected Session ended; Task acceptance and retained background execution are separate.";
+        }
+        else if (retry?.status === "waiting") {
+            group = "waiting";
+            reason = `Controller-owned Provider retry waiting (${retry.attempts}/${retry.limit}); next eligible ${retry.nextEligibleAt}. Existing work is preserved.`;
+        }
+        else if (["failed", "cancelled", "rejected"].includes(turn.status)) {
+            group = background.length ? "background" : "stopped";
+            reason = turn.terminalReason ?? "The selected native execution stopped; Task acceptance is separate.";
+        }
+        else if (turn.status === "completed") {
+            group = background.length ? "background" : "idle";
+            reason = background.length ? "Main Turn ended; background execution remains unsettled."
+                : "The native Turn ended; this is not Task completion.";
+        }
+        else if (turn.status !== "accepted") {
+            group = "waiting";
+            reason = "Waiting for native input acceptance.";
+        }
+        else if (projection.run === "waiting") {
+            group = "waiting";
+        }
+        else if (["broken", "stopped"].includes(health.layer)) {
+            group = "stopped";
+        }
+        else if (["completed", "failed", "cancelled"].includes(projection.run)) {
+            group = "unknown";
+            reason = "Native terminal and current input binding disagree; inspect the exact original input.";
+        }
+        else if (projection.observer.status === "unavailable") {
+            group = "unknown";
+        }
+        else if (health.layer === "diagnostic-needed") {
+            group = "diagnostic";
+        }
+        else if (health.runtimeIdleMs < policy.quietAfterMs && projection.activity.kind !== "provider") {
+            group = "active";
+        }
+        else {
+            group = "quiet";
+            reason = "Accepted input has no recent structured activity; silence is not a proven deadlock.";
+        }
+        sessions.push({ ...row, group, reason, layer: health.layer, background,
+            lastActivityAt: projection.lastRuntimeActivityAt ?? null,
+            waitingReason: projection.waitingReason ?? null, operations: health.activeOperations });
+    }
+    // Retained, exactly fenced child observations can outlive a selected Session.
+    // Do not revive old foreground Turns or enumerate historical Sessions: only
+    // identities with still-unsettled child facts enter this current projection.
+    const retained = new Map();
+    for (const entry of observations) {
+        const fence = entry.observation.fence;
+        const key = observationIdentity(fence);
+        if (!fence.nativeSessionId || selectedIdentities.has(key))
+            continue;
+        const group = retained.get(key) ?? [];
+        group.push(entry);
+        retained.set(key, group);
+    }
+    for (const group of retained.values()) {
+        const first = group[0].observation;
+        const fence = first.fence;
+        const runs = new Map();
+        for (const entry of group) {
+            const runId = entry.observation.fence.runId;
+            const events = runs.get(runId) ?? [];
+            events.push(entry.event);
+            runs.set(runId, events);
+        }
+        const background = backgroundForRuns({
+            taskId: input.taskId, roleName: fence.roleName, agentId: fence.agentId,
+            driverId: fence.driverId, nativeSessionId: fence.nativeSessionId
+        }, first.receivedAt, runs);
+        if (!background.length)
+            continue;
+        sessions.push({
+            taskId: input.taskId, roleName: fence.roleName, agentId: fence.agentId,
+            driverId: fence.driverId,
+            nativeSessionId: fence.nativeSessionId, attemptId: null, nativeTurnId: null, runId: null,
+            group: "background", reason: "Retained child observations from a non-selected native Session; foreground execution is not inferred.",
+            layer: null, lastActivityAt: group.at(-1).observation.receivedAt,
+            semanticProgressAt: null, sourceUpdatedAt: group.at(-1).observation.receivedAt,
+            waitingReason: null, operations: [], background
+        });
+    }
+    const counts = {
+        active: 0, waiting: 0, quiet: 0, diagnostic: 0, unknown: 0, stopped: 0, idle: 0, background: 0
+    };
+    for (const session of sessions)
+        counts[session.group]++;
+    return { scope: "task-recorded-native-activity", taskId: input.taskId,
+        readAt: input.now.toISOString(), counts, sessions,
+        coverage: "Selected Sessions and retained, exactly fenced child observations only; not a live process or complete historical Session inventory." };
+}
+function backgroundForRuns(fence, since, groups) {
+    return [...groups].flatMap(([runId, events]) => {
+        const projection = projectRuntimeTaskEvents({ ...fence, ...(runId === undefined ? {} : { runId }) }, since, events);
+        return [
+            ...Object.entries(projection.continuations)
+                .filter(([, child]) => child.execution !== "quiescent" || child.identityConflict)
+                .map(([id, child]) => ({ id: `${runId ?? "native"}/${id}`, runId: runId ?? null,
+                execution: child.identityConflict ? "unknown" : child.execution })),
+            // Drivers may emit both forms for one child. This fold is already
+            // fenced to Task/Role/Agent/driver/Session/Run; continuation is richer.
+            ...Object.entries(projection.operations).filter(([id, operation]) => operation.kind === "subagent" && !Object.hasOwn(projection.continuations, id))
+                .map(([id]) => ({ id: `${runId ?? "native"}/operation:${id}`, runId: runId ?? null,
+                execution: "unsettled" }))
+        ];
+    });
+}

package/dist/scheduler/operatorEvent.js

@@ -1,6 +1,55 @@
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createTaskEvent } from "../event/taskEvent.js";
+import { claimPending } from "../coordination/workMailbox.js";
 export const LEADER_ATTENTION_REQUIRED_EVENT = "leader.attention-required";
+/** Bound each Operator pass, retaining the exact unclaimed sequence suffix. */
+export function claimOperatorAttention(mailbox, options) {
+    const pending = mailbox.pending;
+    if (pending === null || pending.requestCount <= 64)
+        return claimPending(mailbox, options);
+    // Operator producers append one unique source ref per signal. Mailbox merge
+    // preserves insertion order for refs and keys, including the supported
+    // default sequence keys used by Provider retry attention. Preserve those
+    // keys verbatim; they are valid current data, not a migration or repair.
+    if (pending.requestCount !== pending.dedupeKeys.length
+        || pending.refs.length !== pending.requestCount
+        || pending.toSequence - pending.fromSequence + 1 !== pending.requestCount
+        || pending.dedupeKeys.some((key, index) => {
+            const ref = pending.refs[index];
+            return (ref.type !== "event" && ref.type !== "input")
+                || key !== `operator-${ref.type}:${ref.taskId}:${ref.id}`
+                    && key !== `sequence:${pending.fromSequence + index}`;
+        })) {
+        throw new Error("Operator attention batch cannot be safely partitioned; inspect its source refs and sequence before retrying.");
+    }
+    const prefixKeys = pending.dedupeKeys.slice(0, 64);
+    const suffixKeys = pending.dedupeKeys.slice(64);
+    const through = pending.fromSequence + 63;
+    const prefix = { ...pending, toSequence: through, requestCount: 64,
+        dedupeKeys: prefixKeys, refs: pending.refs.slice(0, 64) };
+    const claimed = claimPending({ ...mailbox, pending: prefix }, {
+        ...options, batchId: `operator:${prefix.fromSequence}-${prefix.toSequence}`
+    });
+    return { ...claimed, pending: { ...pending, fromSequence: through + 1,
+            requestCount: pending.requestCount - 64, dedupeKeys: suffixKeys,
+            refs: pending.refs.slice(64) } };
+}
+/**
+ * Fixed source admission at the durable event write, in the same transaction.
+ * The existing mailbox is the incremental restart cursor: periodic scheduling
+ * reads only outstanding refs, never re-scans or replays historical events.
+ * Context, idle observations and ordinary progress are deliberately absent.
+ */
+export function enqueueDurableOperatorFact(store, event) {
+    const now = new Date(event.createdAt);
+    if (event.type === "input.requested" && typeof event.payload.requestId === "string") {
+        enqueueWork(store, { kind: "operator" }, "input-requested", now, [{ type: "input", taskId: event.taskId, id: event.payload.requestId }], { source: "input-request", dedupeKey: `operator-input:${event.taskId}:${event.payload.requestId}` });
+    }
+    else if (["task.completed", "task.cancelled", "task.retired", "publication.recorded",
+        "publication.candidate-adopted", LEADER_ATTENTION_REQUIRED_EVENT].includes(event.type)) {
+        enqueueOperatorEvent(store, event, event.type.startsWith("task.") ? "task-terminal" : event.type, now);
+    }
+}
 /** 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")