@zq-silk/yui 2.9.0 → 2.10.0

package/README.md

@@ -30,7 +30,7 @@ not from terminal windows you juggle or details you have to remember.
 - **Bring your own Agent** — Codex CLI, Claude Code CLI and ACP peers run behind
   one boundary and stay replaceable without losing the Task.
 - **Local-first and private** — everything runs on your machine for one trusted
-  user; Web is loopback-only, with read-only views and authenticated user controls.
+  user; Web defaults to loopback, with explicitly enabled authenticated LAN access.
 - **Isolated by default** — repository work happens in managed Git worktrees;
   the stable checkout stays read-only.
 
@@ -181,6 +181,8 @@ For a visual overview, run `yui web` in another terminal. The local Web view
 shows the same tasks and pending questions and lets you send messages, answer
 questions and explicitly queue, steer or interrupt Task input. These authenticated
 Task controls use the same operations as the CLI; Web is not a separate task system.
+For explicit trusted-LAN binding, password protection, access URLs and Operator
+start/status/stop, see [Controlled Web access](docs/web-access.md). HTTP is not encrypted.
 The task list remains at the left, task details occupy the primary reading area,
 and recorded Task messages live in a secondary discussion pane. You can resize,
 swap or hide that pane; on narrow screens it opens over the detail. Native Sessions
@@ -311,7 +313,7 @@ the Controller are what touch the store:
      it moves work and records facts — it never judges an answer
 
   Agents work in Projects: read-only checkout + isolated worktrees.
-  Web (yui web): loopback views + authenticated user controls.
+  Web (yui web): local by default + explicitly authenticated LAN access.
 ```
 
 ### Layered design
@@ -321,7 +323,7 @@ never a fixed workflow:
 
 ```text
   Experience   —  how you interact
-    CLI (Operator) · Web (loopback, authenticated) · native Agent sessions
+    CLI (Operator) · Web (local / authenticated LAN) · native Agent sessions
     collect input · show facts · confirm actions · invoke capabilities
         ▼
   Intelligence —  who decides

package/dist/cli/commandCatalog.js

@@ -275,7 +275,7 @@ const taskChildren = [
     {
         name: "project", discovery: { surface: "managed", audiences: ["operator", "leader"] },
         summary: "Manage Projects bound to a Task.",
-        sections: [{ id: "manage", title: "Commands", entries: ["list", "add"] }],
+        sections: [{ id: "manage", title: "Commands", entries: ["list", "add", "delivery"] }],
         children: [
             {
                 name: "list", discovery: { surface: "public", audiences: ["public", "operator", "leader"] },
@@ -287,6 +287,13 @@ const taskChildren = [
                 summary: "Add a Project to a Task.",
                 usage: "yui task project add <task> <project> [--base <ref>] [--directory <name>]",
                 options: ["--base", "--directory"]
+            },
+            {
+                name: "delivery", discovery: { surface: "public", audiences: ["public", "operator", "leader"] },
+                summary: "Record a sourced Task Project delivery requirement; never grants cleanup or execution authority.",
+                usage: "yui task project delivery <task> <project-id> --requirement <required|excluded> --reason <text> --source-message <message-id> --purpose <exact-quote> --if-current <event-id|none>",
+                options: ["--requirement", "--reason", "--source-message", "--purpose", "--if-current"],
+                optionValues: { "--requirement": ["required", "excluded"] }
             }
         ]
     },
@@ -739,7 +746,7 @@ const taskChildren = [
                     },
                     {
                         name: "new", discovery: { surface: "managed", audiences: ["operator", "leader"] },
-                        summary: "Request replacement even for active or ended Sessions; stop exact execution and preserve Task context, results and workspaces.",
+                        summary: "Stop exact execution, then initialize a successor without replaying retained inbox obligations; preserve claims, context and workspaces.",
                         usage: "yui task role session new <task> <role> --reason <text>",
                         options: ["--reason"]
                     }
@@ -1164,11 +1171,12 @@ export const ROOT_COMMAND = buildNode({
         {
             name: "inbox",
             summary: "Read and explicitly handle the current managed Agent's own inbox.",
-            sections: [{ id: "commands", title: "Commands", entries: ["list", "show", "claim", "ack"] }],
+            sections: [{ id: "commands", title: "Commands", entries: ["list", "show", "claim", "ack", "retire"] }],
             children: [
                 { name: "list", discovery: { surface: "managed", audiences: ["operator", "global", "leader", "assignment"] },
                     summary: "Discover unhandled own-address entries, including accepted delivery, with current identity and separate handling receipts.",
-                    usage: "yui inbox list [--limit <1..100>] [--cursor <cursor>]", options: ["--limit", "--cursor"] },
+                    usage: "yui inbox list [--view current|history|all] [--limit <1..100>] [--cursor <cursor>]",
+                    options: ["--view", "--limit", "--cursor"], optionValues: { "--view": ["current", "history", "all"] } },
                 { 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"] },
@@ -1176,8 +1184,12 @@ export const ROOT_COMMAND = buildNode({
                     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.",
+                    summary: "Record handling, including a rightful successor's disposition of an unchanged prior claim; never proves native acceptance or authorizes replay.",
                     usage: "yui inbox ack <entry> [<entry> ...] --request-id <id> --reason <disposition>",
+                    options: ["--request-id", "--reason"] },
+                { name: "retire", discovery: { surface: "managed", audiences: ["operator", "global"] },
+                    summary: "Explicitly retire obsolete proven-unsubmitted Global input, preserving its original target and evidence.",
+                    usage: "yui inbox retire <entry> [<entry> ...] --request-id <id> --reason <disposition>",
                     options: ["--request-id", "--reason"] }
             ]
         },
@@ -1192,8 +1204,8 @@ export const ROOT_COMMAND = buildNode({
                     children: [
                         {
                             name: "list", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Discover Global Messages without consuming input.",
-                            usage: "yui role message list <role> [--pending|--diagnostics|--diagnostic <key>] [--limit <1..100>] [--cursor <cursor>]",
-                            options: ["--pending", "--diagnostics", "--diagnostic", "--limit", "--cursor"]
+                            usage: "yui role message list <role> [--current|--pending|--diagnostics|--diagnostic <key>] [--limit <1..100>] [--cursor <cursor>]",
+                            options: ["--current", "--pending", "--diagnostics", "--diagnostic", "--limit", "--cursor"]
                         },
                         {
                             name: "show", discovery: { surface: "public", audiences: ["public", "operator"] }, summary: "Read one exact Global Message; follow contentPage.nextCursor for long content.",
@@ -1243,8 +1255,8 @@ export const ROOT_COMMAND = buildNode({
         {
             name: "web", discovery: { surface: "public", audiences: ["public", "operator"] },
             summary: "Serve the control room using the running Controller's capability Host.",
-            usage: "yui web [--host <loopback>] [--port <port>] | --status | --stop",
-            options: ["--host", "--port", "--status", "--stop"]
+            usage: "yui web [--host <IP|localhost>] [--port <port>] [--auth-file <absolute-path>] [--detach] | --status | --stop",
+            options: ["--host", "--port", "--auth-file", "--detach", "--status", "--stop"]
         },
         {
             name: "controller", discovery: { surface: "public", audiences: ["public", "operator"] },

package/dist/cli/helpRenderer.js

@@ -25,7 +25,9 @@ function describeOption(option) {
         "--agent": "Select an Agent.",
         "--base": "Set the base Git reference.",
         "--input": "Set dispatch input.",
-        "--host": "Set the loopback listen address.",
+        "--host": "Set the listen IP (default 127.0.0.1); non-loopback requires --auth-file.",
+        "--auth-file": "Owner-only file with a unique 32–128 character password; browser username is yui. HTTP is not encrypted.",
+        "--detach": "Return after Controller starts Web; use --status / --stop. Operator and --json starts always return.",
         "--port": "Set the local listen port.",
         "--json": "Emit machine-readable JSON.",
         "--project": "Select a Project.",

package/dist/commands/globalRoleCommands.js

@@ -6,6 +6,7 @@ import { controlProviderRetry, providerRetryProjection, providerRetrySummary, re
 import { pendingGlobalInboxMessages, inboxHandlingState, globalInboxDeliveryState } from "../message/inboxReceipt.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { globalInputBacklog } from "../message/globalInputBacklog.js";
+import { inboxEntryCategory } from "../message/inboxTurn.js";
 import { checkCurrentSkills, SKILL_REUSE_RULE } from "../context/currentSkills.js";
 import { runtimeDiagnosticGroups, runtimeDiagnosticEvidence } from "../controller/globalRuntimeAttention.js";
 import { roleSkillIds } from "../context/roleSessionContext.js";
@@ -131,10 +132,16 @@ function roleContext(args, store, options) {
     // 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.inbox === undefined
         && message.notDelivered === undefined
         && (message.interruptThen !== undefined || message.inputControl?.action === "queue"));
-    const pending = recordPage(pendingGlobalInboxMessages(messages).map(globalMessageSummary), `global:${name}/messages/pending`, { limit: 8 });
+    const unhandled = pendingGlobalInboxMessages(messages);
+    const current = currentGlobalInboxMessages(messages, name, sessions);
+    const pending = recordPage(current.map(globalMessageSummary), `global:${name}/messages/current`, { limit: 8 }, {
+        historyCount: unhandled.length - current.length,
+        historyRead: "yui inbox list --view history --json",
+        note: "Historical absence of handling evidence is not new work or permission to replay effects."
+    });
     const observedAt = new Date();
     const { oldestAgeMs, messages: _backlogMessages, ...backlog } = globalInputBacklog(queued, sessions, observedAt, {
         attention: name === "operator" ? store.getWorkMailbox({ kind: "operator" }) : null,
@@ -175,9 +182,9 @@ function roleContext(args, store, options) {
         pending,
         backlog,
         reads: {
-            ownInbox: "yui inbox list --json",
+            ownInbox: "yui inbox list --view current --json",
             messages: `role message list ${name}`,
-            pending: `role message list ${name} --pending`,
+            pending: `role message list ${name} --current`,
             detail: `role message show ${name} <message-id>`,
             diagnostics: `role message list ${name} --diagnostics`,
             retry: `session retry ${name} show`
@@ -213,6 +220,16 @@ function roleContext(args, store, options) {
             ""
         ].join("\n") };
 }
+function currentGlobalInboxMessages(messages, name, sessions) {
+    const actor = { scope: "global", roleName: name, agentId: sessions?.activeAgentId ?? "",
+        nativeSessionId: sessions?.sessions[sessions.activeAgentId]?.nativeSessionId ?? "" };
+    const binding = sessions?.providerBinding;
+    const turn = binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId === actor.nativeSessionId
+        ? binding?.run : undefined;
+    const category = (message) => inboxEntryCategory(message, actor, turn);
+    return pendingGlobalInboxMessages(messages).filter(message => category(message) !== "history")
+        .sort((a, b) => Number(category(b) === "current") - Number(category(a) === "current"));
+}
 function globalMessageSummary(message) {
     return {
         id: message.id, createdAt: message.createdAt, kind: message.kind,
@@ -626,17 +643,18 @@ function globalRoleMessage(args, store, options) {
         }
         requireRole(name, store);
         const pending = tail.includes("--pending");
+        const current = tail.includes("--current");
         const diagnostics = tail.includes("--diagnostics");
-        const parsed = readOptions(tail.filter(arg => arg !== "--pending" && arg !== "--diagnostics"), action === "list"
+        const parsed = readOptions(tail.filter(arg => arg !== "--pending" && arg !== "--current" && arg !== "--diagnostics"), action === "list"
             ? ["--cursor", "--limit", "--diagnostic"] : ["--cursor"]);
         const diagnostic = parsed.values.get("--diagnostic");
-        if (Number(pending) + Number(diagnostics) + Number(diagnostic !== undefined) > 1
+        if (Number(pending) + Number(current) + Number(diagnostics) + Number(diagnostic !== undefined) > 1
             || action === "show" && diagnostics)
             throw usageError("Choose one Message discovery view.");
         const messages = store.listGlobalRoleMessages(name);
         let data;
         if (action === "show") {
-            if (parsed.positionals.length !== 1 || pending)
+            if (parsed.positionals.length !== 1 || pending || current)
                 throw usageError("Role message show <role> <message-id> [--cursor <cursor>].");
             const message = messages.find(m => m.id === parsed.positionals[0]);
             if (message === undefined)
@@ -654,8 +672,9 @@ function globalRoleMessage(args, store, options) {
                 return { kind: "output", output: `${JSON.stringify(data)}\n`, data };
             }
             const selected = diagnostic !== undefined ? runtimeDiagnosticEvidence(messages, diagnostic)
-                : pending ? pendingGlobalInboxMessages(messages) : [...messages].reverse();
-            data = recordPage(selected.map(globalMessageSummary), `global:${name}/messages/${diagnostic === undefined ? pending ? "pending" : "all" : `diagnostic/${diagnostic}`}`, parsed);
+                : current ? currentGlobalInboxMessages(messages, name, store.getGlobalRoleSessionSet(name))
+                    : pending ? pendingGlobalInboxMessages(messages) : [...messages].reverse();
+            data = recordPage(selected.map(globalMessageSummary), `global:${name}/messages/${diagnostic === undefined ? current ? "current" : pending ? "pending" : "all" : `diagnostic/${diagnostic}`}`, parsed);
         }
         return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
     }
@@ -711,6 +730,8 @@ function messageGlobalInput(name, input, store, options) {
     }
     store.updateGlobalRoleMessage({ ...persisted.message, control: {
             requestId, receiptId: `steer:${name}/${persisted.message.id}`,
+            target: { agentId: resolution.target.agentId, nativeSessionId: resolution.target.nativeSessionId,
+                attemptId: resolution.target.attemptId },
             outcome: "pending", observedAt: now.toISOString()
         } });
     return {

package/dist/commands/inboxCommands.js

@@ -5,9 +5,10 @@ import { createTaskWake, latestTaskWake } from "../scheduler/taskWake.js";
 import { expandTaskMessageResult } from "../message/message.js";
 import { messageAssignmentBlocker } from "../message/messageContinuation.js";
 import { globalInboxDeliveryState, inboxHandlingState, isGlobalInboxMessage, pendingGlobalInboxMessages } from "../message/inboxReceipt.js";
-import { deliveredMessageWake, isLeaderSteer, pinMessageRevisions, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
+import { nonReplayableMessageWake, isLeaderSteer, pinMessageRevisions, releasedNotificationWake, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isTaskRecordRetired, retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
+import { blocksInboxOrder, inboxEntryCategory, inboxSettled } from "../message/inboxTurn.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)}`;
@@ -15,15 +16,27 @@ 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) {
     const caller = requireManagedCaller(store, env);
+    const binding = caller.scope === "global" ? store.getGlobalRoleSessionSet(caller.roleName)?.providerBinding
+        : store.getTaskRoleSessionSet(caller.taskId, caller.roleName)?.providerBinding;
+    const turn = binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId === caller.nativeSessionId
+        ? binding?.run : undefined;
+    const attempt = turn && ["submitting", "accepted", "delivery-unknown"].includes(turn.status)
+        ? { attemptId: turn.attemptId } : {};
     if (caller.scope === "global") {
-        return { scope: "global", roleName: caller.roleName, agentId: caller.agentId, nativeSessionId: caller.nativeSessionId };
+        return { scope: "global", roleName: caller.roleName, agentId: caller.agentId, nativeSessionId: caller.nativeSessionId, ...attempt };
     }
     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 }) };
+        ...(caller.currentRunId === undefined ? {} : { runId: caller.currentRunId }), ...attempt };
+}
+function currentTurn(store, address) {
+    const binding = address.scope === "global" ? store.getGlobalRoleSessionSet(address.roleName)?.providerBinding
+        : store.getTaskRoleSessionSet(address.taskId, address.roleName)?.providerBinding;
+    return binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId === address.nativeSessionId
+        ? binding?.run : undefined;
 }
 function ownsMessage(store, address, message) {
     if (address.roleName === "leader" && message.taskId === address.taskId && isLeaderSteer(message))
@@ -80,15 +93,15 @@ 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 (inboxSettled(entry.inbox))
+        return entry.inbox?.retirement ? "retired" : "acknowledged";
     if (entry.inbox !== undefined) {
         return sameSession(entry.inbox.claim.actor, address) ? undefined : "claimed-by-previous-session";
     }
     if (isWake(entry)) {
         // Native acceptance releases transport ownership, not semantic handling.
         // The current Leader may explicitly claim the fixed delivered window.
-        if (entry.status === "consumed")
+        if (entry.status === "consumed" || releasedNotificationWake(store, entry.taskId, entry.id))
             return undefined;
         return "automatic-notification-owns-window";
     }
@@ -150,9 +163,12 @@ function checkMutation(store, address) {
 }
 function summary(store, address, entry) {
     return { id: entry.id, kind: isWake(entry) ? "notification-window" : "message",
+        category: inboxEntryCategory(entry, address, currentTurn(store, address)),
         createdAt: entry.createdAt, summary: summaryText(isWake(entry) ? entry.reasons.join(", ") : entry.body),
         blocked: blocker(store, address, entry) ?? null, inbox: summaryMetadata(entry.inbox ?? null),
         handling: inboxHandlingState(entry.inbox),
+        ...(entry.inbox !== undefined && entry.inbox.ack === undefined && !sameSession(entry.inbox.claim.actor, address)
+            ? { recovery: "Read this original and prior effects under current authority; finish handling, then inbox ack this exact entry. Retain the original claim; do not claim again or replay business." } : {}),
         delivery: isWake(entry) ? entry.status : summaryMetadata({
             control: entry.control ?? null,
             ...(address.scope === "global" ? { receipt: entry.delivery ?? null,
@@ -173,23 +189,33 @@ 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 parsed = readOptions(tail, ["--limit", "--cursor", "--view"]);
+        const view = parsed.values.get("--view") ?? "all";
+        if (!["all", "current", "history"].includes(view) || parsed.positionals.length) {
+            throw new Error("Inbox list accepts --view current|history|all, --limit and --cursor.");
+        }
         const retired = address.scope === "task" ? retiredTaskRecordIds(store.listEvents(address.taskId), "message") : new Set();
         const selected = address.scope === "global" ? pendingGlobalInboxMessages(store.listGlobalRoleMessages(address.roleName))
             : entries(store, address).filter(entry => (isWake(entry) || !retired.has(entry.id))
-                && inboxHandlingState(entry.inbox) !== "handled");
-        const items = selected.map(entry => summary(store, address, entry));
+                && !inboxSettled(entry.inbox));
+        const turn = currentTurn(store, address);
+        const categories = selected.map(entry => ({ entry, category: inboxEntryCategory(entry, address, turn) }));
+        const rank = { current: 0, available: 1, history: 2 };
+        categories.sort((a, b) => rank[a.category] - rank[b.category]);
+        const items = categories.filter(item => view === "all"
+            || (view === "history") === (item.category === "history")).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",
+            if (mailbox?.pending != null && view !== "history")
+                items.splice(categories.filter(item => item.category === "current").length, 0, { id: pendingId(mailbox.pending), kind: "notification-window",
+                    category: "available",
                     summary: summaryText(mailbox.pending.reasons.join(", ")),
                     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, { identity: address });
+        return recordPage(items, `${source(address)}/${view}`, parsed, { identity: address, view,
+            historyCount: categories.filter(item => item.category === "history").length,
+            note: "History lacks handling evidence; it is not unexecuted work. Inspect original effects before disposition." });
     }
     if (action === "show") {
         const parsed = readOptions(tail, ["--cursor"]);
@@ -208,8 +234,8 @@ export function runInboxCommand(args, store, env, now = new Date()) {
             ? 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.");
+    if (action !== "claim" && action !== "ack" && action !== "retire")
+        throw new Error("Inbox commands: list, show, claim, ack, retire.");
     const parsed = readOptions(tail, ["--request-id", "--reason"]);
     const ids = parsed.positionals;
     const requestId = parsed.values.get("--request-id");
@@ -220,7 +246,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
     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)) {
+    if (action !== "claim" && (!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)
@@ -251,7 +277,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                     continue;
                 const message = tx.listMessages(current.taskId).find(message => message.id === ref.id);
                 if (message !== undefined && (taskMessageInboxReceipt(tx, message) !== undefined
-                    || deliveredMessageWake(tx, message) !== undefined)
+                    || nonReplayableMessageWake(tx, message) !== undefined)
                     || message?.interruptThen !== undefined
                     || message?.control !== undefined && message.control.outcome !== "rejected"
                     || message?.inputControl?.expectedSessionId !== undefined
@@ -274,7 +300,36 @@ export function runInboxCommand(args, store, env, now = new Date()) {
         }
         else {
             entry = getEntry(tx, current, id);
-            if (action === "claim") {
+            if (action === "retire") {
+                if (current.scope !== "global" || isWake(entry)) {
+                    throw new Error("Task input retirement uses the Leader's existing task message retire operation.");
+                }
+                const message = entry;
+                if (message.inbox?.retirement) {
+                    const saved = message.inbox.retirement;
+                    if (saved.requestId !== requestId || saved.reason !== reason || !sameSession(saved.actor, current)) {
+                        throw new Error("Conflicting retirement; original disposition retained.");
+                    }
+                    return receipt(entry);
+                }
+                // A retained attempt in an older conversation is still evidence of
+                // submission; changing the active Session cannot erase that boundary.
+                const turn = tx.getGlobalRoleSessionSet(current.roleName)?.providerBinding?.run;
+                const foreignTarget = message.deliveryTarget && (message.deliveryTarget.agentId !== current.agentId
+                    || message.deliveryTarget.nativeSessionId !== current.nativeSessionId)
+                    || message.inputControl?.expectedSessionId !== undefined
+                        && message.inputControl.expectedSessionId !== current.nativeSessionId;
+                if (message.inbox?.ack || message.delivery !== undefined || message.interruptThen !== undefined
+                    || message.control !== undefined && message.control.outcome !== "rejected"
+                    || turn?.attemptId === `global-input:${current.roleName}/${message.id}`
+                    || !foreignTarget && message.notDelivered === undefined) {
+                    throw new Error("Retirement requires obsolete, proven-unsubmitted input; unknown/accepted/interrupt-owned input must retain its exact handling path.");
+                }
+                entry = { ...message, inbox: { ...message.inbox,
+                        claim: message.inbox?.claim ?? { requestId, actor: current, at: now.toISOString() },
+                        retirement: { requestId, actor: current, at: now.toISOString(), reason: reason } } };
+            }
+            else 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.");
@@ -285,7 +340,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 const blocked = blocker(tx, current, entry);
                 if (blocked !== undefined)
                     throw new Error(`Inbox entry cannot be claimed: ${blocked}.`);
-                if (isWake(entry) && !acceptedInput(entry)) {
+                if (isWake(entry) && !acceptedInput(entry) && !releasedNotificationWake(tx, entry.taskId, entry.id)) {
                     for (const ref of entry.refs ?? []) {
                         if (ref.type !== "message")
                             continue;
@@ -299,7 +354,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 for (const previous of entries(tx, current)) {
                     if (previous.id === entry.id)
                         break;
-                    if (isWake(previous) || previous.inbox?.ack !== undefined)
+                    if (!blocksInboxOrder(previous, current, currentTurn(tx, current)))
                         continue;
                     if (current.scope === "task"
                         && isTaskRecordRetired(tx.listEvents(current.taskId), "message", previous.id))
@@ -315,11 +370,13 @@ export function runInboxCommand(args, store, env, now = new Date()) {
             else {
                 if (!entry.inbox)
                     throw new Error("Claim the exact entry before handling and acknowledgement.");
+                if (entry.inbox.retirement)
+                    throw new Error("Retirement is not acknowledgement; original disposition retained.");
                 // 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) && !acceptedInput(entry)) {
+                if (isWake(entry) && !acceptedInput(entry) && !releasedNotificationWake(tx, entry.taskId, entry.id)) {
                     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))

package/dist/commands/taskCommands.js

@@ -83,6 +83,7 @@ import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, lead
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
 import { runTaskContextCommand, taskRecordList } from "./taskContextCommand.js";
 import { taskBriefCommand, taskDecisionCommand, taskEventCommand, taskMilestoneCommand } from "./taskFactCommands.js";
+import { taskProjectDeliveryCommand } from "./taskProjectDeliveryCommand.js";
 import { taskUsageCommand } from "./taskUsageCommand.js";
 import { openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
 import { runTaskNextActionCommand } from "./taskNextActionCommand.js";
@@ -456,6 +457,8 @@ function assertCandidateReviewRoleIsolation(producerRoles, reviewerRoleName, lan
 }
 function taskProjectCommand(args, store, options) {
     const [command, ...rest] = args;
+    if (command === "delivery")
+        return taskProjectDeliveryCommand(rest, store, options);
     if (command === "list") {
         exactPositionals(rest, 1, "Task project list usage: yui task project list <task>.");
         const task = requireTask(store, rest[0]);
@@ -1880,7 +1883,9 @@ function steerTaskInput(taskId, input, store, options) {
         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)
+            requestId, receiptId, outcome: "pending", observedAt: clock(options),
+            target: { agentId: resolution.target.agentId, nativeSessionId: resolution.target.nativeSessionId,
+                attemptId: resolution.target.attemptId }
         }));
         return true;
     });

package/dist/commands/taskProjectDeliveryCommand.js

@@ -0,0 +1,56 @@
+import { readTaskAuthorizationMessage, taskAuthorizationSource } from "../grant/taskAuthorization.js";
+import { assertTaskDeliveryAuthority } from "../task/taskAuthority.js";
+import { PROJECT_DELIVERY_DECIDED_EVENT, projectDeliveryDecision } from "../task/projectDeliveryScope.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { usageError } from "../errors/cliError.js";
+import { clock, exactPositionals, leaderMailbox, notifyMailbox, output, parseTail, recordTaskEvent, requiredOption, requireTask, taskMailbox, taskRef } from "./taskCommandSupport.js";
+export function taskProjectDeliveryCommand(args, store, options) {
+    const usage = "yui task project delivery <task> <project-id> --requirement <required|excluded> "
+        + "--reason <text> --source-message <message-id> --purpose <exact-quote> --if-current <event-id|none>";
+    const parsed = parseTail(args, new Set([
+        "--requirement", "--reason", "--source-message", "--purpose", "--if-current"
+    ]), usage);
+    exactPositionals(parsed.positionals, 2, usage);
+    const requirement = requiredOption(parsed.options, "--requirement");
+    if (requirement !== "required" && requirement !== "excluded")
+        throw usageError(usage);
+    const reason = requiredOption(parsed.options, "--reason");
+    const sourceMessage = requiredOption(parsed.options, "--source-message");
+    const purpose = requiredOption(parsed.options, "--purpose");
+    const guard = requiredOption(parsed.options, "--if-current");
+    const now = clock(options);
+    const result = store.transaction(tx => {
+        const task = requireTask(tx, parsed.positionals[0]);
+        const actor = assertTaskDeliveryAuthority(tx, options.environment, task.id);
+        if (!["active", "completed"].includes(task.status) || task.executionGate.state !== "enabled") {
+            throw usageError("Delivery scope requires an active or completed, unarchived Task with execution enabled; it does not reopen or resume work.");
+        }
+        const projectId = parsed.positionals[1];
+        if (!task.projectBindings.some(binding => binding.projectId === projectId)) {
+            throw usageError(`Project is not bound to this Task: ${projectId}.`);
+        }
+        const source = actor === "leader"
+            ? taskAuthorizationSource(tx, task.id, options.environment ?? {}, sourceMessage, purpose)
+            : readTaskAuthorizationMessage(tx, task.id, sourceMessage, purpose);
+        const previous = projectDeliveryDecision(tx.listEventsByType(task.id, [PROJECT_DELIVERY_DECIDED_EVENT]), task.id, projectId);
+        if (guard !== (previous?.id ?? "none")) {
+            throw usageError("Project delivery scope changed; read task remote-delivery and reconcile before retrying with its scopeDecision.id (or none).");
+        }
+        const event = recordTaskEvent(tx, task.id, PROJECT_DELIVERY_DECIDED_EVENT, {
+            projectId, requirement, reason, by: actor,
+            sourceMessageId: source.messageId, sourceDigest: source.digest, purpose: source.purpose,
+            ...("nativeSessionId" in source && typeof source.nativeSessionId === "string"
+                ? { nativeSessionId: source.nativeSessionId } : {}),
+            ...(previous === null ? {} : { supersedes: previous.id })
+        }, now);
+        enqueueWork(tx, taskMailbox(task.id), "project-delivery-decided", now, [taskRef(task.id)]);
+        if (task.status === "active" && actor !== "leader") {
+            enqueueWork(tx, leaderMailbox(task.id), "project-delivery-decided", now, [taskRef(task.id)]);
+        }
+        return { task, event };
+    });
+    notifyMailbox(options.runtime, taskMailbox(result.task.id));
+    if (result.task.status === "active")
+        notifyMailbox(options.runtime, leaderMailbox(result.task.id));
+    return output(`Recorded Project delivery requirement (${requirement}); merge facts and cleanup authority are unchanged.\n`, result.event);
+}

package/dist/commands/taskRemoteDeliveryCommand.js

@@ -27,15 +27,17 @@ export function renderTaskRemoteDelivery(delivery, indent = "") {
     const lines = [
         `${indent}Remote delivery: ${delivery.status}`,
         `${indent}Expected heads: ${source}`,
-        `${indent}All merged: ${delivery.allMerged ? "yes" : "no"}`,
-        `${indent}All verified: ${delivery.allVerified ? "yes" : "no"}`,
-        `${indent}Code Projects: ${delivery.mergedProjectCount}/${delivery.codeProjectCount} merged; ${delivery.verifiedProjectCount}/${delivery.codeProjectCount} verified`,
+        `${indent}Required code Projects all merged: ${delivery.allMerged ? "yes" : "no"}`,
+        `${indent}Required code Projects all verified: ${delivery.allVerified ? "yes" : "no"}`,
+        `${indent}Required code Projects: ${delivery.mergedProjectCount}/${delivery.requiredCodeProjectCount} merged; ${delivery.verifiedProjectCount}/${delivery.requiredCodeProjectCount} verified; excluded=${delivery.excludedProjectCount}`,
+        ...(delivery.requiredCodeProjectCount === 0 ? [`${indent}No delivery obligation.`] : []),
         `${indent}Archive --integrated coverage: ${delivery.integratedCoverageSatisfied ? "satisfied" : "blocked"}`,
         ...(delivery.archiveDisposition === null
             ? []
             : [`${indent}Archive disposition: ${delivery.archiveDisposition}`]),
         `${indent}Projects:${delivery.projects.length === 0 ? " none" : ""}`,
         ...delivery.projects.map((project) => (`${indent}- ${project.directory} (${project.projectId}): `
+            + `requirement=${project.deliveryRequirement}; scopeDecision=${project.scopeDecision?.id ?? "none"}; `
             + `expected=${shortCommit(project.expectedLocalCommit)}; `
             + `candidate=${shortCommit(project.deliveryLocalCommit)}; `
             + `adoption=${project.adoption?.id ?? "none"}; `

package/dist/context/runContextPack.js

@@ -385,6 +385,7 @@ export function runContextEntry(pack) {
                 activeRuns: liveTaskState.activeRuns.length, activeTaskReviews: liveTaskState.activeTaskReviews.length }
         },
         reads: {
+            inbox: "yui inbox list --view current --json",
             refs: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view refs`,
             full: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view full`,
             input: `yui task run context ${pack.identity.taskId}/${pack.identity.runId} --view input`,

package/dist/context/runInputContract.js

@@ -90,6 +90,7 @@ export function serializeRunInputEnvelope(value) {
         ]),
         "Use the Session Manifest's CLI entry. Fail closed if the exact Context is unavailable or mismatched.",
         "Then read the relevant referenced requirements and perform the assigned work. Context loading is not the deliverable.",
+        "Current continuation/steer inputs: yui inbox list --view current --json. Read and claim exact originals, then ack their disposition before the final report; this does not accept the assignment.",
         "During planning, fulfill the user's Draft discussion request without starting delivery before it is requested."
     ];
     const serialized = lines.join("\n");

package/dist/context/taskContext.js

@@ -93,7 +93,7 @@ export function readTaskContext(store, taskId, environment = {}) {
             commandDiscovery: {
                 help: "yui help", describe: "yui --json help",
                 skillCheck: "yui session skills --json",
-                ownInbox: "yui inbox list --json",
+                ownInbox: "yui inbox list --view current --json",
                 note: "Help and completion share the current caller's offline command view. Follow that view for operation-specific discovery; execution always revalidates authority."
             },
             detail: `task context inspect ${taskId} --store <store> --ref <refId> --digest <digest>`,

package/dist/context/taskPhase.js

@@ -61,7 +61,7 @@ export function activationWakeRefs(store, task) {
 }
 const BRIEF_RELEVANT_EVENTS = [
     "message.sent", "message.updated", "message.native-user-input", "brief.updated",
-    "decision.recorded", "decision.superseded", "input.requested", "input.answered", "input.cancelled", "input.auto-answered",
+    "decision.recorded", "decision.superseded", "task.project-delivery-decided", "input.requested", "input.answered", "input.cancelled", "input.auto-answered",
     "run.completed", "run.failed", "run.cancelled", "job.state-changed", "work.accepted",
     "runtime.role-delivery-failed", "run.retired",
     "work.updated", "work.edited", "work.scope-updated", "work.rejected", "work.retired",