@zq-silk/yui 2.5.0 → 2.7.1

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 }),

package/dist/doctor/doctor.js

@@ -1,6 +1,6 @@
 import { accessSync, constants, existsSync, lstatSync, realpathSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
-import Database from "better-sqlite3";
+import Database, { selectSqliteDriver } from "../sqlite/driver.js";
 import { inspectPty } from "./ptyProbe.js";
 import { gitVersionSupport } from "../repository/gitCompatibility.js";
 import { resolveExecutable } from "../external/pinnedCommandRunner.js";
@@ -31,6 +31,7 @@ import { CommandExecutionError } from "../tmux/commandExecutor.js";
  * and never block an update.
  */
 export const STORAGE_DOCTOR_CHECK_NAMES = Object.freeze([
+    "sqlite driver",
     "storage schema",
     "storage compatibility",
     "storage state"
@@ -38,7 +39,7 @@ export const STORAGE_DOCTOR_CHECK_NAMES = Object.freeze([
 /**
  * Classify the storage checks into a machine-readable health verdict. This is the
  * canonical, parseable signal the update post-verify consumes (P1-3): storage is
- * healthy only when schema, compatibility, and state are all `ok`. Any
+ * healthy only when driver, schema, compatibility, and state are all `ok`. Any
  * `unsupported` (version mismatch / needs-new-version), `invalid` (corrupted /
  * unreadable), or `missing` (uninitialized) storage check is blocking — even
  * and the machine-readable command exits non-zero.
@@ -119,6 +120,7 @@ export async function getDoctorChecks(env, executor) {
 async function inspectDoctor(env, executor) {
     const home = resolveYuiHome(env);
     const homeCheck = checkHome(home);
+    const driverCheck = checkSqliteDriver();
     const schema = readSchema(home);
     const compatibility = inspectCompatibility(home, homeCheck, schema);
     const schemaCheck = checkSchema(schema);
@@ -135,6 +137,7 @@ async function inspectDoctor(env, executor) {
     return {
         checks: [
             homeCheck,
+            driverCheck,
             schemaCheck,
             compatibility.check,
             storage.check,
@@ -148,6 +151,26 @@ async function inspectDoctor(env, executor) {
         review: review.report
     };
 }
+export function checkSqliteDriver() {
+    try {
+        const selected = selectSqliteDriver();
+        return {
+            name: "sqlite driver",
+            status: "ok",
+            detail: `${selected.name}@${selected.version}; SQLite ${selected.sqliteVersion}; `
+                + (selected.fallbackReason === undefined
+                    ? "no fallback"
+                    : `fallback: ${selected.fallbackReason}`)
+                + ". Isolated native connection probe; does not validate Home data."
+        };
+    }
+    catch (error) {
+        return {
+            name: "sqlite driver", status: "invalid",
+            detail: `Native driver probe failed (not a Home diagnosis): ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
 /** Query the authenticated Controller endpoint without starting it. */
 export async function checkController(home, probe = callController) {
     try {

package/dist/executor/effectiveLaunch.js

@@ -2,7 +2,7 @@ import { isDeepStrictEqual } from "node:util";
 import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
+import { loadYuiSkillContexts, roleSessionKind, roleSkillIds } from "../context/roleSessionContext.js";
 import { validateSkillPackageRef } from "../context/skillPackage.js";
 import { isAgentAdapterId } from "../agent/adapterCatalog.js";
 import { adapterIdForExecutionComponent, isAgentExecutionComponentId, resolveAgentExecutionComponent } from "../agent/executionComponents.js";
@@ -24,7 +24,7 @@ export function resolveEffectiveLaunch(input) {
     const continuing = existing?.status === "active";
     const skillPackages = continuing ? existing.effective.skillPackages
         : home === undefined ? undefined
-            : compileRoleSessionContext(home, input.role, "taskId" in input.role ? { scope: "task", taskId: input.role.taskId } : { scope: "global" }, { purpose: input.purpose }).skills.map(skill => skill.package);
+            : loadYuiSkillContexts(home, roleSkillIds(input.role, roleSessionKind(input.role, "taskId" in input.role ? { scope: "task", taskId: input.role.taskId } : { scope: "global" }, input.purpose))).map(skill => skill.package);
     return snapshotFromConfig({
         executionAuthority: input.executionAuthority ?? (input.purpose === "planning" ? "planning" : "delivery"),
         sourceDesiredRevision: input.role.launchRevision,

package/dist/executor/fileRoleLaunchPlanner.js

@@ -337,12 +337,10 @@ export class FileRoleLaunchPlanner {
         Object.assign(launchEnvironment, runtimeIsolation === undefined
             ? {}
             : taskRuntimeIsolationEnvironment(runtimeIsolation));
-        const skillPackages = input.mode === "resume"
-            ? existingSession?.effective.skillPackages : effective.skillPackages;
-        if (skillPackages === undefined) {
-            throw new Error("This launch has no frozen Skill package evidence (pre-1.5 or externally recorded Session). Create a new Session from current Role configuration; historical Skill versions cannot be reconstructed.");
-        }
-        const baseSessionContext = compileRoleSessionContext(this.home, launchRole, owner, { ...sessionPolicy, skillPackages });
+        // Frozen packages describe historical materialization, not Session identity
+        // or current instruction availability. Never require or reconstruct them
+        // when reconnecting a valid old Session.
+        const baseSessionContext = compileRoleSessionContext(this.home, launchRole, owner, sessionPolicy);
         const bootstrap = materializeSessionBootstrap({
             yuiHome: this.home,
             role: launchRole,

package/dist/interaction/notificationPresentation.js

@@ -69,7 +69,7 @@ export function taskNotificationPresentation(wake, store) {
         ...(messages.length > 4 ? [`${messages.length - 4} more messages in the fixed wake.`] : []),
         `Refresh: yui task context ${wake.taskId} --json`,
         `Read inputs/results: yui task wake show ${wake.taskId} ${wake.id} --json`,
-        "Apply yui-leader (from the current Manifest); read relevant originals in full and advance authorized work."
+        "Check current Skills each turn: yui session skills --json. Apply current yui-leader; read relevant originals in full and advance authorized work."
     ].join("\n");
 }
 export function globalMessagePresentation(roleName, messageId, message) {
@@ -80,6 +80,6 @@ export function globalMessagePresentation(roleName, messageId, message) {
         ...(summary === undefined ? [] : [`Author summary (message-body): ${JSON.stringify(summary)}`]),
         "Refresh Session Context using the current Manifest's loadCommand.",
         `Read original: yui role message show ${roleName} ${messageId} --json`,
-        `Apply ${roleName === "operator" ? "yui-operator" : "yui-runtime"} from the current Manifest within existing authority.`
+        `The Global loadCommand checks current Skill versions each turn. Apply current ${roleName === "operator" ? "yui-operator" : "yui-runtime"} within existing authority.`
     ].join("\n");
 }

package/dist/interaction/operatorPresentation.js

@@ -10,7 +10,7 @@ export function createOperatorBatchPresentation(batchId, items) {
         receiptId: `operator-batch:${batchId}`,
         text: [
             "[Yui updates]",
-            "Apply yui-operator from the current Manifest: inspect these originals and present material changes or decisions.",
+            "Check current Skills each turn via the Global Manifest's loadCommand. Apply current yui-operator; inspect these originals and present material changes or decisions.",
             ...items.flatMap(renderItem)
         ].join("\n")
     };

package/dist/kernel/builtinCapabilities.js

@@ -47,7 +47,7 @@ const definitions = [
         name: "context.list", summary: "Discover one authorized record family with bounded summaries and exact references.",
         effect: "query", requiredPermissions: ["task:read"], source: "listTaskContext",
         inputSchema: object({ taskId: text, store: text, cursor: text, limit: { type: "integer" },
-            status: text, after: text, workItemId: text }, ["taskId", "store"]),
+            view: { type: "string", enum: ["current", "all"] }, status: text, after: text, workItemId: text }, ["taskId", "store"]),
         outputSchema: { type: "object", required: ["items", "total", "complete", "nextCursor"] }
     },
     {
@@ -304,6 +304,7 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                 }, callerEnvironment(caller));
             if (name === "context.list")
                 return listTaskContext(store, taskId, params.store, {
+                    view: params.view,
                     cursor: params.cursor, limit: params.limit,
                     status: params.status, after: params.after,
                     workItemId: params.workItemId

package/dist/message/globalInputBacklog.js

@@ -0,0 +1,69 @@
+import { providerRetryPending } from "../runtime/providerRetry.js";
+import { hasRuntimeCleanupObligation } from "../runtime/lifecycleReservation.js";
+/** Bounded, derived diagnostics only; never an acknowledgement or recovery authority. */
+export function globalInputBacklog(pending, sessions, now = new Date(), mailboxes = {}) {
+    const first = pending[0];
+    const run = sessions?.providerBinding?.run;
+    const session = sessions?.sessions[sessions.activeAgentId];
+    const authority = sessions?.providerBinding?.authority;
+    const batches = [mailboxes.attention?.pending, mailboxes.attention?.processing?.batch]
+        .filter(batch => batch != null);
+    const coalescedFactCount = batches.reduce((count, batch) => count + batch.requestCount, 0);
+    let reason = "ready";
+    let recovery = "The Controller delivers at the next legal opportunity; do not duplicate the input.";
+    if (first === undefined && coalescedFactCount === 0)
+        reason = "empty";
+    else if (hasRuntimeCleanupObligation(mailboxes.lifecycle ?? null)) {
+        reason = "lifecycle-cleanup";
+        recovery = "Complete the existing exact-owner stop/replacement; queued input cannot revive the Session.";
+    }
+    else if (session?.status !== "active") {
+        reason = session === undefined ? "session-unavailable" : "session-stopped";
+        recovery = "Inspect Session lifecycle. Explicit stop/replacement is not undone by background delivery.";
+    }
+    else if (authority?.owner !== "controller") {
+        reason = "external-or-unknown-writer";
+        recovery = "Resolve the current writer/authority explicitly; no background takeover is allowed.";
+    }
+    else if (providerRetryPending(sessions?.providerBinding)) {
+        reason = "provider-retry";
+        recovery = "The existing bounded Provider retry owns this input; inspect session retry before intervening.";
+    }
+    else if (run && ["submitting", "accepted", "delivery-unknown"].includes(run.status)) {
+        reason = run.status === "accepted" ? "in-flight-or-unobserved-terminal" : run.status;
+        recovery = "Age does not prove a stalled Turn. Periodic reconciliation asks only the original Host for exact retained terminal evidence. Inspect recent runtime-attention Messages if the Host is unobservable; never resend unknown input.";
+    }
+    else if (first?.inbox) {
+        reason = "agent-inbox-handling";
+        recovery = "Read the exact inbox original and prior handling claim; explicitly acknowledge after processing. No automatic replay or timeout release.";
+    }
+    else if (first?.control && first.control.outcome !== "rejected") {
+        reason = "message-acceptance-unresolved";
+        recovery = "Inspect this original Message's exact control receipt; do not replay or bypass uncertain input.";
+    }
+    else if (first?.interruptThen) {
+        reason = "reserved-interrupt-then";
+        recovery = "Only the original Session, authority and exact terminal release the reserved continuation.";
+    }
+    else if (first?.deliveryTarget && (first.deliveryTarget.agentId !== sessions?.activeAgentId
+        || first.deliveryTarget.nativeSessionId !== session.nativeSessionId)) {
+        reason = "stale-target";
+        recovery = "Unsubmitted stale messages are retained with a nondelivery reason; no cross-Session input copy.";
+    }
+    const oldestCreatedAt = [...pending.map(message => message.createdAt), ...batches.map(batch => batch.firstQueuedAt)]
+        .reduce((oldest, at) => oldest === null || at < oldest ? at : oldest, null);
+    return {
+        pendingCount: pending.length, coalescedFactCount, oldestCreatedAt,
+        oldestAgeMs: oldestCreatedAt === null ? null : Math.max(0, now.getTime() - Date.parse(oldestCreatedAt)),
+        reason, recovery,
+        target: session === undefined ? null : {
+            agentId: session.agentId, nativeSessionId: session.nativeSessionId,
+            authority: authority ?? null, attemptId: run?.attemptId ?? null, nativeTurnId: run?.nativeTurnId ?? null
+        },
+        messages: pending.slice(0, 8).map(message => ({
+            id: message.id, createdAt: message.createdAt, deliveryTarget: message.deliveryTarget ?? null,
+            control: message.control ?? null, interruptThen: message.interruptThen ?? null
+        })),
+        omittedMessages: Math.max(0, pending.length - 8)
+    };
+}

package/dist/message/globalMessageQuery.js

@@ -0,0 +1 @@
+export {};

package/dist/message/inboxReceipt.js

@@ -0,0 +1,32 @@
+import { requireKnownFields, requireText, requireTimestamp } from "../domain/validation.js";
+import { isDeepStrictEqual } from "node:util";
+export function validateInboxReceipt(receipt) {
+    if (receipt === undefined)
+        return;
+    requireKnownFields(receipt, ["claim", "ack"], "Inbox receipt");
+    for (const [kind, entry] of Object.entries(receipt)) {
+        requireKnownFields(entry, kind === "claim" ? ["requestId", "actor", "at"]
+            : ["requestId", "actor", "at", "reason"], "Inbox action");
+        requireText(entry.requestId, "Inbox request id");
+        requireTimestamp(entry.at, "Inbox timestamp");
+        const actor = entry.actor;
+        requireKnownFields(actor, ["scope", "taskId", "roleName", "agentId", "nativeSessionId", "runId"], "Inbox actor");
+        if (!["task", "global"].includes(actor.scope)
+            || (actor.scope === "task") !== (actor.taskId !== undefined))
+            throw new Error("Inbox actor scope is invalid.");
+        for (const value of Object.values(actor))
+            requireText(value, "Inbox actor identity");
+        if (kind === "ack")
+            requireText(entry.reason, "Inbox disposition");
+    }
+    if (!receipt.claim)
+        throw new Error("Inbox receipt requires its original claim.");
+}
+/** A stale automatic writer cannot erase an active claim between its read and
+ * Host admission. The original claim and any ack are immutable audit facts. */
+export function assertInboxReceiptPreserved(previous, next) {
+    if (previous !== undefined && (!isDeepStrictEqual(previous.claim, next?.claim)
+        || previous.ack !== undefined && !isDeepStrictEqual(previous.ack, next?.ack))) {
+        throw new Error("Inbox handling ownership changed; reread the original instead of overwriting its receipt.");
+    }
+}

package/dist/message/message.js

@@ -1,5 +1,6 @@
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { requireKnownFields } from "../domain/validation.js";
+import { validateInboxReceipt } from "./inboxReceipt.js";
 export const TASK_MESSAGE_KINDS = ["user", "operator", "role-result", "system"];
 /**
  * How a user/operator submission asks its Task to react (task-32 Requirement A).
@@ -207,8 +208,9 @@ export function validateTaskMessage(message) {
         throw new Error("Task Message must use schemaVersion 1.");
     requireKnownFields(message, [
         "schemaVersion", "id", "taskId", "kind", "author", "body", "intent", "submissionKey", "submissionReceipt",
-        "inputControl", "interruptThen", "control", "runId", "resultRef", "workItemId", "recipient", "continuation", "handovers", "createdAt"
+        "inputControl", "interruptThen", "control", "runId", "resultRef", "workItemId", "recipient", "continuation", "handovers", "createdAt", "inbox"
     ], "Task Message");
+    validateInboxReceipt(message.inbox);
     validateTaskRecordReference({ taskId: message.taskId, localId: message.id }, "message");
     requireText(message.body, "Message body");
     validateKindAndAuthor(message.kind, message.author);
@@ -394,6 +396,7 @@ export function createGlobalRoleMessage(id, roleName, body, kind, author, now, c
     return message;
 }
 export function validateGlobalRoleMessage(message) {
+    validateInboxReceipt(message.inbox);
     if (message.schemaVersion !== 1)
         throw new Error("Global Role Message must use schemaVersion 1.");
     validateGlobalRoleMessageId(message.id);
@@ -517,6 +520,8 @@ export function markGlobalRoleMessageDelivered(message, now, via = "provider") {
  * keeps resolving to this same Message and never creates a second input.
  */
 export function claimGlobalRoleMessageInterruptThen(message, claim) {
+    if (message.inbox !== undefined)
+        throw new Error("Agent inbox handling already owns this Message; it cannot be replayed through interrupt-then.");
     const { inputControl, notDelivered: _priorNondelivery, ...rest } = message;
     const claimed = {
         ...rest,

package/dist/message/messageContinuation.js

@@ -10,6 +10,7 @@ import { validateExactRunReviewRound } from "../lifecycle/exactRunTerminalizatio
 import { sourceRunContextValue } from "../context/sourceRunContext.js";
 import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
 export function resolveMessageRecipient(store, taskId, roleName, scope) {
     if (scope.reviewRoundId !== undefined) {
         const round = store.getReviewRound(taskId, scope.reviewRoundId);
@@ -28,8 +29,11 @@ export function resolveMessageRecipient(store, taskId, roleName, scope) {
         throw new Error("No existing Dispatch owns this Role and work scope.");
     return { roleName, ownerRunId: previous.id, ...scope };
 }
-/** Bounded diagnosis, not automatic ownership repair. */
-export function messageContinuationBlocker(store, message) {
+/** Current Assignment authority, independent of eligibility to start a new Run.
+ * A Reviewer still owns its frozen clarification when Task main advances. */
+export function messageAssignmentBlocker(store, message) {
+    if (isTaskRecordRetired(store.listEvents(message.taskId), "message", message.id))
+        return "message-retired";
     const target = message.recipient;
     if (target?.ownerRunId === undefined)
         return "recipient-assignment-missing";
@@ -78,22 +82,29 @@ export function messageContinuationBlocker(store, message) {
         && latest.inputs[0]?.input.source.channel !== "message-continuation")
         return "assignment-changed";
     if (target.reviewRoundId !== undefined) {
-        const round = store.getReviewRound(message.taskId, target.reviewRoundId);
-        if (round === null)
-            return "review-round-missing";
+        const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });
+        if (validation.disposition !== "applied")
+            return validation.reason ?? "review-candidate-stale";
+    }
+    return undefined;
+}
+/** Starting another Run additionally requires the reviewed candidate to remain current. */
+export function messageContinuationBlocker(store, message) {
+    const invalid = messageAssignmentBlocker(store, message);
+    if (invalid !== undefined)
+        return invalid;
+    const reviewRoundId = message.recipient?.reviewRoundId;
+    if (reviewRoundId !== undefined) {
+        const round = store.getReviewRound(message.taskId, reviewRoundId);
         if (round.scope === "task") {
+            const task = store.getTask(message.taskId);
             if (round.taskCandidate?.projects.some((project) => task.projectBindings.find((binding) => binding.projectId === project.projectId)?.currentCommit !== project.commit)) {
                 return "review-candidate-stale";
             }
         }
-        else {
-            const item = store.getWorkItem(message.taskId, round.workItemId);
-            if (item?.candidates.at(-1)?.id !== round.candidateId)
-                return "review-candidate-stale";
+        else if (store.getWorkItem(message.taskId, round.workItemId)?.candidates.at(-1)?.id !== round.candidateId) {
+            return "review-candidate-stale";
         }
-        const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });
-        if (validation.disposition !== "applied")
-            return validation.reason ?? "review-candidate-stale";
     }
     return undefined;
 }
@@ -189,7 +200,11 @@ export function interruptThenTerminalState(store, message) {
  * remain the pending authority; Mailbox is only the existing scheduling hint.
  * Reserving inputs and creating the next Run is one atomic effect. */
 export function prepareMessageContinuations(store, taskId, now, roleName) {
-    const pending = store.listMessages(taskId).filter((message) => message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined
+    const messages = operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message");
+    const claims = messages.filter(message => message.recipient?.roleName === roleName
+        && message.inbox !== undefined && message.inbox.ack === undefined);
+    const pending = messages.filter((message) => message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined
+        && message.inbox === undefined
         && message.continuation?.runId === undefined
         // A steer targets the exact current native turn, never a queued next Run.
         // If its live attempt did not submit, the message stays saved for the
@@ -197,6 +212,12 @@ export function prepareMessageContinuations(store, taskId, now, roleName) {
         && message.inputControl?.action !== "steer");
     for (const message of pending) {
         const recipient = message.recipient;
+        // Retain ordering within the claimed Assignment, not across unrelated
+        // work owned by the same Role. Only ack or explicit retirement settles a
+        // claim's scheduling obligation; neither time nor a failed Run does.
+        if (claims.some(claim => claim.recipient?.workItemId === recipient.workItemId
+            && claim.recipient?.reviewRoundId === recipient.reviewRoundId))
+            continue;
         const blocker = messageContinuationBlocker(store, message);
         if (blocker !== undefined) {
             markNotDelivered(store, message, blocker);

package/dist/message/taskInboxOwnership.js

@@ -0,0 +1,21 @@
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+export function latestMessageUpdate(store, message) {
+    return store.listEvents(message.taskId).filter(event => event.type === "message.updated" && event.payload.messageId === message.id).at(-1);
+}
+/** Leader steer has no Assignment recipient; ordinary Task records are not
+ * private inbox messages. Queued Leader inputs remain fixed wake windows. */
+export function isLeaderSteer(message) {
+    return message.recipient === undefined && message.inputControl?.action === "steer";
+}
+/** Derive ownership from original receipts, never from disposable mailboxes. */
+export function taskMessageInboxReceipt(store, message) {
+    const revision = latestMessageUpdate(store, message);
+    return message.inbox ?? store.listTaskWakes(message.taskId).find(wake => wake.inbox !== undefined
+        && (revision === undefined || wake.refs?.some(ref => ref.type === "event" && ref.taskId === message.taskId && ref.id === revision.id))
+        && wake.refs?.some(ref => ref.type === "message" && ref.taskId === message.taskId && ref.id === message.id))?.inbox;
+}
+export function unfinishedLeaderInbox(store, taskId) {
+    return store.listTaskWakes(taskId).some(wake => wake.inbox !== undefined && wake.inbox.ack === undefined)
+        || operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message").some(message => isLeaderSteer(message)
+            && message.inbox !== undefined && message.inbox.ack === undefined);
+}