@zq-silk/yui 2.21.0 → 2.22.0

package/dist/commands/roleConfiguration.js

@@ -24,6 +24,8 @@ const AGENT_VALUE_OPTIONS = [
     ["--permission-strategy", "value"],
     ["--sandbox", "value"],
     ["--approval", "value"],
+    ["--exclude-tmpdir-env-var", "value"],
+    ["--exclude-slash-tmp", "value"],
     ["--permission-mode", "value"],
     ["--search", "value"]
 ];
@@ -37,6 +39,8 @@ const AGENT_CLEAR_OPTIONS = [
     ["--clear-allowed-tools", "flag"],
     ["--clear-disallowed-tools", "flag"],
     ["--clear-search", "flag"],
+    ["--clear-exclude-tmpdir-env-var", "flag"],
+    ["--clear-exclude-slash-tmp", "flag"],
     ["--clear-agent-config", "flag"]
 ];
 const AGENT_CONFIG_OPTIONS = new Set([
@@ -196,6 +200,8 @@ function permissionPatch(binding, parsed) {
         : undefined;
     const nativeOptions = [
         "--sandbox", "--approval", "--permission-mode",
+        "--exclude-tmpdir-env-var", "--exclude-slash-tmp",
+        "--clear-exclude-tmpdir-env-var", "--clear-exclude-slash-tmp",
         "--allowed-tool", "--clear-allowed-tools",
         "--disallowed-tool", "--clear-disallowed-tools"
     ].some((option) => parsed.has(option));
@@ -219,6 +225,19 @@ function permissionPatch(binding, parsed) {
             permission.sandbox = requiredText(parsed.one("--sandbox"));
         if (parsed.has("--approval"))
             permission.approval = requiredText(parsed.one("--approval"));
+        for (const [option, key] of [
+            ["exclude-tmpdir-env-var", "excludeTmpdirEnvVar"],
+            ["exclude-slash-tmp", "excludeSlashTmp"]
+        ]) {
+            if (parsed.has(`--${option}`)) {
+                const value = parsed.one(`--${option}`);
+                if (value !== "true" && value !== "false")
+                    throw usageError(`--${option} requires true or false.`);
+                permission[key] = value === "true";
+            }
+            if (parsed.has(`--clear-${option}`))
+                delete permission[key];
+        }
     }
     else if (binding.adapterId === "acp") {
         // An ACP Session's configured permission is exactly one mode id, matched
@@ -263,7 +282,9 @@ function assertAgentOptionConflicts(parsed) {
         ["--effort", "--clear-effort"],
         ["--allowed-tool", "--clear-allowed-tools"],
         ["--disallowed-tool", "--clear-disallowed-tools"],
-        ["--search", "--clear-search"]
+        ["--search", "--clear-search"],
+        ["--exclude-tmpdir-env-var", "--clear-exclude-tmpdir-env-var"],
+        ["--exclude-slash-tmp", "--clear-exclude-slash-tmp"]
     ]);
     if (parsed.has("--clear-agent-config")
         && [...parsed.seen].some((option) => option !== "--clear-agent-config" && AGENT_CONFIG_OPTIONS.has(option))) {
@@ -271,7 +292,9 @@ function assertAgentOptionConflicts(parsed) {
     }
 }
 function assertAdapterOptions(adapterId, parsed) {
-    const codex = ["--sandbox", "--approval", "--search", "--clear-search"];
+    const codex = ["--sandbox", "--approval", "--search", "--clear-search",
+        "--exclude-tmpdir-env-var", "--exclude-slash-tmp",
+        "--clear-exclude-tmpdir-env-var", "--clear-exclude-slash-tmp"];
     const tools = [
         "--allowed-tool", "--clear-allowed-tools",
         "--disallowed-tool", "--clear-disallowed-tools"

package/dist/commands/sessionCommands.js

@@ -27,7 +27,10 @@ export async function runSessionStopCommand(input) {
         // Leader dispatch. The explicit full pass settles pending runtime inbox and
         // lifecycle work that may exist without a current Session candidate.
         await input.runtime.drainController();
-        await input.runtime.stopController();
+        const stoppedController = await input.runtime.stopController();
+        if (stoppedController.stopped !== true && stoppedController.alreadyStopped !== true) {
+            throw new Error("Controller stop was not confirmed; no Session was stopped.");
+        }
         // Re-read the authoritative facts after the drain because a AgentRun that was
         // already inside a pass may have changed state meanwhile.
         const settled = input.runtime.snapshot();
@@ -80,7 +83,7 @@ function blockedSessions(input) {
     });
 }
 function blockedStopResult(blocked) {
-    const details = blocked.map(({ session }) => (`- ${renderSessionOwner(session)} (an active AgentRun or lifecycle operation is still pending)`));
+    const details = blocked.map(({ session }) => (`- ${renderSessionOwner(session)} (native execution, an active AgentRun or lifecycle operation is still pending)`));
     return {
         output: [
             `Cannot stop managed Sessions: ${blocked.length} Session(s) are still busy.`,

package/dist/commands/taskCommands.js

@@ -8,12 +8,12 @@ import { createRun, runExecutionObservation, runPurposeAdmitsTaskState } from ".
 import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { contextContentDigest, contextSnapshotRef } from "../context/contextSnapshot.js";
 import { sourceRunContextValue } from "../context/sourceRunContext.js";
-import { buildRunContextDelta, buildRunContextPack, runContextEntry, runContextPointerPage, contextSnapshotDeltaRefIds, expandRunContextRef, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, freezeCandidateContextSnapshot, readRunContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
+import { buildRunContextDelta, buildRunContextPack, runContextEntry, runContextPointerPage, contextSnapshotDeltaRefIds, expandRunContextRef, expandRunContextRefs, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, freezeCandidateContextSnapshot, readRunContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
 import { createRunInput } from "../context/runInputContract.js";
 import { parseTaskCatalogOptions, readTaskCatalog, renderTaskCatalog } from "../context/taskCatalog.js";
-import { assertTaskReadable, readTaskContextResource, resolveContextReader } from "../context/taskContext.js";
+import { assertTaskReadable, materialize, parseExactContextRef, readTaskContextResource, resolveContextReader } from "../context/taskContext.js";
 import { parseTaskSearchOptions, searchTaskBodies } from "../context/taskSearch.js";
-import { boundedDocument, readOptions, messageReceipt, recordPage } from "../output/boundedRead.js";
+import { boundedDocument, readOptions, messageReceipt, recordPage, summaryText } from "../output/boundedRead.js";
 import { referencedWakeRunIds } from "../context/wakeRunReferences.js";
 import { taskMessagePresentation, wakeChangeLabels, wakeMessages } from "../interaction/notificationPresentation.js";
 import { completeProcessing, releaseProcessing } from "../coordination/workMailbox.js";
@@ -23,7 +23,7 @@ import { dispatchReviewSynthesis, selectedReviewSynthesisProducers } from "../ex
 import { createExecutionGroup, createReviewExecutionAssignment, createWorkItemExecutionAssignment, createWorkItemExecutionGroup, updateExecutionLane as updateUnifiedExecutionLane, updateWorkItemExecutionLane, workItemExecutionGroupSettled } from "../execution/workItemExecution.js";
 import { projectWorkItemExecution } from "../execution/workItemExecutionProjection.js";
 import { dispatchWorkItemSynthesis, selectedWorkItemSynthesisProducers } from "../execution/workItemMainRun.js";
-import { createRoleSessionSet, roleAgentSessionResumeMode, roleSessionControlTarget, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { activeRoleAgentSession, createRoleSessionSet, roleAgentSessionResumeMode, roleSessionControlTarget, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { resolveEffectiveLaunch, effectiveLaunchWithTaskMainWorkspace } from "../executor/effectiveLaunch.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
 import { retireExactActiveRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
@@ -47,7 +47,8 @@ import { copyGlobalRoleToTaskRole, activeRoleAgentBinding, createRole, createRol
 import { roleLaunchEventPayload, saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
 import { RUNTIME_SESSION_REPLACE_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { currentManagedRuntime } from "../runtime/managedCaller.js";
-import { controlProviderRetry, providerRunRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { controlProviderRetry, providerRunRetry, providerRetryProjection, providerRetrySummary, renderProviderRetry } from "../runtime/providerRetry.js";
+import { taskRunRecovery } from "../controller/taskRunRecovery.js";
 import { currentProviderConversation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
@@ -67,7 +68,7 @@ import { addTaskProjectBinding, archiveTask, completeTask, createTask, reopenTas
 import { recordTaskActivationRequestInTransaction, taskActivationOperationRef } from "../task/taskActivationService.js";
 import { assertTaskDeliveryAuthority, assertTaskInputControlAuthority } from "../task/taskAuthority.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-import { createTaskRecordRetirement, isTaskRecordRetired, operationalTaskRecords, taskRecordRetirement } from "../task/taskRecordRetirement.js";
+import { createTaskRecordRetirement, isTaskRecordRetired, operationalTaskRecords, taskRecordRetirement, TASK_RECORD_RETIRED_EVENT } from "../task/taskRecordRetirement.js";
 import { decideSubmissionRouting, describeSubmissionFeedback, draftActivationState, draftHasEnteredPlanning, normalizeSubmissionIntent, sameSubmissionTarget, TASK_PLANNING_ENTERED_EVENT } from "../task/taskSubmission.js";
 import { assertWorkItemDependenciesCompleted as assertWorkItemDependencyGate, WorkItemDependencyGateError } from "../workItem/dependencyGate.js";
 import { attachWorkItemExecutionGroup, createWorkItem, currentWorkItemCandidate, currentWorkItemExecutionGroup, editWorkItemDefinition, prepareWorkItemDispatch, retireWorkItem, submitWorkItemCandidate, updateWorkItemExecutionGroup, updateWorkItemStatus, updateWorkItemWriteProjects, workItemExecutionGroupById } from "../workItem/workItem.js";
@@ -318,7 +319,8 @@ export function runTaskCommand(args, store, options = {}) {
         || (["brief", "decision", "milestone", "event", "work", "wake", "review", "change-set"].includes(args[0] ?? "")
             && args[1] === "show")
         || (args[0] === "role" && (["show", "status"].includes(args[1] ?? "")
-            || args[1] === "session" && args[2] === "inspect"));
+            || args[1] === "session" && (args[2] === "inspect"
+                || args[2] === "retry" && (args[5] === undefined || args[5] === "show" || args[5] === "--cursor"))));
     if (!detail)
         return executeTaskCommand(args, store, options);
     const cursorIndex = args.indexOf("--cursor");
@@ -851,7 +853,15 @@ export function submitOperatorMessage(body, taskId, store, options = {}, intent,
     const header = result.created
         ? `Created Draft task ${result.task.id}: ${result.task.title}\n`
         : "";
-    return `${header}${renderSubmissionFeedback(result.feedback)}`;
+    return {
+        kind: "output",
+        output: `${header}${renderSubmissionFeedback(result.feedback)}`,
+        data: {
+            taskId: result.task.id,
+            message: messageReceipt(result.message),
+            submission: result.feedback
+        }
+    };
 }
 function findSubmissionKeyCreate(store, submissionKey) {
     let otherTarget = false;
@@ -1702,7 +1712,7 @@ function taskMessageCommand(args, store, options) {
         const parsed = parseTail(rest, new Set(["--body-file", "--intent", "--request-id", "--to", "--work-item", "--review-round"]), usage);
         if (parsed.positionals.length < 1 || parsed.positionals.length > 2)
             throw usageError(usage);
-        const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage);
+        const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage, { preserveFileWhitespace: true });
         const intent = parseSubmissionIntentOption(parsed.options.get("--intent"), usage);
         const submissionKey = parsed.options.get("--request-id");
         if (submissionKey !== undefined && submissionKey.trim().length === 0) {
@@ -1771,7 +1781,7 @@ function queueTaskMessage(args, store, options) {
     const parsed = parseTail(args, new Set(["--body-file", "--request-id", "--to", "--work-item", "--review-round"]), usage);
     if (parsed.positionals.length < 1 || parsed.positionals.length > 2)
         throw usageError(usage);
-    const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage);
+    const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage, { preserveFileWhitespace: true });
     const requestId = requiredOption(parsed.options, "--request-id");
     const recipientRole = parsed.options.get("--to");
     const workItemId = parsed.options.get("--work-item");
@@ -1808,7 +1818,7 @@ function steerTaskMessage(args, store, options) {
     const parsed = parseTail(args, new Set(["--body-file", "--request-id", "--expected-target", "--to", "--work-item", "--review-round"]), usage);
     if (parsed.positionals.length < 1 || parsed.positionals.length > 2)
         throw usageError(usage);
-    const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage);
+    const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage, { preserveFileWhitespace: true });
     const requestId = requiredOption(parsed.options, "--request-id");
     const expectedTarget = requiredOption(parsed.options, "--expected-target");
     const recipientRole = parsed.options.get("--to");
@@ -2084,7 +2094,7 @@ function updateMessage(args, store, options) {
     const parsed = parseTail(args, new Set(["--body-file"]), usage);
     if (parsed.positionals.length < 1 || parsed.positionals.length > 2)
         throw usageError(usage);
-    const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage);
+    const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage, { preserveFileWhitespace: true });
     const reference = taskRecordReference(parsed.positionals[0], "message", "Message reference", options);
     const now = clock(options);
     const result = store.transaction((tx) => {
@@ -2507,7 +2517,7 @@ function taskRoleSessionCommand(args, store, options) {
         if (extra.length > 0 || !["show", "cancel", "disable", "enable"].includes(action)) {
             throw usageError("Usage: yui task role session retry <task> <role> [show|cancel|disable|enable]");
         }
-        return store.transaction(tx => {
+        return store[action === "show" ? "readTransaction" : "transaction"](tx => {
             const task = requireTask(tx, taskId);
             const role = requireRole(tx, task.id, roleName);
             if (action !== "show")
@@ -2756,28 +2766,93 @@ function listTaskRoles(args, store, options) {
     return output(`${JSON.stringify(data)}\n`, data);
 }
 function taskRoleStatus(args, store, options) {
-    exactPositionals(args, 2, "Task role status usage: yui task role status <task> <role>.");
-    const task = requireTask(store, args[0]);
-    const role = requireRole(store, task.id, args[1]);
+    const parsed = readOptions(args, ["--view"]);
+    exactPositionals(parsed.positionals, 2, "Task role status usage: yui task role status <task> <role> [--view current|full].");
+    const view = parsed.values.get("--view") ?? "current";
+    if (!["current", "full"].includes(view))
+        throw usageError("Task role status --view must be current or full.");
+    const task = requireTask(store, parsed.positionals[0]);
+    const role = requireRole(store, task.id, parsed.positionals[1]);
     const [status] = inspectTaskRoleRuntimeStatuses(task.id, [role], store, options.runtime?.inspectTaskRolePanes?.(task.id) ?? [], options.now?.() ?? new Date());
     if (status === undefined)
         throw roleNotFound(role.name);
     const observed = withTaskRoleHostObservation(status, options.liveHostObservations?.[role.name]);
-    return output(renderTaskRoleRuntimeStatus(observed), { role: observed });
+    if (view === "full")
+        return output(renderTaskRoleRuntimeStatus(observed), { role: observed });
+    // Presentation only: retain the already-computed health, live Host and
+    // uncertain delivery facts. Run/WorkItem originals are not status fields.
+    const currentRun = (run) => run === null ? null : ({
+        id: run.id, taskId: run.taskId, roleName: run.roleName,
+        purpose: run.purpose, mode: run.mode, status: run.status,
+        workItemId: run.workItemId, reviewRoundId: run.reviewRoundId,
+        executionGroupId: run.executionGroupId, executionLaneId: run.executionLaneId,
+        sourceExecutionGroupId: run.sourceExecutionGroupId,
+        createdAt: run.createdAt, updatedAt: run.updatedAt,
+        result: run.result === undefined ? null : {
+            available: run.result.output !== undefined,
+            bytes: run.result.output === undefined ? 0 : Buffer.byteLength(run.result.output),
+            completedAt: run.result.completedAt, failureReason: run.result.failureReason,
+            diagnostic: run.result.diagnostic, provider: run.result.provider,
+            read: `yui task run show ${run.taskId}/${run.id} --view result --json`
+        },
+        read: `yui task run show ${run.taskId}/${run.id} --view full --json`
+    });
+    const session = observed.nativeSession;
+    const work = observed.activeWork;
+    return output(renderTaskRoleRuntimeStatus(observed), { role: {
+            ...observed,
+            activeRun: currentRun(observed.activeRun), lastRun: currentRun(observed.lastRun),
+            activeWork: work === null ? null : {
+                id: work.id, taskId: work.taskId, title: work.title, status: work.status,
+                revision: work.revision, updatedAt: work.updatedAt,
+                read: `yui task work show ${work.taskId}/${work.id} --json`
+            },
+            nativeSession: session === null ? null : {
+                agentId: session.agentId, adapterId: session.adapterId,
+                nativeSessionId: session.nativeSessionId, status: session.status,
+                endReason: session.endReason, policy: session.policy, effective: session.effective,
+                createdAt: session.createdAt, updatedAt: session.updatedAt,
+                read: `yui task role session inspect ${task.id} ${role.name} --json`
+            },
+            execution: observed.execution === undefined ? undefined : {
+                ...observed.execution,
+                retry: observed.execution.retry === null ? null : providerRetrySummary(store.getTaskRoleSessionSet(task.id, role.name)?.providerBinding, `yui task role session retry ${task.id} ${role.name} show --json`)
+            }
+        }, reads: { full: `yui task role status ${task.id} ${role.name} --view full --json` } });
 }
 function showTaskRole(args, store) {
-    exactPositionals(args, 2, "Task role show usage: yui task role show <task> <role>.");
-    const task = requireTask(store, args[0]);
-    const role = requireRole(store, task.id, args[1]);
+    const parsed = readOptions(args, ["--view"]);
+    exactPositionals(parsed.positionals, 2, "Task role show usage: yui task role show <task> <role> [--view current|full].");
+    const view = parsed.values.get("--view") ?? "current";
+    if (!["current", "full"].includes(view))
+        throw usageError("Task role show --view must be current or full.");
+    const task = requireTask(store, parsed.positionals[0]);
+    const role = requireRole(store, task.id, parsed.positionals[1]);
     const sessions = store.getTaskRoleSessionSet(task.id, role.name);
-    return output(renderRoleDetails(`Task Role: ${role.name}`, role, {
-        kind: "task",
-        sessions
-    }), {
+    const text = renderRoleDetails(`Task Role: ${role.name}`, role, { kind: "task", sessions });
+    if (view === "full")
+        return output(text, {
+            role,
+            sessions,
+            runs: store.listRuns(task.id).filter((run) => run.roleName === role.name)
+                .map((run) => ({ id: run.id, status: run.status, effective: run.effective }))
+        });
+    const active = activeRoleAgentSession(sessions);
+    return output(text + `\nFull history: yui task role show ${task.id} ${role.name} --view full\n`, {
         role,
-        sessions,
-        runs: store.listRuns(task.id).filter((run) => run.roleName === role.name)
-            .map((run) => ({ id: run.id, status: run.status, effective: run.effective }))
+        observation: "recorded-configuration-not-live-state",
+        session: active === null ? null : {
+            agentId: active.agentId, adapterId: active.adapterId, nativeSessionId: active.nativeSessionId,
+            status: active.status, endReason: active.endReason, policy: active.policy, effective: active.effective,
+            createdAt: active.createdAt, updatedAt: active.updatedAt
+        },
+        // A missing/ended cached Session does not prove retained execution stopped.
+        controlTarget: roleSessionControlTarget(sessions) ?? null,
+        reads: {
+            full: `yui task role show ${task.id} ${role.name} --view full`,
+            session: `yui task role session inspect ${task.id} ${role.name}`,
+            status: `yui task role status ${task.id} ${role.name}`
+        }
     });
 }
 function updateTaskRole(args, store, options) {
@@ -3734,22 +3809,19 @@ export function readDispatchContextRefs(store, taskId, selectors, environment =
         throw usageError("Dispatch requires at most 16 distinct --context-ref values.");
     }
     return selectors.flatMap(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 task context list/inspect.`);
-        }
-        const [, family, refId, digest] = match;
+        const ref = parseExactContextRef(selector);
         try {
-            const entry = readTaskContextResource(store, taskId, {
-                store: family, refId: refId, digest: digest
-            }, environment);
+            const entry = readTaskContextResource(store, taskId, ref, environment);
             const resources = [{
-                    ref: { ...entry.ref, layer: "L4", evidenceOf: "dispatch-required" },
+                    ref: { ...entry.ref, layer: "L4", evidenceOf: "dispatch-required",
+                        ...(ref.store === "task-message" ? {
+                            summary: summaryText(`Excerpt: ${entry.value.body}`, 160)
+                        } : {}) },
                     value: entry.value
                 }];
             // Selecting a result Message selects its already-authorized original
             // result too, not just a pointer the receiving Assignment cannot expand.
-            if (family === "task-message" && "result" in entry) {
+            if (ref.store === "task-message" && "result" in entry) {
                 const message = entry.value;
                 const source = store.getRun(taskId, message.resultRef.runId);
                 const value = sourceRunContextValue(source);
@@ -4765,18 +4837,34 @@ function retireRun(args, store, options) {
 function runContextCommand(args, store, options) {
     const [first, ...rest] = args;
     if (first === "expand") {
-        const usage = "Task run context expand usage: yui task run context expand <task>/<run> <ref-id> --store <store> [--mode full].";
-        const parsed = parseTail(rest, new Set(["--store", "--mode", "--cursor"]), usage);
-        exactPositionals(parsed.positionals, 2, usage);
-        const refStore = requiredOption(parsed.options, "--store");
+        const usage = "Task run context expand usage: yui task run context expand <task>/<run> (<ref-id> --store <store> | --context-ref <store/refId[@digest]> ...) [--mode full] [--cursor <cursor>].";
+        const parsed = parseMultiValueTail(rest, new Set(["--store", "--mode", "--cursor"]), new Set(["--context-ref"]), usage);
+        const batch = parsed.multiOptions.get("--context-ref");
+        if (batch !== undefined && (parsed.positionals.length !== 1 || parsed.options.has("--store")))
+            throw usageError("Do not combine --context-ref with a positional ref-id or --store.", usage);
+        exactPositionals(parsed.positionals, batch === undefined ? 2 : 1, usage);
+        const refStore = batch === undefined ? requiredOption(parsed.options, "--store") : undefined;
+        const refs = batch?.map(selector => {
+            if (/@[0-9a-f]{64}$/u.test(selector))
+                return parseExactContextRef(selector);
+            const match = /^([^/]+)\/(.+)$/u.exec(selector);
+            if (match === null)
+                throw usageError("Run Context reference requires store/refId, optionally followed by @digest.", usage);
+            return { store: match[1], refId: match[2] };
+        });
         const mode = parsed.options.get("--mode");
         if (mode !== undefined && mode !== "full") {
             throw usageError("AgentRun Context expansion mode must be full.", usage);
         }
         const { taskId, runId } = parseRunContextReference(parsed.positionals[0]);
         authorizeRunContext(store, taskId, runId, options.environment);
-        const expanded = store.transaction((tx) => expandRunContextRef(tx, taskId, runId, parsed.positionals[1], refStore));
-        const data = boundedDocument(expanded, `run:${taskId}/${runId}/${refStore}/${parsed.positionals[1]}`, parsed.options.get("--cursor"));
+        const expanded = store.readTransaction((tx) => refs === undefined
+            ? expandRunContextRef(tx, taskId, runId, parsed.positionals[1], refStore)
+            : expandRunContextRefs(tx, taskId, runId, refs));
+        const source = refs === undefined
+            ? `run:${taskId}/${runId}/${refStore}/${parsed.positionals[1]}`
+            : `run:${taskId}/${runId}/context-batch:${contextContentDigest(refs)}`;
+        const data = boundedDocument(expanded, source, parsed.options.get("--cursor"));
         return output(`${JSON.stringify(data, null, 2)}\n`, { context: data });
     }
     if (first === "delta") {
@@ -4786,7 +4874,7 @@ function runContextCommand(args, store, options) {
         }
         const { taskId, runId } = parseRunContextReference(parsed.positionals[0]);
         authorizeRunContext(store, taskId, runId, options.environment);
-        const delta = store.transaction((tx) => (buildRunContextDelta(tx, taskId, runId, parsed.values.get("--after"))));
+        const delta = store.readTransaction((tx) => (buildRunContextDelta(tx, taskId, runId, parsed.values.get("--after"))));
         const data = boundedDocument(delta, `run:${taskId}/${runId}/delta/${parsed.values.get("--after")}`, parsed.cursor);
         return output(`${JSON.stringify(data)}\n`, { contextDelta: data });
     }
@@ -4796,7 +4884,7 @@ function runContextCommand(args, store, options) {
     }
     const { taskId, runId } = parseRunContextReference(first);
     authorizeRunContext(store, taskId, runId, options.environment);
-    const pack = store.transaction((tx) => buildRunContextPack(tx, taskId, runId));
+    const pack = store.readTransaction((tx) => buildRunContextPack(tx, taskId, runId));
     const view = parsed.values.get("--view") ?? "current";
     if (!["current", "full", "refs", "input"].includes(view))
         throw usageError("Run Context view must be current, refs, input or full.");
@@ -4928,7 +5016,8 @@ function retryRun(args, store, options) {
         const sessions = tx.getTaskRoleSessionSet(previous.taskId, previous.roleName);
         const retry = options.providerRetryChainId !== undefined ? sessions?.providerBinding?.retry
             : sessions?.providerBinding == null ? undefined
-                : providerRunRetry(sessions.providerBinding, previous.id, clock(options).getTime());
+                : providerRunRetry(sessions.providerBinding, previous.id, clock(options).getTime())
+                    ?? taskRunRecovery(tx, sessions.providerBinding, previous);
         if (options.providerRetryChainId !== undefined
             && (retry?.chainId !== options.providerRetryChainId || retry.status !== "waiting"
                 || retry.previousRunId !== previous.id || clock(options).getTime() < Date.parse(retry.nextEligibleAt)
@@ -5762,17 +5851,49 @@ function retryFailedReviewRun(previous, store, options, now) {
 }
 /** AgentRun details are retained audit evidence; continuation uses durable Task state. */
 function showRun(args, store, options) {
-    const usage = "Task run show usage: yui task run show <task>/<run> [--json].";
-    const parsed = readOptions(args.filter((arg) => arg !== "--json"), ["--cursor"]);
+    const usage = "Task run show usage: yui task run show <task>/<run> [--view full|status|result] [--cursor <cursor>] [--json].";
+    const parsed = readOptions(args.filter((arg) => arg !== "--json"), ["--cursor", "--view"]);
+    const view = parsed.values.get("--view") ?? "full";
+    if (!["full", "status", "result"].includes(view))
+        throw usageError(usage);
     const positionals = parsed.positionals;
     exactPositionals(positionals, 1, usage);
-    const data = store.transaction((tx) => {
+    const data = store.readTransaction((tx) => {
         const run = requireRun(tx, positionals[0], options);
-        const retirement = tx.listEvents(run.taskId)
+        const events = tx.listEventsByType(run.taskId, [TASK_RECORD_RETIRED_EVENT, "runtime.agent-error"]);
+        const retirement = events
             .map(taskRecordRetirement)
             .find((entry) => entry?.recordKind === "run" && entry.recordId === run.id) ?? null;
-        return { run: run, retirement, execution: runExecutionObservation(run, tx.getTaskRoleSessionSet(run.taskId, run.roleName)?.providerBinding, tx.listEvents(run.taskId)) };
+        const binding = tx.getTaskRoleSessionSet(run.taskId, run.roleName)?.providerBinding;
+        const execution = runExecutionObservation(run, binding, events);
+        return { run, retirement, execution: view === "full" ? execution : {
+                ...execution, retry: execution.retry === null ? null : providerRetrySummary(binding, `yui task role session retry ${run.taskId} ${run.roleName} show --json`)
+            } };
     });
+    if (view !== "full") {
+        const { run } = data;
+        const status = {
+            run: {
+                id: run.id, taskId: run.taskId, roleName: run.roleName,
+                purpose: run.purpose, mode: run.mode, status: run.status,
+                workItemId: run.workItemId, reviewRoundId: run.reviewRoundId,
+                createdAt: run.createdAt, updatedAt: run.updatedAt
+            },
+            retirement: data.retirement,
+            execution: data.execution,
+            result: view === "result" ? run.result ?? null : {
+                available: run.result?.output !== undefined,
+                bytes: run.result?.output === undefined ? 0 : Buffer.byteLength(run.result.output),
+                completedAt: run.result?.completedAt,
+                failureReason: run.result?.failureReason,
+                diagnostic: run.result?.diagnostic,
+                read: `yui task run show ${run.taskId}/${run.id} --view result --json`
+            },
+            reads: { full: `yui task run show ${run.taskId}/${run.id} --view full --json` }
+        };
+        const bounded = boundedDocument(status, `run:${run.taskId}/${run.id}:${view}`, parsed.cursor);
+        return output(`${JSON.stringify(bounded, null, 2)}\n`, bounded);
+    }
     const bounded = boundedDocument(data, `run:${data.run.taskId}/${data.run.id}`, parsed.cursor);
     if ("contentPage" in bounded)
         return output(`${JSON.stringify(bounded, null, 2)}\n`, bounded);
@@ -6914,31 +7035,45 @@ function taskWakeDispatch(args, store, options) {
             const target = leaderMailbox(task.id);
             const mailbox = tx.getWorkMailbox(target);
             const claim = mailbox?.processing;
-            if (claim === undefined || claim === null || claim.owner !== `leader-notification:${wake.id}`) {
-                throw usageError("This wake has no unresolved notification claim.");
+            const ownsClaim = claim?.owner === `leader-notification:${wake.id}`;
+            const events = tx.listEvents(task.id);
+            const resolved = events.find(event => event.type === "notification.resolved"
+                && event.payload.wakeId === wake.id && event.payload.outcome === "released-without-replay");
+            if (resolved !== undefined) {
+                return { taskId: task.id, wakeId: wake.id, outcome: "released-without-replay" };
+            }
+            if (wake.status === "consumed")
+                throw usageError("An accepted notification uses ordinary inbox handling.");
+            // Operational mailboxes may disappear on execution stop. Resolve only
+            // the original durable delivery attempt, using the same exact wake
+            // identity as wake inspection; missing evidence is not an unknown result.
+            const previous = events.filter(event => event.type === "notification.delivery"
+                && (ownsClaim ? event.payload.attemptId === claim.batchId
+                    : event.payload.attemptId?.startsWith(`notification:${task.id}/${wake.id}/`))).at(-1);
+            if (previous?.payload.outcome !== "unknown" && previous?.payload.outcome !== "rejected") {
+                throw usageError("Only an unknown or rejected notification can be resolved without replay.");
             }
-            const previous = tx.listEvents(task.id).filter((event) => event.type === "notification.delivery" && event.payload.attemptId === claim.batchId).at(-1);
             const sessions = tx.getTaskRoleSessionSet(task.id, "leader");
             const provider = sessions?.providerBinding;
-            if (previous?.payload.outcome !== "unknown")
-                throw usageError("Only an unknown notification can be resolved.");
             if (tx.getActiveRun(task.id, "leader") !== null
                 || provider?.authority.owner === "human" || provider?.authority.owner === "unknown"
                 || (provider?.run !== undefined && provider.run !== null
                     && ["submitting", "accepted", "delivery-unknown"].includes(provider.run.status))) {
                 throw usageError("Shared native execution is not proven quiescent; resolve that exact runtime boundary first.");
             }
-            // Preserve the original unknown outcome and the unconsumed fixed wake.
+            // Rejection is not quiescence. Preserve every original delivery outcome
+            // (including unknown followed by rejected) and the unconsumed fixed wake.
             // This releases only the scheduling claim; it never replays, claims
             // acceptance, or asserts that Message requirements were implemented.
             recordTaskEvent(tx, task.id, "notification.resolved", {
-                wakeId: wake.id, attemptId: claim.batchId, reason, outcome: "released-without-replay"
+                wakeId: wake.id, attemptId: previous.payload.attemptId, reason, outcome: "released-without-replay"
             }, now);
-            tx.saveWorkMailbox(completeProcessing(mailbox, claim.batchId));
+            if (ownsClaim)
+                tx.saveWorkMailbox(completeProcessing(mailbox, claim.batchId));
             return { taskId: task.id, wakeId: wake.id, outcome: "released-without-replay" };
         });
         notifyMailbox(options.runtime, leaderMailbox(result.taskId));
-        return output(`Released ${result.wakeId} without replay; original acceptance remains unknown.\n`, result);
+        return output(`Released ${result.wakeId} without replay; original delivery evidence is unchanged.\n`, result);
     }
     if (subcommand === "list" || subcommand === "show") {
         return taskWakeInspectionCommand(args, store);
@@ -6953,7 +7088,7 @@ function taskWakeDispatch(args, store, options) {
  * wake — the on-demand read the Agent uses instead of a context dump in the
  * wake envelope.
  */
-function taskWakeInspectionCommand(args, store) {
+export function taskWakeInspectionCommand(args, store) {
     const [command, ...rest] = args;
     if (command === "list") {
         const usage = "Task wake list usage: yui task wake list <task> [--limit <n>] [--cursor <cursor>].";
@@ -7016,6 +7151,26 @@ function taskWakeInspectionCommand(args, store) {
             if (message.resultRef?.type === "agent-run-result")
                 referencedRunIds.add(message.resultRef.runId);
         const runs = operationalTaskRecords(allRuns, allEvents, "run").filter((run) => (history && inWindow(run.createdAt) || referencedRunIds.has(run.id)));
+        // The focused read is an action working set, not merely another directory.
+        // Include small ordinary originals whole, with their current exact identity.
+        // Reports still require their terminal-result read; a completion notice is
+        // not the original report. Do not amplify diagnostic history into bodies.
+        let originalBytesRemaining = 8 * 1024;
+        const messageDetails = messages.map(message => {
+            const original = materialize("task-message", message.id, message);
+            const bytes = Buffer.byteLength(JSON.stringify(message));
+            const include = !history && message.resultRef === undefined
+                && bytes <= 4 * 1024 && bytes <= originalBytesRemaining;
+            if (include)
+                originalBytesRemaining -= bytes;
+            return { id: message.id, kind: message.kind, author: message.author,
+                ...taskMessagePresentation(message, (taskId, runId) => store.getRun(taskId, runId)),
+                resultRef: message.resultRef,
+                ...(include ? { refreshRead: `task message show ${task.id}/${message.id}` }
+                    : { read: `task message show ${task.id}/${message.id}` }),
+                ref: original.ref, contentOmitted: !include,
+                ...(include ? { value: original.value } : {}) };
+        });
         const lines = [
             `Wake: ${wake.id}`,
             `Task: ${task.id}`,
@@ -7063,9 +7218,7 @@ function taskWakeInspectionCommand(args, store) {
             historyRead: `task wake show ${task.id} ${wake.id} --history`,
             events: events.map(event => ({ id: event.id, type: event.type, createdAt: event.createdAt,
                 read: `task event show ${task.id} ${event.id}` })),
-            messages: messages.map(message => ({ id: message.id, kind: message.kind, author: message.author,
-                ...taskMessagePresentation(message, (taskId, runId) => store.getRun(taskId, runId)),
-                resultRef: message.resultRef, read: `task message show ${task.id}/${message.id}` })),
+            messages: messageDetails,
             runs: runs.map(run => ({ id: run.id, status: run.status, purpose: run.purpose, roleName: run.roleName,
                 read: `task run show ${task.id}/${run.id}` }))
         });

package/dist/commands/taskContextCommand.js

@@ -1,5 +1,5 @@
 import { usageError } from "../errors/cliError.js";
-import { inspectTaskContext, listTaskContext, readTaskContext, readTaskContextDelta } from "../context/taskContext.js";
+import { inspectTaskContext, inspectTaskContextBatch, listTaskContext, parseExactContextRef, readTaskContext, readTaskContextDelta } from "../context/taskContext.js";
 import { readOptions } from "../output/boundedRead.js";
 export function taskRecordList(args, store, family, environment = {}) {
     const parsed = readOptions(args, ["--cursor", "--limit", "--status", "--after", "--work-item"]);
@@ -17,19 +17,23 @@ export function runTaskContextCommand(args, store, environment = {}) {
     const action = explicit ? args[0] : "read";
     const taskId = args[explicit ? 1 : 0];
     if (!taskId || taskId.startsWith("--"))
-        throw usageError("Task context usage: yui task context [read|list|delta|inspect] <task> [--after <cursor|timestamp>] [--continuation <cursor>] [--cursor <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest>] [--view <current|all>] [--status <status>] [--work-item <id>].");
+        throw usageError("Task context usage: yui task context [read|list|delta|inspect] <task> [--after <cursor|timestamp>] [--continuation <cursor>] [--cursor <cursor>] [--limit <1..100>] [--store <store> --ref <id> --digest <digest> | --refs <JSON-array> | --context-ref <store/refId@digest> ...] [--view <current|all>] [--status <status>] [--work-item <id>].");
     const options = new Map();
+    const contextRefs = [];
     const rest = args.slice(explicit ? 2 : 1);
     const allowed = action === "read" ? [] : action === "delta"
         ? ["--after", "--continuation", "--limit"] : action === "list"
-        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item", "--view"] : ["--store", "--ref", "--digest", "--cursor"];
+        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item", "--view"] : ["--store", "--ref", "--digest", "--refs", "--context-ref", "--cursor"];
     for (let i = 0; i < rest.length; i += 2) {
         const flag = rest[i];
         const value = rest[i + 1];
         if (!allowed.includes(flag) || options.has(flag) || value === undefined || value.startsWith("--")) {
             throw usageError(`Invalid Context option: ${flag}.`);
         }
-        options.set(flag, value);
+        if (flag === "--context-ref")
+            contextRefs.push(value);
+        else
+            options.set(flag, value);
     }
     let data;
     if (action === "read")
@@ -54,6 +58,24 @@ export function runTaskContextCommand(args, store, environment = {}) {
             ...(options.has("--limit") ? { limit: Number(options.get("--limit")) } : {})
         }, environment);
     }
+    else if (options.has("--refs") || contextRefs.length > 0) {
+        if (["--store", "--ref", "--digest"].some(flag => options.has(flag)))
+            throw usageError("Do not combine batch references with --store, --ref or --digest.");
+        if (options.has("--refs") && contextRefs.length > 0)
+            throw usageError("Do not combine --refs with --context-ref.");
+        let refs;
+        if (contextRefs.length > 0)
+            refs = contextRefs.map(parseExactContextRef);
+        else {
+            try {
+                refs = JSON.parse(options.get("--refs"));
+            }
+            catch {
+                throw usageError("--refs must be a JSON array of exact Context references.");
+            }
+        }
+        data = inspectTaskContextBatch(store, taskId, refs, options.get("--cursor"), environment);
+    }
     else {
         const family = options.get("--store");
         const refId = options.get("--ref");