@zq-silk/yui 2.21.0 → 2.23.0

package/dist/commands/taskRoleRuntimeStatus.js

@@ -19,6 +19,10 @@ export function taskRoleHostDiagnostic(host) {
     const delivery = snapshot.eventDelivery;
     return [
         `Provider Host=${snapshot.state}`,
+        `loaded Host=${snapshot.hostImplementation?.generation ?? "unreported"}`,
+        `loaded Endpoint=${snapshot.endpointImplementation?.generation ?? "unreported"}`,
+        snapshot.hostUpgrade === undefined ? undefined
+            : `Host upgrade=${snapshot.hostUpgrade.state} (${snapshot.hostUpgrade.requestId})${snapshot.hostUpgrade.detail ? `: ${snapshot.hostUpgrade.detail}` : ""}`,
         `terminal reconciliation=${snapshot.controlCapabilities?.includes("reconcile-turn") ? "supported" : "unreported/unsupported"}`,
         delivery === undefined ? "event delivery=unreported" :
             `pending facts=${delivery.pending}; native terminals awaiting acknowledgement=${delivery.pendingTerminals}`,
@@ -49,6 +53,16 @@ export function withTaskRoleHostObservation(status, host) {
     };
 }
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
+    if (roles.length === 0)
+        return [];
+    // One inspection shares the same Task history across Roles. This is local
+    // read reuse, not a cache of runtime health or provider observations.
+    const events = store.listEvents(taskId);
+    const history = {
+        events,
+        runs: operationalTaskRecords(store.listRuns(taskId), events, "run"),
+        workspaces: store.listManagedWorkspaces(taskId)
+    };
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
     const panesByRole = new Map();
@@ -57,7 +71,7 @@ export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now
         if (current === undefined || current.dead && !pane.dead)
             panesByRole.set(pane.roleName, pane);
     }
-    return roles.map((role) => inspectTaskRoleRuntimeStatus(taskId, role, store, panesByRole.get(role.name), role.name === "leader" ? taskOpenInputRequestCount : 0, now));
+    return roles.map((role) => inspectTaskRoleRuntimeStatus(taskId, role, store, panesByRole.get(role.name), role.name === "leader" ? taskOpenInputRequestCount : 0, now, history));
 }
 export function renderTaskRoleRuntimeStatus(status) {
     const activeRun = status.activeRun === null
@@ -185,12 +199,12 @@ export function taskRoleTmuxLabel(status) {
         ? "running"
         : `running (${status.tmux.currentCommand})`;
 }
-function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now) {
+function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now, history) {
     const activeRun = store.getActiveRun(taskId, role.name);
     // The last AgentRun outcome is a separate axis from the Session lifecycle. A
     // Session that stops after its AgentRun completed must not retroactively turn
     // that AgentRun into a failure; the status display keeps both visible.
-    const lastRun = operationalTaskRecords(store.listRuns(taskId), store.listEvents(taskId), "run")
+    const lastRun = history.runs
         .filter((candidate) => candidate.roleName === role.name)
         .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))[0]
         ?? null;
@@ -221,12 +235,12 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
     // distinct from the WorkItem Develop workspace.
     const actualWorkspaceRoot = effectiveLaunch?.workspace.root ?? role.workspace;
     const managedWorkspace = activeRun?.workspace
-        ?? store.listManagedWorkspaces(taskId).find(({ root }) => root === actualWorkspaceRoot)
+        ?? history.workspaces.find(({ root }) => root === actualWorkspaceRoot)
         ?? null;
     const workspace = managedWorkspace === null
         ? { managed: false, path: actualWorkspaceRoot }
         : { ...managedWorkspace, managed: true };
-    const events = store.listEvents(taskId);
+    const { events } = history;
     const sessionTokens = projectSessionTokenMetrics(events, resolveSessionTokenIdentity(nativeSession === null
         ? null
         : { taskId, roleName: role.name, ...nativeSession }));

package/dist/commands/textInput.js

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { usageError } from "../errors/cliError.js";
-export function readCommandText(inline, file, label, usage) {
+export function readCommandText(inline, file, label, usage, options = {}) {
     if ((inline === undefined) === (file === undefined)) {
         throw usageError(`Specify exactly one of ${label} or ${label}-file.`, usage);
     }
@@ -11,5 +11,5 @@ export function readCommandText(inline, file, label, usage) {
     if (normalized.length === 0 || normalized.includes("\0")) {
         throw usageError(`${label} is required.`, usage);
     }
-    return normalized;
+    return file !== undefined && options.preserveFileWhitespace ? value : normalized;
 }

package/dist/context/contextFamilies.js

@@ -0,0 +1,10 @@
+/** Public current-Context family names, shared by reads and CLI discovery.
+ * Listing a family grants no permission to read its records.
+ */
+export const CONTEXT_FAMILIES = Object.freeze([
+    "task", "task-brief", "remote-delivery", "role", "role-profile",
+    "project-policy", "project-knowledge", "input-request", "work-item",
+    "accepted-work-item", "candidate", "environment-preparation", "managed-workspace",
+    "change-set", "task-message", "run", "source-run", "review-round", "mailbox",
+    "task-decision", "task-milestone", "job", "publication", "task-event"
+]);

package/dist/context/currentSkills.js

@@ -1,4 +1,5 @@
 import { accessSync, constants, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { access, lstat, readFile, realpath } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 export const BUILTIN_YUI_SKILLS = new Set([
@@ -41,8 +42,40 @@ export function checkCurrentSkills(home, ids) {
         }
     });
 }
+/** Advisory lifecycle observation uses asynchronous filesystem I/O; it neither
+ * blocks a state transition nor substitutes for the exact per-input check. */
+export async function checkCurrentSkillsAsync(home, ids, signal) {
+    const skills = [];
+    for (const id of new Set(ids)) {
+        signal.throwIfAborted();
+        const path = currentSkillPath(home, id);
+        const versionPath = join(path, "VERSION");
+        try {
+            for (const file of [join(path, "SKILL.md"), versionPath]) {
+                if (await realpath(file) !== resolve(file) || !(await lstat(file)).isFile()) {
+                    throw new Error(`Skill files must be regular files without symlinks: ${file}.`);
+                }
+                await access(file, constants.R_OK);
+            }
+            if ((await lstat(versionPath)).size > 128)
+                throw new Error("VERSION exceeds 128 bytes.");
+            const version = (await readFile(versionPath, { encoding: "utf8", signal })).trim();
+            if (!/^[1-9][0-9]{0,8}$/u.test(version))
+                throw new Error("VERSION must contain a positive internal integer.");
+            skills.push({ id, path, version, versionPath });
+        }
+        catch (error) {
+            throw new Error(`Current Skill ${id} is missing, unreadable or invalid at ${path}. `
+                + `${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    return skills;
+}
 export const SKILL_CHECK_COMMAND = "yui session skills --json";
-export const SKILL_REUSE_RULE = "At the start of every turn, check current Skill versions and availability. "
-    + "Read full SKILL.md and necessary references on first entry, version change, recovery, "
-    + "or missing/compacted/uncertain context; reuse only unchanged full instructions available now. "
-    + "A version check is not a loading receipt or authority.";
+export const SKILL_REUSE_RULE = "The managed Host checks current Skill versions/availability before each input; "
+    + "unchanged inputs carry no notice or marker, and do not require a duplicate check. "
+    + "For unmediated clients or uncertain current input routing, check through the Manifest's command; conversation reuse alone does not establish Host mediation. Keep routine checks internal, not user-facing progress. "
+    + "Reuse unchanged full instructions in context; messages alone require no reload. "
+    + "Read affected entries/references fully on change or localized loss. On first entry, recovery or lost context, "
+    + "rebuild the current working set from applicable Skill entry points and action-relevant references, not all past procedures. "
+    + "Metadata proves neither loading, memory nor authority.";

package/dist/context/runContextPack.js

@@ -371,9 +371,11 @@ export function runContextEntry(pack) {
     const { skillPackages: _packages, pointers: _pointers, deltaRefs, liveTaskState, input, ...identity } = pack;
     const { directive, ...inputIdentity } = input;
     const { items, ...pointerPage } = runContextPointerPage(pack, { limit: 16 });
+    const directiveSummary = directive === undefined ? undefined : summaryText(directive);
     return {
         ...identity, input: { ...inputIdentity, ...(directive === undefined ? {} : {
-                directiveSummary: summaryText(directive), directiveOmitted: true
+                ...(directiveSummary === directive ? { directive, directiveOmitted: false }
+                    : { directiveSummary, directiveOmitted: true })
             }) }, pointers: items, pointerPage,
         deltaRefs: deltaRefs.slice(0, 16), deltaRefsTotal: deltaRefs.length,
         inventory: { ...pack.inventory, complete: pointerPage.complete },
@@ -386,9 +388,16 @@ export function runContextEntry(pack) {
         },
         reads: {
             inbox: "yui inbox list --view current --json",
-            refs: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view refs`,
+            ...(items.length > 0 ? {
+                expand: `yui task run context expand ${pack.identity.taskId}/${pack.identity.runId} --context-ref <store/refId> [--context-ref <store/refId> ...] --mode full --json`
+            } : {}),
+            ...(!pointerPage.complete ? {
+                refs: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view refs`
+            } : {}),
             full: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view full`,
-            input: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view input`,
+            ...(directiveSummary !== directive ? {
+                input: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view input`
+            } : {}),
             live: `yui task context ${pack.identity.taskId}`
         }
     };
@@ -413,7 +422,7 @@ function readLiveTaskState(store, taskId) {
     }));
     return Object.freeze({
         providerRetries: Object.freeze(store.listRoleSessionSets(taskId).flatMap(set => set.providerBinding?.retry === undefined
-            ? [] : [{ roleName: set.owner.roleName, retry: providerRetrySummary(set.providerBinding) }])),
+            ? [] : [{ roleName: set.owner.roleName, retry: providerRetrySummary(set.providerBinding, `yui task role session retry ${taskId} ${set.owner.roleName} show --json`) }])),
         activeRuns: Object.freeze(activeRuns),
         activeTaskReviews: Object.freeze(activeTaskReviews)
     });
@@ -422,6 +431,34 @@ export function expandRunContextRef(store, taskId, runId, refId, refStore) {
     requireIdentity(refStore, "Context ref store");
     const run = requireExactRun(store, taskId, runId);
     const snapshot = readRunContextSnapshot(store, run);
+    return expandSnapshotRef(snapshot, refId, refStore);
+}
+/** Explicit originals from one already-authorized frozen Run, not live Task
+ * discovery. Read the snapshot once and reject the entire selection on drift. */
+export function expandRunContextRefs(store, taskId, runId, selectors) {
+    if (selectors.length < 1 || selectors.length > 8)
+        throw new Error("Run Context batch requires 1..8 exact references.");
+    const seen = new Set();
+    for (const ref of selectors) {
+        requireIdentity(ref.store, "Context ref store");
+        requireIdentity(ref.refId, "Context ref id");
+        if (ref.digest !== undefined && !/^[a-f0-9]{64}$/.test(ref.digest))
+            throw new Error("An explicit Run Context digest must be exact.");
+        const key = JSON.stringify([ref.store, ref.refId]);
+        if (seen.has(key))
+            throw new Error("Duplicate Run Context batch reference.");
+        seen.add(key);
+    }
+    const snapshot = readRunContextSnapshot(store, requireExactRun(store, taskId, runId));
+    const items = selectors.map(ref => {
+        const expanded = expandSnapshotRef(snapshot, ref.refId, ref.store);
+        if (ref.digest !== undefined && expanded.ref.digest !== ref.digest)
+            throw new Error(`Run Context reference digest does not match its frozen Snapshot: ${ref.store}/${ref.refId}.`);
+        return expanded;
+    });
+    return { taskId, runId, items };
+}
+function expandSnapshotRef(snapshot, refId, refStore) {
     const authorized = snapshot.refs.filter((ref) => (ref.refId === refId && ref.store === refStore));
     const selector = `${refStore}/${refId}`;
     if (authorized.length !== 1) {
@@ -770,7 +807,9 @@ function materialize(layer, store, refId, value) {
             summary: (store === "project-knowledge"
                 ? [title, `version: ${record.version}`, ...(record.scope === undefined ? [] : [`scope: ${record.scope}`]),
                     ...(record.expiresWhen === undefined ? [] : [`expiresWhen: ${record.expiresWhen}`])].join("; ")
-                : title).slice(0, 400)
+                : store === "task-message" && typeof record.body === "string"
+                    ? summaryText(`Excerpt: ${record.body}`, 160)
+                    : title).slice(0, 400)
         }),
         value
     });

package/dist/context/runInputContract.js

@@ -79,7 +79,7 @@ export function serializeRunInputEnvelope(value) {
         .join(",");
     const snapshot = normalized.contextSnapshotRef;
     const lines = [
-        "Yui AgentRun input. Check current Skills: yui session skills --json. Follow the Session Manifest profile and current Skills.",
+        "Yui AgentRun input. Follow the Session Manifest profile and current Skills; use the Host check when supplied.",
         `${normalized.subject.taskId === undefined ? "" : `task=${normalized.subject.taskId} `}run=${normalized.runId} role=${normalized.roleName}`,
         `source=${normalized.source.type}/${normalized.source.channel} purpose=${normalized.purpose} subject=${subject || "global"} snapshot=${snapshot === undefined ? "none" : `${snapshot.id}@${snapshot.digest}`}`,
         normalized.deltaRefIds.length === 0

package/dist/context/sessionBootstrapManifest.js

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
 import { chmodSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { validateSkillPackageRef } from "./skillPackage.js";
-import { checkCurrentSkills, SKILL_CHECK_COMMAND, SKILL_REUSE_RULE } from "./currentSkills.js";
+import { checkCurrentSkills, checkCurrentSkillsAsync, SKILL_CHECK_COMMAND, SKILL_REUSE_RULE } from "./currentSkills.js";
 import { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
 export { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
 /** Portable read pointers accompany every managed input, including the first
@@ -18,13 +19,15 @@ export function withSessionContextPointer(text, environment) {
         text
     ].join("\n");
 }
-/** No remembered/sent flag can prove instructions survived context compaction. */
+/** Host metadata checks do not prove instructions survived context compaction.
+ * Unmediated/native clients retain the explicit diagnostic fallback. */
 export function sessionContextInstructions(manifestPath, digest) {
     return `Yui Session Manifest: ${manifestPath}${digest === undefined ? "" : ` (digest ${digest})`}. `
-        + `Before work on every turn run the Manifest's contextProtocol.skillCheckCommand `
-        + `(older Manifests: ${SKILL_CHECK_COMMAND}; Global loadCommand also checks current Skills). `
-        + "Use its current stable Skill paths instead of historical frozen-package paths; preserve the Manifest's Role profile. "
-        + SKILL_REUSE_RULE;
+        + "The managed Host checks Skills internally and injects guidance only when loading is needed; absence of a notice does not require another check. "
+        + `For unmediated clients or uncertain current input routing, run its contextProtocol.skillCheckCommand (fallback: ${SKILL_CHECK_COMMAND}); conversation reuse alone does not establish Host mediation. `
+        + "On first entry or lost instructions, read the current applicable Skill entry points, then only references needed for the current action. "
+        + "On change reload affected instructions. Compaction does not require restoring every previously used procedure. "
+        + "Preserve the Manifest Role profile; metadata never proves loading or memory. Keep routine role, version and empty-inbox checks internal.";
 }
 /** The caller must already pass the ordinary managed Session/CLI/Home checks.
  * Old manifests remain immutable audit records, while this read resolves their
@@ -38,6 +41,15 @@ export function checkSessionSkills(home, manifestPath) {
         historicalPackagesAreAuditOnly: true
     };
 }
+export async function checkSessionSkillsAsync(home, manifestPath, signal) {
+    const manifest = validateSessionBootstrapManifest(JSON.parse(await readFile(resolve(manifestPath), { encoding: "utf8", signal })));
+    return {
+        skills: await checkCurrentSkillsAsync(home, manifest.skills.map(skill => skill.id), signal),
+        roleProfileRef: manifest.roleProfileRef,
+        rule: SKILL_REUSE_RULE,
+        historicalPackagesAreAuditOnly: true
+    };
+}
 /** Read back one immutable Session Manifest and verify its content digest. */
 export function readSessionBootstrapManifest(path) {
     const source = resolve(path);
@@ -48,6 +60,9 @@ export function readSessionBootstrapManifest(path) {
     catch (error) {
         throw new Error(`Session Manifest is unreadable: ${source}.`, { cause: error });
     }
+    return validateSessionBootstrapManifest(parsed);
+}
+function validateSessionBootstrapManifest(parsed) {
     if (parsed === null || typeof parsed !== "object") {
         throw new Error("Session Manifest is invalid.");
     }

package/dist/context/sessionSkillNotice.js

@@ -0,0 +1,74 @@
+import { checkSessionSkills, checkSessionSkillsAsync } from "./sessionBootstrapManifest.js";
+/** Early advisory checks do not commit notices or assert model memory. The
+ * next input still validates its exact metadata and emits only its own delta.
+ * Invalid metadata may reject that input, never a Session state transition. */
+export function createSessionSkillLifecycleCheck(home, environment) {
+    return {
+        id: "session-skills",
+        run: async (transition, signal) => {
+            if (!["connected", "interactive-connected", "settled"].includes(transition.event.type))
+                return;
+            const manifest = environment().YUI_SESSION_MANIFEST;
+            if (!manifest || signal.aborted)
+                return;
+            try {
+                await checkSessionSkillsAsync(home, manifest, signal);
+            }
+            catch (error) {
+                if (!signal.aborted)
+                    throw error;
+            }
+        }
+    };
+}
+/** Host-local last accepted metadata, never a model loading/memory receipt.
+ * A new Host/attachment starts cold. No durable schema or input replay is added. */
+export function createSessionSkillNotice(home) {
+    let previous;
+    let generation = 0;
+    const invalidate = () => { previous = undefined; generation += 1; };
+    return {
+        invalidate,
+        prepare(text, environment, sessionKey, options = {}) {
+            const manifest = environment.YUI_SESSION_MANIFEST;
+            if (manifest === undefined)
+                return { text, inputText: text, commit() { } };
+            let current;
+            try {
+                current = checkSessionSkills(home, manifest);
+            }
+            catch (error) {
+                invalidate();
+                throw error; // Do not submit business input with an invalid current installation.
+            }
+            const key = JSON.stringify([sessionKey, manifest, current.roleProfileRef, options.contextEpoch]);
+            const skills = new Map(current.skills.map(skill => [skill.id, JSON.stringify({
+                    id: skill.id, path: skill.path, version: skill.version
+                })]));
+            const cold = previous?.key !== key;
+            const changed = [...skills].filter(([id, value]) => cold || previous.skills.get(id) !== value)
+                .map(([, value]) => value);
+            const removed = !cold && [...previous.skills.keys()].some(id => !skills.has(id));
+            // Every input is checked, but only a lifecycle/metadata event needs an
+            // instruction-loading notice. Unchanged input is passed through exactly.
+            const lines = [];
+            if (cold || changed.length > 0 || removed) {
+                lines.push(`Yui Session Manifest: ${manifest}`, "Host-managed Skill checks are active; unchanged input has no notice. Detached/unmediated clients must use the Manifest check fallback.", cold
+                    ? `Read the exact Role profile at ${current.roleProfileRef.path} (not a Task projection) and all current Skill entry points below. Follow references only for the current action.`
+                    : "Skill metadata changed: load affected entries and applicable references; retain other complete instructions.", `Current Skill pointers: [${(removed ? [...skills.values()] : changed).join(",")}]`, "Read required files through EOF. Metadata is not loaded instructions. Keep routine checks internal.");
+            }
+            const preparedGeneration = generation;
+            return {
+                text: lines.length === 0 ? text : `${lines.join("\n")}\n\n${text}`,
+                inputText: text,
+                ...(lines.length === 0 ? {} : { context: lines.join("\n") }),
+                commit() {
+                    if (generation !== preparedGeneration)
+                        return;
+                    previous = { key, skills };
+                    generation += 1;
+                }
+            };
+        }
+    };
+}

package/dist/context/taskContext.js

@@ -2,6 +2,7 @@ import { runExecutionObservation } from "../agentRun/agentRun.js";
 import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { taskNotFound, usageError } from "../errors/cliError.js";
 import { expandTaskMessageResult } from "../message/message.js";
+import { taskMessagePresentation } from "../interaction/notificationPresentation.js";
 import { currentManagedRuntime, resolveManagedTaskReader } from "../runtime/managedCaller.js";
 import { hasManagedIdentity } from "../runtime/managedIdentity.js";
 import { providerRetrySummary } from "../runtime/providerRetry.js";
@@ -10,13 +11,21 @@ import { retiredTaskRecordIds, TASK_RECORD_RETIRED_EVENT } from "../task/taskRec
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { contextContentDigest } from "./contextSnapshot.js";
 import { sourceRunContextValue } from "./sourceRunContext.js";
-import { boundedDocument, fitsReadBudget, summaryText, recordPage } from "../output/boundedRead.js";
+import { boundedDocument, fitsReadBudget, summaryText, recordPage, readDigest } from "../output/boundedRead.js";
 import { taskBriefGuard, taskPhase } from "./taskPhase.js";
+import { CONTEXT_FAMILIES } from "./contextFamilies.js";
 const MAX_RECORDS = 64;
 const MAX_VALUE_BYTES = 2048;
 const MAX_PAGE_BYTES = 24 * 1024;
 const MAX_EVENTS = 100;
 const MAX_ATTENTION_REFS = 8;
+// The current read is a working index, not a replay of configuration, workspace
+// inventories and requirements on every wake. Exact bodies use the same scoped,
+// digest-checked inspect path regardless of how small a record happens to be.
+const INDEX_ONLY_FAMILIES = new Set([
+    "task", "task-brief", "remote-delivery", "role", "project-policy",
+    "managed-workspace", "task-decision", "task-message", "run", "work-item", "project-knowledge"
+]);
 /** A current read model, not a second snapshot store or a delivery receipt.
  * Every public path checks the same scope before reading, counting or paging.
  */
@@ -44,8 +53,8 @@ export function readTaskContext(store, taskId, environment = {}) {
                 if (entry.ref.store === "run")
                     runtimeEvents ??= reader.listEventsByType(taskId, ["runtime.agent-error"]);
                 const valueBytes = Buffer.byteLength(JSON.stringify(entry.value));
-                const content = valueBytes > MAX_VALUE_BYTES || ["role", "task-message", "run", "work-item", "project-knowledge"].includes(entry.ref.store)
-                    ? { ref: entry.ref, summary: summarize(entry.value), omitted: true }
+                const content = valueBytes > MAX_VALUE_BYTES || INDEX_ONLY_FAMILIES.has(entry.ref.store)
+                    ? { ref: entry.ref, summary: summarizeEntry(reader, entry), omitted: true }
                     : { ...entry, omitted: false };
                 const revisedAfterActivation = entry.ref.store === "task-message" && phaseSource?.ref !== undefined
                     && reader.queryContextRecords(taskId, {
@@ -61,9 +70,9 @@ export function readTaskContext(store, taskId, environment = {}) {
                                     ? "recorded-before-activation-request" : "recorded-after-activation-request"
                     } : {}),
                     ...(entry.ref.store === "run" ? {
-                        execution: runExecutionObservation(entry.value, reader.getTaskRoleSessionSet(taskId, entry.value.roleName)?.providerBinding, runtimeEvents)
+                        execution: currentRunExecution(reader, entry.value, runtimeEvents)
                     } : {}), ...(entry.ref.store === "role" ? {
-                        providerRetry: providerRetrySummary(reader.getTaskRoleSessionSet(taskId, entry.value.name)?.providerBinding)
+                        providerRetry: providerRetrySummary(reader.getTaskRoleSessionSet(taskId, entry.value.name)?.providerBinding, `yui task role session retry ${taskId} ${entry.value.name} show --json`)
                     } : {}) };
                 const size = Buffer.byteLength(JSON.stringify(record));
                 if (bytes + size > MAX_PAGE_BYTES)
@@ -117,6 +126,15 @@ export function readTaskContext(store, taskId, environment = {}) {
         return result;
     });
 }
+/** Keep live delivery/attempt facts, but do not replay retry diagnostics and
+ * history into the working index. Exact Run inspect below retains the full
+ * observation, under the same authorization and document-pagination contract.
+ */
+function currentRunExecution(store, run, events) {
+    const binding = store.getTaskRoleSessionSet(run.taskId, run.roleName)?.providerBinding;
+    const execution = runExecutionObservation(run, binding, events);
+    return { ...execution, retry: execution.retry === null ? null : providerRetrySummary(binding, `yui task role session retry ${run.taskId} ${run.roleName} show --json`) };
+}
 function summarizeAttention(store, taskId) {
     const group = () => ({ count: 0, refs: [], omittedRefs: 0 });
     const attention = {
@@ -208,6 +226,43 @@ export function inspectTaskContext(store, taskId, selector, environment = {}) {
     const response = readTaskContextResource(store, taskId, selector, environment);
     return boundedDocument(response, `task:${taskId}/${selector.store}/${selector.refId}`, selector.cursor);
 }
+/** CLI spelling shared by explicit dispatch selection and grouped reading. */
+export function parseExactContextRef(selector) {
+    const match = /^([^/]+)\/(.+)@([0-9a-f]{64})$/u.exec(selector);
+    if (match === null)
+        throw usageError(`Invalid required Context reference: ${selector}. Use store/refId@digest from the applicable Context pointers or list/inspect.`);
+    return { store: match[1], refId: match[2], digest: match[3] };
+}
+/** Explicit independent originals, one shared transport budget. Reuse the
+ * single-reference authorization/digest checks on every page. No implicit
+ * discovery, partial success, cached values or read/handling receipts.
+ */
+export function inspectTaskContextBatch(store, taskId, selectors, cursor, environment = {}) {
+    if (!Array.isArray(selectors) || selectors.length < 1 || selectors.length > 8)
+        throw usageError("Context batch requires 1..8 exact references.");
+    const seen = new Set();
+    const refs = selectors.map((value) => {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            throw usageError("Context batch reference requires store, refId and digest.");
+        const ref = value;
+        if (Object.keys(ref).some(key => !["store", "refId", "digest", "revision"].includes(key))
+            || typeof ref.store !== "string" || !ref.store
+            || typeof ref.refId !== "string" || !ref.refId
+            || typeof ref.digest !== "string" || !/^[a-f0-9]{64}$/.test(ref.digest)
+            || ref.revision !== undefined && typeof ref.revision !== "string")
+            throw usageError("Context batch reference requires exact store, refId and digest; revision is optional metadata.");
+        const key = JSON.stringify([ref.store, ref.refId]);
+        if (seen.has(key))
+            throw usageError("Duplicate Context batch reference.");
+        seen.add(key);
+        return { store: ref.store, refId: ref.refId, digest: ref.digest };
+    });
+    // All-or-error: a stale/forbidden source cannot be silently skipped. Each
+    // source is independently digest-pinned; this is not a new cross-record
+    // snapshot. A continuation is additionally bound to the complete response.
+    const items = refs.map(ref => readTaskContextResource(store, taskId, ref, environment));
+    return boundedDocument({ taskId, items }, `task:${taskId}/context-batch:${readDigest(refs)}`, cursor);
+}
 /** The same authorized read as inspect, before transport pagination. */
 export function readTaskContextResource(store, taskId, selector, environment = {}) {
     return store.readTransaction((reader) => {
@@ -257,7 +312,7 @@ export function listTaskContext(store, taskId, family, options = {}, environment
                         || options.workItemId !== undefined && value.workItemId !== options.workItemId
                         || options.after !== undefined && Date.parse(String(value.createdAt)) <= Date.parse(options.after))
                         continue;
-                    records.push({ ref: entry.ref, summary: summarize(value),
+                    records.push({ ref: entry.ref, summary: summarizeEntry(reader, entry),
                         ...(retired === undefined ? {} : { history: retired.has(entry.ref.refId) ? "retired" : "active" }),
                         ...Object.fromEntries(["status", "kind", "type", "createdAt", "roleName", "assignee", "purpose", "workItemId", "reviewRoundId"]
                             .filter(key => typeof value[key] === "string").map(key => [key, value[key]])) });
@@ -269,13 +324,6 @@ export function listTaskContext(store, taskId, family, options = {}, environment
         })}`, options);
     });
 }
-export const CONTEXT_FAMILIES = [
-    "task", "task-brief", "remote-delivery", "role", "role-profile",
-    "project-policy", "project-knowledge", "input-request", "work-item",
-    "accepted-work-item", "candidate", "environment-preparation", "managed-workspace",
-    "change-set", "task-message", "run", "source-run", "review-round", "mailbox",
-    "task-decision", "task-milestone", "job", "publication", "task-event"
-];
 export function listContextMessages(store, taskId, environment = {}) {
     return store.readTransaction((reader) => {
         authorizeContext(reader, taskId, environment);
@@ -478,11 +526,21 @@ function authorizedSources(store, { task, caller }, current = false, requestedFa
             return;
         const selection = { ...options, family };
         const { count } = store.queryContextRecords(taskId, { ...selection, limit: 0 });
+        // The bounded current index must not bury Task main behind alphabetically
+        // earlier integration/review history. Full discovery keeps its stable order.
+        const taskWorkspaceKey = managedWorkspaceKey({ type: "task", taskId });
+        const preferredWorkspace = current && !discovery && family === "managed-workspace"
+            ? store.getManagedWorkspace({ type: "task", taskId }) : null;
         sources.push({ family, count, *read(offset = 0) {
+                if (preferredWorkspace !== null)
+                    yield materialize(family, taskWorkspaceKey, preferredWorkspace);
                 for (const { id, value } of store.queryContextRecords(taskId, {
                     ...selection, offset, limit: current && !discovery ? 8 : MAX_RECORDS
-                }).records)
+                }).records) {
+                    if (preferredWorkspace !== null && id === taskWorkspaceKey)
+                        continue;
                     yield materialize(family, id, value);
+                }
             } });
     };
     add("task", taskId, task);
@@ -517,10 +575,13 @@ function authorizedSources(store, { task, caller }, current = false, requestedFa
     // artifacts remain reachable as commit-pinned pointers under their Candidate.
     if (!current)
         query("environment-preparation");
-    query("managed-workspace");
+    if (!current || discovery)
+        query("managed-workspace");
     if (caller?.taskId === taskId && caller.currentRunId !== undefined) {
         add("managed-workspace", `${taskId}/${caller.roleName}`, store.getRun(taskId, caller.currentRunId)?.workspace ?? null);
     }
+    if (current && !discovery)
+        query("managed-workspace");
     if (!current)
         query("change-set");
     query("task-message", { descending: true, unhandledMessages: current });
@@ -594,8 +655,31 @@ function freeze(value) {
 }
 function summarize(value) {
     const record = value;
-    return summaryText(["title", "name", "activeAgentId", "scope", "expiresWhen", "version", "objective", "question", "summary", "body", "status", "type"]
+    return summaryText(["title", "name", "status", "type", "currentFocus", "root", "activeAgentId", "scope", "expiresWhen", "version", "objective", "question", "summary", "body"]
         .flatMap((key) => typeof record[key] === "string" || (key === "version" && typeof record[key] === "number")
         ? [`${key}: ${record[key]}`] : [])
         .join("; "));
 }
+/** Reuse producer-authored navigation, never generate a verdict or copy a
+ * report. The authorized Message already permits its matching terminal result
+ * through exact inspect; unrelated/malformed links cannot supply summaries.
+ */
+function summarizeEntry(store, entry) {
+    if (entry.ref.store === "task-message") {
+        const message = entry.value;
+        const presentation = taskMessagePresentation(message, (taskId, runId) => {
+            const run = store.getRun(taskId, runId);
+            return run !== null && run.taskId === message.taskId
+                && message.author.type === "role" && run.roleName === message.author.roleName
+                && run.status !== "active" && run.result !== undefined ? run : null;
+        });
+        if (presentation.summary !== undefined) {
+            // Include attribution in the existing budget without clipping qualifiers.
+            const label = `Author summary (${presentation.summarySource})`;
+            const text = `${label}: ${presentation.summary}`;
+            return Buffer.byteLength(text) <= 512 ? text
+                : `${label} omitted: exceeds discovery budget; read original.`;
+        }
+    }
+    return summarize(entry.value);
+}