@zq-silk/yui 2.7.1 → 2.8.1

package/dist/cli/commandCatalog.js

@@ -193,7 +193,8 @@ const globalSessionChildren = [
     {
         name: "skills", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment", "global", "unbound"] },
         summary: "Check current Skill paths, versions and availability for this managed Session without reading bodies.",
-        usage: "yui session skills"
+        usage: "yui session skills [--cursor <cursor>]",
+        options: ["--cursor"]
     },
     { name: "enter", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Enter a global Role's native session.", usage: "yui session enter <role>" },
     {
@@ -911,9 +912,9 @@ const taskChildren = [
             },
             {
                 name: "context", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] },
-                summary: "Load the exact authorized AgentRun context.",
-                usage: "yui task run context <task>/<run> [--cursor <cursor>] [--json]",
-                options: ["--cursor", "--json"],
+                summary: "Load bounded AgentRun entry facts; discover refs or read the full authorized pack explicitly.",
+                usage: "yui task run context <task>/<run> [--view current|refs|input|full] [--cursor <cursor>] [--json]",
+                options: ["--view", "--cursor", "--json"],
                 executable: true,
                 hidden: true,
                 sections: [{ id: "load", title: "Commands", entries: ["expand", "delta"] }],
@@ -1165,7 +1166,7 @@ export const ROOT_COMMAND = buildNode({
             sections: [{ id: "commands", title: "Commands", entries: ["list", "show", "claim", "ack"] }],
             children: [
                 { name: "list", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
-                    summary: "Discover bounded own-address entries without consuming them.",
+                    summary: "Discover unhandled own-address entries, including accepted delivery, with current identity and separate handling receipts.",
                     usage: "yui inbox list [--limit <1..100>] [--cursor <cursor>]", options: ["--limit", "--cursor"] },
                 { name: "show", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
                     summary: "Read an exact original or fixed notification window without acknowledgement.",
@@ -1190,8 +1191,8 @@ export const ROOT_COMMAND = buildNode({
                     children: [
                         {
                             name: "list", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Discover Global Messages without consuming input.",
-                            usage: "yui role message list <role> [--pending] [--limit <1..100>] [--cursor <cursor>]",
-                            options: ["--pending", "--limit", "--cursor"]
+                            usage: "yui role message list <role> [--pending|--diagnostics|--diagnostic <key>] [--limit <1..100>] [--cursor <cursor>]",
+                            options: ["--pending", "--diagnostics", "--diagnostic", "--limit", "--cursor"]
                         },
                         {
                             name: "show", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Read one exact Global Message; follow contentPage.nextCursor for long content.",

package/dist/cli/updateCommand.js

@@ -65,6 +65,9 @@ export function renderUpdateResult(result) {
     })();
     return [
         rendered,
+        ...(result.outcome === "updated" ? [
+            "Runtime: existing Hosts are retained, not upgraded in place. Host control capabilities and event delivery are checked separately; accepted input is never replayed."
+        ] : []),
         ...(result.controllerReconciliation === undefined ? [] : [
             `Controller reconciliation: ${JSON.stringify(result.controllerReconciliation)}`
         ]),

package/dist/cli/updatePorts.js

@@ -776,6 +776,26 @@ function interpretPreflight(result) {
     // error is not a safe preflight — block rather than proceed to a switch.
     const data = parseSuccessEnvelopeData(result);
     if (data === null) {
+        // CLI bootstrap failures use an ok:false envelope on stderr. Preserve its
+        // already-sanitized diagnosis (including recovery guidance), never promote
+        // an error envelope to a successful storage preflight.
+        for (const stream of [result.stderr, result.stdout]) {
+            let failure;
+            try {
+                failure = JSON.parse(stream.toString("utf8").trim());
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(failure) || failure.ok !== false || typeof failure.message !== "string")
+                continue;
+            return {
+                status: "blocked",
+                stage: "preflight",
+                message: `Staged binary preflight failed (exit ${result.status ?? "null"}): ${failure.message}`,
+                action: "Resolve the reported staged-binary failure using the same Home and matching CLI; do not force the update."
+            };
+        }
         return {
             status: "blocked",
             stage: "preflight",

package/dist/commands/configCommands.js

@@ -56,6 +56,7 @@ export function effectiveConfigData(config, domain) {
     const health = resolveRuntimeHealth(config.runtimeHealth);
     const all = {
         schemaVersion: config.schemaVersion,
+        modelManagement: config.modelManagement ?? null,
         defaultAgent: config.defaultAgent ?? null,
         defaultWorkspace: config.defaultWorkspace ?? null,
         timeZone: resolveTimeZone(config.timeZone),

package/dist/commands/globalRoleCommands.js

@@ -1,10 +1,13 @@
 import { roleNotFound, usageError } from "../errors/cliError.js";
 import { hasManagedIdentity } from "../runtime/managedIdentity.js";
-import { boundedDocument, recordPage, readOptions, readDigest, messageReceipt } from "../output/boundedRead.js";
-import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { requireManagedGlobalCaller } from "../runtime/managedCaller.js";
+import { boundedDocument, recordPage, readOptions, readDigest, messageReceipt, summaryText, summaryMetadata } from "../output/boundedRead.js";
+import { controlProviderRetry, providerRetryProjection, providerRetrySummary, renderProviderRetry } from "../runtime/providerRetry.js";
+import { pendingGlobalInboxMessages, inboxHandlingState, globalInboxDeliveryState } from "../message/inboxReceipt.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { globalInputBacklog } from "../message/globalInputBacklog.js";
 import { checkCurrentSkills, SKILL_REUSE_RULE } from "../context/currentSkills.js";
+import { runtimeDiagnosticGroups, runtimeDiagnosticEvidence } from "../controller/globalRuntimeAttention.js";
 import { roleSkillIds } from "../context/roleSessionContext.js";
 import { createRoleSessionSet, recordRoleAgentSession } from "../executor/agentExecutor.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
@@ -76,13 +79,7 @@ function assertGlobalInputAuthority(store, options, target) {
         throw usageError("Global input mutation is outside the exact Session authority.");
     }
     if (env.YUI_SESSION_SCOPE === "global") {
-        const caller = store.getGlobalRoleSessionSet(env.YUI_ROLE ?? "");
-        const session = caller?.sessions[caller.activeAgentId];
-        if (session === undefined || session.status !== "active" || env.YUI_AGENT_ID !== session.agentId
-            || env.YUI_ADAPTER_ID !== session.adapterId
-            || (env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID) !== session.nativeSessionId) {
-            throw usageError("Global input mutation requires the current native caller Session.");
-        }
+        requireManagedGlobalCaller(store, env);
     }
     else if (hasManagedIdentity(env)) {
         throw usageError("Incomplete managed identity cannot acquire user authority.");
@@ -123,9 +120,6 @@ function roleContext(args, store, options) {
         if (environment.YUI_SESSION_SCOPE !== "global" || environment.YUI_ROLE !== name) {
             throw usageError("Managed GlobalRole context is outside the exact Session authority.");
         }
-        if (environment.YUI_SESSION_MANIFEST === undefined) {
-            throw usageError("Managed GlobalRole context requires its Session Manifest.");
-        }
     }
     const role = requireRole(name, store);
     const binding = activeRoleAgentBinding(role);
@@ -140,10 +134,9 @@ function roleContext(args, store, options) {
         && message.inbox?.ack === undefined
         && message.notDelivered === undefined
         && (message.interruptThen !== undefined || message.inputControl?.action === "queue"));
-    const pending = recordPage(queued.map(globalMessageSummary), `global:${name}/messages/pending`, { limit: 8 });
-    const recent = recordPage([...messages].reverse().map(globalMessageSummary), `global:${name}/messages/all`, { limit: 8 });
+    const pending = recordPage(pendingGlobalInboxMessages(messages).map(globalMessageSummary), `global:${name}/messages/pending`, { limit: 8 });
     const observedAt = new Date();
-    const { oldestAgeMs, ...backlog } = globalInputBacklog(queued, sessions, observedAt, {
+    const { oldestAgeMs, messages: _backlogMessages, ...backlog } = globalInputBacklog(queued, sessions, observedAt, {
         attention: name === "operator" ? store.getWorkMailbox({ kind: "operator" }) : null,
         lifecycle: store.getWorkMailbox({ kind: "global-role-runtime", roleName: name })
     });
@@ -163,10 +156,7 @@ function roleContext(args, store, options) {
                 : { nativeSessionId: session.nativeSessionId })
         },
         profile: {
-            description: role.description,
-            responsibilities: role.responsibilities ?? [],
-            constraints: role.constraints ?? [],
-            expectedOutput: role.expectedOutput,
+            read: "Read roleProfileRef from the current Session Manifest; it is not repeated at each entry.",
             skillIds: [
                 "yui-runtime",
                 ...(role.name === "operator" ? ["yui-operator"] : []),
@@ -183,23 +173,27 @@ function roleContext(args, store, options) {
         },
         // Reading pending input is neither delivery nor implementation.
         pending,
-        recent,
         backlog,
         reads: {
             ownInbox: "yui inbox list --json",
             messages: `role message list ${name}`,
             pending: `role message list ${name} --pending`,
-            detail: `role message show ${name} <message-id>`
+            detail: `role message show ${name} <message-id>`,
+            diagnostics: `role message list ${name} --diagnostics`,
+            retry: `session retry ${name} show`
         },
-        nativeTurn: sessions?.providerBinding?.run ?? null,
-        retry: providerRetryProjection(sessions?.providerBinding),
+        nativeTurn: sessions?.providerBinding?.run == null ? null : {
+            attemptId: sessions.providerBinding.run.attemptId,
+            nativeTurnId: sessions.providerBinding.run.nativeTurnId,
+            status: sessions.providerBinding.run.status
+        },
+        retry: providerRetrySummary(sessions?.providerBinding),
         // Historical interrupt receipts are available through Session inspection;
         // only this Turn's exact identity is required at entry.
         sessionManifestPath: environment.YUI_SESSION_MANIFEST,
         skillCheckCommand: "yui session skills --json",
         currentSkills,
         skillLoadingRule: SKILL_REUSE_RULE,
-        skillPackages: session?.effective.skillPackages ?? null,
         cliCommand: "yui"
     });
     // Elapsed wall-clock time is live display metadata, not a changing source
@@ -214,7 +208,7 @@ function roleContext(args, store, options) {
             `Effective revision: ${role.launchRevision}`,
             `Skills: ${context.profile.skillIds.join(", ") || "none"}`,
             `Authority: ${context.authority.view}; Task implementation: no`,
-            `Pending messages: ${pending.total}; recent messages: ${recent.total}`,
+            `Pending messages: ${pending.total}; history is available on demand`,
             JSON.stringify(data),
             ""
         ].join("\n") };
@@ -222,12 +216,15 @@ function roleContext(args, store, options) {
 function globalMessageSummary(message) {
     return {
         id: message.id, createdAt: message.createdAt, kind: message.kind,
-        digest: readDigest(message), summary: message.body.slice(0, 240),
+        digest: readDigest(message), summary: summaryText(message.body),
+        read: `role message show ${message.roleName} ${message.id}`,
         delivery: message.delivery === undefined ? undefined : { deliveredAt: message.delivery.deliveredAt },
-        notDelivered: message.notDelivered === undefined ? undefined : { summary: message.notDelivered.reason.slice(0, 240) },
+        notDelivered: message.notDelivered === undefined ? undefined : { summary: summaryText(message.notDelivered.reason) },
         control: message.control === undefined ? undefined : { outcome: message.control.outcome, observedAt: message.control.observedAt },
         inputAction: message.inputControl?.action,
-        deliveryTarget: message.deliveryTarget,
+        handling: inboxHandlingState(message.inbox),
+        deliveryState: globalInboxDeliveryState(message),
+        deliveryTarget: message.deliveryTarget === undefined ? undefined : summaryMetadata(message.deliveryTarget),
         interruptThen: message.interruptThen === undefined ? undefined : true
     };
 }
@@ -629,8 +626,13 @@ function globalRoleMessage(args, store, options) {
         }
         requireRole(name, store);
         const pending = tail.includes("--pending");
-        const parsed = readOptions(tail.filter(arg => arg !== "--pending"), action === "list"
-            ? ["--cursor", "--limit"] : ["--cursor"]);
+        const diagnostics = tail.includes("--diagnostics");
+        const parsed = readOptions(tail.filter(arg => arg !== "--pending" && arg !== "--diagnostics"), action === "list"
+            ? ["--cursor", "--limit", "--diagnostic"] : ["--cursor"]);
+        const diagnostic = parsed.values.get("--diagnostic");
+        if (Number(pending) + Number(diagnostics) + Number(diagnostic !== undefined) > 1
+            || action === "show" && diagnostics)
+            throw usageError("Choose one Message discovery view.");
         const messages = store.listGlobalRoleMessages(name);
         let data;
         if (action === "show") {
@@ -644,11 +646,16 @@ function globalRoleMessage(args, store, options) {
         else {
             if (parsed.positionals.length !== 0)
                 throw usageError("Role message list <role> [--pending] [--limit <n>] [--cursor <cursor>].");
-            const selected = pending ? messages.filter(message => message.delivery === undefined
-                && message.inbox?.ack === undefined
-                && message.notDelivered === undefined
-                && (message.interruptThen !== undefined || message.inputControl?.action === "queue")) : [...messages].reverse();
-            data = recordPage(selected.map(globalMessageSummary), `global:${name}/messages/${pending ? "pending" : "all"}`, parsed);
+            if (diagnostics) {
+                data = recordPage(runtimeDiagnosticGroups(messages).reverse().map(group => ({
+                    ...group, source: summaryMetadata(group.source),
+                    read: `role message show ${name} ${group.latestEvidence}`
+                })), `global:${name}/diagnostics`, parsed);
+                return { kind: "output", output: `${JSON.stringify(data)}\n`, data };
+            }
+            const selected = diagnostic !== undefined ? runtimeDiagnosticEvidence(messages, diagnostic)
+                : pending ? pendingGlobalInboxMessages(messages) : [...messages].reverse();
+            data = recordPage(selected.map(globalMessageSummary), `global:${name}/messages/${diagnostic === undefined ? pending ? "pending" : "all" : `diagnostic/${diagnostic}`}`, parsed);
         }
         return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
     }

package/dist/commands/inboxCommands.js

@@ -1,10 +1,11 @@
-import { requireManagedGlobalCaller, requireManagedTaskCaller } from "../runtime/managedCaller.js";
-import { boundedDocument, readDigest, readOptions, recordPage } from "../output/boundedRead.js";
+import { requireManagedCaller } from "../runtime/sessionCaller.js";
+import { boundedDocument, readDigest, readOptions, recordPage, summaryMetadata, summaryText } from "../output/boundedRead.js";
 import { claimPending, completeProcessing } from "../coordination/workMailbox.js";
 import { createTaskWake, latestTaskWake } from "../scheduler/taskWake.js";
 import { expandTaskMessageResult } from "../message/message.js";
 import { messageAssignmentBlocker } from "../message/messageContinuation.js";
-import { isLeaderSteer, latestMessageUpdate, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
+import { globalInboxDeliveryState, inboxHandlingState, isGlobalInboxMessage, pendingGlobalInboxMessages } from "../message/inboxReceipt.js";
+import { deliveredMessageWake, isLeaderSteer, pinMessageRevisions, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isTaskRecordRetired, retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
 const target = (address) => ({ kind: "role", taskId: address.taskId, roleName: address.roleName });
@@ -13,11 +14,10 @@ const pendingId = (pending) => `pending-${readDigest(pending)}`;
 const sameSession = (a, b) => a.scope === b.scope && a.taskId === b.taskId
     && a.roleName === b.roleName && a.agentId === b.agentId && a.nativeSessionId === b.nativeSessionId;
 function addressOf(store, env) {
-    if (env.YUI_SESSION_SCOPE === "global") {
-        const caller = requireManagedGlobalCaller(store, env);
+    const caller = requireManagedCaller(store, env);
+    if (caller.scope === "global") {
         return { scope: "global", roleName: caller.roleName, agentId: caller.agentId, nativeSessionId: caller.nativeSessionId };
     }
-    const caller = requireManagedTaskCaller(store, env);
     if (caller.roleName !== "leader" && caller.currentRunId === undefined) {
         throw new Error("An Assignment inbox requires its current active AgentRun.");
     }
@@ -42,7 +42,7 @@ function ownsMessage(store, address, message) {
 function entries(store, address) {
     if (address.scope === "global")
         return store.listGlobalRoleMessages(address.roleName)
-            .filter(message => message.inputControl !== undefined || message.interruptThen !== undefined);
+            .filter(isGlobalInboxMessage);
     const messages = store.listMessages(address.taskId).filter(message => ownsMessage(store, address, message));
     return address.roleName === "leader" ? [...store.listTaskWakes(address.taskId), ...messages] : messages;
 }
@@ -53,6 +53,10 @@ function getEntry(store, address, id) {
     return entry;
 }
 function isWake(entry) { return "fromCursor" in entry; }
+function acceptedInput(entry) {
+    return isWake(entry) ? entry.status === "consumed" : "roleName" in entry
+        ? globalInboxDeliveryState(entry) === "accepted" : entry.control?.outcome === "accepted";
+}
 function assertSelectedTarget(address, message) {
     const selected = message.inputControl?.expectedSessionId;
     const globalTarget = "roleName" in message ? message.deliveryTarget : undefined;
@@ -82,23 +86,33 @@ function blocker(store, address, entry) {
         return sameSession(entry.inbox.claim.actor, address) ? undefined : "claimed-by-previous-session";
     }
     if (isWake(entry)) {
+        // Native acceptance releases transport ownership, not semantic handling.
+        // The current Leader may explicitly claim the fixed delivered window.
         if (entry.status === "consumed")
-            return "already-delivered";
+            return undefined;
         return "automatic-notification-owns-window";
     }
     if (address.scope === "task" && taskMessageInboxReceipt(store, entry) !== undefined) {
         return "claimed-by-notification-window";
     }
-    if (entry.interruptThen !== undefined)
-        return "explicit-interrupt-handoff";
-    if (entry.control !== undefined && entry.control.outcome !== "rejected")
+    if (entry.control !== undefined && ["pending", "delivery-unknown"].includes(entry.control.outcome)) {
         return `delivery-${entry.control.outcome}`;
+    }
+    const accepted = acceptedInput(entry);
+    if (entry.interruptThen !== undefined && !accepted
+        && !(address.scope === "task" && entry.continuation?.runId === address.runId
+            && address.runId !== undefined))
+        return "explicit-interrupt-handoff";
     // Both steer paths reserve pending control before submission and arbitrate
     // with inbox claims. No control is unsubmitted, not an unknown delivery.
     if (address.scope === "global") {
         const message = entry;
-        if (message.delivery !== undefined)
+        if (message.delivery !== undefined && !accepted)
             return `already-delivered-${message.delivery.via}`;
+        // Explicitly settling delivered input is not a new submission or target
+        // selection. A current rightful successor retains the original target.
+        if (accepted)
+            return undefined;
         if (message.deliveryTarget !== undefined && (message.deliveryTarget.nativeSessionId !== address.nativeSessionId
             || message.deliveryTarget.agentId !== address.agentId))
             return "selected-native-session-changed";
@@ -111,9 +125,10 @@ function blocker(store, address, entry) {
     }
     else {
         const message = entry;
-        if (message.continuation?.runId !== undefined)
+        if (message.continuation?.runId !== undefined && message.continuation.runId !== address.runId) {
             return "continuation-already-dispatched";
-        if (message.inputControl?.expectedSessionId !== undefined
+        }
+        if (!accepted && message.inputControl?.expectedSessionId !== undefined
             && message.inputControl.expectedSessionId !== address.nativeSessionId)
             return "selected-native-session-changed";
         return address.roleName === "leader" && isLeaderSteer(message) ? undefined : messageAssignmentBlocker(store, message);
@@ -135,8 +150,15 @@ function checkMutation(store, address) {
 }
 function summary(store, address, entry) {
     return { id: entry.id, kind: isWake(entry) ? "notification-window" : "message",
-        createdAt: entry.createdAt, summary: isWake(entry) ? entry.reasons.join(", ").slice(0, 240) : entry.body.slice(0, 240),
-        blocked: blocker(store, address, entry) ?? null, inbox: entry.inbox ?? null,
+        createdAt: entry.createdAt, summary: summaryText(isWake(entry) ? entry.reasons.join(", ") : entry.body),
+        blocked: blocker(store, address, entry) ?? null, inbox: summaryMetadata(entry.inbox ?? null),
+        handling: inboxHandlingState(entry.inbox),
+        delivery: isWake(entry) ? entry.status : summaryMetadata({
+            control: entry.control ?? null,
+            ...(address.scope === "global" ? { receipt: entry.delivery ?? null,
+                state: globalInboxDeliveryState(entry) }
+                : { continuation: entry.continuation ?? null })
+        }),
         read: `yui inbox show ${entry.id}`, ...(isWake(entry)
             ? { originals: `yui task wake show ${entry.taskId} ${entry.id} --json` } : {}) };
 }
@@ -155,21 +177,19 @@ export function runInboxCommand(args, store, env, now = new Date()) {
         if (parsed.positionals.length)
             throw new Error("Inbox list accepts only --limit and --cursor.");
         const retired = address.scope === "task" ? retiredTaskRecordIds(store.listEvents(address.taskId), "message") : new Set();
-        const selected = entries(store, address).filter(entry => (isWake(entry) || !retired.has(entry.id))
-            && entry.inbox?.ack === undefined
-            && (isWake(entry) ? entry.status !== "consumed"
-                : address.scope === "global" ? entry.delivery === undefined
-                    : entry.continuation?.runId === undefined));
+        const selected = address.scope === "global" ? pendingGlobalInboxMessages(store.listGlobalRoleMessages(address.roleName))
+            : entries(store, address).filter(entry => (isWake(entry) || !retired.has(entry.id))
+                && inboxHandlingState(entry.inbox) !== "handled");
         const items = selected.map(entry => summary(store, address, entry));
         if (address.scope === "task" && address.roleName === "leader") {
             const mailbox = store.getWorkMailbox(target(address));
             if (mailbox?.pending != null)
                 items.push({ id: pendingId(mailbox.pending), kind: "notification-window",
-                    summary: mailbox.pending.reasons.join(", ").slice(0, 240),
+                    summary: summaryText(mailbox.pending.reasons.join(", ")),
                     blocked: mailbox.processing === null && !unfinishedLeaderInbox(store, address.taskId) ? null : "earlier-window-owned",
                     read: `yui inbox show ${pendingId(mailbox.pending)}` });
         }
-        return recordPage(items, source(address), parsed);
+        return recordPage(items, source(address), parsed, { identity: address });
     }
     if (action === "show") {
         const parsed = readOptions(tail, ["--cursor"]);
@@ -230,7 +250,8 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 if (ref.type !== "message")
                     continue;
                 const message = tx.listMessages(current.taskId).find(message => message.id === ref.id);
-                if (message !== undefined && taskMessageInboxReceipt(tx, message) !== undefined
+                if (message !== undefined && (taskMessageInboxReceipt(tx, message) !== undefined
+                    || deliveredMessageWake(tx, message) !== undefined)
                     || message?.interruptThen !== undefined
                     || message?.control !== undefined && message.control.outcome !== "rejected"
                     || message?.inputControl?.expectedSessionId !== undefined
@@ -241,16 +262,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
             const latest = latestTaskWake(tx.listTaskWakes(current.taskId));
             // Pin each mutable Draft original's existing update event, not a clock
             // comparison. A later edit is distinct input even within the same tick.
-            const refs = [...mailbox.pending.refs];
-            for (const ref of mailbox.pending.refs) {
-                if (ref.type !== "message" || ref.taskId !== current.taskId)
-                    continue;
-                const message = tx.listMessages(current.taskId).find(message => message.id === ref.id);
-                const revision = message === undefined ? undefined : latestMessageUpdate(tx, message);
-                if (revision !== undefined && !refs.some(ref => ref.type === "event" && ref.id === revision.id)) {
-                    refs.push({ type: "event", taskId: current.taskId, id: revision.id });
-                }
-            }
+            const refs = pinMessageRevisions(tx, current.taskId, mailbox.pending.refs);
             const wake = createTaskWake({ id: tx.nextTaskWakeId(current.taskId), taskId: current.taskId,
                 reasons: mailbox.pending.reasons, refs,
                 fromCursor: latest?.toCursor ?? tx.getTask(current.taskId).createdAt,
@@ -273,6 +285,17 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 const blocked = blocker(tx, current, entry);
                 if (blocked !== undefined)
                     throw new Error(`Inbox entry cannot be claimed: ${blocked}.`);
+                if (isWake(entry) && !acceptedInput(entry)) {
+                    for (const ref of entry.refs ?? []) {
+                        if (ref.type !== "message")
+                            continue;
+                        const message = tx.listMessages(current.taskId).find(message => message.id === ref.id);
+                        if (message !== undefined)
+                            assertSelectedTarget(current, message);
+                    }
+                }
+                else if (!isWake(entry) && !acceptedInput(entry))
+                    assertSelectedTarget(current, entry);
                 for (const previous of entries(tx, current)) {
                     if (previous.id === entry.id)
                         break;
@@ -281,10 +304,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                     if (current.scope === "task"
                         && isTaskRecordRetired(tx.listEvents(current.taskId), "message", previous.id))
                         continue;
-                    if (current.scope === "global" && (previous.delivery !== undefined
-                        || previous.notDelivered !== undefined))
-                        continue;
-                    if (current.scope === "task" && previous.continuation?.runId !== undefined)
+                    if (current.scope === "global" && previous.notDelivered !== undefined)
                         continue;
                     if (previous.inbox !== undefined && sameSession(previous.inbox.claim.actor, current))
                         continue;
@@ -299,14 +319,14 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 // the original. The current rightful successor may settle a claim
                 // acquired by the exact selected Session, retaining both identities.
                 const claimant = entry.inbox.claim.actor;
-                if (isWake(entry)) {
+                if (isWake(entry) && !acceptedInput(entry)) {
                     const messageIds = new Set(entry.refs?.filter(ref => ref.type === "message").map(ref => ref.id));
                     for (const message of tx.listMessages(current.taskId)) {
                         if (messageIds.has(message.id))
                             assertSelectedTarget(claimant, message);
                     }
                 }
-                else
+                else if (!isWake(entry) && !acceptedInput(entry))
                     assertSelectedTarget(claimant, entry);
                 if (!isWake(entry) && current.scope === "task"
                     && !(current.roleName === "leader" && isLeaderSteer(entry))) {

package/dist/commands/taskCommands.js

@@ -7,7 +7,7 @@ import { createRun, runExecutionObservation, runPurposeAdmitsTaskState } from ".
 import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { contextContentDigest, contextSnapshotRef } from "../context/contextSnapshot.js";
 import { sourceRunContextValue } from "../context/sourceRunContext.js";
-import { buildRunContextDelta, buildRunContextPack, contextSnapshotDeltaRefIds, expandRunContextRef, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, freezeCandidateContextSnapshot, readRunContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
+import { buildRunContextDelta, buildRunContextPack, runContextEntry, runContextPointerPage, contextSnapshotDeltaRefIds, expandRunContextRef, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, freezeCandidateContextSnapshot, readRunContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
 import { createRunInput } from "../context/runInputContract.js";
 import { parseTaskCatalogOptions, readTaskCatalog, renderTaskCatalog } from "../context/taskCatalog.js";
 import { assertContextRecordReadable, readTaskContextResource } from "../context/taskContext.js";
@@ -4777,14 +4777,18 @@ function runContextCommand(args, store, options) {
         const data = boundedDocument(delta, `run:${taskId}/${runId}/delta/${parsed.values.get("--after")}`, parsed.cursor);
         return output(`${JSON.stringify(data)}\n`, { contextDelta: data });
     }
-    const parsed = readOptions(rest, ["--cursor"]);
+    const parsed = readOptions(rest, ["--cursor", "--view"]);
     if (first === undefined || parsed.positionals.length !== 0) {
         throw usageError("Task run context usage: yui task run context <task>/<run>.");
     }
     const { taskId, runId } = parseRunContextReference(first);
     authorizeRunContext(store, taskId, runId, options.environment);
     const pack = store.transaction((tx) => buildRunContextPack(tx, taskId, runId));
-    const data = boundedDocument(pack, `run:${taskId}/${runId}/context`, parsed.cursor);
+    const view = parsed.values.get("--view") ?? "current";
+    if (!["current", "full", "refs", "input"].includes(view))
+        throw usageError("Run Context view must be current, refs, input or full.");
+    const data = view === "refs" ? runContextPointerPage(pack, parsed)
+        : boundedDocument(view === "full" ? pack : view === "input" ? pack.input : runContextEntry(pack), `run:${taskId}/${runId}/context/${view}`, parsed.cursor);
     return output(`${JSON.stringify(data)}\n`, { context: data });
 }
 function parseRunContextReference(value) {

package/dist/commands/taskRoleRuntimeStatus.js

@@ -18,6 +18,7 @@ export function taskRoleHostDiagnostic(host) {
     const delivery = snapshot.eventDelivery;
     return [
         `Provider Host=${snapshot.state}`,
+        `terminal reconciliation=${snapshot.controlCapabilities?.includes("reconcile-turn") ? "supported" : "unreported/unsupported"}`,
         delivery === undefined ? "event delivery=unreported" :
             `pending facts=${delivery.pending}; native terminals awaiting acknowledgement=${delivery.pendingTerminals}`,
         delivery?.failure === undefined ? undefined :
@@ -35,6 +36,7 @@ export function withTaskRoleHostObservation(status, host) {
         return { ...status, host: { detail: "Host does not match the recorded native Session." } };
     }
     const reportingNeedsAttention = snapshot !== undefined && (snapshot.state === "failed" || snapshot.state === "exited"
+        || snapshot.eventDelivery === undefined
         || snapshot.eventDelivery?.failure !== undefined
         || (snapshot.eventDelivery?.pendingTerminals ?? 0) > 0);
     return {

package/dist/context/runContextPack.js

@@ -1,4 +1,4 @@
-import { providerRetryProjection } from "../runtime/providerRetry.js";
+import { providerRetrySummary } from "../runtime/providerRetry.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_INPUT_MAX_DELTAS, requireRunContextSnapshotRef } from "./runInputContract.js";
@@ -9,6 +9,7 @@ import { formatGitArtifactRef, validateGitArtifactRef } from "../artifacts/gitAr
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot, validateContextSnapshot } from "./contextSnapshot.js";
 import { MAX_SYNTHESIS_SOURCE_RUNS, sourceRunContextValue } from "./sourceRunContext.js";
+import { recordPage, summaryText } from "../output/boundedRead.js";
 export const RUN_CONTEXT_PACK_SCHEMA_VERSION = 1;
 function mergeRequiredContext(automatic, required, requiredPolicy = "current") {
     const entries = new Map(automatic.map(entry => [`${entry.ref.store}/${entry.ref.refId}`, entry]));
@@ -356,6 +357,41 @@ export function buildRunContextPack(store, taskId, runId) {
     });
     return pack;
 }
+/** The frozen pack remains authority. Entry is a bounded discovery projection;
+ * historical Skill packages and complete inventories are explicit reads only. */
+export function runContextPointerPage(pack, options = {}) {
+    const priority = ["task", "work-item", "review-round", "role-profile"];
+    const pointers = [...pack.pointers].sort((a, b) => {
+        const rank = (store) => priority.includes(store) ? priority.indexOf(store) : priority.length;
+        return rank(a.store) - rank(b.store);
+    }).map(pointer => ({ ...pointer, summary: summaryText(pointer.summary ?? "") }));
+    return recordPage(pointers, `run:${pack.identity.taskId}/${pack.identity.runId}/refs/${pack.snapshot.digest}`, options);
+}
+export function runContextEntry(pack) {
+    const { skillPackages: _packages, pointers: _pointers, deltaRefs, liveTaskState, input, ...identity } = pack;
+    const { directive, ...inputIdentity } = input;
+    const { items, ...pointerPage } = runContextPointerPage(pack, { limit: 16 });
+    return {
+        ...identity, input: { ...inputIdentity, ...(directive === undefined ? {} : {
+                directiveSummary: summaryText(directive), directiveOmitted: true
+            }) }, pointers: items, pointerPage,
+        deltaRefs: deltaRefs.slice(0, 16), deltaRefsTotal: deltaRefs.length,
+        inventory: { ...pack.inventory, complete: pointerPage.complete },
+        liveTaskState: {
+            providerRetries: liveTaskState.providerRetries.slice(0, 8),
+            activeRuns: liveTaskState.activeRuns.slice(0, 8),
+            activeTaskReviews: liveTaskState.activeTaskReviews.slice(0, 8),
+            totals: { providerRetries: liveTaskState.providerRetries.length,
+                activeRuns: liveTaskState.activeRuns.length, activeTaskReviews: liveTaskState.activeTaskReviews.length }
+        },
+        reads: {
+            refs: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view refs`,
+            full: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view full`,
+            input: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view input`,
+            live: `yui task context ${pack.identity.taskId}`
+        }
+    };
+}
 /** Reads the Task's current in-flight execution, outside the frozen contract. */
 function readLiveTaskState(store, taskId) {
     const activeRuns = store.listActiveRuns(taskId)
@@ -376,7 +412,7 @@ function readLiveTaskState(store, taskId) {
     }));
     return Object.freeze({
         providerRetries: Object.freeze(store.listRoleSessionSets(taskId).flatMap(set => set.providerBinding?.retry === undefined
-            ? [] : [{ roleName: set.owner.roleName, retry: providerRetryProjection(set.providerBinding) }])),
+            ? [] : [{ roleName: set.owner.roleName, retry: providerRetrySummary(set.providerBinding) }])),
         activeRuns: Object.freeze(activeRuns),
         activeTaskReviews: Object.freeze(activeTaskReviews)
     });
@@ -447,9 +483,18 @@ function collectAuthorizedContext(store, run) {
     const view = contextView(run);
     const result = [materialize("L2", "task", task.id, task)];
     const brief = store.getTaskBrief(task.id);
-    if (brief !== null && view === "leader") {
+    if (brief !== null && (view === "leader" || view === "reviewer")) {
         result.push(materialize("L2", "task-brief", task.id, brief));
     }
+    // Reviewers need the current material index and effective decisions, not
+    // only the original Task description. Freeze them with the candidate so
+    // later edits cannot silently change the review contract. Artifact bodies
+    // remain on-demand, commit-pinned reads; do not crawl prose or Task history.
+    if (view === "reviewer") {
+        for (const decision of store.listDecisions(task.id).filter(({ status }) => status === "active")) {
+            result.push(materialize("L2", "task-decision", decision.id, decision));
+        }
+    }
     result.push(...collectRunContextOverlays(store, run));
     result.push(...collectSourceRunContext(store, run));
     if (run.workItemId !== undefined) {