@zq-silk/yui 2.5.0 → 2.6.0

package/dist/web/assets/shell/settings.js

@@ -5,6 +5,7 @@ export const SETTINGS_HTML = `<!doctype html>
 <head>
   <meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="yui-web-token" content="__YUI_WEB_TOKEN__">
+  <script src="/assets/theme.js"></script>
   <link rel="icon" href="data:,"><title>Yui · Settings</title>
   ${STYLESHEETS.map(s => `<link rel="stylesheet" href="/assets/css/${s.name}.css">`).join("\n")}
 </head>

package/dist/web/assets/styles/views/task.js

@@ -53,6 +53,20 @@ export const TASK_STYLES = `
 .next-line .icon{color:var(--accent)}
 .next-line strong{color:var(--ink)}
 
+/* Next step: a compact action bar — prompt left, actions right; the foot
+   (condition + receipt) is one quiet line under a hairline. */
+.next-card>.card-body{gap:0;padding:14px 16px 14px 20px}
+.next-row{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:12px 20px}
+.next-lead{display:grid;gap:3px;flex:1 1 280px;min-width:0}
+.next-kicker{color:var(--ink-4);font-size:var(--fs-2xs);font-weight:600;letter-spacing:.08em;text-transform:uppercase}
+.next-prompt{color:var(--ink-2);font-size:var(--fs-sm);line-height:1.5}
+.next-actions{display:flex;flex-wrap:wrap;align-items:center;gap:8px;flex:none}
+.next-actions .btn{height:34px;padding:0 14px}
+.next-foot{display:flex;flex-wrap:wrap;align-items:baseline;justify-content:space-between;gap:4px 16px;margin-top:12px;padding-top:10px;border-top:1px dashed var(--line)}
+.next-hint{flex:1 1 320px;min-width:0;color:var(--ink-4);font-size:var(--fs-xs);line-height:1.5}
+.next-foot .receipt:empty{display:none}
+@media(max-width:560px){.next-actions{flex:1 1 100%}.next-actions .btn{flex:1 1 0}}
+
 /* Needs you / input requests */
 .needs-card{border-color:var(--warn);box-shadow:0 0 0 3px var(--warn-soft)}
 .needs-card .card-icon{background:var(--warn-soft);color:var(--warn)}

package/dist/web/webServer.js

@@ -5,6 +5,7 @@ import { CliError, usageError } from "../errors/cliError.js";
 import { parseTaskCatalogOptions } from "../context/taskCatalog.js";
 import { parseTaskSearchOptions, searchTaskBodies } from "../context/taskSearch.js";
 import { readTaskUsage } from "../runtime/taskUsageQuery.js";
+import { readWebTaskActivity } from "./webTaskActivity.js";
 import { WebRequestRejected } from "./webMutation.js";
 import { SETTINGS_HTML } from "./assets/shell/settings.js";
 import { TASK_SUBMISSION_INTENTS } from "../message/message.js";
@@ -484,6 +485,7 @@ async function handleHttpRequest(request, response, store, dependencies, token,
                     throw new WebRequestRejected("Invalid list limit.");
                 value = dependencies.surface.list(taskId, {
                     store: query.get("store") ?? "",
+                    ...(query.has("view") ? { view: query.get("view") } : {}),
                     ...(query.has("status") ? { status: query.get("status") } : {}),
                     ...(query.has("cursor") ? { cursor: query.get("cursor") } : {}),
                     ...(limit === null ? {} : { limit: Number(limit) })
@@ -552,6 +554,16 @@ async function handleHttpRequest(request, response, store, dependencies, token,
                     : buildWebTaskCatalog(store, options);
                 sendJson(response, 200, snapshot, method === "HEAD");
             }
+            else if (/^\/api\/tasks\/[^/]+\/activity$/u.test(pathname)) {
+                const taskId = decodeURIComponent(pathname.split("/")[3]);
+                const query = new URL(request.url, "http://localhost").searchParams;
+                if ([...query.keys()].some(key => !["limit", "cursor"].includes(key)))
+                    throw usageError("Invalid activity option.");
+                sendJson(response, 200, readWebTaskActivity(store, taskId, {
+                    ...(query.has("limit") ? { limit: Number(query.get("limit")) } : {}),
+                    ...(query.has("cursor") ? { cursor: query.get("cursor") } : {})
+                }, now()), method === "HEAD");
+            }
             else if (/^\/api\/tasks\/[^/]+\/usage$/u.test(pathname)) {
                 const taskId = decodeURIComponent(pathname.split("/")[3]);
                 const query = new URL(request.url, "http://localhost").searchParams;

package/dist/web/webSessions.js

@@ -1,165 +1,2 @@
-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." };
-}
+// CLI and Web share the same read-only native observation fold.
+export { projectTaskSessions as projectWebSessions } from "../runtime/taskSessions.js";

package/dist/web/webSnapshot.js

@@ -96,14 +96,14 @@ export function buildWebTaskDetail(store, taskId, now = new Date(), compact = fa
                     && effectiveLaunch.sourceDesiredRevision !== role.launchRevision
             };
         });
-        const execution = buildTaskExecutionProjection(reader, taskId, now);
-        if (execution === null)
-            return null;
         const brief = reader.getTaskBrief(taskId);
         const roleSessionSets = reader.listRoleSessionSets(taskId);
         const sessions = projectWebSessions({ taskId, sessionSets: roleSessionSets, events, now,
             ...(brief?.updatedAt === undefined ? {} : { semanticProgressAt: brief.updatedAt }),
             policy: resolveRuntimeHealth(reader.getConfig().runtimeHealth) });
+        const execution = buildTaskExecutionProjection(reader, taskId, now, sessions);
+        if (execution === null)
+            return null;
         if (compact) {
             // Observation is not semantic progress. No Task/Message/Run bodies,
             // Role history or validation logs ride the default polling response.
@@ -115,15 +115,19 @@ export function buildWebTaskDetail(store, taskId, now = new Date(), compact = fa
                     monitoring: execution.monitoring, failClosed: execution.failClosed,
                     activeRuns: execution.activeRuns.slice(0, 16).map(run => ({ id: run.id })),
                     activeRunCount: execution.activeRuns.length,
+                    activity: execution.activity,
                     attention: execution.attention.slice(0, 8).map(item => ({ ...item, summary: clip(item.summary) })),
                     blockers: execution.blockers.slice(0, 8).map(item => ({ ...item, summary: clip(item.summary) }))
                 },
+                roleCount: roles.length,
                 roles: roles.slice(0, 16).map(role => ({
                     name: role.name, status: role.status, runtimeSession: role.runtimeSession
                 })),
-                sessions: { ...sessions, sessions: sessions.sessions.slice(0, 16).map(session => ({
+                sessions: { ...sessions, total: sessions.sessions.length, coverageStatus: "partial",
+                    sessions: sessions.sessions.slice(0, 16).map(session => ({
                         ...session, reason: session.reason.slice(0, 1200),
-                        operations: session.operations.slice(0, 16), background: session.background.slice(0, 16)
+                        operationCount: session.operations.length, backgroundCount: session.background.length,
+                        operations: [], background: []
                     })) },
                 observability: {
                     cost: execution.observability.cost,

package/dist/web/webTaskActivity.js

@@ -0,0 +1,54 @@
+import { taskNotFound } from "../errors/cliError.js";
+import { recordPage } from "../output/boundedRead.js";
+import { resolveRuntimeHealth } from "../config/yuiConfig.js";
+import { projectTaskSessions } from "../runtime/taskSessions.js";
+/** Native observations are not durable execution records. Flatten only the
+ * unfinished, recorded facts so one bounded page cannot hide a large child
+ * collection inside a single Session. Detail remains in the native Session. */
+export function nativeActivityRows(projection) {
+    return projection.sessions.flatMap(session => {
+        const identity = {
+            roleName: session.roleName, agentId: session.agentId,
+            driverId: session.driverId,
+            nativeSessionId: session.nativeSessionId, runId: session.runId,
+            sourceUpdatedAt: session.sourceUpdatedAt
+        };
+        const key = JSON.stringify([session.roleName, session.agentId, session.driverId, session.nativeSessionId]);
+        return [
+            ...(["idle", "stopped"].includes(session.group) ? [] : [{
+                    ...identity, id: key, kind: "session", status: session.group,
+                    summary: session.reason.slice(0, 1200), waitingReason: session.waitingReason,
+                    lastActivityAt: session.lastActivityAt
+                }]),
+            ...session.operations.filter(operation => !operation.startsWith("subagent:")).map(operation => ({
+                ...identity, id: `${key}/operation/${operation}`, kind: "operation",
+                status: "unsettled", summary: operation.slice(0, 1200)
+            })),
+            ...session.background.map(child => ({
+                ...identity, runId: child.runId, id: `${key}/background/${child.id}`, kind: "background",
+                status: child.execution, summary: child.id.slice(0, 1200)
+            }))
+        ];
+    });
+}
+export function readWebTaskActivity(store, taskId, options, now = new Date()) {
+    return store.readTransaction(reader => {
+        if (reader.getTask(taskId) === null)
+            throw taskNotFound(taskId);
+        const projection = projectTaskSessions({
+            taskId, sessionSets: reader.listRoleSessionSets(taskId), events: reader.listEvents(taskId), now,
+            policy: resolveRuntimeHealth(reader.getConfig().runtimeHealth)
+        });
+        const rows = nativeActivityRows(projection);
+        return {
+            ...recordPage(rows, `task:${taskId}/native-activity`, options),
+            readAt: now.toISOString(), coverage: "partial",
+            scope: projection.coverage,
+            counts: {
+                sessions: rows.filter(row => row.kind === "session").length,
+                operations: rows.filter(row => row.kind === "operation").length,
+                background: rows.filter(row => row.kind === "background").length
+            }
+        };
+    });
+}

package/dist/web/webTaskSurface.js

@@ -349,6 +349,7 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
         // The same paged family discovery as `task context list`: summaries and
         // exact references, never bodies; continuations keep their filters.
         list: (taskId, input) => listTaskContext(store, taskId, input.store, {
+            ...(input.view === undefined ? {} : { view: input.view }),
             ...(input.status === undefined ? {} : { status: input.status }),
             ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
             ...(input.limit === undefined ? {} : { limit: input.limit })

package/docs/observability/README.md

@@ -108,8 +108,32 @@ All routes use the local Web token and Task boundary.
 `GET /api/tasks/<id>/artifacts` lists a fixed repository revision;
 `?path=<relative-path>&commit=<full-commit>` reads its exact text file.
 `GET /api/tasks/<id>/evidence` reads original check/Review/workspace records.
-`GET /api/tasks/<id>/list?store=<family>[&status&cursor&limit]` returns the same
+`GET /api/tasks/<id>/list?store=<family>[&view=current|all&status&cursor&limit]` returns the same
 paged summaries as `task context list`.
+
+`task context list <task> --store <family> --view current` uses the same
+membership as the compact Context counts: active runs, pending/running reviews,
+open InputRequests and queued/running/unknown Jobs. The default `all` view
+preserves history. Each continuation binds the filtered collection and rejects
+changed sources; refresh instead of mixing versions. Runtime lists expose
+loaded/total counts, continuation, explicit refresh and read failures. Exact
+record bodies remain on demand.
+
+`GET /api/tasks/<id>/activity[?cursor=...&limit=20]` is a token-authenticated,
+read-only page of recorded native Session, operation and background facts.
+It uses the shared runtime projection, including retained, exactly fenced
+children after Session replacement; it never probes processes or Providers.
+Pages contain at most 100 items and 32 KiB, with separate category counts,
+read time and explicit partial coverage. Compact observations carry full
+counts with bounded Session samples, not nested child lists. Native facts and
+AgentRuns can describe the same execution; their counts are not additive.
+Unknown, unloaded and unavailable observations must not mean no activity.
+
+The execution summary includes Job and native facts alongside open inputs and
+AgentRuns. `waiting-on-jobs` is a derived display/next-action state, not a Task
+lifecycle value. Waiting for a user keeps parallel work visible; unknown Job
+outcomes or native activity remain attention facts, never completion or replay
+authority.
 These reads do not start a runtime, fetch a remote, write business state, require
 a migration, or introduce a new persistent protocol.
 

package/docs/observability/README.zh-CN.md

@@ -89,8 +89,25 @@ skipped／缺失检查不算通过。工作区所有权不证明可清理；既
 `GET /api/tasks/<id>/artifacts` 列出固定仓库版本；
 `?path=<relative-path>&commit=<full-commit>` 读取该版本文本；
 `GET /api/tasks/<id>/evidence` 读取原检查／Review／工作区记录；
-`GET /api/tasks/<id>/list?store=<family>[&status&cursor&limit]` 返回与
+`GET /api/tasks/<id>/list?store=<family>[&view=current|all&status&cursor&limit]` 返回与
 `task context list` 相同的分页摘要。
+
+`task context list <task> --store <family> --view current` 与紧凑 Context
+计数使用同一筛选：active Run、pending/running Review、open InputRequest，
+以及 queued/running/unknown Job。默认 `all` 保留历史。分页游标绑定筛选后的
+集合，来源变化时明确拒绝继续拼接；应刷新重读。运行页展示已加载/总数、继续
+加载、刷新及读取失败，记录原文仍按需展开。
+
+`GET /api/tasks/<id>/activity[?cursor=...&limit=20]` 是经过 token 鉴权的只读
+原生会话、operation 和后台活动分页。复用共享运行投影，覆盖会话更换后身份
+明确的保留子活动，不探测系统进程或 Provider。每页最多 100 项、32 KiB，
+包含分类计数、读取时间和明确的 partial 覆盖范围。紧凑观测返回完整计数及
+有限的会话样本，不携带嵌套子活动清单。原生事实与 AgentRun 可能指向同一
+执行，计数不可相加；未知、未加载和观测不可用都不能表示没有活动。
+
+执行摘要同时考虑 Job、原生事实、用户输入和 AgentRun。`waiting-on-jobs`
+只是派生展示/下一步状态，不改变 Task 生命周期。等待用户不隐藏并行工作；
+未知 Job 结果和原生活动保留为关注事实，不能据此判定完成或授权重放。
 读取不启动运行时、不访问远端、不写业务状态、不引入迁移或新持久协议。
 
 ## 执行审计

package/docs/provider-retry.md

@@ -21,6 +21,10 @@ next input. Agents still own semantic recovery and acceptance.
 - An explicit manual retry of the same Run retains its recovery lineage,
   automatic count and original deadline. It is not charged as an automatic
   attempt, but a further failure cannot replenish automatic allowance.
+  If no automatic chain exists, it can still use the current binding's exact
+  accepted failed Turn and original input. The error need not have qualified
+  for automation; manual intent does not waive Session, authority, latest-Turn
+  or background-quiescence checks.
 
 The records live on the existing Provider binding, with indexed pending-record
 reads and the existing Controller deadline timer. There is no retry Task status,
@@ -56,6 +60,13 @@ failure and earlier chain references. A changed error that still satisfies the
 same safe retry rule continues within the original budget. Loss of that rule,
 authority or budget stops automatic submission.
 
+Codex's structured `codexErrorInfo: "serverOverloaded"` qualifies as temporary
+capacity failure. Capacity prose alone does not grant replay eligibility.
+Native nonterminal error/retry notifications do not create a Yui retry; only
+the exact failed terminal does. A missing retry record therefore does not
+prove budget exhaustion or an unrecoverable Session: inspect the original
+error and current Turn before choosing explicit recovery.
+
 Task errors retain their original `runtime.agent-error` evidence and notify the
 Leader, or the Operator when the affected Role is the Leader. Global failures
 retain record-only Messages in their own Role inbox, including intermediate

package/docs/release-workflow.md

@@ -51,6 +51,33 @@ merely to avoid a version decision. Package versions remain distinct from protoc
 and persistent-storage contracts: their compatibility checks and required migrations
 are unchanged, and the storage rules below do not authorize a package release.
 
+### 2.6.0 compatibility and migration notes
+
+This minor includes Task111's paged current activity and parallel execution
+summary. Task runtime lists can discover all current Roles, Runs, Reviews,
+Jobs and open InputRequests beyond the compact samples; exact record details
+remain on demand. `task context list --view current` selects current membership,
+while the default `all` retains history. Refresh a changed collection instead
+of reusing its stale pagination cursor.
+
+Execution consumers must handle the additional derived `waiting-on-jobs`
+status and `wait-for-jobs` action, and the parallel `activity` categories.
+These are not Task lifecycle states or new scheduling authority. Waiting for
+user input no longer hides concurrent work. Unknown outcomes remain unknown
+and never authorize replay.
+
+Compact native observations now return category totals and bounded Session
+samples with `operationCount`/`backgroundCount`, not embedded child lists.
+Consumers needing those rows must page `/api/tasks/<id>/activity`.
+Coverage is explicitly partial: selected native Sessions and retained,
+exactly fenced child observations, not a live process inventory. Native facts
+may describe an AgentRun and must not be added to it as separate executors.
+
+No storage migration is added; storage remains **1.6**. Existing acceptance
+evidence uses deterministic tests and isolated browser fixtures, not real-model
+validation. Publishing this package does not upgrade a global CLI, migrate a
+Home or restart a Controller.
+
 ### 2.5.0 compatibility and migration notes
 
 This minor includes Task110's notification and context-loading improvements.

package/docs/release-workflow.zh-CN.md

@@ -36,6 +36,28 @@ Agent 选择一个预先声明的计划，设施从持久状态驱动该计划
 不能将不兼容冒称为兼容，也不为回避版本选择新增历史兼容机制。包版本与协议、
 持久存储契约仍然独立：兼容性检查和必要迁移要求不变，下文存储规则不授予发版权限。
 
+### 2.6.0 兼容性及迁移说明
+
+本 minor 包含 Task111 的当前活动分页与并行执行摘要。任务运行列表可发现超出
+紧凑样本的全部当前 Role、Run、Review、Job 及 open InputRequest，精确记录
+仍按需展开。`task context list --view current` 筛选当前事项，默认 `all`
+保留历史。集合变化后须刷新，不可继续使用旧分页游标拼接结果。
+
+执行摘要的消费者须支持新增的派生状态 `waiting-on-jobs`、动作
+`wait-for-jobs` 及并行 `activity` 分类。这些不是 Task 生命周期状态，
+也不增加调度权限。等待用户输入不再隐藏并行工作；未知结果仍为未知，
+不能据此重放执行。
+
+紧凑原生观测现在返回分类总数及有界会话样本，使用
+`operationCount`/`backgroundCount`，不再内嵌子活动列表。需要这些记录的
+消费者须分页读取 `/api/tasks/<id>/activity`。覆盖范围明确为 partial：
+选中的原生会话及身份明确的保留子活动观测，不是实时进程清单。原生事实
+可能描述同一个 AgentRun，不可相加为独立执行者数量。
+
+没有新增存储迁移，存储版本仍为 **1.6**。既有验收证据来自确定性测试和
+隔离浏览器夹具，不代表真实模型验证。发布此包不升级全局 CLI、不迁移 Home，
+也不重启 Controller。
+
 ### 2.5.0 兼容性及迁移说明
 
 本 minor 包含 Task110 的通知和上下文加载优化。正常与恢复通知共用有界事实、

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/skills/yui-runtime/references/recovery.md

@@ -93,6 +93,15 @@ Assignment from memory. A new Host process need not mean a new native Session.
 Preserve frozen Review candidates and selected synthesis sources on retry.
 An infrastructure failure is not a defect in the business result.
 
+Native internal retries are not failed terminals: observe without submitting
+another input. A missing automatic retry record is not evidence of exhausted
+budget or a damaged Session. An explicit `task run retry <task>/<run>` can
+continue from the current exact failed Turn even without an earlier automatic
+chain. Codex `systemError` alone does not require replacement; the normal
+submission path checks that the latest Turn is that failed Turn and background
+execution is empty. Missing or changed proof is a refusal, not permission to
+replay, change models or silently replace the Session.
+
 ## Replace a Session deliberately
 
 An authorized Leader or Operator may request: