@zq-silk/yui 2.5.0 → 2.7.1

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/managed-turn-and-session-runtime.md

@@ -69,11 +69,27 @@ 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
+The Manifest pointer is a recovery locator, not a read receipt. At the start of
+every turn run `yui session skills --json` through the Session's CLI/Home. It
+checks current paths, internal `VERSION` files and readability, without reading
+Skill bodies or walking/snapshotting resources. Builtins use the running
+installation's `skills/<id>` entry; configured Skills use `YUI_HOME/skills/<id>`.
+These paths do not contain a Session/content digest. After changing installation
+locations the check resolves the current installation, not an old recorded path.
+For Global Sessions the Manifest's `skillCheckCommand` is its self-contained
+`session context <role>` read, which also returns current Skill metadata and works
+after moving to Desktop without the launch shell's environment. An older Global
+Manifest's existing `loadCommand` provides the same check.
+
+Load current `yui-runtime`, applicable Role/custom Skills and necessary references,
+plus the Manifest's profile, on first entry, a version change, recovery, or missing/
+compacted/uncertain context. Reuse only when versions are unchanged and the full
+instructions remain available now. Yui stores no "already read" state and does
+not claim to inspect the model's context. Historical packages remain audit only;
+missing/corrupt snapshots do not prevent valid Session resume or input delivery.
+Missing current files report their exact path and recovery action. Session
+identity, scope, writer fences and real CLI/Home incompatibility still reject.
+Always refresh dynamic facts. Leader notifications use
 `currentCommand`; dispatched AgentRuns use the actual Run ID with
 `loadCommand`/`expandCommand`, never their placeholder templates.
 
@@ -139,6 +155,66 @@ 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.
 
+### Operator backlog and periodic recovery
+
+Task completion/cancellation/retirement, publication records/adoption and input
+requests enqueue Operator attention in the same transaction as their durable
+event. Existing Run failure routing keeps its retry and supervisor guards.
+The ready mailbox is the incremental recovery source: a lost scheduler signal
+or Controller restart does not require a Leader report or a scan of historical
+Tasks. The existing periodic pass retries outstanding mailbox work; an unchanged,
+settled mailbox creates neither a Message nor a model call.
+
+At most one unsent engineering notice is queued. Further facts coalesce in the
+mailbox until that notice is accepted or conclusively not delivered. Each handoff
+claims at most 64 source signals and reads exact records, retaining the unclaimed
+suffix. Global delivery reads at most 64 pending Messages per Role per pass;
+conclusively stale originals retain their nondelivery evidence, with later pages
+handled by subsequent passes. Reserved interrupt-then inputs remain discoverable
+beyond that ordinary page. FIFO user inputs and unknown-effect fences are not
+reordered to make notifications appear healthy. SQL aggregates still inspect
+matching stored rows; these bounds limit materialized records and per-pass
+delivery work, not the size of the persisted mailbox or database.
+
+A full reconciliation may ask the original Host to republish an already observed
+terminal for the exact Session, authority, attempt and native Turn. For a Desktop
+direct Turn, that Host must have retained both the exact start and terminal under
+the unchanged writer fence; `direct:<nativeTurnId>` and the native Turn are both
+required. This bounded latest observation does not make the input client-owned.
+This uses the existing Inbox and canonical observer, including the original result.
+It does not submit input, query another native client, restart a Host, or infer
+quiescence from elapsed time/idle state. Normal terminal processing signals again
+after releasing Host occupancy. Unknown acceptance remains isolated unless exact
+evidence settles that input. Explicit stop/replacement and external writers remain
+hard boundaries.
+
+`yui session context <role> --json` includes bounded `backlog` diagnostics: pending
+count, oldest timestamp, target and attempt identities, blocking reason and
+recovery guidance. Live age is in `backlogObservation`, outside the paged source
+digest. `in-flight-or-unobserved-terminal` deliberately does not label a
+long-running accepted Turn as stuck. An unavailable/older Host or missing retained
+terminal produces one record-only runtime-attention Message per exact attempt;
+inspect it through the existing message list/show commands. No recovery Agent,
+private timer, migration or new acknowledgement state is introduced. If the
+Provider itself never reported a terminal, or the original Host lost its evidence,
+automatic reconciliation cannot prove completion: restore the compatible observation
+path or explicitly stop/replace only with the required native quiescence evidence.
+This change does not backfill arbitrary pre-existing historical events, adopt old
+Hosts, or authorize production upgrades/restarts.
+
+Controller restart preserves live Hosts; it does not replace their loaded code.
+A supported surviving Host writes raw observations to the immutable Inbox even
+while the Controller is down; the restarted Controller applies them under current
+Session fences. A frozen Manifest's CLI/storage mismatch is a context-read failure,
+not proof that the Host publisher failed: this publisher uses the Inbox/RPC, not
+that CLI. An Endpoint checkout generation is not a complete Host build identity.
+The runtime-attention evidence distinguishes an unavailable control channel,
+rejected control (including implementations without reconciliation), and a missing
+exact retained terminal, with reported Endpoint/event-delivery observations.
+Missing delivery diagnostics mean unreported, not healthy. Unsupported live code
+cannot be repaired by another Controller restart or guessed adoption; inspect the
+original evidence and explicitly authorize any necessary lifecycle recovery.
+
 `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.

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

@@ -55,9 +55,19 @@ Run Context 冻结 Assignment、来源引用、生效配置和工作区边界。
 和消息正文，而不是把加载成功当成交付物。规划 Pack 不暴露 Project 写范围或 Task 完成
 权限。
 
-Manifest 指针是恢复定位入口，不是已读凭据。首次进入、新会话、版本变化、压缩或恢复后
-说明缺失时，从其确切路径加载 `yui-runtime`、Role Skills 和 profile；仅当同版本全文仍在
-当前可用上下文中，才复用而不机械重读。系统不保存“已经读过”状态。动态事实仍须刷新：
+Manifest 指针是恢复定位入口，不是已读凭据。每轮开始通过本 Session 的 CLI/Home 执行
+`yui session skills --json`，轻量检查当前路径、内部 `VERSION` 和文件可读性，不读取
+正文或遍历/冻结资源。内置入口是当前安装目录的 `skills/<id>`，自定义入口是
+`YUI_HOME/skills/<id>`，不包含 Session/内容摘要；安装位置变化后由检查重新解析当前入口。
+Global Manifest 的 `skillCheckCommand` 使用自包含的 `session context <role>`，
+同时返回 Skill 元数据，因此切换到 Desktop 后不依赖启动 shell 的环境；
+旧 Global Manifest 的 `loadCommand` 也能执行相同检查。
+首次进入、版本变化、恢复，以及压缩后全文缺失或可用性不确定时，读取当前 Runtime、
+Role/custom Skills 全文及必要引用、Manifest 的 profile。只有版本未变且全文仍在当前
+上下文时才复用。系统不保存“已经读过”状态，也不声称检查了模型上下文。
+历史冻结包仅作审计：缺失或损坏不阻止合法 Session 恢复与消息投递；当前文件缺失则
+报告具体路径和修复动作。身份、作用域、writer fence 与实际 CLI/Home 不兼容仍会拒绝。
+动态事实仍须刷新：
 Leader 通知使用 `currentCommand`，显式 AgentRun 使用真实 Run ID 的
 `loadCommand`/`expandCommand`，不可直接执行占位模板。
 
@@ -110,6 +120,44 @@ Leader 本地编辑保留持久事件，但不创建自唤醒。当 Leader 忙
 Task 叙述。人工输入、显式执行进入和激活失败通过既有唤醒机制及时投递。Worker 结果
 保留其聚合窗口。忙碌的原生输入仍保留待处理的消息。
 
+### Operator 积压与周期恢复
+
+Task 完成／取消／退役、Publication 记录／采用及 InputRequest 与持久事件在同一事务中
+进入 Operator 邮箱；Run 失败继续遵守既有重试和监督路由。邮箱自身就是增量恢复源：
+通知信号遗漏或 Controller 重启后，既有周期协调读取尚未处理的引用，不依赖 Leader
+主动报告，也不遍历历史 Task。已结算且无变化的邮箱不会生成消息或调用模型。
+
+最多保留一条未发送的工程通知，后续事实在原邮箱中合并，直到该通知已接受或明确未投递。
+每次认领最多 64 个来源信号，读取精确记录并保留未认领后缀。Global 投递每个 Role 每轮
+最多读取 64 条待处理消息；已证明失效的原始消息保留未投递证据，后续页由下一轮处理。
+interrupt-then 的预留输入不会因超出普通页而被跳过，用户输入顺序和未知效果围栏保持不变。
+SQL 聚合仍检查匹配的存储行；这些上界约束物化记录和每轮投递工作，不限制持久邮箱或数据库大小。
+
+完整周期协调可要求原 Host 重发它已经观察到的精确终态，严格绑定 Session、
+authority、attempt 和 native Turn。Desktop direct 回合还要求该 Host 保留同一 writer 围栏下
+精确匹配的开始和结束，同时核对 `direct:<nativeTurnId>` 与 native Turn；只保留最近一次
+观察，不把 direct 输入改为 client-owned。通过原 Inbox 和规范观察器处理完整结果；不提交新输入、
+另开原生客户端查询、重启 Host，也不凭时间或 idle 推定静止。正常终态在释放 Host 占用后
+再次发出队列信号。未知接受只有精确证据才能结算，显式停止／替换及外部 writer 仍是硬边界。
+
+`yui session context <role> --json` 的 `backlog` 提供有界待投递数量、最老时间、
+目标与尝试身份、阻塞原因和恢复指引；实时年龄位于分页摘要外的 `backlogObservation`，
+不会令分页游标因时间流逝失效。`in-flight-or-unobserved-terminal` 不把长期 accepted
+误报为卡死。Host 不可达、不支持重观察或缺少保留终态时，每个精确尝试只留下一个 record-only
+runtime-attention Message，可通过既有 message list/show 查看，不自动唤醒恢复 Agent。
+如果 Provider 从未报告终态，或原 Host 已失去证据，则不能自动证明完成；须恢复兼容观察路径，
+或在取得原生静止证据后显式停止／替换。不新增私有定时器、迁移或 ack 状态，不猜补任意旧历史、
+收养旧 Host，也不授权生产升级／重启。
+
+Controller 重启保留存活 Host，不替换它们已加载的代码。支持当前协议的原 Host 在 Controller
+停机期间仍把原始观察写入不可变 Inbox，重启后由 Controller 按当前 Session 围栏应用。
+冻结 Manifest 的旧 CLI/storage 不匹配是 Context 读取失败，不足以证明 Host 发布失败：
+发布器使用 Inbox/RPC，不执行该 CLI。Endpoint 的 checkout generation 也不是完整 Host
+构建身份。runtime-attention 区分控制通道不可达、控制被拒绝（包括实现不支持协调）和
+精确终态未保留，并附已报告的 Endpoint/eventDelivery 观察；缺少诊断表示未报告，而非健康。
+再次重启 Controller 或猜测 adoption 不能修复不支持的存活代码；须检查原证据，并为必要的
+生命周期恢复另行取得明确授权。
+
 | 证据 | 处置 |
 | --- | --- |
 | 忙碌且已证明未接受 | 保留输入；新的传输尝试可以使用同一 Session |

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,77 @@ 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.7.1 compatibility and migration notes
+
+This release delivers the intended 2.7 feature line. The `v2.7.0` attempt stopped
+before npm publication because package smoke compared a macOS temporary path
+with its physical alias. The smoke now uses the physical package root; its
+assertions and the cross-platform release gate remain intact.
+
+This minor adds own-scope Agent inbox discovery, full reads, claims and
+acknowledgements for GlobalRoles and Task Leaders, Workers and Reviewers.
+Use `yui inbox list/show/claim/ack` from the current managed Session; reads do
+not consume input, claims do not grant additional authority, and an
+acknowledgement is not execution-result acceptance. Durable receipts arbitrate
+with automatic delivery without replaying unknown native input.
+
+Storage advances from **1.6 to 1.7** through the centralized additive migration
+for Message and Leader-wake inbox receipts. Use `yui update --version 2.7.1`
+for an exact upgrade; the updater preflights the target Home, takes a backup
+when migration is required, and coordinates the exact Controller replacement.
+Do not edit stored records manually. Task, Session and original input history
+remain authoritative.
+
+Runtime and Role instructions now use stable current source paths and independent
+integer `VERSION` files. Every managed turn checks `yui session skills --json`;
+only unchanged full instructions still present in context may be reused.
+Recovery, version changes and missing/uncertain context require full reload.
+Configured Skills must supply `VERSION` beside `SKILL.md`.
+
+Frozen packages remain historical audit, not a Session admission condition.
+Valid pre-1.5 Sessions may resume without that evidence; no historical read,
+native acceptance or input consumption is fabricated. Identity, scope, writer,
+lifecycle, protocol/storage and unknown-input fences are unchanged. The Skill
+loading change itself adds no storage migration.
+
+This release also recovers Operator notification backlogs and Desktop-direct
+terminal facts across Controller replacement, retaining exact input and Turn
+identities. SQLite prefers the pinned modern N-API driver, with a bounded
+compatibility fallback when that optional native candidate is unavailable;
+this fixes the reproduced Node 24 native GC abort.
+
+Deterministic core checks and isolated assembled/fresh-install package smoke
+are the release evidence; they do not establish real-model behavior.
+Publishing this package alone does not authorize a global CLI update, Home
+migration or Controller replacement.
+
+### 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.
@@ -91,8 +162,9 @@ fixes are included; Task110's unmerged work is not part of this release.
 Storage is now **1.6**. Use the supported centralized, contiguous same-major
 upgrade path for older supported Homes; do not edit stored records manually.
 Historical missing cost remains unknown. Old Skill provenance is not rebuilt
-from today's files: if restoring an old Session reports missing frozen-package
-evidence, follow its new-Session guidance while preserving the old history.
+from today's files. The original 2.4 restoration restriction for missing packages
+is superseded by the current Skill-loading contract above; preserve old history
+without making that audit evidence a Session admission condition.
 Current model adoption is connection-local and does not change future defaults;
 exit the Host-owned native TUI before changing its model (closing a viewer only
 detaches it). Unknown sends must be inspected by their original request ID,