@zq-silk/yui 0.14.1 → 0.15.0

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -1,117 +1,305 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import Database from "better-sqlite3";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation } from "../../runtime/runtimeObservation.js";
+import { RUNTIME_PROCESS_EXIT_TASK_EVENT, validateRuntimeProcessExitObservation } from "../../runtime/processExitObservation.js";
+import { validateAgentProfile } from "../../profile/agentProfile.js";
+import { validateRoleSessionSet } from "../../executor/agentExecutor.js";
+import { validateReviewRound } from "../../review/reviewRound.js";
+import { validateTurn } from "../../turn/turn.js";
+import { validateWorkItem } from "../../workItem/workItem.js";
 import { SqliteTaskStore } from "../sqliteStore.js";
-import { inspectStorageSchema } from "../storageSchema.js";
-const CURRENT_DATABASE_FILENAME = "yui.db";
+import { migrateSqliteSchema, storageMigrationPlan } from "../sqliteSchema.js";
+import { CURRENT_DATABASE_FILENAME, inspectStorageSchema } from "../storageSchema.js";
+import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "../storageVersions.js";
 /**
- * Current-only storage admission. Historical Homes are preserved byte-for-byte
- * and rejected; Yui never repairs, normalizes, or upgrades them in place.
+ * Upgrade one valid Home through the complete linear migration chain.
+ *
+ * Supported earlier versions are readable only here. Ordinary stores still
+ * admit exactly {@link CURRENT_STORAGE_VERSION}; no old-shape normalizer or
+ * dual read path enters runtime code. Execute mode is an offline primitive:
+ * its caller must own the maintenance fence and keep the Controller quiesced
+ * for the whole backup, migration, and validation interval.
  */
 export async function runStorageUpgrade(options) {
-    const schema = inspectStorageSchema(options.home);
-    const classification = classifyCurrentHome(schema, options.latest);
-    if (schema.status === "uninitialized") {
-        return blocked(classification, "uninitialized", "Yui storage is not initialized for this Home.", "Run `yui setup` with a new Home.");
+    const state = inspectStorageSchema(options.home);
+    if (state.status === "uninitialized") {
+        return blocked({ ...corruptedClassification("Storage is not initialized."), uninitialized: true }, "uninitialized", "Yui storage is not initialized for this Home.", "Run `yui setup` with a new Home.");
     }
-    if (schema.status === "invalid") {
-        return blocked(classification, "corruption", `Storage schema is invalid: ${schema.detail}`, "Preserve this Home for diagnosis and initialize a new Home.");
+    if (state.status === "invalid") {
+        return blocked(corruptedClassification(state.detail), "corruption", `Storage is invalid: ${state.detail}`, "Preserve this Home for diagnosis and restore it from a known-good backup.");
     }
-    if (schema.status === "unsupported") {
-        return blocked(classification, "unsupported", `Storage contract is ${schema.direction}: ${schema.incompatibleComponent}.`, "Open the old Home only with its original Yui version to export a summary; then let the new Operator create a new Task in a new Home.");
+    if (state.status === "unsupported") {
+        const classification = unsupportedClassification(state);
+        return blocked(classification, "unsupported", classification.classification.verdict === "NEEDS_NEW_VERSION"
+            ? classification.classification.blocker.message
+            : "Storage is unsupported.", classification.classification.verdict === "NEEDS_NEW_VERSION"
+            ? classification.classification.blocker.action
+            : "Use a compatible Yui release.");
     }
-    if (!existsSync(join(options.home, CURRENT_DATABASE_FILENAME))) {
-        return blocked(corruptedClassification(classification, "The current SQLite database is missing."), "corruption", "The current SQLite Home is incomplete: yui.db is missing.", "Preserve this Home for diagnosis and initialize a new Home.");
-    }
-    try {
-        const store = new SqliteTaskStore(options.home);
+    if (state.status === "current") {
         try {
-            store.getConfig();
+            validateCurrentStore(options.home);
         }
-        finally {
-            store.close();
+        catch (error) {
+            return blocked(corruptedClassification(messageOf(error)), "corruption", `Current storage validation failed: ${messageOf(error)}`, "Preserve this Home for diagnosis and restore it from a known-good backup.");
+        }
+        const classification = currentClassification();
+        if (options.mode === "update-preflight") {
+            return {
+                outcome: "update-preflight",
+                status: "already-current",
+                stepCount: 0,
+                steps: [],
+                classification
+            };
         }
+        return {
+            outcome: "already-current",
+            classification,
+            report: {
+                outcome: "already-current",
+                mode: options.mode,
+                sourceVersion: CURRENT_STORAGE_VERSION,
+                targetVersion: CURRENT_STORAGE_VERSION,
+                steps: []
+            }
+        };
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return blocked(corruptedClassification(classification, message), "corruption", `Current storage validation failed: ${message}`, "Preserve this Home for diagnosis and initialize a new Home.");
+    const plan = storageMigrationPlan(state.currentVersion);
+    if (plan === null) {
+        return blocked(corruptedClassification(`No complete migration path exists from ${state.currentVersion} `
+            + `to ${CURRENT_STORAGE_VERSION}.`), "corruption", "The storage migration registry is incomplete.", "Install a Yui release that carries the complete migration chain.");
     }
+    const classification = migratableClassification(state.currentVersion);
     if (options.mode === "update-preflight") {
         return {
             outcome: "update-preflight",
-            status: "already-current",
-            stepCount: 0,
+            status: "migration-ready",
+            stepCount: plan.length,
+            steps: plan,
             classification
         };
     }
-    const report = {
-        outcome: "already-current",
-        mode: options.mode,
-        source: options.latest,
-        target: options.latest
-    };
-    return { outcome: "already-current", classification, report };
-}
-function classifyCurrentHome(schema, latest) {
-    const base = {
-        latestLayoutVersion: latest.layout,
-        latestAggregateVersion: latest.aggregate
-    };
-    if (schema.status === "uninitialized") {
+    if (options.mode === "dry-run") {
         return {
-            ...base,
-            classification: { verdict: "USABLE", status: "current" },
-            uninitialized: true
+            outcome: "upgrade-plan",
+            classification,
+            report: {
+                outcome: "upgrade-plan",
+                mode: "dry-run",
+                sourceVersion: state.currentVersion,
+                targetVersion: CURRENT_STORAGE_VERSION,
+                steps: plan
+            }
         };
     }
-    if (schema.status === "invalid") {
-        return corruptedClassification({
-            ...base,
-            classification: { verdict: "CORRUPTED", status: "unsupported", detail: schema.detail }
-        }, schema.detail);
-    }
-    if (schema.status === "unsupported") {
-        const blocker = schema.direction === "newer"
-            ? {
-                reason: "future-version",
-                axis: schema.incompatibleComponent,
-                ...(schema.recordFamily === undefined ? {} : { recordKind: schema.recordFamily }),
-                found: schema.currentVersion,
-                supported: schema.latestVersion,
-                message: "Historical storage contracts are not supported by this release.",
-                action: "Initialize a new Home."
-            }
-            : {
-                reason: "missing-step",
-                axis: schema.incompatibleComponent,
-                ...(schema.recordFamily === undefined ? {} : { recordKind: schema.recordFamily }),
-                from: schema.currentVersion,
-                to: schema.latestVersion,
-                message: "Historical storage contracts are not supported by this release.",
-                action: "Initialize a new Home."
-            };
+    let backupPath;
+    try {
+        backupPath = await createDatabaseBackup(options.home, state.currentVersion, options.now ?? new Date());
+    }
+    catch (error) {
+        return {
+            outcome: "failed",
+            stage: "backup",
+            message: `Storage backup failed: ${messageOf(error)}`,
+            action: "Storage was not modified. Resolve the backup path, permissions, or free-space problem "
+                + "and rerun `yui upgrade`.",
+            classification,
+            sceneUnchanged: true
+        };
+    }
+    let migrationCommitted = false;
+    try {
+        const database = new Database(join(options.home, CURRENT_DATABASE_FILENAME));
+        try {
+            database.pragma("journal_mode = WAL");
+            database.pragma("synchronous = FULL");
+            database.pragma("foreign_keys = ON");
+            database.pragma("busy_timeout = 5000");
+            migrateSqliteSchema(database, { mode: "apply" });
+            migrationCommitted = true;
+        }
+        finally {
+            database.close();
+        }
+        validateCurrentStore(options.home);
+        rmSync(join(options.home, "schema.json"), { force: true });
+    }
+    catch (error) {
+        const restoration = migrationCommitted
+            ? tryRestoreDatabaseBackup(options.home, backupPath)
+            : { restored: true };
         return {
-            ...base,
-            classification: {
-                verdict: "NEEDS_NEW_VERSION",
-                status: "unsupported",
-                blocker
-            },
-            layoutVersion: schema.currentLayoutVersion,
-            aggregateVersion: schema.currentAggregateSchemaVersion,
-            incompatibleComponent: schema.incompatibleComponent
+            outcome: "failed",
+            stage: "migration",
+            message: `Storage migration failed: ${messageOf(error)}`,
+            action: restoration.restored
+                ? "The original database was restored from the timestamped backup. "
+                    + "Resolve the reported problem and rerun `yui upgrade`."
+                : "Automatic restore also failed. Keep the Home quiesced and restore "
+                    + `${backupPath} manually before retrying. Restore error: ${restoration.error}`,
+            backupPath,
+            classification,
+            sceneUnchanged: restoration.restored
         };
     }
+    const finalState = inspectStorageSchema(options.home);
+    if (finalState.status !== "current") {
+        const restoration = tryRestoreDatabaseBackup(options.home, backupPath);
+        return {
+            outcome: "failed",
+            stage: "migration",
+            message: `Storage migration did not reach version ${CURRENT_STORAGE_VERSION}.`,
+            action: restoration.restored
+                ? "The original database was restored from the timestamped backup. "
+                    + "Inspect the migration registry before retrying."
+                : "Automatic restore also failed. Keep the Home quiesced and restore "
+                    + `${backupPath} manually before retrying. Restore error: ${restoration.error}`,
+            backupPath,
+            classification,
+            sceneUnchanged: restoration.restored
+        };
+    }
+    return {
+        outcome: "upgraded",
+        classification: currentClassification(),
+        report: {
+            outcome: "upgraded",
+            mode: "execute",
+            sourceVersion: state.currentVersion,
+            targetVersion: CURRENT_STORAGE_VERSION,
+            steps: plan,
+            backupPath
+        }
+    };
+}
+function validateCurrentStore(home) {
+    const store = new SqliteTaskStore(home);
+    try {
+        store.getConfig();
+        for (const profile of store.listAgentProfiles())
+            validateAgentProfile(profile);
+        for (const sessions of store.listGlobalRoleSessionSets()) {
+            validateRoleSessionSet(sessions);
+        }
+        for (const owner of store.listSessionOwners()) {
+            if (owner.schemaVersion !== 2
+                || typeof owner.runtimeGenerationId !== "string"
+                || Object.hasOwn(owner, "launchId")) {
+                throw new Error("Session owner runtime generation identity is invalid.");
+            }
+        }
+        for (const taskId of store.listTasks().map(({ id }) => id)) {
+            for (const item of store.listWorkItems(taskId))
+                validateWorkItem(item);
+            for (const round of store.listReviewRounds(taskId))
+                validateReviewRound(round);
+            for (const turn of store.listTurns(taskId))
+                validateTurn(turn);
+            for (const sessions of store.listRoleSessionSets(taskId)) {
+                validateRoleSessionSet(sessions);
+            }
+            for (const event of store.listEvents(taskId)) {
+                if (event.type === RUNTIME_OBSERVATION_TASK_EVENT) {
+                    createRuntimeObservation(JSON.parse(event.payload.observation ?? ""));
+                }
+                else if (event.type === RUNTIME_PROCESS_EXIT_TASK_EVENT) {
+                    validateRuntimeProcessExitObservation(JSON.parse(event.payload.observation ?? ""));
+                }
+            }
+        }
+        const quickCheck = store.databaseHandle().pragma("quick_check", { simple: true });
+        if (quickCheck !== "ok") {
+            throw new Error(`SQLite quick_check failed: ${String(quickCheck)}.`);
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+async function createDatabaseBackup(home, sourceVersion, now) {
+    const source = join(home, CURRENT_DATABASE_FILENAME);
+    if (!existsSync(source))
+        throw new Error("The authoritative yui.db is missing.");
+    const backupDirectory = join(dirname(home), `${basename(home)}-backups`);
+    mkdirSync(backupDirectory, { recursive: true, mode: 0o700 });
+    const timestamp = now.toISOString().replaceAll(":", "-");
+    const backupPath = join(backupDirectory, `pre-storage-v${sourceVersion}-${timestamp}.db`);
+    const database = new Database(source, { readonly: true, fileMustExist: true });
+    try {
+        await database.backup(backupPath);
+    }
+    finally {
+        database.close();
+    }
+    return backupPath;
+}
+function restoreDatabaseBackup(home, backupPath) {
+    const databasePath = join(home, CURRENT_DATABASE_FILENAME);
+    rmSync(`${databasePath}-wal`, { force: true });
+    rmSync(`${databasePath}-shm`, { force: true });
+    copyFileSync(backupPath, databasePath);
+}
+function tryRestoreDatabaseBackup(home, backupPath) {
+    try {
+        restoreDatabaseBackup(home, backupPath);
+        return { restored: true };
+    }
+    catch (error) {
+        return { restored: false, error: messageOf(error) };
+    }
+}
+function currentClassification() {
     return {
-        ...base,
         classification: { verdict: "USABLE", status: "current" },
-        layoutVersion: schema.currentLayoutVersion,
-        aggregateVersion: schema.currentAggregateSchemaVersion
+        storageVersion: CURRENT_STORAGE_VERSION,
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
     };
 }
-function corruptedClassification(classification, detail) {
+function migratableClassification(storageVersion) {
     return {
-        ...classification,
-        classification: { verdict: "CORRUPTED", status: "unsupported", detail }
+        classification: { verdict: "MIGRATABLE", status: "migration-ready" },
+        storageVersion,
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
+    };
+}
+function unsupportedClassification(state) {
+    const future = state.direction === "newer";
+    const message = future
+        ? `Storage version ${state.currentVersion} is newer than this CLI supports `
+            + `(${CURRENT_STORAGE_VERSION}).`
+        : `Storage version ${state.currentVersion} is older than the minimum supported `
+            + `migration version ${MIN_SUPPORTED_STORAGE_VERSION}.`;
+    const action = future
+        ? "Use a newer Yui release."
+        : "Preserve this Home for use with its matching historical Yui release, "
+            + "or initialize a new Home with Yui 0.15.0 or later.";
+    return {
+        classification: {
+            verdict: "NEEDS_NEW_VERSION",
+            status: "unsupported",
+            blocker: {
+                reason: future ? "future-version" : "below-minimum",
+                found: state.currentVersion,
+                current: CURRENT_STORAGE_VERSION,
+                minimum: MIN_SUPPORTED_STORAGE_VERSION,
+                message,
+                action
+            }
+        },
+        storageVersion: state.currentVersion,
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
+    };
+}
+function corruptedClassification(detail) {
+    return {
+        classification: { verdict: "CORRUPTED", status: "unsupported", detail },
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
     };
 }
 function blocked(classification, stage, message, action) {
@@ -124,3 +312,6 @@ function blocked(classification, stage, message, action) {
         sceneUnchanged: true
     };
 }
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/task/completionReadiness.js

@@ -1,10 +1,4 @@
-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/taskFinalReviewContractResolution.js";
-import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
+import { governingWorkItemDeliveries, integrationAttemptRequiresSettlement, workItemDeliverySettled } from "../integration/deliveryObligation.js";
 const ACTIVE_JOB_STATUSES = new Set([
     "queued",
     "running",
@@ -17,13 +11,10 @@ const UNRESOLVED_INTEGRATION_STATUSES = new Set([
 ]);
 const TERMINAL_REVIEW_STATUSES = new Set(["completed", "failed"]);
 const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "skipped"]);
-export function projectCompletionReadiness(facts, options = {}) {
+export function projectCompletionReadiness(facts) {
     const blockers = [];
     const advisories = [];
     const { task } = facts;
-    const findingsGate = options.findingsGate ?? true;
-    const taskFinalReviewContract = resolveRecordedTaskFinalReviewContract(task.id, facts.workItems, facts.reviewRounds)?.effective;
-    const taskFinalReviewRequired = taskFinalReviewContract !== 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")
@@ -39,36 +30,6 @@ export function projectCompletionReadiness(facts, options = {}) {
                 : `wait for Reviewer Turn on ${round.id} to finish`
         });
     }
-    // Issue 07: only the latest completed Task-final Review can define whether
-    // the current review lineage is accepted. Historical delta findings and
-    // escalations remain audit evidence, but a later completed full Review (or
-    // accepted delta) supersedes them instead of blocking completion forever.
-    const latestCompletedTaskReview = facts.reviewRounds
-        .filter((round) => ((round.scope ?? "work-item") === "task"
-        && (taskFinalReviewContract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalReviewContract))
-        && isSemanticReviewRound(round, {
-            listTurns: () => facts.turns,
-            listReviewFindings: () => facts.reviewFindings,
-            listEvents: () => facts.events
-        })))
-        .slice()
-        .sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
-        || left.id.localeCompare(right.id, undefined, { numeric: true })))
-        .at(-1);
-    if (taskFinalReviewRequired
-        && latestCompletedTaskReview !== undefined
-        && deltaRecheckBlocksAcceptance(latestCompletedTaskReview)) {
-        const round = latestCompletedTaskReview;
-        const disposition = round.deltaRecheck.disposition;
-        blockers.push({
-            code: "delta-recheck-not-accepted",
-            ref: ref("review-round", round.id),
-            reason: `Delta-recheck ${round.id} disposition is ${disposition}; the head is not accepted.`,
-            fix: disposition === "requires-full-review"
-                ? `yui task review request ${task.id} --role <global-role>`
-                : `repair the finding and request a new Task-final Review`
-        });
-    }
     // Open Input requests block protocol convergence.
     for (const request of facts.openInputRequests) {
         blockers.push({
@@ -104,34 +65,16 @@ export function projectCompletionReadiness(facts, options = {}) {
             fix: `wait for DurableJob ${job.id} to finish, or cancel it`
         });
     }
-    // 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("work-item", item.id),
-                reason: `Completed WorkItem ${item.id} has an uncaptured Git delivery.`,
-                fix: `yui task work capture ${task.id}/${item.id}`
-            });
-        }
-    }
-    for (const changeSet of deliveryChangeSets) {
-        if (changeSetDeliverySettled(changeSet, facts.integrations, facts.integrationQueueEntries))
+    // Integration obligations follow the exact start/result commits of the
+    // Candidate that currently governs each independent delivery unit.
+    for (const delivery of governingWorkItemDeliveries(facts.workItems)) {
+        if (workItemDeliverySettled(delivery, facts.integrations))
             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}`
+            ref: ref("work-item", delivery.workItemId),
+            reason: `WorkItem ${delivery.workItemId} result for Project ${delivery.projectId} is not part of a committed Integration.`,
+            fix: `yui task integration start ${task.id} --work-item ${delivery.workItemId} --project ${delivery.projectId} --strategy <ff|cherry-pick|merge|manual>`
         });
     }
     // Current delivery Attempts and any Attempt that may still be writing must
@@ -139,7 +82,7 @@ export function projectCompletionReadiness(facts, options = {}) {
     for (const integration of facts.integrations) {
         if (!UNRESOLVED_INTEGRATION_STATUSES.has(integration.status))
             continue;
-        if (!integrationAttemptRequiresSettlement(integration, deliveryChangeSets))
+        if (!integrationAttemptRequiresSettlement(integration))
             continue;
         blockers.push({
             code: "unresolved-integration",
@@ -148,8 +91,9 @@ export function projectCompletionReadiness(facts, options = {}) {
             fix: `yui task integration continue ${task.id}/${integration.id}`
         });
     }
-    // Unsettled integration queue entries must commit or be superseded.
-    for (const entry of latestGoverningQueueEntries(deliveryChangeSets, facts.integrationQueueEntries)) {
+    // Legacy queue entries may still launch an Integration and therefore must
+    // settle even though ChangeSets are no longer delivery authority.
+    for (const entry of facts.integrationQueueEntries) {
         if (entry.status === "committed" || entry.status === "superseded")
             continue;
         blockers.push({
@@ -169,34 +113,6 @@ export function projectCompletionReadiness(facts, options = {}) {
         if (disposition?.kind === "advisory")
             advisories.push(disposition.value);
     }
-    // Review finding ledger gate (enforce mode only).
-    // The transactional completion path runs this gate after final-review
-    // preparation: a pending/running Task-final Review is expected to resolve
-    // `fixed-pending-review` findings, so the gate only blocks when no Review
-    // is active.  Mirror that timing here so the projection never blocks a
-    // completion attempt that is about to request the resolving Review.
-    const activeTaskReview = facts.reviewRounds.some((round) => ((round.scope ?? "work-item") === "task"
-        && (round.status === "pending" || round.status === "running")));
-    if (findingsGate && facts.reviewFindingLedgerMode === "enforce" && !activeTaskReview) {
-        if (reviewFindingLedgerWriteFailedFromEvents(facts.events)) {
-            blockers.push({
-                code: "finding-ledger-unavailable",
-                ref: ref("task", task.id),
-                reason: "The Review finding ledger was unavailable while reconciling a semantic Review.",
-                fix: "recover the ledger and reconcile the Round before completing the Task"
-            });
-        }
-        for (const finding of facts.reviewFindings) {
-            if (!isReviewFindingBlocking(finding))
-                continue;
-            blockers.push({
-                code: "open-review-finding",
-                ref: ref("review-finding", finding.id),
-                reason: `Open ${finding.severity.toUpperCase()} finding ${finding.id} is undispositioned.`,
-                fix: `yui task review finding dispose ${task.id}/${finding.id}`
-            });
-        }
-    }
     const sorted = [...blockers].sort((left, right) => {
         const codeOrder = left.code.localeCompare(right.code);
         if (codeOrder !== 0)
@@ -271,7 +187,10 @@ function workspaceCompletionDisposition(facts, taskId, workspace) {
         }
         case "execution-lane": {
             const lane = findExecutionLane(facts, owner.executionGroupId, owner.executionLaneId);
-            if (lane !== undefined && !TERMINAL_LANE_STATUSES.has(lane.status))
+            const terminal = lane !== undefined && (lane.disposition !== undefined
+                ? lane.disposition !== "open"
+                : lane.status !== undefined && TERMINAL_LANE_STATUSES.has(lane.status));
+            if (lane !== undefined && !terminal)
                 return null;
             const value = {
                 code: "execution-lane-workspace-undisposed",

package/dist/task/deliveryGuard.js

@@ -1,5 +1,4 @@
-import { nextActionReviewOutcomeEvidence } from "./nextAction.js";
-import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
+import { isCompletedTaskReviewEvidenceFromTurns } from "../review/reviewAcceptance.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function detectDeliveryDuplicates(facts, intent) {
     switch (intent.kind) {
@@ -84,29 +83,28 @@ function detectWorkItemDuplicates(facts, scope) {
     return duplicates;
 }
 function detectIntegrationDuplicates(facts, intent) {
-    const wanted = new Set(intent.changeSetIds);
     const duplicates = [];
     for (const attempt of facts.integrations) {
         if (attempt.projectId !== intent.projectId)
             continue;
-        const existing = new Set(attempt.changeSetIds);
-        const sameSet = existing.size === wanted.size
-            && [...wanted].every((id) => existing.has(id));
+        const sameSource = attempt.source.kind === "work-item"
+            && attempt.source.workItemId === intent.workItemId
+            && attempt.source.resultCommit === intent.resultCommit;
         const ref = { kind: "integration-attempt", id: attempt.id };
-        if (sameSet && attempt.status === "committed") {
+        if (sameSource && attempt.status === "committed") {
             duplicates.push({
                 severity: "exact",
-                reason: `Integration ${attempt.id} already committed this exact ChangeSet set`,
+                reason: `Integration ${attempt.id} already committed this exact WorkItem result`,
                 refs: [ref],
                 reuseCommand: `yui task integration show ${facts.task.id}/${attempt.id}`
             });
             continue;
         }
-        if (sameSet
+        if (sameSource
             && (attempt.status === "running" || attempt.status === "validating")) {
             duplicates.push({
                 severity: "suspected",
-                reason: `Integration ${attempt.id} is already ${attempt.status} for this exact ChangeSet set`,
+                reason: `Integration ${attempt.id} is already ${attempt.status} for this WorkItem result`,
                 refs: [ref],
                 reuseCommand: `yui task integration show ${facts.task.id}/${attempt.id}`
             });
@@ -129,7 +127,7 @@ function detectReviewDuplicates(facts, intent) {
         if (!sameCandidate)
             continue;
         const ref = { kind: "review-round", id: round.id };
-        if (isSemanticReviewRound(round, nextActionReviewOutcomeEvidence(facts))) {
+        if (isCompletedTaskReviewEvidenceFromTurns(round, facts.reviewOutcomeEvidence?.turns ?? [])) {
             duplicates.push({
                 severity: "exact",
                 reason: `Task-final Review ${round.id} already attests this exact head`,