@zq-silk/yui 2.21.0 → 2.22.0

package/dist/commands/taskFactCommands.js

@@ -4,6 +4,7 @@ import { taskRecordList } from "./taskContextCommand.js";
 import { materialize } from "../context/taskContext.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
+import { readDigest } from "../output/boundedRead.js";
 import { dataError, usageError } from "../errors/cliError.js";
 import { createMilestone } from "../milestone/milestone.js";
 import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, requiredOption, requiredText, requireTask, taskActor, taskMailbox, taskRef } from "./taskCommandSupport.js";
@@ -107,6 +108,18 @@ export function taskBriefCommand(args, store, options) {
         ? "Task brief command is required."
         : `Unknown command: task brief ${command}`);
 }
+function decisionReceipt(decision) {
+    // A short saved value lets the caller inspect the actual effect without
+    // another read. Bound the complete JSON record, including title/reason.
+    const contentOmitted = Buffer.byteLength(JSON.stringify(decision)) > 2048;
+    const value = contentOmitted ? {
+        id: decision.id, taskId: decision.taskId, status: decision.status,
+        createdAt: decision.createdAt, updatedAt: decision.updatedAt
+    } : decision;
+    return { taskId: decision.taskId, effect: "saved", contentOmitted, decision: { ...value,
+            digest: readDigest(decision), rationaleBytes: Buffer.byteLength(decision.rationale)
+        }, ...(contentOmitted ? { read: `yui task decision show ${decision.taskId} ${decision.id} --json` } : {}) };
+}
 export function taskDecisionCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "record") {
@@ -136,7 +149,7 @@ export function taskDecisionCommand(args, store, options) {
         notifyMailbox(options.runtime, taskMailbox(result.task.id));
         if (result.task.status === "active")
             notifyMailbox(options.runtime, leaderMailbox(result.task.id));
-        return output(`Recorded decision ${result.decision.id} for ${result.task.id}\n`);
+        return output(`Recorded decision ${result.decision.id} for ${result.task.id}\n`, decisionReceipt(result.decision));
     }
     if (command === "list") {
         return taskRecordList(rest, store, "task-decision", options.environment);
@@ -190,7 +203,7 @@ export function taskDecisionCommand(args, store, options) {
         notifyMailbox(options.runtime, taskMailbox(result.task.id));
         if (result.task.status === "active")
             notifyMailbox(options.runtime, leaderMailbox(result.task.id));
-        return output(`Superseded decision ${result.decision.id} for ${result.task.id}\n`);
+        return output(`Superseded decision ${result.decision.id} for ${result.task.id}\n`, decisionReceipt(result.decision));
     }
     throw usageError(command === undefined
         ? "Task decision command is required."

package/dist/commands/taskIntegrationCommands.js

@@ -167,10 +167,10 @@ async function continueIntegration(args, store, home, now, options) {
             || integration.resolution?.action !== "manual-resolution")) {
         throw usageError(`Integration is not ready to continue: ${integration.id}/${integration.status}.`);
     }
-    return runIntegration(store, home, integration, now, options);
+    return runIntegration(store, home, integration, now, options, "continue");
 }
-async function runIntegration(store, home, integration, now, options) {
-    const result = await new GitIntegrationService(home, store, undefined, now, options.environment, undefined, options.jobPort).integrate(integration.taskId, integration.id);
+async function runIntegration(store, home, integration, now, options, intent) {
+    const result = await new GitIntegrationService(home, store, undefined, now, options.environment, undefined, options.jobPort).integrate(integration.taskId, integration.id, undefined, intent);
     const output = result.status === "committed"
         ? `Integrated ${integrationSourceLabel(result.attempt)} into ${result.attempt.targetRef} with CAS (${result.attempt.id})\n`
         : result.status === "conflicted"

package/dist/commands/taskRoleRuntimeStatus.js

@@ -49,6 +49,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 +67,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 +195,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 +231,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

@@ -42,7 +42,9 @@ export function checkCurrentSkills(home, ids) {
     });
 }
 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; "
+    + "do not repeat an explicit Host check. Without that notice, check through the Manifest's command. "
+    + "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

@@ -18,13 +18,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;
+        + "For inputs carrying the Yui Host Skill-check notice, engineering has checked current versions; do not repeat that check. "
+        + `Otherwise run its contextProtocol.skillCheckCommand (fallback: ${SKILL_CHECK_COMMAND}). `
+        + "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.";
 }
 /** The caller must already pass the ordinary managed Session/CLI/Home checks.
  * Old manifests remain immutable audit records, while this read resolves their

package/dist/context/sessionSkillNotice.js

@@ -0,0 +1,53 @@
+import { checkSessionSkills } from "./sessionBootstrapManifest.js";
+/** 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, commit() { } };
+            if (options.recovery)
+                invalidate();
+            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]);
+            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. This marker distinguishes Host-mediated
+            // input from an unmediated client without restating the operating manual.
+            const lines = ["Yui Host checked current Skills; no Agent check needed."];
+            if (cold || changed.length > 0 || removed) {
+                lines.push(`Yui Session Manifest: ${manifest}`, cold
+                    ? `First input or recovered attachment: read the exact Role profile at ${current.roleProfileRef.path} and the full current listed Skill entry points. Follow references only for the action you are taking, not to restore every previously used procedure. A Task role-profile projection is not this profile.`
+                    : "Skill metadata changed: load affected entries and applicable references; retain other complete instructions.", `Current Skill pointers: [${(removed ? [...skills.values()] : changed).join(",")}]`, "Metadata is not a loading receipt. Read each required file through EOF; if output is truncated, finish the missing ranges. Recover missing instructions for the current task, not the whole manual.");
+            }
+            const preparedGeneration = generation;
+            return {
+                text: `${lines.join("\n")}\n\n${text}`,
+                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);
+}

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,14 +12,14 @@ 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 { 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, isTaskReadCommand } from "./cli/managedDiagnostics.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());
@@ -2750,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];
     }