@zq-silk/yui 0.8.2 → 0.8.6

package/dist/task/completionReadiness.js

@@ -1,5 +1,6 @@
 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 { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 const ACTIVE_JOB_STATUSES = new Set([
@@ -16,6 +17,7 @@ const TERMINAL_REVIEW_STATUSES = new Set(["completed", "failed"]);
 const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "yielded"]);
 export function projectCompletionReadiness(facts, options = {}) {
     const blockers = [];
+    const advisories = [];
     const { task } = facts;
     const findingsGate = options.findingsGate ?? true;
     // A pending/running Task-final Review must be resumed or blocked first.
@@ -38,7 +40,11 @@ export function projectCompletionReadiness(facts, options = {}) {
     // 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" && round.status === "completed"))
+        .filter((round) => ((round.scope ?? "work-item") === "task" && isSemanticReviewRound(round, {
+        listAgentRuns: () => facts.agentRuns,
+        listReviewFindings: () => facts.reviewFindings,
+        listEvents: () => facts.events
+    })))
         .slice()
         .sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
         || left.id.localeCompare(right.id, undefined, { numeric: true })))
@@ -142,6 +148,8 @@ export function projectCompletionReadiness(facts, options = {}) {
     }
     // Provider continuations that may still write the Workspace.
     for (const continuation of blockingProviderContinuations(facts.events)) {
+        if (!providerContinuationBlocksCompletion(continuation, facts))
+            continue;
         const identity = continuation.identity;
         blockers.push({
             code: "blocking-provider-continuation",
@@ -151,12 +159,15 @@ export function projectCompletionReadiness(facts, options = {}) {
             fix: `wait for or recover the Provider turn on run ${continuation.runId}`
         });
     }
-    // Undisposed managed workspaces.  The Task-owned main workspace is excluded
-    // (it is cleaned at archive, not at completion).
+    // Terminal child workspaces are cleanup advisories: Task completion is the
+    // semantic delivery boundary, while archive remains the fail-closed resource
+    // reclamation boundary. Missing/non-terminal ownership stays conservative.
     for (const workspace of facts.managedWorkspaces) {
-        const blocker = workspaceBlocker(facts, task.id, workspace);
-        if (blocker !== null)
-            blockers.push(blocker);
+        const disposition = workspaceCompletionDisposition(facts, task.id, workspace);
+        if (disposition?.kind === "blocker")
+            blockers.push(disposition.value);
+        if (disposition?.kind === "advisory")
+            advisories.push(disposition.value);
     }
     // Active non-Leader Runs must finish.  The Leader's own Run is terminalized
     // by the completion transaction itself, so it is not a readiness blocker.
@@ -207,63 +218,124 @@ export function projectCompletionReadiness(facts, options = {}) {
             return kindOrder;
         return left.ref.id.localeCompare(right.ref.id, undefined, { numeric: true });
     });
-    return { taskId: task.id, ready: sorted.length === 0, blockers: sorted };
+    const sortedAdvisories = [...advisories].sort((left, right) => {
+        const codeOrder = left.code.localeCompare(right.code);
+        if (codeOrder !== 0)
+            return codeOrder;
+        const kindOrder = left.ref.kind.localeCompare(right.ref.kind);
+        if (kindOrder !== 0)
+            return kindOrder;
+        return left.ref.id.localeCompare(right.ref.id, undefined, { numeric: true });
+    });
+    return {
+        taskId: task.id,
+        ready: sorted.length === 0,
+        blockers: sorted,
+        advisories: sortedAdvisories
+    };
+}
+/**
+ * A terminal Run releases only its completion blocker, never its immutable
+ * continuation audit. Missing or inconsistent ownership remains ambiguous and
+ * therefore fail-closed. A live exact native Session can still deliver or
+ * write for a terminal Run, so it retains the blocker until that Session is
+ * stopped, broken, or replaced by another Conversation identity.
+ */
+function providerContinuationBlocksCompletion(continuation, facts) {
+    if (continuation.identityConflict)
+        return true;
+    const ownerRun = facts.agentRuns.find(({ id }) => id === continuation.runId);
+    if (ownerRun === undefined
+        || ownerRun.taskId !== continuation.taskId
+        || ownerRun.roleName !== continuation.roleName
+        || ownerRun.effective.agentId !== continuation.identity.accountScope) {
+        return true;
+    }
+    if (ownerRun.status !== "failed" && ownerRun.status !== "yielded")
+        return true;
+    const sessions = facts.roleSessionSets.find(({ owner }) => (owner.taskId === continuation.taskId && owner.roleName === continuation.roleName));
+    const session = sessions?.sessions[continuation.identity.accountScope];
+    if (session !== undefined
+        && session.status !== "stopped"
+        && session.status !== "broken"
+        && session.nativeSessionId === continuation.identity.conversationId) {
+        return true;
+    }
+    const binding = sessions?.providerBinding;
+    if (binding === undefined || binding === null
+        || binding.providerNamespace !== continuation.identity.providerNamespace
+        || binding.accountScope !== continuation.identity.accountScope) {
+        return false;
+    }
+    const conversationIsCurrent = binding.conversations.some((conversation) => (conversation.conversationId === continuation.identity.conversationId
+        && conversation.epoch === binding.currentConversationEpoch
+        && conversation.status === "current"));
+    const activationIsLive = binding.activations.some((activation) => (activation.activationId === continuation.identity.activationId
+        && activation.conversationId === continuation.identity.conversationId
+        && activation.status === "active"));
+    return conversationIsCurrent && activationIsLive;
 }
-function workspaceBlocker(facts, taskId, workspace) {
+function workspaceCompletionDisposition(facts, taskId, workspace) {
     const owner = workspace.owner;
     switch (owner.type) {
         case "task":
             // The Task main workspace is cleaned at archive, not completion.
             return null;
         case "work-item": {
-            // The preflight has always blocked on WorkItem workspaces.  Project the
-            // blocker regardless of the Work Item status: if the item is still open
-            // the incomplete-work-item blocker fires too, and once it is terminal
-            // the workspace is the exact cleanup target.
-            return {
+            const item = facts.workItems.find((entry) => entry.id === owner.workItemId);
+            const value = {
                 code: "work-item-workspace-undisposed",
                 ref: ref("work-item", owner.workItemId),
                 reason: `Work Item ${owner.workItemId} has an isolated workspace that is not disposed.`,
                 fix: `yui task work cleanup ${taskId}/${owner.workItemId} --integrated|--abandon`
             };
+            return item !== undefined && (item.status === "completed" || item.status === "retired")
+                ? { kind: "advisory", value }
+                : { kind: "blocker", value };
         }
         case "review-round": {
             const round = facts.reviewRounds.find((entry) => entry.id === owner.reviewRoundId);
-            // A workspace for a still-active Review is covered by the
-            // active-task-review / wait-for-owned-execution path; only project the
-            // cleanup blocker once the Round is terminal.
             if (round !== undefined && !TERMINAL_REVIEW_STATUSES.has(round.status))
                 return null;
-            return {
+            const value = {
                 code: "review-workspace-undisposed",
                 ref: ref("review-round", owner.reviewRoundId),
                 reason: `ReviewRound ${owner.reviewRoundId} is terminal but its workspace is not cleaned up.`,
                 fix: `yui task work review cleanup ${taskId}/${owner.reviewRoundId}`
             };
+            return round === undefined
+                ? { kind: "blocker", value }
+                : { kind: "advisory", value };
         }
         case "integration-attempt": {
             const integration = facts.integrations.find((entry) => entry.id === owner.integrationAttemptId);
             if (integration !== undefined && UNRESOLVED_INTEGRATION_STATUSES.has(integration.status)) {
                 return null;
             }
-            return {
+            const value = {
                 code: "integration-workspace-undisposed",
                 ref: ref("integration-attempt", owner.integrationAttemptId),
                 reason: `Integration Attempt ${owner.integrationAttemptId} is terminal but its workspace is not cleaned up.`,
                 fix: `retry or continue Integration ${owner.integrationAttemptId} so its workspace is reclaimed`
             };
+            return integration === undefined
+                ? { kind: "blocker", value }
+                : { kind: "advisory", value };
         }
         case "execution-lane": {
             const lane = findExecutionLane(facts, owner.executionGroupId, owner.executionLaneId);
             if (lane !== undefined && !TERMINAL_LANE_STATUSES.has(lane.status))
                 return null;
-            return {
+            const value = {
                 code: "execution-lane-workspace-undisposed",
                 ref: ref("execution-lane", `${owner.executionGroupId}/${owner.executionLaneId}`),
                 reason: `Execution Lane ${owner.executionGroupId}/${owner.executionLaneId} `
                     + "is terminal but its workspace is not cleaned up.",
                 fix: `clean up Execution Lane ${owner.executionGroupId}/${owner.executionLaneId}`
             };
+            return lane === undefined
+                ? { kind: "blocker", value }
+                : { kind: "advisory", value };
         }
     }
 }

package/dist/task/deliveryGuard.js

@@ -1,3 +1,5 @@
+import { nextActionReviewOutcomeEvidence } from "./nextAction.js";
+import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function detectDeliveryDuplicates(facts, intent) {
     switch (intent.kind) {
@@ -127,7 +129,7 @@ function detectReviewDuplicates(facts, intent) {
         if (!sameCandidate)
             continue;
         const ref = { kind: "review-round", id: round.id };
-        if (round.status === "completed") {
+        if (isSemanticReviewRound(round, nextActionReviewOutcomeEvidence(facts))) {
             duplicates.push({
                 severity: "exact",
                 reason: `Task-final Review ${round.id} already attests this exact head`,

package/dist/task/nextAction.js

@@ -1,6 +1,9 @@
 import { createHash } from "node:crypto";
-import { sameTaskFinalReviewContract, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
-import { currentWorkItemCandidate } from "../workItem/workItem.js";
+import { deltaRecheckBlocksAcceptance } from "../review/reviewRound.js";
+import { classifyReviewRoundOutcome, isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
+import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractRebind.js";
+import { taskDeliveryPath } from "./task.js";
+import { currentWorkItemCandidate, governingWorkItemCandidate } from "../workItem/workItem.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function projectNextAction(facts) {
     const { task } = facts;
@@ -252,16 +255,41 @@ export function projectNextAction(facts) {
         });
     }
     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: `yui task work create ${task.id} \"<objective>\"`
-        });
+        if (taskDeliveryPath(task) === "direct" && !taskFinalReviewRequired(facts)) {
+            return buildAction(facts, {
+                kind: "complete-task",
+                reason: `Task ${task.id} uses direct delivery; implement and verify the managed Task main, then complete without creating a WorkItem.`,
+                refs: [ref("task", task.id)],
+                preconditions: [
+                    { fact: "Task is active", satisfied: task.status === "active", ref: ref("task", task.id) },
+                    { fact: "Task main is clean, committed, and verified", satisfied: false }
+                ],
+                recommendedCommand: `yui task complete ${task.id} --summary-file -`,
+                ...(facts.reviewConfig === null
+                    ? {}
+                    : {
+                        alternatives: [{
+                                kind: "promote-to-integrated-delivery",
+                                reason: "Before Task main advances, promote to integrated delivery when risk warrants an independently managed ReviewRound.",
+                                recommendedCommand: `yui task update ${task.id} --delivery integrated`,
+                                refs: [ref("task", task.id)]
+                            }],
+                        judgmentRequired: "Leader must decide whether the work still fits direct delivery or should be promoted before completing it."
+                    })
+            });
+        }
+        if (taskDeliveryPath(task) === "integrated") {
+            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: `yui task work create ${task.id} \"<objective>\"`
+            });
+        }
     }
     const uncaptured = facts.workItems.find((item) => needsChangeSetCapture(facts, item));
     if (uncaptured !== undefined) {
@@ -291,10 +319,38 @@ export function projectNextAction(facts) {
         });
     }
     const failedFinal = latestTaskFinalReview(facts.reviewRounds);
-    if (failedFinal !== undefined && failedFinal.status === "failed") {
+    const failedFinalOutcome = failedFinal === undefined
+        ? null
+        : classifyReviewRoundOutcome(failedFinal, nextActionReviewOutcomeEvidence(facts));
+    if (failedFinal !== undefined && failedFinalOutcome?.kind === "non-semantic") {
+        return buildAction(facts, {
+            kind: "resume-review",
+            reason: `Task-final Review ${failedFinal.id} ended before a semantic review was proven.`,
+            refs: [ref("review-round", failedFinal.id)],
+            preconditions: [
+                { fact: "Task-final Review has semantic evidence", satisfied: false, ref: ref("review-round", failedFinal.id) }
+            ],
+            recommendedCommand: `yui task review force-fresh ${task.id}/${failedFinal.id}`
+        });
+    }
+    if (failedFinal !== undefined && failedFinalOutcome?.kind === "ambiguous") {
+        return buildAction(facts, {
+            kind: "repair-protocol-inconsistency",
+            reason: `Task-final Review ${failedFinal.id} has ambiguous semantic and infrastructure evidence: ${failedFinalOutcome.reason}`,
+            refs: [ref("review-round", failedFinal.id)],
+            conflicts: [ref("review-round", failedFinal.id)],
+            preconditions: [
+                { fact: "Review outcome is unambiguously semantic or non-semantic", satisfied: false, ref: ref("review-round", failedFinal.id) }
+            ]
+        });
+    }
+    if (failedFinal !== undefined
+        && failedFinalOutcome?.kind === "semantic"
+        && ((failedFinal.checks ?? []).some(({ outcome }) => outcome === "failed")
+            || deltaRecheckBlocksAcceptance(failedFinal))) {
         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.`,
+            reason: `Task-final Review ${failedFinal.id} delivered semantic negative evidence; 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) }
@@ -372,19 +428,27 @@ export function projectNextAction(facts) {
         && finalReviewRequired
         && !hasValidFinalReview(facts)) {
         const reviewerRole = taskFinalReviewRole(facts);
+        const directWithoutWorkItems = taskDeliveryPath(task) === "direct"
+            && facts.workItems.length === 0;
         return buildAction(facts, {
             kind: "request-final-review",
-            reason: "All Work Items are delivered but no valid Task-final Review attests the integrated head.",
+            reason: directWithoutWorkItems
+                ? "This direct Task already owns a final-Review obligation; completion must prepare or resume a Review of its frozen Task head."
+                : "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 ${reviewerRole ?? "<reviewer-role>"}`
+            preconditions: directWithoutWorkItems
+                ? [{ fact: "Valid established Task-final Review at the direct head", satisfied: false }]
+                : [
+                    { 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: directWithoutWorkItems
+                ? `yui task complete ${task.id} --summary-file -`
+                : `yui task review request ${task.id} --role ${reviewerRole ?? "<reviewer-role>"}`
         });
     }
-    const finalReviewOptional = task.projectBindings.length > 0
+    const finalReviewOptional = taskDeliveryPath(task) === "integrated"
         && !finalReviewRequired
         && !hasValidFinalReview(facts);
     const finalReviewAlternative = finalReviewOptional && facts.reviewConfig !== null
@@ -397,19 +461,26 @@ export function projectNextAction(facts) {
         : [];
     return buildAction(facts, {
         kind: "complete-task",
-        reason: "The delivery chain is complete; converge the Task instead of creating successor work.",
+        reason: taskDeliveryPath(task) === "direct"
+            ? "The direct Task head and its established obligations are ready; converge the Task without creating successor work."
+            : "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: hasValidFinalReview(facts)
-                    }
-                ])
+                : taskDeliveryPath(task) === "direct"
+                    ? [{
+                            fact: "Valid established Task-final Review at the direct head",
+                            satisfied: hasValidFinalReview(facts)
+                        }]
+                    : [
+                        { fact: "Every ChangeSet is committed", satisfied: true },
+                        {
+                            fact: "Valid Task-final Review at the integrated head",
+                            satisfied: hasValidFinalReview(facts)
+                        }
+                    ])
         ],
         ...(finalReviewAlternative.length === 0 ? {} : { alternatives: finalReviewAlternative }),
         ...(!finalReviewOptional
@@ -431,7 +502,8 @@ export function durableStateFingerprint(facts) {
         ...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 ?? ""}`)
+        ...facts.reviewRounds.map((round) => `review:${round.id}:${round.status}:${round.endedAt ?? ""}`),
+        ...facts.taskFinalReviewContractEvents.map((event) => `task-final-review-event:${event.id}:${event.createdAt}`)
     ];
     return createHash("sha256").update(parts.join("\n")).digest("hex");
 }
@@ -601,16 +673,16 @@ function selectOpenWorkItem(workItems) {
     return { kind: "none" };
 }
 function taskFinalReviewContract(facts) {
-    const contract = facts.workItems
-        .flatMap((item) => item.candidates)
-        .map((candidate) => candidate.taskFinalReviewContract)
-        .find((contract) => contract !== undefined);
-    return contract === undefined ? undefined : validateTaskFinalReviewContract(contract);
+    return taskFinalReviewContractResolution(facts)?.effective;
+}
+function taskFinalReviewContractResolution(facts) {
+    return resolveRecordedTaskFinalReviewContract(facts.task.id, facts.workItems, facts.reviewRounds, facts.taskFinalReviewContractEvents);
 }
 function taskFinalReviewRequired(facts) {
     return taskFinalReviewContract(facts) !== undefined
         || latestTaskFinalReview(facts.reviewRounds) !== undefined
-        || facts.reviewConfig?.trigger === "final";
+        || (taskDeliveryPath(facts.task) === "integrated"
+            && facts.reviewConfig?.trigger === "final");
 }
 function taskFinalReviewRole(facts) {
     return taskFinalReviewContract(facts)?.reviewerRoleName
@@ -658,7 +730,11 @@ function needsChangeSetCapture(facts, item) {
 }
 function hasValidFinalReview(facts) {
     const final = latestTaskFinalReview(facts.reviewRounds);
-    if (final === undefined || final.status !== "completed")
+    if (final === undefined
+        || !isSemanticReviewRound(final, nextActionReviewOutcomeEvidence(facts)))
+        return false;
+    if ((final.checks ?? []).some(({ outcome }) => outcome === "failed")
+        || deltaRecheckBlocksAcceptance(final))
         return false;
     const reviewedCommits = new Set((final.taskCandidate?.projects ?? []).map((project) => project.commit));
     if (reviewedCommits.size === 0)
@@ -676,22 +752,41 @@ function hasValidFinalReview(facts) {
     }
     return true;
 }
+/** Adapts the serializable next-action evidence bundle to the shared classifier. */
+export function nextActionReviewOutcomeEvidence(facts) {
+    const evidence = facts.reviewOutcomeEvidence;
+    if (evidence === undefined)
+        return undefined;
+    return {
+        listAgentRuns: () => evidence.agentRuns,
+        listReviewFindings: () => evidence.reviewFindings,
+        listEvents: () => evidence.events
+    };
+}
 function detectProtocolInconsistency(facts) {
     const changeSetIds = new Set(facts.changeSets.map((changeSet) => changeSet.id));
     const workItemById = new Map(facts.workItems.map((item) => [item.id, item]));
-    const contractedCandidates = facts.workItems
-        .flatMap((item) => item.candidates.map((candidate) => ({ item, candidate })))
-        .filter(({ candidate }) => candidate.taskFinalReviewContract !== undefined);
-    if (contractedCandidates.length > 1) {
-        const first = validateTaskFinalReviewContract(contractedCandidates[0].candidate.taskFinalReviewContract);
-        const conflict = contractedCandidates.find(({ candidate }) => (!sameTaskFinalReviewContract(first, candidate.taskFinalReviewContract)));
-        if (conflict !== undefined) {
-            const refs = contractedCandidates.map(({ item, candidate }) => ref("candidate", `${item.id}/${candidate.id}`));
-            return {
-                reason: "Task-final Review contracts conflict across Candidates; the completion gate is ambiguous.",
-                conflicts: refs
-            };
-        }
+    try {
+        taskFinalReviewContractResolution(facts);
+    }
+    catch (error) {
+        const candidateRefs = facts.workItems.flatMap((item) => {
+            const candidate = governingWorkItemCandidate(item);
+            return candidate?.taskFinalReviewContract === undefined
+                ? []
+                : [ref("candidate", `${item.id}/${candidate.id}`)];
+        });
+        const reviewRefs = facts.reviewRounds
+            .filter((round) => ((round.scope ?? "work-item") === "task"
+            && round.taskFinalReviewContract !== undefined))
+            .map((round) => ref("review-round", round.id));
+        const eventRefs = facts.taskFinalReviewContractEvents
+            .map((event) => ref("task-event", event.id));
+        return {
+            reason: "Task-final Review contract history is inconsistent: "
+                + (error instanceof Error ? error.message : String(error)),
+            conflicts: [...candidateRefs, ...reviewRefs, ...eventRefs]
+        };
     }
     for (const round of facts.reviewRounds) {
         const reviewConflict = reviewRoundConflict(round, facts.activeRuns);

package/dist/task/publicationReference.js

@@ -1,6 +1,7 @@
 import { requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
 import { validateTaskRecordReference } from "./taskRecordReference.js";
 export const PUBLICATION_REFERENCE_SCHEMA_VERSION = 1;
+export const TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT = "task.completion-published-tree-authorized";
 const PROVIDERS = new Set(["github", "gitlab"]);
 const EXTERNAL_KINDS = new Set(["pull-request", "merge-request"]);
 const STATES = new Set(["open", "merged", "closed"]);

package/dist/task/repairWave.js

@@ -27,10 +27,23 @@ export function extractReviewFindings(round) {
     }
     return parseReportFindings(round.report ?? "");
 }
-export function planRepairWave(reviewRoundId, findings) {
+export function planRepairWave(reviewRoundId, findings, strategy = "consolidated") {
     if (findings.length === 0) {
         return { reviewRoundId, openFindingCount: 0, groups: [] };
     }
+    if (strategy === "consolidated") {
+        const ordered = [...findings].sort((left, right) => (left.id.localeCompare(right.id, undefined, { numeric: true })));
+        return {
+            reviewRoundId,
+            openFindingCount: findings.length,
+            groups: [{
+                    id: "repair-1",
+                    findingIds: ordered.map(({ id }) => id),
+                    paths: [...new Set(ordered.flatMap(({ paths }) => paths))].sort(),
+                    reason: "Consolidated by default to minimize repair, integration, and review churn"
+                }]
+        };
+    }
     const parent = new Array(findings.length).fill(0).map((_, index) => index);
     const find = (index) => {
         let current = index;

package/dist/task/task.js

@@ -319,6 +319,16 @@ export function taskProjectBinding(task, projectId) {
 export function taskHasProjects(task) {
     return task.projectBindings.length > 0;
 }
+/**
+ * Delivery is a projection of the existing Task contract, not a second source
+ * of truth. Keeping it derived preserves every stored Task schema while giving
+ * callers one product-level name for the three supported paths.
+ */
+export function taskDeliveryPath(task) {
+    if (task.projectBindings.length === 0)
+        return "no-project";
+    return task.requireIntegration === true ? "integrated" : "direct";
+}
 export function taskProjectIds(task) {
     return task.projectBindings.map(({ projectId }) => projectId);
 }

package/dist/web/webSnapshot.js

@@ -1,3 +1,4 @@
+import { taskDeliveryPath } from "../task/task.js";
 import { isRoleRunStalled, latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
@@ -40,6 +41,7 @@ export function buildWebDashboardSnapshot(store, now = new Date()) {
             });
             return {
                 ...task,
+                deliveryPath: taskDeliveryPath(task),
                 ...(names.length === 0 ? {} : { projectNames: names }),
                 workItems: countWorkItems(reader.listWorkItems(task.id)),
                 roleCount: reader.listRoles(task.id).length,
@@ -106,7 +108,11 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
             };
         });
         return {
-            task: projectNames.length === 0 ? task : { ...task, projectNames },
+            task: {
+                ...task,
+                deliveryPath: taskDeliveryPath(task),
+                ...(projectNames.length === 0 ? {} : { projectNames })
+            },
             execution: buildTaskExecutionProjection(reader, taskId),
             brief: reader.getTaskBrief(taskId),
             roles,

package/dist/workItem/workItem.js

@@ -567,6 +567,18 @@ export function currentWorkItemCandidate(workItem) {
         ? workItem.candidates.at(-1)
         : undefined;
 }
+/**
+ * Resolve the one Candidate that still governs Task delivery semantics.
+ * Awaiting Candidates remain under Leader disposition, while completed
+ * Candidates freeze accepted delivery evidence. Failed, retired, pending,
+ * and running WorkItems retain Candidate history only for audit; older
+ * Candidates on the same WorkItem are superseded by its latest Candidate.
+ */
+export function governingWorkItemCandidate(workItem) {
+    return workItem.status === "awaiting_acceptance" || workItem.status === "completed"
+        ? workItem.candidates.at(-1)
+        : undefined;
+}
 export function updateWorkItemWriteProjects(workItem, writeProjectIds, now) {
     validateWorkItem(workItem);
     if (isTerminalStatus(workItem.status)) {

package/dist/workspace/workItemChangeSetManager.js

@@ -4,6 +4,7 @@ import { createChangeSetManifest } from "../integration/changeSetManifest.js";
 import { deriveManifestTags } from "../integration/manifestTags.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
+import { governingWorkItemCandidate } from "../workItem/workItem.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { captureManagedGitChanges } from "./gitChangeSetCapture.js";
 const CAPTURABLE_WORK_ITEM_STATUSES = new Set([
@@ -427,7 +428,7 @@ function latestExactDirectAnchorId(store, taskId, contract) {
         return undefined;
     return store.listWorkItems(taskId)
         .filter((item) => {
-        const candidate = item.candidates.at(-1);
+        const candidate = governingWorkItemCandidate(item);
         return candidate?.source.type === "direct"
             && sameTaskFinalReviewContract(candidate.taskFinalReviewContract, contract);
     })