@zq-silk/yui 0.8.9 → 0.9.0

package/dist/commands/taskCompletionGate.js

@@ -2,14 +2,13 @@ import { usageError } from "../errors/cliError.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { taskDeliveryPath } from "../task/task.js";
 import { publicationExternalKey } from "../task/publicationReference.js";
 import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 /**
  * Verify the one supported ancestry waiver before `task complete` mutates any
  * durable state. The explicit Publication must be the current verified merged
- * record, bind the exact physical Task head (and, for integrated delivery, its
+ * record, bind the exact physical Task head (and, when WorkItems exist, its
  * completed final Review), and name an ancestry-divergent commit with the
  * exact same Git tree.
  */
@@ -30,12 +29,14 @@ export async function verifyTaskCompletionPublishedTree(taskId, publicationId, s
         throw usageError(`Publication ${publication.id} must record exact local and remote commits.`);
     }
     const workspace = requireTaskWorkspace(store, task);
-    const integrated = taskDeliveryPath(task) === "integrated";
-    const latestReview = integrated ? latestTaskFinalReview(store, task.id) : undefined;
-    if (integrated && (latestReview === undefined
-        || !isSemanticReviewRound(latestReview, store)
-        || latestReview.taskCandidate === undefined)) {
-        throw usageError(`Task ${task.id} requires a latest completed Task-final Review before accepting a published tree.`);
+    const latestRecordedReview = latestTaskFinalReview(store, task.id);
+    const latestReview = latestRecordedReview !== undefined
+        && isSemanticReviewRound(latestRecordedReview, store)
+        && latestRecordedReview.taskCandidate !== undefined
+        ? latestRecordedReview
+        : undefined;
+    if (latestRecordedReview !== undefined && latestReview === undefined) {
+        throw usageError(`Task ${task.id} has an unsettled Task-final Review obligation before accepting a published tree.`);
     }
     const git = options.git ?? new NodeGitWorkspace();
     const actualHeads = new Map();
@@ -122,7 +123,7 @@ export function assertTaskCompletionPublishedTreeProof(store, task, publicationI
         || publication.remoteCommit !== proof.remoteCommit) {
         throw usageError(`Publication evidence changed before Task completion: ${publication.id}.`);
     }
-    if (taskDeliveryPath(task) === "integrated") {
+    if (proof.reviewRoundId !== undefined) {
         const latestReview = latestTaskFinalReview(store, task.id);
         if (latestReview === undefined
             || latestReview.id !== proof.reviewRoundId
@@ -132,8 +133,8 @@ export function assertTaskCompletionPublishedTreeProof(store, task, publicationI
             throw usageError(`Task-final Review evidence changed before published-tree completion: ${task.id}.`);
         }
     }
-    else if (proof.reviewRoundId !== undefined) {
-        throw usageError(`Direct published-tree proof unexpectedly binds a final Review: ${task.id}.`);
+    else if (latestTaskFinalReview(store, task.id) !== undefined) {
+        throw usageError(`Published-tree proof omitted the Task-final Review: ${task.id}.`);
     }
     const actualCommit = actualCandidate.projects.find(({ projectId }) => (projectId === proof.projectId))?.commit;
     if (actualCommit !== proof.localCommit) {
@@ -183,8 +184,10 @@ export async function reconcileTaskRemoteBaselines(taskId, store, home, options
     // The delivery contract opts Project-backed Tasks into committed
     // Integration evidence.  Metadata-only Tasks retain their existing local
     // completion semantics and have no remote baseline to reconcile here.
-    if (task.projectBindings.length === 0 || task.requireIntegration !== true)
+    if (task.projectBindings.length === 0
+        || !store.listIntegrationAttempts(task.id).some(({ status }) => status === "committed")) {
         return [];
+    }
     const workspace = requireTaskWorkspace(store, task);
     const git = options.git ?? new NodeGitWorkspace();
     if (git.fetchRemoteHeadIntoWorktree === undefined

package/dist/commands/taskContextCommand.js

@@ -4,7 +4,6 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectNextAction } from "../task/nextAction.js";
-import { taskDeliveryPath } from "../task/task.js";
 import { inspectTaskRoleSessionRecovery } from "./taskRoleRuntimeStatus.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
@@ -54,7 +53,6 @@ export function runTaskContextCommand(args, store) {
         }
         return {
             task,
-            deliveryPath: taskDeliveryPath(task),
             execution,
             reviewConfig: reader.getReviewConfig(),
             brief: reader.getTaskBrief(task.id),
@@ -141,12 +139,15 @@ export function runTaskContextCommand(args, store) {
         ...(managedWorkspaces.length === 0
             ? ["  None."]
             : managedWorkspaces.map((workspace) => (`  ${managedWorkspaceLabel(workspace)}: ${workspace.root} (${workspace.entries.filter(({ access }) => access === "write").length} writable / ${workspace.entries.length} Projects)`))),
-        `Delivery: ${taskDeliveryPath(task)}`,
-        `Completion evidence: ${task.requireIntegration
-            ? "WorkItem, ChangeSet, and committed Integration required"
-            : task.projectBindings.length > 0
+        `Type: ${task.type ?? "unspecified"}`,
+        `Execution topology: ${workItems.length === 0
+            ? "Leader-owned Task main"
+            : `${workItems.length} independently owned WorkItem(s), integrated on Task main`}`,
+        `Completion evidence: ${task.projectBindings.length === 0
+            ? "no Project evidence required"
+            : workItems.length === 0
                 ? "clean committed Task main required"
-                : "no Project evidence required"}`,
+                : "each delivered WorkItem requires a ChangeSet and committed Integration"}`,
         `Global review: ${reviewConfig === null
             ? "disabled"
             : `${reviewConfig.roleName} (${reviewConfig.trigger})`}`,
@@ -259,10 +260,13 @@ export function runTaskContextCommand(args, store) {
                                 ? []
                                 : [`      Summary: ${compactText(latestRun.summary)}`])
                         ]),
-                    ...renderWorkItemReviews(reviewRounds.filter((round) => round.workItemId === item.id))
+                    ...renderReviewRounds(reviewRounds.filter((round) => round.workItemId === item.id))
                 ];
             })),
         "",
+        "Task-final reviews:",
+        ...renderReviewRounds(reviewRounds.filter((round) => (round.scope ?? "work-item") === "task")),
+        "",
         ...recentSection("AgentRuns", agentRuns, (run) => [
             `  ${run.id} [${run.status}/${run.purpose}] ${run.roleName} via ${run.effective.agentId}/${run.effective.adapterId}`,
             `    Effective: r${run.effective.sourceDesiredRevision}; Profile intent: ${run.effective.profileAccess}; permission: ${run.effective.permission.strategy}; model: ${run.effective.model ?? "default"}; effort: ${run.effective.effort ?? "default"}`,
@@ -358,16 +362,19 @@ function latestStallKind(events, runId) {
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return event?.payload.kind ?? "workflow-not-progressing";
 }
-function renderWorkItemReviews(rounds) {
+function renderReviewRounds(rounds) {
     const latest = rounds.at(-1);
     if (latest === undefined)
         return ["    ReviewRounds: none."];
+    const target = (latest.scope ?? "work-item") === "task"
+        ? "frozen Task candidate"
+        : `Candidate ${latest.candidateId ?? "unavailable"}`;
     return [
-        `    ReviewRounds: ${rounds.length}; latest ${latest.id} [${latest.status}] ${latest.scope === "task" ? "Task-final" : "WorkItem"} for ${latest.candidateId} via ${latest.reviewerRoleName} (${latest.requestedBy})`,
+        `    ReviewRounds: ${rounds.length}; latest ${latest.id} [${latest.status}] ${latest.scope === "task" ? "Task-final" : "WorkItem"} for ${target} via ${latest.reviewerRoleName} (${latest.requestedBy})`,
         `      Review base: ${latest.reviewBaseCommit}`,
         ...(latest.scope === "task"
             ? [
-                `      Frozen integrated Task heads: ${latest.taskCandidate?.projects
+                `      Frozen Task heads: ${latest.taskCandidate?.projects
                     .map(({ projectId, commit }) => `${projectId}@${commit}`).join(", ") ?? "unavailable"}`,
                 `      Task-final contract: ${latest.taskFinalReviewContract?.digest ?? "global policy"}`,
                 ...(latest.deltaRecheck === undefined

package/dist/commands/taskNextActionCommand.js

@@ -2,7 +2,6 @@ import { taskNotFound, usageError } from "../errors/cliError.js";
 import { projectNextAction } from "../task/nextAction.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
-import { taskDeliveryPath } from "../task/task.js";
 import { projectTaskOrchestration } from "../observability/orchestrationMetrics.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 /**
@@ -75,7 +74,7 @@ export function runTaskNextActionCommand(args, store) {
             managedWorkspaces: reader.listManagedWorkspaces(taskId)
         });
         return {
-            deliveryPath: taskDeliveryPath(facts.task),
+            taskType: facts.task.type ?? null,
             action,
             repairWave,
             completionReadiness,
@@ -92,7 +91,7 @@ export function runTaskNextActionCommand(args, store) {
     }
     return {
         kind: "output",
-        output: renderNextAction(data.action, data.deliveryPath, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.orchestration.advisories),
+        output: renderNextAction(data.action, data.taskType, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.orchestration.advisories),
         data
     };
 }
@@ -110,10 +109,10 @@ function repairWaveFor(action, facts) {
         return null;
     return planRepairWave(round.id, findings);
 }
-function renderNextAction(action, deliveryPath, repairWave, completionReadiness, knowledgeProposals, orchestrationAdvisories) {
+function renderNextAction(action, taskType, repairWave, completionReadiness, knowledgeProposals, orchestrationAdvisories) {
     const lines = [
         `Task: ${action.taskId}`,
-        `Delivery: ${deliveryPath}`,
+        `Type: ${taskType ?? "unspecified"}`,
         `Next action: ${action.kind}`,
         `Reason: ${action.reason}`,
         ...(action.refs.length === 0

package/dist/commands/taskWorkspaceCommands.js

@@ -119,8 +119,8 @@ function replaceTaskCommand(args, store, options) {
         createArgs.push("--project", binding.projectId);
         createArgs.push("--base", `${binding.projectId}=${binding.baseRef}`);
     }
-    if (old.requireIntegration)
-        createArgs.push("--require-integration");
+    if (old.type !== undefined)
+        createArgs.push("--type", old.type);
     const created = runTaskCommand(createArgs, store);
     if (created.kind !== "output") {
         throw new Error(`Task replacement could not be created for ${old.id}.`);

package/dist/execution/executionGroup.js

@@ -435,9 +435,6 @@ export function validateExecutionTarget(target, taskId) {
     if (target.kind === "work-item" && target.workItemId === undefined) {
         throw new Error("WorkItem ExecutionTarget requires a Work Item id.");
     }
-    if (target.kind === "task-final-review" && target.candidateId === undefined) {
-        throw new Error("Task-final ExecutionTarget requires a Candidate id.");
-    }
     if (target.workItemId !== undefined)
         requireIdentity(target.workItemId, "Work Item id");
     if (target.candidateId !== undefined)

package/dist/executor/agentExecutor.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { hasRecentTurnId, rememberRecentTurnId, validatePendingTurnCompletion, validateRecentTurnIds } from "./turnCompletion.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, effectiveLaunchSnapshotsCompatibleForTaskReview, validateEffectiveLaunchSnapshot } from "./effectiveLaunch.js";
 import { rebindProviderRuntimeRun, validateProviderRuntimeBinding } from "../runtime/providerRuntimeIdentity.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function createRoleSessionSet(owner, activeAgentId, now) {
@@ -67,7 +67,9 @@ export function recordRoleAgentSession(set, input, now) {
         throw new Error(`Role Agent session effective identity is inconsistent: ${agentId}.`);
     }
     if (existing !== undefined && existing.nativeSessionId === nativeSessionId
-        && !effectiveLaunchSnapshotsCompatible(existing.effective, effective)) {
+        && !effectiveLaunchSnapshotsCompatible(existing.effective, effective)
+        && !(set.owner.scope === "task"
+            && effectiveLaunchSnapshotsCompatibleForTaskReview(existing.effective, effective))) {
         throw new Error(`Role Agent session effective launch cannot change: ${agentId}.`);
     }
     if (existing !== undefined && existing.nativeSessionId !== nativeSessionId

package/dist/executor/effectiveLaunch.js

@@ -84,7 +84,9 @@ export function effectiveLaunchSnapshotsCompatible(existing, desired) {
  * configuration with which it started. A later Run may resume that exact
  * Session only when the current durable Task workspace proves that every
  * non-commit workspace identity and every other launch field is unchanged.
- * WorkItem, ReviewRound and ExecutionLane workspaces remain strict.
+ * A Task-final Reviewer workspace is also mutable between semantic Rounds: it
+ * keeps one Role-owned physical identity while its frozen commits and Round
+ * identity advance. WorkItem and ExecutionLane workspaces remain strict.
  */
 export function effectiveLaunchSnapshotsCompatibleForTaskMain(existing, desired, workspace) {
     if (effectiveLaunchSnapshotsCompatible(existing, desired))
@@ -94,16 +96,34 @@ export function effectiveLaunchSnapshotsCompatibleForTaskMain(existing, desired,
     if (workspace === null || workspace === undefined)
         return false;
     validateManagedWorkspace(workspace);
-    if (workspace.owner.type !== "task")
-        return false;
     const durableWorkspace = {
         root: workspace.root,
         entries: workspace.entries.map((entry) => ({ ...entry }))
     };
     if (!isDeepStrictEqual(desired.workspace, durableWorkspace))
         return false;
+    if (workspace.owner.type === "review-round") {
+        return effectiveLaunchSnapshotsCompatibleForTaskReview(existing, desired);
+    }
+    if (workspace.owner.type !== "task")
+        return false;
     return isDeepStrictEqual(taskMainCompatibleSnapshot(existing), taskMainCompatibleSnapshot(desired));
 }
+/**
+ * Same Task Reviewer Role, same stable physical workspace and launch policy,
+ * but a new semantic ReviewRound and frozen head. The native Session keeps its
+ * conversation; each AgentRun still records the new exact Round snapshot.
+ */
+export function effectiveLaunchSnapshotsCompatibleForTaskReview(existing, desired) {
+    validateEffectiveLaunchSnapshot(existing);
+    validateEffectiveLaunchSnapshot(desired);
+    if (existing.reviewRoundId === undefined
+        || existing.reviewBaseCommit === undefined
+        || desired.reviewRoundId === undefined
+        || desired.reviewBaseCommit === undefined)
+        return false;
+    return isDeepStrictEqual(taskReviewCompatibleSnapshot(existing), taskReviewCompatibleSnapshot(desired));
+}
 /** Preserves a fixed Session's launch configuration while freezing fresh Task-main Git facts. */
 export function effectiveLaunchWithTaskMainWorkspace(existing, workspace) {
     validateEffectiveLaunchSnapshot(existing);
@@ -129,6 +149,16 @@ function taskMainCompatibleSnapshot(snapshot) {
         }
     };
 }
+function taskReviewCompatibleSnapshot(snapshot) {
+    const { sourceDesiredRevision: _sourceDesiredRevision, reviewRoundId: _reviewRoundId, reviewBaseCommit: _reviewBaseCommit, workspace, ...launch } = snapshot;
+    return {
+        ...launch,
+        workspace: {
+            root: workspace.root,
+            entries: workspace.entries.map(({ baseCommit: _baseCommit, baseRef: _baseRef, ...entry }) => entry)
+        }
+    };
+}
 export function validateEffectiveLaunchSnapshot(snapshot) {
     if (snapshot.schemaVersion !== 2) {
         throw new Error("Effective launch snapshot must use schemaVersion 2.");

package/dist/integration/gitIntegrationService.js

@@ -675,7 +675,7 @@ async function integrationCommitPlan(store, taskId, repositoryPath, changeSetIds
             `${changeSet.baseCommit}..${changeSet.headCommit}`
         ])).trim().split("\n").filter(Boolean);
         for (const commit of commits) {
-            // A direct Task-main recovery may capture commits after they are already
+            // A Task-main recovery may capture commits after they are already
             // present on the exact target. Treat those commits as applied rather
             // than attempting an empty cherry-pick; the later checks and CAS still
             // fence the committed Integration to expectedHead.

package/dist/lifecycle/exactRunTerminalization.js

@@ -83,19 +83,23 @@ export function validateExactRunReviewRound(store, run, options = {}) {
             return { disposition: "obsolete", round, reason: "review-lane-workspace-lineage-mismatch" };
         }
     }
-    const item = store.getWorkItem(run.taskId, round.workItemId);
-    if (item === null) {
+    const task = store.getTask(run.taskId);
+    const taskScope = (round.scope ?? "work-item") === "task";
+    const item = taskScope || round.workItemId === undefined
+        ? null
+        : store.getWorkItem(run.taskId, round.workItemId);
+    if (!taskScope && item === null) {
         return { disposition: "obsolete", round, reason: "review-work-item-missing" };
     }
-    const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-    if (candidate === undefined) {
+    const candidate = taskScope
+        ? undefined
+        : item.candidates.find(({ id }) => id === round.candidateId);
+    if (!taskScope && candidate === undefined) {
         return { disposition: "obsolete", round, reason: "review-candidate-missing" };
     }
-    const task = store.getTask(run.taskId);
-    const taskScope = (round.scope ?? "work-item") === "task";
     const frozenProjects = taskScope
         ? round.taskCandidate?.projects
-        : candidate.gitSnapshot?.projects;
+        : candidate?.gitSnapshot?.projects;
     if (taskScope) {
         if (task === null || round.taskCandidate === undefined) {
             return { disposition: "obsolete", round, reason: "review-task-candidate-missing" };
@@ -107,7 +111,7 @@ export function validateExactRunReviewRound(store, run, options = {}) {
             return { disposition: "obsolete", round, reason: "review-frozen-project-scope-drift" };
         }
     }
-    else if (candidate.gitSnapshot !== undefined
+    else if (candidate?.gitSnapshot !== undefined
         && candidate.gitSnapshot.reviewBaseCommit !== round.reviewBaseCommit) {
         return { disposition: "obsolete", round, reason: "review-candidate-snapshot-drift" };
     }

package/dist/observability/orchestrationMetrics.js

@@ -1,6 +1,5 @@
 import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
 import { projectFirstProgressStopLoss } from "../runtime/firstProgressStopLoss.js";
-import { taskDeliveryPath } from "../task/task.js";
 /** One Task's orchestration cost and advisory projection, with no writes. */
 export function projectTaskOrchestration(facts) {
     const evidence = {
@@ -53,7 +52,7 @@ export function projectTaskOrchestration(facts) {
             .at(-1);
     return Object.freeze({
         taskId: facts.task.id,
-        deliveryPath: taskDeliveryPath(facts.task),
+        taskType: facts.task.type ?? null,
         timeToFirstProjectCommitMs: firstCommitAt === undefined
             ? null
             : Math.max(0, Date.parse(firstCommitAt) - Date.parse(facts.task.createdAt)),
@@ -89,24 +88,11 @@ export function projectTaskOrchestration(facts) {
 }
 function projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, stopLoss) {
     const result = [];
-    if (taskDeliveryPath(facts.task) === "direct"
-        && (facts.workItems.length > 0 || facts.reviewRounds.length > 0 || facts.integrations.length > 0)) {
+    if (facts.task.type === "bugfix" && facts.workItems.length > 0) {
         result.push({
-            code: "direct-protocol-overhead",
-            reason: "Direct delivery accumulated WorkItem, Review, or Integration protocol overhead; keep the fix Leader-direct or explicitly promote it to integrated delivery.",
-            refs: [
-                ...facts.workItems.map(({ id }) => `work-item:${id}`),
-                ...facts.reviewRounds.map(({ id }) => `review-round:${id}`),
-                ...facts.integrations.map(({ id }) => `integration-attempt:${id}`)
-            ]
-        });
-    }
-    const initial = facts.workItems.filter(({ dependsOn }) => dependsOn.length === 0);
-    if (taskDeliveryPath(facts.task) === "integrated" && initial.length > 1) {
-        result.push({
-            code: "guarded-workitem-fanout",
-            reason: `${initial.length} initial WorkItems were created for an integrated Task; start with one bounded fix unless independence is explicit.`,
-            refs: initial.map(({ id }) => `work-item:${id}`)
+            code: "bugfix-workitem-overhead",
+            reason: `Bugfix ${facts.task.id} created ${facts.workItems.length} WorkItem(s); bugfixes are Leader-owned, so reclassify expanding scope as a feature before delegating independent delivery units.`,
+            refs: facts.workItems.map(({ id }) => `work-item:${id}`)
         });
     }
     const repairItems = facts.workItems.filter((item) => (item.acceptance.some((line) => line.startsWith("review-finding:"))));

package/dist/profile/agentProfile.js

@@ -75,7 +75,7 @@ export function builtinAgentProfileInputs() {
         {
             id: "reviewer",
             description: "Review one candidate against the user's core outcome, supported behavior, and direct evidence.",
-            instructions: "Start from user intent and acceptance criteria. Inspect the complete relevant change and report only reachable, material, actionable problems with direct evidence. Separate defects from verification gaps, and prefer the smallest sufficient correction. Follow the bound Project's Policy and Knowledge for build, test, migration, release, and review expectations; do not import rules from another Project or Task. For normal software delivery, review the frozen integrated Task result as one final ReviewRound rather than inventing a per-WorkItem protocol unless the Project Policy explicitly requires one. Do not turn speculative or extreme edge cases into new state, retries, fallbacks, or protocol. In a ReviewRound-owned workspace you may edit source or tests, run local checks, and optionally commit diagnostic evidence. Never push, integrate, mutate Task state, touch another workspace or stable checkout, or write the real Yui control-plane home. Report complete findings, checks actually run, uncertainty, and bounded next actions through the exact Review yield; Yui preserves the full free-form report. Expose evidence and options to the Leader, who decides.",
+            instructions: "Start from user intent and acceptance criteria. Inspect the complete relevant change and report only reachable, material, actionable problems with direct evidence. Separate defects from verification gaps, and prefer the smallest sufficient correction. Follow the bound Project's Policy and Knowledge for build, test, migration, release, and review expectations; do not import rules from another Project or Task. For normal software delivery, review the frozen Task result as one final ReviewRound rather than inventing a per-WorkItem protocol unless the Project Policy explicitly requires one. A Task-final Round has no synthetic WorkItem anchor, and a compatible Reviewer Session may continue across changed-head Rounds without reusing an earlier verdict. Do not turn speculative or extreme edge cases into new state, retries, fallbacks, or protocol. In a ReviewRound-owned workspace you may edit source or tests, run local checks, and optionally commit diagnostic evidence. Never push, integrate, mutate Task state, touch another workspace or stable checkout, or write the real Yui control-plane home. Report complete findings, checks actually run, uncertainty, and bounded next actions through the exact Review yield; Yui preserves the full free-form report. Expose evidence and options to the Leader, who decides.",
             defaultAccess: "write"
         }
     ];

package/dist/repository/taskWorkspaceCoordinator.js

@@ -123,6 +123,8 @@ export class TaskWorkspaceCoordinator {
         if (round.status !== "completed" && round.status !== "failed") {
             throw new Error(`ReviewRound must be terminal before cleanup: ${round.id}.`);
         }
+        if (round.workspaceDisposition?.kind === "reassigned")
+            return "missing";
         // Hold the per-Project maintenance fence so a concurrent migrate/rebuild/
         // archive cannot interleave with worktree removal.
         const workspace = this.store.getReviewRoundWorkspace(taskId, reviewRoundId);