@zq-silk/yui 2.21.0 → 2.22.0

package/dist/runtime/structuredProviderHost.js

@@ -31,7 +31,7 @@ export async function startStructuredProviderSession(payload, input = {}) {
     if (control.adapterId === "codex" && control.transport === "codex-app-server-proxy") {
         const proxy = await connectCodexProxy(payload, mirror, true);
         try {
-            const opened = await CodexStructuredProviderSession.open(proxy.child, proxy.exit, proxy.processInstanceId, payload, control, proxy.channel, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, input.onDiagnostic, mirror);
+            const opened = await CodexStructuredProviderSession.open(proxy.child, proxy.exit, proxy.processInstanceId, payload, control, proxy.channel, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, mirror);
             return Object.freeze({
                 session: opened.session,
                 ...(opened.recoveredTerminal === undefined
@@ -238,7 +238,10 @@ class CodexProxyWebSocketChannel {
                 this.#pending.delete(id);
                 reject(new Error(`Provider request timed out: ${method}.`));
             }, PROVIDER_ACCEPT_TIMEOUT_MS);
-            this.#pending.set(id, { resolve: resolvePromise, reject, timer });
+            this.#pending.set(id, {
+                resolve: resolvePromise, reject, timer, method,
+                requestBytes: Buffer.byteLength(JSON.stringify({ id, method, params }), "utf8")
+            });
         });
         try {
             await this.send({ id, method, params });
@@ -282,7 +285,7 @@ class CodexProxyWebSocketChannel {
         if (isBinary || encoded.byteLength > PROVIDER_MESSAGE_MAX_BYTES) {
             this.#close(new Error(isBinary
                 ? "Provider returned an unsupported binary WebSocket message."
-                : "Provider response message exceeds its bound."));
+                : `Provider response message exceeds its bound (receivedBytes=${encoded.byteLength}).`));
             terminateProcessGroup(this.child, "SIGTERM");
             return;
         }
@@ -320,6 +323,15 @@ class CodexProxyWebSocketChannel {
     #close(error) {
         if (this.#closedError !== undefined)
             return;
+        // A rejected WebSocket frame has not reached #receive: its full size and
+        // response/notification identity are unknown. Record pending request
+        // metadata, not parameters or transcript bytes, and never blame a specific
+        // response just because that request was in flight.
+        const pendingMetadata = [...this.#pending].slice(0, 8).map(([id, pending]) => ({
+            id, method: pending.method, requestBytes: pending.requestBytes
+        }));
+        error = new Error(`Codex proxy transport closed: ${error.message}; messageLimitBytes=${PROVIDER_MESSAGE_MAX_BYTES}; `
+            + `pendingRequests=${JSON.stringify(pendingMetadata)}; pendingCount=${this.#pending.size}.`, { cause: error });
         this.#closedError = error;
         if (!this.#ready)
             this.#rejectReady(error);
@@ -410,7 +422,7 @@ class CodexStructuredProviderSession {
         this.mirror = mirror;
         this.nativeAccountHome = nativeAccountHome;
     }
-    static async open(child, exit, processInstanceId, payload, control, channel, onStarted, onTerminal, onGoal, onInput, onActivity, onDiagnostic, mirror) {
+    static async open(child, exit, processInstanceId, payload, control, channel, onStarted, onTerminal, onGoal, onInput, onActivity, mirror) {
         const openingMessages = [];
         const stopOpeningBuffer = channel.onMessage((message) => openingMessages.push(message));
         const initialized = await channel.request("initialize", codexClientInitialization());
@@ -419,7 +431,6 @@ class CodexStructuredProviderSession {
         let conversationId;
         let nativeConfiguration;
         let resumedActiveTurnId;
-        let resumedTurns = [];
         if (control.mode === "new") {
             const opened = await runtime.openConversation({
                 cwd: payload.cwd,
@@ -437,7 +448,6 @@ class CodexStructuredProviderSession {
                 conversationId = resumed.threadId;
                 nativeConfiguration = resumed.raw;
                 resumedActiveTurnId = resumed.activeTurnId;
-                resumedTurns = resumed.turns;
             }
             catch (error) {
                 if (codexAppServerErrorIsMissing(error)) {
@@ -446,37 +456,25 @@ class CodexStructuredProviderSession {
                 throw error;
             }
         }
-        const threadMetadata = nativeConfiguration.thread;
-        const nativeTitle = typeof threadMetadata === "object" && threadMetadata !== null
-            && !Array.isArray(threadMetadata) ? threadMetadata.name : undefined;
-        // A native rename belongs to the user. Missing metadata is not evidence
-        // that an old title is still ours; leave it alone on resume.
-        let appliedGeneratedTitle;
-        if (control.sessionTitle !== undefined && (control.mode === "new"
-            || (control.previousSessionTitle !== undefined && nativeTitle === control.previousSessionTitle))) {
-            try {
-                await runtime.setConversationName({
-                    conversationId,
-                    name: control.sessionTitle
-                });
-                appliedGeneratedTitle = control.sessionTitle;
-            }
-            catch (error) {
-                onDiagnostic?.({
-                    nativeSessionId: conversationId,
-                    failure: providerDeliveryFailureFrom(error, {
-                        phase: "session-start",
-                        inputDisposition: "not-accepted",
-                        sessionDisposition: "recoverable"
-                    })
-                });
-            }
+        if (control.sessionTitle !== undefined) {
+            // The native title mutation can persist without replying and stall later
+            // Goal/Turn requests, even through a separate metadata connection. Keep
+            // Yui's launch title, but do not put that optional mutation on a managed
+            // Session's execution path. Reconnect must not replay it either.
+            // This is an intentional omission, not a failed delivery or unavailable
+            // observer. Keep it in the Host log without waking an Agent to recover
+            // an operation that was never attempted.
+            mirror("stderr", "Native title synchronization was not submitted; Yui retains its Session title without blocking native Goal/Turn control.\n");
         }
+        const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
+        // Keep notifications buffered during paginated recovery. Otherwise a live
+        // terminal can be emitted before open returns and then returned again as a
+        // synthetic recovered terminal, or a newer start can be overwritten.
+        const recoveredOwnedTurn = ownedTurn !== undefined && resumedActiveTurnId !== ownedTurn.turnId
+            ? await runtime.readTurn(conversationId, ownedTurn.turnId) : undefined;
         const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, optionalId(initialized.codexHome));
         session.nativeAccess = createCodexNativeAccess(conversationId, initialized, channel, openingMessages, nativeConfiguration);
-        session.appliedGeneratedTitle = appliedGeneratedTitle;
         session.#activeTurnId = resumedActiveTurnId;
-        const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
         session.#clientOwnedTurnId = ownedTurn?.turnId;
         session.#clientOwnedAttemptId = ownedTurn?.attemptId;
         if (ownedTurn !== undefined)
@@ -493,7 +491,7 @@ class CodexStructuredProviderSession {
         });
         if (ownedTurn !== undefined && recoveredTerminal === undefined
             && session.#activeTurnId !== ownedTurn.turnId) {
-            const recovered = resumedTurns.find((turn) => turn.turnId === ownedTurn.turnId);
+            const recovered = recoveredOwnedTurn;
             if (recovered?.status === "completed"
                 || recovered?.status === "interrupted"
                 || recovered?.status === "failed") {

package/dist/scheduler/wakeupQueue.js

@@ -1,9 +1,15 @@
-import { mergePendingWakeup } from "./pendingWakeup.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
 /** The caller's TaskStore transaction owns this read/merge/write operation. */
 export function queueLeaderWakeup(store, taskId, reason, now) {
     if (store.getTask(taskId)?.status === "archived")
         return null;
-    const pending = mergePendingWakeup(taskId, reason, now, store.getPendingWakeup(taskId));
-    store.savePendingWakeup(pending);
-    return pending;
+    // The scheduler's pending-wakeup projection may expose an already-owned
+    // processing prefix. Append to the actual suffix, never write that read
+    // projection back over independent inputs.
+    const pending = enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, reason, now).pending;
+    return {
+        schemaVersion: 1, taskId, reasons: [...pending.reasons],
+        requestCount: pending.requestCount,
+        firstRequestedAt: pending.firstQueuedAt, lastRequestedAt: pending.lastQueuedAt
+    };
 }

package/dist/storage/sqliteSchema.js

@@ -286,6 +286,15 @@ const MINOR_UPGRADES = Object.freeze([{
         // Optional Role presentation and generated-title provenance. Never infer
         // ownership of historical titles, rewrite frozen profiles, or fill defaults.
         sql: ""
+    }, {
+        fromVersion: "1.25",
+        toVersion: "1.26",
+        name: "codex-workspace-temp-exclusions",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Optional workspace-write permission fields; preserve all existing payloads.
+        sql: ""
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.25";
+export const CURRENT_STORAGE_VERSION = "1.26";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/tmux/tmuxManager.js

@@ -62,7 +62,9 @@ export class TmuxManager {
         this.#yuiHome = options.yuiHome ?? process.env.YUI_HOME ?? process.cwd();
         this.#serverName = yuiTmuxServerName(this.#yuiHome);
         this.#onRoleTargetRecorded = options.onRoleTargetRecorded;
-        this.#terminalInput = options.terminalInput ?? process.stdin;
+        // Creating Node's stdin stream can make piped fd 0 nonblocking. Commands
+        // may still need to read that pipe synchronously before any attach.
+        this.#terminalInput = options.terminalInput;
         this.#terminalType = usableInteractiveTerminal(options.terminalType ?? process.env.TERM);
         this.#closeInteractiveInput = options.closeInteractiveInput ?? (() => { });
         this.#readinessTimeoutMs = positiveInteger(options.readinessTimeoutMs, DEFAULT_READINESS_TIMEOUT_MS, "readiness timeout");
@@ -228,7 +230,7 @@ export class TmuxManager {
             }
             if (resolvedAccess === "read-write")
                 options.revalidateWritableAttach?.();
-            handoffTerminal(this.#terminalInput, this.#closeInteractiveInput);
+            handoffTerminal(this.#terminalInput ?? process.stdin, this.#closeInteractiveInput);
             this.run([
                 "attach-session",
                 ...(resolvedAccess === "read-only" ? ["-r"] : []),

package/dist/web/webSettings.js

@@ -276,6 +276,8 @@ const ROLE_FIELDS = {
     model: { set: "--model", clear: "--clear-model" }, effort: { set: "--effort", clear: "--clear-effort" },
     "permission.strategy": { set: "--permission-strategy" }, "permission.sandbox": { set: "--sandbox" },
     "permission.approval": { set: "--approval" }, "permission.mode": { set: "--permission-mode" },
+    "permission.excludeTmpdirEnvVar": { set: "--exclude-tmpdir-env-var", clear: "--clear-exclude-tmpdir-env-var" },
+    "permission.excludeSlashTmp": { set: "--exclude-slash-tmp", clear: "--clear-exclude-slash-tmp" },
     "permission.allowedTools": { set: "--allowed-tool", clear: "--clear-allowed-tools", many: true },
     "permission.disallowedTools": { set: "--disallowed-tool", clear: "--clear-disallowed-tools", many: true },
     search: { set: "--search", clear: "--clear-search" },

package/docs/authorization.md

@@ -20,9 +20,24 @@ authorization for any external effect.
 | May it access an additional resource or irreversible effect? | `CapabilityGrant`, `grant/taskAuthorization.ts`, resource/plugin/release consumers | Task activation does not authorize arbitrary resources |
 
 The full command inventory is generated from the catalog, not maintained as a
-second per-command permissions table: use `yui --json help` and scoped
-`yui --json help task`, or traverse `describeCommandTree(discoveryCommandTree(env))`
-in offline tooling. Complete role hints retain an offline template even without
+second per-command permissions table. `yui --json help` and scoped
+`yui --json help task` return the selected command's full details and all its
+immediate child **summaries**, not a recursively expanded tree. The `discovery`
+field labels this boundary and gives the detail and full-tree commands. Follow
+each child's `path` with `yui --json help <command ...>` for full usage, options,
+values and examples, or use `yui --json help [command ...] --recursive` for the
+complete caller-filtered tree in one call.
+
+This changes the default JSON help shape: consumers that previously traversed
+nested `children` must request `--recursive`; absence of child details in the
+default view is not proof that the child has no options or descendants.
+Focused leaf details are unchanged, with additive discovery metadata.
+Text help still shows immediate children; `--recursive` requires `--json`.
+`config describe --json` and the offline
+`describeCommandTree(discoveryCommandTree(env))` API retain full recursive
+descriptions. Native `yui agent` product help is a separate surface and unchanged.
+
+Complete role hints retain an offline template even without
 a running Home; that is not authentication. Native-ID-only callers are resolved
 from read-only local storage for help/completion; if that read fails the CLI shows
 the restricted `unbound` template. No Controller or provider is started for that

package/docs/cli-information-contract.md

@@ -21,7 +21,7 @@ declared storage 1.10 → 1.11 transition; historical sources are never invented
 | 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 read pointer, authority, current native Turn/retry facts and a bounded pending Message page; history is opt-in |
 | 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 inputs/results, attributed optional summaries and exact original reads; `--history` expands diagnostics |
+| What arrived in this wake? | `task wake show <task> <wake>` | Fixed-window inputs/results, bounded complete ordinary inputs and exact original reads; `--history` expands diagnostics |
 | What was assigned? | `task run context <task>/<run>` | Frozen authority, up to 16 `pointers`, sampled changed identities and live observations with totals; `--view refs` pages references, `--view full` reads the full pack |
 | Which repeated failure? | `role message list <role> --diagnostics` | Derived classified groups with count, first/latest and recovery evidence; `--diagnostic <key>` pages original occurrences |
 | 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 |
@@ -32,11 +32,35 @@ Task Role-status and wake-history lists also page, with explicit detail commands
 Role discovery reports `recordedHealth` and `hostObservation: "not-requested"`,
 not live Host health. Even a normal recorded status cannot rule out a failed Host
 or unacknowledged terminal; follow the row's `task role status` read to inspect it.
+`task role status <task> <role>` defaults to `--view current`: the same computed
+health, Host, delivery/retry, cleanup and drift observations, with Run/WorkItem
+identities and exact detail commands instead of their input/report/history bodies.
+Retry diagnostics remain available through the current retry read. Desired and
+effective configuration remain visible; unknown evidence is not upgraded to success.
+This changes the default nested JSON contract. Consumers needing the previous
+complete records use `--view full` and retain that option on pagination.
+The underlying runtime status projection and Web payload are unchanged.
 Context lists additionally expose candidates, reviews, jobs, Project Knowledge,
 workspaces and other authorized record families. `--status`, `--after` and
 `--work-item` narrow Context discovery; every continuation must retain filters.
 Run listing accepts a Task or `task/work` target.
 
+`task run show <task>/<run> --view status` reads identity, record status,
+delivery/retry observations, retirement and result availability without copying
+input, launch or report bodies. It uses the same authorization as the default
+`--view full`, which retains complete audit evidence and document pagination.
+Its retry observation is the same current summary used in Task Context, with
+an exact Session retry command for raw diagnostics and history, not their bodies.
+`--view result` returns the complete original result (including failure/provider
+fields), Run identity/status, retirement and execution observation without the
+submitted input or launch configuration. An absent result is `null`, not success.
+Long reports retain document pagination; continue with the same view. The full
+audit command remains available in `reads.full`, and the default is still full.
+Read the original result through its Message, result or full Run view before disposition;
+status is neither a report nor acceptance. Once that exact original is available
+in current context, use status for additional execution facts instead of loading
+the report twice. No read receipt or model-memory cache is introduced.
+
 Current Context's `attention.messages` excludes explicit acknowledgements and
 retirements; delivery alone is not handling. The exact wake receipt and latest
 Message revision determine coverage. `--view current` continues that view;
@@ -45,6 +69,28 @@ explicitly describe incomplete discovery. Samples are not proof that no older pe
 relevant input exists. Read the relevant fixed wake and original Messages;
 use family discovery when a broader requirement/history audit is needed.
 
+Current Context is a working index, not a repeated configuration or requirements
+dump. Task/Brief, Role, Project policy, workspace, delivery and decision records
+return summaries and exact references even when their bodies are small. Lifecycle,
+execution authority, attention counts and active execution/retry observations
+remain inline. Read a relevant original through `context inspect` before acting
+on its requirements or authority; `omitted: true` is not an empty original.
+Fresh reads still compute current identities and enforce scope. There is no
+model-memory cache, inferred handling receipt or automatic reuse of stale state.
+Within the current workspace sample, the exact Run workspace overlay (when
+authorized) precedes Task main, then other workspaces. Historical integration
+directories cannot crowd Task main out of that sample. Full family discovery
+retains its existing ordering, counts and original records; this priority neither
+changes workspace authority nor grants access to another Assignment.
+
+Message discovery can reuse an existing producer-authored `Yui-Summary:` from
+the Message body or its matching terminal Run result. It labels the source as
+an **author summary**, not a verified outcome or handling decision. The source
+label counts toward the 512-byte summary budget; an otherwise valid summary
+that no longer fits is omitted whole with an original-read hint, not clipped.
+Missing, oversized or mismatched result summaries do not hide the Message or
+change its exact original, digest, authorization or handling state.
+
 ## Budgets and continuations
 
 - Discovery pages default to 20 items, accept 1–100, and enforce a 32 KiB
@@ -58,6 +104,11 @@ use family discovery when a broader requirement/history audit is needed.
   uncertain ones. Historical missing receipts are a separate count and explicit
   `inbox list --view history` read; absence of ACK is not proof of unexecuted work.
   Continue its pending page with `role message list <role> --current --cursor`.
+  A managed self-read additionally includes `currentOriginals`: complete records
+  correlated to this exact Turn and present in that pending page, at most 4 KiB
+  each and 8 KiB combined. Available future inputs, history and oversized records
+  remain discovery-only; their exact reads are unchanged. Inspection callers get
+  no inline originals. This does not claim, deliver or acknowledge input.
   It does not repeat recent history, Profile bodies, frozen Skill
   packages or accumulated retry details. The Manifest is the Profile pointer;
   explicit Message and Session retry reads retain history and original evidence.
@@ -75,14 +126,25 @@ use family discovery when a broader requirement/history audit is needed.
   document continuation uses `--view full`. Neither changes the frozen authority.
   Read `--view input` before acting when `input.directiveOmitted` is true: the
   entry's bounded directive summary is not the assigned instruction body.
+  New frozen Task-message pointers include a literal `Excerpt:` preview in their
+  existing summary (at most 160 UTF-8 bytes), alongside the original revision
+  and digest. Use it to select relevant originals, not as their complete body or
+  authority. Later message edits cannot change that Run's frozen preview.
+  Existing snapshots are not regenerated.
+  When pointers are present, `reads.expand` exposes the existing selected-original
+  batch syntax directly. Replace the placeholders with relevant frozen pointers;
+  this is not a preselected read-all command. The existing 1–8 selection limit,
+  exact snapshot checks, complete original bodies and page budget are unchanged.
 - `session skills [--cursor ...]` checks only current metadata/readability. It
   does not read Skill bodies or historical packages, and uses document pagination
   only when the configured metadata exceeds the inline budget.
 - Detail documents up to 16 KiB remain ordinary JSON. Larger documents return
   `contentPage`: exact source, SHA-256 digest, JSON-character offset, total bytes
-  and characters, text, completeness and a next cursor. Chunks contain at most
-  4096 UTF-16 code units without splitting surrogate pairs, keeping escaped
-  wire output below 32 KiB. There is no 4 MiB cutoff that makes a legal original
+  and characters, text, completeness and a next cursor. Chunk lengths adapt to
+  the complete encoded 32 KiB response budget, including identity and cursors,
+  with 256 bytes reserved for small command wrappers. Chunks never split
+  surrogate pairs; offsets remain UTF-16 units and previously issued cursors
+  remain readable. There is no 4 MiB cutoff that makes a legal original
   permanently unreadable.
 - Task metadata/next-action/remote-delivery, Brief, WorkItem, Message, Run,
   decision/milestone/event, Role show/status/Session inspection, wake detail,
@@ -111,6 +173,93 @@ Use `--json` and read the top-level `data`. Run context and expansion use
 the same source and digest, and parse the combined JSON once. Do not parse
 chunks individually or treat a first chunk as the complete report.
 
+### Copyable detail-reading example
+
+For 1–8 already-known independent originals in the same Task, use
+`task context inspect <task> --refs '<JSON array of discovery ref objects>'`.
+For hand-written commands, repeated `--context-ref <store/refId@digest>` flags
+avoid JSON quoting; they use the same exact-reference spelling as dispatch.
+Do not combine the two selection formats or single-inspect selector flags.
+Each object requires `store`, `refId`, and `digest`; optional `revision` is
+discovery metadata, not a second freshness guard. The response contains
+`{taskId, items}`, with each item identical to a single inspect result.
+The entire batch shares the existing 32 KiB budget, not one budget per item.
+Follow `contentPage` using the same ordered references and `--cursor`.
+A stale, duplicate, unavailable or forbidden reference rejects the whole read.
+Each original is independently digest-pinned; this does not create an atomic
+cross-record snapshot, select sources, claim inputs, or grant broader access.
+Use single inspect unchanged when only one original is needed.
+
+For `task context inspect`, the following Node.js example consumes the outer
+`data` envelope. Supply the authorized CLI path and exact discovery arguments;
+keep the current Session environment. It only reads that record, does not claim
+or acknowledge input, and does not prove that an Agent has read its contents.
+Save as a local `.mjs` file and invoke
+`node reader.mjs /absolute/path/to/yui task-1 task-message message-1 <digest>`.
+The final stdout is the reconstructed record; capture it in your owned scratch
+directory and read it in bounded portions if it exceeds the tool output limit.
+Do not re-fetch earlier pages just to inspect metadata.
+
+```js
+import { spawnSync } from "node:child_process";
+
+function readDocument(read) {
+  let cursor, source, digest, total, offset = 0;
+  const chunks = [];
+  for (;;) {
+    const data = read(cursor);
+    const page = data.contentPage;
+    if (!page) {
+      if (chunks.length) throw Error("Detail changed shape during pagination");
+      return data;
+    }
+    if (!chunks.length) {
+      ({ source, digest, totalCharacters: total } = page);
+    }
+    if (page.source !== source || page.digest !== digest ||
+        page.totalCharacters !== total || page.offset !== offset ||
+        typeof page.text !== "string" || !page.text.length) {
+      throw Error(`Detail identity/offset mismatch at ${offset}`);
+    }
+    chunks.push(page.text);
+    offset += page.text.length; // UTF-16 units, not UTF-8 bytes.
+    if (page.complete === true && page.nextCursor === null && offset === total) {
+      try { return JSON.parse(chunks.join("")); }
+      catch { throw Error(`Invalid completed detail at ${offset}`); }
+    }
+    if (page.complete !== false || offset >= total ||
+        typeof page.nextCursor !== "string" || !page.nextCursor.length) {
+      throw Error(`Invalid continuation at ${offset}`);
+    }
+    cursor = page.nextCursor;
+  }
+}
+
+const [cli, task, store, ref, digest] = process.argv.slice(2);
+if (![cli, task, store, ref, digest].every(Boolean)) throw Error("Five arguments required");
+const args = ["task", "context", "inspect", task, "--store", store,
+  "--ref", ref, "--digest", digest, "--json"];
+const record = readDocument(cursor => {
+  const result = spawnSync(cli, [...args, ...(cursor ? ["--cursor", cursor] : [])],
+    { encoding: "utf8", maxBuffer: 1024 * 1024 });
+  if (result.error || result.status !== 0) throw Error("Detail command failed; stop without replay");
+  let reply;
+  try { reply = JSON.parse(result.stdout); }
+  catch { throw Error("Invalid CLI envelope"); }
+  if (reply.ok !== true || !reply.data) throw Error("Detail read refused");
+  return reply.data;
+});
+console.log(JSON.stringify(record));
+```
+
+This is a detail consumer, not a list paginator or a mutation retry helper.
+On a changed source or refusal, stop and reassess the original read; do not
+silently restart or mix versions. Errors deliberately exclude document text:
+passing a partial `contentPage.text` to `jq fromjson` can echo the entire
+fragment on failure. To inspect one already-fetched page without parsing it,
+use `.data.contentPage | {offset,len:(.text|length),complete,nextCursor}`.
+Two pages are not a completion condition; only the returned metadata is.
+
 List responses carry `items`, `total`, `complete`, and `nextCursor`. Counts,
 items and cursor validation occur inside the same authorized scope. Cursors
 are opaque positions, not access tokens: every page reauthorizes. A changed
@@ -163,6 +312,16 @@ timestamps overlap; `--history` retains timestamp-window discovery.
 
 ## Runtime diagnostics
 
+CLI JSON failures keep `ok`, `code`, `message` and `details`. `message` contains
+the primary error, effect uncertainty, safe recovery guidance and focused help;
+`details.diagnostic` retains the complete sanitized cause chain, operation,
+Home, CLI entry, targets and any Controller request/delivery/timing facts.
+Those identity lines and nested causes are not repeated as prose in `message`.
+Consumers needing them must read `details.diagnostic`, not parse the human
+message. Text-mode diagnostics remain unchanged. This is presentation only:
+exit codes, redaction, partial receipts and no-replay/recovery boundaries do
+not change; no probe, retry or repair is performed.
+
 Global failure evidence remains ordinary record-only Messages; no aggregate
 table, Message envelope change, memory store or recovery state machine is added.
 Grouping is a derived view of new evidence documents. Older documents remain
@@ -183,6 +342,42 @@ Discovery and every evidence page retain the existing Role read boundary.
 
 Message send/queue/steer receipts preserve identity, digest, body byte count and
 the original submission/delivery/control states without echoing the body.
+`bodySha256` is the lowercase SHA-256 of the saved body's raw UTF-8 bytes;
+`bodyBytes` counts those same bytes. Callers may compare them with the exact
+submitted file to verify transport without fetching the body again. Do not trim
+or JSON-encode the body before hashing. The separate `digest` covers the entire
+record and is not a body checksum. These fields are derived from the saved
+Message, including idempotent replay; they neither add persistent state nor
+replace required original reads, authorization, ACK or downstream acceptance.
+`operator submit --json` uses that same structured shape:
+`data.taskId`, `data.message` (the bounded Message receipt), and `data.submission`
+(the recorded save, phase, planning, activation, delivery and next-step facts).
+It no longer returns only an `output` string for JSON consumers; ordinary text
+output is unchanged. A same-key retry reproduces the saved submission feedback,
+not a fresh interpretation of the Task's later state. The receipt is not the
+original body or proof that the Leader finished.
+Message `--body-file <path|->` inputs preserve their UTF-8 text, including leading
+and trailing whitespace, through Operator submission and Task/Global message
+send, update, queue and steer paths. Blank-only or NUL-containing input remains
+invalid. Inline text and summary/note file normalization are unchanged. This fixes
+the earlier file-input trim; an old request saved after trimming must be inspected,
+not replayed with newly different bytes under the same request ID.
+Operator's optional `scripts/verify-submission.mjs` compares a local receipt with
+the payload and expected Task/intent/request ID. It performs no Yui operation,
+write, cleanup or ACK; a missing checksum is a failed local check, never success.
+`task decision record|supersede --json` also returns a bounded save receipt:
+`data.taskId`, `effect: "saved"`, `data.decision` (identity, state, timestamps,
+complete-record digest and rationale byte count). When the complete
+saved record is at most 2048 UTF-8 bytes in JSON, `decision` also contains all
+its fields and `contentOmitted` is false: callers can inspect the actual short
+saved value directly, without a `read` follow-up pointer. Larger records set
+`contentOmitted: true`, include an exact `read` command, and omit title,
+rationale and supersede-reason bodies rather than truncate them. The digest
+always covers the complete original record, excluding receipt-added fields;
+`decision show` remains the complete read when needed. Human text is unchanged.
+JSON callers must consume `data`
+instead of parsing the previous `output` string. This confirms the saved state,
+not semantic acceptance; a missing response never authorizes repeating a record.
 Brief updates return a saved reference. No new wait, retry, acknowledgement or
 approval phase is added. Repeating a read cursor must never repeat a mutation.
 
@@ -201,8 +396,35 @@ document does not claim a universal 32 KiB cap for them. Full-detail Web
 projections are separate consumers, not silently replaced with CLI summaries.
 Use targeted Context discovery for large Project Knowledge and Task evidence.
 
-For a typical notification, read current Context once, read the fixed wake once,
-then read each relevant original once (or its complete document pages).
+For a typical notification, read current Context and the fixed wake, then obtain
+only relevant originals not already returned in full (including their complete pages).
+The focused wake JSON includes complete ordinary Message values up to 4 KiB
+each and 8 KiB combined, marked `contentOmitted: false` with their current
+versioned `ref`. Use those bodies directly. Larger messages and result reports
+retain explicit reads; a completion notice never substitutes for its report.
+For an inline complete value, `refreshRead` is an optional current-source refresh,
+not a required next read; `read` is present only when the original is omitted.
+Consumers that previously followed every `messages[].read` must first inspect
+`contentOmitted` and use `value` for complete originals. Text output still links
+to the original because it presents only a summary, not the inline JSON value.
+The fixed window selects identities, not a historical snapshot of mutable
+message bodies. Later revisions remain distinguishable by their exact reference.
+History mode does not inline bodies. This changes no claim or ACK semantics.
+The current Leader's `inbox show <wake>` also returns that focused view as
+`originalContext`, with the existing wake metadata at the top level. It uses
+the same identity selection, inline limits and exact original pointers as
+`task wake show`; reuse the included complete bodies instead of making a second
+read. Own-inbox authorization still applies, and the outer read retains
+`contentPage` pagination. An unclaimed `pending-*` window has no fixed wake yet;
+its claim receipt still supplies the durable wake and original-read command.
+Claim/ACK mutations themselves are unchanged and do not perform extra reads.
+For mutations addressed to an existing `wake-*`, the receipt now calls that
+navigation `refreshOriginals`, not `originals`: use it when the focused originals
+are missing, incomplete or need refreshing, not merely because a claim occurred.
+Mutations addressed to `pending-*` retain `originals`, including idempotent claim
+retries, because their initial inspection did not provide fixed originals.
+This is a JSON navigation-field change; consumers must handle both entry types.
+It records no read history and does not waive complete relevant-original reads.
 Do not reread an aggregate to obtain a detail it intentionally omits.
 Full-original reading costs additional calls only when the original exceeds
 the inline budget; it is never replaced by a summary.