@zq-silk/yui 2.4.0 → 2.6.0

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/cli-information-contract.md

@@ -20,7 +20,7 @@ schema migration or new snapshot/cache store is introduced.
 | What changed? | `task context delta <task> --after <cursor>` | Immutable events with a fixed upper bound, not a snapshot of current mutable state |
 | Which Global input? | `session context <role>` | Identity, profile, authority, current native Turn/retry and separate bounded pending/recent Message pages |
 | Read Global input | `role message list <role> [--pending]`, `role message show <role> <id>` | Scoped discovery, then exact original; queue acceptance never erases history |
-| What arrived in this wake? | `task wake show <task> <wake>` | Fixed window and Message/Run/Event read pointers, not duplicated bodies |
+| What arrived in this wake? | `task wake show <task> <wake>` | Fixed-window inputs/results, attributed optional summaries and exact original reads; `--history` expands diagnostics |
 | What was assigned? | `task run context <task>/<run>` | Frozen authority and a single `pointers` inventory with summaries; changed identities in `deltaRefs`; current observations remain separate |
 | Which configuration is real? | `task role session inspect <task> <role>` | Task/Role identity, desired binding, frozen Session, current Provider binding, retry and explicit Host observation; no full Task/Role copies or Provider conversation history |
 

package/docs/cli-information-contract.zh-CN.md

@@ -18,7 +18,7 @@ CLI 调用成功，不代表 Task、原生 Turn 或远端投递完成。
 | 发生了什么变化？ | `task context delta <task> --after <cursor>` | 固定上界内的不可变事件，不是可变当前状态的快照 |
 | Global 收到了什么？ | `session context <role>` | 身份、Profile、权限、当前原生 Turn/retry，以及分别有界的 pending/recent Message 页 |
 | 读取 Global 输入 | `role message list <role> [--pending]`、`role message show <role> <id>` | 在自身范围内发现，再读完整原文；队列接受不删除历史 |
-| 本次唤醒带来什么？ | `task wake show <task> <wake>` | 固定窗口与 Message/Run/Event 读取指针，不重复正文 |
+| 本次唤醒带来什么？ | `task wake show <task> <wake>` | 固定窗口的输入/结果、标明来源的可选摘要和确切原文入口；`--history` 展开诊断历史 |
 | 分配了什么？ | `task run context <task>/<run>` | 冻结授权与一份带摘要的 `pointers` 目录；`deltaRefs` 表示变化身份；当前观察独立 |
 | 实际配置是什么？ | `task role session inspect <task> <role>` | Task/Role 身份、期望绑定、冻结 Session、当前 Provider 绑定、retry 与显式 Host 观察；不复制整个 Task/Role 或 Provider 会话历史 |
 

package/docs/managed-turn-and-session-runtime.md

@@ -69,6 +69,14 @@ Run Pack is a reference directory: read the relevant requirement and message
 bodies before acting, rather than treating a successful load as the deliverable.
 Planning Packs expose no Project write scope or Task-completion permission.
 
+The Manifest pointer is a recovery locator, not a read receipt. Load its exact
+`yui-runtime`, Role Skills and profile on first entry, a new/version-changed
+Session, or missing context after compaction/recovery. Reuse instructions only
+when the same-version full content is still available; Yui stores no "already
+read" state. Always refresh dynamic facts. Leader notifications use
+`currentCommand`; dispatched AgentRuns use the actual Run ID with
+`loadCommand`/`expandCommand`, never their placeholder templates.
+
 Every new Run, including planning, Review and continuation, binds an explicit
 frozen Snapshot before dispatch. Context reads validate its full identity and
 content digest, then read its stored values without rebuilding current Task
@@ -123,6 +131,20 @@ Human input, explicit execution entry and activation failure are delivered
 promptly through the existing wake mechanism. Worker results retain their
 aggregation window. Busy native input still preserves pending messages.
 
+Normal and retry notifications share the same bounded presentation: factual
+change labels, attributed optional author summaries, and original read entries.
+An author can begin a Message/report with `Yui-Summary: <one line>` (summary
+at most 512 UTF-8 bytes). It remains in the original record; no schema migration,
+summary store, read-acknowledgement or extra model call is involved. Missing or
+oversized summaries fall back to facts without clipping qualifications.
+Summaries never grant authority, accept results or mark reviews approved.
+
+`task wake show <task> <wake>` now defaults to inputs/results and explicit
+references, including older referenced originals. It omits unrelated diagnostic
+events and merely started Runs; `--history` restores full fixed-window discovery.
+Both views retain the fixed window, deduplication, exact detail commands and
+bounded `contentPage` continuations. Read decision-relevant originals in full.
+
 | Evidence | Disposition |
 | --- | --- |
 | Busy with proven non-acceptance | Preserve input; a new transport attempt may use the same Session |

package/docs/managed-turn-and-session-runtime.zh-CN.md

@@ -55,6 +55,21 @@ Run Context 冻结 Assignment、来源引用、生效配置和工作区边界。
 和消息正文，而不是把加载成功当成交付物。规划 Pack 不暴露 Project 写范围或 Task 完成
 权限。
 
+Manifest 指针是恢复定位入口，不是已读凭据。首次进入、新会话、版本变化、压缩或恢复后
+说明缺失时，从其确切路径加载 `yui-runtime`、Role Skills 和 profile；仅当同版本全文仍在
+当前可用上下文中，才复用而不机械重读。系统不保存“已经读过”状态。动态事实仍须刷新：
+Leader 通知使用 `currentCommand`，显式 AgentRun 使用真实 Run ID 的
+`loadCommand`/`expandCommand`，不可直接执行占位模板。
+
+正常和重试通知共用有界呈现：流程事实、标明作者来源的可选摘要与原文入口。Agent 可在
+Message/报告首行写 `Yui-Summary: <单行摘要>`（摘要最多 512 UTF-8 字节），保留失败、
+未验证、待决定等限定。摘要存在原文本身，不新增数据格式、摘要存储、已读状态或模型调用；
+缺失或超长时使用事实模板，不截断关键限定。摘要不是授权、验收或审查通过结论。
+
+`task wake show <task> <wake>` 默认展示消息、结果与明确引用（包括窗口外原文），
+不再枚举无关诊断事件和仅启动的 Run；`--history` 展开完整固定窗口历史。两个视图保留
+去重、固定窗口、确切原文命令及 `contentPage` 续读。决策所依赖的原文仍须全文读取。
+
 新 Run（包括规划、Review 和消息续接）必须在派发前绑定明确冻结的 Snapshot。
 Context 读取校验完整身份与内容 digest，然后直接读取已保存的值，不重新收集当前
 Task 记录。聚合执行从该 Snapshot 读取已选择的 Producer 结果；可写 Project 来自

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,59 @@ 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.
+Normal and recovery notifications share bounded facts, optional attributed
+author summaries and exact action entries. A summary is not acceptance or
+authority: relevant requirements, user messages and execution results must
+still be read in full.
+
+Session instructions name the required Skills explicitly. Reuse is conditional
+on the complete same-version instructions remaining available in context;
+first entry, changed instructions or missing/compacted content require loading
+the exact Manifest and referenced files again. There is no persistent read
+receipt, instruction cache or additional model call for summarization.
+
+`task wake show` now focuses on relevant messages, results and referenced
+evidence by default. Use `--history` for the broader fixed-window diagnostic
+view and follow pagination when present. Consumers must not treat the focused
+view as all history. Original records, exact older references, deduplication,
+snapshot boundaries and unknown-input no-replay rules are preserved.
+
+No storage migration is added; storage remains **1.6**. Deterministic tests and
+package smoke do not prove real-model instruction reuse or compaction recovery.
+Byte measurements are not token savings and can increase for a simple first
+entry. Publishing this package does not upgrade a global CLI, migrate a Home
+or restart a Controller.
+
 ### 2.4.0 compatibility and migration notes
 
 This minor ships the unified Web Task/Operator conversations and same-thread

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

@@ -36,6 +36,46 @@ 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 的通知和上下文加载优化。正常与恢复通知共用有界事实、
+可选且注明来源的作者摘要及精确行动入口。摘要不是验收或授权：相关需求、
+用户消息和执行结果仍须全文读取。
+
+会话说明显式列出所需 Skill。只有完整的同版本说明仍在可用上下文中时才能复用；
+首次进入、说明变更或内容缺失／被压缩时，须重新加载精确 Manifest 及其引用文件。
+没有新增持久已读回执、说明缓存或专用模型摘要调用。
+
+`task wake show` 默认聚焦相关消息、结果及引用证据；如需更完整的固定窗口诊断，
+使用 `--history`，有分页时继续读取。调用方不能将聚焦视图当作全部历史。
+原始记录、精确旧引用、去重、快照边界及未知输入不得重放的规则保持不变。
+
+本版不新增存储迁移，存储仍为 **1.6**。确定性测试及安装包冒烟不证明真实模型
+会复用说明或在压缩后正确补读；字节测量不是 token 节省，简单首次进入的开销
+可能增加。发布本包不会升级全局 CLI、迁移 Home 或重启 Controller。
+
 ### 2.4.0 兼容性及迁移说明
 
 本 minor 发布统一 Web Task／Operator 对话及同 Thread Codex 终端、任务工作台、

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "2.4.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-leader/SKILL.md

@@ -14,10 +14,11 @@ their summaries. Resolve links relative to the file containing them.
 
 Current Context is a bounded working set, not all Task history. Use
 `task context list <task> --store <store>` or a domain list for discovery,
-then an exact detail read. A wake contains original Message/Run read pointers,
-not copied reports. Follow Runtime's `nextCursor` and `contentPage` rules:
-read the full relevant window and originals before disposition, without
-unconditionally walking unrelated history.
+then an exact detail read. A wake contains attributed change summaries and
+original Message/Run pointers, not complete reports. Follow `yui-runtime`'s
+`nextCursor` and `contentPage` rules: read the complete focused wake view and
+relevant originals before disposition; use `wake show --history` only when
+window history/diagnostics matter. Summaries never decide completion.
 
 Before WorkItem dispatch, put the complete bounded requirements in the WorkItem
 or explicitly select up to 16 relevant readable materials with repeated

package/skills/yui-leader/references/execution.md

@@ -420,7 +420,8 @@ notification; no active AgentRun is required.
 
 Before ending authorized execution:
 
-1. Inspect the wake delta, resolve every referenced Worker or Reviewer AgentRun
+1. Inspect the focused wake inputs/results (expand `--history` when needed),
+   resolve every referenced Worker or Reviewer AgentRun
    with `yui task run show`, read each original result in full, and make the
    next decision.
 2. Persist actual WorkItem lifecycle and material Brief, Decision, Milestone,

package/skills/yui-operator/SKILL.md

@@ -30,6 +30,9 @@ another reader's understanding or action. Do not narrate dispatch, attach,
 heartbeat, sampling, unchanged waiting, or routine recovery.
 
 A `[Yui updates]` message is a wake envelope containing durable references.
+Follow `yui-runtime`'s conditional instruction loading and attributed summary
+contract for both Global Message inputs and these notices. Summaries locate
+originals; they cannot grant user authority or prove result acceptance.
 Read those exact records before responding and combine related updates into one
 user-level summary. Do not create a Codex Goal, polling loop, private monitoring
 task, or synthetic progress message; future durable events will wake the

package/skills/yui-reviewer/SKILL.md

@@ -110,8 +110,10 @@ frozen Review or its original report.
 
 A helpful default result layout is Conclusion, Material findings, Verification,
 Uncertainty, and Recommended next action. Markdown or JSON are both acceptable.
-Yui preserves the original text and does not parse, normalize, or reject it for
-missing headings, field names, or formatting.
+Yui preserves the original text and does not parse a verdict or reject it for
+missing headings, field names, or formatting. Follow `yui-runtime`'s optional
+`Yui-Summary:` first-line convention for attributed notification text; retain
+material findings and uncertainty rather than implying automatic approval.
 
 For normal software delivery, follow the applicable Project Policy. The
 Leader decides whether risk warrants one independent Task-final Review of the