@zq-silk/yui 2.4.0 → 2.6.0

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

@@ -86,15 +86,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             attempted = true;
             const outcome = await delivery.sendOnce({
                 delivery: ready, receiptId: notification.attemptId, notificationId: notification.wakeId,
-                text: [
-                    `Yui Task notification: task=${task.id} wake=${notification.wakeId}.`,
-                    `Read current context: yui task context ${task.id} --json.`,
-                    `Read the fixed notification window: yui task wake show ${task.id} ${notification.wakeId}.`,
-                    "Read referenced result Messages in full before deciding their disposition.",
-                    "Follow the Leader Skill to advance outstanding Task work from these durable facts, or record the exact decision/authority needed.",
-                    "This is a notification, not an execution assignment. No separate final report is required.",
-                    "Reading context is not an acknowledgement that its requirements have been implemented."
-                ].join("\n")
+                text: notification.presentation
             });
             const accepted = outcome.status === "sent" || outcome.status === "already-sent";
             const disposition = accepted ? "accepted"

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,

package/dist/web/assets/assetManifest.js

@@ -4,6 +4,7 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { APP_SCRIPT, CLIENT_MODULES } from "./client/index.js";
+import { THEME_BOOTSTRAP_SCRIPT } from "./client/lib/theme.js";
 import { FONT_WOFF2_BASE64 } from "./fontData.js";
 import { DASHBOARD_HTML } from "./shell/index.js";
 import { STYLESHEETS } from "./styles/index.js";
@@ -13,6 +14,7 @@ const JS = "text/javascript; charset=utf-8";
 export const WEB_ASSETS = Object.freeze({
     ...Object.fromEntries(STYLESHEETS.map(({ name, body }) => [`/assets/css/${name}.css`, { contentType: CSS, body }])),
     ...Object.fromEntries(Object.entries(CLIENT_MODULES).map(([path, body]) => [`/assets/js/${path}.js`, { contentType: JS, body }])),
+    "/assets/theme.js": { contentType: JS, body: THEME_BOOTSTRAP_SCRIPT },
     "/assets/app.js": { contentType: JS, body: APP_SCRIPT },
     ...fontAssets(),
     "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", JS),

package/dist/web/assets/client/app/taskView.js

@@ -154,6 +154,7 @@ function detailContext(view) {
     taskAction: deps.api.taskAction,
     inspect: api.inspect,
     list: api.list,
+    activity: api.activity,
     artifacts: api.artifacts,
     readArtifact: api.artifact,
     evidence: api.evidence,

package/dist/web/assets/client/domain/records.js

@@ -4,9 +4,77 @@ export const RECORDS_SCRIPT = String.raw `
 // never acknowledges or accepts anything.
 import { h, icon } from "/assets/js/lib/dom.js";
 import { button, jsonBlock, mono, note } from "/assets/js/ui/primitives.js";
-import { rawDisclosure } from "/assets/js/ui/containers.js";
+import { rawDisclosure, listCard, setCardCount } from "/assets/js/ui/containers.js";
 import { richText } from "/assets/js/ui/text.js";
-import { cachedExact, readExact, summaryFields } from "/assets/js/domain/context.js";
+import { cachedExact, readExact, summaryFields, entriesOf, totalOf, exactCache } from "/assets/js/domain/context.js";
+
+// Current-family counts and pages use exactly the Context current filter.
+// A changed Context revalidates already-loaded membership with one bounded
+// page. Only the family's own digest invalidates its pages, not unrelated
+// runtime events. Loading a list does not eagerly inspect its bodies.
+export function currentRecordCard(data, store, t, actions, options) {
+  const view = data.viewState;
+  exactCache(view);
+  view.openRows = view.openRows || {};
+  view.currentLists = view.currentLists || {};
+  let state = view.currentLists[store];
+  if (!state || (!state.started && state.key !== data.core.coreCursor)) {
+    state = view.currentLists[store] = {
+      key: data.core.coreCursor, items: entriesOf(data.core, store),
+      total: totalOf(data.core, store), started: false, cursor: null, error: null, pending: false
+    };
+  }
+  const revalidate = state.key !== data.core.coreCursor;
+  state.key = data.core.coreCursor;
+  const element = listCard({ id: options.id, title: options.title, icon: options.icon || "pulse", count: state.total });
+  const rows = h("div.stack"), footer = h("div.stack", { "aria-live": "polite" });
+  element.list.append(rows, footer);
+  function draw(updateRows) {
+    setCardCount(element, state.total);
+    if (updateRows !== false) {
+      rows.replaceChildren();
+      state.items.forEach(function (item) {
+        rows.append(!item.omitted && item.value && options.render ? options.render(item.value, null, item)
+          : lazyRow(item, data.task.id, t, actions, {
+            cache: view.exact,
+            openRows: view.openRows,
+            head: h("span", null, item.ref.refId + (item.summary ? " · " + item.summary : "")),
+            render: options.render
+          }));
+      });
+    }
+    footer.replaceChildren(note(t("activity.loaded") + " " + state.items.length + " / " + state.total));
+    if (!state.total) footer.append(note(t("activity.none")));
+    if (state.error) footer.append(note(state.error + " · " + t("activity.refreshHint"), "bad"));
+    if ((!state.started && state.items.length < state.total) || state.cursor) {
+      footer.append(button(t("activity.more") + " (" + Math.max(0, state.total - state.items.length) + ")", {
+        disabled: state.pending, onClick: function () { load(state.started); }
+      }));
+    }
+    footer.append(button(t("activity.refresh"), { disabled: state.pending, onClick: function () { load(false); } }));
+    element.dataset.reading = String(state.pending);
+  }
+  async function load(more) {
+    if (state.pending) return;
+    const busy = function () { return !!rows.querySelector('[data-unsent="true"], [data-reading="true"]'); };
+    if (busy()) { state.error = t("activity.busy"); draw(false); return; }
+    state.pending = true;
+    draw(false);
+    try {
+      const page = await actions.list(data.task.id, store, { view: "current", limit: 20, cursor: more ? state.cursor : null });
+      if (busy()) throw new Error(t("activity.busy"));
+      if (more || !state.started || state.digest !== page.digest) {
+        state.items = more ? state.items.concat(page.items) : page.items;
+        state.cursor = page.nextCursor;
+      }
+      state.digest = page.digest; state.total = page.total; state.started = true; state.error = null;
+    } catch (error) { state.error = error.message; }
+    finally { state.pending = false; draw(!state.error); }
+  }
+  draw();
+  if (revalidate) load(false);
+  return element;
+}
 
 // A row drawn from its exact value: synchronously when cached, otherwise the
 // summary card until the read returns and replaces it in place.

package/dist/web/assets/client/domain/runs.js

@@ -16,7 +16,7 @@ export function runCard(run, t, locale) {
     run.purpose ? chip(label(t, "run.purpose", run.purpose)) : null,
     run.workItemId ? chip(run.workItemId) : null,
     h("span.spacer"),
-    statusBadge(t, "run", "run", run.status)), runBody(run, t, locale));
+    statusBadge(t, "run", "run", run.status)), ...runBody(run, t, locale));
   return element;
 }
 
@@ -107,7 +107,8 @@ export function roleCard(role, t, locale, options) {
 function roleFacts(role, t, locale, opts) {
   const session = opts.runtimeRole && opts.runtimeRole.runtimeSession;
   const rows = [];
-  rows.push([t("role.session"), session && session.nativeSessionId ? mono(session.nativeSessionId) : t("role.noSession")]);
+  rows.push([t("role.session"), session && session.nativeSessionId ? mono(session.nativeSessionId)
+    : !opts.runtimeRole ? t("activity.notLoaded") : t("role.noSession")]);
   if (role.launchRevision !== undefined) rows.push([t("role.desired"), "r" + role.launchRevision + (opts.launchDrift ? " · " + t("role.drift") : "")]);
   if (role.defaultAccess !== undefined) rows.push([t("role.access"), role.defaultAccess]);
   if (opts.retry) rows.push([t("role.providerRetry"), label(t, "retry", opts.retry.status) + " · "

package/dist/web/assets/client/domain/vocab.js

@@ -22,7 +22,7 @@ export function label(t, prefix, value) {
 const TONES = {
   task: { draft: "warn", active: "info", completed: "ok", cancelled: "idle", archived: "idle" },
   exec: {
-    "needs-leader-action": "accent", "waiting-on-agents": "info", "waiting-user": "warn",
+    "needs-leader-action": "accent", "waiting-on-agents": "info", "waiting-on-jobs": "info", "waiting-user": "warn",
     recovering: "warn", attention: "bad", "progressing-with-attention": "warn", blocked: "bad",
     conflicted: "warn", working: "info", completed: "ok", retired: "idle", cancelled: "idle",
     accepted: "ok", open: "info", archived: "idle"

package/dist/web/assets/client/i18n/en.js

@@ -58,7 +58,10 @@ export const EN = {
     "create.hint": "Planning saves a Draft and queues the Leader. It does not start development. Uncheck to save only.",
     "create.open": "Open saved task",
     "workbench.next": "Next step",
-    "workbench.continue": "Continue with the current Leader",
+    "workbench.continue": "Talk to Leader",
+    "workbench.prompt.running": "Talk to the current Leader to adjust direction or add information.",
+    "workbench.prompt.activate": "Start the Task once the draft and plan are confirmed, or keep discussing with the Leader.",
+    "workbench.prompt.archive": "This Task has ended. Archive it, or follow up with the Leader.",
     "workbench.activate": "Start task",
     "workbench.activateConfirm": "Have you confirmed the Draft and plan? Request activation now?",
     "workbench.activateHint": "Uses the existing activation process. A saved request is not an active Task.",
@@ -700,6 +703,19 @@ export const EN = {
     "priority.low": "Low",
     "exec.status.needs-leader-action": "Needs Leader action",
     "exec.status.waiting-on-agents": "Waiting on agents",
+    "exec.status.waiting-on-jobs": "Waiting on background jobs",
+    "exec.action.wait-for-jobs": "Wait for background jobs",
+    "activity.loaded": "Loaded",
+    "activity.none": "No current items in this source.",
+    "activity.notLoaded": "Not loaded. Use the current activity list to read more.",
+    "activity.more": "Load more",
+    "activity.refresh": "Refresh list",
+    "activity.refreshHint": "If the source changed, refresh before continuing.",
+    "activity.busy": "Finish or clear the unsent answer, or wait for the current read before replacing this list.",
+    "activity.reviews": "Unfinished reviews",
+    "activity.native": "Native activity",
+    "activity.openSession": "Open current Role Session",
+    "activity.scope": "Partial coverage: selected native Sessions and retained, exactly identified child observations. Not a live process or complete historical Session inventory. Native facts may describe an AgentRun above; counts must not be added together.",
     "exec.status.waiting-user": "Waiting on you",
     "exec.status.recovering": "Recovering",
     "exec.status.attention": "Needs attention",

package/dist/web/assets/client/i18n/zh-CN.js

@@ -56,7 +56,10 @@ export const ZH_CN = {
     "create.hint": "保存 Draft 并通知 Leader 规划，不启动开发。取消勾选则仅保存任务。",
     "create.open": "打开已保存任务",
     "workbench.next": "下一步",
-    "workbench.continue": "与当前 Leader 继续推进",
+    "workbench.continue": "与 Leader 对话",
+    "workbench.prompt.running": "需要调整方向或补充信息时，直接与当前 Leader 对话。",
+    "workbench.prompt.activate": "确认草稿与方案后启动任务，或继续与 Leader 讨论。",
+    "workbench.prompt.archive": "任务已结束。可以归档，或继续与 Leader 跟进。",
     "workbench.activate": "启动任务",
     "workbench.activateConfirm": "已确认草稿和方案，申请激活此任务？",
     "workbench.activateHint": "复用现有激活流程。请求已保存不代表任务已激活。",
@@ -698,6 +701,19 @@ export const ZH_CN = {
     "priority.low": "低",
     "exec.status.needs-leader-action": "待 Leader 处理",
     "exec.status.waiting-on-agents": "等待智能体",
+    "exec.status.waiting-on-jobs": "等待后台任务",
+    "exec.action.wait-for-jobs": "等待后台任务结果",
+    "activity.loaded": "已加载",
+    "activity.none": "此来源没有当前事项。",
+    "activity.notLoaded": "尚未加载；可通过当前活动列表继续读取。",
+    "activity.more": "继续加载",
+    "activity.refresh": "刷新列表",
+    "activity.refreshHint": "若来源已变化，请刷新后继续。",
+    "activity.busy": "请先完成或清空未发送的回答，或等待当前读取结束，再替换列表。",
+    "activity.reviews": "未结束的审查",
+    "activity.native": "原生活动",
+    "activity.openSession": "打开该角色的当前会话",
+    "activity.scope": "部分覆盖：选中的原生会话，以及身份明确、尚未结束的保留子活动观测；不是实时进程或完整历史会话清单。原生事实可能与上方 AgentRun 描述同一执行，计数不可直接相加。",
     "exec.status.waiting-user": "等待你回答",
     "exec.status.recovering": "恢复中",
     "exec.status.attention": "需要关注",