@zq-silk/yui 0.6.2 → 0.6.4

package/dist/commands/taskCommands.js

@@ -13,7 +13,7 @@ import { createTaskMessage, taskMessageAuthorLabel } from "../message/message.js
 import { cancelInputRequest } from "../input/inputRequest.js";
 import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { resetTaskRoleSessionGeneration } from "../lifecycle/taskRoleSessionReset.js";
-import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
+import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
 import { createAgentRun } from "../run/agentRun.js";
 import { matchYieldReceipt } from "../run/yieldReceipt.js";
 import { providerRetryConfig } from "../run/providerRetryConfig.js";
@@ -1268,7 +1268,7 @@ function listTaskRoles(args, store, options) {
     exactPositionals(args, 1, "Task role list usage: yui task role list <task>.");
     const task = requireTask(store, args[0]);
     const roles = store.listRoles(task.id);
-    const statuses = inspectTaskRoleRuntimeStatuses(task.id, roles, store, options.runtime?.inspectTaskRolePanes?.(task.id) ?? []);
+    const statuses = inspectTaskRoleRuntimeStatuses(task.id, roles, store, options.runtime?.inspectTaskRolePanes?.(task.id) ?? [], options.now?.() ?? new Date());
     if (statuses.length === 0)
         return output("No roles assigned.\n", { roles: statuses });
     return output(`${renderTable(`Task roles: ${task.id}`, [
@@ -1293,7 +1293,7 @@ function taskRoleStatus(args, store, options) {
     exactPositionals(args, 2, "Task role status usage: yui task role status <task> <role>.");
     const task = requireTask(store, args[0]);
     const role = requireRole(store, task.id, args[1]);
-    const [status] = inspectTaskRoleRuntimeStatuses(task.id, [role], store, options.runtime?.inspectTaskRolePanes?.(task.id) ?? []);
+    const [status] = inspectTaskRoleRuntimeStatuses(task.id, [role], store, options.runtime?.inspectTaskRolePanes?.(task.id) ?? [], options.now?.() ?? new Date());
     if (status === undefined)
         throw roleNotFound(role.name);
     return output(renderTaskRoleRuntimeStatus(status), { role: status });
@@ -1475,25 +1475,60 @@ function unbindTaskRole(args, store, options) {
     });
     return `Unbound Agent ${args[2]} from ${result.taskId}/${result.name}\n`;
 }
-function enterTaskRole(args, store, options) {
-    exactPositionals(args, 2, "Task role enter usage: yui task role enter <task> <role>.");
-    const task = requireTask(store, args[0]);
+function enterTaskRole(args, store, _options) {
+    const usage = "Task role enter usage: yui task role enter <task> <role> "
+        + "[--read-only | --read-write].";
+    const parsed = parseTail(args, new Set(), usage, new Set(["--read-only", "--read-write"]));
+    exactPositionals(parsed.positionals, 2, usage);
+    if (parsed.options.has("--read-only") && parsed.options.has("--read-write")) {
+        throw usageError("--read-only and --read-write are mutually exclusive.", usage);
+    }
+    const task = requireTask(store, parsed.positionals[0]);
     if (task.status !== "active") {
         throw usageError(inactiveTaskMessage(task, "entering a role session"));
     }
-    const role = requireRole(store, task.id, args[1]);
+    const role = requireRole(store, task.id, parsed.positionals[1]);
+    const access = parsed.options.has("--read-write") ? "read-write" : "read-only";
+    if (access === "read-write") {
+        assertTaskRoleWritableAttachAvailable(store, task.id, role.name);
+    }
     return {
         kind: "enter",
         taskId: task.id,
         roleName: role.name,
-        output: `Prepared role ${role.name} for ${task.id}\n`
+        access,
+        output: `Attaching to ${role.name} for ${task.id} (${access})\n`
     };
 }
+/** Re-run after the tmux writer lease exists to close attach/launch races. */
+export function assertTaskRoleWritableAttachAvailable(store, taskId, roleName, options = {}) {
+    const role = requireRole(store, taskId, roleName);
+    if (store.getActiveAgentRun(taskId, roleName) !== null) {
+        throw usageError(`Role has an active managed Run; writable attach is unavailable: ${taskId}/${roleName}.`);
+    }
+    const session = store.getRoleSession(taskId, roleName);
+    if (activeRoleAgentBinding(role).adapterId === "claude"
+        && ((session !== null
+            && session.status !== "stopped"
+            && session.status !== "broken")
+            || options.isManagedProcessRunning?.() === true)) {
+        throw usageError(`A managed Claude process is still running; writable attach is unavailable: ${taskId}/${roleName}.`);
+    }
+}
 function enterTaskRoleAlias(args, store, options) {
-    if (args.length < 1 || args.length > 2 || args.some((value) => value.trim().length === 0)) {
-        throw usageError("Task enter usage: yui task enter <task> [role].");
+    const usage = "Task enter usage: yui task enter <task> [role] "
+        + "[--read-only | --read-write].";
+    const parsed = parseTail(args, new Set(), usage, new Set(["--read-only", "--read-write"]));
+    if (parsed.positionals.length < 1 || parsed.positionals.length > 2
+        || parsed.positionals.some((value) => value.trim().length === 0)) {
+        throw usageError(usage);
     }
-    return enterTaskRole([args[0], args[1] ?? LEADER_ROLE], store, options);
+    return enterTaskRole([
+        parsed.positionals[0],
+        parsed.positionals[1] ?? LEADER_ROLE,
+        ...(parsed.options.has("--read-only") ? ["--read-only"] : []),
+        ...(parsed.options.has("--read-write") ? ["--read-write"] : [])
+    ], store, options);
 }
 function taskWorkCommand(args, store, options) {
     const [command, ...rest] = args;

package/dist/commands/taskContextCommand.js

@@ -303,7 +303,7 @@ function latestStallKind(events, runId) {
     const event = [...events]
         .filter((candidate) => candidate.type === "run.stalled" && candidate.payload.runId === runId)
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
-    return event?.payload.kind ?? "execution-stalled";
+    return event?.payload.kind ?? "workflow-not-progressing";
 }
 function renderWorkItemReviews(rounds) {
     const latest = rounds.at(-1);

package/dist/commands/taskRoleRuntimeStatus.js

@@ -1,7 +1,11 @@
 import { isDeepStrictEqual } from "node:util";
 import { hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
-export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes) {
+import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { evaluateRuntimeAttention, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
+import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
     const panesByRole = new Map();
@@ -10,7 +14,7 @@ export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes) {
         if (current === undefined || current.dead && !pane.dead)
             panesByRole.set(pane.roleName, pane);
     }
-    return roles.map((role) => inspectTaskRoleRuntimeStatus(taskId, role, store, panesByRole.get(role.name), role.name === "leader" ? taskOpenInputRequestCount : 0));
+    return roles.map((role) => inspectTaskRoleRuntimeStatus(taskId, role, store, panesByRole.get(role.name), role.name === "leader" ? taskOpenInputRequestCount : 0, now));
 }
 export function renderTaskRoleRuntimeStatus(status) {
     const activeRun = status.activeRun === null
@@ -36,6 +40,23 @@ export function renderTaskRoleRuntimeStatus(status) {
     const workspaceDetails = status.workspace.managed
         ? status.workspace.entries.map((entry) => (`  Project          ${entry.directory} (${entry.access}) ${entry.branch} @ ${entry.baseCommit}`))
         : [];
+    const runtime = status.runtime === null
+        ? "not observable"
+        : [
+            `${status.runtime.driverId}: ${status.runtime.status}`,
+            `attention=${status.runtime.attention}`,
+            status.runtime.lastActivityAt === undefined
+                ? undefined
+                : `last activity=${status.runtime.lastActivityAt}`,
+            status.runtime.activeOperations.length === 0
+                ? undefined
+                : `operations=${status.runtime.activeOperations.join(",")}`,
+            status.runtime.observerStatus === undefined
+                ? undefined
+                : `observer=${status.runtime.observerStatus}${status.runtime.observerDetail === undefined
+                    ? ""
+                    : ` (${status.runtime.observerDetail})`}`
+        ].filter((value) => value !== undefined).join("; ");
     return [
         `Task Role status: ${status.taskId}/${status.roleName}`,
         "",
@@ -53,9 +74,10 @@ export function renderTaskRoleRuntimeStatus(status) {
         `  Active work      ${activeWork}`,
         `  Active run       ${activeRun}`,
         `  Run attention    ${status.stall.active
-            ? `needs-attention (${status.stall.kind ?? "execution-stalled"}; no durable progress since ${status.stall.progressAt ?? "unknown"})`
+            ? `needs-attention (${status.stall.kind ?? "workflow-not-progressing"}; no workflow progress since ${status.stall.progressAt ?? "unknown"})`
             : "none"}`,
         `  Native session   ${nativeSession}`,
+        `  Agent runtime    ${runtime}`,
         `  Runtime cleanup  ${status.runtimeCleanupPending ? "pending" : "none"}`,
         `  Fresh launch     ${status.freshLaunchAllowed ? "allowed" : "blocked"}`,
         `  tmux pane        ${tmux}`,
@@ -97,7 +119,7 @@ export function taskRoleTmuxLabel(status) {
         ? "running"
         : `running (${status.tmux.currentCommand})`;
 }
-function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount) {
+function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now) {
     const activeRun = store.getActiveAgentRun(taskId, role.name);
     const activeWork = activeRun?.workItemId === undefined
         ? null
@@ -132,6 +154,7 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         ? { managed: false, path: role.workspace }
         : { ...managedWorkspace, managed: true };
     const events = store.listEvents(taskId);
+    const runtime = projectTaskRoleRuntime(activeRun, nativeSession, tmux, events, now);
     const stalled = activeRun !== null && isRoleRunStalled(events, activeRun.id);
     const stallProgressAt = activeRun === null
         ? undefined
@@ -139,7 +162,7 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
     const stallKind = activeRun === null
         ? undefined
         : latestStallKind(events, activeRun.id);
-    const health = calculateHealth(role, activeRun, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled);
+    const health = calculateHealth(role, activeRun, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime);
     const stall = activeRun === null
         ? { active: false }
         : {
@@ -165,6 +188,7 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         nativeSession,
         tmux,
         workspace,
+        runtime,
         stall
     };
 }
@@ -172,11 +196,11 @@ function latestStallKind(events, runId) {
     const event = [...events]
         .filter((candidate) => candidate.type === "run.stalled" && candidate.payload.runId === runId)
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
-    return event?.payload.kind === "delivery-stalled" || event?.payload.kind === "execution-stalled"
+    return event?.payload.kind === "delivery-stalled" || event?.payload.kind === "workflow-not-progressing"
         ? event.payload.kind
         : undefined;
 }
-function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled) {
+function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime) {
     if (runtimeCleanupPending && nativeSession === null) {
         return {
             health: "needs-attention",
@@ -217,6 +241,49 @@ function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending,
                 healthReason: "the live active Run has no durable progress in the configured stall window"
             };
         }
+        if (activeRun.deliveredAt !== undefined) {
+            if (runtime === null
+                || runtime.status === "runtime-unobservable"
+                || runtime.attention === "unobservable") {
+                return {
+                    health: "needs-attention",
+                    healthReason: "the host is present but the Agent Driver exposes no current runtime state"
+                };
+            }
+            if (runtime.attention === "quiet" || runtime.attention === "active-operation-quiet") {
+                return {
+                    health: "needs-attention",
+                    healthReason: runtime.attention === "active-operation-quiet"
+                        ? "the Agent Driver reports an open operation but no recent structured runtime activity"
+                        : "the Agent Driver has not reported recent structured runtime activity"
+                };
+            }
+            if (runtime.status === "broken" || runtime.status === "stopped") {
+                return {
+                    health: "failed",
+                    healthReason: `the Agent Driver runtime is ${runtime.status}`
+                };
+            }
+            if (runtime.status.startsWith("waiting-")) {
+                return {
+                    health: runtime.status === "waiting-user" ? "blocked-input" : "waiting",
+                    healthReason: `the Agent Driver is ${runtime.status.replaceAll("-", " ")}`
+                };
+            }
+            if (runtime.status === "ready") {
+                return {
+                    health: "needs-attention",
+                    healthReason: "the Agent turn ended while the workflow Run is still active"
+                };
+            }
+            if (["model-active", "tool-active", "subagent-active", "active-quiet"]
+                .includes(runtime.status)) {
+                return {
+                    health: "running",
+                    healthReason: `the Agent Driver reports ${runtime.status.replaceAll("-", " ")}`
+                };
+            }
+        }
     }
     if (activeRun === null && role.status === "running") {
         return { health: "needs-attention", healthReason: "the Role is running without an active Run" };
@@ -234,9 +301,11 @@ function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending,
         };
     }
     if (activeRun !== null) {
-        if (activeRun.deliveredAt !== undefined) {
-            return { health: "running", healthReason: "the active Run has a live tmux pane" };
-        }
+        if (activeRun.deliveredAt !== undefined)
+            return {
+                health: "needs-attention",
+                healthReason: "the delivered Run has no authoritative Agent Driver state"
+            };
         if (activeRun.pushedAt !== undefined) {
             return {
                 health: "awaiting-provider-acceptance",
@@ -249,6 +318,97 @@ function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending,
         ? { health: "ready", healthReason: "the native Agent pane is ready without active work" }
         : { health: "idle", healthReason: "there is no active work or live tmux pane" };
 }
+function projectTaskRoleRuntime(run, session, tmux, events, now) {
+    if (run === null || session?.launchId === undefined)
+        return null;
+    let driverId;
+    try {
+        driverId = builtinDriverIdForAdapter(run.effective.adapterId);
+    }
+    catch {
+        return null;
+    }
+    const fence = {
+        taskId: run.taskId,
+        roleName: run.roleName,
+        runId: run.id,
+        agentId: run.effective.agentId,
+        driverId,
+        launchId: session.launchId,
+        sessionGenerationId: session.launchId,
+        nativeSessionId: session.nativeSessionId,
+        nativeTurnId: runtimeNativeTurnId(events, {
+            taskId: run.taskId,
+            roleName: run.roleName,
+            runId: run.id,
+            agentId: run.effective.agentId,
+            driverId,
+            launchId: session.launchId,
+            nativeSessionId: session.nativeSessionId,
+            receiptId: formatAgentRunReceiptId(run.taskId, run.id)
+        }) ?? run.id,
+        receiptId: formatAgentRunReceiptId(run.taskId, run.id)
+    };
+    let projection = projectRuntimeTaskEvents(fence, run.createdAt, events);
+    projection = projectRuntimeObservation(projection, createRuntimeObservation({
+        schemaVersion: 1,
+        eventId: `runtime-host-${run.id}`,
+        kind: "host.observed",
+        authority: "host",
+        receivedAt: run.updatedAt,
+        fence,
+        payload: { alive: tmux.state === "running" }
+    }));
+    const attention = evaluateRuntimeAttention(projection, now, {
+        runtimeSilenceMs: 5 * 60_000,
+        // Workflow attention has its own durable scheduler policy. This value is
+        // deliberately not consumed here; keeping it separate prevents token/tool
+        // activity from extending the workflow deadline.
+        semanticSilenceMs: 30 * 60_000
+    });
+    return {
+        driverId,
+        status: runtimeDisplayStatus(projection),
+        attention: attention.runtime,
+        ...(projection.lastRuntimeActivityAt === undefined
+            ? {}
+            : { lastActivityAt: projection.lastRuntimeActivityAt }),
+        activeOperations: Object.entries(projection.operations).map(([id, operation]) => (`${operation.kind}:${id}`)),
+        ...(projection.waitingReason === undefined
+            ? {}
+            : { waitingReason: projection.waitingReason }),
+        ...(projection.usage === undefined ? {} : { usage: projection.usage }),
+        ...(projection.observer.status === "unknown"
+            ? {}
+            : {
+                observerStatus: projection.observer.status,
+                ...(projection.observer.detail === undefined
+                    ? {}
+                    : { observerDetail: projection.observer.detail })
+            })
+    };
+}
+function runtimeNativeTurnId(events, expected) {
+    const observations = events
+        .map(runtimeObservationFromTaskEvent)
+        .filter((observation) => observation !== null
+        && observation.fence.taskId === expected.taskId
+        && observation.fence.roleName === expected.roleName
+        && observation.fence.runId === expected.runId
+        && observation.fence.agentId === expected.agentId
+        && observation.fence.driverId === expected.driverId
+        && observation.fence.launchId === expected.launchId
+        && observation.fence.nativeSessionId === expected.nativeSessionId
+        && observation.fence.receiptId === expected.receiptId
+        && observation.fence.nativeTurnId !== undefined)
+        .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
+        || (left.sequence ?? -1) - (right.sequence ?? -1)
+        || (left.ordinal ?? -1) - (right.ordinal ?? -1)
+        || left.eventId.localeCompare(right.eventId)));
+    return observations.filter(({ kind }) => kind === "turn.accepted").at(-1)
+        ?.fence.nativeTurnId
+        ?? observations.at(-1)?.fence.nativeTurnId;
+}
 function activeRunDeliveryLabel(run) {
     if (run.deliveredAt !== undefined)
         return "delivered";

package/dist/controller/agentRuntimeObserver.js

@@ -0,0 +1,210 @@
+import { createHash } from "node:crypto";
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+/**
+ * Controller-owned, provider-independent sampler. Drivers own source parsing;
+ * this component owns active-Run discovery, cursor lifetime, canonical event
+ * creation, and low-latency mailbox wakes.
+ */
+export class AgentRuntimeObserver {
+    store;
+    inbox;
+    drivers;
+    #states = new Map();
+    #sequence = 0;
+    constructor(store, inbox, drivers = builtinAgentDriverRegistry()) {
+        this.store = store;
+        this.inbox = inbox;
+        this.drivers = drivers;
+    }
+    async sample(now = new Date()) {
+        const active = this.activeSources();
+        const activeKeys = new Set(active.map(({ key }) => key));
+        for (const key of this.#states.keys()) {
+            if (!activeKeys.has(key))
+                this.#states.delete(key);
+        }
+        const dirty = new Set();
+        await Promise.all(active.map(async ({ key, fence, source, freshSession, persistedState }) => {
+            const existingState = this.#states.get(key);
+            // Cursor state is intentionally process-local, but the latest canonical
+            // usage/activity baseline is durable. Rehydrate it after Controller
+            // restart so rereading the bounded transcript tail cannot manufacture a
+            // fresh activity edge from tokens that were already observed.
+            const state = existingState ?? { ...persistedState };
+            const driver = this.drivers.require(fence.driverId);
+            const observer = driver.runtime.observer;
+            if (observer === undefined)
+                return;
+            let sample;
+            try {
+                sample = await observer.sample(source, state.cursor);
+            }
+            catch (error) {
+                sample = Object.freeze({
+                    cursor: state.cursor ?? Object.freeze({}),
+                    status: "unavailable",
+                    detail: error instanceof Error ? error.message : String(error)
+                });
+            }
+            state.cursor = sample.cursor;
+            const at = now.toISOString();
+            const sequence = this.#sequence++;
+            if (existingState === undefined && freshSession && state.usage === undefined) {
+                const zero = Object.freeze({ inputTokens: 0, outputTokens: 0 });
+                this.inbox.enqueueObservation(createRuntimeObservation({
+                    schemaVersion: 1,
+                    eventId: observationId("baseline", fence, source.sourceId, "zero"),
+                    kind: "activity.observed",
+                    authority: "controller",
+                    receivedAt: at,
+                    sequence,
+                    ordinal: 1,
+                    fence,
+                    payload: { activity: "model", usage: zero }
+                }));
+                state.usage = zero;
+                dirty.add(`role:${fence.taskId}/${fence.roleName}`);
+            }
+            const health = JSON.stringify([sample.status, sample.detail ?? null]);
+            if (state.health !== health) {
+                this.inbox.enqueueObservation(createRuntimeObservation({
+                    schemaVersion: 1,
+                    eventId: observationId("health", fence, source.sourceId, health),
+                    kind: "observer.health",
+                    authority: "diagnostic",
+                    receivedAt: at,
+                    sequence,
+                    ordinal: 0,
+                    fence,
+                    payload: {
+                        sourceId: source.sourceId,
+                        observerStatus: sample.status,
+                        ...(sample.detail === undefined ? {} : { observerDetail: sample.detail })
+                    }
+                }));
+                state.health = health;
+                dirty.add(`role:${fence.taskId}/${fence.roleName}`);
+            }
+            const usageChanged = sample.usage !== undefined
+                && !sameUsage(state.usage, sample.usage);
+            const activityChanged = sample.activityId !== undefined
+                && sample.activityId !== state.activityId;
+            if (usageChanged || (activityChanged && state.cursor !== undefined)) {
+                const usage = sample.usage;
+                this.inbox.enqueueObservation(createRuntimeObservation({
+                    schemaVersion: 1,
+                    eventId: observationId("activity", fence, source.sourceId, JSON.stringify([usage ?? null, sample.activityId ?? null])),
+                    kind: "activity.observed",
+                    authority: "driver-inferred",
+                    receivedAt: at,
+                    sequence,
+                    ordinal: 2,
+                    fence,
+                    payload: {
+                        activity: sample.activity ?? "model",
+                        ...(sample.activityId === undefined ? {} : { activityId: sample.activityId }),
+                        ...(usage === undefined ? {} : { usage })
+                    }
+                }));
+                dirty.add(`role:${fence.taskId}/${fence.roleName}`);
+            }
+            if (sample.usage !== undefined)
+                state.usage = sample.usage;
+            if (sample.activityId !== undefined)
+                state.activityId = sample.activityId;
+            this.#states.set(key, state);
+        }));
+        return Object.freeze([...dirty].sort());
+    }
+    activeSources() {
+        const result = [];
+        for (const task of this.store.listTasks()) {
+            if (task.status !== "active")
+                continue;
+            const observations = this.store.listEvents(task.id)
+                .map(runtimeObservationFromTaskEvent)
+                .filter((value) => value !== null);
+            for (const run of this.store.listAgentRuns(task.id)) {
+                if (run.status !== "active"
+                    || this.store.getActiveAgentRun(task.id, run.roleName)?.id !== run.id)
+                    continue;
+                const accepted = observations
+                    .filter((observation) => observation.kind === "turn.accepted"
+                    && observation.fence.runId === run.id
+                    && observation.fence.roleName === run.roleName
+                    && observation.fence.agentId === run.effective.agentId
+                    && observation.payload.observerSource !== undefined)
+                    .sort(compareObservations)
+                    .at(-1);
+                const source = accepted?.payload.observerSource;
+                if (accepted === undefined || source === undefined
+                    || accepted.fence.taskId === undefined || accepted.fence.runId === undefined)
+                    continue;
+                try {
+                    if (this.drivers.require(accepted.fence.driverId).runtime.observer === undefined)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                const fence = accepted.fence;
+                const exact = observations
+                    .filter((observation) => runtimeObservationFenceMatches(fence, observation.fence))
+                    .sort(compareObservations);
+                const persistedUsage = exact.filter((observation) => (observation.kind === "activity.observed"
+                    && observation.payload.usage !== undefined)).at(-1);
+                const persistedHealth = exact.filter((observation) => (observation.kind === "observer.health"
+                    && observation.payload.sourceId === source.sourceId)).at(-1);
+                result.push(Object.freeze({
+                    key: JSON.stringify([
+                        fence.driverId,
+                        fence.sessionGenerationId,
+                        fence.nativeSessionId,
+                        fence.nativeTurnId,
+                        fence.runId,
+                        source.sourceId
+                    ]),
+                    fence,
+                    source,
+                    freshSession: run.mode === "new",
+                    persistedState: Object.freeze({
+                        ...(persistedUsage?.payload.usage === undefined
+                            ? {}
+                            : { usage: persistedUsage.payload.usage }),
+                        ...(persistedUsage?.payload.activityId === undefined
+                            ? {}
+                            : { activityId: persistedUsage.payload.activityId }),
+                        ...(persistedHealth === undefined
+                            ? {}
+                            : {
+                                health: JSON.stringify([
+                                    persistedHealth.payload.observerStatus,
+                                    persistedHealth.payload.observerDetail ?? null
+                                ])
+                            })
+                    })
+                }));
+            }
+        }
+        return result;
+    }
+}
+function compareObservations(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 observationId(kind, fence, sourceId, value) {
+    return `runtime-observer-${createHash("sha256")
+        .update(JSON.stringify([kind, fence, sourceId, value]))
+        .digest("hex")}`;
+}
+function sameUsage(left, right) {
+    return left !== undefined
+        && left.inputTokens === right.inputTokens
+        && left.outputTokens === right.outputTokens
+        && left.cachedInputTokens === right.cachedInputTokens
+        && left.reasoningTokens === right.reasoningTokens;
+}

package/dist/controller/clientRuntime.js

@@ -405,22 +405,6 @@ export class FileTaskWorkflowRuntime {
     reconcileTask(taskId) {
         void this.#prepareAndScan(taskId).catch(this.clientOptions.onError ?? (() => { }));
     }
-    async prepareTaskRoleEnter(input) {
-        const task = this.store.getTask(input.taskId);
-        if (task?.status === "active" && this.workspacePreparer !== undefined) {
-            await this.workspacePreparer.prepareTaskWorkspace(task.id);
-        }
-        const environment = foregroundRoleEnvironment(this.store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, this.clientOptions.environment ?? process.env);
-        await callFileTaskController(this.home, "runtime.ensure-role-session", {
-            scope: "task",
-            taskId: input.taskId,
-            roleName: input.roleName,
-            ...(environment === undefined ? {} : { environment })
-        }, {
-            ...this.clientOptions,
-            requestTimeoutMs: LIFECYCLE_REQUEST_TIMEOUT_MS
-        });
-    }
     async stopTaskRoleSessions(taskId, roleNames) {
         const targets = [];
         for (const roleName of [...new Set(roleNames)]) {
@@ -508,7 +492,7 @@ export class FileTaskWorkflowRuntime {
         return this.tmux.inspectTaskRolePanes(taskId);
     }
     async prepareGlobalRoleEnter(roleName) {
-        const environment = foregroundRoleEnvironment(this.store, { scope: "global", roleName }, this.clientOptions.environment ?? process.env);
+        const environment = foregroundGlobalRoleEnvironment(this.store, roleName, this.clientOptions.environment ?? process.env);
         await callFileTaskController(this.home, "runtime.ensure-role-session", {
             scope: "global",
             roleName,
@@ -532,10 +516,8 @@ export class FileTaskWorkflowRuntime {
     }
 }
 const MANAGED_RUNTIME_ENVIRONMENT = new Set(YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES);
-function foregroundRoleEnvironment(store, owner, source) {
-    const role = owner.scope === "task"
-        ? store.getRole?.(owner.taskId, owner.roleName)
-        : store.getGlobalRole?.(owner.roleName);
+function foregroundGlobalRoleEnvironment(store, roleName, source) {
+    const role = store.getGlobalRole?.(roleName);
     if (role === null || role === undefined)
         return undefined;
     const agent = store.getConfiguredAgent?.(role.activeAgentId);