@zq-silk/yui 0.14.1 → 0.14.2

package/dist/integration/integrationAttempt.js

@@ -1,16 +1,16 @@
-import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
+import { normalizedUniqueText, requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { normalizeCheckResult } from "./checkResult.js";
 export function createIntegrationAttempt(input, now) {
     const timestamp = now.toISOString();
     return validateIntegrationAttempt({
-        schemaVersion: 5,
+        schemaVersion: 6,
         id: input.id,
         taskId: input.taskId,
         projectId: input.projectId,
         targetRef: input.targetRef,
-        expectedHead: input.expectedHead,
-        changeSetIds: [...input.changeSetIds],
+        source: input.source,
+        beforeCommit: input.beforeCommit,
         checkCommands: normalizedUniqueText(input.checkCommands ?? [], "Integration check command"),
         status: "running",
         createdAt: timestamp,
@@ -123,8 +123,8 @@ export function supersedeIntegration(attempt, reason, now) {
     });
 }
 export function validateIntegrationAttempt(attempt) {
-    if (attempt.schemaVersion !== 5) {
-        throw new Error("IntegrationAttempt must use schemaVersion 5.");
+    if (attempt.schemaVersion !== 6) {
+        throw new Error("IntegrationAttempt must use schemaVersion 6.");
     }
     validateTaskRecordReference({
         taskId: attempt.taskId,
@@ -132,18 +132,29 @@ export function validateIntegrationAttempt(attempt) {
     }, "integrationAttempt");
     requireIdentity(attempt.projectId, "Project id");
     requireText(attempt.targetRef, "Integration target ref");
-    requireCommit(attempt.expectedHead, "Integration expected head");
-    normalizedUniqueIdentities(attempt.changeSetIds, "ChangeSet id");
-    for (const changeSetId of attempt.changeSetIds) {
-        validateTaskRecordReference({ taskId: attempt.taskId, localId: changeSetId }, "changeSet");
-    }
+    requireCommit(attempt.beforeCommit, "Integration before commit");
+    validateIntegrationSource(attempt.taskId, attempt.source);
     normalizedUniqueText(attempt.checkCommands, "Integration check command");
-    if (attempt.changeSetIds.length === 0) {
-        throw new Error("IntegrationAttempt requires at least one ChangeSet.");
-    }
     if (attempt.candidateCommit !== undefined) {
         requireCommit(attempt.candidateCommit, "Integration candidate commit");
     }
+    if (attempt.afterCommit !== undefined) {
+        requireCommit(attempt.afterCommit, "Integration after commit");
+    }
+    if (attempt.summary !== undefined)
+        requireText(attempt.summary, "Integration summary");
+    if (attempt.status === "committed") {
+        requireCommit(attempt.afterCommit ?? "", "Committed Integration after commit");
+        requireText(attempt.summary ?? "", "Committed Integration summary");
+        if (attempt.candidateCommit !== attempt.afterCommit) {
+            throw new Error("Committed Integration candidate and afterCommit must match.");
+        }
+        if (attempt.source.kind === "work-item"
+            && attempt.source.strategy === "manual"
+            && attempt.resolution?.action !== "manual-resolution") {
+            throw new Error("Committed manual Integration requires a Task-control resolution decision.");
+        }
+    }
     if (attempt.jobId !== undefined) {
         validateTaskRecordReference({ taskId: attempt.taskId, localId: attempt.jobId }, "durableJob");
     }
@@ -179,6 +190,45 @@ export function validateIntegrationAttempt(attempt) {
     }
     return attempt;
 }
+function validateIntegrationSource(taskId, source) {
+    if (typeof source !== "object" || source === null) {
+        throw new Error("Integration source is required.");
+    }
+    if (source.kind === "work-item") {
+        validateTaskRecordReference({ taskId, localId: source.workItemId }, "workItem");
+        requireCommit(source.startCommit, "WorkItem Integration start commit");
+        requireCommit(source.resultCommit, "WorkItem Integration result commit");
+        if (!["ff", "cherry-pick", "merge", "manual"].includes(source.strategy)) {
+            throw new Error(`WorkItem Integration strategy is invalid: ${String(source.strategy)}.`);
+        }
+        return;
+    }
+    if (source.kind === "upstream") {
+        requireText(source.branch, "Upstream branch");
+        requireCommit(source.remoteCommit, "Upstream remote commit");
+        requireCommit(source.taskBaseCommit, "Upstream Task base commit");
+        const strategy = source.strategy;
+        if (strategy !== "rebase") {
+            throw new Error(`Upstream Integration strategy is invalid: ${String(strategy)}.`);
+        }
+        return;
+    }
+    if (source.kind === "historical-change-sets") {
+        if (!Array.isArray(source.changeSetIds) || source.changeSetIds.length === 0) {
+            throw new Error("Historical Integration source requires ChangeSet ids.");
+        }
+        const seen = new Set();
+        for (const changeSetId of source.changeSetIds) {
+            validateTaskRecordReference({ taskId, localId: changeSetId }, "changeSet");
+            if (seen.has(changeSetId)) {
+                throw new Error(`Historical Integration ChangeSet is duplicated: ${changeSetId}.`);
+            }
+            seen.add(changeSetId);
+        }
+        return;
+    }
+    throw new Error("Integration source is invalid.");
+}
 function normalizeConflictReport(report) {
     const affectedPaths = normalizedUniqueText(report.affectedPaths, "Conflict path");
     return {

package/dist/integration/integrationQueueEntry.js

@@ -47,7 +47,7 @@ export function createConvergedIntegrationQueueEntry(input, now) {
 }
 export function markIntegrationQueueRunning(entry, targetBefore, now) {
     validateIntegrationQueueEntry(entry);
-    if (!["queued", "conflicted", "validated"].includes(entry.status)) {
+    if (!["queued", "conflicted"].includes(entry.status)) {
         throw new Error(`Integration queue entry cannot run from ${entry.status}: ${entry.id}.`);
     }
     const { conflictSummary: _previousConflict, ...rest } = entry;
@@ -95,36 +95,10 @@ export function markIntegrationQueueCommitted(entry, targetAfter, now) {
         endedAt: timestamp
     });
 }
-/**
- * Records that this entry's reusable evidence was checked against an exact
- * target head.  The evidence only covers `evidenceTargetHead`; a target
- * advance invalidates it unless the delta is provably empty.  Path
- * disjointness alone never justifies this transition: a gate may read any
- * file, so a non-empty target increment cannot be proven irrelevant.
- */
-export function markIntegrationQueueValidated(entry, now, evidenceTargetHead) {
-    validateIntegrationQueueEntry(entry);
-    if (entry.status !== "queued") {
-        throw new Error(`Integration queue entry cannot validate from ${entry.status}: ${entry.id}.`);
-    }
-    if (entry.evidenceRefs.length === 0) {
-        throw new Error(`Integration queue entry has no reusable evidence: ${entry.id}.`);
-    }
-    return validateIntegrationQueueEntry({
-        ...entry,
-        status: "validated",
-        ...(evidenceTargetHead === undefined ? {} : { evidenceTargetHead }),
-        updatedAt: now.toISOString()
-    });
-}
-/**
- * A validated entry whose ChangeSet became affected by a later target advance
- * loses its evidence coverage and runs its checks again; a conflicted entry is
- * manually retried after its underlying issue was fixed.
- */
+/** A conflicted entry is manually retried after its underlying issue was fixed. */
 export function markIntegrationQueueRequeued(entry, now) {
     validateIntegrationQueueEntry(entry);
-    if (entry.status !== "validated" && entry.status !== "conflicted") {
+    if (entry.status !== "conflicted") {
         throw new Error(`Integration queue entry cannot requeue from ${entry.status}: ${entry.id}.`);
     }
     return validateIntegrationQueueEntry({
@@ -135,7 +109,7 @@ export function markIntegrationQueueRequeued(entry, now) {
 }
 export function recordIntegrationQueueAffectedPaths(entry, affectedPaths, now) {
     validateIntegrationQueueEntry(entry);
-    if (!["queued", "validated"].includes(entry.status)) {
+    if (entry.status !== "queued") {
         throw new Error(`Integration queue entry cannot recompute overlap from ${entry.status}: ${entry.id}.`);
     }
     const previous = new Set(entry.affectedPaths ?? []);
@@ -148,7 +122,7 @@ export function recordIntegrationQueueAffectedPaths(entry, affectedPaths, now) {
 }
 export function markIntegrationQueueSuperseded(entry, reason, now) {
     validateIntegrationQueueEntry(entry);
-    if (!["queued", "conflicted", "validated"].includes(entry.status)) {
+    if (!["queued", "conflicted"].includes(entry.status)) {
         throw new Error(`Integration queue entry cannot be superseded from ${entry.status}: ${entry.id}.`);
     }
     const timestamp = now.toISOString();
@@ -174,7 +148,6 @@ export function validateIntegrationQueueEntry(entry) {
         "queued",
         "running",
         "conflicted",
-        "validated",
         "committed",
         "superseded"
     ].includes(entry.status)) {
@@ -184,9 +157,6 @@ export function validateIntegrationQueueEntry(entry) {
         requireCommit(entry.targetBefore, "Integration queue targetBefore");
     if (entry.targetAfter !== undefined)
         requireCommit(entry.targetAfter, "Integration queue targetAfter");
-    if (entry.evidenceTargetHead !== undefined) {
-        requireCommit(entry.evidenceTargetHead, "Integration queue evidenceTargetHead");
-    }
     if (entry.integrationAttemptId !== undefined) {
         normalizedUniqueIdentities([entry.integrationAttemptId], "Integration attempt id");
     }

package/dist/integration/integrationQueueService.js

@@ -1,9 +1,8 @@
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 import { createIntegrationAttempt, recordResolutionDecision, updateIntegrationAttempt } from "./integrationAttempt.js";
-import { createConvergedIntegrationQueueEntry, createIntegrationQueueEntry, markIntegrationQueueBlocked, markIntegrationQueueCommitted, markIntegrationQueueRequeued, markIntegrationQueueRunning, markIntegrationQueueSuperseded, markIntegrationQueueValidated, recordIntegrationQueueAffectedPaths, recordIntegrationQueueAttempt } from "./integrationQueueEntry.js";
+import { createConvergedIntegrationQueueEntry, createIntegrationQueueEntry, markIntegrationQueueBlocked, markIntegrationQueueCommitted, markIntegrationQueueRequeued, markIntegrationQueueRunning, markIntegrationQueueSuperseded, recordIntegrationQueueAffectedPaths, recordIntegrationQueueAttempt } from "./integrationQueueEntry.js";
 import { GitIntegrationService } from "./gitIntegrationService.js";
-import { gateArtifactCoversCheckCommands } from "../verification/verificationGateService.js";
 /**
  * Producer WorkItem statuses that close the WorkItem lifecycle.  A ChangeSet
  * captured from a WorkItem that reached one of these without ever producing a
@@ -197,13 +196,14 @@ export async function enqueueIntegrationQueueEntry(input) {
         throw new Error(`Task main worktree is not ready; reconcile the Task first: ${task.id}.`);
     }
     const canonicalTargetRef = canonicalizeTargetRef(targetRef);
-    const targetHead = (await git.inspect(project.path, exactBranchRef(canonicalTargetRef))).baseCommit;
-    let equivalent = await findEquivalentCommit(git, project.path, changeSet.headCommit, targetHead, changeSet.baseCommit);
+    const repositoryPath = taskMainRepositoryPath(input.store, task.id, project.id);
+    const targetHead = (await git.inspect(repositoryPath, exactBranchRef(canonicalTargetRef))).baseCommit;
+    let equivalent = await findEquivalentCommit(git, repositoryPath, changeSet.headCommit, targetHead, changeSet.baseCommit);
     if (equivalent === null) {
         // The identical change may already have landed through another commit
         // while the target also moved on with unrelated work: the whole-tree
         // check misses it, but the touched paths already agree.
-        equivalent = await findContainedChangeSet(git, project.path, changeSet, targetHead);
+        equivalent = await findContainedChangeSet(git, repositoryPath, changeSet, targetHead);
     }
     return input.store.transactionAsync(async (tx) => {
         const duplicate = findActiveQueueDuplicate(tx, task.id, input.projectId, input.changeSetId);
@@ -252,7 +252,7 @@ export async function enqueueIntegrationQueueEntry(input) {
         // proof if it moved.
         let effectiveTargetHead = targetHead;
         if (equivalent !== null) {
-            effectiveTargetHead = (await git.inspect(project.path, exactBranchRef(canonicalTargetRef))).baseCommit;
+            effectiveTargetHead = (await git.inspect(repositoryPath, exactBranchRef(canonicalTargetRef))).baseCommit;
             if (effectiveTargetHead !== targetHead) {
                 equivalent = null;
             }
@@ -261,7 +261,7 @@ export async function enqueueIntegrationQueueEntry(input) {
                 // advance the target during the call, so the returned head may
                 // already be stale.  Verify with a second read; if it moved, the
                 // convergence proof is stale and the entry must queue.
-                const verifiedHead = (await git.inspect(project.path, exactBranchRef(canonicalTargetRef))).baseCommit;
+                const verifiedHead = (await git.inspect(repositoryPath, exactBranchRef(canonicalTargetRef))).baseCommit;
                 if (verifiedHead !== effectiveTargetHead) {
                     equivalent = null;
                     effectiveTargetHead = verifiedHead;
@@ -269,25 +269,14 @@ export async function enqueueIntegrationQueueEntry(input) {
             }
         }
         if (equivalent === null || requestedChecks.length > 0) {
-            let entry = createIntegrationQueueEntry({
+            const entry = createIntegrationQueueEntry({
                 id,
                 taskId: task.id,
                 projectId: input.projectId,
                 changeSetId: input.changeSetId,
                 targetRef: canonicalTargetRef,
-                checkCommands: requestedChecks,
-                evidenceRefs: changeSet.manifest.evidenceRefs
+                checkCommands: requestedChecks
             }, now());
-            // Durable positive exact-SHA evidence on an unchanged target, at the lane
-            // head, validates the entry so processing skips its checks.  The process-
-            // path evidence fence still invalidates the binding if the target moves
-            // before this entry runs, so a non-empty advance never rebinds old
-            // evidence.  A converged ChangeSet with explicit gates queues normally:
-            // the no-op apply still runs the caller's checks against the current
-            // target instead of waiving them.
-            if (await canReuseEvidenceAtHead(tx, task.id, tx.listIntegrationQueueEntries(task.id), entry, changeSet, effectiveTargetHead)) {
-                entry = markIntegrationQueueValidated(entry, now(), effectiveTargetHead);
-            }
             tx.saveIntegrationQueueEntry(task.id, entry);
             return { entry, outcome: "queued" };
         }
@@ -314,10 +303,21 @@ export async function enqueueIntegrationQueueEntry(input) {
             taskId: task.id,
             projectId: input.projectId,
             targetRef: canonicalTargetRef,
-            expectedHead: effectiveTargetHead,
-            changeSetIds: [input.changeSetId],
+            beforeCommit: effectiveTargetHead,
+            source: {
+                kind: "work-item",
+                workItemId: changeSet.workItemId,
+                startCommit: changeSet.baseCommit,
+                resultCommit: changeSet.headCommit,
+                strategy: "cherry-pick"
+            },
             checkCommands: []
-        }, now()), { status: "committed", candidateCommit: effectiveTargetHead }, now());
+        }, now()), {
+            status: "committed",
+            candidateCommit: effectiveTargetHead,
+            afterCommit: effectiveTargetHead,
+            summary: `WorkItem ${changeSet.workItemId} result was already represented; Task head was unchanged.`
+        }, now());
         const convergedEntry = createConvergedIntegrationQueueEntry({
             id,
             taskId: task.id,
@@ -331,7 +331,7 @@ export async function enqueueIntegrationQueueEntry(input) {
             integrationAttemptId: attempt.id
         }, now());
         try {
-            await git.assertRefAt(project.path, exactBranchRef(canonicalTargetRef), effectiveTargetHead);
+            await git.assertRefAt(repositoryPath, exactBranchRef(canonicalTargetRef), effectiveTargetHead);
         }
         catch {
             const queuedEntry = createIntegrationQueueEntry({
@@ -340,8 +340,7 @@ export async function enqueueIntegrationQueueEntry(input) {
                 projectId: input.projectId,
                 changeSetId: input.changeSetId,
                 targetRef: canonicalTargetRef,
-                checkCommands: requestedChecks,
-                evidenceRefs: changeSet.manifest.evidenceRefs
+                checkCommands: requestedChecks
             }, now());
             tx.saveIntegrationQueueEntry(task.id, queuedEntry);
             return { entry: queuedEntry, outcome: "queued" };
@@ -358,82 +357,10 @@ function findActiveQueueDuplicate(store, taskId, projectId, changeSetId) {
         && entry.status !== "superseded");
 }
 /**
- * Whether a freshly queued entry may start `validated` (skipping its checks):
- * its ChangeSet carries durable positive exact-SHA evidence, the target is
- * unchanged since the ChangeSet was based (so integrating fast-forwards to
- * the reviewed head), no earlier lane entry will advance the target first,
- * and the evidence covers every requested check command.  Entries behind a
- * lane mate stay `queued`: the mate's commit moves the target, so the
- * evidence would not cover their integration anyway.  A review check that
- * passed for command X never waives a different gate Y.
- */
-async function canReuseEvidenceAtHead(store, taskId, entries, entry, changeSet, targetHead) {
-    if (entry.evidenceRefs.length === 0)
-        return false;
-    if (targetHead !== changeSet.baseCommit)
-        return false;
-    const lane = queueLaneKey(entry);
-    if (entries.some((existing) => queueLaneKey(existing) === lane
-        && existing.status !== "committed"
-        && existing.status !== "superseded"))
-        return false;
-    return evidenceCoversCheckCommands(store, taskId, entry.evidenceRefs, entry.checkCommands, changeSet.headCommit, entry.projectId);
-}
-/**
- * Resolve each reusable evidence reference to its ReviewRound and collect the
- * names of checks that passed.  A requested gate command is covered only when
- * a resolved round recorded that exact command as passed.  A review that ran
- * `true` (or any other unrelated check) never waives a different gate.
- *
- * A check is reusable only when it ran on the frozen candidate tree.  A
- * ReviewRound must attest to this by recording its `evidenceCommit` as the
- * exact `reviewBaseCommit`.  A missing `evidenceCommit` is ambiguous: the
- * reviewer may have run checks with uncommitted dirty diagnostics, so the
- * absence cannot be treated as frozen-tree proof.  A round whose
- * `evidenceCommit` differs from its `reviewBaseCommit` ran its checks on a
- * diagnostic tree (the reviewer's own commit with review-only changes); those
- * checks proved a different tree and cannot waive the candidate gate.
- */
-async function evidenceCoversCheckCommands(store, taskId, evidenceRefs, checkCommands, candidateCommit, projectId) {
-    if (checkCommands.length === 0)
-        return true;
-    const covered = new Set();
-    for (const ref of evidenceRefs) {
-        // Issue 08: a `gate-artifact:` ref covers the exact commands its L2
-        // artifact passed on the exact candidate commit. The store resolves the
-        // artifact through its persistence backend (SQLite or file).
-        if (ref.startsWith("gate-artifact:")) {
-            if (await gateArtifactCoversCheckCommands(store, projectId, ref, checkCommands, candidateCommit)) {
-                for (const command of checkCommands)
-                    covered.add(command);
-            }
-            continue;
-        }
-        const roundId = parseReviewRoundRef(ref);
-        if (roundId === undefined)
-            continue;
-        const round = store.getReviewRound(taskId, roundId);
-        if (round === null || round.status !== "completed")
-            continue;
-        if (round.evidenceCommit !== round.reviewBaseCommit)
-            continue;
-        for (const check of round.checks ?? []) {
-            if (check.outcome === "passed")
-                covered.add(check.name);
-        }
-    }
-    return checkCommands.every((cmd) => covered.has(cmd));
-}
-function parseReviewRoundRef(ref) {
-    const prefix = "review-round:";
-    return ref.startsWith(prefix) ? ref.slice(prefix.length) : undefined;
-}
-/**
- * Process queued items in id order.  Each item gets a fresh IntegrationAttempt
+ * Process queued items in id order. Each item gets a fresh IntegrationAttempt
  * on the exact current target; conflicts and gate failures map the item to
  * `conflicted` without touching the others.  After every commit the remaining
- * items recompute overlap, and an item whose own paths became affected loses
- * its evidence coverage and runs its checks again.
+ * items recompute overlap diagnostics.
  *
  * A lane (one Project/targetRef pair) integrates one item at a time: while an
  * item is `running` — claimed by this or another processor — no other item of
@@ -467,22 +394,8 @@ export async function processIntegrationQueue(store, home, taskId, options = {})
         const project = store.getProject(candidate.projectId);
         if (project === null)
             throw new Error(`Project not found: ${candidate.projectId}.`);
-        const targetBefore = (await git.inspect(project.path, exactBranchRef(candidate.targetRef))).baseCommit;
-        // Evidence fence: a validated entry's reusable evidence only covers the
-        // exact target head it was validated against.  An out-of-band target
-        // advance (another Task) that touches the entry's paths, or whose impact
-        // cannot be proven, invalidates the evidence: requeue and run its checks.
-        if (candidate.status === "validated"
-            && await evidenceTargetAdvanced(git, project.path, candidate, targetBefore, store, task.id)) {
-            store.transaction((tx) => {
-                assertTaskActive(tx, task.id);
-                const current = tx.getIntegrationQueueEntry(task.id, candidate.id);
-                if (current !== null && current.status === "validated") {
-                    tx.saveIntegrationQueueEntry(task.id, markIntegrationQueueRequeued(current, now()));
-                }
-            });
-            continue;
-        }
+        const repositoryPath = taskMainRepositoryPath(store, task.id, project.id);
+        const targetBefore = (await git.inspect(repositoryPath, exactBranchRef(candidate.targetRef))).baseCommit;
         // CAS claim: re-read the entry inside the write transaction.  Another
         // store instance may have taken it since selection; if the status changed,
         // do not create an Attempt and re-select instead.  The running barrier is
@@ -490,8 +403,7 @@ export async function processIntegrationQueue(store, home, taskId, options = {})
         // between selection and claim serializes this entry behind it.
         const claimed = store.transaction((tx) => {
             const current = tx.getIntegrationQueueEntry(task.id, candidate.id);
-            if (current === null
-                || (current.status !== "queued" && current.status !== "validated")) {
+            if (current === null || current.status !== "queued") {
                 return { skipped: true };
             }
             if (laneBlockedByRunningEntry(tx.listIntegrationQueueEntries(task.id), current)) {
@@ -506,8 +418,8 @@ export async function processIntegrationQueue(store, home, taskId, options = {})
             // entered retry (or whose latest Candidate no longer matches) must not
             // advance the target.  Mark it conflicted so the Leader can supersede
             // or re-enqueue a fresh ChangeSet.
+            const changeSet = tx.getChangeSet(task.id, current.changeSetId);
             try {
-                const changeSet = tx.getChangeSet(task.id, current.changeSetId);
                 if (changeSet === null) {
                     throw new Error(`ChangeSet not found: ${current.changeSetId}.`);
                 }
@@ -519,14 +431,23 @@ export async function processIntegrationQueue(store, home, taskId, options = {})
                 tx.saveIntegrationQueueEntry(task.id, markIntegrationQueueBlocked(running, error instanceof Error ? error.message : String(error), now()));
                 return { skipped: true };
             }
+            if (changeSet === null) {
+                throw new Error(`ChangeSet not found after validation: ${current.changeSetId}.`);
+            }
             const attempt = createIntegrationAttempt({
                 id: tx.nextIntegrationAttemptId(task.id),
                 taskId: task.id,
                 projectId: current.projectId,
                 targetRef: current.targetRef,
-                expectedHead: targetBefore,
-                changeSetIds: [current.changeSetId],
-                checkCommands: current.status === "validated" ? [] : current.checkCommands
+                beforeCommit: targetBefore,
+                source: {
+                    kind: "work-item",
+                    workItemId: changeSet.workItemId,
+                    startCommit: changeSet.baseCommit,
+                    resultCommit: changeSet.headCommit,
+                    strategy: "cherry-pick"
+                },
+                checkCommands: current.checkCommands
             }, now());
             tx.saveIntegrationAttempt(task.id, attempt);
             const entry = recordIntegrationQueueAttempt(markIntegrationQueueRunning(current, targetBefore, now()), attempt.id, now());
@@ -553,10 +474,7 @@ export async function processIntegrationQueue(store, home, taskId, options = {})
             return entry;
         });
         if (result.status === "committed") {
-            const project = store.getProject(settled.projectId);
-            if (project !== null) {
-                await recomputeAffectedPaths(store, task.id, settled, project.path, git, now);
-            }
+            await recomputeAffectedPaths(store, task.id, settled, taskMainRepositoryPath(store, task.id, settled.projectId), git, now);
         }
         processed.push({ entry: settled, attempt: result.attempt, result });
     }
@@ -588,7 +506,7 @@ function queueLaneKey(entry) {
     return `${entry.projectId} ${canonicalizeTargetRef(entry.targetRef)}`;
 }
 /**
- * The first entry a processor may claim: the earliest queued/validated entry
+ * The first entry a processor may claim: the earliest queued entry
  * whose lane has no running entry anywhere in it.  A running entry serializes
  * its whole lane — predecessors and successors alike — so a requeued
  * predecessor cannot slip past a successor that is already running.
@@ -605,7 +523,7 @@ function firstClaimableQueueEntry(entries, projectId) {
     for (const entry of entries) {
         if (projectId !== undefined && entry.projectId !== projectId)
             continue;
-        if ((entry.status === "queued" || entry.status === "validated")
+        if (entry.status === "queued"
             && !blockedLanes.has(queueLaneKey(entry))) {
             return entry;
         }
@@ -624,50 +542,6 @@ function laneBlockedByRunningEntry(entries, candidate) {
         && entry.status === "running"
         && queueLaneKey(entry) === lane);
 }
-/**
- * Whether a validated entry's reusable evidence no longer covers the current
- * target.  The evidence only proves the gate as of `entry.evidenceTargetHead`;
- * an out-of-band target advance (another Task) on the entry's own paths, or any
- * advance whose impact on the entry's gate cannot be proven, invalidates it.
- * Returns false (evidence still covers the target) only when proven unaffected.
- */
-async function evidenceTargetAdvanced(git, repositoryPath, entry, currentTargetHead, store, taskId) {
-    const boundary = entry.evidenceTargetHead;
-    if (boundary === undefined)
-        return true;
-    if (boundary === currentTargetHead)
-        return false;
-    // The target advanced out of band since the evidence boundary.  Compute the
-    // real path delta and re-run the gate unless the entry is provably unaffected.
-    if (git.changedFilesBetween === undefined)
-        return true;
-    let delta;
-    try {
-        delta = await git.changedFilesBetween({
-            repositoryPath,
-            fromCommit: boundary,
-            toCommit: currentTargetHead
-        });
-    }
-    catch {
-        return true;
-    }
-    const changeSet = store.getChangeSet(taskId, entry.changeSetId);
-    if (changeSet === null)
-        return true;
-    const ownPaths = new Set([
-        ...changeSet.changedPaths,
-        ...changeSet.manifest.deletedPaths
-    ]);
-    if (delta.some((path) => ownPaths.has(path)))
-        return true;
-    // The delta does not touch the entry's own paths, but the entry's gate may
-    // read any file — including the exact target SHA the evidence is bound to.
-    // A changed target SHA invalidates exact-SHA evidence regardless of tree
-    // identity, so any entry with checks must re-run its gate.  An entry
-    // without checks has nothing to re-run and may commit directly.
-    return entry.checkCommands.length > 0;
-}
 /**
  * A conflicted entry whose manual-resolution Attempt committed converges.  The
  * settle happens in one transaction; the downstream affected-path recompute
@@ -693,10 +567,7 @@ export async function reconcileIntegrationQueueEntry(store, taskId, entryId, git
         tx.saveIntegrationQueueEntry(taskId, settled);
         return settled;
     });
-    const project = store.getProject(committed.projectId);
-    if (project !== null) {
-        await recomputeAffectedPaths(store, taskId, committed, project.path, git, now);
-    }
+    await recomputeAffectedPaths(store, taskId, committed, taskMainRepositoryPath(store, taskId, committed.projectId), git, now);
     return committed;
 }
 /**
@@ -786,10 +657,7 @@ async function reconcileTerminalAttempts(store, taskId, git, now) {
             // Crash window: the settle marked this entry committed but died before
             // recomputing downstream affectedPaths.  Replay that update idempotently
             // so waiting entries regain their overlap evidence.
-            const project = store.getProject(entry.projectId);
-            if (project !== null) {
-                await recomputeAffectedPaths(store, taskId, entry, project.path, git, now);
-            }
+            await recomputeAffectedPaths(store, taskId, entry, taskMainRepositoryPath(store, taskId, entry.projectId), git, now);
             continue;
         }
         if (entry.status !== "conflicted" && entry.status !== "running")
@@ -800,10 +668,7 @@ async function reconcileTerminalAttempts(store, taskId, git, now) {
         if (attempt.status === "committed") {
             const committed = markIntegrationQueueCommitted(entry, committedTargetAfter(attempt), now());
             store.saveIntegrationQueueEntry(taskId, committed);
-            const project = store.getProject(committed.projectId);
-            if (project !== null) {
-                await recomputeAffectedPaths(store, taskId, committed, project.path, git, now);
-            }
+            await recomputeAffectedPaths(store, taskId, committed, taskMainRepositoryPath(store, taskId, committed.projectId), git, now);
             continue;
         }
         // Crash window: the Attempt persisted a terminal failed/blocked outcome
@@ -832,7 +697,7 @@ async function recomputeAffectedPaths(store, taskId, committed, projectPath, git
             continue;
         if (canonicalizeTargetRef(entry.targetRef) !== canonicalizeTargetRef(committed.targetRef))
             continue;
-        if (entry.status !== "queued" && entry.status !== "validated")
+        if (entry.status !== "queued")
             continue;
         const changeSet = store.getChangeSet(taskId, entry.changeSetId);
         if (changeSet === null)
@@ -853,21 +718,16 @@ async function recomputeAffectedPaths(store, taskId, committed, projectPath, git
             const current = tx.getIntegrationQueueEntry(taskId, entry.id);
             if (current === null)
                 return;
-            if (current.status !== "queued" && current.status !== "validated")
+            if (current.status !== "queued")
                 return;
-            let updated = recordIntegrationQueueAffectedPaths(current, affected, now());
-            if (updated.status === "validated" && (updated.affectedPaths?.length ?? 0) > 0) {
-                // The target advanced onto this entry's own paths: its evidence no
-                // longer covers the target, so the gate must run again.
-                updated = markIntegrationQueueRequeued(updated, now());
-            }
+            const updated = recordIntegrationQueueAffectedPaths(current, affected, now());
             // A queued entry keeps its place and runs its checks against the exact
             // current target at process time.  Disjoint changedPaths must never
             // rebind its evidence to the new target head: a gate may read any file,
             // so a non-empty target increment cannot be proven irrelevant from path
             // metadata alone.
-            if (updated.status !== current.status
-                || (updated.affectedPaths ?? []).join("\n") !== (current.affectedPaths ?? []).join("\n")) {
+            if ((updated.affectedPaths ?? []).join("\n")
+                !== (current.affectedPaths ?? []).join("\n")) {
                 tx.saveIntegrationQueueEntry(taskId, updated);
             }
         });
@@ -937,3 +797,14 @@ function taskMainBranch(store, taskId, projectId) {
         return undefined;
     return workspaceProjectEntry(mainWorkspace, projectId)?.branch;
 }
+function taskMainRepositoryPath(store, taskId, projectId) {
+    const mainWorkspace = store.getTaskWorkspace(taskId);
+    if (mainWorkspace === null || mainWorkspace.owner.type !== "task") {
+        throw new Error(`Task has no authoritative main workspace: ${taskId}.`);
+    }
+    const entry = workspaceProjectEntry(mainWorkspace, projectId);
+    if (entry === undefined) {
+        throw new Error(`Task main workspace has no Project: ${taskId}/${projectId}.`);
+    }
+    return entry.path;
+}