@zq-silk/yui 2.6.0 → 2.7.1

package/README.md

@@ -67,6 +67,29 @@ Native first-run confirmations may still require your input.
 npm install -g @zq-silk/yui
 ```
 
+SQLite is selected lazily before opening your Home: Yui probes a disposable
+in-memory connection with `sqlite-modern` (`better-sqlite3@13.0.3`, N-API) first,
+then tries `sqlite-compat` (`better-sqlite3@10.1.0`) only for identified missing
+native bindings, Node ABI or system-library incompatibility. Each process keeps
+its successful selection. Home permissions, corruption, locks, SQL and migration
+errors never trigger a driver switch. `yui doctor` reports the driver version,
+actual SQLite engine and fallback reason separately from Home health.
+
+The N-API driver avoids the native `ObjectWrap` garbage-collection abort seen
+with the earlier driver on Node 24.19/24.20. It requires Node-API 10;
+runtimes with an older API (including Node 20 and Node 22.9) skip it before
+native loading and use the compatibility candidate. No global Node change
+or Home migration is needed for this dependency correction.
+
+npm attempts **both** fixed optional aliases during installation; it does not
+install the older one only after the newer one fails. This increases download
+size and installation/build time. Optional installation failures may leave npm
+successful, but Yui cannot run without a usable candidate; do not use
+`--omit=optional`. The compatibility driver uses older SQLite (3.46.0), without
+later fixes, and is not guaranteed on every old glibc/toolchain or newer Node
+ABI. The supported Node range above is unchanged; an OS/toolchain upgrade may
+still be necessary. Selection does not downgrade or migrate Home data.
+
 ### 2. Set up, yourself or with an Agent
 
 Run the interactive setup:

package/dist/cli/commandCatalog.js

@@ -190,6 +190,11 @@ const roleChildren = [
     { name: "unbind", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Unbind a dormant Agent from a global Role.", usage: "yui config role unbind <role> <agent-id>" }
 ];
 const globalSessionChildren = [
+    {
+        name: "skills", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment", "global", "unbound"] },
+        summary: "Check current Skill paths, versions and availability for this managed Session without reading bodies.",
+        usage: "yui session skills"
+    },
     { name: "enter", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Enter a global Role's native session.", usage: "yui session enter <role>" },
     {
         name: "context", discovery: { surface: "managed", audiences: ["operator", "global", "unbound"] },
@@ -366,7 +371,7 @@ const taskChildren = [
             }
         ]
     },
-    { name: "reopen", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Explicitly reopen completed or cancelled intent without replaying historical inputs.", usage: "yui task reopen <id>" },
+    { name: "reopen", discovery: { surface: "public", audiences: ["public", "operator", "leader"] }, summary: "Reopen a completed Task without replaying historical inputs; a current Leader is limited to its own Task. Restoring cancelled intent requires user or Operator authority; an independent execution stop is preserved.", usage: "yui task reopen <id>" },
     {
         name: "cancel", discovery: { surface: "public", audiences: ["public", "operator", "leader"] },
         summary: "Stop pursuing a Task without claiming its processes stopped.",
@@ -1128,7 +1133,7 @@ export const ROOT_COMMAND = buildNode({
         { id: "general", title: "General", entries: [
                 "help", "version", "update", "upgrade", "setup", "start", "doctor"
             ] },
-        { id: "workflow", title: "Workflow", entries: ["agent", "operator", "role", "project", "task"] },
+        { id: "workflow", title: "Workflow", entries: ["agent", "operator", "role", "inbox", "project", "task"] },
         { id: "configuration", title: "Configuration", entries: ["config"] },
         { id: "operations", title: "Operations", entries: ["web", "controller", "session", "execution", "capability", "job", "jobs", "telemetry", "release"] },
         { id: "resources", title: "Resources", entries: ["resources"] },
@@ -1154,6 +1159,26 @@ export const ROOT_COMMAND = buildNode({
                     options: catalogCommandOptions(name) }))
             ]
         },
+        {
+            name: "inbox",
+            summary: "Read and explicitly handle the current managed Agent's own inbox.",
+            sections: [{ id: "commands", title: "Commands", entries: ["list", "show", "claim", "ack"] }],
+            children: [
+                { name: "list", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Discover bounded own-address entries without consuming them.",
+                    usage: "yui inbox list [--limit <1..100>] [--cursor <cursor>]", options: ["--limit", "--cursor"] },
+                { name: "show", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Read an exact original or fixed notification window without acknowledgement.",
+                    usage: "yui inbox show <entry> [--cursor <cursor>]", options: ["--cursor"] },
+                { name: "claim", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Reserve 1..16 exact entries for handling in this turn; never starts a model turn.",
+                    usage: "yui inbox claim <entry> [<entry> ...] --request-id <id>", options: ["--request-id"] },
+                { name: "ack", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
+                    summary: "Confirm handling of claimed entries with an auditable disposition, not Provider acceptance.",
+                    usage: "yui inbox ack <entry> [<entry> ...] --request-id <id> --reason <disposition>",
+                    options: ["--request-id", "--reason"] }
+            ]
+        },
         {
             name: "role", discovery: { surface: "public", audiences: ["public", "operator"] },
             summary: "Queue input or control an exact current Global Role Turn.",
@@ -1584,6 +1609,7 @@ export const ROOT_COMMAND = buildNode({
                 "yui session reconcile --report"
             ],
             sections: [
+                { id: "instructions", title: "Managed instructions", entries: ["skills"] },
                 { id: "global", title: "Global Role sessions", entries: ["context", "enter", "record", "replace"] },
                 { id: "maintenance", title: "Maintenance", entries: ["stop"] },
                 { id: "recovery", title: "Recovery", entries: ["reconcile", "retry"] }

package/dist/commands/globalRoleCommands.js

@@ -3,6 +3,9 @@ import { hasManagedIdentity } from "../runtime/managedIdentity.js";
 import { boundedDocument, recordPage, readOptions, readDigest, messageReceipt } from "../output/boundedRead.js";
 import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
+import { globalInputBacklog } from "../message/globalInputBacklog.js";
+import { checkCurrentSkills, SKILL_REUSE_RULE } from "../context/currentSkills.js";
+import { roleSkillIds } from "../context/roleSessionContext.js";
 import { createRoleSessionSet, recordRoleAgentSession } from "../executor/agentExecutor.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { managedGlobalRoleWorkspace } from "../storage/homeLayout.js";
@@ -129,13 +132,21 @@ function roleContext(args, store, options) {
     const effective = resolveEffectiveLaunch({ role, purpose: "execution" });
     const sessions = store.getGlobalRoleSessionSet(name);
     const session = sessions?.sessions[role.activeAgentId];
-    // Only the controlled Endpoint's accepted receipt consumes a queued Message.
+    const currentSkills = checkCurrentSkills(options.yuiHome ?? environment.YUI_HOME, roleSkillIds(session?.effective.context ?? role, role.name === "operator" ? "operator" : "global"));
+    // Native delivery and explicit Agent handling settle the same queued input
+    // through distinct receipts; a context read does neither.
     const messages = store.listGlobalRoleMessages(name);
     const queued = messages.filter((message) => message.delivery === undefined
+        && message.inbox?.ack === undefined
         && message.notDelivered === undefined
         && (message.interruptThen !== undefined || message.inputControl?.action === "queue"));
     const pending = recordPage(queued.map(globalMessageSummary), `global:${name}/messages/pending`, { limit: 8 });
     const recent = recordPage([...messages].reverse().map(globalMessageSummary), `global:${name}/messages/all`, { limit: 8 });
+    const observedAt = new Date();
+    const { oldestAgeMs, ...backlog } = globalInputBacklog(queued, sessions, observedAt, {
+        attention: name === "operator" ? store.getWorkMailbox({ kind: "operator" }) : null,
+        lifecycle: store.getWorkMailbox({ kind: "global-role-runtime", roleName: name })
+    });
     const context = Object.freeze({
         schemaVersion: 1,
         protocol: "yui-managed-context/v1",
@@ -173,7 +184,9 @@ function roleContext(args, store, options) {
         // Reading pending input is neither delivery nor implementation.
         pending,
         recent,
+        backlog,
         reads: {
+            ownInbox: "yui inbox list --json",
             messages: `role message list ${name}`,
             pending: `role message list ${name} --pending`,
             detail: `role message show ${name} <message-id>`
@@ -183,10 +196,16 @@ function roleContext(args, store, options) {
         // Historical interrupt receipts are available through Session inspection;
         // only this Turn's exact identity is required at entry.
         sessionManifestPath: environment.YUI_SESSION_MANIFEST,
+        skillCheckCommand: "yui session skills --json",
+        currentSkills,
+        skillLoadingRule: SKILL_REUSE_RULE,
         skillPackages: session?.effective.skillPackages ?? null,
         cliCommand: "yui"
     });
-    const data = boundedDocument(context, `global:${name}/context`, parsed.cursor);
+    // Elapsed wall-clock time is live display metadata, not a changing source
+    // fact: keep it outside the digest so a long Context remains pageable.
+    const data = { ...boundedDocument(context, `global:${name}/context`, parsed.cursor),
+        backlogObservation: { observedAt: observedAt.toISOString(), oldestAgeMs } };
     return { kind: "output", data, output: [
             `Role Context: ${role.name}`,
             `Scope: global (${context.identity.roleKind})`,
@@ -626,6 +645,7 @@ function globalRoleMessage(args, store, options) {
             if (parsed.positionals.length !== 0)
                 throw usageError("Role message list <role> [--pending] [--limit <n>] [--cursor <cursor>].");
             const selected = pending ? messages.filter(message => message.delivery === undefined
+                && message.inbox?.ack === undefined
                 && message.notDelivered === undefined
                 && (message.interruptThen !== undefined || message.inputControl?.action === "queue")) : [...messages].reverse();
             data = recordPage(selected.map(globalMessageSummary), `global:${name}/messages/${pending ? "pending" : "all"}`, parsed);

package/dist/commands/inboxCommands.js

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

package/dist/commands/roleSkillValidation.js

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

package/dist/commands/taskCommands.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+import { taskMessageInboxReceipt } from "../message/taskInboxOwnership.js";
 import { agentExecutionComponentLabel } from "../agent/executionComponents.js";
 import { assertLeaderArchiveAdmission } from "../task/leaderArchiveAuthority.js";
 import { createRun, runExecutionObservation, runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
@@ -1631,9 +1632,25 @@ function taskMessageCommand(args, store, options) {
         const message = store.transaction((tx) => {
             assertTaskDeliveryAuthority(tx, options.environment, ref.taskId);
             const current = tx.listMessages(ref.taskId).find((entry) => entry.id === ref.localId);
-            if (current?.recipient?.ownerRunId === undefined || current.continuation?.runId !== undefined) {
+            if (current?.inbox?.ack !== undefined || current?.recipient?.ownerRunId === undefined || current.continuation?.runId !== undefined) {
                 throw usageError("Only an unassigned pending Message can be explicitly handed off.");
             }
+            if (current.inbox !== undefined) {
+                const actor = current.inbox.claim.actor;
+                for (const runId of new Set([actor.runId, current.recipient.ownerRunId])) {
+                    const handler = runId === undefined ? null : tx.getRun(ref.taskId, runId);
+                    const observation = handler === null ? undefined : runExecutionObservation(handler, tx.getTaskRoleSessionSet(ref.taskId, handler.roleName)?.providerBinding, tx.listEvents(ref.taskId));
+                    if (handler === null || handler.status === "active"
+                        || handler.result?.failureReason === "delivery-unknown"
+                        || handler.result?.provider === undefined
+                        || runId === actor.runId && handler.result.provider.conversationId !== actor.nativeSessionId
+                        || !["completed", "failed", "cancelled"].includes(observation?.delivery ?? "")) {
+                        throw usageError("The original and current inbox handlers must have exact stopped native execution before explicit handoff.");
+                    }
+                }
+                // Preserve the original claim: the new authorized Assignment must
+                // inspect prior effects and ack explicitly, never auto-replay the input.
+            }
             const recipient = resolveMessageRecipient(tx, ref.taskId, requiredOption(parsed.options, "--to"), {
                 ...(current.recipient.workItemId === undefined ? {} : { workItemId: current.recipient.workItemId }),
                 ...(current.recipient.reviewRoundId === undefined ? {} : { reviewRoundId: current.recipient.reviewRoundId })
@@ -1853,15 +1870,23 @@ function steerTaskInput(taskId, input, store, options) {
     // and idempotent, so the Host's later settlement fold promotes it to a proven
     // terminal and never rewinds it. An idempotent replay above already returned
     // the saved Message, so this records the attempt exactly once.
-    store.transaction((tx) => {
+    const admitted = store.transaction((tx) => {
         const saved = tx.listMessages(result.task.id).find((entry) => entry.id === result.message.id);
         const requestId = saved?.inputControl?.requestId;
-        if (saved === undefined || requestId === undefined)
-            return;
+        // The recipient may claim between Message persistence and control
+        // admission. A Leader window owns its referenced originals even after ack;
+        // never re-submit them through a delayed steer.
+        if (saved === undefined || requestId === undefined || taskMessageInboxReceipt(tx, saved) !== undefined)
+            return false;
         tx.updateMessage(result.task.id, recordTaskMessageControlOutcome(saved, {
             requestId, receiptId, outcome: "pending", observedAt: clock(options)
         }));
+        return true;
     });
+    if (!admitted) {
+        return output(`Steer message ${result.message.id} saved but not delivered (TARGET_CHANGED: inbox handling owns the input).\n`, { taskId: result.task.id, message: messageReceipt(result.message),
+            steer: { state: "not-steered", code: "TARGET_CHANGED", detail: "Inbox handling already owns the original input." } });
+    }
     return {
         kind: "input-steer",
         taskId: result.task.id,
@@ -2407,6 +2432,9 @@ function registerInterruptThen(store, taskId, roleName, thenMessageRef, target,
     }
     // A Message that already delivered, or was already ruled undeliverable, is not
     // a fresh input to reuse; reusing it would replay or resurrect a settled fact.
+    if (taskMessageInboxReceipt(store, message) !== undefined) {
+        return { code: "TARGET_CHANGED", detail: `Message ${thenMessageRef} is owned by active inbox handling.` };
+    }
     if (message.continuation?.runId !== undefined) {
         return { code: "TARGET_CHANGED", detail: `Message ${thenMessageRef} was already delivered by ${message.continuation.runId}.` };
     }