@zq-silk/yui 2.5.0 → 2.6.0

package/dist/cli/commandCatalog.js

@@ -408,8 +408,9 @@ const taskChildren = [
     {
         name: "context", discovery: { surface: "public", audiences: ["public", "operator", "leader", "assignment", "unbound"] },
         summary: "Read compact authorized facts, fixed-bound delta, or inspect a Context reference.",
-        usage: "yui task context [read|list|delta|inspect] <task> [--after <cursor>] [--continuation <cursor>] [--cursor <cursor>] [--limit <n>] [--store <store> --ref <id>] [--digest <digest>]",
-        options: ["--after", "--continuation", "--cursor", "--limit", "--store", "--ref", "--digest", "--status", "--work-item"]
+        usage: "yui task context [read|list|delta|inspect] <task> [--after <cursor>] [--continuation <cursor>] [--cursor <cursor>] [--limit <n>] [--store <store> --ref <id>] [--digest <digest>] [--view <current|all>]",
+        options: ["--after", "--continuation", "--cursor", "--limit", "--store", "--ref", "--digest", "--status", "--work-item", "--view"],
+        optionValues: { "--view": ["current", "all"] }
     },
     {
         name: "next-action", discovery: { surface: "managed", audiences: ["operator", "leader"] },

package/dist/commands/taskCommands.js

@@ -45,7 +45,7 @@ import { copyGlobalRoleToTaskRole, activeRoleAgentBinding, createRole, createRol
 import { roleLaunchEventPayload, saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
 import { RUNTIME_SESSION_REPLACE_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { currentManagedRuntime, resolveManagedTaskReader } from "../runtime/managedCaller.js";
-import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { controlProviderRetry, providerRunRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
 import { currentProviderConversation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
@@ -4897,7 +4897,9 @@ function retryRun(args, store, options) {
             return output(`Retry already recorded as ${existing.payload.runId}; retry that exact successor if needed.\n`);
         }
         const sessions = tx.getTaskRoleSessionSet(previous.taskId, previous.roleName);
-        const retry = sessions?.providerBinding?.retry;
+        const retry = options.providerRetryChainId !== undefined ? sessions?.providerBinding?.retry
+            : sessions?.providerBinding == null ? undefined
+                : providerRunRetry(sessions.providerBinding, previous.id, clock(options).getTime());
         if (options.providerRetryChainId !== undefined
             && (retry?.chainId !== options.providerRetryChainId || retry.status !== "waiting"
                 || retry.previousRunId !== previous.id || clock(options).getTime() < Date.parse(retry.nextEligibleAt)
@@ -4909,7 +4911,10 @@ function retryRun(args, store, options) {
             const successor = tx.getActiveRun(previous.taskId, previous.roleName);
             tx.saveTaskRoleSessionSet({
                 ...sessions, providerBinding: {
-                    ...sessions.providerBinding, retry: {
+                    ...sessions.providerBinding,
+                    ...(sessions.providerBinding.retry !== undefined && sessions.providerBinding.retry.chainId !== retry.chainId
+                        ? { retryHistory: [...(sessions.providerBinding.retryHistory ?? []), sessions.providerBinding.retry] } : {}),
+                    retry: {
                         ...retry, status: "waiting", successorAutomatic: options.providerRetryChainId !== undefined,
                         ...(options.providerRetryChainId === undefined ? {
                             intentAt: clock(options).toISOString(),

package/dist/commands/taskContextCommand.js

@@ -17,12 +17,12 @@ export function runTaskContextCommand(args, store, environment = {}) {
     const action = explicit ? args[0] : "read";
     const taskId = args[explicit ? 1 : 0];
     if (!taskId || taskId.startsWith("--"))
-        throw usageError("Task context usage: yui task context [read|list|delta|inspect] <task> [--after <cursor|timestamp>] [--continuation <cursor>] [--cursor <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest>] [--status <status>] [--work-item <id>].");
+        throw usageError("Task context usage: yui task context [read|list|delta|inspect] <task> [--after <cursor|timestamp>] [--continuation <cursor>] [--cursor <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest>] [--view <current|all>] [--status <status>] [--work-item <id>].");
     const options = new Map();
     const rest = args.slice(explicit ? 2 : 1);
     const allowed = action === "read" ? [] : action === "delta"
         ? ["--after", "--continuation", "--limit"] : action === "list"
-        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item"] : ["--store", "--ref", "--digest", "--cursor"];
+        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item", "--view"] : ["--store", "--ref", "--digest", "--cursor"];
     for (let i = 0; i < rest.length; i += 2) {
         const flag = rest[i];
         const value = rest[i + 1];
@@ -40,6 +40,7 @@ export function runTaskContextCommand(args, store, environment = {}) {
             throw usageError("Context list requires --store.");
         data = listTaskContext(store, taskId, family, {
             cursor: options.get("--cursor"),
+            view: options.get("--view"),
             status: options.get("--status"), after: options.get("--after"), workItemId: options.get("--work-item"),
             ...(options.has("--limit") ? { limit: Number(options.get("--limit")) } : {})
         }, environment);

package/dist/context/taskContext.js

@@ -191,7 +191,10 @@ export function readTaskContextResource(store, taskId, selector, environment = {
 export function listTaskContext(store, taskId, family, options = {}, environment = {}) {
     return store.readTransaction(reader => {
         const scope = authorizeContext(reader, taskId, environment);
-        const sources = authorizedSources(reader, scope, false, family);
+        if (options.view !== undefined && !["current", "all"].includes(options.view)) {
+            throw usageError("Context list view must be current or all.");
+        }
+        const sources = authorizedSources(reader, scope, options.view === "current", family, true);
         if (!CONTEXT_FAMILIES.includes(family))
             throw usageError(`Unknown Context store: ${family}.`);
         if (options.after !== undefined && !Number.isFinite(Date.parse(options.after)))
@@ -216,7 +219,7 @@ export function listTaskContext(store, taskId, family, options = {}, environment
             }
         }
         return recordPage(records, `task:${taskId}/${family}/${JSON.stringify({
-            status: options.status, after: options.after, workItemId: options.workItemId
+            view: options.view ?? "all", status: options.status, after: options.after, workItemId: options.workItemId
         })}`, options);
     });
 }
@@ -447,7 +450,7 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
         default: return null;
     }
 }
-function authorizedSources(store, { task, allow, caller }, current = false, requestedFamily) {
+function authorizedSources(store, { task, allow, caller }, current = false, requestedFamily, discovery = false) {
     const taskId = task.id;
     const sources = [];
     const add = (family, id, value) => {
@@ -462,7 +465,7 @@ function authorizedSources(store, { task, allow, caller }, current = false, requ
         const { count } = store.queryContextRecords(taskId, { ...selection, limit: 0 });
         sources.push({ family, count, *read(offset = 0) {
                 for (const { id, value } of store.queryContextRecords(taskId, {
-                    ...selection, offset, limit: current ? 8 : MAX_RECORDS
+                    ...selection, offset, limit: current && !discovery ? 8 : MAX_RECORDS
                 }).records)
                     yield materialize(family, id, value);
             } });

package/dist/kernel/builtinCapabilities.js

@@ -47,7 +47,7 @@ const definitions = [
         name: "context.list", summary: "Discover one authorized record family with bounded summaries and exact references.",
         effect: "query", requiredPermissions: ["task:read"], source: "listTaskContext",
         inputSchema: object({ taskId: text, store: text, cursor: text, limit: { type: "integer" },
-            status: text, after: text, workItemId: text }, ["taskId", "store"]),
+            view: { type: "string", enum: ["current", "all"] }, status: text, after: text, workItemId: text }, ["taskId", "store"]),
         outputSchema: { type: "object", required: ["items", "total", "complete", "nextCursor"] }
     },
     {
@@ -304,6 +304,7 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                 }, callerEnvironment(caller));
             if (name === "context.list")
                 return listTaskContext(store, taskId, params.store, {
+                    view: params.view,
                     cursor: params.cursor, limit: params.limit,
                     status: params.status, after: params.after,
                     workItemId: params.workItemId

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/taskExecutionProjection.js

@@ -5,6 +5,7 @@ import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
 import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from "../execution/executionHealth.js";
 import { buildTaskObservabilityProjection } from "./taskObservabilityProjection.js";
+import { projectTaskSessions } from "../runtime/taskSessions.js";
 import { isRoleRunStalled, latestStallProgressAt } from "./roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
@@ -13,7 +14,7 @@ import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runt
  * aggregate. This function only reads; it never starts a Controller, queues a
  * wake, writes a Message, or mutates any record.
  */
-export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
+export function buildTaskExecutionProjection(store, taskId, now = new Date(), nativeSessions) {
     const task = store.getTask(taskId);
     if (task === null)
         return null;
@@ -23,6 +24,7 @@ export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
     const workItems = store.listWorkItems(taskId);
     const reviewRounds = store.listReviewRounds(taskId);
     const runs = operationalTaskRecords(usageRuns, events, "run");
+    const brief = store.getTaskBrief(taskId);
     const leaderMailbox = store.getWorkMailbox({
         kind: "role",
         taskId,
@@ -36,6 +38,12 @@ export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
     });
     return projectTaskExecution({
         task,
+        jobs: store.listDurableJobs(taskId),
+        nativeSessions: nativeSessions ?? projectTaskSessions({
+            taskId, sessionSets: store.listRoleSessionSets(taskId), events, now,
+            ...(brief?.updatedAt === undefined ? {} : { semanticProgressAt: brief.updatedAt }),
+            policy: resolveRuntimeHealth(store.getConfig().runtimeHealth)
+        }),
         usageFacts: store.readTaskUsageFacts(taskId),
         roles,
         runs,
@@ -56,7 +64,7 @@ export function buildTaskExecutionProjection(store, taskId, now = new Date()) {
         changeSets: store.listChangeSets(taskId),
         integrations: store.listIntegrationAttempts(taskId),
         events,
-        brief: store.getTaskBrief(taskId),
+        brief,
         pendingWakeup: store.getPendingWakeup(taskId),
         leaderMailbox,
         leaderFailure: store.getLeaderFailure(taskId),
@@ -118,8 +126,27 @@ export function projectTaskExecution(facts) {
         now
     });
     const laneRecovery = actionableExecutionLaneRecoveries(groupSummaries)[0];
+    const jobs = facts.jobs ?? [];
+    const native = facts.nativeSessions;
+    const activity = {
+        jobs: {
+            queued: jobs.filter(job => job.status === "queued").length,
+            running: jobs.filter(job => job.status === "running").length,
+            unknown: jobs.filter(job => job.status === "unknown-needs-attention").length
+        },
+        openInputs: inputRequests.filter(input => input.status === "open").length,
+        native: {
+            active: (native?.counts.active ?? 0) + (native?.counts.quiet ?? 0),
+            waiting: native?.counts.waiting ?? 0,
+            unknown: (native?.counts.unknown ?? 0) + (native?.counts.diagnostic ?? 0)
+                + (native?.sessions.reduce((sum, session) => sum
+                    + session.background.filter(child => child.execution === "unknown").length, 0) ?? 0),
+            background: native?.sessions.reduce((sum, session) => sum + session.background.length, 0) ?? 0
+        }
+    };
     const render = (input) => projection({
         ...input,
+        activity,
         executionGroups: groupSummaries,
         observability
     });
@@ -128,10 +155,12 @@ export function projectTaskExecution(facts) {
         const known = facts.runDelivery?.[run.id];
         if (known !== undefined && known !== "unobserved")
             return known;
-        const observed = events.map(runtimeObservationFromTaskEvent).filter((event) => event?.fence.runId === run.id && event.authority !== "transport"
+        const observed = events.map(runtimeObservationFromTaskEvent).filter((event) => event?.fence.runId === run.id && event.fence.taskId === task.id
+            && event.fence.roleName === run.roleName && event.fence.agentId === run.effective.agentId
+            && event.authority !== "transport"
             && ["turn.accepted", "turn.completed", "turn.failed", "turn.cancelled"].includes(event.kind)).at(-1);
         return observed === undefined || observed === null ? "unobserved"
-            : observed.kind.slice("run.".length);
+            : observed.kind.slice("turn.".length);
     };
     const runHasSession = (run) => roleSessions.some((session) => (session.roleName === run.roleName
         && session.agentId === run.effective.agentId
@@ -206,7 +235,7 @@ export function projectTaskExecution(facts) {
     const activeLeader = activeRuns.find((run) => run.roleName === "leader");
     const pendingDeliveryRuns = activeRuns.filter((run) => deliveryOf(run) !== "accepted");
     const hasPendingLeaderWork = pendingWakeup !== null
-        || leaderMailbox?.pending !== null;
+        || leaderMailbox?.pending != null;
     const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure);
     const providerRecoveries = (facts.providerRetries ?? []).filter(retry => retry.status === "waiting" || retry.status === "in-flight");
     const recoveringRunIds = new Set(providerRecoveries.flatMap(retry => [retry.previousRunId, retry.successorRunId].filter((id) => id !== undefined)));
@@ -257,13 +286,30 @@ export function projectTaskExecution(facts) {
             summary: openInputs[0].question,
             reason: "open-input-request",
             monitoring,
-            failClosed: false,
+            failClosed: activity.jobs.unknown > 0 || activity.native.unknown > 0,
             activeRuns: activeRunViews,
             attention,
             blockers,
             pendingWakeup
         });
     }
+    if (activity.jobs.unknown > 0 || activity.native.unknown > 0) {
+        return render({
+            task, status: "attention", owner: "leader", action: "inspect-attention",
+            summary: `${activity.jobs.unknown} Job(s) have unknown outcomes; ${activity.native.unknown} native observation(s) need attention. Other parallel activity remains visible; do not infer completion or replay.`,
+            reason: "parallel-execution-unknown", monitoring, failClosed: true,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
+    const nativeWait = native?.sessions.find(session => session.group === "waiting" && ["user", "permission"].includes(session.waitingReason ?? ""));
+    if (nativeWait) {
+        return render({
+            task, status: "waiting-user", owner: "user", action: "inspect-attention",
+            summary: `Native Session ${nativeWait.roleName} is waiting for ${nativeWait.waitingReason}; other activity remains visible.`,
+            reason: "native-input-wait", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (laneRecovery !== undefined && (laneRecovery.runId === undefined || !recoveringRunIds.has(laneRecovery.runId))) {
         return render({
             task,
@@ -382,6 +428,15 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
+    if (native?.sessions.some(session => session.roleName === "leader"
+        && ["active", "quiet"].includes(session.group))) {
+        return render({
+            task, status: "working", owner: "leader", action: "advance-task",
+            summary: "Leader native input is accepted; managed AgentRuns and parallel background work remain separate facts.",
+            reason: "leader-native-turn", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (hasPendingLeaderWork) {
         return render({
             task,
@@ -449,6 +504,22 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
+    if (activity.jobs.queued + activity.jobs.running > 0) {
+        return render({
+            task, status: "waiting-on-jobs", owner: "none", action: "wait-for-jobs",
+            summary: `${activity.jobs.running} background Job(s) running; ${activity.jobs.queued} queued. Leader is not currently executing.`,
+            reason: "background-jobs", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
+    if (activity.native.active + activity.native.waiting + activity.native.background > 0) {
+        return render({
+            task, status: "waiting-on-agents", owner: "none", action: "wait-for-agents",
+            summary: "Recorded native execution or retained background activity remains unsettled; this is separate from managed AgentRuns.",
+            reason: "native-execution", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (candidateReady || unresolvedIntegration) {
         return render({
             task,
@@ -496,6 +567,7 @@ function projection(input) {
         monitoring: input.monitoring,
         failClosed: input.failClosed,
         activeRuns: input.activeRuns,
+        activity: input.activity,
         executionGroups: input.executionGroups ?? [],
         observability: input.observability,
         attention: input.attention,