@zq-silk/yui 0.8.3 → 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 })))
@@ -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");
 }
@@ -601,15 +673,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 +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)
@@ -675,25 +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) => {
-        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/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/i18n/README.zh-CN.md

@@ -106,7 +106,8 @@ yui project add app /absolute/workspace/app \
 yui project update app --alias app-cli --development develop
 yui project list
 
-yui task create "交付 CSV 导出" --project app
+yui task create "修复 CSV 转义" --project app --delivery direct
+yui task create "交付 CSV 导出" --project app --delivery integrated
 yui task update <task-id> --priority high --tags release,csv --due-at 2026-08-01T00:00:00Z
 yui task update <task-id> --clear-priority --clear-tags --clear-due-at
 yui task show <task-id>
@@ -114,6 +115,16 @@ yui task context <task-id>
 yui task activate <task-id>
 ```
 
+Project 交付路径显式分为两类，但仍复用现有 Task schema。`direct` 用于
+Project Policy 允许的单一低风险修复：Leader 直接在干净且已提交的 Task main
+实现、验证并完成，不要求 WorkItem、IntegrationAttempt 或由全局策略自动创建的
+final ReviewRound。`integrated` 用于受保护、跨 Project、迁移、授权、并发/恢复、
+破坏性或发布改动，并要求 WorkItem、ChangeSet 与 committed Integration 证据。
+全局 final-review 策略只自动约束 integrated Task。direct Task 可使用有边界的原生
+review；若需要独立托管的 final Review，必须在 Task main 前进前提升为 integrated。
+一旦已有提交或交付证据，提升会 fail closed，避免早期修改失去 ChangeSet provenance。
+旧的 `--require-integration` 等价于 `--delivery integrated`，且 integrated 不可降级。
+
 面向用户的时间默认按北京时间（`Asia/Shanghai`）显示；持久化记录和
 `--json` 数据仍使用 UTC/RFC 3339。可通过以下命令查看或修改 IANA 时区：
 
@@ -150,8 +161,9 @@ AgentRun 不创建新 WorkItem，也不会递归触发审查。审查以自然
 唤醒 Leader；Leader 决定验收、reject 后在原 Role 与原 Session 中修复、
 再次审查，或通过 InputRequest 询问用户。审查失败会保留为可见证据并
 唤醒 Leader，但不会取代 Leader 的最终判断。
-`final` 不为每个 WorkItem 创建完整 ReviewRound；`task complete` 会在每个绑定
-Project 都有 committed Integration 后排队一次 Task 级 Review。冻结的集成头
+`final` 不为每个 WorkItem 创建完整 ReviewRound；integrated Task 的
+`task complete` 会在每个绑定 Project 都有 committed Integration 后排队一次
+Task 级 Review。direct Task 不会因可变的全局 final 配置自动增加 Review。冻结的集成头
 发生变化时才会重新排队，旧报告仍保留为证据。Reviewer 按 Project Policy/Knowledge
 检查整个 Task，并只报告有直接证据的可达、重要、可行动问题或有限验证缺口。
 所有候选、ReviewRound 和 Leader 决策都集中在原 WorkItem 下；reject
@@ -230,6 +242,7 @@ WorkItem workspace 之间移动时，Yui 会退役已停止的旧 Session；下
 ```sh
 yui operator submit "比较 CSV 与 JSON 的兼容性" --task <task-id>
 yui operator submit "研究更小的缓存设计"
+yui operator status
 yui operator list
 yui operator resume
 yui operator resume --last
@@ -254,12 +267,13 @@ Operator 会结合 Project Catalog 和现有 Task context 路由请求。同一
 目标的追加需求、修复、审查和咨询继续进入原 Task，即使它涉及多个 Project。
 目标、所有权边界或生命周期独立时才创建新 Task。需求、Bug 和咨询共用同一
 Task/WorkItem 模型，不增加额外任务类型。
-`operator list` 按固定的最近更新时间倒序展示历史对话，并显示 Agent
+`operator status` 将 GlobalRole 选中的唯一 active writer 与保留的历史对话
+分开展示。`operator list` 按固定的最近更新时间倒序展示历史对话，并显示 Agent
 及可读的标题或摘要；底层 provider session ID 始终保持内部实现细节。
 若 adapter 尚未提供这些元数据，Yui 会显示 provider 和稳定的 Yui
-短引用，确保无标题会话仍可区分。`operator resume` 使用同一个轻量编号列表，
-`--last` 可直接恢复最近一条；
-`operator new` 创建空白对话，并把原对话保留在历史中。
+短引用，确保无标题会话仍可区分。`operator resume` 使用轻量历史编号列表，
+`--last` 可直接恢复最近一条；新建会话不会伪装成 resume 选项，必须显式使用
+`operator new`，并把原对话保留在历史中。
 
 从已配置的全局 Worker 创建 Task Role，应用 Profile 并派发 WorkItem：
 
@@ -430,7 +444,13 @@ yui task complete <task-id> --summary "CSV 导出已交付并验证"
 yui task reopen <task-id>
 ```
 
-completed Task 在显式 reopen 前会拒绝消息、派发、进入 session、重试和迟到的 yield。每个隔离 WorkItem worktree 必须先显式清理，清理时也会删除其受管分支；archive 还必须通过 `--integrated` 或 `--abandon` 明确 Task main 的处理结果，之后才会停止 session 并清理干净的 Task main。Task 与 WorkItem 记录都会保留，Task main 分支作为恢复信息保留，不会被静默删除。
+completed Task 在显式 reopen 前会拒绝消息、派发、进入 session、重试和迟到的
+yield。终态 WorkItem、Review、Integration 与 Lane worktree 会作为非阻塞的
+completion advisory 返回，但必须在 archive 前处理。每个隔离 WorkItem worktree
+仍需显式标记 integrated 或 abandoned，清理时也会删除其受管分支；archive 还必须
+通过 `--integrated` 或 `--abandon` 明确 Task main 的处理结果，之后才会停止
+session 并清理干净的 Task main。Task 与 WorkItem 记录都会保留，Task main 分支
+作为恢复信息保留，不会被静默删除。
 Task 生命周期的交互选择只展示有效来源状态：activate 只展示 Draft，complete 只展示 active，reopen 只展示 completed。
 
 ## Session 与 tmux

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.8.3",
+  "version": "0.8.6",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,