@zq-silk/yui 2.6.0 → 2.8.0

package/dist/commands/inboxCommands.js

@@ -0,0 +1,372 @@
+import { requireManagedCaller } from "../runtime/sessionCaller.js";
+import { boundedDocument, readDigest, readOptions, recordPage, summaryMetadata, summaryText } from "../output/boundedRead.js";
+import { claimPending, completeProcessing } from "../coordination/workMailbox.js";
+import { createTaskWake, latestTaskWake } from "../scheduler/taskWake.js";
+import { expandTaskMessageResult } from "../message/message.js";
+import { messageAssignmentBlocker } from "../message/messageContinuation.js";
+import { globalInboxDeliveryState, inboxHandlingState, isGlobalInboxMessage, pendingGlobalInboxMessages } from "../message/inboxReceipt.js";
+import { deliveredMessageWake, isLeaderSteer, pinMessageRevisions, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { isTaskRecordRetired, retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
+const target = (address) => ({ kind: "role", taskId: address.taskId, roleName: address.roleName });
+const source = (address) => `inbox:${address.scope}:${address.taskId ?? ""}:${address.roleName}`;
+const pendingId = (pending) => `pending-${readDigest(pending)}`;
+const sameSession = (a, b) => a.scope === b.scope && a.taskId === b.taskId
+    && a.roleName === b.roleName && a.agentId === b.agentId && a.nativeSessionId === b.nativeSessionId;
+function addressOf(store, env) {
+    const caller = requireManagedCaller(store, env);
+    if (caller.scope === "global") {
+        return { scope: "global", roleName: caller.roleName, agentId: caller.agentId, nativeSessionId: caller.nativeSessionId };
+    }
+    if (caller.roleName !== "leader" && caller.currentRunId === undefined) {
+        throw new Error("An Assignment inbox requires its current active AgentRun.");
+    }
+    return { scope: "task", taskId: caller.taskId, roleName: caller.roleName,
+        agentId: caller.agentId, nativeSessionId: caller.nativeSessionId,
+        ...(caller.currentRunId === undefined ? {} : { runId: caller.currentRunId }) };
+}
+function ownsMessage(store, address, message) {
+    if (address.roleName === "leader" && message.taskId === address.taskId && isLeaderSteer(message))
+        return true;
+    if (address.runId === undefined || message.taskId !== address.taskId
+        || message.recipient?.roleName !== address.roleName)
+        return false;
+    const current = store.getRun(address.taskId, address.runId);
+    const owner = message.recipient.ownerRunId === undefined ? null
+        : store.getRun(address.taskId, message.recipient.ownerRunId);
+    return current !== null && owner !== null && current.roleName === owner.roleName
+        && owner.workItemId === message.recipient.workItemId && owner.reviewRoundId === message.recipient.reviewRoundId
+        && current.workItemId === owner.workItemId && current.reviewRoundId === owner.reviewRoundId
+        && (owner.id === current.id || messageAssignmentBlocker(store, message) === undefined);
+}
+function entries(store, address) {
+    if (address.scope === "global")
+        return store.listGlobalRoleMessages(address.roleName)
+            .filter(isGlobalInboxMessage);
+    const messages = store.listMessages(address.taskId).filter(message => ownsMessage(store, address, message));
+    return address.roleName === "leader" ? [...store.listTaskWakes(address.taskId), ...messages] : messages;
+}
+function getEntry(store, address, id) {
+    const entry = entries(store, address).find(entry => entry.id === id);
+    if (entry === undefined)
+        throw new Error("Inbox entry is not in this Agent's current authorized receiving scope.");
+    return entry;
+}
+function isWake(entry) { return "fromCursor" in entry; }
+function acceptedInput(entry) {
+    return isWake(entry) ? entry.status === "consumed" : "roleName" in entry
+        ? globalInboxDeliveryState(entry) === "accepted" : entry.control?.outcome === "accepted";
+}
+function assertSelectedTarget(address, message) {
+    const selected = message.inputControl?.expectedSessionId;
+    const globalTarget = "roleName" in message ? message.deliveryTarget : undefined;
+    if (selected !== undefined && selected !== address.nativeSessionId
+        || globalTarget !== undefined && (globalTarget.agentId !== address.agentId
+            || globalTarget.nativeSessionId !== address.nativeSessionId)) {
+        throw new Error("The original input explicitly targets another native Session; inbox handling cannot retarget it.");
+    }
+}
+function save(store, address, entry) {
+    if (isWake(entry))
+        store.saveTaskWake(address.taskId, entry);
+    else if (address.scope === "global")
+        store.updateGlobalRoleMessage(entry);
+    else
+        store.updateMessage(address.taskId, entry);
+}
+/** The same durable claim is checked at automatic delivery admission. No lease
+ * expires, and neither a receipt nor a cursor gives a caller identity. */
+function blocker(store, address, entry) {
+    if (!isWake(entry) && address.scope === "task"
+        && isTaskRecordRetired(store.listEvents(address.taskId), "message", entry.id))
+        return "message-retired";
+    if (entry.inbox?.ack !== undefined)
+        return "acknowledged";
+    if (entry.inbox !== undefined) {
+        return sameSession(entry.inbox.claim.actor, address) ? undefined : "claimed-by-previous-session";
+    }
+    if (isWake(entry)) {
+        // Native acceptance releases transport ownership, not semantic handling.
+        // The current Leader may explicitly claim the fixed delivered window.
+        if (entry.status === "consumed")
+            return undefined;
+        return "automatic-notification-owns-window";
+    }
+    if (address.scope === "task" && taskMessageInboxReceipt(store, entry) !== undefined) {
+        return "claimed-by-notification-window";
+    }
+    if (entry.control !== undefined && ["pending", "delivery-unknown"].includes(entry.control.outcome)) {
+        return `delivery-${entry.control.outcome}`;
+    }
+    const accepted = acceptedInput(entry);
+    if (entry.interruptThen !== undefined && !accepted
+        && !(address.scope === "task" && entry.continuation?.runId === address.runId
+            && address.runId !== undefined))
+        return "explicit-interrupt-handoff";
+    // Both steer paths reserve pending control before submission and arbitrate
+    // with inbox claims. No control is unsubmitted, not an unknown delivery.
+    if (address.scope === "global") {
+        const message = entry;
+        if (message.delivery !== undefined && !accepted)
+            return `already-delivered-${message.delivery.via}`;
+        // Explicitly settling delivered input is not a new submission or target
+        // selection. A current rightful successor retains the original target.
+        if (accepted)
+            return undefined;
+        if (message.deliveryTarget !== undefined && (message.deliveryTarget.nativeSessionId !== address.nativeSessionId
+            || message.deliveryTarget.agentId !== address.agentId))
+            return "selected-native-session-changed";
+        if (message.inputControl?.expectedSessionId !== undefined
+            && message.inputControl.expectedSessionId !== address.nativeSessionId)
+            return "selected-native-session-changed";
+        const turn = store.getGlobalRoleSessionSet(address.roleName)?.providerBinding?.run;
+        if (turn?.attemptId === `global-input:${address.roleName}/${entry.id}`)
+            return `native-attempt-${turn.status}`;
+    }
+    else {
+        const message = entry;
+        if (message.continuation?.runId !== undefined && message.continuation.runId !== address.runId) {
+            return "continuation-already-dispatched";
+        }
+        if (!accepted && message.inputControl?.expectedSessionId !== undefined
+            && message.inputControl.expectedSessionId !== address.nativeSessionId)
+            return "selected-native-session-changed";
+        return address.roleName === "leader" && isLeaderSteer(message) ? undefined : messageAssignmentBlocker(store, message);
+    }
+    return undefined;
+}
+function checkMutation(store, address) {
+    const owner = address.scope === "global" ? { scope: "global", roleName: address.roleName }
+        : { scope: "task", taskId: address.taskId, roleName: address.roleName };
+    if (hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget(owner)))) {
+        throw new Error("Inbox cannot change while this runtime is being released.");
+    }
+    if (address.scope === "task") {
+        const task = store.getTask(address.taskId);
+        if (!task || !["active", "draft"].includes(task.status) || task.executionGate.state !== "enabled") {
+            throw new Error("Inbox handling requires an open Task with execution enabled.");
+        }
+    }
+}
+function summary(store, address, entry) {
+    return { id: entry.id, kind: isWake(entry) ? "notification-window" : "message",
+        createdAt: entry.createdAt, summary: summaryText(isWake(entry) ? entry.reasons.join(", ") : entry.body),
+        blocked: blocker(store, address, entry) ?? null, inbox: summaryMetadata(entry.inbox ?? null),
+        handling: inboxHandlingState(entry.inbox),
+        delivery: isWake(entry) ? entry.status : summaryMetadata({
+            control: entry.control ?? null,
+            ...(address.scope === "global" ? { receipt: entry.delivery ?? null,
+                state: globalInboxDeliveryState(entry) }
+                : { continuation: entry.continuation ?? null })
+        }),
+        read: `yui inbox show ${entry.id}`, ...(isWake(entry)
+            ? { originals: `yui task wake show ${entry.taskId} ${entry.id} --json` } : {}) };
+}
+function receipt(entry) {
+    return { id: entry.id, inbox: entry.inbox,
+        ...(isWake(entry) ? { originals: `yui task wake show ${entry.taskId} ${entry.id} --json` } : {}) };
+}
+/** Own-address command: there is deliberately no --role, --task or --session.
+ * Reads do not claim. Exact claim precedes semantic handling; exact ack follows
+ * full original reads and actual handling. A batch is independent per item. */
+export function runInboxCommand(args, store, env, now = new Date()) {
+    const [action, ...tail] = args;
+    const address = addressOf(store, env);
+    if (action === "list") {
+        const parsed = readOptions(tail);
+        if (parsed.positionals.length)
+            throw new Error("Inbox list accepts only --limit and --cursor.");
+        const retired = address.scope === "task" ? retiredTaskRecordIds(store.listEvents(address.taskId), "message") : new Set();
+        const selected = address.scope === "global" ? pendingGlobalInboxMessages(store.listGlobalRoleMessages(address.roleName))
+            : entries(store, address).filter(entry => (isWake(entry) || !retired.has(entry.id))
+                && inboxHandlingState(entry.inbox) !== "handled");
+        const items = selected.map(entry => summary(store, address, entry));
+        if (address.scope === "task" && address.roleName === "leader") {
+            const mailbox = store.getWorkMailbox(target(address));
+            if (mailbox?.pending != null)
+                items.push({ id: pendingId(mailbox.pending), kind: "notification-window",
+                    summary: summaryText(mailbox.pending.reasons.join(", ")),
+                    blocked: mailbox.processing === null && !unfinishedLeaderInbox(store, address.taskId) ? null : "earlier-window-owned",
+                    read: `yui inbox show ${pendingId(mailbox.pending)}` });
+        }
+        return recordPage(items, source(address), parsed, { identity: address });
+    }
+    if (action === "show") {
+        const parsed = readOptions(tail, ["--cursor"]);
+        if (parsed.positionals.length !== 1)
+            throw new Error("Inbox show requires one exact entry.");
+        const id = parsed.positionals[0];
+        if (id.startsWith("pending-") && address.scope === "task" && address.roleName === "leader") {
+            const pending = store.getWorkMailbox(target(address))?.pending;
+            if (!pending || id !== pendingId(pending))
+                throw new Error("Pending window changed; list the inbox again.");
+            return boundedDocument({ id, ...pending,
+                note: "Claim this exact window before processing; claim returns its durable wake and original-read command." }, `${source(address)}/${id}`, parsed.cursor);
+        }
+        const entry = getEntry(store, address, id);
+        const value = !isWake(entry) && address.scope === "task"
+            ? expandTaskMessageResult(entry, (task, run) => store.getRun(task, run)) : entry;
+        return boundedDocument(value, `${source(address)}/${id}`, parsed.cursor);
+    }
+    if (action !== "claim" && action !== "ack")
+        throw new Error("Inbox commands: list, show, claim, ack.");
+    const parsed = readOptions(tail, ["--request-id", "--reason"]);
+    const ids = parsed.positionals;
+    const requestId = parsed.values.get("--request-id");
+    const reason = parsed.values.get("--reason");
+    if (!requestId || requestId.length > 128 || !/^[A-Za-z0-9_.:-]+$/.test(requestId)) {
+        throw new Error("Inbox mutation requires a stable --request-id (1..128 safe characters).");
+    }
+    if (!ids.length || ids.length > 16 || new Set(ids).size !== ids.length) {
+        throw new Error("Select 1..16 distinct exact inbox entries; no wildcard acknowledgement.");
+    }
+    if (action === "ack" && (!reason?.trim() || Buffer.byteLength(reason) > 2048)) {
+        throw new Error("Acknowledgement requires --reason describing handling or why no action remains (up to 2048 bytes).");
+    }
+    if (action === "claim" && reason !== undefined)
+        throw new Error("Claim does not record a disposition; use ack after handling.");
+    const apply = (id) => store.transaction(tx => {
+        const current = addressOf(tx, env);
+        checkMutation(tx, current);
+        let entry;
+        if (id.startsWith("pending-") && current.scope === "task" && current.roleName === "leader" && action === "claim") {
+            // Retry the exact logical operation even after its pending batch moved.
+            const existing = tx.listTaskWakes(current.taskId).find(wake => wake.inbox?.claim.requestId === requestId && sameSession(wake.inbox.claim.actor, current));
+            if (existing) {
+                if (existing.inboxPendingId !== id) {
+                    throw new Error("Inbox request id was reused for a different window.");
+                }
+                return receipt(existing);
+            }
+            const mailbox = tx.getWorkMailbox(target(current));
+            if (!mailbox?.pending || pendingId(mailbox.pending) !== id)
+                throw new Error("Pending window changed; list the inbox again.");
+            if (mailbox.processing !== null || unfinishedLeaderInbox(tx, current.taskId)) {
+                throw new Error("An earlier automatic or active inbox claim owns the notification window.");
+            }
+            // A pending Leader input with an exact transport/interrupt owner cannot be
+            // hidden inside an actively consumed window.
+            for (const ref of mailbox.pending.refs) {
+                if (ref.type !== "message")
+                    continue;
+                const message = tx.listMessages(current.taskId).find(message => message.id === ref.id);
+                if (message !== undefined && (taskMessageInboxReceipt(tx, message) !== undefined
+                    || deliveredMessageWake(tx, message) !== undefined)
+                    || message?.interruptThen !== undefined
+                    || message?.control !== undefined && message.control.outcome !== "rejected"
+                    || message?.inputControl?.expectedSessionId !== undefined
+                        && message.inputControl.expectedSessionId !== current.nativeSessionId) {
+                    throw new Error("Window contains an input with an existing or foreign delivery owner; inspect its original receipt.");
+                }
+            }
+            const latest = latestTaskWake(tx.listTaskWakes(current.taskId));
+            // Pin each mutable Draft original's existing update event, not a clock
+            // comparison. A later edit is distinct input even within the same tick.
+            const refs = pinMessageRevisions(tx, current.taskId, mailbox.pending.refs);
+            const wake = createTaskWake({ id: tx.nextTaskWakeId(current.taskId), taskId: current.taskId,
+                reasons: mailbox.pending.reasons, refs,
+                fromCursor: latest?.toCursor ?? tx.getTask(current.taskId).createdAt,
+                toCursor: new Date(Math.max(now.getTime(), Date.parse(mailbox.pending.lastQueuedAt))).toISOString(), now });
+            entry = { ...wake, inbox: { claim: { requestId, actor: current, at: now.toISOString() } },
+                inboxPendingId: id };
+            tx.saveWorkMailbox(claimPending(mailbox, { batchId: `inbox:${wake.id}`,
+                owner: `agent-inbox:${wake.id}`, startedAt: now.toISOString() }));
+        }
+        else {
+            entry = getEntry(tx, current, id);
+            if (action === "claim") {
+                if (entry.inbox !== undefined) {
+                    if (!sameSession(entry.inbox.claim.actor, current))
+                        throw new Error("Claim belongs to a previous Session; read the original and prior effects, then explicitly acknowledge only after finishing its handling.");
+                    if (entry.inbox.claim.requestId !== requestId)
+                        throw new Error("Entry already claimed; retain the original request id.");
+                    return receipt(entry);
+                }
+                const blocked = blocker(tx, current, entry);
+                if (blocked !== undefined)
+                    throw new Error(`Inbox entry cannot be claimed: ${blocked}.`);
+                if (isWake(entry) && !acceptedInput(entry)) {
+                    for (const ref of entry.refs ?? []) {
+                        if (ref.type !== "message")
+                            continue;
+                        const message = tx.listMessages(current.taskId).find(message => message.id === ref.id);
+                        if (message !== undefined)
+                            assertSelectedTarget(current, message);
+                    }
+                }
+                else if (!isWake(entry) && !acceptedInput(entry))
+                    assertSelectedTarget(current, entry);
+                for (const previous of entries(tx, current)) {
+                    if (previous.id === entry.id)
+                        break;
+                    if (isWake(previous) || previous.inbox?.ack !== undefined)
+                        continue;
+                    if (current.scope === "task"
+                        && isTaskRecordRetired(tx.listEvents(current.taskId), "message", previous.id))
+                        continue;
+                    if (current.scope === "global" && previous.notDelivered !== undefined)
+                        continue;
+                    if (previous.inbox !== undefined && sameSession(previous.inbox.claim.actor, current))
+                        continue;
+                    throw new Error(`Earlier inbox entry ${previous.id} must be handled first; input order is preserved.`);
+                }
+                entry = { ...entry, inbox: { claim: { requestId, actor: current, at: now.toISOString() } } };
+            }
+            else {
+                if (!entry.inbox)
+                    throw new Error("Claim the exact entry before handling and acknowledgement.");
+                // Ack settles already-owned handling; it never submits or retargets
+                // the original. The current rightful successor may settle a claim
+                // acquired by the exact selected Session, retaining both identities.
+                const claimant = entry.inbox.claim.actor;
+                if (isWake(entry) && !acceptedInput(entry)) {
+                    const messageIds = new Set(entry.refs?.filter(ref => ref.type === "message").map(ref => ref.id));
+                    for (const message of tx.listMessages(current.taskId)) {
+                        if (messageIds.has(message.id))
+                            assertSelectedTarget(claimant, message);
+                    }
+                }
+                else if (!isWake(entry) && !acceptedInput(entry))
+                    assertSelectedTarget(claimant, entry);
+                if (!isWake(entry) && current.scope === "task"
+                    && !(current.roleName === "leader" && isLeaderSteer(entry))) {
+                    const invalid = messageAssignmentBlocker(tx, entry);
+                    if (invalid !== undefined)
+                        throw new Error(`Assignment no longer authorizes this inbox disposition: ${invalid}.`);
+                }
+                // Current rightful successor may settle a prior Session's unfinished
+                // claim explicitly; this never replays input or discards prior evidence.
+                if (entry.inbox.ack) {
+                    if (entry.inbox.ack.requestId !== requestId || entry.inbox.ack.reason !== reason
+                        || !sameSession(entry.inbox.ack.actor, current))
+                        throw new Error("Conflicting acknowledgement; original disposition retained.");
+                    return receipt(entry);
+                }
+                const inbox = { ...entry.inbox,
+                    ack: { requestId, actor: current, at: now.toISOString(), reason: reason } };
+                if (isWake(entry)) {
+                    const mailbox = tx.getWorkMailbox(target(current));
+                    // stop/start removes operational mailboxes, not durable claim
+                    // ownership. Settle that receipt without touching a later batch.
+                    if (mailbox?.processing?.owner === `agent-inbox:${entry.id}`
+                        && mailbox.processing.batchId === `inbox:${entry.id}`) {
+                        tx.saveWorkMailbox(completeProcessing(mailbox, mailbox.processing.batchId));
+                    }
+                }
+                entry = { ...entry, inbox };
+            }
+        }
+        save(tx, current, entry);
+        return receipt(entry);
+    });
+    if (ids.length === 1)
+        return apply(ids[0]);
+    return { results: ids.map(id => {
+            try {
+                return { id, ok: true, result: apply(id) };
+            }
+            catch (error) {
+                return { id, ok: false, reason: error instanceof Error ? error.message : String(error) };
+            }
+        }) };
+}

package/dist/commands/roleSkillValidation.js

@@ -1,5 +1,6 @@
 import { usageError } from "../errors/cliError.js";
 import { loadYuiSkillContexts } from "../context/roleSessionContext.js";
+import { checkCurrentSkills } from "../context/currentSkills.js";
 const ROLE_LAUNCH_CONTEXT_OPTIONS = new Set([
     "--workspace",
     "--description",
@@ -34,6 +35,7 @@ export function validateConfiguredRoleSkills(yuiHome, skillIds) {
             throw usageError(`Configured Skill id is invalid: ${id}.`);
         }
         try {
+            checkCurrentSkills(yuiHome, [id]);
             loadYuiSkillContexts(yuiHome, [id]);
         }
         catch (error) {

package/dist/commands/taskCommands.js

@@ -1,12 +1,13 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+import { taskMessageInboxReceipt } from "../message/taskInboxOwnership.js";
 import { agentExecutionComponentLabel } from "../agent/executionComponents.js";
 import { assertLeaderArchiveAdmission } from "../task/leaderArchiveAuthority.js";
 import { createRun, runExecutionObservation, runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { contextContentDigest, contextSnapshotRef } from "../context/contextSnapshot.js";
 import { sourceRunContextValue } from "../context/sourceRunContext.js";
-import { buildRunContextDelta, buildRunContextPack, contextSnapshotDeltaRefIds, expandRunContextRef, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, freezeCandidateContextSnapshot, readRunContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
+import { buildRunContextDelta, buildRunContextPack, runContextEntry, runContextPointerPage, contextSnapshotDeltaRefIds, expandRunContextRef, 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 { assertContextRecordReadable, readTaskContextResource } from "../context/taskContext.js";
@@ -1631,9 +1632,25 @@ function taskMessageCommand(args, store, options) {
         const message = store.transaction((tx) => {
             assertTaskDeliveryAuthority(tx, options.environment, ref.taskId);
             const current = tx.listMessages(ref.taskId).find((entry) => entry.id === ref.localId);
-            if (current?.recipient?.ownerRunId === undefined || current.continuation?.runId !== undefined) {
+            if (current?.inbox?.ack !== undefined || current?.recipient?.ownerRunId === undefined || current.continuation?.runId !== undefined) {
                 throw usageError("Only an unassigned pending Message can be explicitly handed off.");
             }
+            if (current.inbox !== undefined) {
+                const actor = current.inbox.claim.actor;
+                for (const runId of new Set([actor.runId, current.recipient.ownerRunId])) {
+                    const handler = runId === undefined ? null : tx.getRun(ref.taskId, runId);
+                    const observation = handler === null ? undefined : runExecutionObservation(handler, tx.getTaskRoleSessionSet(ref.taskId, handler.roleName)?.providerBinding, tx.listEvents(ref.taskId));
+                    if (handler === null || handler.status === "active"
+                        || handler.result?.failureReason === "delivery-unknown"
+                        || handler.result?.provider === undefined
+                        || runId === actor.runId && handler.result.provider.conversationId !== actor.nativeSessionId
+                        || !["completed", "failed", "cancelled"].includes(observation?.delivery ?? "")) {
+                        throw usageError("The original and current inbox handlers must have exact stopped native execution before explicit handoff.");
+                    }
+                }
+                // Preserve the original claim: the new authorized Assignment must
+                // inspect prior effects and ack explicitly, never auto-replay the input.
+            }
             const recipient = resolveMessageRecipient(tx, ref.taskId, requiredOption(parsed.options, "--to"), {
                 ...(current.recipient.workItemId === undefined ? {} : { workItemId: current.recipient.workItemId }),
                 ...(current.recipient.reviewRoundId === undefined ? {} : { reviewRoundId: current.recipient.reviewRoundId })
@@ -1853,15 +1870,23 @@ function steerTaskInput(taskId, input, store, options) {
     // and idempotent, so the Host's later settlement fold promotes it to a proven
     // terminal and never rewinds it. An idempotent replay above already returned
     // the saved Message, so this records the attempt exactly once.
-    store.transaction((tx) => {
+    const admitted = store.transaction((tx) => {
         const saved = tx.listMessages(result.task.id).find((entry) => entry.id === result.message.id);
         const requestId = saved?.inputControl?.requestId;
-        if (saved === undefined || requestId === undefined)
-            return;
+        // The recipient may claim between Message persistence and control
+        // admission. A Leader window owns its referenced originals even after ack;
+        // never re-submit them through a delayed steer.
+        if (saved === undefined || requestId === undefined || taskMessageInboxReceipt(tx, saved) !== undefined)
+            return false;
         tx.updateMessage(result.task.id, recordTaskMessageControlOutcome(saved, {
             requestId, receiptId, outcome: "pending", observedAt: clock(options)
         }));
+        return true;
     });
+    if (!admitted) {
+        return output(`Steer message ${result.message.id} saved but not delivered (TARGET_CHANGED: inbox handling owns the input).\n`, { taskId: result.task.id, message: messageReceipt(result.message),
+            steer: { state: "not-steered", code: "TARGET_CHANGED", detail: "Inbox handling already owns the original input." } });
+    }
     return {
         kind: "input-steer",
         taskId: result.task.id,
@@ -2407,6 +2432,9 @@ function registerInterruptThen(store, taskId, roleName, thenMessageRef, target,
     }
     // A Message that already delivered, or was already ruled undeliverable, is not
     // a fresh input to reuse; reusing it would replay or resurrect a settled fact.
+    if (taskMessageInboxReceipt(store, message) !== undefined) {
+        return { code: "TARGET_CHANGED", detail: `Message ${thenMessageRef} is owned by active inbox handling.` };
+    }
     if (message.continuation?.runId !== undefined) {
         return { code: "TARGET_CHANGED", detail: `Message ${thenMessageRef} was already delivered by ${message.continuation.runId}.` };
     }
@@ -4749,14 +4777,18 @@ function runContextCommand(args, store, options) {
         const data = boundedDocument(delta, `run:${taskId}/${runId}/delta/${parsed.values.get("--after")}`, parsed.cursor);
         return output(`${JSON.stringify(data)}\n`, { contextDelta: data });
     }
-    const parsed = readOptions(rest, ["--cursor"]);
+    const parsed = readOptions(rest, ["--cursor", "--view"]);
     if (first === undefined || parsed.positionals.length !== 0) {
         throw usageError("Task run context usage: yui task run context <task>/<run>.");
     }
     const { taskId, runId } = parseRunContextReference(first);
     authorizeRunContext(store, taskId, runId, options.environment);
     const pack = store.transaction((tx) => buildRunContextPack(tx, taskId, runId));
-    const data = boundedDocument(pack, `run:${taskId}/${runId}/context`, parsed.cursor);
+    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.");
+    const data = view === "refs" ? runContextPointerPage(pack, parsed)
+        : boundedDocument(view === "full" ? pack : view === "input" ? pack.input : runContextEntry(pack), `run:${taskId}/${runId}/context/${view}`, parsed.cursor);
     return output(`${JSON.stringify(data)}\n`, { context: data });
 }
 function parseRunContextReference(value) {

package/dist/commands/taskRoleRuntimeStatus.js

@@ -18,6 +18,7 @@ export function taskRoleHostDiagnostic(host) {
     const delivery = snapshot.eventDelivery;
     return [
         `Provider Host=${snapshot.state}`,
+        `terminal reconciliation=${snapshot.controlCapabilities?.includes("reconcile-turn") ? "supported" : "unreported/unsupported"}`,
         delivery === undefined ? "event delivery=unreported" :
             `pending facts=${delivery.pending}; native terminals awaiting acknowledgement=${delivery.pendingTerminals}`,
         delivery?.failure === undefined ? undefined :
@@ -35,6 +36,7 @@ export function withTaskRoleHostObservation(status, host) {
         return { ...status, host: { detail: "Host does not match the recorded native Session." } };
     }
     const reportingNeedsAttention = snapshot !== undefined && (snapshot.state === "failed" || snapshot.state === "exited"
+        || snapshot.eventDelivery === undefined
         || snapshot.eventDelivery?.failure !== undefined
         || (snapshot.eventDelivery?.pendingTerminals ?? 0) > 0);
     return {

package/dist/context/currentSkills.js

@@ -0,0 +1,48 @@
+import { accessSync, constants, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const BUILTIN_YUI_SKILLS = new Set([
+    "yui-runtime", "yui-operator", "yui-leader", "yui-worker", "yui-reviewer"
+]);
+export function currentSkillPath(home, id) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/u.test(id))
+        throw new Error(`Invalid configured Skill id: ${id}.`);
+    if (BUILTIN_YUI_SKILLS.has(id))
+        return fileURLToPath(new URL(`../../skills/${id}`, import.meta.url));
+    if (home === undefined)
+        throw new Error("YUI_HOME is required to load configured Role skills.");
+    return resolve(home, "skills", id);
+}
+/** Per-turn metadata only: never read the body, traverse resources, snapshot a
+ * package, or claim that the model still has instructions in its context. */
+export function checkCurrentSkills(home, ids) {
+    return [...new Set(ids)].map(id => {
+        const path = currentSkillPath(home, id);
+        const versionPath = join(path, "VERSION");
+        try {
+            for (const file of [join(path, "SKILL.md"), versionPath]) {
+                if (realpathSync(file) !== resolve(file) || !lstatSync(file).isFile()) {
+                    throw new Error(`Skill files must be regular files without symlinks: ${file}.`);
+                }
+                accessSync(file, constants.R_OK);
+            }
+            if (lstatSync(versionPath).size > 128)
+                throw new Error("VERSION exceeds 128 bytes.");
+            const version = readFileSync(versionPath, "utf8").trim();
+            if (!/^[1-9][0-9]{0,8}$/u.test(version))
+                throw new Error("VERSION must contain a positive internal integer.");
+            return { id, path, version, versionPath };
+        }
+        catch (error) {
+            throw new Error(`Current Skill ${id} is missing, unreadable or invalid at ${path}. `
+                + `${error instanceof Error ? error.message : String(error)} `
+                + "Restore the current installation/configured Skill (including VERSION) in this Home, then check again; "
+                + "do not replace the Session or replay input to repair Skill loading.", { cause: error });
+        }
+    });
+}
+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.";

package/dist/context/roleSessionContext.js

@@ -3,29 +3,18 @@ import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { snapshotSkillPackage, verifySkillPackage } from "./skillPackage.js";
+import { BUILTIN_YUI_SKILLS, checkCurrentSkills } from "./currentSkills.js";
+export { BUILTIN_YUI_SKILLS } from "./currentSkills.js";
 import { SYSTEM_LEADER_ROLE, SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-export const BUILTIN_YUI_SKILLS = new Set([
-    "yui-runtime",
-    "yui-operator",
-    "yui-leader",
-    "yui-worker",
-    "yui-reviewer"
-]);
 /**
  * Compiles stable Role policy for an Agent-native instruction channel.
  * Dynamic wakeups and AgentRun assignments deliberately remain outside this value.
  */
 export function compileRoleSessionContext(yuiHome, role, owner, options = {}) {
     const kind = roleSessionKind(role, owner, options.purpose ?? "execution");
-    const builtInSkillId = kind === "global" ? undefined : `yui-${kind}`;
-    const skillIds = unique([
-        "yui-runtime",
-        ...(builtInSkillId === undefined ? [] : [builtInSkillId]),
-        ...(role.skills ?? [])
-    ]);
-    const skills = options.skillPackages === undefined
-        ? loadYuiSkillContexts(yuiHome, skillIds)
-        : options.skillPackages.map(loadSkillPackageContext);
+    const skills = checkCurrentSkills(yuiHome, roleSkillIds(role, kind)).map(skill => ({
+        ...skill, content: readFileSync(join(skill.path, "SKILL.md"), "utf8").trim()
+    }));
     return {
         developerInstructions: renderDeveloperInstructions(kind, role, owner),
         skills,
@@ -34,6 +23,14 @@ export function compileRoleSessionContext(yuiHome, role, owner, options = {}) {
             : { managedContextFile: roleContextFile(yuiHome, role, owner, kind) })
     };
 }
+export function roleSkillIds(role, kind) {
+    const builtInSkillId = kind === "global" ? undefined : `yui-${kind}`;
+    return unique([
+        "yui-runtime",
+        ...(builtInSkillId === undefined ? [] : [builtInSkillId]),
+        ...(role.skills ?? [])
+    ]);
+}
 function renderDeveloperInstructions(kind, role, owner) {
     const core = renderRoleCore(kind, role, owner);
     const profile = [