@zq-silk/yui 2.4.0 → 2.5.0

package/dist/cli/commandCatalog.js

@@ -1096,7 +1096,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";
@@ -51,7 +52,7 @@ import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.j
 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";
@@ -6932,12 +6933,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 +6958,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 +6980,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 +6996,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/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/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/scheduler/leaderWakeupProcessor.js

@@ -86,15 +86,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             attempted = true;
             const outcome = await delivery.sendOnce({
                 delivery: ready, receiptId: notification.attemptId, notificationId: notification.wakeId,
-                text: [
-                    `Yui Task notification: task=${task.id} wake=${notification.wakeId}.`,
-                    `Read current context: yui task context ${task.id} --json.`,
-                    `Read the fixed notification window: yui task wake show ${task.id} ${notification.wakeId}.`,
-                    "Read referenced result Messages in full before deciding their disposition.",
-                    "Follow the Leader Skill to advance outstanding Task work from these durable facts, or record the exact decision/authority needed.",
-                    "This is a notification, not an execution assignment. No separate final report is required.",
-                    "Reading context is not an acknowledgement that its requirements have been implemented."
-                ].join("\n")
+                text: notification.presentation
             });
             const accepted = outcome.status === "sent" || outcome.status === "already-sent";
             const disposition = accepted ? "accepted"

package/dist/web/webConversation.js

@@ -170,7 +170,7 @@ export function createWebConversationSurface(store, surface, plan, readPage = re
                 return [item];
             let messages = [];
             if (owner.scope === "task") {
-                const ref = /^Yui Task notification: task=([A-Za-z0-9_-]+) wake=([A-Za-z0-9_-]+)\.\nRead current context: /m.exec(item.text);
+                const ref = /^Yui Task notification: task=([A-Za-z0-9_-]+) wake=([A-Za-z0-9_-]+)\.$/m.exec(item.text);
                 if (ref?.[1] === owner.taskId) {
                     const wake = store.listTaskWakes(owner.taskId).find(w => w.id === ref[2] && w.status === "consumed");
                     const ids = new Set(wake?.refs?.filter(r => r.type === "message").map(r => r.id));
@@ -178,7 +178,7 @@ export function createWebConversationSurface(store, surface, plan, readPage = re
                 }
             }
             else {
-                const ref = /^Yui Global Message: role=([A-Za-z0-9_-]+) message=([A-Za-z0-9_-]+)\.\nRead your Session Context/m.exec(item.text);
+                const ref = /^Yui Global Message: role=([A-Za-z0-9_-]+) message=([A-Za-z0-9_-]+)\.$/m.exec(item.text);
                 if (ref?.[1] === owner.roleName)
                     messages = store.listGlobalRoleMessages(owner.roleName)
                         .filter(m => m.id === ref[2] && m.delivery?.via === "provider" && m.deliveryTarget?.nativeSessionId === id);

package/docs/cli-information-contract.md

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

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

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

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

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

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

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

package/docs/release-workflow.md

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/skills/yui-leader/SKILL.md

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

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

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

package/skills/yui-operator/SKILL.md

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

package/skills/yui-reviewer/SKILL.md

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

package/skills/yui-runtime/SKILL.md

@@ -16,6 +16,24 @@ workspace layout, native transcript, or an earlier AgentRun.
 
 ## Enter through the current context
 
+Stable instructions and dynamic facts have different lifetimes. On first entry,
+new Session, Manifest/version change, or missing instructions (including after
+compaction/recovery), read the exact Session Manifest and fully load its profile
+and named Skills: `yui-runtime` plus the referenced `yui-leader`, `yui-worker`,
+`yui-reviewer`, `yui-operator`, or custom Role Skills. Resolve IDs to paths and
+versions through that Manifest, never another installed namesake. If those exact
+same-version instructions are already fully available in current context, apply
+them without mechanically rereading. Same Session, prior delivery, and prior
+reads do not prove availability. The short Manifest pointer remains a recovery
+entry, not a cache or authority receipt.
+
+Refresh dynamic Task/Session facts before the relevant decision regardless of
+instruction reuse. Leader notifications use the Manifest's `currentCommand`;
+explicit AgentRuns use `loadCommand`/`expandCommand` with the actual newest
+dispatched Run identity. Never execute `<run-id>` placeholders or substitute a
+notification's wake ID for a Run. CLI/Controller identity, scope, Snapshot and
+permission checks remain authoritative on every operation.
+
 There are two normal Task entry points. A user may continue directly with the
 current, unrevoked Leader Session: read current context using
 `yui task context <task-id> --json`. Do not request a self-wake, reopen a Task,
@@ -167,8 +185,13 @@ and digest. A source-change error requires a fresh read, not mixing old and
 new chunks. Never use a read cursor to repeat a mutation.
 
 Read all pages of a relevant original requirement, result, or authorization
-before acting on it. For a wake, read its complete fixed window and the
-referenced original Messages; the wake itself contains pointers, not reports.
+before acting on it. For a wake, read its complete focused input/result view and
+relevant original Messages. `task wake show <task> <wake>` preserves the fixed
+window and explicit older refs, deduplicates inputs, and provides exact original
+reads. Use `--history` when window history or diagnostics is needed; unrelated
+events and merely started Runs are not required for ordinary result disposition.
+Follow any `contentPage` continuation for either view. The wake contains pointers
+and attributed summaries, not complete reports.
 For unrelated discovery, stop once the necessary evidence is found. Task
 event deltas retain their fixed upper bound and are history, not replacement
 current state. No read acknowledges implementation or consumes a queue.
@@ -244,6 +267,24 @@ create an InputRequest merely to solicit permission for it.
 
 ## Return evidence and recover within scope
 
+When authoring a durable Message or managed final report, put a concise
+`Yui-Summary: <one line>` first when useful for notification readers. Keep the
+summary itself at most 512 UTF-8 bytes, and preserve material failure,
+unverified-result, pending-decision and authority qualifications. Do this as
+part of producing the original, not a separate model call. The optional line
+remains part of the original text; missing or oversized summaries use factual
+templates without blocking delivery. Core may reuse that line as explicitly
+attributed presentation, never parse it into acceptance, review verdict or
+Task state. A returned execution result is not completed requirements; a
+returned review is not approval. Summaries do not replace reading full
+requirements, results or authorizations before decisions.
+
+Ordinary Task/Global notifications grant no new Assignment or authority and
+require no separate execution report. Read the referenced originals and advance
+outstanding work within existing authority under the relevant Role Skill.
+Reading context or accepting notification delivery does not implement input.
+Unknown delivery must not be replayed; use the recovery contract below.
+
 Provider acceptance, Context load, AgentRun completion, and Task completion are
 separate facts. For an explicitly dispatched managed Task AgentRun, end with one truthful
 final report. Yui automatically correlates that native terminal with the exact

package/skills/yui-worker/SKILL.md

@@ -104,8 +104,9 @@ once and stop without wrappers, permission broadening, or another AgentRun targe
 
 Use clear prose. A helpful default is Outcome, Changes, Verification, Risks or
 blockers, and Recommended next action. This is a communication convention, not
-a protocol: Yui preserves the original text and does not parse, normalize, or
-reject it for missing headings or invalid JSON.
+a disposition protocol: Yui preserves the original text and does not reject
+missing headings or invalid JSON. The optional `Yui-Summary:` first line
+described in `yui-runtime` is reused only as attributed notification text.
 
 Leave managed workspaces intact after handoff. Their owner lifecycle and
 cleanup belong to the Leader and Yui Core.