@runfusion/fusion 0.77.0-beta.5 → 0.77.0-beta.6

package/dist/child-process-worker.js

@@ -231,10 +231,16 @@ function resolveEntryPointBranchAssignment(input) {
       };
   }
 }
-var isValidTaskBranchName;
+var BranchWriteProvenanceError, isValidTaskBranchName;
 var init_branch_assignment = __esm({
   "../core/src/branch/branch-assignment.ts"() {
     "use strict";
+    BranchWriteProvenanceError = class extends Error {
+      constructor() {
+        super("branchWriteOrigin is required when branch is provided");
+        this.name = "BranchWriteProvenanceError";
+      }
+    };
     isValidTaskBranchName = isValidBranchGroupBranchName;
   }
 });
@@ -4612,8 +4618,8 @@ var init_research_settings = __esm({
 function resolveResearchFindingId(finding) {
   const explicitId = typeof finding.id === "string" ? finding.id.trim() : "";
   if (explicitId) return explicitId;
-  const normalize9 = (value) => value.trim().replace(/\s+/g, " ").toLowerCase();
-  const canonical = [normalize9(finding.heading ?? ""), normalize9(finding.content ?? ""), ...[...finding.sources ?? []].map(normalize9).filter(Boolean).sort()].join("\n");
+  const normalize10 = (value) => value.trim().replace(/\s+/g, " ").toLowerCase();
+  const canonical = [normalize10(finding.heading ?? ""), normalize10(finding.content ?? ""), ...[...finding.sources ?? []].map(normalize10).filter(Boolean).sort()].join("\n");
   let hash3 = 2166136261;
   for (let index2 = 0; index2 < canonical.length; index2 += 1) {
     hash3 ^= canonical.charCodeAt(index2);
@@ -36067,17 +36073,17 @@ var init_agent_store = __esm({
        * @returns Matching agent when unambiguous; otherwise null
        */
       async resolveAgent(shortname) {
-        const normalize9 = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+        const normalize10 = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
         const all = await this.listAgents();
         const exact = all.find((agent) => agent.id === shortname);
         if (exact) {
           return exact;
         }
-        const normalizedTarget = normalize9(shortname);
+        const normalizedTarget = normalize10(shortname);
         if (!normalizedTarget) {
           return null;
         }
-        const matches = all.filter((agent) => normalize9(agent.name) === normalizedTarget);
+        const matches = all.filter((agent) => normalize10(agent.name) === normalizedTarget);
         return matches.length === 1 ? matches[0] : null;
       }
       // ─────────────────────────────────────────────────────────────────────────
@@ -45319,11 +45325,11 @@ function withWindowsNativeBinPath(environment, nativeRoot, platform3 = process.p
   if (platform3 !== "win32") return environment;
   const pathKey = Object.keys(environment).find((key) => key.toLowerCase() === "path") ?? "PATH";
   const bin = nativeRoot.replace(/[\\/]+$/, "") + "\\bin";
-  const normalize9 = (value) => value.replace(/\//g, "\\").toLowerCase();
+  const normalize10 = (value) => value.replace(/\//g, "\\").toLowerCase();
   const inherited = environment[pathKey] ?? "";
   const segments = inherited.split(";").filter(Boolean);
-  const normalizedBin = normalize9(bin);
-  const deduplicated = segments.filter((segment) => normalize9(segment) !== normalizedBin);
+  const normalizedBin = normalize10(bin);
+  const deduplicated = segments.filter((segment) => normalize10(segment) !== normalizedBin);
   return { ...environment, [pathKey]: [bin, ...deduplicated].join(";") };
 }
 function readPostgresPid(dataDir) {
@@ -67272,14 +67278,14 @@ function resolveGlobalDir(dir) {
       const isFusionDirInsideRepo = basename8(dir) === ".fusion" && existsSync14(join19(dirname11(dir), ".git"));
       if (isFusionDirInsideRepo) {
         const homeGlobalDir = resolveGlobalDirForHome(getHomeDir2());
-        const normalize9 = (p2) => {
+        const normalize10 = (p2) => {
           try {
             return realpathSync3.native(p2);
           } catch {
             return resolve13(p2);
           }
         };
-        if (normalize9(dir) !== normalize9(homeGlobalDir)) {
+        if (normalize10(dir) !== normalize10(homeGlobalDir)) {
           throw new Error(
             `resolveGlobalDir(): refusing project-local '.fusion' directory '${dir}' for the central/global store. This would create a stray per-project central database seeded with default global settings and silently reset them. Pass the resolved global dir (or omit the argument so it defaults to ~/.fusion); see TaskStore.getGlobalSettingsDir(). If this really is your intended global dir (e.g. a version-controlled dotfiles repo), set FUSION_ALLOW_PROJECT_LOCAL_GLOBAL_DIR=true to override.`
           );
@@ -88006,15 +88012,15 @@ async function appendRecall(layer, input) {
 async function mergeRecallGraphNodeIds(layer, recordId, addGraphNodeIds) {
   const pid = projectId(layer);
   const table = project_exports.memoryRecallRecords;
-  const normalize9 = (ids) => [...new Set(ids.map((id) => id.trim()).filter(Boolean))].sort();
+  const normalize10 = (ids) => [...new Set(ids.map((id) => id.trim()).filter(Boolean))].sort();
   return layer.transactionImmediate(async (tx) => {
     await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${recallGraphNodeIdsLockKey(pid, recordId)}))`);
     const rows = await tx.select().from(table).where(and(eq(table.projectId, pid), eq(table.id, recordId))).limit(1);
     await recallGraphNodeIdsTestHooks?.afterRowRead?.();
     const row = rows[0];
     if (!row) return { status: "missing" };
-    const stored = normalize9(row.graphNodeIds);
-    const next = normalize9([...stored, ...addGraphNodeIds]);
+    const stored = normalize10(row.graphNodeIds);
+    const next = normalize10([...stored, ...addGraphNodeIds]);
     if (stored.length === next.length && stored.every((value, index2) => value === next[index2])) return { status: "unchanged" };
     await tx.update(table).set({ graphNodeIds: next, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and(eq(table.projectId, pid), eq(table.id, recordId)));
     return { status: "updated" };
@@ -92417,7 +92423,7 @@ import { randomUUID as randomUUID31 } from "node:crypto";
 function normalizeCreateBranchProvenance(input) {
   if (input.branch === void 0) return input;
   if (input.branchWriteOrigin !== "operator" && input.branchWriteOrigin !== "engine") {
-    throw new Error("branchWriteOrigin is required when branch is provided");
+    throw new BranchWriteProvenanceError();
   }
   validateTaskBranchName(input.branch);
   if (input.branchWriteOrigin === "operator") {
@@ -94634,7 +94640,7 @@ async function updateTaskRepositoryScopeImpl(store, id, requestedScope) {
         ...replacement,
         repositories: nextRepositories,
         revision: Math.max((current.repositoryScope?.revision ?? 0) + 1, replacement.revision ?? 0),
-        ...scopeChanged ? { reviewEvidence: void 0 } : {}
+        ...scopeChanged ? { reviewEvidence: void 0, reviewRemediation: void 0 } : {}
       };
       const [updatedRow] = await tx.update(project_exports.tasks).set({
         repositoryScope: normalized2 ?? null,
@@ -94650,6 +94656,35 @@ async function updateTaskRepositoryScopeImpl(store, id, requestedScope) {
     return outcome;
   }));
 }
+async function updateWorkspaceReviewStateImpl(store, id, expectedScopeRevision, reviewRemediation) {
+  return store.withTaskLock(id, async () => {
+    const layer = store.asyncLayer;
+    const outcome = await layer.transactionImmediate(async (tx) => {
+      await acquireTaskAdvisoryXactLock(tx, layer.projectId, id);
+      const row = await readTaskRowInTransaction(tx, id, { includeDeleted: true }, layer.projectId);
+      if (!row) throw new TaskNotFoundError(id);
+      if (row.deletedAt) throw new TaskDeletedError(id, row.deletedAt);
+      const current = store.rowToTask(store.pgRowToTaskRow(row));
+      if (current.repositoryScope?.revision !== expectedScopeRevision) return { task: current, updated: false };
+      const repositoryScope = {
+        ...current.repositoryScope,
+        ...reviewRemediation ? { reviewRemediation } : { reviewRemediation: void 0 }
+      };
+      const [updatedRow] = await tx.update(project_exports.tasks).set({
+        repositoryScope,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }).where(and(eq(project_exports.tasks.id, id), taskProjectScope(layer))).returning();
+      if (!updatedRow) throw new TaskNotFoundError(id);
+      return { task: store.rowToTask(store.pgRowToTaskRow(updatedRow)), updated: true };
+    });
+    if (outcome.updated) {
+      await store.writeTaskJsonFile(store.taskDir(id), outcome.task);
+      if (store.isWatching) store.taskCache.set(id, { ...outcome.task });
+      store.emitTaskLifecycleEventSafely("task:updated", [outcome.task]);
+    }
+    return outcome;
+  });
+}
 async function resolveTaskWedgeNotificationEpisodeImpl(store, id, episodeId) {
   const layer = store.asyncLayer;
   const row = await resolveActiveTaskWedgeEpisodeRow(layer, id, episodeId, (/* @__PURE__ */ new Date()).toISOString());
@@ -103453,7 +103488,7 @@ async function updateTaskUnlockedImpl(store, id, updates, runContext) {
   if (updates.recommendations !== void 0) assertValidRecommendations(updates.recommendations);
   if (updates.branch !== void 0) {
     if (updates.branchWriteOrigin !== "operator" && updates.branchWriteOrigin !== "engine") {
-      throw new Error("branchWriteOrigin is required when branch is provided");
+      throw new BranchWriteProvenanceError();
     }
     if (updates.branch !== null) validateTaskBranchName(updates.branch);
   }
@@ -103542,7 +103577,7 @@ async function updateTaskUnlockedImpl(store, id, updates, runContext) {
       task.repositoryScope = void 0;
     } else if (updates.repositoryScope !== void 0) {
       const scopeRevisionChanged = task.repositoryScope?.revision !== updates.repositoryScope.revision;
-      task.repositoryScope = scopeRevisionChanged ? { ...updates.repositoryScope, reviewEvidence: void 0 } : updates.repositoryScope;
+      task.repositoryScope = scopeRevisionChanged ? { ...updates.repositoryScope, reviewEvidence: void 0, reviewRemediation: void 0 } : updates.repositoryScope;
       if (scopeRevisionChanged) {
         task.workflowStepResults = invalidateSupersededRepositoryScopeReviews(
           task.workflowStepResults,
@@ -106042,6 +106077,9 @@ var init_store = __esm({
       async mutateTaskRepositoryScope(id, mutation) {
         return updateTaskRepositoryScopeImpl(this, id, mutation);
       }
+      async updateWorkspaceReviewState(id, expectedScopeRevision, reviewRemediation) {
+        return updateWorkspaceReviewStateImpl(this, id, expectedScopeRevision, reviewRemediation);
+      }
       async resolveTaskWedgeNotificationEpisode(id, episodeId) {
         return resolveTaskWedgeNotificationEpisodeImpl(this, id, episodeId);
       }
@@ -136049,6 +136087,7 @@ __export(src_exports, {
   BUNDLED_PLUGIN_IDS: () => BUNDLED_PLUGIN_IDS,
   BackupManager: () => BackupManager,
   BackwardCompat: () => BackwardCompat,
+  BranchWriteProvenanceError: () => BranchWriteProvenanceError,
   CENTRAL_BACKUP_SCHEMAS: () => CENTRAL_BACKUP_SCHEMAS,
   CLAUDE_SONNET_5_MODEL_ID: () => CLAUDE_SONNET_5_MODEL_ID,
   CLEAN_COMPLETION_MARKERS: () => CLEAN_COMPLETION_MARKERS,
@@ -163898,8 +163937,8 @@ var require_resolve = __commonJS({
       }
       return count2;
     }
-    function getFullPath(resolver, id = "", normalize9) {
-      if (normalize9 !== false)
+    function getFullPath(resolver, id = "", normalize10) {
+      if (normalize10 !== false)
         id = normalizeId2(id);
       const p2 = resolver.parse(id);
       return _getFullPath(resolver, p2);
@@ -165239,7 +165278,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize9(uri, options) {
+    function normalize10(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         serialize(parse4(uri, options), options);
@@ -165475,7 +165514,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize9,
+      normalize: normalize10,
       resolve: resolve50,
       resolveComponent,
       equal,
@@ -177689,6 +177728,39 @@ var init_worktrunk_failure_handler = __esm({
   }
 });
 
+// ../engine/src/executor/workspace-review-remediation.ts
+function normalize8(value) {
+  return (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function resolveWorkspaceReviewRemediationRepository(task, declaredRepositories) {
+  const scope = task.repositoryScope;
+  const remediation = scope?.reviewRemediation;
+  if (!remediation) return void 0;
+  if (scope?.state !== "confirmed" || scope.revision !== remediation.scopeRevision) {
+    throw new Error(`Workspace Code Review remediation target is stale for ${task.id}`);
+  }
+  if (!declaredRepositories.includes(remediation.repository)) {
+    throw new Error(`Workspace Code Review remediation repository ${remediation.repository} is not declared for ${task.id}`);
+  }
+  return remediation.repository;
+}
+function deriveWorkspaceReviewRemediation(result) {
+  if (typeof result.repositoryScopeRevision !== "number") return void 0;
+  const blocking = (result.repositoryReviewOutcomes ?? []).filter((outcome) => outcome.status === "REVIEWED" && (outcome.verdict === "REVISE" || outcome.verdict === "RETHINK")).sort((left, right) => left.repository.localeCompare(right.repository))[0];
+  if (!blocking) return void 0;
+  const findings = (blocking.findings ?? []).map((finding) => `${finding.id}:${normalize8(finding.title)}:${normalize8(finding.body)}`).sort().join("|");
+  return {
+    scopeRevision: result.repositoryScopeRevision,
+    repository: blocking.repository,
+    inputSignature: `${result.workflowStepId}\0${blocking.repository}\0${blocking.fingerprint ?? ""}\0${blocking.verdict}\0${findings}`
+  };
+}
+var init_workspace_review_remediation = __esm({
+  "../engine/src/executor/workspace-review-remediation.ts"() {
+    "use strict";
+  }
+});
+
 // ../engine/src/worktree/worktree-copy-files.ts
 import { constants as fsConstants3 } from "node:fs";
 import { access as access7, copyFile as copyFile2, lstat as lstat2, mkdir as mkdir26 } from "node:fs/promises";
@@ -178075,14 +178147,15 @@ function invalidateWorkspaceConfigCache(owner) {
   workspaceConfigEpochs.set(owner, (workspaceConfigEpochs.get(owner) ?? 0) + 1);
 }
 async function normalizeWorkspaceTaskRouting(store, taskId) {
-  const normalize9 = store.normalizeWorkspaceTaskWorktreeMetadata;
-  if (typeof normalize9 === "function") return normalize9.call(store, taskId);
+  const normalize10 = store.normalizeWorkspaceTaskWorktreeMetadata;
+  if (typeof normalize10 === "function") return normalize10.call(store, taskId);
   let task = await store.getTask(taskId);
   if (task.worktree || task.branch || task.executionStartBranch || task.baseCommitSha) {
     if (typeof store.updateTask !== "function") return task;
     await store.updateTask(taskId, {
       worktree: null,
       branch: null,
+      branchWriteOrigin: "engine",
       executionStartBranch: null,
       baseCommitSha: null,
       sessionFile: null
@@ -178284,11 +178357,15 @@ async function ensureWorkspaceGroupOwnership(workspaceContext, settings) {
 async function acquireTaskWorktree(opts) {
   const { task, rootDir, store, settings, pool, logger: logger3, audit, runContext, createWorktree: createWorktree2, runConfiguredCommand: runConfiguredCommand2, runInitCommand, taskEnv, secretsStore, workspaceContext } = opts;
   const persistWorktreeAssignment = async (patch) => {
+    const provenancePatch = patch.branch === void 0 ? patch : {
+      ...patch,
+      branchWriteOrigin: patch.branchWriteOrigin ?? (classifyTaskBranchOrigin(task, patch.branch ?? void 0) === "operator-supplied" ? "operator" : "engine")
+    };
     if (!opts.suppressSingularWorktreePersist) {
-      await store.updateTask(task.id, patch);
+      await store.updateTask(task.id, provenancePatch);
       return;
     }
-    const { worktree: _worktree, branch: _branch, ...nonSingularPatch } = patch;
+    const { worktree: _worktree, branch: _branch, branchWriteOrigin: _origin, ...nonSingularPatch } = provenancePatch;
     if (Object.keys(nonSingularPatch).length > 0) {
       await store.updateTask(task.id, nonSingularPatch);
     }
@@ -178525,7 +178602,22 @@ async function acquireTaskWorktree(opts) {
     }
     worktreePath = created2.path;
     branch = created2.branch;
-    await persistWorktreeAssignment({ worktree: created2.path, branch: created2.branch });
+    try {
+      await persistWorktreeAssignment({ worktree: created2.path, branch: created2.branch });
+    } catch (error2) {
+      try {
+        await removeWorktree({
+          worktreePath: created2.path,
+          rootDir,
+          settings,
+          taskId: task.id,
+          reason: RemovalReason.ExecutorDispose
+        });
+      } catch (cleanupError) {
+        logger3?.warn(`${task.id}: failed to compensate unpersisted worktree ${created2.path}: ${formatError(cleanupError)}`);
+      }
+      throw error2;
+    }
     await audit?.git({ type: "worktree:create", target: created2.path, metadata: { branch: created2.branch, source: logOrigin === "return-guard" ? "acquire-return-guard" : void 0 } });
     await audit?.git({ type: "branch:create", target: created2.branch });
     if (created2.branch !== branchName) {
@@ -178767,6 +178859,17 @@ async function acquireTaskWorktree(opts) {
   if (pinned) {
     return acquirePinnedWorktree();
   }
+  if (!workspaceContext && !task.worktree && !(pool && settings.recycleWorktrees)) {
+    const registeredMatches = (await getRegisteredWorktreeBranches(rootDir)).filter((entry) => entry.branch === branchName);
+    if (registeredMatches.length === 1) {
+      const registeredPath = registeredMatches[0].worktreePath;
+      const classification = await classifyTaskWorktree(rootDir, registeredPath);
+      if (classification.ok) {
+        await persistWorktreeAssignment({ worktree: registeredPath, branch: branchName });
+        return reuseWarmWorktree(registeredPath, branchName, "existing");
+      }
+    }
+  }
   if (task.worktree && isResume) {
     if (logger3?.debug) logger3.debug(`Reusing existing worktree: ${worktreePath}`);
     const cleanup = await removeDesktopBuildArtifacts(worktreePath, logger3);
@@ -178802,6 +178905,7 @@ async function acquireTaskWorktree(opts) {
       }
     }
     if (pooled) {
+      let poolAssignmentPersistenceStarted = false;
       try {
         const preparedRaw = await pool.prepareForTask(pooled, branchName, freshStartPoint, {
           allowSiblingBranchRename,
@@ -178859,7 +178963,9 @@ async function acquireTaskWorktree(opts) {
           });
           acquiredFromPool = true;
           logger3?.log(`Acquired worktree from pool: ${worktreePath}`);
+          poolAssignmentPersistenceStarted = true;
           await persistWorktreeAssignment({ worktree: worktreePath, branch });
+          poolAssignmentPersistenceStarted = false;
           await audit?.git({ type: "worktree:reuse", target: worktreePath, metadata: { branch, reclaimed: prepared.reclaimed } });
           if (prepared.reclaimed) {
             await store.logEntry(task.id, `Acquired reclaimed worktree from pool: ${worktreePath} (${prepared.strandedCommitCount ?? 0} commits preserved)`, void 0, runContext);
@@ -178913,6 +179019,10 @@ async function acquireTaskWorktree(opts) {
           });
         }
       } catch (poolErr) {
+        if (poolAssignmentPersistenceStarted) {
+          pool.release(pooled, task.id);
+          throw poolErr;
+        }
         if (poolErr instanceof WorktreeBaseRefreshError) {
           await persistWorktreeAssignment({ worktree: null, branch: null, branchWriteOrigin: "engine", sessionFile: null });
           pool.release(pooled, task.id);
@@ -179224,7 +179334,11 @@ async function acquireWorkspaceTaskWorktrees(opts) {
     current = await opts.store.getTask(opts.task.id);
   }
   const entries = current.workspaceWorktrees ?? {};
-  const coordinatorWorktreePath = repoRelPaths.map((repoRelPath) => entries[repoRelPath]?.worktreePath).find((path6) => typeof path6 === "string" && path6.length > 0);
+  const remediationRepository = resolveWorkspaceReviewRemediationRepository(current, repoRelPaths);
+  if (opts.remediationRepository !== remediationRepository) {
+    throw new Error(`Workspace Code Review remediation target changed during acquisition for ${opts.task.id}`);
+  }
+  const coordinatorWorktreePath = remediationRepository ? entries[remediationRepository]?.worktreePath : repoRelPaths.map((repoRelPath) => entries[repoRelPath]?.worktreePath).find((path6) => typeof path6 === "string" && path6.length > 0);
   if (!coordinatorWorktreePath) {
     throw new Error(`Workspace task ${opts.task.id} did not acquire a declared repository worktree`);
   }
@@ -179245,6 +179359,7 @@ var init_worktree_acquisition = __esm({
     init_worktree_backend();
     init_worktrunk_installer();
     init_worktrunk_failure_handler();
+    init_workspace_review_remediation();
     init_secrets_env_writer();
     init_worktree_desktop_artifacts();
     init_worktree_hooks();
@@ -185943,7 +186058,7 @@ var init_agent_memory_index = __esm({
 // ../engine/src/agents/agent-instructions.ts
 import { readFile as readFile42, writeFile as writeFile28, mkdir as mkdir29, access as access8 } from "node:fs/promises";
 import { constants as fsConstants4 } from "node:fs";
-import { isAbsolute as isAbsolute17, resolve as resolve40, relative as relative16, normalize as normalize8, sep as sep12, dirname as dirname30 } from "node:path";
+import { isAbsolute as isAbsolute17, resolve as resolve40, relative as relative16, normalize as normalize9, sep as sep12, dirname as dirname30 } from "node:path";
 function trimAndClamp(value, maxLength, label, agentId) {
   const trimmed = value.trim();
   if (!trimmed) {
@@ -185977,7 +186092,7 @@ function resolveValidatedMarkdownPath(rawPath, rootDir, agentId, fieldLabel) {
     log27.warn(`${fieldLabel} must be project-relative for agent ${agentId}: ${trimmed}`);
     return null;
   }
-  const normalized2 = normalize8(trimmed);
+  const normalized2 = normalize9(trimmed);
   if (isPathTraversal2(normalized2)) {
     log27.warn(`${fieldLabel} traversal is not allowed for agent ${agentId}: ${trimmed}`);
     return null;
@@ -199373,7 +199488,8 @@ async function tryEarlyEmptyOwnDiffFinalize(input) {
     try {
       await store.updateTask(taskId, {
         worktree: worktreeRemoved ? null : task.worktree,
-        branch: branchDeleted ? null : task.branch
+        branch: branchDeleted ? null : task.branch,
+        ...branchDeleted ? { branchWriteOrigin: "engine" } : {}
       });
       if (worktreeRemoved) task.worktree = void 0;
       if (branchDeleted) task.branch = void 0;
@@ -199733,7 +199849,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
             rootDir,
             integrationBranch: mergeTarget.branch
           });
-          await store.updateTask(taskId, { worktree: reusableMatch.path, branch: reusableMatch.branch });
+          await store.updateTask(taskId, { worktree: reusableMatch.path, branch: reusableMatch.branch, branchWriteOrigin: "engine" });
           await emitReuseHandoffAuditEvent(
             "merge:reuse-fallback-reused-existing-registration",
             {
@@ -205486,8 +205602,10 @@ function workflowNodeRequiresWorktree(node, { optionalGroupId, reviewerInlineFix
 }
 
 // ../engine/src/workflows/workflow-graph-executor.ts
+init_src2();
 init_worktree_acquisition();
 var PLAN_REVIEW_PROVIDER_FAILURE_HOLD_VALUE = "plan-review-provider-failure-hold";
+var BRANCH_WRITE_PROVENANCE_FAILURE_VALUE = "branch-write-provenance-failure";
 var PLAN_REVIEW_LEASE_HELD_VALUE = "plan-review-lease-held";
 function enclosingContainerInstanceId(parent, nodeId) {
   if (!parent || parent === nodeId) return void 0;
@@ -206514,7 +206632,7 @@ var WorkflowGraphExecutor = class {
     const failureResult = {
       outcome: "failure",
       // FNXC:SessionContention 2026-07-25-21:30: contention is a retryable hold, not an exception.
-      value: isSessionContentionError(lastErrorText) ? SESSION_CONTENTION_HOLD_VALUE : "exception",
+      value: lastError instanceof BranchWriteProvenanceError ? BRANCH_WRITE_PROVENANCE_FAILURE_VALUE : isSessionContentionError(lastErrorText) ? SESSION_CONTENTION_HOLD_VALUE : "exception",
       contextPatch: {
         [`node:${node.id}:error`]: lastErrorText
       }
@@ -213855,8 +213973,8 @@ async function autoRecoverWorktreeSessionStartFailure(store, task, opts) {
   }
   const workspaceTask = configuredWorkspace || isWorkspaceTask(task);
   if (workspaceTask) {
-    const normalize9 = store.normalizeWorkspaceTaskWorktreeMetadata;
-    if (typeof normalize9 === "function") task = await normalize9.call(store, task.id);
+    const normalize10 = store.normalizeWorkspaceTaskWorktreeMetadata;
+    if (typeof normalize10 === "function") task = await normalize10.call(store, task.id);
   }
   const resetRetryBudget = opts.resetRetryBudgetOnStaleMetadataClear === true;
   const staleMetadataClearRecoveryRetryCount = opts.staleMetadataClearRecoveryRetryCount;
@@ -213911,7 +214029,13 @@ async function autoRecoverWorktreeSessionStartFailure(store, task, opts) {
     worktreeSessionRetryCount: nextCount,
     ...nextStaleMetadataClearRecoveryCount === void 0 ? {} : { recoveryRetryCount: nextStaleMetadataClearRecoveryCount },
     worktree: clearWorktreeMetadata ? null : staleWorktree,
-    branch: nextBranch,
+    /*
+     * FNXC:BranchNaming 2026-08-21-09:36:
+     * Session recovery often changes only worktree/session metadata. Do not reassert an unchanged
+     * branch with engine provenance: that would erase a matching operator override and later make
+     * its branch eligible for engine cleanup. A real canonical clear remains an explicit engine write.
+     */
+    ...(task.branch ?? null) === nextBranch ? {} : { branch: nextBranch, branchWriteOrigin: "engine" },
     sessionFile: null
   });
   await opts.auditor?.database({
@@ -218009,7 +218133,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
             } catch {
             }
           }
-          const patch = preservedWorktree ? { branch: selected.branch } : { branch: selected.branch, worktree: null };
+          const patch = preservedWorktree ? { branch: selected.branch, branchWriteOrigin: "engine" } : { branch: selected.branch, branchWriteOrigin: "engine", worktree: null };
           if (!task.baseCommitSha) {
             const derivedBaseCommit = (await execAsync18(
               `git merge-base ${shellQuote2(integrationBase)} ${shellQuote2(selected.branch)}`,
@@ -221686,6 +221810,12 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
             await this.emitWorkspacePartialLandNoAction(task, "merge-pending", liveness.livePaths);
             continue;
           }
+          const latestTask = await this.store.getTask(task.id).catch(() => null);
+          const blockerTask = latestTask?.status === "failed" && latestTask.error?.startsWith("Workspace partial land:") ? { ...latestTask, status: null, error: void 0 } : latestTask;
+          if (!blockerTask || getTaskMergeBlocker(blockerTask, { skipColumnIdentityCheck: true }) !== void 0) {
+            await this.emitWorkspacePartialLandNoAction(task, "merge-blocked", []);
+            continue;
+          }
           const workspaceWorktrees = task.workspaceWorktrees ?? {};
           const explicitScope = task.repositoryScope?.state === "confirmed" ? task.repositoryScope.repositories : void 0;
           if (!explicitScope) {
@@ -221693,8 +221823,12 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
             continue;
           }
           const repoKeys = Object.keys(workspaceWorktrees).filter(
-            (repoRel) => explicitScope.includes(repoRel) && (task.modifiedFiles ?? []).some((file) => file.startsWith(`${repoRel}/`))
+            (repoRel) => explicitScope.includes(repoRel) && ((task.modifiedFiles ?? []).some((file) => file.startsWith(`${repoRel}/`)) || Boolean(workspaceWorktrees[repoRel]?.landedSha))
           );
+          if (repoKeys.length === 0) {
+            await this.emitWorkspacePartialLandNoAction(task, "empty-obligations", []);
+            continue;
+          }
           const landedRepos = [];
           const unlandedRepos = [];
           const unrecoverableRepos = [];
@@ -221751,13 +221885,12 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
             phase: "reconcile-workspace-partial-land"
           });
           if (evidenceUnavailableRepos.length > 0) {
-            const defers = (this.workspacePartialLandEvidenceDefers.get(task.id) ?? 0) + 1;
-            this.workspacePartialLandEvidenceDefers.set(task.id, defers);
+            const defers = (task.mergeTransientRetryCount ?? 0) + 1;
+            await this.store.updateTask(task.id, { mergeTransientRetryCount: defers });
             if (defers >= MAX_STARVATION_DROPS) {
               const error2 = `Workspace partial-land evidence unavailable: branch state could not be read after ${MAX_STARVATION_DROPS} sweeps for sub-repo(s) ${evidenceUnavailableRepos.join(", ")} \u2014 manual intervention required.`;
               await this.store.updateTask(task.id, { status: "failed", error: error2 });
               await this.store.logEntry(task.id, error2);
-              this.workspacePartialLandEvidenceDefers.delete(task.id);
               await auditor.database({
                 type: "task:reconcile-workspace-partial-land",
                 target: task.id,
@@ -221770,7 +221903,6 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
             }
             continue;
           }
-          this.workspacePartialLandEvidenceDefers.delete(task.id);
           if (unrecoverableRepos.length > 0) {
             const missingBranches = unrecoverableRepos.map((repoRel) => workspaceWorktrees[repoRel]?.branch ?? resolveTaskWorkingBranch(task)).join(", ");
             const error2 = `Workspace partial-land unrecoverable: sub-repo(s) ${unrecoverableRepos.join(", ")} have no branch (${missingBranches}) and no landedSha \u2014 manual intervention required.`;
@@ -221798,7 +221930,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
               landedRepos,
               unlandedRepos: [],
               reason: "all-landed-not-finalized",
-              successLog: "Auto-recovered (workspace): all sub-repos landed but task not finalized \u2014 re-enqueued finalize-once"
+              successLog: "Workspace merge recovery scheduled: all sub-repositories have proven landing evidence; awaiting finalize-once result"
             });
             recovered++;
             continue;
@@ -221807,7 +221939,7 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
             landedRepos,
             unlandedRepos,
             reason: landedRepos.length > 0 ? "partial-land" : "zero-land",
-            successLog: `Auto-recovered (workspace): re-enqueued partial land (${landedRepos.length} landed, ${unlandedRepos.length} pending)`
+            successLog: `Workspace merge recovery scheduled: ${landedRepos.length} landed, ${unlandedRepos.length} pending`
           });
           recovered++;
         } catch (err) {
@@ -221872,7 +222004,8 @@ var SelfHealingManager = class _SelfHealingManager extends SelfHealingGitEvidenc
       }).catch(() => void 0);
       return false;
     }
-    const drops = (this.workspacePartialLandDrops.get(task.id) ?? 0) + 1;
+    const drops = (task.mergeTransientRetryCount ?? 0) + 1;
+    await this.store.updateTask(task.id, { mergeTransientRetryCount: drops });
     this.workspacePartialLandDrops.set(task.id, drops);
     log34.warn(`reconcileWorkspacePartialLands: enqueue dropped for ${task.id} (${drops}/${MAX_STARVATION_DROPS}); merge queue rejected re-enqueue`);
     if (drops >= MAX_STARVATION_DROPS) {
@@ -230129,6 +230262,7 @@ async function handleBranchConflict(deps, task, error2) {
       status: "failed",
       error: conflictMessage,
       branch: error2.branchName,
+      branchWriteOrigin: "engine",
       worktree: error2.conflictingWorktreePath,
       paused: true,
       pausedReason: "branch-conflict-unrecoverable"
@@ -230171,8 +230305,8 @@ async function recoverMissingWorktreeSessionStartFailure(deps, task, worktreePat
   }
   let recoveryTask = task;
   if (workspaceTask) {
-    const normalize9 = deps.store.normalizeWorkspaceTaskWorktreeMetadata;
-    if (typeof normalize9 === "function") recoveryTask = await normalize9.call(deps.store, task.id);
+    const normalize10 = deps.store.normalizeWorkspaceTaskWorktreeMetadata;
+    if (typeof normalize10 === "function") recoveryTask = await normalize10.call(deps.store, task.id);
   }
   if (!workspaceTask && isInsideWorktreesDir(deps.rootDir, staleWorktreePath)) {
     try {
@@ -230564,8 +230698,21 @@ async function detectWorkspaceMainCheckoutWork(deps, task, repos, declaredScope)
       const { stdout } = await execAsync40("git log -n 200 --format=%H%x1f%ct%x1f%B%x1e HEAD", { ...probeOptions, cwd: checkout });
       const attributed = new RegExp(`(?:${task.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}|Fusion-Task-Id:\\s*${task.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`, "i");
       for (const commit of parseCommits(stdout)) {
-        const evidence = attributed.test(commit.body) ? "task-attributed-commit" : anchor !== null && commit.committedAt >= anchor ? "post-anchor-commit" : null;
-        if (evidence) violations.push({ repo, files: [], commits: [commit.sha], evidence });
+        const entry = workspaceWorktrees[repo];
+        const recordedLanding = entry?.landedSha === commit.sha || task.mergeDetails?.workspaceLandedShas?.[repo] === commit.sha || task.mergeDetails?.commitSha === commit.sha;
+        let reachableFromBaseline = false;
+        if (entry?.baseCommitSha) {
+          try {
+            await execAsync40(`git merge-base --is-ancestor ${commit.sha} ${entry.baseCommitSha}`, { ...probeOptions, cwd: checkout });
+            reachableFromBaseline = true;
+          } catch {
+          }
+        }
+        if (attributed.test(commit.body) && !recordedLanding && !reachableFromBaseline && anchor !== null && commit.committedAt >= anchor) {
+          violations.push({ repo, files: [], commits: [commit.sha], evidence: "task-attributed-commit" });
+        } else if (!recordedLanding && !reachableFromBaseline && anchor !== null && commit.committedAt >= anchor) {
+          warnings.push({ repo, files: [], commits: [commit.sha], reason: "pre-existing-dirt" });
+        }
       }
     } catch {
       warnings.push({ repo, files: [], commits: [], reason: "commit-scan-unavailable" });
@@ -230632,7 +230779,7 @@ async function verifyWorktreeInvariants(deps, task, worktreePathOverride, allowR
         reason: "main_checkout_edit",
         repo: firstMainCheckoutViolation.repo,
         observed: `${firstMainCheckoutViolation.evidence}: ${observed}`,
-        expected: `move task work into the acquired fusion/${task.id} worktree for ${firstMainCheckoutViolation.repo} (acquire it first if needed), restore its main checkout, then retry fn_task_done; only 3 requeue attempts are available`
+        expected: `move task work into the acquired fusion/${task.id} worktree for ${firstMainCheckoutViolation.repo} (acquire it first if needed), restore its main checkout, then ask an operator to retry fn_task_done`
       };
     }
     const zeroAcquire = classifyWorkspaceZeroAcquire(task, {
@@ -232005,7 +232152,7 @@ ${scopeGuard}
 }
 
 // ../engine/src/executor/send-task-back-for-fix.ts
-async function sendTaskBackForFix(deps, task, worktreePath, failureFeedback, stepName, reason, preserveResumeState = true, mergeVerificationFailure = false, retryPresentation, findings) {
+async function sendTaskBackForFix(deps, task, worktreePath, failureFeedback, stepName, reason, preserveResumeState = true, mergeVerificationFailure = false, retryPresentation, findings, persistWorktreePath) {
   const taskId = task.id;
   deps.clearCompletedTaskWatchdog(taskId);
   const { task: authoritativeRemediationTask, route: externalExecutionRoute } = await resolveAuthoritativeExternalExecutionRoute(deps.store, task);
@@ -232048,7 +232195,7 @@ Please fix the issues so the verification can pass on the next attempt.`,
     remediationWorktreePath,
     `${taskId}: sent back to in-progress for remediation`,
     preserveResumeState,
-    !externalExecutionRoute.configured
+    persistWorktreePath ?? !externalExecutionRoute.configured
   );
 }
 
@@ -236837,6 +236984,7 @@ init_logger();
 init_run_audit();
 init_worktree_acquisition();
 init_workspace_config_resolver();
+init_workspace_review_remediation();
 async function ensureGraphCustomNodeWorktree(deps, task, settings, nodeId, refreshStaleBase = false) {
   const workspaceConfig = await resolveWorkspaceConfigOnce(deps);
   const syntheticRunId = generateSyntheticRunId("workflow-node-worktree", task.id);
@@ -236856,6 +237004,7 @@ async function ensureGraphCustomNodeWorktree(deps, task, settings, nodeId, refre
       deps.getRunContextFor(task.id)
     );
     if (workspaceConfig) {
+      const remediationRepository = resolveWorkspaceReviewRemediationRepository(task, workspaceConfig.repos);
       const workspace = await acquireWorkspaceTaskWorktrees({
         workspaceConfig,
         workspaceRootDir: deps.rootDir,
@@ -236880,7 +237029,8 @@ async function ensureGraphCustomNodeWorktree(deps, task, settings, nodeId, refre
           return result;
         }),
         taskEnv: process.env,
-        addActiveWorktree: deps.addActiveWorktree
+        addActiveWorktree: deps.addActiveWorktree,
+        remediationRepository
       });
       deps.onStart?.(workspace.task, workspace.coordinatorWorktreePath);
       executorLog.debug(`${task.id}: workflow node '${nodeId}' using workspace coordinator ${workspace.coordinatorWorktreePath}`);
@@ -237410,6 +237560,7 @@ init_effective_settings();
 init_replan_target();
 init_transient_error_detector();
 init_logger();
+init_workspace_review_remediation();
 function normalizeConvergenceText(value) {
   return (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
 }
@@ -237570,7 +237721,22 @@ ${info.feedback}`,
     return false;
   }
   const revisionKey = optionalStepRevisionKey2(info.nodeId, info.stepName);
-  if (hasRepeatedUnchangedCodeReview(liveTask, info)) {
+  const reviewResult = (liveTask.workflowStepResults ?? []).find(
+    (result) => (result.workflowStepId === info.nodeId || result.workflowStepName === info.stepName) && result.verdict === "REVISE"
+  );
+  const derivedRemediation = reviewResult ? deriveWorkspaceReviewRemediation(reviewResult) : void 0;
+  const remediation = derivedRemediation && liveTask.workspaceWorktrees ? derivedRemediation : void 0;
+  const priorRemediation = liveTask.repositoryScope?.reviewRemediation;
+  const hasDurableRepeatedWorkspaceReview = remediation !== void 0 && priorRemediation?.scopeRevision === remediation.scopeRevision && priorRemediation.repository === remediation.repository && priorRemediation.inputSignature === remediation.inputSignature;
+  const updateWorkspaceReviewState = deps.store.updateWorkspaceReviewState;
+  if (remediation && !hasDurableRepeatedWorkspaceReview && updateWorkspaceReviewState) {
+    const persisted = await updateWorkspaceReviewState.call(deps.store, taskId, remediation.scopeRevision, remediation);
+    if (!persisted.updated) {
+      executorLog.warn(`${taskId}: workspace Code Review remediation was superseded by a repository scope change.`);
+      return false;
+    }
+  }
+  if (hasDurableRepeatedWorkspaceReview || (!remediation || !updateWorkspaceReviewState) && hasRepeatedUnchangedCodeReview(liveTask, info)) {
     const runContext = deps.getRunContextFor(taskId);
     await deps.store.logEntry(
       taskId,
@@ -237618,9 +237784,18 @@ Feedback:
 ${info.feedback}`, revisionKey),
     deps.getRunContextFor(taskId)
   );
-  await deps.sendTaskBackForFix(
+  const remediationWorktreePath = remediation ? liveTask.workspaceWorktrees?.[remediation.repository]?.worktreePath : liveTask.worktree;
+  if (remediation && !remediationWorktreePath) {
+    await deps.store.updateTask(taskId, {
+      status: "awaiting-approval",
+      awaitingApprovalReason: "code-review-non-convergence",
+      error: `Workspace Code Review remediation target ${remediation.repository} has no acquired worktree.`
+    });
+    return false;
+  }
+  const sendArgs = [
     liveTask,
-    liveTask.worktree ?? "",
+    remediationWorktreePath ?? "",
     info.feedback,
     info.stepName,
     `Pre-merge optional workflow step "${info.stepName}" requested revision`,
@@ -237628,7 +237803,12 @@ ${info.feedback}`, revisionKey),
     false,
     { attempt: nextCount, max: budget.unbounded ? void 0 : budget.max },
     info.findings
-  );
+  ];
+  if (remediation) {
+    await deps.sendTaskBackForFix(...sendArgs, false);
+  } else {
+    await deps.sendTaskBackForFix(...sendArgs);
+  }
   return true;
 }
 
@@ -238498,6 +238678,14 @@ function createTaskDoneTool(deps, taskId, worktreePath, promptContent, codeRevie
         const refusalMessage = `fn_task_done refused: ${invariantCheck.reason} \u2014 observed=${invariantCheck.observed}, expected=${invariantCheck.expected}`;
         await store.logEntry(taskId, refusalMessage, void 0, deps.getRunContextFor(task.id));
         executorLog.error(`${taskId}: fn_task_done refused (${invariantCheck.reason}) \u2014 observed=${invariantCheck.observed}, expected=${invariantCheck.expected}`);
+        if (invariantCheck.reason === "main_checkout_edit") {
+          await store.updateTask(taskId, { status: "failed", error: refusalMessage });
+          await store.logEntry(taskId, `${refusalMessage} \u2014 operator cleanup and Retry are required; executor retry budget preserved`, void 0, deps.getRunContextFor(task.id));
+          return {
+            content: [{ type: "text", text: refusalMessage }],
+            details: { error: refusalMessage }
+          };
+        }
         const priorRequeues = task.taskDoneRetryCount ?? 0;
         const nextRequeueCount = priorRequeues + 1;
         if (priorRequeues < MAX_TASK_DONE_REQUEUE_RETRIES) {
@@ -240161,7 +240349,9 @@ Repository scope (task-level; review this plan once): ${detail.repositoryScope?.
           return {
             repositoryScope: {
               ...currentScope,
-              reviewEvidence: Object.fromEntries(Object.entries(review.repositoryDiffFingerprints).map(([repo, fingerprint]) => [repo, { fingerprint, approvedAt }]))
+              reviewEvidence: Object.fromEntries(Object.entries(review.repositoryDiffFingerprints).map(([repo, fingerprint]) => [repo, { fingerprint, approvedAt }])),
+              // FNXC:WorkspaceFinalization 2026-08-21-09:50: An APPROVE for this fenced scope ends its REVISE episode; retaining its target would misroute later acquisition.
+              ...currentScope.reviewRemediation?.scopeRevision === review.repositoryScopeRevision ? { reviewRemediation: void 0 } : {}
             }
           };
         });
@@ -241438,6 +241628,7 @@ async function executeWorkflowGraph(deps, task, opts) {
 // ../engine/src/executor/run-graph-custom-node.ts
 init_src2();
 init_logger();
+init_workspace_review_remediation();
 import { existsSync as existsSync74 } from "node:fs";
 var WORKFLOW_THINKING_LEVEL_SET2 = new Set(THINKING_LEVELS);
 async function runGraphCustomNode(deps, node, nodeTask, settings, columnBinding, graphContext, outputLanguage) {
@@ -241517,7 +241708,8 @@ async function runGraphCustomNode(deps, node, nodeTask, settings, columnBinding,
       executionTarget = await deps.ensureGraphCustomNodeWorktree(acquisitionTask, settings, node.id);
     }
   }
-  const workspaceCoordinator = workspaceConfig ? Object.keys(executionTarget.workspaceWorktrees ?? {}).filter((repoRelPath) => workspaceConfig.repos.includes(repoRelPath)).sort().map((repoRelPath) => executionTarget.workspaceWorktrees?.[repoRelPath]?.worktreePath).find((path6) => typeof path6 === "string" && path6.length > 0) : void 0;
+  const remediationRepository = workspaceConfig ? resolveWorkspaceReviewRemediationRepository(executionTarget, workspaceConfig.repos) : void 0;
+  const workspaceCoordinator = workspaceConfig ? remediationRepository ? executionTarget.workspaceWorktrees?.[remediationRepository]?.worktreePath : Object.keys(executionTarget.workspaceWorktrees ?? {}).filter((repoRelPath) => workspaceConfig.repos.includes(repoRelPath)).sort().map((repoRelPath) => executionTarget.workspaceWorktrees?.[repoRelPath]?.worktreePath).find((path6) => typeof path6 === "string" && path6.length > 0) : void 0;
   if (!executionTarget.worktree && !workspaceCoordinator) {
     return { outcome: "failure", value: "no-worktree-for-write-node" };
   }
@@ -241677,7 +241869,9 @@ ${prompt}`;
           return {
             repositoryScope: {
               ...currentScope,
-              reviewEvidence: Object.fromEntries(Object.entries(aggregate.repositoryDiffFingerprints).map(([repo, fingerprint]) => [repo, { fingerprint, approvedAt }]))
+              reviewEvidence: Object.fromEntries(Object.entries(aggregate.repositoryDiffFingerprints).map(([repo, fingerprint]) => [repo, { fingerprint, approvedAt }])),
+              // FNXC:WorkspaceFinalization 2026-08-21-09:50: A current-scope APPROVE clears the durable REVISE coordinator before graph completion can schedule another run.
+              ...currentScope.reviewRemediation?.scopeRevision === aggregate.repositoryScopeRevision ? { reviewRemediation: void 0 } : {}
             }
           };
         });
@@ -241824,6 +242018,13 @@ async function handleGraphFailure(deps, task, result) {
       await deps.persistTokenUsage(task.id);
       return;
     }
+    if (graphFailureValue(result) === BRANCH_WRITE_PROVENANCE_FAILURE_VALUE) {
+      const diagnostic = graphFailureErrorTexts(result).find((message2) => message2.includes("branchWriteOrigin is required when branch is provided")) ?? "branchWriteOrigin is required when branch is provided";
+      await deps.store.logEntry(task.id, diagnostic, void 0, deps.getRunContextFor(task.id));
+      await deps.store.updateTask(task.id, { status: "failed", error: diagnostic }, deps.getRunContextFor(task.id));
+      await deps.persistTokenUsage(task.id);
+      return;
+    }
     if (isSessionContentionGraphFailure(result)) {
       await deps.holdForSessionContention(task, live, result);
       await deps.persistTokenUsage(task.id);
@@ -245639,6 +245840,7 @@ init_planner_lane_resolution();
 init_effective_settings();
 init_run_audit();
 init_worktree_acquisition();
+init_workspace_review_remediation();
 init_worktree_paths();
 init_worktree_pool();
 var execAsync52 = promisify74(exec55);
@@ -245817,6 +246019,7 @@ async function runImplementation(deps, task, graphCompletion, reportImplementati
     deps.registerConfiguredCommandController(task.id, taskCommandAbortController);
     let workspaceCoordinatorWorktree;
     if (hasWorkspaceRepos && deps.workspaceConfig) {
+      const remediationRepository = resolveWorkspaceReviewRemediationRepository(task, deps.workspaceConfig.repos);
       const workspace = await acquireWorkspaceTaskWorktrees({
         workspaceConfig: deps.workspaceConfig,
         workspaceRootDir: deps.rootDir,
@@ -245841,7 +246044,8 @@ async function runImplementation(deps, task, graphCompletion, reportImplementati
           return result;
         }),
         taskEnv,
-        addActiveWorktree: deps.addActiveWorktree
+        addActiveWorktree: deps.addActiveWorktree,
+        remediationRepository
       });
       task = workspace.task;
       workspaceCoordinatorWorktree = workspace.coordinatorWorktreePath;
@@ -269259,6 +269463,35 @@ init_merge_dependency_sync();
 init_active_session_registry();
 init_mcp_resolution();
 
+// ../engine/src/merge/workspace-merge-readiness.ts
+function resolveWorkspaceMergeReadiness(task, freshModifiedRepositories, netZeroBranchRepositories) {
+  const scope = task.repositoryScope;
+  if (scope?.state !== "confirmed") {
+    return { kind: "blocked", reason: `Workspace repository scope is unresolved for ${task.id}; operator confirmation is required before landing` };
+  }
+  const entries = task.workspaceWorktrees ?? {};
+  const declaredRepositories = scope.repositories.map((repository) => repository.trim());
+  if (declaredRepositories.some((repository) => !repository) || new Set(declaredRepositories).size !== declaredRepositories.length) {
+    return { kind: "blocked", reason: `Workspace repository scope has duplicate or invalid declarations for ${task.id}; operator repair is required` };
+  }
+  const worktreePaths = Object.values(entries).map((entry) => entry.worktreePath?.trim()).filter((path6) => Boolean(path6));
+  if (new Set(worktreePaths).size !== worktreePaths.length) {
+    return { kind: "blocked", reason: `Workspace merge has duplicate worktree paths for ${task.id}; operator repair is required` };
+  }
+  const repositories = declaredRepositories.filter((repo) => Boolean(entries[repo])).filter((repo) => freshModifiedRepositories.has(repo) || netZeroBranchRepositories.has(repo) || Boolean(entries[repo]?.landedSha)).sort();
+  const preservedFiles = [...new Set(task.modifiedFiles ?? [])].sort();
+  if (repositories.length > 0) return { kind: "ready", repositories, preservedFiles };
+  if (task.noCommitsExpected === true && scope.repositories.length === 0) {
+    return { kind: "no-op", repositories: [], preservedFiles: [] };
+  }
+  const declared = [...declaredRepositories].sort();
+  const knownEntries = declared.filter((repo) => entries[repo] !== void 0);
+  if (knownEntries.length === 0) {
+    return { kind: "blocked", reason: `Workspace merge has no acquired repositories matching confirmed scope for ${task.id}; operator repair is required` };
+  }
+  return { kind: "blocked", reason: `Workspace merge has no evidenced landing obligations for ${task.id}; operator repair is required` };
+}
+
 // ../engine/src/merge/workspace-fence-ref.ts
 import { execFile as execFile33 } from "node:child_process";
 import { createHash as createHash35 } from "node:crypto";
@@ -271000,6 +271233,14 @@ var WorkspaceRepoLandBusyError = class extends Error {
   }
   retryable = true;
 };
+var WorkspaceMergeTechnicalError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "WorkspaceMergeTechnicalError";
+  }
+  retryable = true;
+};
 var WorkspacePartialLandError = class extends Error {
   constructor(landedCount, failedRepos, message) {
     super(message);
@@ -271061,8 +271302,21 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
   const taskTitle = task.title?.trim() ? task.title.split("\n")[0] : void 0;
   const liveMergeBoundaryTask = await store.getTask(taskId).catch(() => void 0);
   const mergeBoundaryTask = liveMergeBoundaryTask?.workspaceWorktrees ? liveMergeBoundaryTask : task;
+  const reviewColumns = /* @__PURE__ */ new Set(["in-review"]);
+  const workflowIr = await resolveWorkflowIrForTask(store, taskId).catch(() => void 0);
+  if (workflowIr) for (const column of resolveReviewColumns(workflowIr)) reviewColumns.add(column);
+  const completeColumns = /* @__PURE__ */ new Set(["done"]);
+  if (workflowIr) for (const column of resolveTerminalColumns(workflowIr)) completeColumns.add(column);
+  if (!completeColumns.has(mergeBoundaryTask.column)) {
+    const mergeBlocker = getTaskMergeBlocker(mergeBoundaryTask, {
+      manual: options.manual === true,
+      reviewColumns
+    });
+    if (mergeBlocker) throw new WorkspaceFinalizeBlockedError(taskId, mergeBlocker);
+  }
   const confirmedScope = mergeBoundaryTask.repositoryScope?.state === "confirmed" ? new Set(mergeBoundaryTask.repositoryScope.repositories) : void 0;
   const mergeBoundaryModifiedFiles = [];
+  const mergeBoundaryModifiedRepositories = /* @__PURE__ */ new Set();
   const mergeBoundaryFingerprints = {};
   const modifiedOutOfScopeRepositories = /* @__PURE__ */ new Set();
   const netZeroBranchRepositories = /* @__PURE__ */ new Set();
@@ -271079,6 +271333,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
       if (files.length > 0 && !confirmedScope?.has(repoRel)) {
         modifiedOutOfScopeRepositories.add(repoRel);
       } else if (confirmedScope?.has(repoRel)) {
+        if (files.length > 0) mergeBoundaryModifiedRepositories.add(repoRel);
         mergeBoundaryModifiedFiles.push(...files.map((file) => `${repoRel}/${file}`));
         if (files.length === 0) {
           const { stdout: aheadCount } = await execFileAsync29("git", ["rev-list", "--count", `HEAD..${entry.branch}`], { cwd: entry.worktreePath, encoding: "utf8" });
@@ -271094,19 +271349,26 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
   }
   const normalizedMergeBoundaryFiles = [...new Set(mergeBoundaryModifiedFiles)].sort();
   const persistedReviewFiles = [...new Set(mergeBoundaryTask.modifiedFiles ?? [])].sort();
-  const approvedReviewEvidence = mergeBoundaryTask.repositoryScope?.reviewEvidence ?? {};
-  const missingOrStaleReviewApproval = Object.entries(mergeBoundaryFingerprints).some(([repoRel, fingerprint]) => approvedReviewEvidence[repoRel]?.fingerprint !== fingerprint);
-  if (normalizedMergeBoundaryFiles.some((file) => !persistedReviewFiles.includes(file)) || missingOrStaleReviewApproval) {
+  const approvedReviewEvidence = mergeBoundaryTask.repositoryScope?.reviewEvidence;
+  const requiresRepositoryReviewEvidence = approvedReviewEvidence !== void 0 || (mergeBoundaryTask.enabledWorkflowSteps ?? []).some((step) => /review/i.test(step));
+  const missingOrStaleReviewApproval = requiresRepositoryReviewEvidence && Object.entries(mergeBoundaryFingerprints).some(([repoRel, fingerprint]) => approvedReviewEvidence?.[repoRel]?.fingerprint !== fingerprint);
+  if (requiresRepositoryReviewEvidence && normalizedMergeBoundaryFiles.some((file) => !persistedReviewFiles.includes(file)) || missingOrStaleReviewApproval) {
     throw new Error(`Workspace merge evidence changed after review for ${taskId}; return the task to Code Review before landing`);
   }
-  await store.updateTask(taskId, { modifiedFiles: normalizedMergeBoundaryFiles });
-  task = { ...mergeBoundaryTask, modifiedFiles: normalizedMergeBoundaryFiles };
-  const workspaceWorktrees = task.workspaceWorktrees ?? {};
-  const explicitScope = task.repositoryScope?.state === "confirmed" ? task.repositoryScope.repositories : void 0;
-  if (!explicitScope) {
-    throw new Error(`Workspace repository scope is unresolved for ${taskId}; operator confirmation is required before landing`);
+  const readiness = resolveWorkspaceMergeReadiness(
+    mergeBoundaryTask,
+    mergeBoundaryModifiedRepositories,
+    netZeroBranchRepositories
+  );
+  if (readiness.kind === "blocked") throw new Error(readiness.reason);
+  if (readiness.kind === "no-op") {
+    throw new Error(`Workspace task ${taskId} has explicit no-commits policy and cannot enter repository landing`);
   }
-  const repoKeys = Object.keys(workspaceWorktrees).filter((repoRel) => explicitScope.includes(repoRel) && ((task.modifiedFiles ?? []).some((file) => file.startsWith(`${repoRel}/`)) || netZeroBranchRepositories.has(repoRel))).sort();
+  const retainedModifiedFiles = [.../* @__PURE__ */ new Set([...normalizedMergeBoundaryFiles, ...readiness.preservedFiles])].sort();
+  await store.updateTask(taskId, { modifiedFiles: retainedModifiedFiles });
+  task = { ...mergeBoundaryTask, modifiedFiles: retainedModifiedFiles };
+  const workspaceWorktrees = task.workspaceWorktrees ?? {};
+  const repoKeys = readiness.repositories;
   const repos = [];
   let allLanded = true;
   await setStatus("merging");
@@ -271135,7 +271397,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
         };
       } catch (error2) {
         if (error2 instanceof WorkspaceFenceRefError) {
-          throw new WorkspaceRepoLandBusyError(repoKeys[0] ?? "workspace", "workspace-merge-dispatch-fence", taskId);
+          throw new WorkspaceMergeTechnicalError("dispatch-fence-publication", `Workspace merge dispatch fence publication failed for ${taskId}: ${error2.message}`);
         }
         throw error2;
       }
@@ -271224,7 +271486,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
       } catch (error2) {
         if (durableLandLease) await store.releaseWorkspaceLease(durableLandLease).catch(() => void 0);
         if (error2 instanceof WorkspaceRepoLandBusyError) throw error2;
-        throw new WorkspaceRepoLandBusyError(repoRel, "durable-workspace-lease", taskId);
+        throw new WorkspaceMergeTechnicalError("durable-lease", `Workspace repository lease unavailable for ${repoRel}: ${getErrorMessage4(error2)}`);
       }
       try {
         activeSessionRegistry.registerPath(repoRootDir, {
@@ -271261,7 +271523,7 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
       renewalTimer?.unref?.();
       const landSignal = options.signal ? AbortSignal.any([options.signal, leaseAbort.signal]) : leaseAbort.signal;
       const assertLeaseLive = () => {
-        if (leaseLost || leaseAbort.signal.aborted) throw new WorkspaceRepoLandBusyError(repoRel, "durable-workspace-lease", taskId);
+        if (leaseLost || leaseAbort.signal.aborted) throw new WorkspaceMergeTechnicalError("durable-lease", `Workspace repository lease renewal was lost for ${repoRel}`);
       };
       try {
         const landResult = await landOneRepo(repoRootDir, entry.branch, integrationBranch, {
@@ -271346,11 +271608,11 @@ async function landWorkspaceTask(store, task, workspaceRootDir, options = {}, de
           repos.push({ repo: repoRel, repoRootDir, integrationBranch, branch: entry.branch, status: "empty" });
         }
       } catch (err) {
-        if (leaseLost) throw new WorkspaceRepoLandBusyError(repoRel, "durable-workspace-lease", taskId);
+        if (leaseLost) throw new WorkspaceMergeTechnicalError("durable-lease", `Workspace repository lease renewal was lost for ${repoRel}`);
         if (isMergeAbortedError(err)) throw err;
         if (err instanceof WorkspacePartialLandError) throw err;
         if (err instanceof WorkspaceFenceRefError) {
-          throw new WorkspaceRepoLandBusyError(repoRel, "workspace-merge-dispatch-fence", taskId);
+          throw new WorkspaceMergeTechnicalError("repository-fence-publication", `Workspace repository fence publication failed for ${repoRel}: ${err.message}`);
         }
         const message = getErrorMessage4(err);
         await log42(`AI merge (workspace): sub-repo ${repoRel} land failed: ${message}`);
@@ -276162,6 +276424,15 @@ ${detail}`);
             }
             continue;
           }
+          if (err instanceof WorkspaceMergeTechnicalError) {
+            await store.logEntry(taskId, `Workspace merge technical failure (${err.kind}): ${err.message}`, "WorkspaceMergeTechnicalFailure").catch(() => void 0);
+            if (hasManualResolver) {
+              this.rejectMergeResolvers(taskId, err);
+            } else if (!await this.maybeRetryTransientMerge(store, taskId, await store.getTask(taskId).catch(() => null), err.message, true)) {
+              await store.updateTask(taskId, { status: "failed", error: err.message }).catch(() => void 0);
+            }
+            continue;
+          }
           const isWorkspaceBusyError = err instanceof WorkspaceRepoLandBusyError || err instanceof WorkspaceMergeDispatchBusyError || err instanceof WorkspaceMergeDispatchSupersededError;
           if (isWorkspaceBusyError && hasManualResolver) {
             await store.logEntry(taskId, `Workspace sub-repo land busy (contention): ${errorMsg}`, "WorkspaceRepoLandBusy").catch(() => void 0);
@@ -276169,18 +276440,18 @@ ${detail}`);
             continue;
           }
           if (isWorkspaceBusyError && !hasManualResolver) {
-            const busyCount = this.workspaceBusyReenqueues.get(taskId) ?? 0;
+            const liveTask = await store.getTask(taskId).catch(() => null);
+            const busyCount = liveTask?.mergeTransientRetryCount ?? 0;
             await store.logEntry(taskId, `Workspace sub-repo land busy (contention): ${errorMsg}`, "WorkspaceRepoLandBusy").catch(() => void 0);
             if (busyCount < _ProjectEngine.WORKSPACE_BUSY_MAX_REENQUEUES) {
-              this.workspaceBusyReenqueues.set(taskId, busyCount + 1);
+              const nextCount = busyCount + 1;
               const delayMs = Math.min(5e3 * Math.pow(2, busyCount), 6e4);
-              await store.updateTask(taskId, { status: null }).catch(() => void 0);
+              await store.updateTask(taskId, { status: null, mergeTransientRetryCount: nextCount }).catch(() => void 0);
               runtimeLog.log(
-                `Workspace land busy re-enqueue ${busyCount + 1}/${_ProjectEngine.WORKSPACE_BUSY_MAX_REENQUEUES} for ${taskId} in ${delayMs / 1e3}s (no mergeRetry consumed \u2014 pure lease contention)`
+                `Workspace land busy re-enqueue ${nextCount}/${_ProjectEngine.WORKSPACE_BUSY_MAX_REENQUEUES} for ${taskId} in ${delayMs / 1e3}s (durable transient retry)`
               );
               this.scheduleWorkspaceBusyReenqueue(taskId, delayMs);
             } else {
-              this.workspaceBusyReenqueues.delete(taskId);
               await store.updateTask(taskId, { status: "failed", error: errorMsg }).catch(() => void 0);
               runtimeLog.error(
                 `Auto-merge: ${taskId} workspace land busy ${_ProjectEngine.WORKSPACE_BUSY_MAX_REENQUEUES} times \u2014 parked as failed (sustained sub-repo lease contention)`