@zq-silk/yui 0.14.1 → 0.14.2

package/dist/workItem/workItem.js

@@ -1,10 +1,9 @@
-import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
-import { contextContentDigest, validateContextSnapshotRef } from "../context/contextSnapshot.js";
+import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
 import { validateReviewConfig } from "../review/reviewConfig.js";
 import { taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
-import { assertExecutionGroupTransition, validateExecutionGroup, WORK_ITEM_EXPLORATION_STAGES } from "../execution/executionGroup.js";
+import { assertWorkItemExecutionGroupTransition, validateWorkItemExecutionGroup as validateExecutionGroupRecord, workItemExecutionGroupSettled } from "../execution/workItemExecution.js";
 const TERMINAL_STATUSES = [
     "completed",
     "failed",
@@ -13,7 +12,7 @@ const TERMINAL_STATUSES = [
 export function createWorkItem(id, taskId, input, now) {
     const timestamp = now.toISOString();
     return validateWorkItem({
-        schemaVersion: 13,
+        schemaVersion: 15,
         id: requireIdentity(id, "Work Item id"),
         taskId: requireIdentity(taskId, "Task id"),
         title: requireText(input.title, "Work item title"),
@@ -38,6 +37,54 @@ export function createWorkItem(id, taskId, input, now) {
         updatedAt: timestamp
     });
 }
+/** Replace the mutable definition of an execution-free Draft WorkItem. */
+export function editDraftWorkItemDefinition(workItem, update, now) {
+    validateWorkItem(workItem);
+    if (workItem.status !== "pending"
+        || workItem.executionGroups.length > 0
+        || workItem.candidates.length > 0
+        || workItem.disposition !== undefined
+        || workItem.workspaceDisposition !== undefined) {
+        throw new Error(`Work Item has execution or retirement facts: ${workItem.id}.`);
+    }
+    const next = {
+        ...workItem,
+        ...(update.title === undefined
+            ? {}
+            : { title: requireText(update.title, "Work item title") }),
+        ...(update.objective === undefined
+            ? {}
+            : { objective: requireText(update.objective, "Work item objective") }),
+        ...(update.acceptance === undefined
+            ? {}
+            : { acceptance: normalizedUniqueText(update.acceptance, "Work item acceptance criterion") }),
+        ...(update.dependsOn === undefined
+            ? {}
+            : { dependsOn: normalizedUniqueIdentities(update.dependsOn, "Work item dependency") }),
+        ...(update.writeProjectIds === undefined
+            ? {}
+            : {
+                writeProjectIds: normalizedUniqueIdentities(update.writeProjectIds, "Work item writable Project")
+            }),
+        revision: workItem.revision + 1,
+        updatedAt: now.toISOString()
+    };
+    if (update.baseRefs === null)
+        delete next.baseRefs;
+    else if (update.baseRefs !== undefined) {
+        const normalized = normalizeProjectBaseRefs(update.baseRefs);
+        if (normalized.length === 0)
+            delete next.baseRefs;
+        else
+            next.baseRefs = normalized;
+    }
+    if (update.assignee === null)
+        delete next.assignee;
+    else if (update.assignee !== undefined) {
+        next.assignee = requireIdentity(update.assignee, "Work item assignee");
+    }
+    return validateWorkItem(next);
+}
 export function submitWorkItemCandidate(workItem, input, now) {
     validateWorkItem(workItem);
     if (workItem.status !== "running") {
@@ -138,8 +185,8 @@ export function attachWorkItemExecutionGroup(workItem, executionGroup, now) {
         throw new Error(`Work Item historical ExecutionGroup is immutable: ${workItem.id}/${checked.id}.`);
     }
     const current = currentWorkItemExecutionGroup(workItem);
-    if (current !== undefined && current.resolution === undefined) {
-        throw new Error(`Work Item already has an unresolved ExecutionGroup: ${workItem.id}/${current.id}.`);
+    if (current !== undefined && !workItemExecutionGroupSettled(current)) {
+        throw new Error(`Work Item already has an open ExecutionGroup: ${workItem.id}/${current.id}.`);
     }
     return validateWorkItem({
         ...workItem,
@@ -160,12 +207,12 @@ export function updateWorkItemExecutionGroup(workItem, executionGroup, now) {
     if (workItem.currentExecutionGroupId !== checked.id) {
         throw new Error(`Work Item historical ExecutionGroup is immutable: ${workItem.id}/${checked.id}.`);
     }
-    if (JSON.stringify(existing.target) !== JSON.stringify(checked.target)) {
-        throw new Error(`Work Item ExecutionGroup target is immutable: ${workItem.id}/${checked.id}.`);
+    if (JSON.stringify(existing.assignment) !== JSON.stringify(checked.assignment)) {
+        throw new Error(`Work Item ExecutionGroup Assignment is immutable: ${workItem.id}/${checked.id}.`);
     }
     if (JSON.stringify(existing) === JSON.stringify(checked))
         return workItem;
-    assertExecutionGroupTransition(existing, checked);
+    assertWorkItemExecutionGroupTransition(existing, checked);
     return validateWorkItem({
         ...workItem,
         executionGroups: workItem.executionGroups.map((group) => group.id === checked.id ? checked : group),
@@ -216,10 +263,10 @@ export function retryFailedWorkItem(workItem, now) {
         throw new Error(`Work item workspace is already settled: ${workItem.id}.`);
     }
     const { outcome: _outcome, endedAt: _endedAt, ...base } = workItem;
-    // Keep every historical Group. A resolved current Group is cleared only as
-    // the current pointer; dispatch appends a fresh immutable Group.
+    // Keep every historical Group. A settled current Group is cleared only as
+    // the current pointer; redispatch appends a fresh immutable Group.
     const current = currentWorkItemExecutionGroup(workItem);
-    const retryBase = current?.resolution === undefined
+    const retryBase = current === undefined || !workItemExecutionGroupSettled(current)
         ? base
         : (({ currentExecutionGroupId: _currentExecutionGroupId, ...history }) => history)(base);
     return validateWorkItem({
@@ -248,8 +295,31 @@ export function recordWorkItemWorkspaceDisposition(workItem, disposition, now) {
     });
 }
 export function validateWorkItem(workItem) {
-    if (workItem.schemaVersion !== 13)
-        throw new Error("WorkItem must use schemaVersion 13.");
+    rejectUnknownFields(workItem, [
+        "schemaVersion",
+        "id",
+        "taskId",
+        "title",
+        "objective",
+        "acceptance",
+        "dependsOn",
+        "writeProjectIds",
+        "executionGroups",
+        "currentExecutionGroupId",
+        "baseRefs",
+        "revision",
+        "assignee",
+        "status",
+        "candidates",
+        "outcome",
+        "disposition",
+        "workspaceDisposition",
+        "createdAt",
+        "updatedAt",
+        "endedAt"
+    ], "WorkItem");
+    if (workItem.schemaVersion !== 15)
+        throw new Error("WorkItem must use schemaVersion 15.");
     validateTaskRecordReference({ taskId: workItem.taskId, localId: workItem.id }, "workItem");
     requireIdentity(workItem.taskId, "Task id");
     requireText(workItem.title, "Work item title");
@@ -284,7 +354,6 @@ export function validateWorkItem(workItem) {
         }
         groupIds.add(group.id);
     }
-    validateWorkItemExplorationHistory(workItem.executionGroups);
     if (workItem.currentExecutionGroupId !== undefined) {
         requireIdentity(workItem.currentExecutionGroupId, "ExecutionGroup id");
         if (!groupIds.has(workItem.currentExecutionGroupId)) {
@@ -311,16 +380,6 @@ export function validateWorkItem(workItem) {
         if (candidate.workItemRevision > workItem.revision) {
             throw new Error("Work Item candidate revision cannot exceed the Work Item revision.");
         }
-        if (candidate.executionGroupId !== undefined) {
-            const group = workItem.executionGroups.find(({ id }) => id === candidate.executionGroupId);
-            if (group?.stage !== undefined) {
-                if (group.stage.stage !== "resolve"
-                    || group.resolution?.decision !== "accept"
-                    || !group.resolution.selectedLaneIds.includes(candidate.executionLaneId)) {
-                    throw new Error("An exploration Candidate must come from the accepted Resolve stage.");
-                }
-            }
-        }
     });
     const currentCandidate = currentWorkItemCandidate(workItem);
     if (workItem.status === "awaiting_acceptance" && currentCandidate === undefined) {
@@ -363,130 +422,6 @@ export function validateWorkItem(workItem) {
     }
     return workItem;
 }
-/**
- * Project the next legal exploration stage from immutable WorkItem Group
- * history. Retry repeats the current stage; retry at Resolve begins the next
- * round. Reject has no continuation, while blocked follows the same bounded
- * retry path after the Leader settles any required InputRequest.
- */
-export function planWorkItemExplorationStage(workItem, input) {
-    validateWorkItem(workItem);
-    const snapshot = validateContextSnapshotRef(input.contextSnapshotRef);
-    const capacity = executionStrategyCapacity(input.strategy);
-    const current = currentWorkItemExecutionGroup(workItem);
-    if (workItem.executionGroups.length === 0) {
-        if (workItem.status !== "pending" && workItem.status !== "running") {
-            throw new Error(`Work Item cannot begin exploration from ${workItem.status}: ${workItem.id}.`);
-        }
-        if (input.mode === undefined) {
-            throw new Error("The first exploration stage requires a mode.");
-        }
-        if (input.convergence === undefined) {
-            throw new Error("The first exploration stage requires a candidate convergence policy.");
-        }
-        const resourceBudget = requireNewStageResourceBudget(input.resourceBudget);
-        const resources = requireNewStageResources(input.resources);
-        return {
-            schemaVersion: 1,
-            mode: input.mode,
-            stage: "plan",
-            round: 1,
-            stageAttempt: 1,
-            maxRounds: requirePositiveInteger(input.maxRounds ?? 1, "Exploration max rounds"),
-            budget: {
-                maxLanes: capacity,
-                maxAttempts: requirePositiveInteger(input.maxAttempts ?? 1, "Exploration stage max attempts"),
-                ...resourceBudget
-            },
-            resources,
-            contextSnapshotRef: snapshot,
-            parentResults: [],
-            ...(input.convergence === undefined ? {} : { convergence: input.convergence })
-        };
-    }
-    if (current === undefined || current.stage === undefined) {
-        throw new Error("A Work Item cannot mix single and exploration ExecutionGroups.");
-    }
-    if (current.resolution === undefined) {
-        throw new Error(`Execution stage is still active: ${current.id}.`);
-    }
-    if (input.mode !== undefined && input.mode !== current.stage.mode) {
-        throw new Error("Work Item exploration mode is immutable.");
-    }
-    if (input.maxRounds !== undefined && input.maxRounds !== current.stage.maxRounds) {
-        throw new Error("Work Item exploration maxRounds is immutable.");
-    }
-    const parentResults = selectedParentResults(current);
-    const base = {
-        schemaVersion: 1,
-        mode: current.stage.mode,
-        maxRounds: current.stage.maxRounds,
-        contextSnapshotRef: snapshot,
-        parentResults,
-        ...(current.stage.convergence === undefined
-            ? {}
-            : { convergence: current.stage.convergence })
-    };
-    if (current.resolution.decision === "reject") {
-        throw new Error(`Rejected exploration has no continuation: ${current.id}.`);
-    }
-    if (current.resolution.decision === "accept") {
-        if (current.stage.stage === "resolve") {
-            throw new Error(`Accepted Resolve stage already completed exploration: ${current.id}.`);
-        }
-        const resourceBudget = requireNewStageResourceBudget(input.resourceBudget);
-        const resources = requireNewStageResources(input.resources);
-        return {
-            ...base,
-            stage: nextExplorationStage(current.stage.stage),
-            round: current.stage.round,
-            stageAttempt: 1,
-            budget: {
-                maxLanes: capacity,
-                maxAttempts: requirePositiveInteger(input.maxAttempts ?? 1, "Exploration stage max attempts"),
-                ...resourceBudget
-            },
-            resources
-        };
-    }
-    if (current.stage.stage === "resolve" && current.resolution.decision === "retry") {
-        if (current.stage.round >= current.stage.maxRounds) {
-            throw new Error(`Work Item exploration round budget is exhausted: ${workItem.id}.`);
-        }
-        const resourceBudget = requireNewStageResourceBudget(input.resourceBudget);
-        const resources = requireNewStageResources(input.resources);
-        return {
-            ...base,
-            stage: "plan",
-            round: current.stage.round + 1,
-            stageAttempt: 1,
-            budget: {
-                maxLanes: capacity,
-                maxAttempts: requirePositiveInteger(input.maxAttempts ?? 1, "Exploration stage max attempts"),
-                ...resourceBudget
-            },
-            resources
-        };
-    }
-    if (current.stage.stageAttempt >= current.stage.budget.maxAttempts) {
-        throw new Error(`Work Item exploration stage attempt budget is exhausted: ${workItem.id}.`);
-    }
-    if (capacity !== current.stage.budget.maxLanes) {
-        throw new Error("A retried exploration stage must keep its frozen Lane budget.");
-    }
-    if (input.maxAttempts !== undefined
-        && input.maxAttempts !== current.stage.budget.maxAttempts) {
-        throw new Error("A retried exploration stage must keep its frozen attempt budget.");
-    }
-    return {
-        ...base,
-        stage: current.stage.stage,
-        round: current.stage.round,
-        stageAttempt: current.stage.stageAttempt + 1,
-        budget: current.stage.budget,
-        ...(current.stage.resources === undefined ? {} : { resources: current.stage.resources })
-    };
-}
 /** Resolve the WorkItem's current execution iteration. */
 export function currentWorkItemExecutionGroup(workItem) {
     return workItem.currentExecutionGroupId === undefined
@@ -509,124 +444,17 @@ export function workItemOwnsUnresolvedExecutionLane(workItem, executionGroupId,
         return false;
     const group = workItem.executionGroups.find(({ id }) => id === executionGroupId);
     return group !== undefined
-        && group.resolution === undefined
-        && group.lanes.some(({ id, status }) => (id === executionLaneId && status === "failed"));
-}
-function validateWorkItemExplorationHistory(groups) {
-    const staged = groups.filter(({ stage }) => stage !== undefined);
-    if (staged.length === 0)
-        return;
-    if (staged.length !== groups.length) {
-        throw new Error("A Work Item cannot mix single and exploration ExecutionGroups.");
-    }
-    const first = groups[0].stage;
-    if (first.stage !== "plan"
-        || first.round !== 1
-        || first.stageAttempt !== 1
-        || first.parentResults.length !== 0) {
-        throw new Error("Work Item exploration must begin at Plan round 1 attempt 1.");
-    }
-    for (let index = 1; index < groups.length; index += 1) {
-        const previous = groups[index - 1];
-        const current = groups[index];
-        const before = previous.stage;
-        const after = current.stage;
-        if (previous.resolution === undefined) {
-            throw new Error(`Exploration stage must resolve before its successor: ${previous.id}.`);
-        }
-        if (previous.resolution.decision === "reject") {
-            throw new Error(`Rejected exploration cannot have a successor: ${previous.id}.`);
-        }
-        if (after.mode !== before.mode
-            || after.maxRounds !== before.maxRounds
-            || JSON.stringify(after.convergence) !== JSON.stringify(before.convergence)) {
-            throw new Error("Work Item exploration mode, maxRounds and convergence policy are immutable.");
-        }
-        const parents = selectedParentResults(previous);
-        if (JSON.stringify(after.parentResults) !== JSON.stringify(parents)) {
-            throw new Error(`Exploration parentResults do not match ${previous.id}.`);
-        }
-        if (previous.resolution.decision === "accept") {
-            if (before.stage === "resolve"
-                || after.stage !== nextExplorationStage(before.stage)
-                || after.round !== before.round
-                || after.stageAttempt !== 1) {
-                throw new Error(`Exploration stage transition is invalid: ${previous.id}/${current.id}.`);
-            }
-            continue;
-        }
-        if (before.stage === "resolve" && previous.resolution.decision === "retry") {
-            if (before.round >= before.maxRounds
-                || after.stage !== "plan"
-                || after.round !== before.round + 1
-                || after.stageAttempt !== 1) {
-                throw new Error(`Exploration round transition is invalid: ${previous.id}/${current.id}.`);
-            }
-            continue;
-        }
-        if (after.stage !== before.stage
-            || after.round !== before.round
-            || after.stageAttempt !== before.stageAttempt + 1
-            || after.stageAttempt > before.budget.maxAttempts
-            || JSON.stringify(after.budget) !== JSON.stringify(before.budget)
-            || JSON.stringify(after.resources) !== JSON.stringify(before.resources)) {
-            throw new Error(`Exploration retry transition is invalid: ${previous.id}/${current.id}.`);
-        }
-    }
-}
-function requireNewStageResourceBudget(value) {
-    if (value?.maxTokens === undefined
-        || value.maxToolCalls === undefined
-        || value.maxWallClockSeconds === undefined) {
-        throw new Error("A new exploration stage requires token, tool-call and wall-clock budgets.");
-    }
-    return {
-        maxTokens: requirePositiveInteger(value.maxTokens, "Exploration stage max tokens"),
-        maxToolCalls: requirePositiveInteger(value.maxToolCalls, "Exploration stage max tool calls"),
-        maxWallClockSeconds: requirePositiveInteger(value.maxWallClockSeconds, "Exploration stage max wall-clock seconds")
-    };
-}
-function requireNewStageResources(value) {
-    if (value === undefined) {
-        throw new Error("A new exploration stage requires resource completion policy.");
-    }
-    return value;
-}
-function selectedParentResults(group) {
-    if (group.resolution === undefined) {
-        throw new Error(`ExecutionGroup is unresolved: ${group.id}.`);
-    }
-    return group.resolution.selectedLaneIds.map((laneId) => {
-        const lane = group.lanes.find(({ id }) => id === laneId);
-        if (lane?.result === undefined) {
-            throw new Error(`Selected ExecutionLane result is missing: ${group.id}/${laneId}.`);
-        }
-        return {
-            executionGroupId: group.id,
-            executionLaneId: lane.id,
-            resultDigest: contextContentDigest(lane.result)
-        };
-    });
-}
-function nextExplorationStage(stage) {
-    const index = WORK_ITEM_EXPLORATION_STAGES.indexOf(stage);
-    const next = WORK_ITEM_EXPLORATION_STAGES[index + 1];
-    if (next === undefined)
-        throw new Error("Resolve is the final exploration stage.");
-    return next;
-}
-function executionStrategyCapacity(strategy) {
-    return requirePositiveInteger(strategy.mode === "fixed" ? strategy.count : strategy.max, "Execution strategy capacity");
+        && !workItemExecutionGroupSettled(group)
+        && group.lanes.some(({ id, disposition, currentTurnId }) => (id === executionLaneId && disposition === "open" && currentTurnId !== undefined));
 }
 function validateWorkItemExecutionGroup(group, taskId, workItemId) {
-    validateExecutionGroup(group);
-    if (group.taskId !== taskId || group.purpose !== "execution") {
+    validateExecutionGroupRecord(group);
+    if (group.taskId !== taskId) {
         throw new Error(`Work Item ExecutionGroup provenance is invalid: ${workItemId}.`);
     }
-    if (group.target.kind !== "work-item"
-        || group.target.workItemId !== workItemId
-        || group.target.taskId !== taskId) {
-        throw new Error(`Work Item ExecutionGroup target is invalid: ${workItemId}.`);
+    if (group.assignment.workItemId !== workItemId
+        || group.assignment.taskId !== taskId) {
+        throw new Error(`Work Item ExecutionGroup Assignment is invalid: ${workItemId}.`);
     }
     return group;
 }
@@ -700,11 +528,10 @@ export function validateWorkItemCandidate(candidate) {
         validateCandidateGitSnapshot(candidate.gitSnapshot, candidate.workspace);
     }
     if (candidate.taskMainSnapshot !== undefined) {
-        if (candidate.source.type !== "direct"
-            || candidate.workspace !== undefined
+        if (candidate.workspace !== undefined
             || candidate.gitSnapshot !== undefined
             || candidate.taskFinalReviewContract === undefined) {
-            throw new Error("Task-main Candidate snapshot requires an exact direct metadata-only Candidate.");
+            throw new Error("Task-main Candidate snapshot requires an exact metadata-only Candidate.");
         }
         validateDirectTaskMainSnapshot(candidate.taskMainSnapshot);
     }
@@ -933,3 +760,9 @@ function sameDisposition(left, right) {
         && left.summary === right.summary
         && left.replacementWorkItemId === right.replacementWorkItemId;
 }
+function rejectUnknownFields(value, fields, label) {
+    const allowed = new Set(fields);
+    const unknown = Object.keys(value).find((field) => !allowed.has(field));
+    if (unknown !== undefined)
+        throw new Error(`${label} has unknown field: ${unknown}.`);
+}

package/dist/workspace/workItemChangeSetManager.js

@@ -60,35 +60,26 @@ export class WorkItemChangeSetManager {
                 throw new Error(`WorkItem Project workspace is not clean: ${item.id}/${entry.projectId}.`);
             }
             const headCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
-            const latest = latestWorkItemChangeSet(this.store, item.taskId, item.id, entry.projectId);
-            if (headCommit === entry.baseCommit) {
-                if (latest !== undefined) {
-                    throw new Error(`WorkItem Project no longer matches its latest ChangeSet: ${item.id}/${entry.projectId}.`);
-                }
-                projects.push({
-                    projectId: entry.projectId,
-                    baseCommit: entry.baseCommit,
-                    headCommit
-                });
-                continue;
-            }
-            if (latest === undefined
-                || latest.baseCommit !== entry.baseCommit
-                || latest.headCommit !== headCommit
-                || latest.branch !== entry.branch) {
-                throw new Error(`WorkItem Project has uncaptured commits: ${item.id}/${entry.projectId}.`);
+            const candidate = governingWorkItemCandidate(item);
+            const resultCommit = candidate?.gitSnapshot?.projects.find(({ projectId }) => projectId === entry.projectId)?.commit;
+            if (candidate?.workspace === undefined
+                || !isDeepStrictEqual(candidate.workspace, workspace)
+                || resultCommit !== headCommit) {
+                throw new Error(`WorkItem Project no longer matches its frozen result: ${item.id}/${entry.projectId}.`);
             }
             const integrated = this.store.listIntegrationAttempts(item.taskId).some((integration) => (integration.status === "committed"
                 && integration.projectId === entry.projectId
-                && integration.changeSetIds.includes(latest.id)));
+                && integration.source.kind === "work-item"
+                && integration.source.workItemId === item.id
+                && integration.source.startCommit === entry.baseCommit
+                && integration.source.resultCommit === headCommit));
             if (!integrated) {
-                throw new Error(`WorkItem ChangeSet is not integrated: ${latest.id}.`);
+                throw new Error(`WorkItem result is not integrated: ${item.id}/${entry.projectId}.`);
             }
             projects.push({
                 projectId: entry.projectId,
                 baseCommit: entry.baseCommit,
-                headCommit,
-                changeSetId: latest.id
+                headCommit
             });
         }
         return {
@@ -167,8 +158,7 @@ export class WorkItemChangeSetManager {
                         projects.push({
                             projectId: entry.projectId,
                             baseCommit: entry.baseCommit,
-                            headCommit,
-                            changeSetId: latest.id
+                            headCommit
                         });
                         continue;
                     }
@@ -226,8 +216,7 @@ export class WorkItemChangeSetManager {
                 deletedPaths: result.deletedPaths
             }),
             deletedPaths: result.deletedPaths,
-            ...(targetRef === undefined ? {} : { targetRef }),
-            evidenceRefs: this.#captureEvidenceRefs(context.taskId, context.workItemId, result.headCommit)
+            ...(targetRef === undefined ? {} : { targetRef })
         });
         return this.store.transaction((tx) => {
             assertCaptureStillCurrent(tx, context);
@@ -258,39 +247,6 @@ export class WorkItemChangeSetManager {
             return changeSet;
         });
     }
-    /**
-     * Verified evidence for the exact reviewed candidate.  A completed
-     * ReviewRound freezes the candidate it reviewed at `reviewBaseCommit`; when
-     * the captured ChangeSet head is that commit, the round's checks are
-     * durable evidence for it.  "completed" alone is not a verdict: the
-     * reviewer may have completed with failed checks (requires-repair), so only a
-     * round with an explicit positive verdict — at least one passed check and
-     * no failed one — may feed `evidenceRefs`.  The link is by
-     * `reviewBaseCommit`, not by `evidenceCommit`: the latter records the exact
-     * tree the checks ran on (the frozen base for a clean review, a diagnostic
-     * commit for a committed-diagnostic review, absent for a dirty review), and
-     * the queue separately re-checks that tree binding before waiving a gate.
-     */
-    #captureEvidenceRefs(taskId, workItemId, headCommit) {
-        return this.store.listReviewRounds(taskId)
-            .filter((round) => round.status === "completed"
-            && round.workItemId === workItemId
-            && round.reviewBaseCommit === headCommit
-            && hasPositiveReviewVerdict(round.checks))
-            .map(({ id }) => `review-round:${id}`);
-    }
-}
-/**
- * A ReviewRound carries reusable verification evidence only when its checks
- * state an explicit positive verdict: at least one check passed and none
- * failed.  A round without checks, or with only skipped checks, has no
- * positive conclusion; a round with a failed check rejects the candidate.
- * Neither may skip a later gate.
- */
-function hasPositiveReviewVerdict(checks) {
-    return checks !== undefined
-        && checks.some((check) => check.outcome === "passed")
-        && checks.every((check) => check.outcome !== "failed");
 }
 function requireCapturableContext(store, taskId, workItemId, taskFinalReviewContract) {
     const item = store.getWorkItem(taskId, workItemId);
@@ -327,7 +283,7 @@ function requireCapturableContext(store, taskId, workItemId, taskFinalReviewCont
             throw new Error(`Work item has no managed workspace: ${item.id}.`);
         }
         const candidate = item.candidates.at(-1);
-        if (candidate?.source.type !== "direct"
+        if (candidate === undefined
             || !sameTaskFinalReviewContract(candidate.taskFinalReviewContract, taskFinalReviewContract)) {
             throw new Error(`Work item has no matching exact Task-final direct Candidate: ${item.id}.`);
         }

package/docs/task-local-identity.md

@@ -51,7 +51,7 @@ There is no compatibility lookup, cross-Task guess, or bare-ID fallback.
 
 ## Current-schema boundary
 
-Runtime opens only aggregate v13 / StoredTask v12. It does not convert,
+Runtime opens only aggregate v31 / Task v7. It does not convert,
 dual-read, or infer records from an older schema. If an existing `YUI_HOME`
 does not match the current schema, keep it untouched for external archival
 and initialize a fresh home for this runtime.