@zq-silk/yui 2.5.0 → 2.7.1

package/dist/commands/taskCommands.js

@@ -1,5 +1,6 @@
 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";
@@ -45,7 +46,7 @@ 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, resolveManagedTaskReader } from "../runtime/managedCaller.js";
-import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { controlProviderRetry, providerRunRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
 import { currentProviderConversation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.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}.` };
     }
@@ -4897,7 +4925,9 @@ function retryRun(args, store, options) {
             return output(`Retry already recorded as ${existing.payload.runId}; retry that exact successor if needed.\n`);
         }
         const sessions = tx.getTaskRoleSessionSet(previous.taskId, previous.roleName);
-        const retry = sessions?.providerBinding?.retry;
+        const retry = options.providerRetryChainId !== undefined ? sessions?.providerBinding?.retry
+            : sessions?.providerBinding == null ? undefined
+                : providerRunRetry(sessions.providerBinding, previous.id, clock(options).getTime());
         if (options.providerRetryChainId !== undefined
             && (retry?.chainId !== options.providerRetryChainId || retry.status !== "waiting"
                 || retry.previousRunId !== previous.id || clock(options).getTime() < Date.parse(retry.nextEligibleAt)
@@ -4909,7 +4939,10 @@ function retryRun(args, store, options) {
             const successor = tx.getActiveRun(previous.taskId, previous.roleName);
             tx.saveTaskRoleSessionSet({
                 ...sessions, providerBinding: {
-                    ...sessions.providerBinding, retry: {
+                    ...sessions.providerBinding,
+                    ...(sessions.providerBinding.retry !== undefined && sessions.providerBinding.retry.chainId !== retry.chainId
+                        ? { retryHistory: [...(sessions.providerBinding.retryHistory ?? []), sessions.providerBinding.retry] } : {}),
+                    retry: {
                         ...retry, status: "waiting", successorAutomatic: options.providerRetryChainId !== undefined,
                         ...(options.providerRetryChainId === undefined ? {
                             intentAt: clock(options).toISOString(),

package/dist/commands/taskContextCommand.js

@@ -17,12 +17,12 @@ 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>] [--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>] [--view <current|all>] [--status <status>] [--work-item <id>].");
     const options = new Map();
     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"] : ["--store", "--ref", "--digest", "--cursor"];
+        ? ["--store", "--cursor", "--limit", "--status", "--after", "--work-item", "--view"] : ["--store", "--ref", "--digest", "--cursor"];
     for (let i = 0; i < rest.length; i += 2) {
         const flag = rest[i];
         const value = rest[i + 1];
@@ -40,6 +40,7 @@ export function runTaskContextCommand(args, store, environment = {}) {
             throw usageError("Context list requires --store.");
         data = listTaskContext(store, taskId, family, {
             cursor: options.get("--cursor"),
+            view: options.get("--view"),
             status: options.get("--status"), after: options.get("--after"), workItemId: options.get("--work-item"),
             ...(options.has("--limit") ? { limit: Number(options.get("--limit")) } : {})
         }, environment);

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 = [

package/dist/context/runContextPack.js

@@ -344,6 +344,8 @@ export function buildRunContextPack(store, taskId, runId) {
     const preliminaryBytes = Buffer.byteLength(JSON.stringify({ ...body, digest }), "utf8");
     const pack = Object.freeze({
         ...body,
+        // Current loading guidance is not part of the frozen Assignment digest.
+        skillCheckCommand: "yui session skills --json",
         inventory: Object.freeze({
             refs: pointers.length,
             frozenBytes: preliminaryBytes,

package/dist/context/runInputContract.js

@@ -79,7 +79,7 @@ export function serializeRunInputEnvelope(value) {
         .join(",");
     const snapshot = normalized.contextSnapshotRef;
     const lines = [
-        "Yui AgentRun input. Follow the Session Manifest and injected Skills.",
+        "Yui AgentRun input. Check current Skills: yui session skills --json. Follow the Session Manifest profile and current Skills.",
         `${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

@@ -3,6 +3,7 @@ import { chmodSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { validateSkillPackageRef } from "./skillPackage.js";
+import { checkCurrentSkills, SKILL_CHECK_COMMAND, SKILL_REUSE_RULE } from "./currentSkills.js";
 import { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
 export { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
 /** Portable read pointers accompany every managed input, including the first
@@ -20,9 +21,22 @@ export function withSessionContextPointer(text, environment) {
 /** No remembered/sent flag can prove instructions survived context compaction. */
 export function sessionContextInstructions(manifestPath, digest) {
     return `Yui Session Manifest: ${manifestPath}${digest === undefined ? "" : ` (digest ${digest})`}. `
-        + "Apply yui-runtime and its Role Skills/profile by exact manifest paths. "
-        + "Load on first entry, version change or missing context; reuse only same-version instructions "
-        + "fully available now, never infer availability from prior reads.";
+        + `Before work on every turn run the Manifest's contextProtocol.skillCheckCommand `
+        + `(older Manifests: ${SKILL_CHECK_COMMAND}; Global loadCommand also checks current Skills). `
+        + "Use its current stable Skill paths instead of historical frozen-package paths; preserve the Manifest's Role profile. "
+        + SKILL_REUSE_RULE;
+}
+/** The caller must already pass the ordinary managed Session/CLI/Home checks.
+ * Old manifests remain immutable audit records, while this read resolves their
+ * Skill IDs against the currently executing installation and Home. */
+export function checkSessionSkills(home, manifestPath) {
+    const manifest = readSessionBootstrapManifest(manifestPath);
+    return {
+        skills: checkCurrentSkills(home, manifest.skills.map(skill => skill.id)),
+        roleProfileRef: manifest.roleProfileRef,
+        rule: SKILL_REUSE_RULE,
+        historicalPackagesAreAuditOnly: true
+    };
 }
 /** Read back one immutable Session Manifest and verify its content digest. */
 export function readSessionBootstrapManifest(path) {
@@ -76,6 +90,10 @@ export function readSessionBootstrapManifest(path) {
         requireText(entry.id, "Session Manifest Skill id");
         requireText(entry.path, "Session Manifest Skill path");
         requireDigest(entry.digest, "Session Manifest Skill digest");
+        if (entry.version !== undefined) {
+            requireText(entry.version, "Session Manifest Skill version");
+            requireText(entry.versionPath, "Session Manifest Skill version path");
+        }
         if (entry.package !== undefined) {
             const ref = entry.package;
             validateSkillPackageRef(ref);
@@ -121,6 +139,7 @@ export function materializeSessionBootstrap(input) {
             id: skill.id,
             path: skill.path,
             digest: skill.package?.digest ?? digest(skill.content),
+            ...(skill.version === undefined ? {} : { version: skill.version, versionPath: skill.versionPath }),
             ...(skill.package === undefined ? {} : { package: skill.package })
         })),
         roleProfileRef: { digest: profileDigest, path: roleProfilePath },
@@ -129,11 +148,15 @@ export function materializeSessionBootstrap(input) {
                 // A Global Session may move between Yui's remote TUI and Desktop.
                 // Carry its read entry in the Thread-visible Manifest instead of
                 // depending on the client process that happened to create it.
-                loadCommand: renderGlobalContextCommand(input.entryPoint, home, input.role.name)
+                loadCommand: renderGlobalContextCommand(input.entryPoint, home, input.role.name),
+                // Same self-contained read remains usable from Desktop without the
+                // launching shell's managed environment or PATH.
+                skillCheckCommand: renderGlobalContextCommand(input.entryPoint, home, input.role.name)
             }
             : {
                 loadCommand: `yui task run context ${quoteShellWord(`${input.owner.taskId}/<run-id>`)} --json`,
                 expandCommand: `yui task run context expand ${quoteShellWord(`${input.owner.taskId}/<run-id>`)} <ref-id> --store <store> --mode full --json`,
+                skillCheckCommand: SKILL_CHECK_COMMAND,
                 ...(input.role.name === "leader" ? {
                     currentCommand: `yui task context ${quoteShellWord(input.owner.taskId)} --json`
                 } : {})

package/dist/context/skillCatalog.js

@@ -1,9 +1,8 @@
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { dirname, join, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
 import { verifySkillPackage } from "./skillPackage.js";
-import { BUILTIN_YUI_SKILLS } from "./roleSessionContext.js";
+import { BUILTIN_YUI_SKILLS, currentSkillPath } from "./currentSkills.js";
 const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/u;
 const MAX_TEXT = 256 * 1024;
 const digest = (data) => createHash("sha256").update(data).digest("hex");
@@ -13,7 +12,7 @@ export function skillSource(home, id) {
         throw new Error("Invalid Skill id.");
     const builtin = BUILTIN_YUI_SKILLS.has(id);
     return { kind: builtin ? "builtin" : "configured",
-        path: builtin ? fileURLToPath(new URL(`../../skills/${id}`, import.meta.url)) : resolve(home, "skills", id) };
+        path: currentSkillPath(home, id) };
 }
 function physical(path) {
     if (realpathSync(path) !== resolve(path))

package/dist/context/taskContext.js

@@ -67,6 +67,8 @@ export function readTaskContext(store, taskId, environment = {}) {
             discovery: `task context list ${taskId} --store <store>`,
             commandDiscovery: {
                 help: "yui help", describe: "yui --json help",
+                skillCheck: "yui session skills --json",
+                ownInbox: "yui inbox list --json",
                 note: "Help and completion share the current caller's offline command view. Follow that view for operation-specific discovery; execution always revalidates authority."
             },
             detail: `task context inspect ${taskId} --store <store> --ref <refId> --digest <digest>`,
@@ -191,7 +193,10 @@ export function readTaskContextResource(store, taskId, selector, environment = {
 export function listTaskContext(store, taskId, family, options = {}, environment = {}) {
     return store.readTransaction(reader => {
         const scope = authorizeContext(reader, taskId, environment);
-        const sources = authorizedSources(reader, scope, false, family);
+        if (options.view !== undefined && !["current", "all"].includes(options.view)) {
+            throw usageError("Context list view must be current or all.");
+        }
+        const sources = authorizedSources(reader, scope, options.view === "current", family, true);
         if (!CONTEXT_FAMILIES.includes(family))
             throw usageError(`Unknown Context store: ${family}.`);
         if (options.after !== undefined && !Number.isFinite(Date.parse(options.after)))
@@ -216,7 +221,7 @@ export function listTaskContext(store, taskId, family, options = {}, environment
             }
         }
         return recordPage(records, `task:${taskId}/${family}/${JSON.stringify({
-            status: options.status, after: options.after, workItemId: options.workItemId
+            view: options.view ?? "all", status: options.status, after: options.after, workItemId: options.workItemId
         })}`, options);
     });
 }
@@ -447,7 +452,7 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
         default: return null;
     }
 }
-function authorizedSources(store, { task, allow, caller }, current = false, requestedFamily) {
+function authorizedSources(store, { task, allow, caller }, current = false, requestedFamily, discovery = false) {
     const taskId = task.id;
     const sources = [];
     const add = (family, id, value) => {
@@ -462,7 +467,7 @@ function authorizedSources(store, { task, allow, caller }, current = false, requ
         const { count } = store.queryContextRecords(taskId, { ...selection, limit: 0 });
         sources.push({ family, count, *read(offset = 0) {
                 for (const { id, value } of store.queryContextRecords(taskId, {
-                    ...selection, offset, limit: current ? 8 : MAX_RECORDS
+                    ...selection, offset, limit: current && !discovery ? 8 : MAX_RECORDS
                 }).records)
                     yield materialize(family, id, value);
             } });

package/dist/controlPlaneCli.js

@@ -38,6 +38,7 @@ import { runDurableJobCommand } from "./commands/durableJobCommands.js";
 import { parseExecutionAuditOptions, runExecutionAuditCommand } from "./commands/executionAuditCommands.js";
 import { runGlobalRoleCommand, previewGlobalRoleAgentConfigurationMutation } from "./commands/globalRoleCommands.js";
 import { runJobCommand } from "./commands/jobCommands.js";
+import { runInboxCommand } from "./commands/inboxCommands.js";
 import { applyOperatorSessionControl, runOperatorCommand } from "./commands/operatorCommands.js";
 import { previewProfileAgentConfigurationMutation, runProfileCommand } from "./commands/profileCommands.js";
 import { runProjectCommand } from "./commands/projectCommands.js";
@@ -61,7 +62,7 @@ import { runWorkflowCommandAsync } from "./commands/workflowCommands.js";
 import { FileCompletionManager } from "./completion/fileCompletionManager.js";
 import { CONFIG_DOMAINS } from "./config/configCatalog.js";
 import { resolveTmuxBin, resolveTmuxHistoryLimit } from "./config/yuiConfig.js";
-import { readSessionBootstrapManifest } from "./context/sessionBootstrapManifest.js";
+import { checkSessionSkills, readSessionBootstrapManifest } from "./context/sessionBootstrapManifest.js";
 import { assertFileTaskControllerStorageCompatible, ensureFileTaskController, FileTaskWorkflowRuntime, refreshRunningFileTaskControllerConfiguration, refreshRunningFileTaskControllerEnvironment, restartFileTaskController, stopFileTaskController } from "./controller/clientRuntime.js";
 import { FileSchedulerStoreAdapter } from "./controller/fileSchedulerStoreAdapter.js";
 import { createControllerIntegrationJobPort } from "./controller/jobClient.js";
@@ -632,6 +633,11 @@ export async function main() {
         return;
     }
     assertTaskInvocationScope(resolved, process.env);
+    if (resolved[0] === "inbox") {
+        const result = runInboxCommand(resolved.slice(1), store, process.env);
+        emit(JSON.stringify(result, null, 2), false, result);
+        return;
+    }
     if (resolved[0] === "task" && resolved[1] === "role" && resolved[2] === "capabilities") {
         const query = parseTaskAgentCapabilityQuery(resolved.slice(3));
         const result = await callController(home, "task.role-capabilities", {
@@ -789,6 +795,17 @@ export async function main() {
             return;
         }
         if (resolved[0] === "session") {
+            if (resolved[1] === "skills") {
+                if (resolved.length !== 2)
+                    throw usageError("Usage: yui session skills --json");
+                const path = process.env.YUI_SESSION_MANIFEST;
+                if (!["task", "global"].includes(process.env.YUI_SESSION_SCOPE ?? "") || path === undefined) {
+                    throw usageError("Skill checks require the current managed Session and its Manifest.");
+                }
+                const data = checkSessionSkills(home, path);
+                emit(JSON.stringify(data, null, 2), false, data);
+                return;
+            }
             if (resolved[1] === "stop") {
                 const options = parseSessionStopOptions(resolved.slice(2));
                 const result = await runSessionStopCommand({

package/dist/controller/controller.js

@@ -996,7 +996,7 @@ export class FileTaskController {
                     }
                     const firstRuntimeDrain = await this.#drainRuntimeEvents();
                     await this.#providerRetry?.reconcile();
-                    await this.#globalInputDelivery?.();
+                    await this.#globalInputDelivery?.({ reconcile: scope.kind === "full", now: this.#now() });
                     for (const taskId of runtimeTaskFailureIds(firstRuntimeDrain)) {
                         runtimeFailedTaskIds.add(taskId);
                     }
@@ -1076,7 +1076,8 @@ export class FileTaskController {
                     if (scope.kind === "full"
                         || scope.keys.some((key) => key !== "operator")
                         || runtimeAdvanced) {
-                        this.#signalOperatorMailbox(runtimeAdvanced);
+                        this.#signalOperatorMailbox(runtimeAdvanced || scope.kind === "full"
+                            || scope.kind === "dirty" && scope.keys.some(key => parseMailboxKey(key).kind === "global-role"));
                     }
                 }
                 catch (error) {

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+import { taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { freezeRunContextSnapshot } from "../context/runContextPack.js";
 import { taskNotificationPresentation } from "../interaction/notificationPresentation.js";
@@ -30,6 +31,7 @@ import { standardAgentError } from "../runtime/agentError.js";
 import { recordTaskAgentError } from "./taskAgentError.js";
 import { recordGlobalRuntimeAttention, recordGlobalRuntimeFailure } from "./globalRuntimeAttention.js";
 import { queueOperatorNotification } from "./operatorNotification.js";
+import { claimOperatorAttention } from "../scheduler/operatorEvent.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
@@ -882,6 +884,11 @@ export class FileSchedulerStoreAdapter {
         return [...this.store.listPendingActivationRequestTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
     }
     getTask(taskId) { return this.store.getTask(taskId); }
+    getEvent(taskId, eventId) {
+        return this.store.queryContextRecords(taskId, {
+            family: "task-event", ids: [eventId], limit: 1
+        }).records[0]?.value ?? null;
+    }
     getTaskWorkspace(taskId) { return this.store.getTaskWorkspace(taskId); }
     getTaskBrief(taskId) { return this.store.getTaskBrief(taskId); }
     listDecisions(taskId) { return this.store.listDecisions(taskId); }
@@ -1146,7 +1153,8 @@ export class FileSchedulerStoreAdapter {
                     throw new AgentHostProviderSessionBusyError("The next Global input belongs to an explicit then handoff.");
                 }
                 if (message !== undefined) {
-                    if (message.delivery !== undefined || message.notDelivered !== undefined
+                    if (store.queryGlobalRoleMessages(input.roleName, { handling: true, limit: 0 }).count > 0
+                        || message.inbox !== undefined || message.delivery !== undefined || message.notDelivered !== undefined
                         || message.control !== undefined && message.control.outcome !== "rejected"
                         || message.deliveryTarget?.agentId !== input.agentId
                         || message.deliveryTarget?.nativeSessionId !== input.nativeSessionId) {
@@ -1567,7 +1575,7 @@ export class FileSchedulerStoreAdapter {
             if (mailbox.processing !== null) {
                 return { status: "processing", processing: mailbox.processing };
             }
-            let claimed = claimPending(mailbox, {
+            let claimed = (input.target.kind === "operator" ? claimOperatorAttention : claimPending)(mailbox, {
                 batchId: input.batchId,
                 owner: input.owner,
                 startedAt: input.now.toISOString()
@@ -1737,7 +1745,7 @@ export class FileSchedulerStoreAdapter {
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
     prepareMessageContinuations(taskId, now) {
-        const roles = new Set(this.store.listMessages(taskId).flatMap((message) => message.recipient?.ownerRunId !== undefined && message.continuation?.runId === undefined ? [message.recipient.roleName] : []));
+        const roles = new Set(this.store.listMessages(taskId).flatMap((message) => message.inbox === undefined && message.recipient?.ownerRunId !== undefined && message.continuation?.runId === undefined ? [message.recipient.roleName] : []));
         for (const roleName of roles) {
             try {
                 this.store.transaction((store) => prepareMessageContinuations(store, taskId, now, roleName));
@@ -1746,7 +1754,7 @@ export class FileSchedulerStoreAdapter {
                 const reason = `preparation-failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 1000);
                 this.store.transaction((store) => {
                     for (const message of store.listMessages(taskId)) {
-                        if (message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined && message.continuation?.runId === undefined
+                        if (message.inbox === undefined && message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined && message.continuation?.runId === undefined
                             && message.continuation?.notDeliveredReason !== reason) {
                             store.updateMessage(taskId, { ...message, continuation: { notDeliveredReason: reason } });
                         }
@@ -1855,6 +1863,8 @@ export class FileSchedulerStoreAdapter {
                 return { wakeId, attemptId: nextAttempt, disposition: "submit",
                     presentation: taskNotificationPresentation(wake, store) };
             }
+            if (unfinishedLeaderInbox(store, taskId))
+                return null;
             if (mailbox.pending === null || (provider !== null && provider !== undefined
                 && ["submitting", "accepted", "delivery-unknown"].includes(provider.status)))
                 return null;
@@ -1864,6 +1874,11 @@ export class FileSchedulerStoreAdapter {
             const sessions = store.getTaskRoleSessionSet(taskId, "leader");
             const session = sessions?.sessions[sessions.activeAgentId];
             const obsoleteIds = new Set();
+            for (const message of store.listMessages(taskId)) {
+                if (pendingMessageIds.has(message.id) && taskMessageInboxReceipt(store, message) !== undefined) {
+                    obsoleteIds.add(message.id);
+                }
+            }
             for (const message of store.listMessages(taskId)) {
                 if (!pendingMessageIds.has(message.id) || message.inputControl?.expectedSessionId === undefined)
                     continue;