@zq-silk/yui 0.8.9 → 0.9.0

package/dist/storage/taskStore.js

@@ -62,13 +62,13 @@ export const CURRENT_PROJECT_SCHEMA_VERSION = 4;
 export const CURRENT_AGENT_PROFILE_SCHEMA_VERSION = 2;
 export const CURRENT_GLOBAL_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 3;
-export const CURRENT_TASK_SCHEMA_VERSION = 4;
+export const CURRENT_TASK_SCHEMA_VERSION = 5;
 export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
 export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION = 2;
 export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 9;
-export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 4;
+export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 5;
 export const CURRENT_CHANGE_SET_SCHEMA_VERSION = 3;
 export const CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION = 4;
 export const CURRENT_MESSAGE_SCHEMA_VERSION = 3;
@@ -417,7 +417,7 @@ export class FileTaskStore {
                 id: aggregate.task.id,
                 status: aggregate.task.status,
                 projectBindings: aggregate.task.projectBindings,
-                requireIntegration: aggregate.task.requireIntegration
+                type: aggregate.task.type
             },
             workItems: values(aggregate.workItems, "id"),
             changeSets: values(aggregate.changeSets, "id"),
@@ -1026,18 +1026,16 @@ export class FileTaskStore {
             throw new StorageRecordError(`ReviewRound belongs to another Task: ${stored.taskId}.`);
         }
         const aggregate = this.#requireTaskForWrite(taskId);
-        const item = aggregate.workItems[stored.workItemId];
-        if (item === undefined) {
-            throw new StorageRecordError(`ReviewRound Work Item not found: ${stored.workItemId}.`);
-        }
-        const candidate = item.candidates.find(({ id }) => id === stored.candidateId);
-        if (candidate === undefined) {
-            throw new StorageRecordError(`ReviewRound Candidate not found: ${stored.candidateId}.`);
-        }
-        assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${stored.id}`);
-        if ((stored.scope ?? "work-item") === "task"
-            && !sameTaskFinalReviewContract(stored.taskFinalReviewContract, candidate.taskFinalReviewContract)) {
-            throw new StorageRecordError(`Task ReviewRound contract does not match its Candidate: ${stored.id}.`);
+        if ((stored.scope ?? "work-item") === "work-item") {
+            const item = aggregate.workItems[stored.workItemId];
+            if (item === undefined) {
+                throw new StorageRecordError(`ReviewRound Work Item not found: ${stored.workItemId}.`);
+            }
+            const candidate = item.candidates.find(({ id }) => id === stored.candidateId);
+            if (candidate === undefined) {
+                throw new StorageRecordError(`ReviewRound Candidate not found: ${stored.candidateId}.`);
+            }
+            assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${stored.id}`);
         }
         if (stored.reviewerRunId !== undefined) {
             const reviewerRun = aggregate.agentRuns[stored.reviewerRunId];
@@ -3349,24 +3347,23 @@ function validateCanonicalTaskReferences(state, aggregate) {
         }
     }
     for (const round of Object.values(aggregate.reviewRounds)) {
-        const item = aggregate.workItems[round.workItemId];
-        if (item === undefined) {
-            throw new StorageRecordError(`ReviewRound references are invalid: ${round.id}.`);
-        }
-        const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-        if (candidate === undefined) {
-            throw new StorageRecordError(`ReviewRound Candidate not found: ${round.candidateId}.`);
-        }
-        assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${round.id}`);
         if ((round.scope ?? "work-item") === "task") {
             const frozenProjects = round.taskCandidate?.projects ?? [];
             if (frozenProjects.length !== boundProjects.size
                 || frozenProjects.some(({ projectId }) => !boundProjects.has(projectId))) {
                 throw new StorageRecordError(`Task ReviewRound Projects do not match Task scope: ${round.id}.`);
             }
-            if (!sameTaskFinalReviewContract(round.taskFinalReviewContract, candidate.taskFinalReviewContract)) {
-                throw new StorageRecordError(`Task ReviewRound contract does not match its Candidate: ${round.id}.`);
+        }
+        else {
+            const item = aggregate.workItems[round.workItemId];
+            if (item === undefined) {
+                throw new StorageRecordError(`ReviewRound references are invalid: ${round.id}.`);
+            }
+            const candidate = item.candidates.find(({ id }) => id === round.candidateId);
+            if (candidate === undefined) {
+                throw new StorageRecordError(`ReviewRound Candidate not found: ${round.candidateId}.`);
             }
+            assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${round.id}`);
         }
         if (round.reviewerRunId !== undefined) {
             const reviewerRun = aggregate.agentRuns[round.reviewerRunId];
@@ -3496,7 +3493,9 @@ function assertManagedWorkspaceReferences(aggregate, workspace, label, workItemO
             if (workspace.entries.some(({ access }) => access !== "write")) {
                 throw new StorageRecordError(`${label} ReviewRound workspace must be writable: ${taskId}/${round.id}.`);
             }
-            const item = aggregate.workItems[round.workItemId];
+            const item = round.workItemId === undefined
+                ? undefined
+                : aggregate.workItems[round.workItemId];
             const candidate = item?.candidates.find(({ id }) => id === round.candidateId);
             const frozenProjects = round.scope === "task"
                 ? round.taskCandidate?.projects

package/dist/task/completionReadiness.js

@@ -97,33 +97,35 @@ export function projectCompletionReadiness(facts, options = {}) {
             fix: `wait for DurableJob ${job.id} to finish, or cancel it`
         });
     }
-    // requireIntegration Tasks need the full evidence chain.
-    if (task.requireIntegration === true) {
-        if (facts.workItems.length === 0) {
-            blockers.push({
-                code: "integration-evidence-missing",
-                ref: ref("task", task.id),
-                reason: `Task ${task.id} requires at least one WorkItem before completion.`,
-                fix: `yui task work create ${task.id} "<objective>"`
-            });
-        }
-        if (facts.changeSets.length === 0) {
-            blockers.push({
-                code: "integration-evidence-missing",
-                ref: ref("task", task.id),
-                reason: `Task ${task.id} requires at least one ChangeSet before completion.`,
-                fix: `yui task work capture ${task.id}/<work-item>`
-            });
-        }
-        if (!facts.integrations.some(({ status }) => status === "committed")) {
+    // Integration obligations are derived from real independent delivery units.
+    // A Leader-owned Task needs no synthetic WorkItem; once a WorkItem produces a
+    // Git Candidate, that exact unit must be captured and integrated.
+    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
+            && !facts.changeSets.some((changeSet) => changeSet.workItemId === item.id)) {
             blockers.push({
                 code: "integration-evidence-missing",
-                ref: ref("task", task.id),
-                reason: `Task ${task.id} requires a committed Integration Attempt before completion.`,
-                fix: `yui task integration start ${task.id} --project <project> --change-set <change-set>`
+                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 facts.changeSets) {
+        if (facts.integrations.some((attempt) => (attempt.status === "committed" && attempt.changeSetIds.includes(changeSet.id))))
+            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}`
+        });
+    }
     // Unresolved Integration Attempts must settle.
     for (const integration of facts.integrations) {
         if (!UNRESOLVED_INTEGRATION_STATUSES.has(integration.status))

package/dist/task/nextAction.js

@@ -2,7 +2,6 @@ import { createHash } from "node:crypto";
 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) {
@@ -70,7 +69,7 @@ export function projectNextAction(facts) {
             const candidateRef = ref("candidate", `${candidateReady.id}/${candidate.id}`);
             return buildAction(facts, {
                 kind: "repair-protocol-inconsistency",
-                reason: `Candidate ${candidate.id} is a direct Task-main delivery with base==head (no commits); reject it and re-dispatch real work.`,
+                reason: `Candidate ${candidate.id} is a Task-main delivery with base==head (no commits); reject it and re-dispatch real work.`,
                 refs: [ref("work-item", candidateReady.id), candidateRef],
                 conflicts: [candidateRef],
                 preconditions: [
@@ -254,42 +253,35 @@ export function projectNextAction(facts) {
             judgmentRequired: "Leader must choose the execution path: direct execution, a native subagent, or managed Task Role dispatch."
         });
     }
-    if (facts.workItems.length === 0) {
-        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>\"`
-            });
-        }
+    if (facts.workItems.length === 0 && !taskFinalReviewRequired(facts)) {
+        const reviewAlternative = facts.reviewConfig === null
+            ? []
+            : [{
+                    kind: "request-final-review",
+                    reason: "Request one independent Review of the frozen Task result when risk warrants it.",
+                    recommendedCommand: `yui task review request ${task.id} --role ${facts.reviewConfig.roleName}`,
+                    refs: [ref("task", task.id)]
+                }];
+        return buildAction(facts, {
+            kind: "complete-task",
+            reason: task.type === "bugfix"
+                ? `Task ${task.id} is a Leader-owned bugfix; implement and verify it on Task main without manufacturing a WorkItem.`
+                : task.type === "feature"
+                    ? `Feature ${task.id} has no independent delivery units; the Leader may implement it on Task main or create WorkItems only if separate ownership is genuinely useful.`
+                    : `Task ${task.id} has no independent delivery units; the Leader decides whether to own it on Task main or create WorkItems only if separate ownership is genuinely useful.`,
+            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 -`,
+            ...(reviewAlternative.length === 0 ? {} : { alternatives: reviewAlternative }),
+            judgmentRequired: task.type === "bugfix"
+                ? "Leader must judge whether the bugfix risk warrants one optional final Review."
+                : task.type === "feature"
+                    ? "Leader must judge whether this feature is small enough to own directly or needs independently owned WorkItems, and whether the final result warrants Review."
+                    : "Leader must choose the smallest useful topology from the Project-defined Task intent, then decide whether the frozen result warrants Review."
+        });
     }
     const uncaptured = facts.workItems.find((item) => needsChangeSetCapture(facts, item));
     if (uncaptured !== undefined) {
@@ -428,28 +420,25 @@ 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: 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.",
+            reason: facts.workItems.length === 0
+                ? "This Task already owns a final-Review obligation; completion must prepare or resume a Review of its frozen Task head."
+                : "All WorkItems are integrated but no valid Task-final Review attests the frozen Task result.",
             refs: [ref("task", task.id)],
-            preconditions: directWithoutWorkItems
+            preconditions: facts.workItems.length === 0
                 ? [{ 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
+            recommendedCommand: facts.workItems.length === 0
                 ? `yui task complete ${task.id} --summary-file -`
                 : `yui task review request ${task.id} --role ${reviewerRole ?? "<reviewer-role>"}`
         });
     }
-    const finalReviewOptional = taskDeliveryPath(task) === "integrated"
-        && !finalReviewRequired
+    const finalReviewOptional = !finalReviewRequired
         && !hasValidFinalReview(facts);
     const finalReviewAlternative = finalReviewOptional && facts.reviewConfig !== null
         ? [{
@@ -461,19 +450,16 @@ export function projectNextAction(facts) {
         : [];
     return buildAction(facts, {
         kind: "complete-task",
-        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.",
+        reason: facts.workItems.length === 0
+            ? "The Leader-owned Task result and its established obligations are ready; complete it without creating successor work."
+            : "Every independent delivery unit is integrated; complete 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
                 ? []
-                : taskDeliveryPath(task) === "direct"
-                    ? [{
-                            fact: "Valid established Task-final Review at the direct head",
-                            satisfied: hasValidFinalReview(facts)
-                        }]
+                : facts.workItems.length === 0
+                    ? [{ fact: "Task main is clean, committed, and verified", satisfied: false }]
                     : [
                         { fact: "Every ChangeSet is committed", satisfied: true },
                         {
@@ -486,7 +472,7 @@ export function projectNextAction(facts) {
         ...(!finalReviewOptional
             ? {}
             : {
-                judgmentRequired: "Leader must decide whether the integrated delivery is safe to complete directly or needs an optional Task-final Review."
+                judgmentRequired: "Leader must decide whether the frozen Task result is safe to complete or needs one optional Task-final Review."
             }),
         recommendedCommand: `yui task complete ${task.id} --summary-file -`
     });
@@ -685,9 +671,7 @@ function taskFinalReviewContractResolution(facts) {
 }
 function taskFinalReviewRequired(facts) {
     return taskFinalReviewContract(facts) !== undefined
-        || latestTaskFinalReview(facts.reviewRounds) !== undefined
-        || (taskDeliveryPath(facts.task) === "integrated"
-            && facts.reviewConfig?.trigger === "final");
+        || latestTaskFinalReview(facts.reviewRounds) !== undefined;
 }
 function taskFinalReviewRole(facts) {
     return taskFinalReviewContract(facts)?.reviewerRoleName
@@ -724,7 +708,7 @@ function needsChangeSetCapture(facts, item) {
     const candidate = item.candidates.at(-1);
     if (candidate === undefined)
         return false;
-    // A metadata-only direct Task-main Candidate has no WorkItem Develop
+    // A metadata-only Task-main Candidate has no WorkItem Develop
     // workspace to capture; its boundary is the Task-main head itself.
     if (candidate.workspace === undefined
         && candidate.gitSnapshot === undefined
@@ -750,7 +734,7 @@ function hasValidFinalReview(facts) {
         .filter((changeSet) => attempt.changeSetIds.includes(changeSet.id))
         .map((changeSet) => changeSet.headCommit)));
     if (integratedHeads.size === 0)
-        return false;
+        return facts.workItems.length === 0;
     for (const head of integratedHeads) {
         if (!reviewedCommits.has(head))
             return false;
@@ -816,6 +800,8 @@ function detectProtocolInconsistency(facts) {
     for (const round of facts.reviewRounds) {
         if (round.status !== "pending" && round.status !== "running")
             continue;
+        if (round.workItemId === undefined)
+            continue;
         const item = workItemById.get(round.workItemId);
         if (item !== undefined && item.status === "retired") {
             return {

package/dist/task/task.js

@@ -2,7 +2,7 @@ import { validateTaskWorkspaceIdentity } from "../repository/taskWorkspaceIdenti
 export function createTask(id, title, now, metadata = {}) {
     const timestamp = now.toISOString();
     return {
-        schemaVersion: 4,
+        schemaVersion: 5,
         id: requireSafeIdentity(id, "Task id"),
         title: requireText(title, "Task title"),
         ...cloneMetadata(metadata),
@@ -141,6 +141,7 @@ export function updateTaskMetadata(task, metadata, now) {
     const updated = { ...task, updatedAt: now.toISOString() };
     if (metadata.title !== undefined)
         updated.title = requireText(metadata.title, "Task title");
+    applyOptional(updated, "type", metadata.type);
     applyOptional(updated, "description", metadata.description);
     applyOptional(updated, "priority", metadata.priority);
     applyOptional(updated, "tags", metadata.tags === undefined || metadata.tags === null
@@ -152,8 +153,6 @@ export function updateTaskMetadata(task, metadata, now) {
     }
     if (metadata.cwd !== undefined)
         updated.cwd = requireText(metadata.cwd, "Task workspace");
-    if (metadata.requireIntegration === true)
-        updated.requireIntegration = true;
     return updated;
 }
 function applyOptional(task, key, value) {
@@ -171,10 +170,12 @@ export function isTaskArchived(task) {
     return task.status === "archived";
 }
 export function validateTask(task) {
-    if (task.schemaVersion !== 4)
-        throw new Error("Task must use schemaVersion 4.");
+    if (task.schemaVersion !== 5)
+        throw new Error("Task must use schemaVersion 5.");
     requireSafeIdentity(task.id, "Task id");
     requireText(task.title, "Task title");
+    if (task.type !== undefined)
+        requireSafeIdentity(task.type, "Task type");
     if (!["draft", "active", "completed", "retired", "archived"].includes(task.status)) {
         throw new Error(`Task status is invalid: ${String(task.status)}.`);
     }
@@ -206,8 +207,10 @@ export function validateTask(task) {
     normalizeProjectBindings(task.projectBindings);
     if (task.cwd !== undefined)
         requireText(task.cwd, "Task workspace");
-    if (task.requireIntegration !== undefined && task.requireIntegration !== true) {
-        throw new Error("Task requireIntegration must be true when present.");
+    if (task.legacyDeliveryPath !== undefined
+        && task.legacyDeliveryPath !== "direct"
+        && task.legacyDeliveryPath !== "integrated") {
+        throw new Error("Task legacy delivery path is invalid.");
     }
     const completionFields = [task.completedAt, task.completedBy, task.completionSummary];
     const hasAnyCompletion = completionFields.some((value) => value !== undefined);
@@ -283,13 +286,13 @@ export function validateTask(task) {
 }
 function cloneMetadata(metadata) {
     const cloned = {
+        ...(metadata.type === undefined ? {} : { type: requireSafeIdentity(metadata.type, "Task type") }),
         ...(metadata.description === undefined ? {} : { description: metadata.description }),
         ...(metadata.priority === undefined ? {} : { priority: metadata.priority }),
         ...(metadata.tags === undefined ? {} : { tags: [...metadata.tags] }),
         ...(metadata.dueAt === undefined ? {} : { dueAt: metadata.dueAt }),
         projectBindings: normalizeProjectBindings(metadata.projectBindings ?? []),
-        ...(metadata.cwd === undefined ? {} : { cwd: requireText(metadata.cwd, "Task workspace") }),
-        ...(metadata.requireIntegration === true ? { requireIntegration: true } : {})
+        ...(metadata.cwd === undefined ? {} : { cwd: requireText(metadata.cwd, "Task workspace") })
     };
     return cloned;
 }
@@ -319,16 +322,6 @@ 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/assets/client/components.js

@@ -577,7 +577,9 @@ export function reviewCard(round, t, locale) {
   card.append(head);
   const meta = node("div", "record-meta");
   meta.append(node("span", "meta-name", round.reviewerRoleName));
-  meta.append(node("span", "mono", round.workItemId + " · " + round.candidateId));
+  if (round.workItemId && round.candidateId) {
+    meta.append(node("span", "mono", round.workItemId + " · " + round.candidateId));
+  }
   if (round.createdAt) meta.append(node("time", "", formatDateTime(round.createdAt, locale)));
   meta.append(node("span", "", t("detail.reviewBase") + " · " + round.reviewBaseCommit));
   if (round.workspace && round.workspace.root) {

package/dist/web/assets/client/i18n.js

@@ -106,6 +106,9 @@ const messages = {
     "detail.writeProjects": "Writable Projects",
     "disposition.abandoned": "Abandoned",
     "disposition.integrated": "Integrated",
+    "disposition.preserved": "Preserved",
+    "disposition.reassigned": "Continued by a newer review",
+    "disposition.removed": "Removed",
     "empty.brief": "No task brief has been recorded.",
     "empty.none": "No items",
     "empty.runs": "No runs yet.",
@@ -406,6 +409,9 @@ const messages = {
     "detail.writeProjects": "可写项目",
     "disposition.abandoned": "已废弃",
     "disposition.integrated": "已集成",
+    "disposition.preserved": "已保留",
+    "disposition.reassigned": "已由后续评审继续使用",
+    "disposition.removed": "已移除",
     "empty.brief": "尚未记录任务简报。",
     "empty.none": "暂无条目",
     "empty.runs": "暂无运行记录。",

package/dist/web/webSnapshot.js

@@ -1,4 +1,3 @@
-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";
@@ -41,7 +40,6 @@ 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,
@@ -110,7 +108,6 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
         return {
             task: {
                 ...task,
-                deliveryPath: taskDeliveryPath(task),
                 ...(projectNames.length === 0 ? {} : { projectNames })
             },
             execution: buildTaskExecutionProjection(reader, taskId),

package/i18n/README.zh-CN.md

@@ -106,8 +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 --delivery direct
-yui task create "交付 CSV 导出" --project app --delivery integrated
+yui task create "修复 CSV 转义" --project app --type bugfix
+yui task create "交付 CSV 导出" --project app --type feature
 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>
@@ -115,15 +115,13 @@ 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 不可降级。
+Task type 描述需求意图，不选择执行协议。软件 Project 通常使用 `bugfix` 或
+`feature`：bugfix 由 Leader 在 Task main 独立、快速完成；如果范围扩大到需要
+独立 owner，应先改为 feature 再创建 WorkItem。feature 由 Leader 判断是自己直接
+交付，还是拆成由不同 Worker 独立负责、可并行推进的较大
+WorkItem。实现步骤、测试、review finding 和局部修复都不是 WorkItem。只有当一项
+需求本身具有独立 owner 和可验收结果时才创建 WorkItem；一旦 WorkItem 产生 Git
+结果，就必须通过 ChangeSet 和 committed Integration 汇总回 Leader 的 Task main。
 
 面向用户的时间默认按北京时间（`Asia/Shanghai`）显示；持久化记录和
 `--json` 数据仍使用 UTC/RFC 3339。可通过以下命令查看或修改 IANA 时区：
@@ -142,9 +140,8 @@ yui config show
 yui config workflow clear review
 ```
 
-对带 Project 的软件交付，可使用 `--trigger final`：WorkItem 验收与
-Integration 保持独立，在 Task 完成前只对所有已集成 Project 的冻结候选做
-一次 Task 级 ReviewRound：
+对带 Project 的软件交付，可使用 `--trigger final` 提供默认 Reviewer Role；
+是否需要独立的 Task-final Review 仍由 Leader 根据风险判断：
 
 ```sh
 yui config workflow set review --role reviewer --trigger final
@@ -161,11 +158,13 @@ AgentRun 不创建新 WorkItem，也不会递归触发审查。审查以自然
 唤醒 Leader；Leader 决定验收、reject 后在原 Role 与原 Session 中修复、
 再次审查，或通过 InputRequest 询问用户。审查失败会保留为可见证据并
 唤醒 Leader，但不会取代 Leader 的最终判断。
-`final` 不为每个 WorkItem 创建完整 ReviewRound；integrated Task 的
-`task complete` 会在每个绑定 Project 都有 committed Integration 后排队一次
-Task 级 Review。direct Task 不会因可变的全局 final 配置自动增加 Review。冻结的集成头
-发生变化时才会重新排队，旧报告仍保留为证据。Reviewer 按 Project Policy/Knowledge
-检查整个 Task，并只报告有直接证据的可达、重要、可行动问题或有限验证缺口。
+`final` 不为每个 WorkItem 创建完整 ReviewRound，也不决定 Task 拓扑。Leader
+显式请求 Task 级 Review；不可变 Task contract 也可以强制要求。Task-final Round
+直接冻结 Task main，不需要虚构 WorkItem/Candidate，因此没有 WorkItem 的小任务也能
+review。冻结头变化时创建新的语义 Round；同一 Reviewer 的兼容原生 Session 可以在
+稳定 workspace 中继续，而每个 Run 仍严格绑定自己的 Round 和冻结头。旧报告保留为
+证据。Reviewer 按 Project Policy/Knowledge 检查整个 Task，并只报告有直接证据的
+可达、重要、可行动问题或有限验证缺口。
 所有候选、ReviewRound 和 Leader 决策都集中在原 WorkItem 下；reject
 后的下一轮会复用原执行 Role、Session 与 workspace，并追加新候选。
 

package/package.json

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