@zq-silk/yui 2.4.0 → 2.6.0

package/dist/cli/commandCatalog.js

@@ -408,8 +408,9 @@ const taskChildren = [
     {
         name: "context", discovery: { surface: "public", audiences: ["public", "operator", "leader", "assignment", "unbound"] },
         summary: "Read compact authorized facts, fixed-bound delta, or inspect a Context reference.",
-        usage: "yui task context [read|list|delta|inspect] <task> [--after <cursor>] [--continuation <cursor>] [--cursor <cursor>] [--limit <n>] [--store <store> --ref <id>] [--digest <digest>]",
-        options: ["--after", "--continuation", "--cursor", "--limit", "--store", "--ref", "--digest", "--status", "--work-item"]
+        usage: "yui task context [read|list|delta|inspect] <task> [--after <cursor>] [--continuation <cursor>] [--cursor <cursor>] [--limit <n>] [--store <store> --ref <id>] [--digest <digest>] [--view <current|all>]",
+        options: ["--after", "--continuation", "--cursor", "--limit", "--store", "--ref", "--digest", "--status", "--work-item", "--view"],
+        optionValues: { "--view": ["current", "all"] }
     },
     {
         name: "next-action", discovery: { surface: "managed", audiences: ["operator", "leader"] },
@@ -1096,7 +1097,7 @@ const taskChildren = [
         sections: [{ id: "manage", title: "Commands", entries: ["list", "show", "retry", "resolve"] }],
         children: [
             { name: "list", discovery: { surface: "managed", audiences: ["operator", "leader"] }, summary: "List recorded Leader wakes.", usage: "yui task wake list <task> [--limit <1..100>] [--cursor <cursor>]", options: ["--limit", "--cursor"] },
-            { name: "show", discovery: { surface: "managed", audiences: ["operator", "leader"] }, summary: "Show a fixed wake window and exact detail reads.", usage: "yui task wake show <task> <wake> [--cursor <cursor>]", options: ["--cursor"] },
+            { name: "show", discovery: { surface: "managed", audiences: ["operator", "leader"] }, summary: "Show fixed wake inputs/results; expand diagnostics with --history.", usage: "yui task wake show <task> <wake> [--history] [--cursor <cursor>]", options: ["--history", "--cursor"] },
             { name: "retry", discovery: { surface: "managed", audiences: ["operator", "leader"] }, summary: "Retry a rejected notification after correcting its cause; preserve original input.",
                 usage: "yui task wake retry <task> <wake> --reason <correction>", options: ["--reason"] },
             { name: "resolve", discovery: { surface: "managed", audiences: ["operator", "leader"] }, summary: "Release an unknown notification claim after explicit quiescence evidence, without replay.",

package/dist/commands/taskCommands.js

@@ -13,6 +13,7 @@ import { assertContextRecordReadable, readTaskContextResource } from "../context
 import { parseTaskSearchOptions, searchTaskBodies } from "../context/taskSearch.js";
 import { boundedDocument, readOptions, messageReceipt, recordPage } from "../output/boundedRead.js";
 import { referencedWakeRunIds } from "../context/wakeRunReferences.js";
+import { taskMessagePresentation, wakeChangeLabels, wakeMessages } from "../interaction/notificationPresentation.js";
 import { completeProcessing, releaseProcessing } from "../coordination/workMailbox.js";
 import { enqueueRoleRunDispatch, enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
 import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageError } from "../errors/cliError.js";
@@ -44,14 +45,14 @@ import { copyGlobalRoleToTaskRole, activeRoleAgentBinding, createRole, createRol
 import { roleLaunchEventPayload, saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
 import { RUNTIME_SESSION_REPLACE_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { currentManagedRuntime, resolveManagedTaskReader } from "../runtime/managedCaller.js";
-import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { controlProviderRetry, providerRunRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
 import { currentProviderConversation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { failureCapabilitiesCommand } from "../runtime/agentFailureContext.js";
 import { enqueueOperatorEvent } from "../scheduler/operatorEvent.js";
 import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
-import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
+import { parseWakeReason, renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { planningRuntimeCwd } from "../storage/homeLayout.js";
 import { StorageConflictError } from "../storage/taskStore.js";
@@ -4896,7 +4897,9 @@ function retryRun(args, store, options) {
             return output(`Retry already recorded as ${existing.payload.runId}; retry that exact successor if needed.\n`);
         }
         const sessions = tx.getTaskRoleSessionSet(previous.taskId, previous.roleName);
-        const retry = sessions?.providerBinding?.retry;
+        const retry = options.providerRetryChainId !== undefined ? sessions?.providerBinding?.retry
+            : sessions?.providerBinding == null ? undefined
+                : providerRunRetry(sessions.providerBinding, previous.id, clock(options).getTime());
         if (options.providerRetryChainId !== undefined
             && (retry?.chainId !== options.providerRetryChainId || retry.status !== "waiting"
                 || retry.previousRunId !== previous.id || clock(options).getTime() < Date.parse(retry.nextEligibleAt)
@@ -4908,7 +4911,10 @@ function retryRun(args, store, options) {
             const successor = tx.getActiveRun(previous.taskId, previous.roleName);
             tx.saveTaskRoleSessionSet({
                 ...sessions, providerBinding: {
-                    ...sessions.providerBinding, retry: {
+                    ...sessions.providerBinding,
+                    ...(sessions.providerBinding.retry !== undefined && sessions.providerBinding.retry.chainId !== retry.chainId
+                        ? { retryHistory: [...(sessions.providerBinding.retryHistory ?? []), sessions.providerBinding.retry] } : {}),
+                    retry: {
                         ...retry, status: "waiting", successorAutomatic: options.providerRetryChainId !== undefined,
                         ...(options.providerRetryChainId === undefined ? {
                             intentAt: clock(options).toISOString(),
@@ -6932,12 +6938,16 @@ function taskWakeInspectionCommand(args, store) {
         return output(`${JSON.stringify(data)}\n`, data);
     }
     if (command === "show") {
-        const usage = "Task wake show usage: yui task wake show <task> <wake>.";
-        exactPositionals(rest, 2, usage);
-        const task = requireTask(store, rest[0]);
-        const wake = store.getTaskWake(task.id, rest[1]);
+        const usage = "Task wake show usage: yui task wake show <task> <wake> [--history].";
+        const history = rest.includes("--history");
+        const positional = history ? rest.filter(arg => arg !== "--history") : rest;
+        exactPositionals(positional, 2, usage);
+        if (rest.filter(arg => arg === "--history").length > 1)
+            throw usageError(usage);
+        const task = requireTask(store, positional[0]);
+        const wake = store.getTaskWake(task.id, positional[1]);
         if (wake === null)
-            throw dataError(`Wake not found: ${rest[1]}.`);
+            throw dataError(`Wake not found: ${positional[1]}.`);
         const timeZone = store.getConfig().timeZone;
         const fromMs = Date.parse(wake.fromCursor);
         const toMs = Date.parse(wake.toCursor);
@@ -6953,8 +6963,20 @@ function taskWakeInspectionCommand(args, store) {
         const currentClaim = store.getWorkMailbox(leaderMailbox(task.id))?.processing;
         const referenced = (type, id) => wake.refs?.some(ref => ref.type === type && ref.id === id
             && (!("taskId" in ref) || ref.taskId === task.id)) === true;
-        const events = allEvents.filter((e) => inWindow(e.createdAt) || referenced("event", e.id));
-        const messages = store.listMessages(task.id).filter((m) => inWindow(m.createdAt) || referenced("message", m.id));
+        // Some existing producers carry the exact source only in a reason tag
+        // (e.g. input-timeout:<request>). Do not hide its decision behind --history.
+        const reasonRefs = new Set(wake.reasons.flatMap(tag => {
+            const reason = parseWakeReason(tag);
+            return reason.kind !== "force-wake" && reason.ref !== undefined ? [reason.ref] : [];
+        }));
+        const reasonEvent = (event) => Date.parse(event.createdAt) <= toMs && [
+            event.id, event.payload.runId, event.payload.requestId, event.payload.jobId,
+            event.payload.workItemId, event.payload.reviewRoundId
+        ].some(id => id !== undefined && reasonRefs.has(id));
+        const windowEvents = allEvents.filter((e) => inWindow(e.createdAt) || referenced("event", e.id) || reasonEvent(e));
+        const events = history ? windowEvents : windowEvents.filter(e => referenced("event", e.id)
+            || reasonEvent(e) || ["run.completed", "run.failed", "run.cancelled"].includes(e.type));
+        const messages = wakeMessages(wake, store.listMessages(task.id));
         const allRuns = store.listRuns(task.id);
         const referencedRunIds = new Set(referencedWakeRunIds(allRuns, allEvents, events));
         for (const run of allRuns)
@@ -6963,7 +6985,7 @@ function taskWakeInspectionCommand(args, store) {
         for (const message of messages)
             if (message.resultRef?.type === "agent-run-result")
                 referencedRunIds.add(message.resultRef.runId);
-        const runs = operationalTaskRecords(allRuns, allEvents, "run").filter((run) => (inWindow(run.createdAt) || referencedRunIds.has(run.id)));
+        const runs = operationalTaskRecords(allRuns, allEvents, "run").filter((run) => (history && inWindow(run.createdAt) || referencedRunIds.has(run.id)));
         const lines = [
             `Wake: ${wake.id}`,
             `Task: ${task.id}`,
@@ -6979,29 +7001,40 @@ function taskWakeInspectionCommand(args, store) {
                 `Recovery: correct the cause, then yui task wake retry ${task.id} ${wake.id} --reason <correction>.`
             ]),
             `Reasons: ${wake.reasons.map(renderWakeReason).join(", ")}`,
+            `Changes: ${wakeChangeLabels(wake.reasons).join("; ")}`,
             `Delta window: ${wake.fromCursor} → ${wake.toCursor}`,
             `Dispatched: ${presentTime(wake.createdAt, timeZone)}`,
             ...(wake.consumedAt === undefined
                 ? []
                 : [`Consumed: ${presentTime(wake.consumedAt, timeZone)}`]),
             `Events (${events.length}):`,
-            ...events.map((e) => `  ${e.id} ${e.type} ${presentTime(e.createdAt, timeZone)}`),
+            ...events.map((e) => `  ${e.id} ${e.type} ${presentTime(e.createdAt, timeZone)} → yui task event show ${task.id} ${e.id}`),
             `Messages (${messages.length}):`,
-            ...messages.map((m) => `  ${m.id} [${taskMessageAuthorLabel(m.author)}] ${presentTime(m.createdAt, timeZone)}`),
+            ...messages.map((m) => {
+                const item = taskMessagePresentation(m, (taskId, runId) => store.getRun(taskId, runId));
+                return `  ${m.id} [${taskMessageAuthorLabel(m.author)}] ${item.fact}`
+                    + (item.summary === undefined ? "" : `; author summary (${item.summarySource}): ${JSON.stringify(item.summary)}`)
+                    + ` → yui task message show ${task.id}/${m.id}`;
+            }),
             `AgentRuns (${runs.length}):`,
             ...runs.map((run) => (`  ${run.id} [${run.status}/${run.purpose}] ${run.roleName} `
                 + `${presentTime(run.createdAt, timeZone)}`
                 + `${referencedRunIds.has(run.id)
                     ? ` → yui task run show ${task.id}/${run.id}`
-                    : ""}`))
+                    : ""}`)),
+            ...(!history ? [`History/diagnostics: yui task wake show ${task.id} ${wake.id} --history`,
+                "Read relevant originals in full; follow contentPage.nextCursor when present."] : [])
         ];
         return output(lines.join("\n").concat("\n"), {
             taskId: task.id,
             deliveryEvents,
             wake,
+            view: history ? "history" : "focus",
+            historyRead: `task wake show ${task.id} ${wake.id} --history`,
             events: events.map(event => ({ id: event.id, type: event.type, createdAt: event.createdAt,
                 read: `task event show ${task.id} ${event.id}` })),
             messages: messages.map(message => ({ id: message.id, kind: message.kind, author: message.author,
+                ...taskMessagePresentation(message, (taskId, runId) => store.getRun(taskId, runId)),
                 resultRef: message.resultRef, read: `task message show ${task.id}/${message.id}` })),
             runs: runs.map(run => ({ id: run.id, status: run.status, purpose: run.purpose, roleName: run.roleName,
                 read: `task run show ${task.id}/${run.id}` }))

package/dist/commands/taskContextCommand.js

@@ -17,12 +17,12 @@ export function runTaskContextCommand(args, store, environment = {}) {
     const action = explicit ? args[0] : "read";
     const taskId = args[explicit ? 1 : 0];
     if (!taskId || taskId.startsWith("--"))
-        throw usageError("Task context usage: yui task context [read|list|delta|inspect] <task> [--after <cursor|timestamp>] [--continuation <cursor>] [--cursor <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest>] [--status <status>] [--work-item <id>].");
+        throw usageError("Task context usage: yui task context [read|list|delta|inspect] <task> [--after <cursor|timestamp>] [--continuation <cursor>] [--cursor <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest>] [--view <current|all>] [--status <status>] [--work-item <id>].");
     const options = new Map();
     const rest = args.slice(explicit ? 2 : 1);
     const allowed = action === "read" ? [] : action === "delta"
         ? ["--after", "--continuation", "--limit"] : action === "list"
-        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item"] : ["--store", "--ref", "--digest", "--cursor"];
+        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item", "--view"] : ["--store", "--ref", "--digest", "--cursor"];
     for (let i = 0; i < rest.length; i += 2) {
         const flag = rest[i];
         const value = rest[i + 1];
@@ -40,6 +40,7 @@ export function runTaskContextCommand(args, store, environment = {}) {
             throw usageError("Context list requires --store.");
         data = listTaskContext(store, taskId, family, {
             cursor: options.get("--cursor"),
+            view: options.get("--view"),
             status: options.get("--status"), after: options.get("--after"), workItemId: options.get("--work-item"),
             ...(options.has("--limit") ? { limit: Number(options.get("--limit")) } : {})
         }, environment);

package/dist/context/sessionBootstrapManifest.js

@@ -12,12 +12,18 @@ export function withSessionContextPointer(text, environment) {
     if (manifest === undefined)
         return text;
     return [
-        `Read the Yui Session Manifest at ${manifest}.`,
-        "Follow its referenced Role Skills and role profile. It gives the exact Context load command.",
+        sessionContextInstructions(manifest),
         "",
         text
     ].join("\n");
 }
+/** No remembered/sent flag can prove instructions survived context compaction. */
+export function sessionContextInstructions(manifestPath, digest) {
+    return `Yui Session Manifest: ${manifestPath}${digest === undefined ? "" : ` (digest ${digest})`}. `
+        + "Apply yui-runtime and its Role Skills/profile by exact manifest paths. "
+        + "Load on first entry, version change or missing context; reuse only same-version instructions "
+        + "fully available now, never infer availability from prior reads.";
+}
 /** Read back one immutable Session Manifest and verify its content digest. */
 export function readSessionBootstrapManifest(path) {
     const source = resolve(path);

package/dist/context/taskContext.js

@@ -191,7 +191,10 @@ export function readTaskContextResource(store, taskId, selector, environment = {
 export function listTaskContext(store, taskId, family, options = {}, environment = {}) {
     return store.readTransaction(reader => {
         const scope = authorizeContext(reader, taskId, environment);
-        const sources = authorizedSources(reader, scope, false, family);
+        if (options.view !== undefined && !["current", "all"].includes(options.view)) {
+            throw usageError("Context list view must be current or all.");
+        }
+        const sources = authorizedSources(reader, scope, options.view === "current", family, true);
         if (!CONTEXT_FAMILIES.includes(family))
             throw usageError(`Unknown Context store: ${family}.`);
         if (options.after !== undefined && !Number.isFinite(Date.parse(options.after)))
@@ -216,7 +219,7 @@ export function listTaskContext(store, taskId, family, options = {}, environment
             }
         }
         return recordPage(records, `task:${taskId}/${family}/${JSON.stringify({
-            status: options.status, after: options.after, workItemId: options.workItemId
+            view: options.view ?? "all", status: options.status, after: options.after, workItemId: options.workItemId
         })}`, options);
     });
 }
@@ -447,7 +450,7 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
         default: return null;
     }
 }
-function authorizedSources(store, { task, allow, caller }, current = false, requestedFamily) {
+function authorizedSources(store, { task, allow, caller }, current = false, requestedFamily, discovery = false) {
     const taskId = task.id;
     const sources = [];
     const add = (family, id, value) => {
@@ -462,7 +465,7 @@ function authorizedSources(store, { task, allow, caller }, current = false, requ
         const { count } = store.queryContextRecords(taskId, { ...selection, limit: 0 });
         sources.push({ family, count, *read(offset = 0) {
                 for (const { id, value } of store.queryContextRecords(taskId, {
-                    ...selection, offset, limit: current ? 8 : MAX_RECORDS
+                    ...selection, offset, limit: current && !discovery ? 8 : MAX_RECORDS
                 }).records)
                     yield materialize(family, id, value);
             } });

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { taskNotificationPresentation } from "../interaction/notificationPresentation.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { interruptThenTerminalState, prepareMessageContinuations } from "../message/messageContinuation.js";
 import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
@@ -1848,7 +1849,11 @@ export class FileSchedulerStoreAdapter {
                 }
                 const nextAttempt = `notification:${taskId}/${wakeId}/${randomUUID()}`;
                 store.saveWorkMailbox({ ...mailbox, processing: { ...processing, batchId: nextAttempt } });
-                return { wakeId, attemptId: nextAttempt, disposition: "submit" };
+                const wake = store.getTaskWake(taskId, wakeId);
+                if (wake === null)
+                    throw new Error(`Notification wake is unavailable: ${taskId}/${wakeId}.`);
+                return { wakeId, attemptId: nextAttempt, disposition: "submit",
+                    presentation: taskNotificationPresentation(wake, store) };
             }
             if (mailbox.pending === null || (provider !== null && provider !== undefined
                 && ["submitting", "accepted", "delivery-unknown"].includes(provider.status)))
@@ -1918,7 +1923,7 @@ export class FileSchedulerStoreAdapter {
             // batch, rather than delivering them with the chosen immediate successor.
             if (remainingRefs.length > 0)
                 enqueueWork(store, target, "user-message", now, remainingRefs, { source: "controller", dedupeKey: `then-remainder:${wakeId}` });
-            return { wakeId, attemptId, disposition: "submit" };
+            return { wakeId, attemptId, disposition: "submit", presentation: taskNotificationPresentation(wake, store) };
         });
     }
     settleLeaderNotification(taskId, attemptId, outcome, now, detail, failure) {

package/dist/controller/globalInputDelivery.js

@@ -4,6 +4,7 @@ import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/
 import { markGlobalRoleMessageNotDelivered } from "../message/message.js";
 import { providerRetryPending } from "../runtime/providerRetry.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
+import { globalMessagePresentation } from "../interaction/notificationPresentation.js";
 /** Messages are the only queue. Host's atomic begin arbitrates native writers. */
 export async function deliverGlobalInputs(home, store, ensure, onError) {
     for (const role of store.listGlobalRoles()) {
@@ -119,10 +120,7 @@ export async function deliverGlobalInputs(home, store, ensure, onError) {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "submit-turn", nativeSessionId,
                     authority: { epoch: binding.authority.epoch, owner: "controller",
                         holderId: binding.authority.holderId },
-                    run: { attemptId, boundedText: [
-                            `Yui Global Message: role=${role.name} message=${next.id}.`,
-                            "Read your Session Context and the referenced Message in full, then act on its durable input."
-                        ].join("\n") }
+                    run: { attemptId, boundedText: globalMessagePresentation(role.name, next.id, next) }
                 }
             });
             if (result.outcome === "rejected") {

package/dist/controller/providerRetryDelivery.js

@@ -10,6 +10,7 @@ import { cancelProviderRetry, providerRetryAttemptId, providerRetryPending, prov
 import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { retryIntentBlocker } from "./providerRetryAdmission.js";
 import { recordGlobalRuntimeAttention } from "./globalRuntimeAttention.js";
+import { globalMessagePresentation, taskNotificationPresentation } from "../interaction/notificationPresentation.js";
 /** Hooks in the existing Controller pass and nearest-deadline timer. SQLite's
  * current Provider input is the only pending intent; nothing is queued here. */
 export function createProviderRetryHooks(home, store, ports = {}) {
@@ -185,11 +186,12 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                             });
                         }
                         else {
+                            const wake = retry.input.kind === "wake" ? store.getTaskWake(retry.input.taskId, retry.input.wakeId) : null;
                             const original = retry.input.kind === "text" ? retry.input.text
                                 : retry.input.kind === "wake"
-                                    ? `Yui Task notification: task=${retry.input.taskId} wake=${retry.input.wakeId}.\nRead current Task context and that fixed wake window, including original Messages in full. This is not an execution assignment.`
+                                    ? wake === null ? undefined : taskNotificationPresentation(wake, store)
                                     : retry.input.kind === "message"
-                                        ? `Yui Global Message: role=${retry.input.roleName} message=${retry.input.messageId}.\nRead your Session Context and referenced original Message in full.`
+                                        ? globalMessagePresentation(retry.input.roleName, retry.input.messageId, store.listGlobalRoleMessages(retry.input.roleName).find(message => retry.input.kind === "message" && message.id === retry.input.messageId))
                                         : undefined;
                             if (original === undefined) {
                                 stop(set, "original-input-unavailable", at);

package/dist/executor/agentAdapter.js

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { realpathSync, statSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
+import { sessionContextInstructions } from "../context/sessionBootstrapManifest.js";
 import { isAgentAdapterId, supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
 import { ownedArgumentsForAdapter, validateAgentAdvancedArguments, validateAgentBaseArguments } from "../agent/argumentPolicy.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
@@ -434,10 +435,7 @@ function acpSessionBootstrap(input) {
             ])
         ]
         : [
-            `Yui managed Session. Read and follow the Session Manifest at `
-                + `${input.sessionManifestPath} (digest ${input.sessionManifestDigest ?? "unknown"}). `
-                + "Load each Skill and Role Profile by its manifest path before acting; Task "
-                + "content is available only through the manifest's exact Context API."
+            sessionContextInstructions(input.sessionManifestPath, input.sessionManifestDigest)
         ];
     const bootstrap = sections
         .filter((value) => value !== undefined && value.trim().length > 0)
@@ -500,7 +498,7 @@ function codexThreadOptions(input, config) {
 }
 function codexSessionInstructions(input) {
     if (input.sessionManifestPath !== undefined) {
-        return `Yui managed Session. Read and follow the Session Manifest at ${input.sessionManifestPath} (digest ${input.sessionManifestDigest ?? "unknown"}). Load each Skill and Role Profile by its manifest path before acting; Task content is available only through the manifest's exact Context API.`;
+        return sessionContextInstructions(input.sessionManifestPath, input.sessionManifestDigest);
     }
     const instructions = [
         input.developerInstructions,

package/dist/executor/fileRoleLaunchPlanner.js

@@ -9,7 +9,7 @@ import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironme
 import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/agent.js";
 import { NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment } from "../agent/launchEnvironment.js";
 import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
-import { materializeSessionBootstrap } from "../context/sessionBootstrapManifest.js";
+import { materializeSessionBootstrap, sessionContextInstructions } from "../context/sessionBootstrapManifest.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { activeRoleAgentBinding } from "../role/role.js";
 import { managedRuntimeAdmission } from "../runtime/agentDriver.js";
@@ -358,7 +358,7 @@ export class FileRoleLaunchPlanner {
         }
         const sessionContext = {
             ...baseSessionContext,
-            developerInstructions: `Read and follow the exact Yui Session Manifest at ${bootstrap.manifestPath}.`,
+            developerInstructions: sessionContextInstructions(bootstrap.manifestPath, bootstrap.manifest.digest),
             managedContextFile: bootstrap.manifestPath,
             sessionManifestPath: bootstrap.manifestPath,
             sessionManifestDigest: bootstrap.manifest.digest

package/dist/interaction/notificationPresentation.js

@@ -0,0 +1,85 @@
+import { parseWakeReason } from "../scheduler/wakeReason.js";
+/** Optional producer-authored presentation, stored in the original text, not a
+ * parsed business outcome or a second fact store. Reject oversized summaries
+ * whole: clipping could remove a failure/authority qualifier. */
+export function authoredNotificationSummary(text) {
+    const line = text?.trimStart().split(/\r?\n/u, 1)[0];
+    if (!line?.startsWith("Yui-Summary: "))
+        return undefined;
+    const summary = line.slice("Yui-Summary: ".length).trim();
+    return summary.length > 0 && Buffer.byteLength(summary) <= 512
+        && !/[\u0000-\u001f\u007f]/u.test(summary) ? summary : undefined;
+}
+export function taskMessagePresentation(message, getRun) {
+    const run = message.resultRef?.type === "agent-run-result"
+        ? getRun(message.taskId, message.resultRef.runId) : null;
+    const summary = authoredNotificationSummary(run?.result?.output ?? message.body);
+    const fact = run !== null
+        ? `${run.purpose === "review" ? "Review" : "Execution"} result returned (${run.status}); disposition pending`
+        : message.kind === "role-result" ? "Role result returned; disposition pending"
+            : message.kind === "user" || message.kind === "operator" ? "Additional input received"
+                : "System message received";
+    return {
+        fact,
+        ...(summary === undefined ? {} : {
+            summary, summarySource: run?.result?.output === undefined ? "message-body" : "agent-run-result"
+        })
+    };
+}
+export function wakeChangeLabels(reasons) {
+    return [...new Set(reasons.map(tag => {
+            const { kind } = parseWakeReason(tag);
+            switch (kind) {
+                case "operator-input":
+                case "user-message":
+                case "interrupt-then": return "Additional input received";
+                case "execution-started": return "Task execution enabled";
+                case "task-created": return "Task created";
+                case "task-reopened": return "Task reopened; check for scoped follow-up";
+                case "role-result": return "Role result returned; disposition pending";
+                case "review-failed": return "Review execution failed; inspect original failure";
+                case "agent-error":
+                case "leader-turn-failed":
+                case "role-turn-failed": return "Execution failure needs attention";
+                case "job-finished": return "Job ended; inspect outcome";
+                case "input-timeout": return "Input deadline reached; inspect recorded decision";
+                case "notification-retry": return "Notification retry after recorded correction";
+                default: return Buffer.byteLength(kind) <= 120 && !/[\u0000-\u001f\u007f]/u.test(kind)
+                    ? `Recorded update: ${kind}` : "Other recorded update; inspect wake";
+            }
+        }))];
+}
+export function wakeMessages(wake, messages) {
+    const ids = new Set(wake.refs?.filter(ref => ref.type === "message" && ref.taskId === wake.taskId).map(ref => ref.id));
+    const from = Date.parse(wake.fromCursor), to = Date.parse(wake.toCursor);
+    return messages.filter(message => ids.has(message.id)
+        || Date.parse(message.createdAt) > from && Date.parse(message.createdAt) <= to);
+}
+export function taskNotificationPresentation(wake, store) {
+    const messages = wakeMessages(wake, store.listMessages(wake.taskId));
+    const labels = wakeChangeLabels(wake.reasons);
+    return [
+        `Yui Task notification: task=${wake.taskId} wake=${wake.id}.`,
+        `Changes: ${labels.slice(0, 4).join("; ")}${labels.length > 4 ? "; more in wake" : ""}.`,
+        ...messages.slice(0, 4).map(message => {
+            const item = taskMessagePresentation(message, (task, run) => store.getRun(task, run));
+            return `- ${message.id} [${message.author.type}${message.author.type === "role" ? `:${message.author.roleName}` : ""}]: ${item.fact}.`
+                + (item.summary === undefined ? "" : ` Author summary (${item.summarySource}): ${JSON.stringify(item.summary)}`);
+        }),
+        ...(messages.length > 4 ? [`${messages.length - 4} more messages in the fixed wake.`] : []),
+        `Refresh: yui task context ${wake.taskId} --json`,
+        `Read inputs/results: yui task wake show ${wake.taskId} ${wake.id} --json`,
+        "Apply yui-leader (from the current Manifest); read relevant originals in full and advance authorized work."
+    ].join("\n");
+}
+export function globalMessagePresentation(roleName, messageId, message) {
+    const summary = authoredNotificationSummary(message?.body);
+    return [
+        `Yui Global Message: role=${roleName} message=${messageId}.`,
+        `Changes: ${message?.author.type ?? "Recorded"} input received.`,
+        ...(summary === undefined ? [] : [`Author summary (message-body): ${JSON.stringify(summary)}`]),
+        "Refresh Session Context using the current Manifest's loadCommand.",
+        `Read original: yui role message show ${roleName} ${messageId} --json`,
+        `Apply ${roleName === "operator" ? "yui-operator" : "yui-runtime"} from the current Manifest within existing authority.`
+    ].join("\n");
+}

package/dist/interaction/operatorPresentation.js

@@ -10,8 +10,7 @@ export function createOperatorBatchPresentation(batchId, items) {
         receiptId: `operator-batch:${batchId}`,
         text: [
             "[Yui updates]",
-            "Yui recorded the following durable updates. Inspect the referenced records and present only information that changes the user's understanding, authorization, or next action.",
-            "This notification is not a new execution assignment or authorization to replay prior operations.",
+            "Apply yui-operator from the current Manifest: inspect these originals and present material changes or decisions.",
             ...items.flatMap(renderItem)
         ].join("\n")
     };

package/dist/kernel/builtinCapabilities.js

@@ -47,7 +47,7 @@ const definitions = [
         name: "context.list", summary: "Discover one authorized record family with bounded summaries and exact references.",
         effect: "query", requiredPermissions: ["task:read"], source: "listTaskContext",
         inputSchema: object({ taskId: text, store: text, cursor: text, limit: { type: "integer" },
-            status: text, after: text, workItemId: text }, ["taskId", "store"]),
+            view: { type: "string", enum: ["current", "all"] }, status: text, after: text, workItemId: text }, ["taskId", "store"]),
         outputSchema: { type: "object", required: ["items", "total", "complete", "nextCursor"] }
     },
     {
@@ -304,6 +304,7 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                 }, callerEnvironment(caller));
             if (name === "context.list")
                 return listTaskContext(store, taskId, params.store, {
+                    view: params.view,
                     cursor: params.cursor, limit: params.limit,
                     status: params.status, after: params.after,
                     workItemId: params.workItemId

package/dist/runtime/builtinAgentErrorMappers.js

@@ -26,7 +26,7 @@ function mapClaudeDisplayError(input) {
 }
 /** Provider-specific Codex failure recognition. */
 export function mapCodexAgentError(input) {
-    return withTransientEvidence(mapCodexDisplayError(input), input);
+    return withTransientEvidence(mapCodexDisplayError(input), input, true);
 }
 function mapCodexDisplayError(input) {
     const text = `${input.message}\n${input.raw}`;
@@ -208,7 +208,7 @@ function sessionUnavailable(code) {
 }
 /** Replay qualification is stricter than the readable, best-effort category.
  * Never promote a number occurring in provider prose to submission safety. */
-function structuredTransientError(input) {
+function structuredTransientError(input, codex) {
     if (/insufficient[_ -]quota|quota.{0,25}(exhaust|exceed)|billing[_ -]hard[_ -]limit|usageLimitExceeded|credits?.{0,20}(exhaust|insufficient)/iu.test(`${input.message}\n${input.raw}`))
         return { category: "access", code: "provider.quota-exhausted", retryable: false };
     const nodes = [];
@@ -228,7 +228,8 @@ function structuredTransientError(input) {
     catch { /* Display classification may still use prose. */ }
     const codes = nodes.flatMap(n => [n.code, n.type, n.error, n.codexErrorInfo]).filter(v => typeof v === "string");
     if (codes.some(c => ["authentication_error", "permission_error", "invalid_api_key", "invalid_model",
-        "model_not_found", "usage_limit_exceeded", "insufficient_quota"].includes(c))) {
+        "model_not_found", "usage_limit_exceeded", "insufficient_quota"].includes(c))
+        || codex && nodes.some(n => ["usageLimitExceeded", "unauthorized", "badRequest"].includes(String(n.codexErrorInfo)))) {
         return { category: "access", code: "provider.access-denied", retryable: false };
     }
     const statuses = nodes.flatMap(n => [n.httpStatusCode, n.statusCode, n.status]).filter(v => typeof v === "number");
@@ -240,6 +241,9 @@ function structuredTransientError(input) {
     if (statuses.includes(429) || codes.includes("rate_limit_error") || nativeCode === "rate_limit_error") {
         result = recoverable("rate-limit", "provider.rate-limit");
     }
+    else if (codex && nodes.some(n => n.codexErrorInfo === "serverOverloaded")) {
+        result = recoverable("availability", "provider.model-capacity");
+    }
     else if (statuses.some(s => [500, 502, 503, 504].includes(s))
         || codes.some(c => ["server_error", "overloaded_error"].includes(c))
         || ["server_error", "overloaded_error"].includes(nativeCode)) {
@@ -277,8 +281,8 @@ function structuredTransientError(input) {
 }
 /** Add positive evidence without renaming established diagnostics or letting
  * a transient nested cause override a known fatal Session/request failure. */
-function withTransientEvidence(base, input) {
-    const evidence = structuredTransientError(input);
+function withTransientEvidence(base, input, codex = false) {
+    const evidence = structuredTransientError(input, codex);
     if (evidence === undefined)
         return base;
     const possiblyTransient = ["rate-limit", "availability", "transport", "unknown"].includes(base.category);

package/dist/runtime/providerRetry.js

@@ -3,6 +3,44 @@ export const PROVIDER_RETRY_BUDGET_MS = 600_000;
 export function providerRetryPending(binding) {
     return binding?.retry?.status === "waiting" || binding?.retry?.status === "in-flight";
 }
+/** An explicit Run retry can carry exact failed-input proof even when the
+ * error did not qualify for automation. This does not grant automatic replay:
+ * the shared admission and native latest-Turn/quiescence checks still apply. */
+export function providerRunRetry(binding, runId, at) {
+    const turn = binding.run;
+    const nativeSessionId = binding.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId;
+    if (turn?.runId !== runId || !["failed", "rejected", "deferred"].includes(turn.status)
+        || binding.authority.owner !== "controller" || turn.authorityEpoch !== binding.authority.epoch
+        || nativeSessionId === undefined)
+        return undefined;
+    const previous = binding.retry;
+    if (previous?.previousRunId === runId && previous.status !== "recovered"
+        && previous.failedAttemptId === turn.attemptId
+        && previous.authorityEpoch === binding.authority.epoch
+        && previous.nativeSessionId === nativeSessionId)
+        return previous;
+    const failure = turn.failure;
+    if (turn.status !== "failed" || turn.nativeTurnId === undefined || turn.input === undefined
+        || turn.retrySupported !== true || failure?.error.inputDisposition !== "accepted"
+        || failure.error.sessionDisposition !== "recoverable")
+        return undefined;
+    // A manual attempt can cancel automation when its error changes character.
+    // Refresh its failed-Turn proof without granting the same input a new budget.
+    const continuing = previous?.status !== "recovered" && previous?.currentAttemptId === turn.attemptId
+        && previous.authorityEpoch === binding.authority.epoch && previous.nativeSessionId === nativeSessionId;
+    return {
+        policyVersion: 1, chainId: continuing ? previous.chainId : turn.attemptId, status: "waiting",
+        input: continuing ? previous.input : turn.input, nativeSessionId, authorityEpoch: binding.authority.epoch,
+        attempts: continuing ? previous.attempts : 0,
+        transportSequence: continuing ? previous.transportSequence : 0,
+        startedAt: continuing ? previous.startedAt : iso(at), intentAt: iso(at),
+        deadline: continuing ? previous.deadline : iso(at + PROVIDER_RETRY_BUDGET_MS),
+        nextEligibleAt: iso(at), updatedAt: iso(at),
+        failedAttemptId: turn.attemptId, failureAttemptId: turn.attemptId,
+        failedNativeTurnId: turn.nativeTurnId, previousRunId: runId,
+        failureRef: failure.ref, error: failure.error, successorAutomatic: false
+    };
+}
 /** Called only in the transaction recording the exact failed/rejected input. */
 export function recordProviderFailure(binding, input) {
     let turn = binding.run;