@zq-silk/yui 2.6.0 → 2.7.1

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>`,

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;

package/dist/controller/globalInputDelivery.js

@@ -1,16 +1,18 @@
-import { sendAgentHostRunControl, AGENT_HOST_CONTROL_PROTOCOL } from "../runtime/agentHost.js";
+import { sendAgentHostRunControl, reconcileAgentHostTurn, AGENT_HOST_CONTROL_PROTOCOL } from "../runtime/agentHost.js";
 import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { markGlobalRoleMessageNotDelivered } from "../message/message.js";
 import { providerRetryPending } from "../runtime/providerRetry.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { globalMessagePresentation } from "../interaction/notificationPresentation.js";
+import { recordGlobalRuntimeAttention } from "./globalRuntimeAttention.js";
 /** Messages are the only queue. Host's atomic begin arbitrates native writers. */
-export async function deliverGlobalInputs(home, store, ensure, onError) {
+export async function deliverGlobalInputs(home, store, ensure, onError, options = {}) {
     for (const role of store.listGlobalRoles()) {
         try {
-            let pending = store.listGlobalRoleMessages(role.name).filter(message => message.delivery === undefined && message.notDelivered === undefined
-                && (message.inputControl?.action === "queue" || message.interruptThen !== undefined));
+            if (store.queryGlobalRoleMessages(role.name, { handling: true, limit: 0 }).count > 0)
+                continue;
+            let pending = store.queryGlobalRoleMessages(role.name, { pending: true, limit: 64 }).messages;
             if (pending.length === 0 || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName: role.name }))))
                 continue;
             let sessions = store.getGlobalRoleSessionSet(role.name);
@@ -20,15 +22,68 @@ export async function deliverGlobalInputs(home, store, ensure, onError) {
                 continue;
             if (sessions?.providerBinding?.retry !== undefined && !providerRetryPending(sessions.providerBinding)) {
                 store.transaction(tx => settleGlobalRetryInput(tx, role.name, tx.getGlobalRoleSessionSet(role.name)?.providerBinding, new Date()));
-                pending = store.listGlobalRoleMessages(role.name).filter(message => message.delivery === undefined && message.notDelivered === undefined
-                    && (message.inputControl?.action === "queue" || message.interruptThen !== undefined));
+                pending = store.queryGlobalRoleMessages(role.name, { pending: true, limit: 64 }).messages;
                 if (pending.length === 0)
                     continue;
             }
             if (providerRetryPending(sessions?.providerBinding))
                 continue;
-            const current = sessions?.providerBinding?.run;
-            const obsolete = pending.filter(message => {
+            let current = sessions?.providerBinding?.run;
+            const bindingBefore = sessions?.providerBinding;
+            if (options.reconcile && current != null
+                && ["submitting", "accepted", "delivery-unknown"].includes(current.status)
+                && bindingBefore?.authority.owner === "controller" && bindingBefore.authority.holderId !== undefined) {
+                const ownedTurn = current;
+                // Only ask the original Host to republish evidence it already holds.
+                // Busy, unknown, unavailable and older Hosts never authorize replay,
+                // Session creation, native reads through another client, or timeout settlement.
+                let observed;
+                try {
+                    observed = await reconcileAgentHostTurn({
+                        home, scope: "global", roleName: role.name,
+                        control: { protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "reconcile-turn",
+                            nativeSessionId: currentProviderConversation(bindingBefore).conversationId,
+                            attemptId: current.attemptId, nativeTurnId: current.nativeTurnId,
+                            authority: { epoch: bindingBefore.authority.epoch, owner: "controller",
+                                holderId: bindingBefore.authority.holderId } }
+                    });
+                    if (observed.outcome === "rejected" || ["idle", "failed", "exited"].includes(observed.snapshot.state)
+                        && observed.reconciliation !== "terminal-republished") {
+                        throw new Error(observed.failure?.detail ?? observed.snapshot.detail ?? "Host cannot reconcile this exact terminal.");
+                    }
+                }
+                catch (error) {
+                    store.transaction(tx => recordGlobalRuntimeAttention(tx, role.name, `terminal-reconcile:${currentProviderConversation(bindingBefore).conversationId}:${ownedTurn.attemptId}`, { attemptId: ownedTurn.attemptId, nativeTurnId: ownedTurn.nativeTurnId,
+                        nativeSessionId: currentProviderConversation(bindingBefore).conversationId,
+                        reason: "host-terminal-unobservable",
+                        cause: observed === undefined ? "host-control-unavailable"
+                            : observed.outcome === "rejected" ? "host-control-rejected" : "exact-terminal-not-retained",
+                        hostState: observed?.snapshot.state ?? null,
+                        endpointImplementation: observed?.snapshot.endpointImplementation ?? null,
+                        eventDelivery: observed?.snapshot.eventDelivery ?? null,
+                        // Endpoint generation is not a loaded Host/package version.
+                        inputKind: ownedTurn.attemptId.startsWith("direct:") ? "direct" : "managed",
+                        detail: error instanceof Error ? error.message : String(error),
+                        recovery: "Inspect the original Host, Session, input and raw Inbox. Controller restart preserves live Hosts; it does not upgrade their loaded observation code. Restore the supported observation path, or explicitly stop/replace with exact native quiescence evidence. Missing eventDelivery means unreported, not healthy. Do not resend unknown input.",
+                        confirmed: ownedTurn.status, unknown: "Native terminal and remaining writer ownership." }, options.now ?? new Date()));
+                    continue;
+                }
+                sessions = store.getGlobalRoleSessionSet(role.name);
+                current = sessions?.providerBinding?.run;
+                if (sessions?.sessions[sessions.activeAgentId]?.status !== "active"
+                    || providerRetryPending(sessions?.providerBinding)
+                    || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName: role.name }))))
+                    continue;
+                pending = store.queryGlobalRoleMessages(role.name, { pending: true, limit: 64 }).messages;
+                if (pending.length === 0)
+                    continue;
+            }
+            // Interrupt-then reserves the next legal slot even behind a large queue.
+            const reservedPage = store.queryGlobalRoleMessages(role.name, {
+                pending: true, interruptThen: true, limit: 64
+            });
+            const reserved = reservedPage.messages;
+            const obsolete = reserved.filter(message => {
                 const claim = message.interruptThen;
                 return claim !== undefined && (sessions?.activeAgentId !== claim.targetAgentId
                     || sessions.sessions[claim.targetAgentId]?.nativeSessionId !== claim.targetNativeSessionId
@@ -37,15 +92,18 @@ export async function deliverGlobalInputs(home, store, ensure, onError) {
             });
             for (const message of obsolete)
                 store.updateGlobalRoleMessage(markGlobalRoleMessageNotDelivered(message, "native-session-or-authority-changed", new Date()));
-            pending = pending.filter(message => !obsolete.includes(message));
+            const obsoleteIds = new Set(obsolete.map(message => message.id));
+            pending = pending.filter(message => !obsoleteIds.has(message.id));
             if (pending.length === 0)
                 continue;
+            if (reservedPage.count > reserved.length && obsolete.length === reserved.length)
+                continue;
             if (current != null && ["submitting", "accepted", "delivery-unknown"].includes(current.status))
                 continue;
             const matchesTarget = (message) => message.deliveryTarget === undefined
                 || sessions?.activeAgentId === message.deliveryTarget.agentId
                     && sessions.sessions[message.deliveryTarget.agentId]?.nativeSessionId === message.deliveryTarget.nativeSessionId;
-            const claims = pending.filter(message => message.interruptThen !== undefined);
+            const claims = reserved.filter(message => !obsolete.includes(message));
             let next;
             if (claims.length > 0) {
                 next = claims.find(message => {
@@ -76,7 +134,7 @@ export async function deliverGlobalInputs(home, store, ensure, onError) {
                     return false;
                 });
             }
-            if (next === undefined)
+            if (next === undefined || next.inbox !== undefined)
                 continue;
             const attemptId = `global-input:${role.name}/${next.id}`;
             if (current?.attemptId === attemptId)
@@ -96,8 +154,8 @@ export async function deliverGlobalInputs(home, store, ensure, onError) {
             if (binding == null || binding.authority.owner !== "controller")
                 continue;
             const nativeSessionId = currentProviderConversation(binding).conversationId;
-            const persisted = store.listGlobalRoleMessages(role.name).find(message => message.id === next.id);
-            if (persisted === undefined || JSON.stringify(persisted) !== JSON.stringify(next))
+            const persisted = store.queryGlobalRoleMessages(role.name, { id: next.id, limit: 1 }).messages[0];
+            if (persisted === undefined || persisted.inbox !== undefined || JSON.stringify(persisted) !== JSON.stringify(next))
                 continue;
             const claim = next.interruptThen;
             if (!matchesTarget(next) || claim !== undefined
@@ -125,8 +183,8 @@ export async function deliverGlobalInputs(home, store, ensure, onError) {
             });
             if (result.outcome === "rejected") {
                 store.transaction(tx => {
-                    const latest = tx.listGlobalRoleMessages(role.name).find(message => message.id === next.id);
-                    if (latest === undefined || latest.delivery !== undefined || latest.notDelivered !== undefined)
+                    const latest = tx.queryGlobalRoleMessages(role.name, { id: next.id, limit: 1 }).messages[0];
+                    if (latest === undefined || latest.inbox !== undefined || latest.delivery !== undefined || latest.notDelivered !== undefined)
                         return;
                     const turn = tx.getGlobalRoleSessionSet(role.name)?.providerBinding?.run;
                     if (providerRetryPending(tx.getGlobalRoleSessionSet(role.name)?.providerBinding))

package/dist/controller/globalRuntimeAttention.js

@@ -19,7 +19,7 @@ export function recordGlobalRuntimeAttention(store, roleName, identity, facts, n
     // diagnostic readable; never create a Role or launch a substitute Agent.
     const recipient = store.getGlobalRole("operator") === null ? roleName : "operator";
     const requestId = `runtime-attention:${createHash("sha256").update(`${roleName}\0${identity}`).digest("hex")}`;
-    if (store.listGlobalRoleMessages(recipient).some(message => message.inputControl?.requestId === requestId))
+    if (store.queryGlobalRoleMessages(recipient, { requestId, limit: 1 }).messages.length > 0)
         return;
     const message = createGlobalRoleMessage(store.nextGlobalRoleMessageId(), recipient, [
         `Global Role ${roleName} needs attention. No recovery or new authority is implied.`,

package/dist/controller/operatorNotification.js

@@ -8,7 +8,7 @@ import { createGlobalRoleMessage } from "../message/message.js";
 export function queueOperatorNotification(store, input, now = new Date()) {
     return store.transaction(tx => {
         const requestId = `operator-notice:${encodeURIComponent(input.receiptId)}`;
-        const previous = tx.listGlobalRoleMessages("operator").find(entry => (entry.inputControl ?? entry.interruptThen?.reusedInput)?.requestId === requestId);
+        const previous = tx.queryGlobalRoleMessages("operator", { requestId, limit: 1 }).messages[0];
         const mailbox = tx.getWorkMailbox({ kind: "operator" });
         const claimed = mailbox?.processing?.batchId === input.batchId;
         if (previous !== undefined) {
@@ -18,6 +18,11 @@ export function queueOperatorNotification(store, input, now = new Date()) {
         }
         if (!claimed)
             throw new Error(`Operator notification claim changed: ${input.batchId}`);
+        // At most one unsent engineering notice. New facts coalesce in the existing
+        // mailbox while busy, without rewriting originals or overtaking user input.
+        if (tx.queryGlobalRoleMessages("operator", { pending: true, operatorNotice: true, limit: 1 }).count > 0) {
+            return { status: "deferred" };
+        }
         const sessions = tx.getGlobalRoleSessionSet("operator");
         const session = sessions?.sessions[sessions.activeAgentId];
         if (session?.status !== "active" || sessions?.providerBinding == null)

package/dist/controller/providerRetryDelivery.js

@@ -1,6 +1,6 @@
 import { performance } from "node:perf_hooks";
 import { runTaskCommand } from "../commands/taskCommands.js";
-import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { redactAgentErrorText } from "../runtime/agentError.js";
@@ -57,8 +57,7 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                     roleName: owner.roleName, chainId: binding.retry.chainId, reason
                 }, new Date(at));
                 store.saveEvent(owner.taskId, event);
-                enqueueWork(store, owner.roleName === "leader" ? { kind: "operator" }
-                    : { kind: "role", taskId: owner.taskId, roleName: "leader" }, "provider-retry-needs-attention", new Date(at), [{ type: "event", taskId: owner.taskId, id: event.id }]);
+                routeRoleEvent(store, event, owner.roleName, "provider-retry-needs-attention", new Date(at));
             }
         });
     };
@@ -142,8 +141,7 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                                         roleName: owner.roleName, attemptId: retry.currentAttemptId, nativeSessionId: retry.nativeSessionId, detail
                                     }, new Date(at));
                                     store.saveEvent(owner.taskId, event);
-                                    enqueueWork(store, owner.roleName === "leader" ? { kind: "operator" }
-                                        : { kind: "role", taskId: owner.taskId, roleName: "leader" }, "provider-retry-needs-attention", new Date(at), [{ type: "event", taskId: owner.taskId, id: event.id }]);
+                                    routeRoleEvent(store, event, owner.roleName, "provider-retry-needs-attention", new Date(at));
                                 }
                             });
                         }

package/dist/controller/runtime.js

@@ -560,9 +560,9 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                 }
             }),
             jobSupervisor,
-            globalInputDelivery: () => deliverGlobalInputs(home, store, async (roleName) => {
+            globalInputDelivery: (deliveryOptions) => deliverGlobalInputs(home, store, async (roleName) => {
                 await lifecycleDispatcher("runtime.ensure-role-session", { scope: "global", roleName });
-            }, options.onError ?? (() => undefined)),
+            }, options.onError ?? (() => undefined), deliveryOptions),
             jobControl,
             capabilityDispatcher: createCapabilityDispatcher(kernel.capabilities),
             ...(continuationReconciler === undefined ? {} : { continuationReconciler }),