@zq-silk/yui 0.14.0 → 0.14.2

package/dist/task/completionReadiness.js

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

package/dist/task/deliveryGuard.js

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

package/dist/task/draftPlan.js

@@ -0,0 +1,142 @@
+export function assertDraftTaskExecutionFree(store, task) {
+    if (task.status !== "draft") {
+        throw new Error(`Task is not a Draft: ${task.id}/${task.status}.`);
+    }
+    const executionFact = firstDraftExecutionFact(store, task);
+    if (executionFact !== undefined) {
+        throw new Error(`Draft Task ${task.id} has execution facts (${executionFact}); `
+            + "retire it and create a clean Draft instead of editing runtime history.");
+    }
+}
+export function validateDraftWorkItemEdit(store, task, candidate) {
+    assertDraftTaskExecutionFree(store, task);
+    const workItems = store.listWorkItems(task.id).map((item) => (item.id === candidate.id ? candidate : item));
+    const facts = draftPlanFacts(store, task, workItems);
+    validateWorkItemReferences(facts, candidate);
+    assertDraftWorkItemDependencyGraph(facts.workItems, candidate);
+}
+export function validateDraftTaskForActivation(store, task) {
+    assertDraftTaskExecutionFree(store, task);
+    const facts = draftPlanFacts(store, task, store.listWorkItems(task.id));
+    const current = facts.workItems.filter(({ status }) => status !== "retired");
+    for (const item of current)
+        validateWorkItemReferences(facts, item);
+    assertDraftWorkItemDependencyGraph(current);
+}
+/** Derive the first invalid edge in the current Draft dependency graph. */
+export function draftWorkItemDependencyIssue(workItems, onlyItem) {
+    const current = workItems.filter(({ status }) => status !== "retired");
+    const byId = new Map(current.map((item) => [item.id, item]));
+    for (const item of onlyItem === undefined ? current : [onlyItem]) {
+        const dependencyId = item.dependsOn.find((id) => !byId.has(id));
+        if (dependencyId !== undefined) {
+            return { kind: "missing-or-retired", workItemId: item.id, dependencyId };
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (item) => {
+        visiting.add(item.id);
+        for (const dependencyId of item.dependsOn) {
+            if (visiting.has(dependencyId)) {
+                return { kind: "cycle", workItemId: item.id, dependencyId };
+            }
+            if (visited.has(dependencyId))
+                continue;
+            const dependency = byId.get(dependencyId);
+            if (dependency === undefined)
+                continue;
+            const issue = visit(dependency);
+            if (issue !== undefined)
+                return issue;
+        }
+        visiting.delete(item.id);
+        visited.add(item.id);
+        return undefined;
+    };
+    for (const item of current) {
+        if (visited.has(item.id))
+            continue;
+        const issue = visit(item);
+        if (issue !== undefined)
+            return issue;
+    }
+    return undefined;
+}
+function draftPlanFacts(store, task, workItems) {
+    const projects = new Map();
+    for (const binding of task.projectBindings) {
+        const project = store.getProject(binding.projectId);
+        if (project === null) {
+            throw new Error(`Task Project not found: ${binding.projectId}.`);
+        }
+        if (project.status !== "active") {
+            throw new Error(`Task Project is not active: ${project.id}/${project.status}.`);
+        }
+        projects.set(project.id, project);
+    }
+    return {
+        task,
+        workItems,
+        roleNames: new Set(store.listRoles(task.id).map(({ name }) => name)),
+        projects
+    };
+}
+function validateWorkItemReferences(facts, item) {
+    if (item.assignee !== undefined && !facts.roleNames.has(item.assignee)) {
+        throw new Error(`Work Item assignee Role not found: ${item.id}/${item.assignee}.`);
+    }
+    for (const projectId of item.writeProjectIds) {
+        if (!facts.projects.has(projectId)) {
+            throw new Error(`Work Item writable Project is not bound: ${item.id}/${projectId}.`);
+        }
+    }
+    for (const baseRef of item.baseRefs ?? []) {
+        if (!item.writeProjectIds.includes(baseRef.projectId)) {
+            throw new Error(`Work Item base-ref Project is not writable: ${item.id}/${baseRef.projectId}.`);
+        }
+    }
+}
+function assertDraftWorkItemDependencyGraph(workItems, onlyItem) {
+    const issue = draftWorkItemDependencyIssue(workItems, onlyItem);
+    if (issue === undefined)
+        return;
+    if (issue.kind === "missing-or-retired") {
+        throw new Error(`Work Item dependency is missing or retired: ${issue.workItemId}/${issue.dependencyId}.`);
+    }
+    throw new Error(`Work Item dependency cycle detected: ${issue.workItemId}/${issue.dependencyId}.`);
+}
+function firstDraftExecutionFact(store, task) {
+    if (task.workspaceIdentity !== undefined || task.cwd !== undefined)
+        return "Task workspace";
+    const hostOwner = store.listSessionOwners().find(({ owner }) => (owner.scope === "task" && owner.taskId === task.id));
+    if (hostOwner !== undefined)
+        return `Host owner (${hostOwner.runtimeGenerationId})`;
+    if (store.listTurns(task.id).length > 0)
+        return "Turn";
+    if (store.listRoleSessionSets(task.id).length > 0)
+        return "Role Session";
+    if (store.listDurableJobs(task.id).length > 0)
+        return "DurableJob";
+    if (store.listManagedWorkspaces(task.id).length > 0)
+        return "managed Workspace";
+    if (store.listReviewRounds(task.id).length > 0)
+        return "ReviewRound";
+    if (store.listIntegrationAttempts(task.id).length > 0)
+        return "Integration Attempt";
+    if (store.listChangeSets(task.id).length > 0)
+        return "ChangeSet";
+    const itemWithExecution = store.listWorkItems(task.id).find((item) => (item.executionGroups.length > 0
+        || item.currentExecutionGroupId !== undefined
+        || item.candidates.length > 0
+        || item.workspaceDisposition !== undefined
+        || !["pending", "retired"].includes(item.status)));
+    if (itemWithExecution !== undefined) {
+        return `Work Item execution (${itemWithExecution.id})`;
+    }
+    const runtimeEvent = store.listEvents(task.id).find(({ type }) => (type.startsWith("runtime.")
+        || type.startsWith("turn.")
+        || type.startsWith("review.")
+        || type.startsWith("integration.")));
+    return runtimeEvent === undefined ? undefined : `event ${runtimeEvent.id}/${runtimeEvent.type}`;
+}