@zq-silk/yui 2.9.0 → 2.10.0

package/dist/controlPlaneCli.js

@@ -168,8 +168,6 @@ export async function main() {
     const discovery = discoveryCommandTree(process.env);
     invocationHome = home;
     const routedForFence = args.length === 0 ? undefined : routeInvocation(args);
-    const managedInvocation = process.env.YUI_SESSION_SCOPE === "task"
-        || process.env.YUI_SESSION_SCOPE === "global";
     const homeFreeInvocation = args.length === 0
         || (args[0] === "config" && (args[1] === "describe"
             || (args[1] === "completion" && args[2] === "candidates")))
@@ -679,29 +677,46 @@ export async function main() {
         });
         const workspaceCoordinator = new TaskWorkspaceCoordinator(store, workspacePreparer, runtime);
         if (resolved[0] === "web") {
-            if (managedInvocation || process.env.YUI_ROLE || process.env.YUI_NATIVE_SESSION_ID) {
-                throw usageError("The Web user ingress must be started from a local user terminal, not a managed Session.");
-            }
+            if (hasManagedIdentity(process.env)) {
+                const current = requireManagedCaller(store, process.env);
+                if (current.scope !== "global" || current.roleName !== "operator") {
+                    throw usageError("Only a local user or the current global Operator may manage Web listeners.");
+                }
+            }
+            const caller = resolveJobCaller(process.env, "");
+            const describe = (status) => status
+                ? `Web listener: ${status.state}\n`
+                    + (status.alreadyRunning ? "Existing listener reused; credentials were not reloaded.\n" : "")
+                    + (status.authentication === "basic" ? "Browser authentication: username yui; use the password from your private credential file.\n" : "")
+                    + (status.urls ?? []).map(url => `Yui web control room: ${url}\n`).join("")
+                    + (status.warnings ?? []).map(warning => `Warning: ${warning}\n`).join("")
+                : "Web is not running. Start it explicitly; Controller recovery does not restore listeners.\n";
             if (resolved.length === 2 && (resolved[1] === "--status" || resolved[1] === "--stop")) {
-                const status = await callController(home, "web.status", {});
+                const status = await callController(home, "web.status", { caller });
                 if (resolved[1] === "--status")
-                    emit(status ? `Yui web control room: ${status.url}\n` : "Web is not running.\n", false, status);
+                    emit(describe(status), false, status);
                 else {
-                    if (status)
-                        await callController(home, "web.stop", { id: status.id });
-                    emit("Web listener stopped; Controller and Agents are unchanged.\n");
+                    if (status && !status.id)
+                        throw usageError("Web listener is starting; query status before stopping.");
+                    const result = status ? await callController(home, "web.stop", { id: status.id, caller }) : { stopped: false };
+                    emit("Web listener stopped or already absent; Controller and Agents are unchanged.\n", false, result);
                 }
                 return;
             }
-            if (jsonOutput)
-                throw usageError("Web start does not support --json; use --status.");
-            const options = parseWebCommandOptions(resolved.slice(1));
+            const detached = jsonOutput || caller.scope === "global" || resolved.includes("--detach");
+            const options = parseWebCommandOptions(resolved.slice(1).filter(arg => arg !== "--detach"));
             const id = randomUUID();
-            await callController(home, "web.start", { ...options, id });
-            const displayHost = options.host === "::1" ? "[::1]" : options.host;
-            process.stdout.write(`Yui web control room: http://${displayHost}:${options.port}\n`);
+            const status = await callController(home, "web.start", { ...options, id, caller });
+            emit(describe(status), false, status);
+            if (detached || status.alreadyRunning)
+                return;
             await new Promise((resolve) => {
+                // The Controller owns the listening socket, so this CLI otherwise has
+                // no referenced handle: a Promise/signal handler alone does not keep
+                // Node alive for the foreground user's Ctrl-C.
+                const keepAlive = setInterval(() => { }, 60_000);
                 const stop = () => {
+                    clearInterval(keepAlive);
                     process.off("SIGINT", stop);
                     process.off("SIGTERM", stop);
                     resolve();
@@ -709,7 +724,7 @@ export async function main() {
                 process.once("SIGINT", stop);
                 process.once("SIGTERM", stop);
             });
-            await callController(home, "web.stop", { id });
+            await callController(home, "web.stop", { id, caller });
             return;
         }
         if (resolved[0] === "config") {

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { deliveredMessageWake, pinMessageRevisions, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
+import { nonReplayableMessageWake, pinMessageRevisions, 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 +30,7 @@ import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
 import { standardAgentError } from "../runtime/agentError.js";
 import { recordTaskAgentError } from "./taskAgentError.js";
 import { recordGlobalRuntimeAttention, recordGlobalRuntimeFailure, recordGlobalRuntimeRecovery } from "./globalRuntimeAttention.js";
+import { checkInboxTurn } from "./inboxTurnCheck.js";
 import { queueOperatorNotification } from "./operatorNotification.js";
 import { claimOperatorAttention } from "../scheduler/operatorEvent.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
@@ -466,7 +467,7 @@ export class FileSchedulerStoreAdapter {
                     const outcome = input.kind === "input.accepted" ? "accepted"
                         : input.kind === "input.rejected" ? "rejected" : "delivery-unknown";
                     if (message.control?.outcome !== "accepted" && message.control?.outcome !== "rejected") {
-                        const updated = { ...message, control: { requestId: message.inputControl.requestId,
+                        const updated = { ...message, control: { ...message.control, requestId: message.inputControl.requestId,
                                 receiptId: receipt, outcome, observedAt: at } };
                         store.updateGlobalRoleMessage(outcome === "accepted"
                             ? markGlobalRoleMessageDelivered(updated, new Date(at)) : updated);
@@ -490,6 +491,10 @@ export class FileSchedulerStoreAdapter {
             }
             store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, binding, now));
             settleGlobalRetryInput(store, fence.roleName, binding, now);
+            if (["turn.completed", "turn.failed", "turn.cancelled"].includes(input.kind)) {
+                checkInboxTurn(store, { scope: "global", roleName: fence.roleName, agentId: fence.agentId,
+                    nativeSessionId: fence.nativeSessionId }, binding.run, now);
+            }
             if (input.kind === "turn.failed" && matches && input.payload.failure !== undefined
                 && !providerRetryPending(binding)) {
                 recordGlobalRuntimeAttention(store, fence.roleName, input.eventId, {
@@ -1157,8 +1162,7 @@ export class FileSchedulerStoreAdapter {
                     throw new AgentHostProviderSessionBusyError("The next Global input belongs to an explicit then handoff.");
                 }
                 if (message !== undefined) {
-                    if (store.queryGlobalRoleMessages(input.roleName, { handling: true, limit: 0 }).count > 0
-                        || message.inbox !== undefined || message.delivery !== undefined || message.notDelivered !== undefined
+                    if (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) {
@@ -1687,12 +1691,24 @@ export class FileSchedulerStoreAdapter {
                     store.saveTaskRoleSessionSet(selectNewTaskRoleSession(set, set.activeAgentId, now));
                 const event = createTaskEvent(store.nextEventId(owner.taskId), owner.taskId, "runtime.session-replaced", { roleName: owner.roleName }, now);
                 store.saveEvent(owner.taskId, event);
-                // Accepted notification batches are already consumed; unresolved old
-                // claims belong to the discarded runtime, not to its successor.
+                // Release only operational occupancy after exact runtime stop. Neither
+                // an uncertain automatic submission nor an Agent's handling claim may
+                // be replayed as input to the replacement.
                 const leaderTarget = { kind: "role", taskId: owner.taskId, roleName: "leader" };
                 const leaderMailbox = store.getWorkMailbox(leaderTarget);
-                if (owner.roleName === "leader" && leaderMailbox?.processing?.owner.startsWith("leader-notification:")) {
-                    store.saveWorkMailbox(releaseProcessing(leaderMailbox, leaderMailbox.processing.batchId));
+                if (owner.roleName === "leader" && leaderMailbox?.processing != null) {
+                    const processing = leaderMailbox.processing;
+                    if (processing.owner.startsWith("leader-notification:")) {
+                        store.saveEvent(owner.taskId, createTaskEvent(store.nextEventId(owner.taskId), owner.taskId, "notification.resolved", {
+                            wakeId: processing.owner.slice("leader-notification:".length), attemptId: processing.batchId,
+                            reason: "Session replacement after verified native/resource stop; inspect original effects.",
+                            outcome: "released-without-replay"
+                        }, now));
+                        store.saveWorkMailbox(completeProcessing(leaderMailbox, processing.batchId));
+                    }
+                    else if (processing.owner.startsWith("agent-inbox:")) {
+                        store.saveWorkMailbox(completeProcessing(leaderMailbox, processing.batchId));
+                    }
                 }
                 enqueueWork(store, leaderTarget, "session-replaced", now, [{ type: "event", taskId: owner.taskId, id: event.id }]);
             }
@@ -1839,6 +1855,24 @@ export class FileSchedulerStoreAdapter {
             if (mailbox === null)
                 return null;
             const provider = store.getTaskRoleSessionSet(taskId, "leader")?.providerBinding?.run;
+            // Only a committed lifecycle event opens this initialization path, not a
+            // caller-supplied reason string. Consume that event once, separately from
+            // business input. It exists only after exact-owner cleanup completed.
+            const recoveryRefs = mailbox.pending?.reasons.includes("session-replaced")
+                ? mailbox.pending.refs.filter(ref => {
+                    if (ref.type !== "event" || ref.taskId !== taskId)
+                        return false;
+                    const event = store.queryContextRecords(taskId, { family: "task-event", ids: [ref.id],
+                        eventTypes: ["runtime.session-replaced"], limit: 1 }).records[0]?.value;
+                    return event?.payload.roleName === "leader";
+                }) : [];
+            // Valid earlier storage may retain an actively claimed mailbox even
+            // after replacement completed. Its durable wake/claim remains untouched.
+            if (recoveryRefs.length > 0 && mailbox.processing?.owner.startsWith("agent-inbox:")
+                && !(provider && ["submitting", "accepted", "delivery-unknown"].includes(provider.status))) {
+                mailbox = completeProcessing(mailbox, mailbox.processing.batchId);
+                store.saveWorkMailbox(mailbox);
+            }
             const processing = mailbox.processing;
             if (processing !== null) {
                 if (!processing.owner.startsWith("leader-notification:"))
@@ -1882,7 +1916,7 @@ export class FileSchedulerStoreAdapter {
                 return { wakeId, attemptId: nextAttempt, disposition: "submit",
                     presentation: taskNotificationPresentation(wake, store) };
             }
-            if (unfinishedLeaderInbox(store, taskId))
+            if (unfinishedLeaderInbox(store, taskId) && recoveryRefs.length === 0)
                 return null;
             if (mailbox.pending === null || (provider !== null && provider !== undefined
                 && ["submitting", "accepted", "delivery-unknown"].includes(provider.status)))
@@ -1895,7 +1929,7 @@ export class FileSchedulerStoreAdapter {
             const obsoleteIds = new Set();
             for (const message of store.listMessages(taskId)) {
                 if (pendingMessageIds.has(message.id) && (taskMessageInboxReceipt(store, message) !== undefined
-                    || deliveredMessageWake(store, message) !== undefined)) {
+                    || nonReplayableMessageWake(store, message) !== undefined)) {
                     obsoleteIds.add(message.id);
                 }
             }
@@ -1930,21 +1964,23 @@ export class FileSchedulerStoreAdapter {
             const handoffs = claimedMessages.filter(message => !obsoleteIds.has(message.id));
             // A quiet/new Session is not evidence that the claimed old Turn stopped.
             // Keep the exact pending intent until the original fence is provable.
-            if (handoffs.some((message) => interruptThenTerminalState(store, message) !== "ready"))
+            if (recoveryRefs.length === 0
+                && handoffs.some((message) => interruptThenTerminalState(store, message) !== "ready"))
                 return null;
             const handoffIds = new Set(handoffs.map((message) => message.id));
             if (availableRefs.length === 0 && obsoleteIds.size > 0) {
                 store.saveWorkMailbox(consumePendingBatch(mailbox, pending));
                 return null;
             }
-            const selectedRefs = handoffs.length === 0 ? availableRefs
+            const selectedRefs = recoveryRefs.length > 0 ? recoveryRefs : handoffs.length === 0 ? availableRefs
                 : availableRefs.filter((ref) => ref.type === "message" && handoffIds.has(ref.id));
-            const remainingRefs = handoffs.length === 0 ? []
-                : availableRefs.filter((ref) => !(ref.type === "message" && handoffIds.has(ref.id)));
+            const remainingRefs = recoveryRefs.length > 0 ? availableRefs.filter(ref => !recoveryRefs.includes(ref))
+                : handoffs.length === 0 ? []
+                    : availableRefs.filter((ref) => !(ref.type === "message" && handoffIds.has(ref.id)));
             const latest = latestTaskWake(store.listTaskWakes(taskId));
             const wakeId = store.nextTaskWakeId(taskId);
             const wake = createTaskWake({
-                id: wakeId, taskId, reasons: mailbox.pending.reasons,
+                id: wakeId, taskId, reasons: recoveryRefs.length > 0 ? ["session-replaced"] : mailbox.pending.reasons,
                 refs: pinMessageRevisions(store, taskId, selectedRefs),
                 fromCursor: latest?.toCursor ?? task.createdAt,
                 toCursor: new Date(Math.max(now.getTime(), Date.parse(mailbox.pending.lastQueuedAt))).toISOString(), now
@@ -2231,6 +2267,8 @@ export class FileSchedulerStoreAdapter {
                     }
                     sessions = settleStructuredProviderTurn(sessions, canonicalRunId, input.providerStatus, now, attemptId);
                     store.saveTaskRoleSessionSet(sessions);
+                    checkInboxTurn(store, { scope: "task", taskId: input.taskId, roleName: input.roleName,
+                        agentId: input.agentId, nativeSessionId: input.nativeSessionId }, sessions.providerBinding?.run, now);
                 }
                 if (input.observation !== undefined)
                     this.persistRuntimeObservation(input.observation, now);
@@ -2336,6 +2374,8 @@ export class FileSchedulerStoreAdapter {
             }
             if (input.observation !== undefined)
                 this.persistRuntimeObservation(input.observation, now);
+            checkInboxTurn(store, { scope: "task", taskId: input.taskId, roleName: input.roleName,
+                agentId: input.agentId, nativeSessionId: input.nativeSessionId }, sessions.providerBinding?.run, now);
             return {
                 session: sessions.sessions[input.agentId],
                 duplicate: false,
@@ -2822,6 +2862,10 @@ export class FileSchedulerStoreAdapter {
             // durable native terminal recorded just above remains the proof of record.
             current = settleGlobalRoleRuntimeTurn(current, input.nativeTurnId, input.providerStatus, now);
             store.saveGlobalRoleSessionSet(current);
+            if (current.providerBinding?.run?.nativeTurnId === input.nativeTurnId) {
+                checkInboxTurn(store, { scope: "global", roleName: input.roleName,
+                    agentId: input.agentId, nativeSessionId }, current.providerBinding.run, now);
+            }
             if (input.roleName === SYSTEM_OPERATOR_ROLE
                 && input.adapterId === "codex"
                 && completedStatus === "active") {

package/dist/controller/globalInputDelivery.js

@@ -6,11 +6,12 @@ import { providerRetryPending } from "../runtime/providerRetry.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { globalMessagePresentation } from "../interaction/notificationPresentation.js";
 import { recordGlobalRuntimeAttention, recordGlobalRuntimeRecovery } from "./globalRuntimeAttention.js";
+import { globalInboxRecovery } from "../message/globalInboxRecovery.js";
 /** Messages are the only queue. Host's atomic begin arbitrates native writers. */
 export async function deliverGlobalInputs(home, store, ensure, onError, options = {}) {
     for (const role of store.listGlobalRoles()) {
         try {
-            let pending = store.queryGlobalRoleMessages(role.name, { pending: true, limit: 64 }).messages;
+            let pending = store.queryGlobalRoleMessages(role.name, { pending: true, unclaimed: true, limit: 64 }).messages;
             if (hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName: role.name }))))
                 continue;
             let sessions = store.getGlobalRoleSessionSet(role.name);
@@ -20,7 +21,7 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
                 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.queryGlobalRoleMessages(role.name, { pending: true, limit: 64 }).messages;
+                pending = store.queryGlobalRoleMessages(role.name, { pending: true, unclaimed: true, limit: 64 }).messages;
                 if (pending.length === 0)
                     continue;
             }
@@ -84,12 +85,13 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
                     || providerRetryPending(sessions?.providerBinding)
                     || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName: role.name }))))
                     continue;
-                pending = store.queryGlobalRoleMessages(role.name, { pending: true, limit: 64 }).messages;
+                pending = store.queryGlobalRoleMessages(role.name, { pending: true, unclaimed: true, limit: 64 }).messages;
                 if (pending.length === 0)
                     continue;
             }
-            if (store.queryGlobalRoleMessages(role.name, { handling: true, limit: 0 }).count > 0)
-                continue;
+            const recovery = globalInboxRecovery(store, role.name, options.now ?? new Date());
+            const recovering = recovery !== undefined && recovery.inbox === undefined && recovery.delivery === undefined
+                && recovery.notDelivered === undefined && recovery.control === undefined;
             // Interrupt-then reserves the next legal slot even behind a large queue.
             const reservedPage = store.queryGlobalRoleMessages(role.name, {
                 pending: true, interruptThen: true, limit: 64
@@ -106,7 +108,7 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
                 store.updateGlobalRoleMessage(markGlobalRoleMessageNotDelivered(message, "native-session-or-authority-changed", new Date()));
             const obsoleteIds = new Set(obsolete.map(message => message.id));
             pending = pending.filter(message => !obsoleteIds.has(message.id));
-            if (pending.length === 0)
+            if (pending.length === 0 && !recovering)
                 continue;
             if (reservedPage.count > reserved.length && obsolete.length === reserved.length)
                 continue;
@@ -117,7 +119,15 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
                     && sessions.sessions[message.deliveryTarget.agentId]?.nativeSessionId === message.deliveryTarget.nativeSessionId;
             const claims = reserved.filter(message => !obsolete.includes(message));
             let next;
-            if (claims.length > 0) {
+            if (recovering) {
+                // The notice carries no original business input. An obsolete then
+                // target is never inherited; a current explicit reservation still
+                // owns its slot. Host admission checks this again atomically.
+                if (claims.length > 0)
+                    continue;
+                next = recovery;
+            }
+            else if (claims.length > 0) {
                 next = claims.find(message => {
                     const claim = message.interruptThen;
                     const binding = sessions?.providerBinding;

package/dist/controller/inboxTurnCheck.js

@@ -0,0 +1,64 @@
+import { createGlobalRoleMessage } from "../message/message.js";
+import { INBOX_CHECK_PREFIX, INBOX_CHECK_REASON, missingTurnHandling } from "../message/inboxTurn.js";
+import { readDigest } from "../output/boundedRead.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
+import { completeProcessing } from "../coordination/workMailbox.js";
+/** Called inside exact-terminal persistence's transaction. A terminal checks
+ * receipts; it cannot infer a disposition. One existing notification per exact
+ * turn, no timer, retry queue, automatic ACK or reminder-of-reminder loop. */
+export function checkInboxTurn(store, actor, turn, now) {
+    if (!turn || !["completed", "failed", "cancelled"].includes(turn.status))
+        return;
+    const retired = actor.scope === "task" ? retiredTaskRecordIds(store.listEvents(actor.taskId), "message") : new Set();
+    const entries = actor.scope === "global" ? store.listGlobalRoleMessages(actor.roleName)
+        : [...(actor.roleName === "leader" ? store.listTaskWakes(actor.taskId) : []),
+            ...store.listMessages(actor.taskId).filter(message => !retired.has(message.id))];
+    const missing = missingTurnHandling(entries, actor, turn);
+    if (actor.scope === "task" && actor.roleName === "leader") {
+        const mailbox = store.getWorkMailbox({ kind: "role", taskId: actor.taskId, roleName: "leader" });
+        // End the exact active-consumption notification reservation only. Its
+        // original claim remains unfinished and discoverable; no writer is freed
+        // here (the caller already persisted an exact native terminal).
+        if (mailbox?.processing && entries.some(entry => entry.inbox?.claim.actor.attemptId === turn.attemptId
+            && entry.inbox.claim.actor.nativeSessionId === actor.nativeSessionId
+            && entry.inbox.claim.actor.agentId === actor.agentId
+            && mailbox.processing?.owner === `agent-inbox:${entry.id}`
+            && mailbox.processing.batchId === `inbox:${entry.id}`)) {
+            store.saveWorkMailbox(completeProcessing(mailbox, mailbox.processing.batchId));
+        }
+    }
+    if (!missing.length)
+        return;
+    const requestId = INBOX_CHECK_PREFIX + readDigest([actor.scope, actor.taskId, actor.roleName,
+        actor.agentId, actor.nativeSessionId, turn.attemptId]);
+    const facts = {
+        roleName: actor.roleName, nativeSessionId: actor.nativeSessionId, attemptId: turn.attemptId,
+        status: turn.status, count: String(missing.length), entries: missing.slice(0, 16).map(entry => entry.id).join(","),
+        read: actor.scope === "global" || actor.roleName === "leader" ? "yui inbox list --view history --json"
+            : `yui task message show ${actor.taskId}/${missing[0].id} --json`,
+        disposition: "Missing handling evidence, not unexecuted work. Read originals and prior effects; explicitly ack or retire within authority. Never replay external effects."
+    };
+    if (actor.scope === "global") {
+        if (store.queryGlobalRoleMessages(actor.roleName, { requestId, limit: 1 }).count)
+            return;
+        const notice = createGlobalRoleMessage(store.nextGlobalRoleMessageId(), actor.roleName, `Yui-Summary: ${missing.length} input(s) lack handling receipts after an exact native terminal.\n`
+            + JSON.stringify(facts), "system", { type: "system" }, now, { inputControl: { action: "queue", requestId } });
+        // Retain the original target: replacing a Session is not permission to
+        // replay this reminder elsewhere. Successors can inspect history explicitly.
+        store.saveGlobalRoleMessage({ ...notice,
+            deliveryTarget: { agentId: actor.agentId, nativeSessionId: actor.nativeSessionId } });
+    }
+    else {
+        if (store.listEvents(actor.taskId).some(event => event.type === INBOX_CHECK_REASON
+            && event.payload.requestId === requestId))
+            return;
+        const event = createTaskEvent(store.nextEventId(actor.taskId), actor.taskId, INBOX_CHECK_REASON, { ...facts, requestId }, now);
+        store.saveEvent(actor.taskId, event);
+        const task = store.getTask(actor.taskId);
+        if (task && ["active", "draft"].includes(task.status) && task.executionGate.state === "enabled") {
+            enqueueWork(store, { kind: "role", taskId: actor.taskId, roleName: "leader" }, INBOX_CHECK_REASON, now, [{ type: "event", taskId: actor.taskId, id: event.id }], { source: "inbox-check", dedupeKey: requestId });
+        }
+    }
+}

package/dist/controller/providerRetryAdmission.js

@@ -2,6 +2,7 @@ import { admitProviderRetry, cancelProviderRetry, providerRetryAttemptId, provid
 import { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { isDeepStrictEqual } from "node:util";
+import { isHandlingReminder } from "../message/inboxTurn.js";
 export function ownedProviderInput(input) {
     if (input.runId !== undefined && input.taskId !== undefined) {
         return { kind: "run", taskId: input.taskId, runId: input.runId };
@@ -26,6 +27,7 @@ export function retryIntentBlocker(store, input, retry) {
             return "role-configuration-changed";
         if (store.listGlobalRoleMessages(input.roleName).some(message => (message.kind === "user" || message.kind === "operator"
             || message.inputControl !== undefined || message.interruptThen !== undefined)
+            && !isHandlingReminder(message)
             && Date.parse(message.createdAt) > Date.parse(retry.intentAt)
             && message.delivery === undefined && message.notDelivered === undefined))
             return "new-user-input";

package/dist/external/gitlabPublicationVerifier.js

@@ -1,5 +1,6 @@
 import { createExecFileCommandRunner, createPinnedCommandRunner } from "./pinnedCommandRunner.js";
 import { redactLaunchText } from "../runtime/launchDiagnostics.js";
+import { canonicalPublicationUrl } from "../task/publicationToolObservation.js";
 const GIT_COMMIT = /^[0-9a-f]{40}$/iu;
 const GITLAB_REPOSITORY = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+$/u;
 const MAX_FAILURE_DETAIL_CHARS = 4_000;
@@ -64,8 +65,13 @@ export function parseGitLabMergeRequest(stdout, repository, externalId, expected
     }
     const externalUrl = optionalText(record.web_url);
     assertGitLabReference(record.references, repository, externalId);
-    if (externalUrl !== undefined && expectedHost !== undefined) {
-        assertGitLabWebUrl(externalUrl, expectedHost, repository, externalId);
+    if (externalUrl !== undefined) {
+        const url = new URL(canonicalPublicationUrl(externalUrl));
+        // references.full and iid establish identity; web_url is a browser link,
+        // not a repository/MR path schema. The command also checks the candidate URL.
+        if (expectedHost !== undefined && url.host.toLowerCase() !== expectedHost.toLowerCase()) {
+            throw new Error(`GitLab MR web URL does not match service ${expectedHost}.`);
+        }
     }
     const mergedAt = optionalText(record.merged_at);
     return {
@@ -103,21 +109,6 @@ function assertGitLabReference(value, repository, externalId) {
             + `${repository}!${externalId}.`);
     }
 }
-function assertGitLabWebUrl(value, expectedHost, repository, externalId) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        throw new Error("GitLab MR web URL is invalid.");
-    }
-    const expectedSuffix = `/${repository}/-/merge_requests/${externalId}`;
-    if ((url.protocol !== "https:" && url.protocol !== "http:")
-        || url.host.toLowerCase() !== expectedHost.toLowerCase()
-        || !url.pathname.endsWith(expectedSuffix)) {
-        throw new Error(`GitLab MR web URL does not match ${expectedHost}/${repository}!${externalId}.`);
-    }
-}
 function firstCommit(...values) {
     for (const value of values) {
         if (value === null || value === undefined || value === "")
@@ -140,17 +131,8 @@ function optionalText(value) {
 function gitLabHostname(externalUrl) {
     if (externalUrl === undefined)
         return undefined;
-    let url;
-    try {
-        url = new URL(externalUrl);
-    }
-    catch {
-        throw new Error(`GitLab external URL is invalid: ${externalUrl}.`);
-    }
-    if (url.protocol !== "https:" && url.protocol !== "http:") {
-        throw new Error(`GitLab external URL protocol is invalid: ${url.protocol}.`);
-    }
-    return url.hostname === "gitlab.com" ? undefined : url.host;
+    const url = new URL(canonicalPublicationUrl(externalUrl));
+    return url.host === "gitlab.com" ? undefined : url.host;
 }
 function boundedFailureDetail(value) {
     return value.length <= MAX_FAILURE_DETAIL_CHARS

package/dist/grant/taskAuthorization.js

@@ -13,6 +13,12 @@ export function taskAuthorizationSource(store, taskId, environment, messageId, p
         || task.executionGate?.state === "stopped") {
         throw usageError("Task authorization is unavailable in this lifecycle or execution gate.");
     }
+    return { ...readTaskAuthorizationMessage(store, taskId, messageId, purpose),
+        nativeSessionId: caller.nativeSessionId };
+}
+/** Shared source binding; interpreting the quoted authority remains the caller's
+ * responsibility. A matching quote proves provenance, not semantic permission. */
+export function readTaskAuthorizationMessage(store, taskId, messageId, purpose) {
     const message = store.listMessages(taskId).find(entry => entry.id === messageId);
     if (!message || !((message.kind === "user" && message.author.type === "user")
         || (message.kind === "operator" && message.author.type === "operator"))) {
@@ -29,8 +35,7 @@ export function taskAuthorizationSource(store, taskId, environment, messageId, p
             taskId: message.taskId, id: message.id, kind: message.kind,
             author: message.author, body: message.body, createdAt: message.createdAt
         })).digest("hex"),
-        purpose: purpose.trim(),
-        nativeSessionId: caller.nativeSessionId
+        purpose: purpose.trim()
     };
 }
 const RELEASE_ACTIONS = new Set([

package/dist/interaction/notificationPresentation.js

@@ -69,6 +69,13 @@ 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`,
+        `Handling: claim exact inbox entry ${wake.id}; after disposition, ack it with a concrete reason before ending this turn.`,
+        "Use yui inbox list --view current --json for current inputs. Historical missing receipts are not new work; never replay effects to repair an ACK.",
+        ...(wake.reasons.includes("session-replaced") ? [
+            "Session replacement is initialization, not replay or completion of earlier input.",
+            "Read yui inbox list --view history --json; inspect retained originals, prior effects and current authority before explicit settlement.",
+            "Preserve original claims and delivery targets. Unknown external effects require evidence, not another execution."
+        ] : []),
         "Check current Skills each turn: yui session skills --json. Apply current yui-leader; read relevant originals in full and advance authorized work."
     ].join("\n");
 }
@@ -80,6 +87,8 @@ 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`,
+        `Handling: claim exact inbox entry ${messageId}; after disposition, ack it with a concrete reason before ending this turn.`,
+        "Routing to a Task or asking a necessary user question can settle this input without completing the Task. Missing ACK is not permission to repeat effects.",
         `The Global loadCommand checks current Skill versions each turn. Apply current ${roleName === "operator" ? "yui-operator" : "yui-runtime"} within existing authority.`
     ].join("\n");
 }

package/dist/message/globalInboxRecovery.js

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+import { createGlobalRoleMessage } from "./message.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
+import { INBOX_CHECK_PREFIX } from "./inboxTurn.js";
+const requestId = (agentId, nativeSessionId) => `${INBOX_CHECK_PREFIX}recovery:${createHash("sha256").update(JSON.stringify([agentId, nativeSessionId])).digest("hex")}`;
+/** Derive a single initialization notice from existing retained claims. New
+ * Sessions are created only by the existing authorized lifecycle path. A
+ * restart can finish notice creation, but cannot select or replace a Session. */
+export function globalInboxRecovery(store, roleName, now) {
+    return store.transaction(tx => {
+        const sessions = tx.getGlobalRoleSessionSet(roleName);
+        const session = sessions?.sessions[sessions.activeAgentId];
+        const binding = sessions?.providerBinding;
+        if (!session || session.status !== "active" || !session.nativeSessionId || !binding
+            || binding.authority.owner !== "controller"
+            || currentProviderConversation(binding).conversationId !== session.nativeSessionId
+            || binding.run && ["submitting", "accepted", "delivery-unknown"].includes(binding.run.status)
+            || hasRuntimeCleanupObligation(tx.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName }))))
+            return;
+        if (tx.queryGlobalRoleMessages(roleName, { handling: true, handlingExceptSession: {
+                agentId: session.agentId, nativeSessionId: session.nativeSessionId
+            }, limit: 0 }).count === 0)
+            return;
+        const id = requestId(session.agentId, session.nativeSessionId);
+        const existing = tx.queryGlobalRoleMessages(roleName, { requestId: id, limit: 1 }).messages[0];
+        if (existing)
+            return existing;
+        const notice = {
+            ...createGlobalRoleMessage(tx.nextGlobalRoleMessageId(), roleName, [
+                "Yui-Summary: This successor has retained inbox handling obligations; inspect original evidence before settlement.",
+                "Read current Session Context and yui inbox list --view history --json. Read the exact original, original claim and prior effects.",
+                "This is initialization only: do not replay old input, retarget its delivery, or infer business completion.",
+                "After handling under current authority, explicitly acknowledge the original entry without replacing its claim.",
+                "Uncertain external effects require verification or a real user decision. New queued input remains separate."
+            ].join("\n"), "system", { type: "system" }, now, {
+                inputControl: { action: "queue", requestId: id, expectedSessionId: session.nativeSessionId }
+            }),
+            deliveryTarget: { agentId: session.agentId, nativeSessionId: session.nativeSessionId }
+        };
+        tx.saveGlobalRoleMessage(notice);
+        return notice;
+    });
+}

package/dist/message/globalInterrupt.js

@@ -11,7 +11,7 @@ export function recordGlobalSteerResult(store, roleName, messageId, receipt) {
         const now = new Date();
         const outcome = receipt.state === "steered" ? "accepted"
             : receipt.state === "steer-unknown" ? "delivery-unknown" : "rejected";
-        const updated = { ...message, control: {
+        const updated = { ...message, control: { ...message.control,
                 requestId: source.requestId, receiptId: `steer:${roleName}/${messageId}`,
                 outcome, observedAt: now.toISOString()
             } };