@zq-silk/yui 2.9.0 → 2.10.0

package/dist/message/inboxReceipt.js

@@ -3,7 +3,8 @@ import { isDeepStrictEqual } from "node:util";
 /** Semantic handling and transport delivery are independent facts. Projections
  * must not infer handling from delivery, a native terminal, or an empty queue. */
 export function inboxHandlingState(receipt) {
-    return receipt?.ack !== undefined ? "handled" : receipt !== undefined ? "claimed-unacknowledged" : "unclaimed";
+    return receipt?.retirement !== undefined ? "retired" : receipt?.ack !== undefined ? "handled"
+        : receipt !== undefined ? "claimed-unacknowledged" : "unclaimed";
 }
 export function isGlobalInboxMessage(message) {
     return message.inputControl !== undefined || message.interruptThen !== undefined;
@@ -11,7 +12,8 @@ export function isGlobalInboxMessage(message) {
 /** Unhandled own-role input, including accepted and unknown delivery. This is
  * NOT the scheduler's deliverable queue; selecting it never authorizes replay. */
 export function pendingGlobalInboxMessages(messages) {
-    return messages.filter(message => isGlobalInboxMessage(message) && inboxHandlingState(message.inbox) !== "handled");
+    return messages.filter(message => isGlobalInboxMessage(message)
+        && !["handled", "retired"].includes(inboxHandlingState(message.inbox)));
 }
 /** Original message evidence only. A missing receipt is not proof of
  * non-submission; admission additionally inspects the exact native attempt. */
@@ -22,20 +24,22 @@ export function globalInboxDeliveryState(message) {
 export function validateInboxReceipt(receipt) {
     if (receipt === undefined)
         return;
-    requireKnownFields(receipt, ["claim", "ack"], "Inbox receipt");
+    requireKnownFields(receipt, ["claim", "ack", "retirement"], "Inbox receipt");
+    if (receipt.ack && receipt.retirement)
+        throw new Error("Inbox disposition cannot be both acknowledgement and retirement.");
     for (const [kind, entry] of Object.entries(receipt)) {
         requireKnownFields(entry, kind === "claim" ? ["requestId", "actor", "at"]
             : ["requestId", "actor", "at", "reason"], "Inbox action");
         requireText(entry.requestId, "Inbox request id");
         requireTimestamp(entry.at, "Inbox timestamp");
         const actor = entry.actor;
-        requireKnownFields(actor, ["scope", "taskId", "roleName", "agentId", "nativeSessionId", "runId"], "Inbox actor");
+        requireKnownFields(actor, ["scope", "taskId", "roleName", "agentId", "nativeSessionId", "runId", "attemptId"], "Inbox actor");
         if (!["task", "global"].includes(actor.scope)
             || (actor.scope === "task") !== (actor.taskId !== undefined))
             throw new Error("Inbox actor scope is invalid.");
         for (const value of Object.values(actor))
             requireText(value, "Inbox actor identity");
-        if (kind === "ack")
+        if (kind !== "claim")
             requireText(entry.reason, "Inbox disposition");
     }
     if (!receipt.claim)
@@ -45,7 +49,8 @@ export function validateInboxReceipt(receipt) {
  * Host admission. The original claim and any ack are immutable audit facts. */
 export function assertInboxReceiptPreserved(previous, next) {
     if (previous !== undefined && (!isDeepStrictEqual(previous.claim, next?.claim)
-        || previous.ack !== undefined && !isDeepStrictEqual(previous.ack, next?.ack))) {
+        || previous.ack !== undefined && !isDeepStrictEqual(previous.ack, next?.ack)
+        || previous.retirement !== undefined && !isDeepStrictEqual(previous.retirement, next?.retirement))) {
         throw new Error("Inbox handling ownership changed; reread the original instead of overwriting its receipt.");
     }
 }
@@ -55,6 +60,9 @@ export function assertInboxReceiptPreserved(previous, next) {
  */
 export function assertInboxOriginalPreserved(previous, next) {
     assertInboxReceiptPreserved(previous?.inbox, next.inbox);
+    if (previous?.control?.target !== undefined && !isDeepStrictEqual(previous.control.target, next.control?.target)) {
+        throw new Error("The exact admitted control target cannot be replaced or erased.");
+    }
     if (previous?.inbox !== undefined && (previous.body !== next.body || previous.kind !== next.kind
         || !isDeepStrictEqual(previous.author, next.author) || !isDeepStrictEqual(previous.inputControl, next.inputControl))) {
         throw new Error("Inbox receipt binds the exact original Message; submit changed content as a new Message.");

package/dist/message/inboxTurn.js

@@ -0,0 +1,86 @@
+import { globalInboxDeliveryState } from "./inboxReceipt.js";
+export const INBOX_CHECK_PREFIX = "inbox-check:";
+export const INBOX_CHECK_REASON = "inbox-handling-missing";
+export const isInboxWake = (entry) => "fromCursor" in entry;
+export const isHandlingReminder = (entry) => isInboxWake(entry)
+    ? entry.reasons.every(reason => reason === INBOX_CHECK_REASON)
+    : entry.kind === "system" && entry.inputControl?.requestId.startsWith(INBOX_CHECK_PREFIX) === true;
+/** Correlation uses existing input identities, not timestamps, output text or
+ * Task state. Active consumption adds only the exact attempt to its claim. */
+export function belongsToInboxTurn(entry, actor, turn) {
+    if (!turn)
+        return false;
+    const claim = entry.inbox?.claim.actor;
+    if (claim?.attemptId === turn.attemptId && claim.scope === actor.scope && claim.taskId === actor.taskId
+        && claim.roleName === actor.roleName && claim.agentId === actor.agentId
+        && claim.nativeSessionId === actor.nativeSessionId)
+        return true;
+    if (isInboxWake(entry))
+        return actor.scope === "task" && actor.roleName === "leader"
+            && entry.taskId === actor.taskId && (turn.input?.kind === "wake" && turn.input.wakeId === entry.id
+            && turn.input.taskId === entry.taskId
+            || turn.attemptId.startsWith(`notification:${entry.taskId}/${entry.id}/`));
+    if ("roleName" in entry) {
+        if (actor.scope !== "global" || entry.roleName !== actor.roleName)
+            return false;
+        if (entry.deliveryTarget && (entry.deliveryTarget.agentId !== actor.agentId
+            || entry.deliveryTarget.nativeSessionId !== actor.nativeSessionId))
+            return false;
+        if (turn.input?.kind === "message" && turn.input.roleName === actor.roleName
+            && turn.input.messageId === entry.id || turn.attemptId === `global-input:${actor.roleName}/${entry.id}`)
+            return true;
+    }
+    else {
+        if (actor.scope !== "task" || entry.taskId !== actor.taskId)
+            return false;
+        if (turn.runId !== undefined && entry.recipient?.roleName === actor.roleName
+            && entry.continuation?.runId === turn.runId)
+            return true;
+    }
+    const target = entry.control?.target;
+    return entry.control?.outcome === "accepted" && target?.agentId === actor.agentId
+        && target.nativeSessionId === actor.nativeSessionId && target.attemptId === turn.attemptId;
+}
+/** Historical absence of ACK is not fresh work. Current unsubmitted input
+ * remains discoverable, but never steals an unsettled transport owner. */
+export function inboxEntryCategory(entry, actor, turn) {
+    if (belongsToInboxTurn(entry, actor, turn))
+        return "current";
+    if (entry.inbox !== undefined)
+        return "history";
+    if (isInboxWake(entry))
+        return "history";
+    if ("roleName" in entry) {
+        if (entry.delivery !== undefined || entry.notDelivered !== undefined
+            || entry.deliveryTarget && (entry.deliveryTarget.agentId !== actor.agentId
+                || entry.deliveryTarget.nativeSessionId !== actor.nativeSessionId))
+            return "history";
+    }
+    else if (entry.continuation?.runId !== undefined)
+        return "history";
+    if (entry.inputControl?.expectedSessionId !== undefined
+        && entry.inputControl.expectedSessionId !== actor.nativeSessionId)
+        return "history";
+    if (entry.control?.outcome === "accepted")
+        return "history";
+    return "available";
+}
+export function inboxSettled(receipt) {
+    return receipt?.ack !== undefined || receipt?.retirement !== undefined;
+}
+export function missingTurnHandling(entries, actor, turn) {
+    return entries.filter(entry => !inboxSettled(entry.inbox) && !isHandlingReminder(entry)
+        && belongsToInboxTurn(entry, actor, turn));
+}
+/** Accepted historical input and explicit nondelivery do not impose an input
+ * order on independent new messages. Unknown delivery still does. */
+export function blocksInboxOrder(entry, actor, turn) {
+    if (isInboxWake(entry) || inboxSettled(entry.inbox))
+        return false;
+    if ("roleName" in entry && (globalInboxDeliveryState(entry) === "accepted" || entry.notDelivered !== undefined))
+        return false;
+    if (entry.control?.outcome === "accepted")
+        return false;
+    return inboxEntryCategory(entry, actor, turn) !== "history"
+        || entry.control !== undefined && ["pending", "delivery-unknown"].includes(entry.control.outcome);
+}

package/dist/message/message.js

@@ -147,6 +147,7 @@ export function recordTaskMessageControlOutcome(message, record) {
             requestId: requireSafeIdentity(record.requestId, "Message control requestId"),
             receiptId: requireText(record.receiptId, "Message control receiptId"),
             outcome: record.outcome,
+            ...(existing?.target ?? record.target ? { target: existing?.target ?? record.target } : {}),
             observedAt: record.observedAt.toISOString()
         }
     };
@@ -282,6 +283,7 @@ export function validateTaskMessage(message) {
         }
     }
     if (message.control !== undefined) {
+        validateControlTarget(message.control);
         requireSafeIdentity(message.control.requestId, "Message control requestId");
         requireText(message.control.receiptId, "Message control receiptId");
         if (!TASK_MESSAGE_INPUT_CONTROL_OUTCOMES.includes(message.control.outcome)) {
@@ -408,6 +410,7 @@ export function validateGlobalRoleMessage(message) {
         requireText(message.deliveryTarget.nativeSessionId, "Global input Session");
     }
     if (message.control !== undefined) {
+        validateControlTarget(message.control);
         requireSafeIdentity(message.control.requestId, "Global input requestId");
         requireText(message.control.receiptId, "Global input receiptId");
         if (!TASK_MESSAGE_INPUT_CONTROL_OUTCOMES.includes(message.control.outcome)
@@ -479,6 +482,14 @@ export function validateGlobalRoleMessage(message) {
         throw new Error("Message createdAt is invalid.");
     }
 }
+function validateControlTarget(control) {
+    if (control.target === undefined)
+        return;
+    requireKnownFields(control.target, ["agentId", "nativeSessionId", "attemptId"], "Control target");
+    requireText(control.target.agentId, "Control target Agent");
+    requireText(control.target.nativeSessionId, "Control target Session");
+    requireText(control.target.attemptId, "Control target attempt");
+}
 /** A Global message local id is `global-message-<n>`; it carries no Task id. */
 export function validateGlobalRoleMessageId(localId) {
     const normalized = requireSafeIdentity(localId, "Global message id");

package/dist/message/taskInboxOwnership.js

@@ -26,10 +26,15 @@ export function isLeaderSteer(message) {
 export function taskMessageInboxReceipt(store, message) {
     return message.inbox ?? messageRevisionWakes(store, message).find(wake => wake.inbox !== undefined)?.inbox;
 }
-/** Delivery suppresses repeat notification of that revision, but remains
- * distinct from handling. The original fixed window stays in the own inbox. */
-export function deliveredMessageWake(store, message) {
-    return messageRevisionWakes(store, message).find(wake => wake.status === "consumed");
+/** Acceptance or explicit no-replay release suppresses repeat notification,
+ * never handling. The original fixed window stays in the own inbox. */
+export function nonReplayableMessageWake(store, message) {
+    return messageRevisionWakes(store, message).find(wake => wake.status === "consumed" || releasedNotificationWake(store, message.taskId, wake.id));
+}
+/** Operational release is not acceptance. Keep its originals out of automatic
+ * delivery while permitting explicit inspection and settlement in the inbox. */
+export function releasedNotificationWake(store, taskId, wakeId) {
+    return store.listEventsByType(taskId, ["notification.resolved"]).some(event => event.payload.wakeId === wakeId && event.payload.outcome === "released-without-replay");
 }
 function messageRevisionWakes(store, message) {
     const revision = latestMessageUpdate(store, message);
@@ -37,7 +42,16 @@ function messageRevisionWakes(store, message) {
         && wake.refs?.some(ref => ref.type === "message" && ref.taskId === message.taskId && ref.id === message.id));
 }
 export function unfinishedLeaderInbox(store, taskId) {
-    return store.listTaskWakes(taskId).some(wake => wake.inbox !== undefined && wake.inbox.ack === undefined)
+    const sessions = store.getTaskRoleSessionSet(taskId, "leader");
+    const binding = sessions?.providerBinding;
+    const turn = binding?.run;
+    const nativeSessionId = binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId;
+    const active = (receipt) => receipt !== undefined && receipt.ack === undefined
+        && (receipt.claim.actor.attemptId === undefined || turn?.attemptId === receipt.claim.actor.attemptId
+            && receipt.claim.actor.agentId === sessions?.activeAgentId
+            && receipt.claim.actor.nativeSessionId === nativeSessionId
+            && ["submitting", "accepted", "delivery-unknown"].includes(turn.status));
+    return store.listTaskWakes(taskId).some(wake => active(wake.inbox))
         || operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message").some(message => isLeaderSteer(message)
-            && message.inbox !== undefined && message.inbox.ack === undefined);
+            && active(message.inbox));
 }

package/dist/repository/workspaceCleanupInspection.js

@@ -157,7 +157,12 @@ export async function inspectWorkspaceCleanup(store, git, workspace, disposition
                     const observed = (await git.inspect(entry.path, "HEAD")).baseCommit;
                     const baseline = task.projectBindings.find(binding => binding.projectId === entry.projectId)?.baseCommit;
                     const unchangedAbandonment = disposition === "abandoned" && baseline !== undefined && observed === baseline;
-                    if (!unchangedAbandonment && disposition === "abandoned" && (!covered?.merged || !covered.verified)) {
+                    if (covered?.deliveryRequirement === "excluded"
+                        && (baseline === undefined || observed !== baseline)
+                        && (!covered.merged || !covered.verified)) {
+                        check("excluded-project-retained", "Excluding delivery does not authorize discarding unique or unverified local commits.", { baseline: baseline ?? null, verifiedDelivery: true }, observed);
+                    }
+                    else if (!unchangedAbandonment && disposition === "abandoned" && (!covered?.merged || !covered.verified)) {
                         check("delivery-coverage", "Abandonment does not discard unverified local commits; only the exact unchanged baseline is disposable.", { baseline: baseline ?? null, verifiedDelivery: true }, observed);
                     }
                     else if (!unchangedAbandonment && expected != null && expected !== observed && covered?.deliveryLocalCommit !== observed) {

package/dist/storage/sqliteSchema.js

@@ -133,6 +133,27 @@ const MINOR_UPGRADES = Object.freeze([{
         // New Task Job semantic writes also append job.state-changed events; no old
         // Job history is backfilled and the SQL layout remains unchanged.
         sql: ""
+    }, {
+        fromVersion: "1.11",
+        toVersion: "1.12",
+        name: "project-delivery-scope",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // New append-only Project scope decisions use Task events. Preserve all old
+        // completion, binding and publication records; absence still means required.
+        sql: ""
+    }, {
+        fromVersion: "1.12",
+        toVersion: "1.13",
+        name: "inbox-turn-handling",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Claims may name their exact current attempt; explicit Global retirement
+        // and terminal-check notices preserve original records. Never backfill
+        // historical turn ownership, handling evidence or acknowledgements.
+        sql: ""
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)

package/dist/storage/sqliteStore.js

@@ -989,10 +989,22 @@ export class SqliteTaskStore {
         const params = { name: roleName };
         if (query.handling)
             where.push(`json_extract(payload, '$.inbox.claim') IS NOT NULL
-      AND json_extract(payload, '$.inbox.ack') IS NULL`);
+      AND json_extract(payload, '$.inbox.ack') IS NULL
+      AND json_extract(payload, '$.inbox.retirement') IS NULL`);
+        if (query.unclaimed)
+            where.push("json_extract(payload, '$.inbox') IS NULL");
+        if (query.handlingExceptSession !== undefined) {
+            if (!query.handling)
+                throw new Error("A handling Session filter requires a handling query.");
+            where.push(`(json_extract(payload, '$.inbox.claim.actor.agentId') != @handlingAgent
+        OR json_extract(payload, '$.inbox.claim.actor.nativeSessionId') != @handlingSession)`);
+            params.handlingAgent = query.handlingExceptSession.agentId;
+            params.handlingSession = query.handlingExceptSession.nativeSessionId;
+        }
         if (query.pending)
             where.push(`json_extract(payload, '$.delivery') IS NULL
       AND json_extract(payload, '$.inbox.ack') IS NULL
+      AND json_extract(payload, '$.inbox.retirement') IS NULL
       AND json_extract(payload, '$.notDelivered') IS NULL
       AND (json_extract(payload, '$.inputControl.action') = 'queue'
         OR json_extract(payload, '$.interruptThen') IS NOT NULL)`);

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.11";
+export const CURRENT_STORAGE_VERSION = "1.13";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/task/archiveDiagnostics.js

@@ -76,7 +76,7 @@ export function archiveRetainedResources(store, task) {
     return resources;
 }
 export function archiveDeliveryWarnings(delivery) {
-    return delivery.projects.filter(p => p.codeDelivery !== "none" && (!p.merged || !p.verified))
+    return delivery.projects.filter(p => p.deliveryRequired && (!p.merged || !p.verified))
         .map(p => ({ resource: `delivery:${delivery.taskId}/${p.projectId}`,
         detail: `${p.coverage}: ${p.reason} Merged=${p.merged}; verified=${p.verified}.` }));
 }

package/dist/task/archivePreflight.js

@@ -65,7 +65,7 @@ export async function inspectTaskArchive(coordinator, request) {
         throw new Error(`Task not found: ${request.taskId}.`);
     const settlement = archiveSettlementChecks(store, task);
     const delivery = await readArchiveDelivery(store, preparer.git, task, request.force);
-    const deliveryChecks = delivery.projects.filter(p => p.codeDelivery !== "none" && (!p.merged || !p.verified))
+    const deliveryChecks = delivery.projects.filter(p => p.deliveryRequired && (!p.merged || !p.verified))
         .map(p => ({ resource: `delivery:${task.id}/${p.projectId}`, reason: "delivery-coverage", status: "blocked",
         detail: p.reason, expected: { merged: true, verified: true, localCommit: p.expectedLocalCommit },
         observed: { coverage: p.coverage, merged: p.merged, verified: p.verified, localCommit: p.publication?.localCommit ?? null },

package/dist/task/projectDeliveryScope.js

@@ -0,0 +1,20 @@
+/** An append-only Task decision, not a Project permission or a merge fact. */
+export const PROJECT_DELIVERY_DECIDED_EVENT = "task.project-delivery-decided";
+export function projectDeliveryDecision(events, taskId, projectId) {
+    return events.filter(event => event.taskId === taskId
+        && event.type === PROJECT_DELIVERY_DECIDED_EVENT && event.payload.projectId === projectId)
+        // Task event IDs are monotonic durable sequence numbers; wall clocks can move backwards.
+        .sort((a, b) => a.id.localeCompare(b.id, undefined, { numeric: true })).at(-1) ?? null;
+}
+export function projectDeliveryRequirement(decision) {
+    if (decision === null)
+        return "required";
+    const p = decision.payload;
+    if (!["required", "excluded"].includes(p.requirement ?? "")
+        || !p.reason?.trim() || !p.sourceMessageId?.trim()
+        || !/^[a-f0-9]{64}$/u.test(p.sourceDigest ?? "") || !p.purpose?.trim()
+        || !["user", "operator", "leader"].includes(p.by ?? "")) {
+        throw new Error(`Project delivery decision ${decision.id} has incomplete evidence; preserve it for diagnosis.`);
+    }
+    return p.requirement;
+}

package/dist/task/publicationToolObservation.js

@@ -74,12 +74,10 @@ export function assertPublicationToolObservation(publication, observation, now,
         throw usageError("Tool observation externalUrl must match the recorded Publication service and object.");
     }
     const url = new URL(canonicalPublicationUrl(observation.externalUrl, publication.provider));
-    const path = publication.provider === "gitlab"
-        ? `/${publication.repository}/-/merge_requests/${publication.externalId}`
-        : `/${publication.repository.toLowerCase()}/pull/${publication.externalId}`;
-    // The registered URL comparison above pins the host AND any service prefix.
-    // GitLab may be served below a relative root such as /gitlab.
-    if (publication.provider === "gitlab" ? !url.pathname.endsWith(path) : url.pathname !== path) {
+    // GitLab UI routes are deployment-specific. Structured identity above and
+    // the complete registered URL bind the object without inventing a web route.
+    if (publication.provider === "github"
+        && url.pathname !== `/${publication.repository.toLowerCase()}/pull/${publication.externalId}`) {
         throw usageError("Tool observation URL does not match the repository and PR/MR identity.");
     }
     const observed = Date.parse(observation.observedAt);

package/dist/task/remoteDelivery.js

@@ -1,4 +1,5 @@
 import { publicationAdoption } from "./publicationAdoption.js";
+import { projectDeliveryDecision, projectDeliveryRequirement } from "./projectDeliveryScope.js";
 /**
  * One read-only delivery projection over existing Task, workspace, completion,
  * and Publication facts. It never writes a merged flag or queries a provider.
@@ -10,6 +11,8 @@ export function projectTaskRemoteDelivery(facts) {
     const currentPublications = currentPublicationReferences(facts.publications);
     const projects = facts.task.projectBindings.map((binding) => {
         const expectedLocalCommit = expected.commits.get(binding.projectId) ?? null;
+        const scopeDecision = projectDeliveryDecision(facts.events, facts.task.id, binding.projectId);
+        const deliveryRequirement = projectDeliveryRequirement(scopeDecision);
         const baseCommit = baseCommits.get(binding.projectId) ?? null;
         const codeDelivery = expectedLocalCommit === null
             ? "unknown"
@@ -44,6 +47,9 @@ export function projectTaskRemoteDelivery(facts) {
             deliveryLocalCommit: covers ? publication.localCommit ?? null : null,
             adoption,
             codeDelivery,
+            deliveryRequirement,
+            scopeDecision,
+            deliveryRequired: deliveryRequirement === "required" && codeDelivery !== "none",
             publication,
             state: publication?.state ?? null,
             verification: publication?.verification ?? null,
@@ -51,23 +57,26 @@ export function projectTaskRemoteDelivery(facts) {
             coverage,
             merged,
             verified,
-            reason: projectCoverageReason(expectedLocalCommit, publication, coverage, adoption) + (coverage === "stale" && adoptionEvidence?.reason
+            reason: (deliveryRequirement === "excluded"
+                ? `No delivery obligation: ${scopeDecision.payload.reason} (${scopeDecision.id}). Merge and cleanup facts remain separate. `
+                : "") + projectCoverageReason(expectedLocalCommit, publication, coverage, adoption) + (coverage === "stale" && adoptionEvidence?.reason
                 ? ` ${adoptionEvidence.reason}` : "")
         };
     });
     const codeProjects = projects.filter((project) => project.codeDelivery !== "none");
-    const mergedProjectCount = codeProjects.filter((project) => project.merged).length;
-    const verifiedProjectCount = codeProjects.filter((project) => project.verified).length;
-    const allMerged = codeProjects.every((project) => project.merged);
-    const allVerified = codeProjects.every((project) => project.verified);
-    const status = codeProjects.length === 0
+    const requiredProjects = projects.filter(project => project.deliveryRequired);
+    const mergedProjectCount = requiredProjects.filter((project) => project.merged).length;
+    const verifiedProjectCount = requiredProjects.filter((project) => project.verified).length;
+    const allMerged = requiredProjects.every((project) => project.merged);
+    const allVerified = requiredProjects.every((project) => project.verified);
+    const status = requiredProjects.length === 0
         ? "none"
-        : codeProjects.some((project) => project.coverage === "head-unavailable")
+        : requiredProjects.some((project) => project.coverage === "head-unavailable")
             ? "unavailable"
             : allMerged
                 ? allVerified ? "merged" : "unverified"
                 : mergedProjectCount > 0 ? "partial"
-                    : codeProjects.some(p => p.state === "merged") ? "uncovered" : "pending";
+                    : requiredProjects.some(p => p.state === "merged") ? "uncovered" : "pending";
     return {
         taskId: facts.task.id,
         source: expected.source,
@@ -81,6 +90,8 @@ export function projectTaskRemoteDelivery(facts) {
         allVerified,
         totalProjectCount: projects.length,
         codeProjectCount: codeProjects.length,
+        requiredCodeProjectCount: requiredProjects.length,
+        excludedProjectCount: projects.filter(project => project.deliveryRequirement === "excluded").length,
         mergedProjectCount,
         verifiedProjectCount,
         integratedCoverageSatisfied: allMerged && allVerified,

package/dist/task/remoteDeliveryService.js

@@ -2,6 +2,7 @@ import { isDeepStrictEqual } from "node:util";
 import { usageError } from "../errors/cliError.js";
 import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
 import { PUBLICATION_ADOPTED_EVENT } from "./publicationAdoption.js";
+import { PROJECT_DELIVERY_DECIDED_EVENT } from "./projectDeliveryScope.js";
 export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate = null) {
     return createTaskRemoteDeliveryProof(store, task, currentCandidate).delivery;
 }
@@ -10,7 +11,7 @@ export function createTaskRemoteDeliveryProof(store, task, currentCandidate = nu
     const delivery = projectTaskRemoteDelivery({
         task,
         events: store.listEventsByType(task.id, [
-            "task.completed", "task.archived", PUBLICATION_ADOPTED_EVENT
+            "task.completed", "task.archived", PUBLICATION_ADOPTED_EVENT, PROJECT_DELIVERY_DECIDED_EVENT
         ]),
         publications,
         managedWorkspaces: store.listManagedWorkspaces(task.id),
@@ -49,13 +50,13 @@ export function assertTaskRemoteDeliveryProof(store, task, proof) {
 }
 export function assertTaskRemoteDeliveryIntegrated(delivery) {
     if (!delivery.allMerged) {
-        const headUnavailable = delivery.projects.filter((project) => (project.codeDelivery !== "none"
+        const headUnavailable = delivery.projects.filter((project) => (project.deliveryRequired
             && project.coverage === "head-unavailable"));
         if (headUnavailable.length > 0 && delivery.source === "task-completed") {
             throw usageError(`Task ${delivery.taskId} has no frozen completion heads for: ${headUnavailable.map(({ projectId }) => projectId).join(", ")}. Historical acceptance cannot be inferred from a merge or archive.`);
         }
         const uncovered = delivery.projects
-            .filter((project) => project.codeDelivery !== "none" && !project.merged)
+            .filter((project) => project.deliveryRequired && !project.merged)
             .map((project) => (`${project.projectId}/${project.coverage}`
             + (project.publication === null ? "" : `/${project.publication.id}`)))
             .join(", ");
@@ -65,7 +66,7 @@ export function assertTaskRemoteDeliveryIntegrated(delivery) {
     if (delivery.allVerified)
         return;
     const unverified = delivery.projects
-        .filter((project) => (project.codeDelivery !== "none"
+        .filter((project) => (project.deliveryRequired
         && project.merged
         && !project.verified))
         .map((project) => (`${project.projectId}/${project.coverage}`

package/dist/web/assets/client/i18n/en.js

@@ -1052,7 +1052,7 @@ export const EN = {
     "messageKind.operator": "Operator",
     "messageKind.role-result": "Role result",
     "messageKind.system": "System",
-    "remoteDelivery.none": "No code delivery",
+    "remoteDelivery.none": "No delivery obligation",
     "remoteDelivery.unavailable": "Exact heads unavailable",
     "remoteDelivery.pending": "Not delivered",
     "remoteDelivery.uncovered": "Merged, acceptance not covered",
@@ -1084,7 +1084,9 @@ export const EN = {
     "delivery.title": "Integration and delivery",
     "delivery.hint": "Integration checks, PR/MR and remote merge are separate facts; none of them is acceptance.",
     "delivery.readAt": "Evidence read at",
-    "delivery.counts": "{merged}/{total} code projects merged · {verified}/{total} verified",
+    "delivery.counts": "{merged}/{total} required code projects merged · {verified}/{total} verified",
+    "delivery.excluded": "Excluded from delivery",
+    "delivery.scopeDecision": "Scope decision",
     "delivery.noProjects": "No project is bound to this Task.",
     "evidence.loading": "Reading original evidence…",
     "evidence.report": "Original review report",

package/dist/web/assets/client/i18n/zh-CN.js

@@ -1048,7 +1048,7 @@ export const ZH_CN = {
     "messageKind.operator": "Operator",
     "messageKind.role-result": "Role 结果",
     "messageKind.system": "系统",
-    "remoteDelivery.none": "无代码交付",
+    "remoteDelivery.none": "无交付义务",
     "remoteDelivery.unavailable": "精确 head 不可用",
     "remoteDelivery.pending": "尚未交付",
     "remoteDelivery.uncovered": "已合并，未覆盖验收",
@@ -1080,7 +1080,9 @@ export const ZH_CN = {
     "delivery.title": "集成与交付",
     "delivery.hint": "集成检查、PR/MR 与远程合并是不同事实，都不等于验收。",
     "delivery.readAt": "证据读取于",
-    "delivery.counts": "已合入 {merged}/{total} 个代码项目 · 已验证 {verified}/{total}",
+    "delivery.counts": "已合入 {merged}/{total} 个应交付代码项目 · 已验证 {verified}/{total}",
+    "delivery.excluded": "已排除交付",
+    "delivery.scopeDecision": "交付范围决定",
     "delivery.noProjects": "此任务未绑定项目。",
     "evidence.loading": "正在读取原始证据…",
     "evidence.report": "原始评审报告",

package/dist/web/assets/client/views/task/deliveryResults.js

@@ -53,9 +53,9 @@ function drawResults(body, scope) {
 function drawRemote(body, remote, t) {
   body.append(h("h4.sub-head", null, icon("package", "icon-sm"), h("span", null, t("evidence.remote")),
     badge(t("remoteDelivery." + remote.status, remote.status), DELIVERY_TONES[remote.status] || "idle", { dot: true })));
-  if (remote.codeProjectCount) {
+  if (remote.requiredCodeProjectCount) {
     body.append(h("p.faint.small", null, fill(t("delivery.counts"), {
-      merged: remote.mergedProjectCount, verified: remote.verifiedProjectCount, total: remote.codeProjectCount
+      merged: remote.mergedProjectCount, verified: remote.verifiedProjectCount, total: remote.requiredCodeProjectCount
     })));
   }
   (remote.projects || []).forEach(function (project) { body.append(projectRow(project, t)); });
@@ -85,6 +85,7 @@ function projectRow(project, t) {
   const href = publication && publication.externalUrl && safeUrl(publication.externalUrl);
   const element = h("article.record.delivery-project");
   element.append(h("header.record-head", null, icon("folder", "icon-sm"), h("strong", null, project.directory || project.projectId),
+    project.deliveryRequirement === "excluded" ? chip(t("delivery.excluded")) : null,
     project.coverage ? chip(label(t, "coverage", project.coverage)) : null,
     h("span.spacer"),
     publication ? (href
@@ -97,6 +98,9 @@ function projectRow(project, t) {
     project.state ? chip(label(t, "publicationState", project.state)) : null,
     project.verification ? chip(t("evidence.verification") + " · " + label(t, "verification", project.verification)) : null,
     project.adoption ? h("span", null, t("evidence.adoption") + " ", mono(project.adoption.id)) : null));
+  if (project.scopeDecision) element.append(h("p.faint.small", null,
+    t("delivery.scopeDecision") + " " + project.scopeDecision.id + " · "
+    + project.scopeDecision.payload.sourceMessageId + " · " + project.scopeDecision.payload.reason));
   return element;
 }