@zq-silk/yui 2.20.0 → 2.22.0

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";
@@ -9,15 +10,22 @@ import { projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryServic
 import { retiredTaskRecordIds, TASK_RECORD_RETIRED_EVENT } from "../task/taskRecordRetirement.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { contextContentDigest } from "./contextSnapshot.js";
-import { buildRunContextPack } from "./runContextPack.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.
  */
@@ -27,12 +35,12 @@ export function readTaskContext(store, taskId, environment = {}) {
         const sources = authorizedSources(reader, scope, true);
         const count = sources.reduce((total, source) => total + source.count, 0);
         const cursor = currentCursor(reader, taskId);
-        const phase = scope.allow === undefined ? taskPhase(reader, scope.task) : undefined;
+        const phase = taskPhase(reader, scope.task);
         const phaseSource = phase?.activation?.source;
         const priorMessageId = phaseSource?.priorMessageId;
         // Reserve a small, classified view before ordinary history consumes the
         // page. Counts and samples come from the exact same authorized read.
-        const attention = summarizeAttention(reader, taskId, scope.allow);
+        const attention = summarizeAttention(reader, taskId);
         let bytes = Buffer.byteLength(JSON.stringify(attention));
         const records = [];
         let runtimeEvents;
@@ -45,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, {
@@ -62,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)
@@ -75,13 +83,13 @@ export function readTaskContext(store, taskId, environment = {}) {
         const result = {
             taskId, coreCursor: encode(cursor), throughCursor: encode(cursor),
             view: "current",
-            ...(scope.allow === undefined ? {
-                phase,
-                briefWriteGuard: taskBriefGuard(reader, scope.task)
-            } : {}),
+            phase,
+            briefWriteGuard: taskBriefGuard(reader, scope.task),
             caller: scope.caller === undefined ? { kind: "unmanaged-or-global" } : {
+                taskId: scope.caller.taskId,
                 role: scope.caller.roleName,
-                executionAuthority: currentManagedRuntime(reader, environment, taskId)?.executionAuthority ?? "historical-read-only"
+                executionAuthority: scope.caller.taskId !== taskId ? "reference-only"
+                    : currentManagedRuntime(reader, environment, taskId)?.executionAuthority ?? "historical-read-only"
             },
             collections: Object.entries(sources.reduce((counts, source) => {
                 counts[source.family] = (counts[source.family] ?? 0) + source.count;
@@ -118,7 +126,16 @@ export function readTaskContext(store, taskId, environment = {}) {
         return result;
     });
 }
-function summarizeAttention(store, taskId, allow) {
+/** 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 = {
         openInputs: group(), pendingOperations: group(), unknownOperations: group(), messages: group()
@@ -131,7 +148,7 @@ function summarizeAttention(store, taskId, allow) {
     ]) {
         const page = store.queryContextRecords(taskId, {
             family, statuses, descending: category === "messages",
-            unhandledMessages: category === "messages", ids: allowedIds(allow, family), limit: MAX_ATTENTION_REFS
+            unhandledMessages: category === "messages", limit: MAX_ATTENTION_REFS
         });
         const summary = attention[category];
         summary.count = page.count;
@@ -154,7 +171,7 @@ function summarizeAttention(store, taskId, allow) {
  */
 export function readTaskContextDelta(store, taskId, input, environment = {}) {
     return store.readTransaction((reader) => {
-        const { allow } = authorizeContext(reader, taskId, environment);
+        authorizeContext(reader, taskId, environment);
         const start = decode(input.after, taskId);
         const now = currentCursor(reader, taskId);
         const continuation = input.continuation === undefined ? undefined : decodePage(input.continuation, taskId);
@@ -174,7 +191,7 @@ export function readTaskContextDelta(store, taskId, input, environment = {}) {
             throw usageError(`Context delta limit must be between 1 and ${MAX_EVENTS}.`);
         }
         const selected = reader.queryContextRecords(taskId, {
-            family: "task-event", ids: allowedIds(allow, "task-event"),
+            family: "task-event",
             afterSequence: after, throughSequence: bound.sequence, limit
         });
         const page = [];
@@ -209,12 +226,48 @@ 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) => {
         const scope = authorizeContext(reader, taskId, environment);
-        const value = isAllowed(scope.allow, selector.store, selector.refId)
-            ? inspectValue(reader, scope, selector) : null;
+        const value = inspectValue(reader, scope, selector);
         if (value === null)
             throw usageError("Context reference is unavailable in the caller's current scope.");
         const entry = materialize(selector.store, selector.refId, value);
@@ -259,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]])) });
@@ -271,18 +324,10 @@ 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) => {
-        const { allow } = authorizeContext(reader, taskId, environment);
+        authorizeContext(reader, taskId, environment);
         return reader.listMessages(taskId)
-            .filter((message) => isAllowed(allow, "task-message", message.id))
             .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
     });
 }
@@ -334,7 +379,11 @@ export async function withContextObservations(core, providers, timeoutMs = 250)
     }
     return { ...result, omittedObservations: observations.length - result.observations.length };
 }
-/** Shared current/historical Session read identity; discovery may only narrow it. */
+/** Authenticate ordinary reads of the local user's resource. Task/Assignment
+ * ownership is execution scope, not a confidentiality boundary. This does not
+ * switch Home, impersonate a target Role, or relax explicit global Job limits.
+ * Filesystem access and the authenticated Web/Controller transport remain the
+ * resource boundary of this single-user local product. */
 export function resolveContextReader(store, environment) {
     const caller = resolveManagedTaskReader(store, environment);
     if (caller === undefined && environment.YUI_SESSION_SCOPE === "global" && environment.YUI_ROLE !== "operator") {
@@ -351,57 +400,14 @@ export function resolveContextReader(store, environment) {
 }
 function authorizeContext(store, taskId, environment) {
     const caller = resolveContextReader(store, environment);
-    if (caller !== undefined && caller.taskId !== taskId)
-        throw usageError("Context is outside the caller's Task.");
     const task = store.getTask(taskId);
     if (task === null)
         throw taskNotFound(taskId);
-    let allow;
-    if (caller !== undefined && caller.roleName !== "leader") {
-        if (caller.currentRunId === undefined)
-            throw usageError("A managed Role needs a current AgentRun to read its scoped Context.");
-        const pack = buildRunContextPack(store, taskId, caller.currentRunId);
-        allow = new Set(pack.pointers.map((ref) => `${ref.store}:${ref.refId}`));
-        allow.add(`role:${caller.roleName}`);
-        allow.add(`turn:${caller.currentRunId}`);
-        // Shared current user intent and this exact Assignment's live steers augment
-        // the frozen refs. Query identities only: another Role's results, ordinary
-        // addressed messages and Leader steers remain outside this scope.
-        const run = store.getRun(taskId, caller.currentRunId);
-        const current = store.contextInputReferences(taskId, {
-            roleName: caller.roleName, workItemId: run?.workItemId, reviewRoundId: run?.reviewRoundId
-        });
-        for (const id of current.messages)
-            allow.add(`task-message:${id}`);
-        for (const id of current.events)
-            allow.add(`task-event:${id}`);
-        if (run?.workItemId !== undefined) {
-            for (const job of store.listDurableJobs(taskId)) {
-                if (job.owner.kind === "work-item" && job.owner.workItemId === run.workItemId)
-                    allow.add(`job:${job.id}`);
-            }
-        }
-    }
-    return { task, allow, caller };
-}
-/** Independent record commands share Context's exact read boundary, not a
- * second role-based approximation of Assignment visibility. */
-export function contextRecordReader(store, taskId, environment = {}) {
-    const { allow } = authorizeContext(store, taskId, environment);
-    return (family, id) => isAllowed(allow, family, id);
-}
-export function assertContextRecordReadable(store, taskId, family, id, environment = {}) {
-    if (!contextRecordReader(store, taskId, environment)(family, id)) {
-        throw usageError("Context reference is outside the caller's Assignment.");
-    }
-}
-function isAllowed(allow, family, id) {
-    return allow === undefined || allow.has(`${family}:${id}`);
+    return { task, caller };
 }
-function allowedIds(allow, family) {
-    const prefix = `${family}:`;
-    return allow === undefined ? undefined : [...allow]
-        .filter(ref => ref.startsWith(prefix)).map(ref => ref.slice(prefix.length));
+/** Independent record commands authenticate against the same resource boundary. */
+export function assertTaskReadable(store, taskId, environment = {}) {
+    authorizeContext(store, taskId, environment);
 }
 function roleProfile(role) {
     return {
@@ -413,12 +419,12 @@ function roleProfile(role) {
 /** Resolve just the requested family. Families without a singular Store read
  * use their existing list primitive, without constructing unrelated Context.
  */
-function inspectValue(store, { task, allow, caller }, { store: family, refId }) {
+function inspectValue(store, { task, caller }, { store: family, refId }) {
     const taskId = task.id;
     switch (family) {
         case "task": return refId === taskId ? task : null;
         case "task-brief": return refId === taskId ? store.getTaskBrief(taskId) : null;
-        case "remote-delivery": return refId === taskId && allow === undefined
+        case "remote-delivery": return refId === taskId
             ? projectTaskRemoteDeliveryFromStore(store, task) : null;
         case "role": return store.getRole(taskId, refId);
         case "role-profile": {
@@ -442,8 +448,10 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
         }
         case "input-request": return store.getInputRequest(taskId, refId);
         case "work-item": return store.getWorkItem(taskId, refId);
-        case "accepted-work-item":
-            return allow?.has(`accepted-work-item:${refId}`) ? store.getWorkItem(taskId, refId) : null;
+        case "accepted-work-item": {
+            const item = store.getWorkItem(taskId, refId);
+            return item?.status === "accepted" ? item : null;
+        }
         case "candidate": {
             const parts = refId.split("/");
             if (parts.length !== 2)
@@ -457,8 +465,6 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
             return store.queryContextRecords(taskId, { family, ids: [refId], limit: 1 }).records[0]?.value ?? null;
         case "run": return store.getRun(taskId, refId);
         case "source-run": {
-            if (!allow?.has(`source-turn:${refId}`))
-                return null;
             const run = store.getRun(taskId, refId);
             return run === null ? null : sourceRunContextValue(run);
         }
@@ -488,15 +494,13 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
         case "managed-workspace": {
             // Existing frozen AgentRun overlays use the Task/Role alias; owner keys
             // identify the durable workspace in current Task reads.
-            if (caller?.currentRunId !== undefined && refId === `${taskId}/${caller.roleName}`) {
+            if (caller?.taskId === taskId && caller.currentRunId !== undefined && refId === `${taskId}/${caller.roleName}`) {
                 return store.getRun(taskId, caller.currentRunId)?.workspace ?? null;
             }
             return store.listManagedWorkspaces(taskId)
                 .find((workspace) => managedWorkspaceKey(workspace.owner) === refId) ?? null;
         }
         case "mailbox": {
-            if (allow !== undefined)
-                return null;
             if (refId === "task")
                 return store.getWorkMailbox({ kind: "task", taskId });
             const roleName = refId.startsWith("role:") ? refId.slice("role:".length) : undefined;
@@ -509,29 +513,39 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
         default: return null;
     }
 }
-function authorizedSources(store, { task, allow, caller }, current = false, requestedFamily, discovery = false) {
+function authorizedSources(store, { task, caller }, current = false, requestedFamily, discovery = false) {
     const taskId = task.id;
     const sources = [];
     const add = (family, id, value) => {
-        if ((requestedFamily === undefined || requestedFamily === family) && value !== null && isAllowed(allow, family, id)) {
+        if ((requestedFamily === undefined || requestedFamily === family) && value !== null) {
             sources.push({ family, count: 1, read: () => [materialize(family, id, value)] });
         }
     };
     const query = (family, options = {}) => {
         if (requestedFamily !== undefined && requestedFamily !== family)
             return;
-        const selection = { ...options, family, ids: allowedIds(allow, family) };
+        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);
     add("task-brief", taskId, store.getTaskBrief(taskId));
-    if (allow === undefined && (requestedFamily === undefined || requestedFamily === "remote-delivery")) {
+    if (requestedFamily === undefined || requestedFamily === "remote-delivery") {
         add("remote-delivery", taskId, projectTaskRemoteDeliveryFromStore(store, task));
     }
     for (const role of store.listRoles(taskId)) {
@@ -552,9 +566,6 @@ function authorizedSources(store, { task, allow, caller }, current = false, requ
     // Current responsibilities and unanswered inputs precede historical bulk.
     query("input-request", { statuses: ["open"] });
     query("work-item", current ? { excludeStatuses: ["accepted", "retired"] } : {});
-    for (const id of allowedIds(allow, "accepted-work-item") ?? []) {
-        add("accepted-work-item", id, store.getWorkItem(taskId, id));
-    }
     if (!current)
         query("candidate");
     // File artifacts are not enumerated into the synchronous Context listing: the
@@ -564,23 +575,21 @@ function authorizedSources(store, { task, allow, caller }, current = false, requ
     // artifacts remain reachable as commit-pinned pointers under their Candidate.
     if (!current)
         query("environment-preparation");
-    query("managed-workspace");
-    if (caller?.currentRunId !== undefined) {
+    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 });
     query("run", { descending: true, ...(current ? { statuses: ["active"] } : {}) });
-    for (const id of allowedIds(allow, "source-turn") ?? []) {
-        const run = store.getRun(taskId, id);
-        if (run !== null)
-            add("source-run", id, sourceRunContextValue(run));
-    }
     query("review-round", { descending: true, ...(current ? { statuses: ["pending", "running"] } : {}) });
     if (!current)
         query("input-request", { excludeStatuses: ["open"] });
-    if (!current && allow === undefined) {
+    if (!current) {
         add("mailbox", "task", store.getWorkMailbox({ kind: "task", taskId }));
         for (const role of store.listRoles(taskId)) {
             add("mailbox", `role:${role.name}`, store.getWorkMailbox({ kind: "role", taskId, roleName: role.name }));
@@ -646,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);
+}

package/dist/context/taskSearch.js

@@ -1,8 +1,7 @@
 import { usageError } from "../errors/cliError.js";
 import { TASK_SEARCH_KINDS } from "../storage/taskSearch.js";
 import { contextContentDigest } from "./contextSnapshot.js";
-import { taskCatalogScope } from "./taskCatalog.js";
-import { readTaskContextResource } from "./taskContext.js";
+import { readTaskContextResource, resolveContextReader } from "./taskContext.js";
 const PAGE_BYTES = 32 * 1024;
 /** Human-readable field pages, using the same source authorization and version
  * checks as Context. Offsets are Unicode code points, like search snippets. */
@@ -67,11 +66,8 @@ export function searchTaskBodies(store, options, environment = {}) {
         ...(options.kind === undefined ? [] : ["--kind", options.kind]),
         ...(options.cursor === undefined ? [] : ["--cursor", options.cursor])]);
     return store.readTransaction(reader => {
-        const callerTask = taskCatalogScope(reader, environment);
-        if (callerTask !== undefined && valid.taskId !== undefined && callerTask !== valid.taskId) {
-            throw usageError("Search target is outside the caller's Task.");
-        }
-        const taskId = callerTask ?? valid.taskId;
+        resolveContextReader(reader, environment);
+        const taskId = valid.taskId;
         const scope = contextContentDigest({ taskId: taskId ?? null, query: valid.query, kind: valid.kind ?? null });
         const after = valid.cursor === undefined ? undefined : decodeCursor(valid.cursor, scope);
         const rows = reader.queryTaskSearch({ ...valid, taskId, after, limit: valid.limit + 1 });

package/dist/controlPlaneCli.js

@@ -4,6 +4,7 @@ import { randomUUID } from "node:crypto";
 import { readFileSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
+import { isatty } from "node:tty";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { agentAdapterLabel as adapterLabel } from "./agent/adapterCatalog.js";
@@ -11,17 +12,17 @@ import { recordTaskInterruptResult } from "./message/taskInterrupt.js";
 import { nativeAgentEnvironmentNames } from "./agent/launchEnvironment.js";
 import { listArtifactsCapability, readArtifactCapability, saveArtifactCapability } from "./artifacts/artifactCapability.js";
 import { renderAgentConfigurationResolutionNotice } from "./cli/agentConfigurationPicker.js";
-import { describeCommandTree, findCommandNode } from "./cli/commandCatalog.js";
+import { describeCommandHelp, describeCommandTree, findCommandNode } from "./cli/commandCatalog.js";
 import { discoveryCommandTree } from "./cli/commandDiscovery.js";
 import { callerDiscoveryAudience } from "./cli/callerDiscovery.js";
-import { contextRecordReader } from "./context/taskContext.js";
+import { assertTaskReadable } from "./context/taskContext.js";
 import { renderCompletion } from "./cli/completion.js";
 import { runCompletionWizard } from "./cli/completionWizard.js";
 import { resolveCompletionCandidates } from "./cli/dynamicCompletion.js";
-import { renderCommandHelp } from "./cli/helpRenderer.js";
+import { renderCommandHelp, renderCommandPathHint } from "./cli/helpRenderer.js";
 import { allowsInteractiveSelection, resolveInteractiveArguments } from "./cli/interactiveSelection.js";
 import { routeInvocation } from "./cli/invocationRouter.js";
-import { operatorOfflineCommand, taskDiagnosticTarget } from "./cli/managedDiagnostics.js";
+import { operatorOfflineCommand, isTaskReadCommand } from "./cli/managedDiagnostics.js";
 import { assertConfigurationAuthority, assertTaskInvocationScope } from "./cli/invocationAuthority.js";
 import { requireManagedGlobalCaller, requireManagedGlobalReader, ManagedRuntimeDriftError } from "./runtime/managedCaller.js";
 import { assertJobAgentCommand } from "./job/agentRoleScope.js";
@@ -202,7 +203,7 @@ export async function main() {
         return;
     }
     if (args.length === 0) {
-        emit(renderCommandHelp(discovery, VERSION), false, jsonOutput ? describeCommandTree(discovery) : undefined);
+        emit(renderCommandHelp(discovery, VERSION), false, jsonOutput ? describeCommandHelp(discovery) : undefined);
         return;
     }
     if (args[0] === "version" && args.length === 1) {
@@ -211,11 +212,19 @@ export async function main() {
     }
     const invocation = routeInvocation(args, discovery);
     if (invocation.kind === "help") {
-        emit(renderCommandHelp(invocation.node, VERSION), true, jsonOutput ? describeCommandTree(invocation.node) : undefined);
+        if (invocation.recursive && !jsonOutput)
+            throw usageError("Recursive help requires --json.");
+        emit(renderCommandHelp(invocation.node, VERSION), true, jsonOutput
+            ? invocation.recursive ? describeCommandTree(invocation.node) : describeCommandHelp(invocation.node)
+            : undefined);
         return;
     }
     if (invocation.kind === "path-error") {
-        throw usageError(`Unknown command: ${invocation.typedPath}`, renderCommandHelp(invocation.helpNode, VERSION));
+        throw usageError(invocation.discoveryOnly
+            ? `Command not listed in the current caller's help view: ${invocation.typedPath}. `
+                + "Help is filtered discovery, not an execution or permission check. "
+                + "Follow current instructions and exact read links; execution still validates authority."
+            : `Unknown command: ${invocation.typedPath}`, renderCommandPathHint(invocation.helpNode));
     }
     if (invocation.kind === "incomplete") {
         throw usageError(`Command required after: ${invocation.typedPath}`, renderCommandHelp(invocation.helpNode, VERSION));
@@ -660,7 +669,6 @@ export async function main() {
     const tmux = new TmuxManager(resolveTmuxBin(store.getConfig().tmuxBin), executor, {
         yuiHome: home,
         historyLimit: resolveTmuxHistoryLimit(store.getConfig().tmuxHistoryLimit),
-        terminalInput: process.stdin,
         onWarning: (message) => writeCliWarning(message)
     });
     const telemetry = openSchedulerTelemetry(home, store.getConfig());
@@ -1094,7 +1102,7 @@ export async function main() {
                 if (taskId === undefined || action === undefined || !["list", "read", "save"].includes(action)) {
                     throw usageError(usage);
                 }
-                if (process.env.YUI_SESSION_SCOPE === "task" && process.env.YUI_TASK_ID !== taskId) {
+                if (action === "save" && process.env.YUI_SESSION_SCOPE === "task" && process.env.YUI_TASK_ID !== taskId) {
                     throw usageError("Artifact is outside the managed Task scope.");
                 }
                 if (store.getTask(taskId) === null)
@@ -2065,12 +2073,7 @@ async function preflightManagedTaskControlPlane() {
         && ["agent-host", "session-notify", "runtime-hook"].includes(args[1] ?? "");
     const home = resolveYuiHome(process.env);
     assertManagedSessionManifest(home, "task");
-    const diagnosticTarget = taskDiagnosticTarget(args);
-    const diagnostic = diagnosticTarget !== undefined
-        && diagnosticTarget === process.env.YUI_TASK_ID;
-    if (diagnosticTarget !== undefined && !diagnostic) {
-        throw usageError("Diagnostics must remain within this Session's Task.");
-    }
+    const diagnostic = isTaskReadCommand(args);
     // One gate for every managed command: the current CLI, Home, and Controller
     // must agree. Internal callbacks must still be able to append their immutable
     // fact while the Controller is offline.
@@ -2087,13 +2090,6 @@ async function preflightManagedTaskControlPlane() {
         : diagnostic
             ? resolveManagedTaskReader(verifiedStore, process.env)
             : requireManagedTaskCaller(verifiedStore, process.env);
-    if (diagnostic && runtime?.roleName !== "leader"
-        && !(args[1] === "show"
-            || (args[1] === "role" && args[2] === "session" && args[3] === "inspect"
-                && args[5] === runtime?.roleName))) {
-        // Non-Leaders keep their Assignment-scoped read authorization.
-        requireManagedTaskCaller(verifiedStore, process.env);
-    }
     const request = taskFinalReviewInvocation.request;
     if (request !== undefined && diagnostic)
         requireManagedTaskCaller(verifiedStore, process.env);
@@ -2762,7 +2758,9 @@ function completionShell(value) {
     throw usageError("Completion shell must be one of bash, zsh, fish.");
 }
 async function resolveTerminalArguments(commandArgs, node, store, catalogs) {
-    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    // Probe the descriptor without constructing a stdin stream: Node makes
+    // pipes nonblocking on stream creation, breaking later --body-file - reads.
+    const interactive = isatty(0) && process.stdout.isTTY === true;
     if (!interactive || !allowsInteractiveSelection(commandArgs, jsonOutput)) {
         return [...commandArgs];
     }
@@ -3079,7 +3077,7 @@ function completionSelectionPorts(home) {
     if (process.env.YUI_SESSION_SCOPE !== "task")
         return ports;
     const taskId = process.env.YUI_TASK_ID;
-    const readable = contextRecordReader(store, taskId, process.env);
+    assertTaskReadable(store, taskId, process.env);
     const families = {
         "task.list": "task", "project.list": "project-policy", "task.role.list": "role",
         "task.work.list": "work-item", "task.message.list": "task-message", "task.input.list": "input-request",
@@ -3103,7 +3101,7 @@ function completionSelectionPorts(home) {
                     return false;
                 if (method === "project.list" && !store.getTask(taskId)?.projectBindings.some(binding => binding.projectId === id))
                     return false;
-                return readable(family, id);
+                return true;
             });
         } };
 }