@zq-silk/yui 0.8.9 → 0.10.0

package/dist/executor/codexConfigConflict.js

@@ -4,15 +4,14 @@ import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { parse } from "smol-toml";
 /**
- * Inspects the local, file-backed Codex configuration layers supported by Yui
- * that can conflict with launch-owned settings. Remote and platform-managed
- * layers are outside this compatibility boundary. Project files are considered
- * only when the directory, project root, or project root is trusted.
+ * Reports the local, file-backed Codex configuration layers supported by Yui.
+ * Yui's invocation-local launch settings take precedence over ordinary local
+ * layers without mutating those files. Higher-precedence managed policy is
+ * reported separately because an invocation cannot override it. Remote
+ * managed layers remain outside this reporting boundary. Project files are
+ * considered only when the directory, project root, or repository root is
+ * trusted.
  */
-export function inspectCodexDeveloperInstructions(input) {
-    return inspectCodexConfigKeys(input, ["developer_instructions"])
-        .developerInstructions;
-}
 export function inspectCodexLaunchConfig(input) {
     return inspectCodexConfigKeys(input, ["developer_instructions", "notify"]);
 }
@@ -49,12 +48,17 @@ function inspectCodexConfigKeys(input, keys) {
         ? withExactWorkspaceTrust(discovery, input.workspace)
         : discovery);
     const candidates = [
-        ...discoveryPaths.map((path) => ({ path, keys })),
+        ...discoveryPaths.map((path) => ({
+            path,
+            keys,
+            precedence: "session-overridable"
+        })),
         ...projectPaths.map((path) => ({
             path,
-            keys: keys.filter((key) => key === "developer_instructions")
+            keys: keys.filter((key) => key === "developer_instructions"),
+            precedence: "session-overridable"
         })),
-        { path: managedPath, keys }
+        { path: managedPath, keys, precedence: "managed" }
     ];
     let developerInstructions = { status: "absent" };
     let notify = { status: "absent" };
@@ -71,16 +75,36 @@ function inspectCodexConfigKeys(input, keys) {
         catch (error) {
             throw unreliableInspection(candidate.path, error);
         }
-        if (developerInstructions.status === "absent"
-            && configured.has("developer_instructions")) {
-            developerInstructions = { status: "configured", source: candidate.path };
+        if (configured.has("developer_instructions")) {
+            developerInstructions = {
+                status: "configured",
+                source: candidate.path,
+                precedence: candidate.precedence
+            };
         }
-        if (notify.status === "absent" && configured.has("notify")) {
-            notify = { status: "configured", source: candidate.path };
+        if (configured.has("notify")) {
+            notify = {
+                status: "configured",
+                source: candidate.path,
+                precedence: candidate.precedence
+            };
         }
     }
     return { developerInstructions, notify };
 }
+export function assertCodexLaunchOverridesAvailable(inspection, keys) {
+    for (const key of keys) {
+        const configured = inspection[key];
+        if (configured.status !== "configured" || configured.precedence !== "managed") {
+            continue;
+        }
+        const nativeKey = key === "developerInstructions"
+            ? "developer_instructions"
+            : "notify";
+        throw new Error(`Codex ${nativeKey} is controlled by higher-precedence managed configuration at `
+            + `${configured.source}; Yui cannot apply its invocation-local ${nativeKey} value.`);
+    }
+}
 function withExactWorkspaceTrust(discovery, workspace) {
     return {
         ...discovery,

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/executor/fileRoleLaunchPlanner.js

@@ -13,7 +13,6 @@ import { serializeRunBootstrapEnvelope, serializeRunHostRecoveryEnvelope } from
 import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
 import { prefixYuiTitleInput } from "../run/runIdentity.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
@@ -26,6 +25,7 @@ import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { builtinAgentDriverRegistry, builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { managedRuntimeAdmission } from "../runtime/agentDriver.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { assertCodexLaunchOverridesAvailable, inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 /** Builds managed native Agent launches from the authoritative Task records. */
 export class FileRoleLaunchPlanner {
     home;
@@ -274,6 +274,19 @@ export class FileRoleLaunchPlanner {
         const adapter = resolveAgentAdapter(binding.adapterId);
         const effectiveWorkspace = effective.workspace.root;
         const agentWorkspace = nativeAgentWorkspace(effective.workspace);
+        if (adapter.id === "codex") {
+            const codexConfig = inspectCodexLaunchConfig({
+                environment: launchEnvironment,
+                workspace: agentWorkspace,
+                profile: binding.config.adapterId === "codex"
+                    ? binding.config.profile
+                    : undefined,
+                trustWorkspace: true
+            });
+            assertCodexLaunchOverridesAvailable(codexConfig, owner.scope !== "task" || input.runId === undefined
+                ? ["developerInstructions", "notify"]
+                : ["developerInstructions"]);
+        }
         const runtimeIsolation = input.runtimeIsolation === undefined
             ? undefined
             : parseTaskRuntimeIsolationDescriptor(JSON.stringify(input.runtimeIsolation));
@@ -309,25 +322,6 @@ export class FileRoleLaunchPlanner {
             sessionManifestDigest: bootstrap.manifest.digest,
             sessionCliPath: bootstrap.sessionCliPath
         };
-        const codexConfig = binding.config.adapterId === "codex"
-            ? inspectCodexLaunchConfig({
-                environment: {
-                    ...operationalSourceEnvironment,
-                    ...agentSourceEnvironment,
-                    ...launchEnvironment
-                },
-                workspace: agentWorkspace,
-                profile: binding.config.profile,
-                trustWorkspace: true
-            })
-            : undefined;
-        if (codexConfig?.notify.status === "configured"
-            && (owner.scope !== "task" || input.runId === undefined)) {
-            throw new Error("Codex notify is already configured by "
-                + `${codexConfig.notify.source}; this interactive Yui Session requires exclusive `
-                + "ownership of the structured notify callback and refuses to replace or be replaced "
-                + "by native configuration.");
-        }
         const managedRun = owner.scope === "task" && input.runId !== undefined
             ? this.store.getAgentRun(owner.taskId, input.runId)
             : null;
@@ -353,10 +347,7 @@ export class FileRoleLaunchPlanner {
             config: effectiveConfig,
             workspace: agentWorkspace,
             ...(sessionTitle === undefined ? {} : { sessionTitle }),
-            ...sessionContext,
-            ...(codexConfig === undefined
-                ? {}
-                : { codexDeveloperInstructions: codexConfig.developerInstructions })
+            ...sessionContext
         };
         if (input.mode === "resume"
             && knownNativeSessionId !== undefined

package/dist/integration/deliveryObligation.js

@@ -0,0 +1,72 @@
+import { governingWorkItemCandidate } from "../workItem/workItem.js";
+/**
+ * Delivery obligations follow the Candidate that currently governs each
+ * WorkItem. Older Candidates and their ChangeSets remain audit evidence, but
+ * they do not keep a Task open after a replacement Candidate is accepted.
+ */
+export function governingChangeSets(workItems, changeSets) {
+    const selected = new Map();
+    for (const item of workItems) {
+        const candidate = governingWorkItemCandidate(item);
+        if (candidate === undefined)
+            continue;
+        for (const changeSet of changeSets) {
+            if (changeSet.workItemId !== item.id)
+                continue;
+            const expectedHead = candidateProjectHead(candidate, changeSet.projectId);
+            if (expectedHead !== undefined && changeSet.headCommit !== expectedHead)
+                continue;
+            const key = `${item.id}\0${changeSet.projectId}`;
+            const current = selected.get(key);
+            if (current === undefined || compareChangeSets(current, changeSet) < 0) {
+                selected.set(key, changeSet);
+            }
+        }
+    }
+    return [...selected.values()].sort(compareChangeSets);
+}
+export function changeSetDeliverySettled(changeSet, integrations, queueEntries = []) {
+    if (integrations.some((attempt) => (attempt.status === "committed" && attempt.changeSetIds.includes(changeSet.id))))
+        return true;
+    const latestQueueEntry = queueEntries
+        .filter((entry) => entry.changeSetId === changeSet.id)
+        .sort(compareQueueEntries)
+        .at(-1);
+    return latestQueueEntry?.status === "superseded";
+}
+export function latestGoverningQueueEntries(changeSets, queueEntries) {
+    const governingIds = new Set(changeSets.map(({ id }) => id));
+    const latest = new Map();
+    for (const entry of queueEntries) {
+        if (!governingIds.has(entry.changeSetId))
+            continue;
+        const current = latest.get(entry.changeSetId);
+        if (current === undefined || compareQueueEntries(current, entry) < 0) {
+            latest.set(entry.changeSetId, entry);
+        }
+    }
+    return [...latest.values()].sort(compareQueueEntries);
+}
+/**
+ * Historical blocked attempts are audit evidence once every ChangeSet they
+ * reference has been replaced by a newer governing Candidate. Attempts that
+ * may still be writing remain blockers regardless of Candidate history.
+ */
+export function integrationAttemptRequiresSettlement(attempt, changeSets) {
+    if (attempt.status === "running" || attempt.status === "validating")
+        return true;
+    const governingIds = new Set(changeSets.map(({ id }) => id));
+    return attempt.changeSetIds.some((id) => governingIds.has(id));
+}
+function candidateProjectHead(candidate, projectId) {
+    return candidate.gitSnapshot?.projects.find((project) => project.projectId === projectId)?.commit
+        ?? candidate.taskMainSnapshot?.projects.find((project) => project.projectId === projectId)?.headCommit;
+}
+function compareChangeSets(left, right) {
+    return left.createdAt.localeCompare(right.createdAt)
+        || left.id.localeCompare(right.id, undefined, { numeric: true });
+}
+function compareQueueEntries(left, right) {
+    return left.updatedAt.localeCompare(right.updatedAt)
+        || left.id.localeCompare(right.id, undefined, { numeric: true });
+}

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";
+import { projectFirstProgressAdvisory } from "../runtime/firstProgressAdvisory.js";
 /** One Task's orchestration cost and advisory projection, with no writes. */
 export function projectTaskOrchestration(facts) {
     const evidence = {
@@ -36,14 +35,14 @@ export function projectTaskOrchestration(facts) {
     const repeatedIdentities = [...integrationIdentities.values()]
         .reduce((total, count) => total + Math.max(0, count - 1), 0);
     const leaderSessions = facts.roleSessionSets.find(({ owner }) => owner.roleName === "leader") ?? null;
-    const firstProgress = projectFirstProgressStopLoss({
+    const firstProgress = projectFirstProgressAdvisory({
         sessions: leaderSessions,
         events: facts.events,
         workItems: facts.workItems,
         reviewRounds: facts.reviewRounds,
         integrations: facts.integrations
     });
-    const advisories = projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgress.exhausted);
+    const advisories = projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgress.attentionRecommended);
     const publicationAt = facts.task.completedAt === undefined
         ? undefined
         : facts.publications
@@ -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)),
@@ -87,26 +86,13 @@ export function projectTaskOrchestration(facts) {
         advisories
     });
 }
-function projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, stopLoss) {
+function projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgressAttention) {
     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:"))));
@@ -150,10 +136,10 @@ function projectAdvisories(facts, classifications, fullRounds, repeatedIdentitie
             refs: recent.map(({ id }) => `review-round:${id}`)
         });
     }
-    if (stopLoss) {
+    if (firstProgressAttention) {
         result.push({
-            code: "provider-first-progress-stop-loss",
-            reason: "Two fresh Leader generations produced no first durable progress; hand off to the unique Operator before another generation.",
+            code: "provider-first-progress-advisory",
+            reason: "Two fresh Leader generations produced no first durable progress; consider Operator attention before another generation.",
             refs: [facts.task.id]
         });
     }

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/taskBaseFreshness.js

@@ -113,23 +113,17 @@ export function assertTaskBaseFreshnessForCompletion(report, options = {}) {
         const acceptedPublishedTree = options.acceptedPublishedTreeProjectId === entry.projectId;
         if ((entry.status === "behind" || entry.status === "diverged")
             && !acceptedPublishedTree) {
-            throw usageError(`Task ${report.taskId} Project ${entry.projectId} base is ${entry.status}; `
-                + `run 'yui task base status ${report.taskId} --refresh' and choose an explicit delivery base. `
-                + "Safe resolutions are to rebase or merge the Task workspace onto the refreshed remote base, "
-                + "create a clean delivery branch from that base and cherry-pick the Task changes, "
-                + "or ask the Leader to resolve it. Continuing without rebasing is allowed only after explicitly "
-                + "recording the unrelated-diff risk.");
+            warnings.push(`Project ${entry.projectId} base is ${entry.status}; the Leader must choose the delivery base `
+                + "and account for any remote-only changes.");
         }
         if (entry.workspaceClean === false) {
             throw usageError(`Task ${report.taskId} Project ${entry.projectId} workspace is dirty; `
                 + "commit, integrate, or clean it before completion.");
         }
         if (entry.status === "unknown") {
-            if (report.refreshed) {
-                throw usageError(`Task ${report.taskId} Project ${entry.projectId} remote base could not be refreshed: `
-                    + `${entry.error ?? "unknown error"}`);
-            }
-            warnings.push(`Project ${entry.projectId} remote base is unknown; local completion continues without a remote claim.`);
+            warnings.push(report.refreshed
+                ? `Project ${entry.projectId} remote base could not be refreshed: ${entry.error ?? "unknown error"}; local completion continues without a remote claim.`
+                : `Project ${entry.projectId} remote base is unknown; local completion continues without a remote claim.`);
         }
     }
     return warnings;

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);