@zq-silk/yui 0.5.3 → 0.6.1

package/dist/task/deliveryGuard.js

@@ -0,0 +1,226 @@
+const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
+export function detectDeliveryDuplicates(facts, intent) {
+    switch (intent.kind) {
+        case "create-work-item":
+            return detectWorkItemDuplicates(facts, intent.scope);
+        case "integration-start":
+            return detectIntegrationDuplicates(facts, intent);
+        case "review-request":
+            return detectReviewDuplicates(facts, intent);
+        case "complete-task":
+            return detectCompleteDuplicates(facts);
+    }
+}
+/**
+ * Apply the configured mode. `display` never interferes; `warn` reports every
+ * match as a warning; `enforce` hard-blocks on exact evidence and warns on
+ * suspected duplicates.
+ */
+export function evaluateDeliveryGuard(duplicates, mode) {
+    if (mode === "display" || duplicates.length === 0) {
+        return { blocked: null, warnings: [] };
+    }
+    const exact = duplicates.filter((duplicate) => duplicate.severity === "exact");
+    const suspected = duplicates.filter((duplicate) => duplicate.severity === "suspected");
+    if (mode === "enforce" && exact.length > 0) {
+        return { blocked: exact[0], warnings: suspected };
+    }
+    return { blocked: null, warnings: [...exact, ...suspected] };
+}
+export function formatDeliveryDuplicate(duplicate) {
+    const refs = duplicate.refs.map((ref) => `${ref.kind} ${ref.id}`).join(", ");
+    const reuse = duplicate.reuseCommand === undefined
+        ? ""
+        : ` Existing proof: ${duplicate.reuseCommand}`;
+    return `${duplicate.severity === "exact" ? "Exact duplicate" : "Suspected duplicate"}: ${duplicate.reason} (${refs}).${reuse}`;
+}
+function detectWorkItemDuplicates(facts, scope) {
+    const wanted = normalizeScope(scope);
+    const duplicates = [];
+    for (const item of facts.workItems) {
+        const existing = normalizeScope({
+            title: item.title,
+            objective: item.objective,
+            acceptance: item.acceptance,
+            writeProjectIds: item.writeProjectIds
+        });
+        const sameScope = existing.title === wanted.title
+            && existing.objective === wanted.objective
+            && existing.acceptance === wanted.acceptance
+            && existing.writeProjectIds === wanted.writeProjectIds;
+        const ref = { kind: "work-item", id: item.id };
+        if (sameScope && OPEN_WORK_ITEM_STATUSES.has(item.status)) {
+            duplicates.push({
+                severity: "exact",
+                reason: `Work Item ${item.id} is already open with the identical scope`,
+                refs: [ref],
+                reuseCommand: `yui task work show ${facts.task.id}/${item.id}`
+            });
+            continue;
+        }
+        if (sameScope && item.status === "completed") {
+            duplicates.push({
+                severity: "suspected",
+                reason: `Work Item ${item.id} already delivered the identical scope; re-creating it may be a duplicate successor`,
+                refs: [ref],
+                reuseCommand: `yui task work show ${facts.task.id}/${item.id}`
+            });
+            continue;
+        }
+        if (!sameScope
+            && OPEN_WORK_ITEM_STATUSES.has(item.status)
+            && existing.writeProjectIds === wanted.writeProjectIds
+            && wanted.writeProjectIds.length > 0
+            && overlap(existing.acceptance, wanted.acceptance)) {
+            duplicates.push({
+                severity: "suspected",
+                reason: `Open Work Item ${item.id} shares the same Project scope and acceptance lines`,
+                refs: [ref]
+            });
+        }
+    }
+    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 ref = { kind: "integration-attempt", id: attempt.id };
+        if (sameSet && attempt.status === "committed") {
+            duplicates.push({
+                severity: "exact",
+                reason: `Integration ${attempt.id} already committed this exact ChangeSet set`,
+                refs: [ref],
+                reuseCommand: `yui task integration show ${facts.task.id}/${attempt.id}`
+            });
+            continue;
+        }
+        if (sameSet
+            && (attempt.status === "running" || attempt.status === "validating")) {
+            duplicates.push({
+                severity: "suspected",
+                reason: `Integration ${attempt.id} is already ${attempt.status} for this exact ChangeSet set`,
+                refs: [ref],
+                reuseCommand: `yui task integration show ${facts.task.id}/${attempt.id}`
+            });
+        }
+    }
+    return duplicates;
+}
+function detectReviewDuplicates(facts, intent) {
+    const wanted = new Set(intent.taskCandidateCommits.map((commit) => commit.toLowerCase()));
+    const duplicates = [];
+    for (const round of facts.reviewRounds) {
+        if ((round.scope ?? "work-item") !== "task")
+            continue;
+        if (round.reviewerRoleName !== intent.reviewerRoleName)
+            continue;
+        const commits = new Set((round.taskCandidate?.projects ?? []).map((project) => project.commit.toLowerCase()));
+        const sameCandidate = commits.size === wanted.size
+            && commits.size > 0
+            && [...wanted].every((commit) => commits.has(commit));
+        if (!sameCandidate)
+            continue;
+        const ref = { kind: "review-round", id: round.id };
+        if (round.status === "completed") {
+            duplicates.push({
+                severity: "exact",
+                reason: `Task-final Review ${round.id} already attests this exact head`,
+                refs: [ref]
+            });
+        }
+        else if (round.status === "pending" || round.status === "running") {
+            duplicates.push({
+                severity: "suspected",
+                reason: `Task-final Review ${round.id} is already ${round.status} for this exact head`,
+                refs: [ref]
+            });
+        }
+    }
+    return duplicates;
+}
+function detectCompleteDuplicates(facts) {
+    if (facts.task.status === "completed" || facts.task.status === "archived") {
+        return [{
+                severity: "exact",
+                reason: `Task ${facts.task.id} is already ${facts.task.status}`,
+                refs: [{ kind: "task", id: facts.task.id }]
+            }];
+    }
+    return [];
+}
+function normalizeScope(scope) {
+    return {
+        title: scope.title.trim().toLowerCase(),
+        objective: scope.objective.trim().toLowerCase(),
+        acceptance: [...scope.acceptance]
+            .map((line) => line.trim().toLowerCase())
+            .filter((line) => line.length > 0)
+            .sort()
+            .join("\n"),
+        writeProjectIds: [...scope.writeProjectIds].map((id) => id.trim()).sort().join(",")
+    };
+}
+function overlap(left, right) {
+    const rightLines = new Set(right.split("\n"));
+    return left.split("\n").some((line) => line.length > 0 && rightLines.has(line));
+}
+/**
+ * Default number of consecutive yielded Leader turns that must produce no
+ * durable delivery change before the budget is exhausted.
+ */
+export const DEFAULT_SEMANTIC_BUDGET_TURNS = 3;
+/**
+ * Evaluate the semantic-progress budget from existing records only. The
+ * budget is exhausted when the last `turns` Leader Runs all yielded and no
+ * WorkItem/ChangeSet/Integration/Review record changed at or after the first
+ * of those Runs. Active execution (any Run) never exhausts the budget: a
+ * slow but progressing Worker or Leader is never interrupted.
+ */
+export function evaluateSemanticBudget(facts, turns = DEFAULT_SEMANTIC_BUDGET_TURNS) {
+    if (facts.activeRuns.length > 0) {
+        return {
+            exhausted: false,
+            reason: "Active execution is in flight; the budget never interrupts a progressing Run.",
+            evidence: facts.activeRuns.map((run) => run.id)
+        };
+    }
+    const recentLeaderRuns = facts.leaderRuns
+        .filter((run) => run.status === "yielded")
+        .slice(-turns);
+    if (recentLeaderRuns.length < turns) {
+        return {
+            exhausted: false,
+            reason: `Fewer than ${turns} consecutive yielded Leader turns.`,
+            evidence: recentLeaderRuns.map((run) => run.id)
+        };
+    }
+    const firstStartedAt = Math.min(...recentLeaderRuns.map((run) => Date.parse(run.createdAt)));
+    const changed = latestDeliveryChangeAt(facts);
+    if (changed >= firstStartedAt) {
+        return {
+            exhausted: false,
+            reason: "A delivery record changed during the recent Leader turns.",
+            evidence: recentLeaderRuns.map((run) => run.id)
+        };
+    }
+    return {
+        exhausted: true,
+        reason: `${turns} consecutive Leader turns produced no durable delivery change; record a diagnosis/yield and wait for new facts instead of creating more records.`,
+        evidence: recentLeaderRuns.map((run) => run.id)
+    };
+}
+function latestDeliveryChangeAt(facts) {
+    const timestamps = [
+        ...facts.workItems.map((item) => Date.parse(item.updatedAt)),
+        ...facts.changeSets.map((changeSet) => Date.parse(changeSet.createdAt)),
+        ...facts.integrations.map((attempt) => Math.max(Date.parse(attempt.updatedAt), Date.parse(attempt.endedAt ?? attempt.updatedAt))),
+        ...facts.reviewRounds.map((round) => Math.max(Date.parse(round.createdAt), Date.parse(round.endedAt ?? round.createdAt)))
+    ];
+    return timestamps.length === 0 ? 0 : Math.max(...timestamps);
+}

package/dist/task/nextAction.js

@@ -0,0 +1,343 @@
+import { createHash } from "node:crypto";
+import { currentWorkItemCandidate } from "../workItem/workItem.js";
+const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
+export function projectNextAction(facts) {
+    const { task } = facts;
+    if (task.status !== "active" && task.status !== "draft") {
+        return buildAction(facts, {
+            kind: "complete-task",
+            reason: `Task ${task.id} is ${task.status}; no further protocol action is available.`,
+            refs: [ref("task", task.id)],
+            preconditions: [
+                { fact: `Task status is ${task.status}`, satisfied: true, ref: ref("task", task.id) }
+            ]
+        });
+    }
+    const openInput = facts.openInputRequests[0];
+    if (openInput !== undefined) {
+        return buildAction(facts, {
+            kind: "resolve-input",
+            reason: `Input ${openInput.id} is open and blocks protocol convergence.`,
+            refs: [ref("input-request", openInput.id)],
+            preconditions: [
+                { fact: "Input request is open", satisfied: true, ref: ref("input-request", openInput.id) }
+            ],
+            recommendedCommand: `yui task input answer ${task.id}/${openInput.id}`
+        });
+    }
+    const inconsistency = detectProtocolInconsistency(facts);
+    if (inconsistency !== null) {
+        return buildAction(facts, {
+            kind: "repair-protocol-inconsistency",
+            reason: inconsistency.reason,
+            refs: inconsistency.conflicts,
+            conflicts: inconsistency.conflicts,
+            preconditions: inconsistency.conflicts.map((entry) => ({ fact: `Conflicting record ${entry.kind} ${entry.id}`, satisfied: false, ref: entry })),
+            recommendedCommand: inconsistency.recommendedCommand
+        });
+    }
+    const activeLeader = facts.activeRuns.find((run) => run.roleName === "leader");
+    if (activeLeader !== undefined) {
+        return buildAction(facts, {
+            kind: "wait-for-owned-execution",
+            reason: `Leader Run ${activeLeader.id} is active; the protocol position is being executed.`,
+            refs: [ref("agent-run", activeLeader.id)],
+            preconditions: [
+                { fact: "Leader Run is active", satisfied: true, ref: ref("agent-run", activeLeader.id) }
+            ]
+        });
+    }
+    const candidateReady = facts.workItems
+        .find((item) => item.status === "awaiting_acceptance");
+    if (candidateReady !== undefined) {
+        const candidate = currentWorkItemCandidate(candidateReady);
+        if (candidate !== undefined && isEmptyDirectCandidate(candidate)) {
+            const candidateRef = ref("candidate", `${candidateReady.id}/${candidate.id}`);
+            return buildAction(facts, {
+                kind: "repair-protocol-inconsistency",
+                reason: `Candidate ${candidate.id} is a direct Task-main delivery with base==head (no commits); reject it and re-dispatch real work.`,
+                refs: [ref("work-item", candidateReady.id), candidateRef],
+                conflicts: [candidateRef],
+                preconditions: [
+                    { fact: "Direct Candidate contains at least one commit", satisfied: false, ref: candidateRef }
+                ],
+                recommendedCommand: `yui task work reject ${task.id}/${candidateReady.id} --summary \"empty base==head candidate\"`
+            });
+        }
+        const refs = [
+            ref("work-item", candidateReady.id),
+            ...(candidate === undefined ? [] : [ref("candidate", `${candidateReady.id}/${candidate.id}`)])
+        ];
+        return buildAction(facts, {
+            kind: "accept-or-reject-candidate",
+            reason: `Work Item ${candidateReady.id} has a Candidate awaiting Leader disposition.`,
+            refs,
+            preconditions: [
+                { fact: "Work Item is awaiting acceptance", satisfied: true, ref: refs[0] },
+                ...(candidate === undefined
+                    ? [{ fact: "Candidate record exists", satisfied: false }]
+                    : [{ fact: "Candidate record exists", satisfied: true, ref: refs[1] }])
+            ],
+            recommendedCommand: `yui task work accept ${task.id}/${candidateReady.id} --summary \"<decision>\"`
+        });
+    }
+    const activeWorkers = facts.activeRuns.filter((run) => run.roleName !== "leader");
+    if (activeWorkers.length > 0) {
+        return buildAction(facts, {
+            kind: "wait-for-owned-execution",
+            reason: `${activeWorkers.length} delegated Run(s) are active; wait for their delivery.`,
+            refs: activeWorkers.map((run) => ref("agent-run", run.id)),
+            preconditions: activeWorkers.map((run) => ({ fact: `Delegated Run ${run.id} is active`, satisfied: true, ref: ref("agent-run", run.id) }))
+        });
+    }
+    const failedWork = facts.workItems.find((item) => item.status === "failed");
+    if (failedWork !== undefined) {
+        const failedReview = latestFailedReviewFor(facts.reviewRounds, failedWork.id);
+        if (failedReview !== undefined) {
+            return buildAction(facts, {
+                kind: "route-review-findings",
+                reason: `Work Item ${failedWork.id} failed with Review ${failedReview.id}; route its open findings into a repair wave.`,
+                refs: [ref("work-item", failedWork.id), ref("review-round", failedReview.id)],
+                preconditions: [
+                    { fact: "Work Item is failed", satisfied: true, ref: ref("work-item", failedWork.id) },
+                    { fact: "Review Round is failed", satisfied: true, ref: ref("review-round", failedReview.id) }
+                ]
+            });
+        }
+        return buildAction(facts, {
+            kind: "implement-current-work-item",
+            reason: `Work Item ${failedWork.id} failed without a Review verdict; retry implementation.`,
+            refs: [ref("work-item", failedWork.id)],
+            preconditions: [
+                { fact: "Work Item is failed", satisfied: true, ref: ref("work-item", failedWork.id) }
+            ],
+            recommendedCommand: `yui task work update ${task.id}/${failedWork.id} running`
+        });
+    }
+    const openWork = facts.workItems
+        .find((item) => OPEN_WORK_ITEM_STATUSES.has(item.status));
+    if (openWork !== undefined) {
+        return buildAction(facts, {
+            kind: "implement-current-work-item",
+            reason: `Work Item ${openWork.id} is ${openWork.status}; dispatch or continue its implementation.`,
+            refs: [ref("work-item", openWork.id)],
+            preconditions: [
+                { fact: `Work Item is ${openWork.status}`, satisfied: true, ref: ref("work-item", openWork.id) }
+            ],
+            recommendedCommand: `yui task work dispatch ${task.id}/${openWork.id}`
+        });
+    }
+    if (facts.workItems.length === 0) {
+        return buildAction(facts, {
+            kind: "implement-current-work-item",
+            reason: `Task ${task.id} has no Work Item; create the first unit of work.`,
+            refs: [],
+            preconditions: [
+                { fact: "At least one Work Item exists", satisfied: false },
+                { fact: "Task is active", satisfied: task.status === "active" }
+            ],
+            recommendedCommand: task.status === "draft"
+                ? `yui task activate ${task.id}`
+                : `yui task work create ${task.id} \"<objective>\"`
+        });
+    }
+    const uncaptured = facts.workItems.find((item) => needsChangeSetCapture(facts, item));
+    if (uncaptured !== undefined) {
+        return buildAction(facts, {
+            kind: "capture-change-set",
+            reason: `Work Item ${uncaptured.id} is completed but has no ChangeSet; capture its delivery boundary.`,
+            refs: [ref("work-item", uncaptured.id)],
+            preconditions: [
+                { fact: "Work Item is completed", satisfied: true, ref: ref("work-item", uncaptured.id) },
+                { fact: "ChangeSet exists for the Work Item", satisfied: false }
+            ],
+            recommendedCommand: `yui task work capture ${task.id}/${uncaptured.id}`
+        });
+    }
+    const unintegrated = facts.changeSets
+        .find((changeSet) => !hasCommittedIntegration(facts.integrations, changeSet.id));
+    if (unintegrated !== undefined) {
+        return buildAction(facts, {
+            kind: "integrate-change-set",
+            reason: `ChangeSet ${unintegrated.id} has no committed Integration.`,
+            refs: [ref("change-set", unintegrated.id)],
+            preconditions: [
+                { fact: "ChangeSet exists", satisfied: true, ref: ref("change-set", unintegrated.id) },
+                { fact: "Committed Integration references the ChangeSet", satisfied: false }
+            ],
+            recommendedCommand: `yui task integration start ${task.id} --project ${unintegrated.projectId} --change-set ${unintegrated.id}`
+        });
+    }
+    const failedFinal = latestTaskFinalReview(facts.reviewRounds);
+    if (failedFinal !== undefined && failedFinal.status === "failed") {
+        return buildAction(facts, {
+            kind: "route-review-findings",
+            reason: `Task-final Review ${failedFinal.id} failed; route its open findings into a repair wave on one frozen head.`,
+            refs: [ref("review-round", failedFinal.id)],
+            preconditions: [
+                { fact: "Task-final Review is failed", satisfied: true, ref: ref("review-round", failedFinal.id) }
+            ]
+        });
+    }
+    if (task.projectBindings.length > 0 && !hasValidFinalReview(facts)) {
+        return buildAction(facts, {
+            kind: "request-final-review",
+            reason: "All Work Items are delivered but no valid Task-final Review attests the integrated head.",
+            refs: [ref("task", task.id)],
+            preconditions: [
+                { fact: "All Work Items are terminal", satisfied: true },
+                { fact: "Every ChangeSet is committed", satisfied: true },
+                { fact: "Valid Task-final Review at the integrated head", satisfied: false }
+            ],
+            recommendedCommand: `yui task review request ${task.id} --role <global-reviewer>`
+        });
+    }
+    return buildAction(facts, {
+        kind: "complete-task",
+        reason: "The delivery chain is complete; converge the Task instead of creating successor work.",
+        refs: [ref("task", task.id)],
+        preconditions: [
+            { fact: "All Work Items are terminal", satisfied: true },
+            ...(task.projectBindings.length === 0
+                ? []
+                : [
+                    { fact: "Every ChangeSet is committed", satisfied: true },
+                    { fact: "Valid Task-final Review at the integrated head", satisfied: true }
+                ])
+        ],
+        recommendedCommand: `yui task complete ${task.id} --summary-file -`
+    });
+}
+/**
+ * Stable fingerprint of the durable delivery position. It changes exactly
+ * when a delivery record changes, so the semantic-progress budget can compare
+ * positions across Leader turns without persisting anything new.
+ */
+export function durableStateFingerprint(facts) {
+    const parts = [
+        `task:${facts.task.status}`,
+        ...facts.workItems.map((item) => `work:${item.id}:${item.status}:${item.revision}:${item.updatedAt}`),
+        ...facts.changeSets.map((changeSet) => `change-set:${changeSet.id}:${changeSet.headCommit}`),
+        ...facts.integrations.map((attempt) => `integration:${attempt.id}:${attempt.status}:${attempt.updatedAt}`),
+        ...facts.reviewRounds.map((round) => `review:${round.id}:${round.status}:${round.endedAt ?? ""}`)
+    ];
+    return createHash("sha256").update(parts.join("\n")).digest("hex");
+}
+function buildAction(facts, input) {
+    const fingerprintSource = [
+        input.kind,
+        ...input.refs.map((entry) => `${entry.kind}:${entry.id}`)
+    ].join("|");
+    return {
+        taskId: facts.task.id,
+        kind: input.kind,
+        reason: input.reason,
+        refs: input.refs,
+        preconditions: input.preconditions,
+        ...(input.recommendedCommand === undefined
+            ? {}
+            : { recommendedCommand: input.recommendedCommand }),
+        ...(input.conflicts === undefined ? {} : { conflicts: input.conflicts }),
+        fingerprint: createHash("sha256").update(fingerprintSource).digest("hex")
+    };
+}
+function ref(kind, id) {
+    return { kind, id };
+}
+function isEmptyDirectCandidate(candidate) {
+    const snapshot = candidate.taskMainSnapshot;
+    if (snapshot === undefined)
+        return false;
+    return snapshot.projects.every((project) => project.baseCommit === project.headCommit);
+}
+function latestFailedReviewFor(rounds, workItemId) {
+    return [...rounds]
+        .reverse()
+        .find((round) => round.workItemId === workItemId && round.status === "failed");
+}
+function latestTaskFinalReview(rounds) {
+    return [...rounds]
+        .reverse()
+        .find((round) => (round.scope ?? "work-item") === "task");
+}
+function hasCommittedIntegration(integrations, changeSetId) {
+    return integrations.some((attempt) => attempt.status === "committed" && attempt.changeSetIds.includes(changeSetId));
+}
+function needsChangeSetCapture(facts, item) {
+    if (item.status !== "completed")
+        return false;
+    if (facts.changeSets.some((changeSet) => changeSet.workItemId === item.id))
+        return false;
+    const candidate = item.candidates.at(-1);
+    if (candidate === undefined)
+        return false;
+    // A metadata-only direct Task-main Candidate has no WorkItem Develop
+    // workspace to capture; its boundary is the Task-main head itself.
+    if (candidate.workspace === undefined
+        && candidate.gitSnapshot === undefined
+        && candidate.taskMainSnapshot !== undefined) {
+        return false;
+    }
+    return candidate.workspace !== undefined || candidate.gitSnapshot !== undefined;
+}
+function hasValidFinalReview(facts) {
+    const final = latestTaskFinalReview(facts.reviewRounds);
+    if (final === undefined || final.status !== "completed")
+        return false;
+    const reviewedCommits = new Set((final.taskCandidate?.projects ?? []).map((project) => project.commit));
+    if (reviewedCommits.size === 0)
+        return false;
+    const integratedHeads = new Set(facts.integrations
+        .filter((attempt) => attempt.status === "committed")
+        .flatMap((attempt) => facts.changeSets
+        .filter((changeSet) => attempt.changeSetIds.includes(changeSet.id))
+        .map((changeSet) => changeSet.headCommit)));
+    if (integratedHeads.size === 0)
+        return false;
+    for (const head of integratedHeads) {
+        if (!reviewedCommits.has(head))
+            return false;
+    }
+    return true;
+}
+function detectProtocolInconsistency(facts) {
+    const changeSetIds = new Set(facts.changeSets.map((changeSet) => changeSet.id));
+    const workItemById = new Map(facts.workItems.map((item) => [item.id, item]));
+    for (const attempt of facts.integrations) {
+        if (attempt.status !== "committed")
+            continue;
+        const dangling = attempt.changeSetIds
+            .filter((id) => !changeSetIds.has(id));
+        if (dangling.length > 0) {
+            return {
+                reason: `Committed Integration ${attempt.id} references missing ChangeSet(s): ${dangling.join(", ")}.`,
+                conflicts: [
+                    ref("integration-attempt", attempt.id),
+                    ...dangling.map((id) => ref("change-set", id))
+                ]
+            };
+        }
+    }
+    for (const round of facts.reviewRounds) {
+        if (round.status !== "pending" && round.status !== "running")
+            continue;
+        const item = workItemById.get(round.workItemId);
+        if (item !== undefined && item.status === "retired") {
+            return {
+                reason: `Review ${round.id} is still ${round.status} but its Work Item ${item.id} is retired.`,
+                conflicts: [ref("review-round", round.id), ref("work-item", item.id)]
+            };
+        }
+    }
+    for (const item of facts.workItems) {
+        if (item.status !== "awaiting_acceptance")
+            continue;
+        if (item.candidates.length === 0) {
+            return {
+                reason: `Work Item ${item.id} is awaiting acceptance but has no Candidate record.`,
+                conflicts: [ref("work-item", item.id)]
+            };
+        }
+    }
+    return null;
+}