@zq-silk/yui 0.8.9 → 0.10.0

package/dist/storage/migration/productionRegistry.js

@@ -20,6 +20,8 @@ const PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION = 3;
 const PROJECT_KNOWLEDGE_PROPOSALS_TO_VERSION = 4;
 const TASK_FROM_VERSION = 3;
 const TASK_TO_VERSION = 4;
+const TASK_INTENT_FROM_VERSION = 4;
+const TASK_INTENT_TO_VERSION = 5;
 const WORK_ITEM_FROM_VERSION = 6;
 const WORK_ITEM_TO_VERSION = 7;
 const WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION = 7;
@@ -45,6 +47,8 @@ const REVIEW_ROUND_FROM_VERSION = 2;
 const REVIEW_ROUND_TO_VERSION = 3;
 const REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION = 3;
 const REVIEW_ROUND_GIT_SNAPSHOT_TO_VERSION = 4;
+const REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION = 4;
+const REVIEW_ROUND_TASK_ANCHOR_TO_VERSION = 5;
 const ACTIVE_RUN_POINTER_FROM_VERSION = 1;
 const ACTIVE_RUN_POINTER_TO_VERSION = 2;
 const ACTIVE_RUN_POINTER_NAMESPACE_FROM_VERSION = 2;
@@ -136,6 +140,7 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(configV2Step())
         .registerCompatible(projectKnowledgeProposalsStep())
         .registerOfflineMigration(taskWorkspaceIdentityStep())
+        .registerOfflineMigration(taskIntentStep())
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_FROM_VERSION, WORK_ITEM_TO_VERSION, "workItems"))
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION, WORK_ITEM_GIT_SNAPSHOT_TO_VERSION, "workItems"))
         .registerOfflineMigration(workItemExecutionGroupHistoryStep())
@@ -146,6 +151,7 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(messageWakePolicyStep())
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_FROM_VERSION, REVIEW_ROUND_TO_VERSION, "reviewRounds"))
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION, REVIEW_ROUND_GIT_SNAPSHOT_TO_VERSION, "reviewRounds"))
+        .registerOfflineMigration(reviewRoundTaskAnchorStep())
         .registerOfflineMigration(recordFamilyStep("activeRunPointer", ACTIVE_RUN_POINTER_FROM_VERSION, ACTIVE_RUN_POINTER_TO_VERSION, "activeRuns"))
         .registerOfflineMigration(managedWorkspaceFamilyStep())
         .registerOfflineMigration(activeRunPointerNamespaceStep())
@@ -1546,6 +1552,65 @@ function recordFamilyStep(recordKind, fromVersion, toVersion, taskMapKey) {
         declaredEffects: []
     };
 }
+function reviewRoundTaskAnchorStep() {
+    return {
+        axis: "record",
+        recordKind: "reviewRound",
+        fromVersion: REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION,
+        toVersion: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION,
+        preconditions: (snapshot) => requireRecordFamilyVersion(snapshot, "reviewRound", REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION, "reviewRounds"),
+        transform: migrateReviewRoundTaskAnchors,
+        declaredEffects: []
+    };
+}
+function migrateReviewRoundTaskAnchors(snapshot) {
+    requireRecordFamilyVersion(snapshot, "reviewRound", REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION, "reviewRounds");
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            reviewRound: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const aggregate = asObject(rawTask, `Task aggregate ${taskId}`);
+        const rawRounds = aggregate.reviewRounds;
+        if (rawRounds === undefined) {
+            nextTasks[taskId] = { ...aggregate };
+            continue;
+        }
+        const rounds = asObject(rawRounds, `reviewRound map ${taskId}`);
+        const nextRounds = {};
+        for (const [roundId, rawRound] of Object.entries(rounds)) {
+            const round = asObject(rawRound, `reviewRound ${taskId}/${roundId}`);
+            if (round.scope !== "task") {
+                nextRounds[roundId] = {
+                    ...round,
+                    schemaVersion: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION
+                };
+                continue;
+            }
+            const workItemId = requiredMigrationText(round.workItemId, `reviewRound ${taskId}/${roundId} WorkItem id`);
+            const candidateId = requiredMigrationText(round.candidateId, `reviewRound ${taskId}/${roundId} Candidate id`);
+            const { workItemId: _workItemId, candidateId: _candidateId, schemaVersion: _schemaVersion, ...retained } = round;
+            nextRounds[roundId] = {
+                ...retained,
+                schemaVersion: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION,
+                legacyAnchor: { workItemId, candidateId }
+            };
+        }
+        nextTasks[taskId] = { ...aggregate, reviewRounds: nextRounds };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 function agentRunContextProtocolStep() {
     return {
         axis: "record",
@@ -2747,6 +2812,79 @@ function migrateTaskV3ToV4(snapshot) {
         state: { ...snapshot.state, tasks: nextTasks }
     };
 }
+/**
+ * Task v5 replaces the stored delivery topology switch with an optional,
+ * Project-defined intent. Historical topology is retained as audit context,
+ * but no current workflow decision reads it.
+ */
+function taskIntentStep() {
+    return {
+        axis: "record",
+        recordKind: "task",
+        fromVersion: TASK_INTENT_FROM_VERSION,
+        toVersion: TASK_INTENT_TO_VERSION,
+        preconditions: requireTaskV4Family,
+        transform: migrateTaskV4ToV5,
+        declaredEffects: []
+    };
+}
+function requireTaskV4Family(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.task !== TASK_INTENT_FROM_VERSION) {
+        throw new Error(`Record task migration requires manifest version ${TASK_INTENT_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const aggregate = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (aggregate.task === undefined)
+            continue;
+        const record = asObject(aggregate.task, `Task ${taskId}`);
+        if (record.schemaVersion !== TASK_INTENT_FROM_VERSION) {
+            throw new Error(`Task ${taskId} must use schemaVersion ${TASK_INTENT_FROM_VERSION}.`);
+        }
+    }
+}
+function migrateTaskV4ToV5(snapshot) {
+    requireTaskV4Family(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...manifestVersions, task: TASK_INTENT_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const aggregate = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (aggregate.task === undefined) {
+            nextTasks[taskId] = { ...aggregate };
+            continue;
+        }
+        const task = asObject(aggregate.task, `Task ${taskId}`);
+        const { requireIntegration, schemaVersion: _schemaVersion, ...retained } = task;
+        const projectBindings = Array.isArray(task.projectBindings)
+            ? task.projectBindings
+            : [];
+        const legacyDeliveryPath = projectBindings.length === 0
+            ? undefined
+            : requireIntegration === true ? "integrated" : "direct";
+        nextTasks[taskId] = {
+            ...aggregate,
+            task: {
+                ...retained,
+                schemaVersion: TASK_INTENT_TO_VERSION,
+                ...(legacyDeliveryPath === undefined ? {} : { legacyDeliveryPath })
+            }
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 /**
  * A version bump is deliverable only when the shared planner resolves the full
  * adjacent path. This also covers target-only record families as explicit 0->1

package/dist/storage/sqliteStore.js

@@ -722,11 +722,12 @@ export class SqliteTaskStore {
                 id: task.id,
                 status: task.status,
                 projectBindings: task.projectBindings,
-                requireIntegration: task.requireIntegration
+                type: task.type
             },
             workItems: this.#sortById(this.#listPayload("work_items", "task_id = ?", [taskId]), (item) => item.id),
             changeSets: this.#sortById(this.#listPayload("change_sets", "task_id = ?", [taskId]), (changeSet) => changeSet.id),
             integrations: this.#sortById(this.#listPayload("integration_attempts", "task_id = ?", [taskId]), (attempt) => attempt.id),
+            integrationQueueEntries: this.#sortById(this.#listPayload("integration_queue", "task_id = ?", [taskId]), (entry) => entry.id),
             reviewRounds: this.#sortById(this.#listPayload("review_rounds", "task_id = ?", [taskId]), (round) => round.id),
             taskFinalReviewContractEvents: events
                 .filter((event) => event.type === TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT),

package/dist/storage/taskStore.js

@@ -62,13 +62,13 @@ export const CURRENT_PROJECT_SCHEMA_VERSION = 4;
 export const CURRENT_AGENT_PROFILE_SCHEMA_VERSION = 2;
 export const CURRENT_GLOBAL_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 3;
-export const CURRENT_TASK_SCHEMA_VERSION = 4;
+export const CURRENT_TASK_SCHEMA_VERSION = 5;
 export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
 export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION = 2;
 export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 9;
-export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 4;
+export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 5;
 export const CURRENT_CHANGE_SET_SCHEMA_VERSION = 3;
 export const CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION = 4;
 export const CURRENT_MESSAGE_SCHEMA_VERSION = 3;
@@ -417,11 +417,12 @@ export class FileTaskStore {
                 id: aggregate.task.id,
                 status: aggregate.task.status,
                 projectBindings: aggregate.task.projectBindings,
-                requireIntegration: aggregate.task.requireIntegration
+                type: aggregate.task.type
             },
             workItems: values(aggregate.workItems, "id"),
             changeSets: values(aggregate.changeSets, "id"),
             integrations: values(aggregate.integrationAttempts, "id"),
+            integrationQueueEntries: values(aggregate.integrationQueue, "id"),
             reviewRounds: values(aggregate.reviewRounds, "id"),
             taskFinalReviewContractEvents: events
                 .filter((event) => event.type === TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT),
@@ -1026,18 +1027,16 @@ export class FileTaskStore {
             throw new StorageRecordError(`ReviewRound belongs to another Task: ${stored.taskId}.`);
         }
         const aggregate = this.#requireTaskForWrite(taskId);
-        const item = aggregate.workItems[stored.workItemId];
-        if (item === undefined) {
-            throw new StorageRecordError(`ReviewRound Work Item not found: ${stored.workItemId}.`);
-        }
-        const candidate = item.candidates.find(({ id }) => id === stored.candidateId);
-        if (candidate === undefined) {
-            throw new StorageRecordError(`ReviewRound Candidate not found: ${stored.candidateId}.`);
-        }
-        assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${stored.id}`);
-        if ((stored.scope ?? "work-item") === "task"
-            && !sameTaskFinalReviewContract(stored.taskFinalReviewContract, candidate.taskFinalReviewContract)) {
-            throw new StorageRecordError(`Task ReviewRound contract does not match its Candidate: ${stored.id}.`);
+        if ((stored.scope ?? "work-item") === "work-item") {
+            const item = aggregate.workItems[stored.workItemId];
+            if (item === undefined) {
+                throw new StorageRecordError(`ReviewRound Work Item not found: ${stored.workItemId}.`);
+            }
+            const candidate = item.candidates.find(({ id }) => id === stored.candidateId);
+            if (candidate === undefined) {
+                throw new StorageRecordError(`ReviewRound Candidate not found: ${stored.candidateId}.`);
+            }
+            assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${stored.id}`);
         }
         if (stored.reviewerRunId !== undefined) {
             const reviewerRun = aggregate.agentRuns[stored.reviewerRunId];
@@ -3349,24 +3348,23 @@ function validateCanonicalTaskReferences(state, aggregate) {
         }
     }
     for (const round of Object.values(aggregate.reviewRounds)) {
-        const item = aggregate.workItems[round.workItemId];
-        if (item === undefined) {
-            throw new StorageRecordError(`ReviewRound references are invalid: ${round.id}.`);
-        }
-        const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-        if (candidate === undefined) {
-            throw new StorageRecordError(`ReviewRound Candidate not found: ${round.candidateId}.`);
-        }
-        assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${round.id}`);
         if ((round.scope ?? "work-item") === "task") {
             const frozenProjects = round.taskCandidate?.projects ?? [];
             if (frozenProjects.length !== boundProjects.size
                 || frozenProjects.some(({ projectId }) => !boundProjects.has(projectId))) {
                 throw new StorageRecordError(`Task ReviewRound Projects do not match Task scope: ${round.id}.`);
             }
-            if (!sameTaskFinalReviewContract(round.taskFinalReviewContract, candidate.taskFinalReviewContract)) {
-                throw new StorageRecordError(`Task ReviewRound contract does not match its Candidate: ${round.id}.`);
+        }
+        else {
+            const item = aggregate.workItems[round.workItemId];
+            if (item === undefined) {
+                throw new StorageRecordError(`ReviewRound references are invalid: ${round.id}.`);
+            }
+            const candidate = item.candidates.find(({ id }) => id === round.candidateId);
+            if (candidate === undefined) {
+                throw new StorageRecordError(`ReviewRound Candidate not found: ${round.candidateId}.`);
             }
+            assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${round.id}`);
         }
         if (round.reviewerRunId !== undefined) {
             const reviewerRun = aggregate.agentRuns[round.reviewerRunId];
@@ -3496,7 +3494,9 @@ function assertManagedWorkspaceReferences(aggregate, workspace, label, workItemO
             if (workspace.entries.some(({ access }) => access !== "write")) {
                 throw new StorageRecordError(`${label} ReviewRound workspace must be writable: ${taskId}/${round.id}.`);
             }
-            const item = aggregate.workItems[round.workItemId];
+            const item = round.workItemId === undefined
+                ? undefined
+                : aggregate.workItems[round.workItemId];
             const candidate = item?.candidates.find(({ id }) => id === round.candidateId);
             const frozenProjects = round.scope === "task"
                 ? round.taskCandidate?.projects

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -298,7 +298,7 @@ function describeOfflineBlockers(inventory) {
         return `${index + 1}. ${identity.length === 0 ? "identity=unknown" : identity} ` +
             `reason=${reason}`;
     });
-    return `Offline migration blocked by ${inventory.total} active runtime item(s). ` +
+    return `Offline Home migration cannot start while ${inventory.total} runtime obligation(s) remain. ` +
         lines.join("; ");
 }
 async function readOfflineInventory(options, home) {
@@ -315,15 +315,43 @@ async function readOfflineInventory(options, home) {
 }
 function offlineInventoryBlocker(inventory, sceneUnchanged) {
     const lifecycleOnly = inventory.blockers.every(({ reason }) => (reason === "pending-mailbox" || reason === "pending-inbox"));
+    const runtimeUnknown = inventory.blockers.some(({ reason }) => (reason === "native-session-unknown"));
+    const action = lifecycleOnly
+        ? (sceneUnchanged
+            ? "No binary, Controller, fence, or Home change was made. Wait for the listed lifecycle "
+                + "events to settle, then re-run `yui update`."
+            : "The Home was not switched. Wait for the listed lifecycle events to settle, then "
+                + "re-run `yui update`.")
+        : runtimeUnknown
+            ? (sceneUnchanged
+                ? "Offline Home migration could not confirm that every native Session is stopped. Run "
+                    + "`yui controller status --verbose` from a normal shell and inspect the reported "
+                    + "runtime ownership. Use `yui controller cleanup` only for resources it classifies "
+                    + "for cleanup, then re-run `yui update`; do not kill unknown processes blindly. No "
+                    + "binary, Controller, fence, or Home change was made."
+                : "The Home was not switched because native Session state could not be confirmed. Run "
+                    + "`yui controller status --verbose`, inspect the reported ownership, and use "
+                    + "`yui controller cleanup` only for resources it classifies for cleanup before "
+                    + "retrying; do not kill unknown processes blindly.")
+            : (sceneUnchanged
+                ? "This version requires an offline Home migration with every managed Agent Session "
+                    + "stopped. Let the listed Turns or Runs finish. If the installed `yui` supports "
+                    + "`session stop --all`, run `yui session stop --all` from a normal shell; otherwise "
+                    + "exit every listed managed Session manually. Then re-run `yui update`. No binary, "
+                    + "Controller, fence, or Home change was made."
+                : "The Home was not switched. Let the listed Turns or Runs finish. If the installed "
+                    + "`yui` supports `session stop --all`, run `yui session stop --all` from a normal "
+                    + "shell; otherwise exit every listed managed Session manually. Then re-run "
+                    + "`yui update`.");
     return {
         outcome: "blocked",
-        stage: lifecycleOnly ? "drain-incomplete" : "active-sessions",
+        stage: lifecycleOnly
+            ? "drain-incomplete"
+            : runtimeUnknown
+                ? "runtime-unknown"
+                : "active-sessions",
         message: describeOfflineBlockers(inventory),
-        action: sceneUnchanged
-            ? "No binary, Controller, fence, or Home change was made. Keep working; when every " +
-                "listed runtime obligation is clear, re-run `yui update` so preflight is repeated."
-            : "The Home was not switched. Let every listed runtime obligation settle, then re-run " +
-                "`yui update`; do not kill, reset, rebind, or retry the blocked runtime blindly.",
+        action,
         blockers: inventory.blockers,
         retryCommand: "yui update",
         ...(sceneUnchanged ? { sceneUnchanged: true } : {})

package/dist/task/completionReadiness.js

@@ -1,7 +1,9 @@
+import { changeSetDeliverySettled, governingChangeSets, integrationAttemptRequiresSettlement, latestGoverningQueueEntries } from "../integration/deliveryObligation.js";
 import { isReviewFindingBlocking } from "../review/reviewFinding.js";
 import { deltaRecheckBlocksAcceptance } from "../review/reviewRound.js";
 import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
 import { reviewFindingLedgerWriteFailedFromEvents } from "../review/reviewFindingLedger.js";
+import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractRebind.js";
 import { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 const ACTIVE_JOB_STATUSES = new Set([
     "queued",
@@ -20,6 +22,7 @@ export function projectCompletionReadiness(facts, options = {}) {
     const advisories = [];
     const { task } = facts;
     const findingsGate = options.findingsGate ?? true;
+    const taskFinalReviewRequired = resolveRecordedTaskFinalReviewContract(task.id, facts.workItems, facts.reviewRounds, facts.taskFinalReviewContractEvents) !== undefined;
     // A pending/running Task-final Review must be resumed or blocked first.
     for (const round of facts.reviewRounds) {
         if ((round.scope ?? "work-item") !== "task")
@@ -49,7 +52,8 @@ export function projectCompletionReadiness(facts, options = {}) {
         .sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
         || left.id.localeCompare(right.id, undefined, { numeric: true })))
         .at(-1);
-    if (latestCompletedTaskReview !== undefined
+    if (taskFinalReviewRequired
+        && latestCompletedTaskReview !== undefined
         && deltaRecheckBlocksAcceptance(latestCompletedTaskReview)) {
         const round = latestCompletedTaskReview;
         const disposition = round.deltaRecheck.disposition;
@@ -97,37 +101,43 @@ export function projectCompletionReadiness(facts, options = {}) {
             fix: `wait for DurableJob ${job.id} to finish, or cancel it`
         });
     }
-    // requireIntegration Tasks need the full evidence chain.
-    if (task.requireIntegration === true) {
-        if (facts.workItems.length === 0) {
-            blockers.push({
-                code: "integration-evidence-missing",
-                ref: ref("task", task.id),
-                reason: `Task ${task.id} requires at least one WorkItem before completion.`,
-                fix: `yui task work create ${task.id} "<objective>"`
-            });
-        }
-        if (facts.changeSets.length === 0) {
-            blockers.push({
-                code: "integration-evidence-missing",
-                ref: ref("task", task.id),
-                reason: `Task ${task.id} requires at least one ChangeSet before completion.`,
-                fix: `yui task work capture ${task.id}/<work-item>`
-            });
-        }
-        if (!facts.integrations.some(({ status }) => status === "committed")) {
+    // Integration obligations follow only the Candidate that currently governs
+    // each independent delivery unit. Superseded Candidate history remains
+    // visible without keeping the Task open forever.
+    const deliveryChangeSets = governingChangeSets(facts.workItems, facts.changeSets);
+    for (const item of facts.workItems) {
+        if (item.status !== "completed")
+            continue;
+        const candidate = item.candidates?.at(-1);
+        const hasGitDelivery = candidate?.workspace !== undefined
+            || candidate?.gitSnapshot !== undefined;
+        if (hasGitDelivery
+            && !deliveryChangeSets.some((changeSet) => changeSet.workItemId === item.id)) {
             blockers.push({
                 code: "integration-evidence-missing",
-                ref: ref("task", task.id),
-                reason: `Task ${task.id} requires a committed Integration Attempt before completion.`,
-                fix: `yui task integration start ${task.id} --project <project> --change-set <change-set>`
+                ref: ref("work-item", item.id),
+                reason: `Completed WorkItem ${item.id} has an uncaptured Git delivery.`,
+                fix: `yui task work capture ${task.id}/${item.id}`
             });
         }
     }
-    // Unresolved Integration Attempts must settle.
+    for (const changeSet of deliveryChangeSets) {
+        if (changeSetDeliverySettled(changeSet, facts.integrations, facts.integrationQueueEntries))
+            continue;
+        blockers.push({
+            code: "integration-evidence-missing",
+            ref: ref("change-set", changeSet.id),
+            reason: `ChangeSet ${changeSet.id} is not part of a committed Integration.`,
+            fix: `yui task integration start ${task.id} --project ${changeSet.projectId} --change-set ${changeSet.id}`
+        });
+    }
+    // Current delivery Attempts and any Attempt that may still be writing must
+    // settle. Historical blocked Attempts remain audit evidence only.
     for (const integration of facts.integrations) {
         if (!UNRESOLVED_INTEGRATION_STATUSES.has(integration.status))
             continue;
+        if (!integrationAttemptRequiresSettlement(integration, deliveryChangeSets))
+            continue;
         blockers.push({
             code: "unresolved-integration",
             ref: ref("integration-attempt", integration.id),
@@ -136,7 +146,7 @@ export function projectCompletionReadiness(facts, options = {}) {
         });
     }
     // Unsettled integration queue entries must commit or be superseded.
-    for (const entry of facts.integrationQueueEntries) {
+    for (const entry of latestGoverningQueueEntries(deliveryChangeSets, facts.integrationQueueEntries)) {
         if (entry.status === "committed" || entry.status === "superseded")
             continue;
         blockers.push({