@zq-silk/yui 0.8.3 → 0.8.7

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 })))
@@ -153,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.
@@ -209,7 +218,21 @@ 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
@@ -252,61 +275,67 @@ function providerContinuationBlocksCompletion(continuation, facts) {
         && 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,5 +1,8 @@
 import { createHash } from "node:crypto";
-import { sameTaskFinalReviewContract, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.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) {
@@ -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");
 }
@@ -578,7 +650,10 @@ function selectOpenWorkItem(workItems) {
     const openItems = workItems.filter((item) => OPEN_WORK_ITEM_STATUSES.has(item.status));
     if (openItems.length === 0)
         return { kind: "none" };
-    const eligible = openItems.find((item) => (item.dependsOn.every((dependencyId) => byId.get(dependencyId)?.status === "completed")));
+    const eligible = openItems.find((item) => (item.dependsOn.every((dependencyId) => {
+        const status = byId.get(dependencyId)?.status;
+        return status === "completed" || status === "retired";
+    })));
     if (eligible !== undefined)
         return { kind: "ready", item: eligible };
     let current = openItems[0];
@@ -588,8 +663,10 @@ function selectOpenWorkItem(workItems) {
             return { kind: "blocked", itemId: current.id, blockedBy: current.id };
         }
         visited.add(current.id);
-        const blockedBy = current.dependsOn
-            .find((dependencyId) => byId.get(dependencyId)?.status !== "completed");
+        const blockedBy = current.dependsOn.find((dependencyId) => {
+            const status = byId.get(dependencyId)?.status;
+            return status !== "completed" && status !== "retired";
+        });
         if (blockedBy === undefined)
             return { kind: "ready", item: current };
         const dependency = byId.get(blockedBy);
@@ -601,15 +678,16 @@ function selectOpenWorkItem(workItems) {
     return { kind: "none" };
 }
 function taskFinalReviewContract(facts) {
-    const contract = facts.workItems
-        .map((item) => governingWorkItemCandidate(item)?.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
@@ -657,7 +735,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)
@@ -675,25 +757,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) => {
-        const candidate = governingWorkItemCandidate(item);
-        return candidate === undefined ? [] : [{ 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/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/task/taskRecordRetirement.js

@@ -0,0 +1,72 @@
+import { createTaskEvent } from "../event/taskEvent.js";
+export const TASK_RECORD_RETIRED_EVENT = "task.record-retired";
+export const RETIRABLE_TASK_RECORD_KINDS = [
+    "work-item",
+    "message",
+    "agent-run"
+];
+/**
+ * Appends a tombstone fact without rewriting the original record. Operational
+ * projections ignore the retired identity; audit and list surfaces can still
+ * render both the original bytes and this reasoned retirement event.
+ */
+export function createTaskRecordRetirement(input, now) {
+    return createTaskEvent(input.eventId, input.taskId, TASK_RECORD_RETIRED_EVENT, {
+        recordKind: requireRecordKind(input.recordKind),
+        recordId: requireText(input.recordId, "Task record id"),
+        reason: requireText(input.reason, "Task record retirement reason"),
+        retiredBy: requireRetiredBy(input.retiredBy)
+    }, now);
+}
+export function taskRecordRetirement(event) {
+    if (event.type !== TASK_RECORD_RETIRED_EVENT)
+        return null;
+    const recordKind = event.payload.recordKind;
+    const retiredBy = event.payload.retiredBy;
+    if (!RETIRABLE_TASK_RECORD_KINDS.includes(recordKind)
+        || (retiredBy !== "user" && retiredBy !== "operator" && retiredBy !== "leader")
+        || event.payload.recordId?.trim().length === 0
+        || event.payload.reason?.trim().length === 0) {
+        return null;
+    }
+    return Object.freeze({
+        recordKind: recordKind,
+        recordId: event.payload.recordId,
+        reason: event.payload.reason,
+        retiredBy
+    });
+}
+export function retiredTaskRecordIds(events, recordKind) {
+    const ids = new Set();
+    for (const event of events) {
+        const retirement = taskRecordRetirement(event);
+        if (retirement?.recordKind === recordKind)
+            ids.add(retirement.recordId);
+    }
+    return ids;
+}
+export function isTaskRecordRetired(events, recordKind, recordId) {
+    return retiredTaskRecordIds(events, recordKind).has(recordId);
+}
+export function operationalTaskRecords(records, events, recordKind) {
+    const retired = retiredTaskRecordIds(events, recordKind);
+    return retired.size === 0 ? [...records] : records.filter(({ id }) => !retired.has(id));
+}
+function requireRecordKind(value) {
+    if (!RETIRABLE_TASK_RECORD_KINDS.includes(value)) {
+        throw new Error(`Task record retirement kind is invalid: ${String(value)}.`);
+    }
+    return value;
+}
+function requireRetiredBy(value) {
+    if (value !== "user" && value !== "operator" && value !== "leader") {
+        throw new Error(`Task record retirement actor is invalid: ${String(value)}.`);
+    }
+    return value;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {
+        throw new Error(`${label} is required.`);
+    }
+    return value.trim();
+}

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

@@ -638,8 +638,8 @@ function normalizeProjectBaseRefs(baseRefs) {
     });
 }
 function normalizeDisposition(input, now) {
-    if (input.by !== "leader") {
-        throw new Error("Only the Task Leader may retire a Work Item.");
+    if (input.by !== "leader" && input.by !== "operator" && input.by !== "user") {
+        throw new Error("Work Item retirement actor is invalid.");
     }
     const summary = requireText(input.summary, "Work item disposition summary");
     const replacementWorkItemId = input.replacementWorkItemId;
@@ -648,7 +648,7 @@ function normalizeDisposition(input, now) {
     }
     const result = {
         schemaVersion: 1,
-        by: "leader",
+        by: input.by,
         summary,
         retiredAt: now.toISOString(),
         ...(replacementWorkItemId === undefined ? {} : { replacementWorkItemId })
@@ -659,7 +659,9 @@ function validateDisposition(disposition) {
     if (disposition.schemaVersion !== 1) {
         throw new Error("Work Item disposition must use schemaVersion 1.");
     }
-    if (disposition.by !== "leader") {
+    if (disposition.by !== "leader"
+        && disposition.by !== "operator"
+        && disposition.by !== "user") {
         throw new Error("Work Item disposition actor is invalid.");
     }
     requireText(disposition.summary, "Work item disposition summary");