@zq-silk/yui 0.16.0 → 0.99.0

package/dist/web/assets/client/taskSurface.js

@@ -1,6 +1,7 @@
 export const TASK_SURFACE_SCRIPT = `
 import { node, clear } from "/assets/js/dom.js";
 import { anchorSection, sectionHead, richText, inputCard, roleCard, runCard, pill } from "/assets/js/components.js";
+import { renderTaskSummary, renderEvidence } from "/assets/js/task-summary.js";
 
 // All business facts below retain their Context reference. Expanded values
 // are current reads, not mutations of a historical Context snapshot.
@@ -16,6 +17,10 @@ export function renderTaskSurface(container, data, t, locale, actions) {
   const scaffold = node("div", "detail-scaffold task-surface");
   const summary = node("div", "section-body");
   summary.append(node("span", "detail-kicker", task.id), node("h2", "detail-title", task.title), pill(t, "status", task.status));
+  renderTaskSummary(summary, data, t, locale, actions, recordCard);
+  const discuss = node("details", "record-card");
+  discuss.dataset.viewKey = "discussion";
+  discuss.append(node("summary", "", say("Discuss this Task", "讨论此任务")));
   const conversation = node("button", "record-open", say("View Leader Session (read-only)", "查看 Leader Session（只读）"));
   conversation.type = "button";
   // A Draft's planning Session is a real Leader Session, so it is viewable once it
@@ -26,7 +31,7 @@ export function renderTaskSurface(container, data, t, locale, actions) {
   const hasLeaderSession = Boolean(leaderRole?.runtimeSession?.nativeSessionId);
   conversation.disabled = task.status === "archived" || !hasLeaderSession;
   conversation.addEventListener("click", () => actions.openTerminal({ scope: "task", taskId: task.id, roleName: "leader" }));
-  summary.append(conversation);
+  discuss.append(conversation);
   const chat = node("form", "record-card");
   const chatLabel = node("label", "", say("Message to Task Leader", "发送给 Task Leader"));
   const message = node("textarea", "");
@@ -90,13 +95,15 @@ export function renderTaskSurface(container, data, t, locale, actions) {
         "提交结果未知。请重新加载并检查已保存消息，不要盲目重发 · ") + requestId;
     }
   });
-  summary.append(chat);
+  discuss.append(chat);
+  summary.append(discuss);
   // decision-3 three-action input control (queue / steer / interrupt). This is
   // the same application-layer path the CLI drives; the Web surface adds no
   // fourth action and no auto-fallback. Steer/interrupt name an exact current
   // Turn (expected-target); a mismatch or missing Turn is a visible failure
   // receipt, never a silent downgrade to a queue.
   const control = node("details", "record-card");
+  control.dataset.viewKey = "control";
   control.append(node("summary", "", say("Redirect a running Role (queue / steer / interrupt)",
     "改向运行中的 Role（排队／即时插话／打断）")));
   const controlForm = node("form", "record-block");
@@ -207,8 +214,8 @@ export function renderTaskSurface(container, data, t, locale, actions) {
     // durable read and the one that drives re-rendering. The runtime observation
     // is explicitly optional (it may time out and only ever enriches a live
     // Session), so it must not decide whether a planning Turn is reported.
-    const turnEntries = records("turn");
-    const planningTurns = values("turn").filter((turn) =>
+    const turnEntries = records("run");
+    const planningTurns = values("run").filter((turn) =>
       turn.roleName === "leader" && turn.purpose === "planning");
     // The latest planning Turn, whatever state it reached. A completed planning
     // Turn is still the real observed fact; reporting only active ones would call
@@ -224,19 +231,19 @@ export function renderTaskSurface(container, data, t, locale, actions) {
       ? planningTurn.status
       : withheldTurns ? "withheld" : "not-dispatched";
     planning.append(node("p", "muted", withheldTurns
-      ? say("This bounded snapshot withholds Turn detail; read the Turn directly to see planning state.",
-        "当前受限快照未展开 Turn 详情；请直接读取 Turn 查看规划状态。")
+      ? say("This bounded snapshot withholds AgentRun detail; read the original planning Run.",
+        "当前受限快照未展开 AgentRun 详情；请读取原始 planning Run。")
       : planningTurn === null
-      ? say("No planning Turn has been dispatched yet. Sending a message queues the Leader.",
-        "尚未派发 planning Turn；发送消息会为 Leader 排队。")
+      ? say("No planning AgentRun is included. Direct Session activity is shown separately.",
+        "本次读取未包含 planning AgentRun；直接 Session 活动单独展示。")
       : planningTurn.status === "active"
-      ? say("Planning Turn is active; messages reach the Task Leader.",
-        "planning Turn 正在进行；消息会送达 Task Leader。")
-      : say("Planning Turn reached " + planningTurn.status
+      ? say("The planning AgentRun is open; this is not proof of native activity.",
+        "planning AgentRun 尚未结清；这不证明原生会话仍有活动。")
+      : say("Planning AgentRun reached " + planningTurn.status
         + "; messages reach the same Task Leader and queue the next Turn.",
-        "planning Turn 已" + planningTurn.status + "；消息仍送达同一 Task Leader 并为下一个 Turn 排队。")));
+        "planning AgentRun 已" + planningTurn.status + "；消息仍送达同一 Task Leader 并为下一个 Turn 排队。")));
     const facts = [
-      [say("Planning Turn", "planning Turn"), planningTurn
+      [say("Planning AgentRun", "planning AgentRun"), planningTurn
         ? planningTurn.id + " (" + planningTurn.status + ")"
         : withheldTurns ? say("withheld by this snapshot", "本快照未展开") : say("none", "无")],
       [say("Provider terminal", "Provider 终态"),
@@ -251,7 +258,7 @@ export function renderTaskSurface(container, data, t, locale, actions) {
           ?? say("not currently running", "当前未在运行")],
       [say("Environment", "环境"), environment?.environmentRef
         ?? say("empty (legal for planning)", "空环境（规划阶段合法）")],
-      [say("Turn observed at", "Turn 观测时间"),
+      [say("Run record updated", "Run 记录更新时间"),
         planningTurn?.result?.completedAt ?? planningTurn?.updatedAt ?? say("unknown", "未知")]
     ];
     for (const [label, value] of facts) {
@@ -259,8 +266,13 @@ export function renderTaskSurface(container, data, t, locale, actions) {
     }
     summary.append(planning);
   }
-  if (task.description) summary.append(richText(say("Current requirements", "当前要求"), task.description, t));
-  if (task.completionSummary) summary.append(richText(t("detail.conclusion"), task.completionSummary, t));
+  if (task.description) {
+    const requirements = node("details", "record-card");
+    requirements.dataset.viewKey = "requirements";
+    requirements.append(node("summary", "", say("Original requirements and boundaries", "原始要求与边界")),
+      richText(null, task.description, t));
+    summary.append(requirements);
+  }
   const edit = node("details", "record-card");
   edit.append(node("summary", "", say("Edit Task title", "修改任务标题")));
   const form = node("form", "record-block");
@@ -316,6 +328,9 @@ export function renderTaskSurface(container, data, t, locale, actions) {
       const value = entry.value;
       const text = value.content || value.summary || value.body || value.objective || value.title || value.leaderSummary;
       if (text) card.append(richText(null, text, t));
+      if (entry.ref.store === "task-decision" && value.rationale) {
+        card.append(richText(say("Reason and boundaries", "理由与边界"), value.rationale, t));
+      }
       if (value.status) card.append(node("p", "muted", value.status));
       if (value.roleName) card.append(node("p", "muted", value.roleName));
       if (entry.ref.store === "work-item") {
@@ -357,7 +372,10 @@ export function renderTaskSurface(container, data, t, locale, actions) {
     if (!entries.length) body.append(node("p", "muted", core.omitted.records
       ? say("Not included in this compact read", "此紧凑读取未包含该记录")
       : say("No records", "暂无记录")));
-    scaffold.append(anchorSection(id, sectionHead(name, { count: entries.length }), body));
+    const folded = node("details", "record-card");
+    folded.dataset.viewKey = id;
+    folded.append(node("summary", "", name + " · " + entries.length), body);
+    scaffold.append(anchorSection(id, null, folded));
     return body;
   }
   const focus = section("detail-focus", say("Goal and current focus", "目标与当前关注"), records("task-brief"));
@@ -366,13 +384,10 @@ export function renderTaskSurface(container, data, t, locale, actions) {
     focus.prepend(richText(t("detail.focus"), brief.currentFocus, t));
     if (brief.boundaries.length) focus.append(richText(say("Boundaries", "边界"), brief.boundaries.join("\\n"), t));
   }
-  const questions = node("div", "section-body");
-  records("input-request").filter((entry) => entry.omitted || entry.value.status === "open").forEach((entry) => {
-    questions.append(entry.omitted ? recordCard(entry) : inputCard(entry.value, { single: true }, t, locale, actions));
-  });
-  scaffold.append(anchorSection("detail-attention", sectionHead(t("detail.attention")), questions));
   section("detail-work", say("Responsibilities and acceptance", "工作责任与验收"), records("work-item"));
-  section("detail-results", say("Saved results and provenance", "已保存结果与来源"), records("artifact").concat(records("candidate")));
+  const evidence = node("div", "section-body");
+  renderEvidence(evidence, data, t, locale, actions);
+  scaffold.append(anchorSection("detail-results", sectionHead(say("Results and evidence", "成果与证据")), evidence));
   section("detail-messages", t("detail.messages"), records("task-message"));
   section("detail-history", say("Decisions and milestones", "决策与里程碑"), records("task-decision").concat(records("task-milestone")));
   section("detail-reviews", t("detail.reviews"), records("review-round"));
@@ -381,10 +396,9 @@ export function renderTaskSurface(container, data, t, locale, actions) {
     if (entry.omitted) { roles.append(recordCard(entry)); return; }
     const role = entry.value;
     const active = values("run").find((run) => run.roleName === role.name && run.status === "active");
-    const incomplete = core.omitted.records > 0 || records("run").some((entry) => entry.omitted);
     roles.append(roleCard({
       ...role, providerRetry: entry.providerRetry,
-      status: entry.providerRetry?.status === "waiting" ? "waiting" : active || incomplete ? "unknown" : "idle",
+      status: entry.providerRetry?.status === "waiting" ? "waiting" : "unknown",
       effectiveLaunch: active ? active.effective : null,
       launchDrift: active && active.effective.sourceDesiredRevision !== role.launchRevision
     }, task, t, locale, actions));
@@ -392,8 +406,12 @@ export function renderTaskSurface(container, data, t, locale, actions) {
       "No active AgentRun in this read; Session activity is a separate observation.",
       "此读取中没有活跃 AgentRun；Session 活动属于独立观察。")));
   });
-  scaffold.append(anchorSection("detail-roles", sectionHead(t("detail.roles")), roles));
+  const roleDetails = node("details", "record-card");
+  roleDetails.dataset.viewKey = "roles";
+  roleDetails.append(node("summary", "", t("detail.roles")), roles);
+  scaffold.append(anchorSection("detail-roles", null, roleDetails));
   const execution = node("details", "record-card");
+  execution.dataset.viewKey = "execution";
   execution.append(node("summary", "", say("Execution and observations", "展开执行与观察")));
   execution.append(node("p", "muted", say(
     "An open execution record is not proof of Agent activity. Native admission and Task progress are separate facts.",

package/dist/web/assets/client/view.js

@@ -3,6 +3,7 @@ export const VIEW_SCRIPT = `
 // All reusable widgets and cards come from components.js.
 import { clear, node } from "/assets/js/dom.js";
 import { renderTaskSurface } from "/assets/js/task-surface.js";
+import { renderSessionSummary } from "/assets/js/task-summary.js";
 import { byNewest, formatDateTime } from "/assets/js/format.js";
 import {
   anchorSection,
@@ -162,6 +163,10 @@ export function renderOverview(detail, state, t, locale, onSelect) {
   const counts = state.counts;
 
   const total = counts ? counts.total : 0;
+  const say = (en, cn) => locale.startsWith("zh") ? cn : en;
+  wrap.append(node("p", "muted", say(
+    "Attention counts cover the authorized catalog before search/status filters; task lists below cover this page.",
+    "关注计数覆盖搜索／状态过滤前的可见目录；下方任务列表仅覆盖当前页。")));
   const rail = node("div", "command-rail");
   rail.append(
     metricTile(t("metrics.active"), counts ? counts.active : "—", { hot: true }),
@@ -208,6 +213,32 @@ export function renderOverview(detail, state, t, locale, onSelect) {
   }
   wrap.append(inbox);
   if (state.catalogScope) wrap.append(node("p", "", t("catalog.pageScope")));
+  const sessions = node("section", "overview-block");
+  sessions.append(sectionHead(say("Session activity · current page only", "会话活动 · 仅当前页")));
+  sessions.append(node("p", "muted", say(
+    "Not loaded by the compact list. Active Task / AgentRun counts cannot establish how many native Sessions are running.",
+    "紧凑列表不加载会话观察。Active Task／AgentRun 数不能说明有几个原生会话在运行。")));
+  const observe = node("button", "record-open", say("Read this page's Sessions", "读取本页会话"));
+  observe.type = "button";
+  observe.dataset.observeSessions = "";
+  observe.disabled = state.sessionLoading || !state.tasks.length;
+  sessions.append(observe);
+  if (state.sessionError) sessions.append(node("p", "muted", state.sessionError));
+  if (state.sessionOverview) {
+    sessions.append(node("p", "muted", say("Read at: ", "读取于：") + formatDateTime(state.sessionOverview.readAt, locale)));
+    for (const task of state.sessionOverview.tasks) {
+      const card = node("article", "record-card");
+      const open = node("button", "record-open", task.taskId + " · " + task.title);
+      open.type = "button";
+      open.addEventListener("click", () => onSelect(task.taskId));
+      card.append(open);
+      const body = node("div", "");
+      renderSessionSummary(body, task, locale);
+      card.append(body);
+      sessions.append(card);
+    }
+  }
+  wrap.append(sessions);
 
   // Tasks whose Task-first projection says they need attention: blocked,
   // recovering, or in an attention state. This replaces the raw stalled-AgentRun
@@ -228,6 +259,8 @@ export function renderOverview(detail, state, t, locale, onSelect) {
         task,
         t("exec.status." + task.executionStatus),
         "has-inputs",
+        t,
+        locale,
         onSelect
       ));
     });

package/dist/web/assets/shell.js

@@ -89,6 +89,7 @@ export const DASHBOARD_HTML = `<!doctype html>
       <nav id="detail-tabs" class="detail-tabs" aria-label="Task sections" data-i18n-aria-label="tabs.label" hidden>
         <button class="tab" type="button" data-target="detail-top" data-i18n="tabs.summary">Summary</button>
         <button class="tab" type="button" data-target="detail-focus" data-i18n="tabs.focus">Focus</button>
+        <button class="tab" type="button" data-target="detail-results" data-i18n="tabs.results">Results</button>
         <button class="tab" type="button" data-target="detail-work" data-i18n="tabs.work">Work items</button>
         <button class="tab" type="button" data-target="detail-exec" data-i18n="tabs.exec">AgentRuns</button>
         <button class="tab" type="button" data-target="detail-reviews" data-i18n="tabs.reviews">Reviews</button>

package/dist/web/assets/styles/cards.js

@@ -23,6 +23,27 @@ export const CARD_STYLES = `
 .task-surface button { min-height:40px; }
 .task-surface summary { cursor:pointer; padding:8px 0; font-weight:600; }
 .task-surface [role=status] { overflow-wrap:anywhere; }
+.summary-block h3 { margin:0 0 12px; font-size:16px; }
+.summary-block h4 { margin:12px 0 4px; }
+.summary-block p { overflow-wrap:anywhere; }
+.task-summary-grid { display:grid; gap:12px; min-width:0; align-items:start; }
+.task-summary-grid .summary-block { display:block; }
+.task-summary-grid .summary-block p { margin:8px 0; }
+.task-surface .record-pills { flex-wrap:wrap; max-width:100%; }
+@media (min-width:1100px) {
+  .task-summary-grid { grid-template-columns:repeat(2,minmax(0,1fr)); }
+}
+.session-counts { display:flex; flex-wrap:wrap; gap:8px; }
+.session-count { padding:6px 10px; background:var(--bg-3); border:1px solid var(--border); border-radius:var(--radius); }
+.session-row { padding:12px 0; border-top:1px solid var(--border); overflow-wrap:anywhere; }
+.artifact-choice { text-align:left; white-space:normal; overflow-wrap:anywhere; }
+.task-surface .artifact-text { max-height:32rem; padding:16px; border:1px solid var(--border); background:var(--bg-1); }
+.task-surface .mono { overflow-wrap:anywhere; }
+.task-surface .muted { overflow-wrap:anywhere; min-width:0; }
+.task-surface .observability-metrics { grid-template-columns:repeat(auto-fit,minmax(min(100%,12rem),1fr)); }
+.task-surface .observability-metrics .metric { flex-direction:column; align-items:flex-start; min-width:0; }
+.task-surface .observability-metrics .metric-value { overflow-wrap:anywhere; max-width:100%; }
+.task-surface button { min-height:44px; }
 /* Overview scaffolding */
 .overview{display:grid;gap:14px;padding-top:2px}
 .overview-duo{display:grid;grid-template-columns:1fr 1fr;gap:14px;align-items:start}

package/dist/web/webServer.js

@@ -6,7 +6,7 @@ import { parseTaskCatalogOptions } from "../context/taskCatalog.js";
 import { WebRequestRejected } from "./webMutation.js";
 import { TASK_SUBMISSION_INTENTS } from "../message/message.js";
 import { DASHBOARD_HTML, findWebAsset } from "./assets/assetManifest.js";
-import { buildWebTaskCatalog, buildWebTaskDetail } from "./webSnapshot.js";
+import { buildWebTaskCatalog, buildWebPageSessions, buildWebTaskDetail } from "./webSnapshot.js";
 const MAX_JSON_BODY_BYTES = 16 * 1024;
 const MAX_TERMINAL_MESSAGE_BYTES = 64 * 1024;
 const MAX_TERMINAL_BUFFERED_BYTES = 1024 * 1024;
@@ -100,6 +100,37 @@ async function handleHttpRequest(request, response, store, dependencies, token,
         sendJson(response, 403, { error: "Invalid Yui web token.", disposition: "not-submitted" }, method === "HEAD");
         return;
     }
+    const artifactTarget = /^\/api\/tasks\/([^/]+)\/(artifacts|evidence)$/.exec(pathname);
+    if (artifactTarget && dependencies.surface) {
+        if (method !== "GET") {
+            sendJson(response, 405, { error: "Artifacts are read-only." }, false);
+            return;
+        }
+        try {
+            const taskId = decodeURIComponent(artifactTarget[1]);
+            const query = new URL(request.url, "http://localhost").searchParams;
+            if (artifactTarget[2] === "evidence") {
+                if ([...query.keys()].length)
+                    throw new WebRequestRejected("Evidence read takes no additional parameters.");
+                sendJson(response, 200, dependencies.surface.evidence(taskId), false);
+                return;
+            }
+            if ([...query.keys()].some(key => !["path", "commit"].includes(key))) {
+                throw new WebRequestRejected("Artifact read accepts only path and commit.");
+            }
+            const path = query.get("path");
+            const commit = query.get("commit");
+            if ((path === null) !== (commit === null))
+                throw new WebRequestRejected("Select path and fixed commit together.");
+            const result = path === null ? await dependencies.surface.artifacts(taskId)
+                : await dependencies.surface.artifact(taskId, path, commit);
+            sendJson(response, 200, result, false);
+        }
+        catch (error) {
+            sendJson(response, 409, { error: error instanceof Error ? error.message : "Artifact unavailable." }, false);
+        }
+        return;
+    }
     const globalControl = /^\/api\/roles\/([^/]+)\/control$/.exec(pathname);
     if (globalControl && dependencies.surface) {
         try {
@@ -236,18 +267,21 @@ async function handleHttpRequest(request, response, store, dependencies, token,
             else if (asset !== null) {
                 sendAsset(response, asset, method === "HEAD");
             }
-            else if (pathname === "/api/dashboard") {
+            else if (pathname === "/api/dashboard" || pathname === "/api/dashboard/sessions") {
                 const query = new URL(request.url, "http://localhost").searchParams;
-                const snapshot = buildWebTaskCatalog(store, parseTaskCatalogOptions([...query].flatMap(([key, value]) => key === "all"
+                const options = parseTaskCatalogOptions([...query].flatMap(([key, value]) => key === "all"
                     ? (value === "true" ? ["--all"] : ["--invalid-all"])
-                    : [`--${key}`, value])));
+                    : [`--${key}`, value]));
+                const snapshot = pathname.endsWith("/sessions")
+                    ? buildWebPageSessions(store, options, now())
+                    : buildWebTaskCatalog(store, options);
                 sendJson(response, 200, snapshot, method === "HEAD");
             }
             else if (pathname.startsWith("/api/tasks/")) {
                 const taskId = decodeURIComponent(pathname.slice("/api/tasks/".length));
                 const detail = taskId.length === 0 || taskId.includes("/")
                     ? null
-                    : buildWebTaskDetail(store, taskId);
+                    : buildWebTaskDetail(store, taskId, now());
                 sendJson(response, detail === null ? 404 : 200, detail ?? { error: "Task not found." }, method === "HEAD");
             }
             else {

package/dist/web/webSessions.js

@@ -0,0 +1,165 @@
+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 projectWebSessions(input) {
+    const policy = input.policy ?? DEFAULT_RUNTIME_HEALTH_POLICY;
+    const sessions = [];
+    const seen = new Map();
+    const observations = input.events.map(event => ({ event, observation: runtimeObservationFromTaskEvent(event) }))
+        .filter(entry => entry.observation !== null);
+    for (const set of input.sessionSets) {
+        const session = set.sessions[set.activeAgentId];
+        const binding = set.providerBinding;
+        const conversation = binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch && c.status === "current");
+        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;
+        const row = {
+            taskId: input.taskId, roleName: set.owner.roleName, agentId: set.activeAgentId,
+            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 || !binding || !conversation || conversation.conversationId !== session.nativeSessionId) {
+            sessions.push(row);
+            continue;
+        }
+        let driverId;
+        try {
+            driverId = builtinDriverIdForAdapter(session.adapterId);
+        }
+        catch {
+            sessions.push(row);
+            continue;
+        }
+        const fence = { taskId: input.taskId, roleName: set.owner.roleName,
+            agentId: session.agentId, driverId, nativeSessionId: session.nativeSessionId };
+        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 = [...groups].flatMap(([runId, events]) => {
+            const projection = projectRuntimeTaskEvents({ ...fence, ...(runId ? { runId } : {}) }, session.createdAt, events);
+            const children = Object.entries(projection.continuations)
+                .filter(([, c]) => c.execution !== "quiescent" || c.identityConflict)
+                .map(([id, c]) => ({ id: `${runId ?? "native"}/${id}`, execution: c.execution }));
+            return [...children, ...Object.entries(projection.operations)
+                    .filter(([, operation]) => operation.kind === "subagent")
+                    .map(([id]) => ({ id: `${runId ?? "native"}/operation:${id}`, execution: "unsettled" }))];
+        });
+        if (!turn) {
+            sessions.push({ ...row, background, ...(background.length ? {
+                    group: "background", reason: "Retained background execution is not settled."
+                } : {}) });
+            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 });
+    }
+    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-selected-native-sessions", taskId: input.taskId,
+        readAt: input.now.toISOString(), counts, sessions,
+        coverage: "Recorded selected Sessions only; not a live process or historical resource inventory." };
+}

package/dist/web/webSnapshot.js

@@ -1,4 +1,5 @@
 import { providerRetryProjection } from "../runtime/providerRetry.js";
+import { projectWebSessions } from "./webSessions.js";
 import { readTaskCatalog } from "../context/taskCatalog.js";
 import { isRoleRunStalled, latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
@@ -14,6 +15,23 @@ import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
 export function buildWebTaskCatalog(store, options) {
     return store.transaction(reader => readTaskCatalog(reader, options));
 }
+/** Explicit optional read of just one visible catalog page. Never part of the
+ * compact discovery contract, and never an unfiltered global Session count. */
+export function buildWebPageSessions(store, options, now) {
+    return store.transaction(reader => {
+        const page = readTaskCatalog(reader, options);
+        const tasks = page.tasks.map(task => ({
+            title: task.title,
+            ...projectWebSessions({ taskId: task.id, sessionSets: reader.listRoleSessionSets(task.id),
+                events: reader.listEvents(task.id), now,
+                ...(reader.getTaskBrief(task.id)?.updatedAt === undefined ? {} : {
+                    semanticProgressAt: reader.getTaskBrief(task.id).updatedAt
+                }),
+                policy: resolveRuntimeHealth(reader.getConfig().runtimeHealth) })
+        }));
+        return { scope: "current-catalog-page", readAt: now.toISOString(), tasks };
+    });
+}
 export function buildWebTaskDetail(store, taskId, now = new Date()) {
     return store.transaction((reader) => {
         const task = reader.getTask(taskId);
@@ -90,6 +108,11 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
                 ...(projectNames.length === 0 ? {} : { projectNames })
             },
             execution,
+            sessions: projectWebSessions({ taskId, sessionSets: roleSessionSets, events, now,
+                ...(reader.getTaskBrief(taskId)?.updatedAt === undefined ? {} : {
+                    semanticProgressAt: reader.getTaskBrief(taskId).updatedAt
+                }),
+                policy: resolveRuntimeHealth(reader.getConfig().runtimeHealth) }),
             remoteDelivery,
             observability: execution.observability,
             brief: reader.getTaskBrief(taskId),

package/dist/web/webTaskSurface.js

@@ -1,3 +1,5 @@
+import { readArtifactCapability } from "../artifacts/artifactCapability.js";
+import { openTaskArtifactRepository } from "../artifacts/taskArtifactRepository.js";
 import { applyGlobalInputControl } from "../commands/globalRoleCommands.js";
 import { applyTaskInputControl, sendTaskMessageCommand, updateTaskMetadataCommand } from "../commands/taskCommands.js";
 import { runTaskInputCommand } from "../commands/taskInputCommands.js";
@@ -37,6 +39,27 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
             ? { kind: "role", taskId, roleName: "leader" } : { kind: "task", taskId });
     };
     return {
+        evidence: (taskId) => store.transaction(reader => {
+            if (reader.getTask(taskId) === null)
+                throw new WebRequestRejected("Task not found.");
+            return { taskId, integrations: reader.listIntegrationAttempts(taskId),
+                reviews: reader.listReviewRounds(taskId), workspaces: reader.listManagedWorkspaces(taskId) };
+        }),
+        artifacts: async (taskId) => {
+            if (store.getTask(taskId) === null)
+                throw new WebRequestRejected("Task not found.");
+            const repo = openTaskArtifactRepository(store.rootDirectory(), taskId);
+            const commit = await repo.head();
+            const entries = commit === null ? [] : await repo.list(commit);
+            return { taskId, commit, entries };
+        },
+        artifact: async (taskId, relativePath, commit) => {
+            if (store.getTask(taskId) === null)
+                throw new WebRequestRejected("Task not found.");
+            // The browser always names a fixed revision. Never substitute HEAD after
+            // a missing object, and never execute/render artifact HTML as an app.
+            return readArtifactCapability(store.rootDirectory(), taskId, { relativePath, commit });
+        },
         globalState: (roleName) => {
             const role = store.getGlobalRole(roleName);
             if (role === null)