@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-6KZKRTG3.js

@@ -0,0 +1,4885 @@
+import {
+  abortPendingSquashMerge,
+  acquireFlywheelApplyLock,
+  describeVerificationFailedStages,
+  failedOnlyOnUnavailableVerification,
+  readStagesUnverifiedDisposition,
+  renderWarn,
+  selectStageablePaths
+} from "./chunk-QDKYT4CI.js";
+import {
+  recordCompetitionOutcomeEvent,
+  resolveLatestEvaluationId
+} from "./chunk-TSQ256N5.js";
+import {
+  isNodeVerificationPath,
+  resolverVitestRun
+} from "./chunk-PHZGLQSK.js";
+import {
+  buildCompetitionOutcomeEvent
+} from "./chunk-YBHUB4XR.js";
+import {
+  openConfiguredTelemetryDb
+} from "./chunk-KHW3UD7B.js";
+import {
+  isRunnableProjectTestFile
+} from "./chunk-JOSK6GEU.js";
+import {
+  resolvePlanArtifactPath
+} from "./chunk-V3YFFHDR.js";
+import {
+  resolveGitMessageStyle
+} from "./chunk-3REDAJUJ.js";
+import {
+  beginManagedSync,
+  capCommitSubject,
+  codeCheckoutCarriesSharedBuckets,
+  publishManagedSync
+} from "./chunk-TRURQUBP.js";
+import {
+  countArchivedTasksForSprint,
+  getCurrentSprint,
+  listTasksInSprint,
+  refreshSprintMarkdown
+} from "./chunk-L2CBG5IX.js";
+import {
+  TaskNotFoundError,
+  applyTaskTransitionOutcome,
+  completeTask,
+  createTask,
+  deriveTransitionIdentity,
+  getTask,
+  restoreTask
+} from "./chunk-7LHJDJB3.js";
+import {
+  cleanupWorkflowRelatedBranchesAndWorktrees
+} from "./chunk-ES6NWJ36.js";
+import {
+  WorktreeManagerPresets
+} from "./chunk-57WRCJJW.js";
+import {
+  trackWorktreeCleaned
+} from "./chunk-UJYDH2MW.js";
+import {
+  listFlywheelBranches
+} from "./chunk-75EMT7BF.js";
+import {
+  getPlanningRoot,
+  withDeferredIndexRegeneration
+} from "./chunk-CSXLLEGB.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketByName,
+  getBucketPathByKind,
+  getBuckets
+} from "./chunk-V3KLVK7B.js";
+import {
+  isSystemWritePath
+} from "./chunk-XZOXEIN4.js";
+import {
+  getArtifactDir,
+  getArtifactDirForRoot,
+  getManifestStatus,
+  getProjectRoot,
+  getResultPath,
+  getTrackedCleanupTargets,
+  loadManifest,
+  loadTriage,
+  updateManifestApplyStatus
+} from "./chunk-6TRD7TEE.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import {
+  pruneGitWorktreeEntries
+} from "./chunk-33IGPPUI.js";
+import {
+  isWorktreeRunSentinelPath
+} from "./chunk-2NMNFUQA.js";
+import {
+  canonicalizeVariantIdentifier
+} from "./chunk-TGXXYDL4.js";
+import {
+  execGitChecked
+} from "./chunk-XHOI4V62.js";
+import {
+  detectResolverUnavailableSignal,
+  detectUnavailableSignal
+} from "./chunk-6TBEX4R4.js";
+import {
+  createVerificationCommandEnv
+} from "./chunk-S2E632FQ.js";
+import {
+  isRecord
+} from "./chunk-XJ2E7YEJ.js";
+import {
+  wrapWithSandbox
+} from "./chunk-B7YRSULE.js";
+import {
+  CURRENT_BRANCH_REV_PARSE_ARGS,
+  assertBranchAllowsCodeApply,
+  classifyBranchRole,
+  isDisposableBranchRole,
+  parseCurrentBranchRef
+} from "./chunk-XGU6PBO5.js";
+import {
+  buildConflictBranchName
+} from "./chunk-F55YABKV.js";
+import {
+  readTrackedToolOutputRoots,
+  shouldExcludeStatusPath
+} from "./chunk-5EQN56OZ.js";
+import {
+  classifyRepoPath,
+  normalizeRepoPath
+} from "./chunk-RBBTBCHX.js";
+import {
+  buildProjectVerificationGuidance,
+  deriveDependencySetupCommandsForVerification,
+  detectMissingInstallForVerification,
+  detectProjectCapabilities,
+  isAllowedVerifyCommand,
+  isBaselineComparableTypeScriptCommand,
+  isBiomeAvailableForTarget,
+  partitionVerifyCommands,
+  selectFailureOutputTail,
+  targetSignalsVitest,
+  verificationCommandsCoverChangedPaths
+} from "./chunk-AHU3FKPA.js";
+import {
+  isProjectTestPath
+} from "./chunk-RPIMAMV7.js";
+import {
+  parseGitStatus
+} from "./chunk-5KQETTNS.js";
+import {
+  TelemetryPathResolver,
+  isLabModeFromEnv
+} from "./chunk-C3KCMAJP.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  escapeShellArg
+} from "./chunk-HGFXODKO.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  isQuietOutputRequested
+} from "./chunk-XWIZ6B5S.js";
+import {
+  GIT_HOOK_COMMIT_TIMEOUT_MS
+} from "./chunk-I56TH7VM.js";
+import {
+  BUILD_AUTOMERGE_MODE,
+  BUILD_PRESERVE_WORKTREES,
+  emitCustomWarning,
+  emitWarning,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/planning/task-status-sync.ts
+function emitTaskStatusSyncWarning(message, metadata) {
+  emitCustomWarning(
+    "WARN" /* WARN */,
+    "validation" /* VALIDATION */,
+    message,
+    {
+      taskId: "task-status-sync",
+      subsystem: "planning/task-status-sync",
+      executionPhase: "execution"
+    },
+    { metadata, skipConsole: true }
+  );
+}
+async function calculateSprintProgress(sprintId) {
+  try {
+    const tasks = await listTasksInSprint(sprintId);
+    const [archivedTotal, archivedDone] = await Promise.all([
+      countArchivedTasksForSprint(sprintId),
+      countArchivedTasksForSprint(sprintId, "done")
+    ]);
+    const total = tasks.length + archivedTotal;
+    if (total === 0) return 0;
+    const completedTasks = tasks.filter((t) => t.status === "done");
+    return (completedTasks.length + archivedDone) / total * 100;
+  } catch {
+    return 0;
+  }
+}
+function formatSyncSummary(result) {
+  const lines = [];
+  lines.push(`Tasks updated: ${result.tasksUpdated}`);
+  lines.push(`Tasks completed: ${result.tasksCompleted}`);
+  lines.push(`Tasks already satisfied: ${result.tasksAlreadySatisfied}`);
+  lines.push(`Tasks failed: ${result.tasksFailed}`);
+  lines.push(`Tasks ephemeral (skipped): ${result.tasksEphemeral}`);
+  lines.push(`Sprint progress: ${result.sprintProgress.toFixed(1)}%`);
+  const sections = [
+    ["Skipped:", result.details.filter((d) => d.error && d.ephemeral)],
+    ["Errors:", result.details.filter((d) => d.error && !d.ephemeral)]
+  ];
+  for (const [heading, details] of sections) {
+    if (details.length === 0) continue;
+    lines.push("", heading);
+    for (const detail of details) {
+      lines.push(`  ${detail.taskId}: ${detail.error}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function applyTaskTransitions(sprintId, transitions, options) {
+  const details = [];
+  let tasksUpdated = 0;
+  let tasksCompleted = 0;
+  let tasksAlreadySatisfied = 0;
+  let tasksFailed = 0;
+  let tasksEphemeral = 0;
+  const statusPriority = {
+    done: 4,
+    review: 3,
+    in_progress: 2,
+    blocked: 1,
+    todo: 0
+  };
+  function mergeTransitionGroup(group, winner) {
+    const resultArtifactPath = winner.resultArtifactPath ?? group.find((t) => t.resultArtifactPath)?.resultArtifactPath;
+    const reason = winner.reason ?? group.find((t) => t.reason)?.reason;
+    return {
+      taskId: winner.taskId,
+      targetStatus: winner.targetStatus,
+      ...resultArtifactPath ? { resultArtifactPath } : {},
+      ...reason ? { reason } : {}
+    };
+  }
+  const deduplicatedTransitions = [];
+  const byTaskId = /* @__PURE__ */ new Map();
+  for (const t of transitions) {
+    const existing = byTaskId.get(t.taskId);
+    if (existing) {
+      existing.push(t);
+    } else {
+      byTaskId.set(t.taskId, [t]);
+    }
+  }
+  for (const [, group] of byTaskId) {
+    if (group.length === 1) {
+      deduplicatedTransitions.push({
+        merged: group[0],
+        constituents: group
+      });
+    } else {
+      const allSame = group.every((t) => t.targetStatus === group[0]?.targetStatus);
+      if (allSame) {
+        const winner = group[0];
+        deduplicatedTransitions.push({
+          merged: mergeTransitionGroup(group, winner),
+          constituents: group
+        });
+      } else {
+        const winner = group.reduce((best, t) => {
+          const bp = statusPriority[best.targetStatus] ?? 0;
+          const tp = statusPriority[t.targetStatus] ?? 0;
+          return tp > bp ? t : best;
+        });
+        const statuses = group.map((t) => t.targetStatus).join(", ");
+        emitTaskStatusSyncWarning(
+          `[task-status-sync] Conflicting transitions for task ${winner.taskId}: [${statuses}] - keeping "${winner.targetStatus}"`,
+          {
+            taskId: winner.taskId,
+            statuses: group.map((t) => t.targetStatus),
+            selectedStatus: winner.targetStatus,
+            operation: "deduplicate-transitions"
+          }
+        );
+        deduplicatedTransitions.push({
+          merged: mergeTransitionGroup(group, winner),
+          constituents: group
+        });
+      }
+    }
+  }
+  let sprintTaskIds = /* @__PURE__ */ new Set();
+  let sprintQueryable = true;
+  try {
+    const sprintTasks = await listTasksInSprint(sprintId);
+    sprintTaskIds = new Set(sprintTasks.map((task) => task.id));
+  } catch {
+    sprintQueryable = false;
+  }
+  const effectiveStatusOf = (targetStatus) => options?.promoteToDone && targetStatus === "review" ? "done" : targetStatus;
+  const routeDoneThroughCompleteTask = (effectiveTargetStatus) => options?.promoteToDone === true && effectiveTargetStatus === "done";
+  const ancillaryTargetStatus = (transition, task, effectiveTargetStatus) => {
+    if (!routeDoneThroughCompleteTask(effectiveTargetStatus)) {
+      return effectiveTargetStatus;
+    }
+    if (transition.targetStatus === "review") {
+      return "review";
+    }
+    return task.status;
+  };
+  const pendingCompletions = [];
+  let sprintProgress = await withDeferredIndexRegeneration(getPlanningRoot(), async () => {
+    for (const prepared of deduplicatedTransitions) {
+      const transition = prepared.merged;
+      const detail = {
+        taskId: transition.taskId,
+        previousStatus: "todo",
+        updated: false
+      };
+      try {
+        if (!sprintQueryable) {
+          detail.error = `Sprint artifact not queryable for ${sprintId}; transition skipped as ephemeral.`;
+          detail.ephemeral = true;
+          tasksEphemeral++;
+          details.push(detail);
+          continue;
+        }
+        if (!sprintTaskIds.has(transition.taskId)) {
+          if (options?.promoteToDone) {
+            try {
+              const archivedLookup = await getTask(transition.taskId, { includeArchive: true });
+              if (archivedLookup.isArchived) {
+                detail.previousStatus = archivedLookup.yaml.status;
+                detail.newStatus = "done";
+                tasksAlreadySatisfied++;
+                details.push(detail);
+                continue;
+              }
+            } catch {
+            }
+          }
+          detail.error = `Task ${transition.taskId} is not linked to sprint ${sprintId}; transition skipped as ephemeral.`;
+          detail.ephemeral = true;
+          tasksEphemeral++;
+          details.push(detail);
+          continue;
+        }
+        const { yaml: task, isArchived } = await getTask(transition.taskId, {
+          includeArchive: true
+        });
+        detail.previousStatus = task.status;
+        const effectiveTargetStatus = effectiveStatusOf(transition.targetStatus);
+        const finalizeViaCompleteTask = routeDoneThroughCompleteTask(effectiveTargetStatus);
+        if (finalizeViaCompleteTask && isArchived) {
+          detail.newStatus = "done";
+          tasksAlreadySatisfied++;
+          details.push(detail);
+          continue;
+        }
+        const outcomeTargetStatus = ancillaryTargetStatus(transition, task, effectiveTargetStatus);
+        const constituents = prepared.constituents.map((c) => ({
+          identity: deriveTransitionIdentity({
+            taskId: c.taskId,
+            targetStatus: effectiveStatusOf(c.targetStatus),
+            hoursLogged: c.hoursLogged,
+            resultArtifactPath: c.resultArtifactPath,
+            transitionId: c.transitionId
+          }),
+          hoursLogged: c.hoursLogged
+        }));
+        const outcome = await applyTaskTransitionOutcome(transition.taskId, {
+          targetStatus: outcomeTargetStatus,
+          resultArtifactPath: transition.resultArtifactPath,
+          reason: transition.reason,
+          constituents
+        });
+        if (outcome.hoursApplied > 0) {
+          detail.hoursLogged = outcome.hoursApplied;
+        }
+        if (finalizeViaCompleteTask) {
+          pendingCompletions.push({
+            taskId: transition.taskId,
+            detail,
+            previousStatus: task.status,
+            ancillaryFileUpdated: outcome.fileUpdated
+          });
+          details.push(detail);
+          continue;
+        }
+        detail.newStatus = effectiveTargetStatus;
+        if (outcome.unverifiedLabel) detail.unverifiedLabel = outcome.unverifiedLabel;
+        if (outcome.statusChanged) {
+          detail.updated = true;
+          tasksUpdated++;
+          if (effectiveTargetStatus === "done") {
+            tasksCompleted++;
+          }
+        } else {
+          detail.fileUpdated = outcome.fileUpdated;
+          tasksAlreadySatisfied++;
+        }
+        details.push(detail);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        const missingTask = error instanceof TaskNotFoundError && error.taskId === transition.taskId || error?.code === "ENOENT";
+        if (missingTask) {
+          detail.error = `Task artifact not queryable for ${transition.taskId}; transition skipped as ephemeral.`;
+          detail.ephemeral = true;
+          tasksEphemeral++;
+        } else {
+          detail.error = errorMsg;
+          tasksFailed++;
+        }
+        details.push(detail);
+      }
+    }
+    const progress = await calculateSprintProgress(sprintId);
+    try {
+      await refreshSprintMarkdown(sprintId);
+    } catch {
+    }
+    return progress;
+  });
+  const planningRoot = getPlanningRoot();
+  let completionsSucceeded = 0;
+  for (const pending of pendingCompletions) {
+    try {
+      const completion = await completeTask(pending.taskId, {
+        completionContractRoot: planningRoot
+      });
+      completionsSucceeded++;
+      pending.detail.previousStatus = pending.previousStatus;
+      pending.detail.newStatus = "done";
+      pending.detail.updated = true;
+      pending.detail.archivedPath = completion.archivedPath;
+      if (completion.unverifiedLabel) pending.detail.unverifiedLabel = completion.unverifiedLabel;
+      if (completion.unblockedTaskIds.length > 0) {
+        pending.detail.unblockedTaskIds = [...completion.unblockedTaskIds];
+      }
+      tasksUpdated++;
+      tasksCompleted++;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      pending.detail.error = errorMsg;
+      pending.detail.updated = false;
+      pending.detail.newStatus = "review";
+      if (pending.ancillaryFileUpdated) {
+        pending.detail.fileUpdated = true;
+      }
+      tasksFailed++;
+    }
+  }
+  if (completionsSucceeded > 0) {
+    sprintProgress = await calculateSprintProgress(sprintId);
+    try {
+      await refreshSprintMarkdown(sprintId);
+    } catch {
+    }
+  }
+  return {
+    tasksUpdated,
+    tasksCompleted,
+    tasksAlreadySatisfied,
+    tasksFailed,
+    tasksEphemeral,
+    sprintProgress,
+    details
+  };
+}
+
+// src/automation/flywheel-merge.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync } from "fs";
+import * as fs4 from "fs/promises";
+import * as os from "os";
+import * as path4 from "path";
+import chalk4 from "chalk";
+import { execa as execa2 } from "execa";
+import yaml from "js-yaml";
+
+// src/core/git/github-host-probe.ts
+var PROBE_TIMEOUT_MS = 1e4;
+function isNotGithubHostMessage(text) {
+  return /point to a known github host/i.test(text);
+}
+async function probeGithubHost(projectRoot, runner) {
+  try {
+    await runner("gh", ["repo", "view", "--json", "nameWithOwner"], {
+      cwd: projectRoot,
+      timeout: PROBE_TIMEOUT_MS,
+      env: { GH_PROMPT_DISABLED: "1" }
+    });
+    return "github";
+  } catch (error) {
+    const failure = error;
+    const text = [failure?.stderr, failure?.message].filter((part) => typeof part === "string").join("\n");
+    return isNotGithubHostMessage(text) ? "not-github" : "unknown";
+  }
+}
+
+// src/core/project/merge-normalization.ts
+import path from "path";
+var BIOME_SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".jsx",
+  ".ts",
+  ".cts",
+  ".mts",
+  ".tsx",
+  ".json",
+  ".jsonc",
+  ".css",
+  ".graphql",
+  ".gql"
+]);
+function filterBiomePaths(files) {
+  return files.filter((file) => BIOME_SUPPORTED_EXTENSIONS.has(path.extname(file).toLowerCase()));
+}
+function resolveMergeNormalization(root, stagedFiles) {
+  const available = isBiomeAvailableForTarget(root);
+  const files = filterBiomePaths(stagedFiles);
+  if (!available) {
+    return {
+      kind: "unavailable",
+      message: files.length > 0 ? `  Biome merge gate unavailable for this target (${files.length} Biome-lintable file(s) staged but the resolver does not declare Biome available); lint/format is verified by the resolver-derived commands.` : "  Biome merge gate unavailable for this target language (no Node lint surface); lint/format is verified by the resolver-derived commands."
+    };
+  }
+  if (files.length === 0) return { kind: "not-required" };
+  return {
+    kind: "available",
+    label: "Biome",
+    files,
+    safeWrite: { command: "npx", args: ["--no-install", "biome", "check", "--write", ...files] },
+    check: {
+      command: "npx",
+      args: ["--no-install", "biome", "check", "--max-diagnostics", "50", ...files]
+    },
+    // Unsafe fixes remain manual guidance, never an automatic operation.
+    manualFixCommand: `npx --no-install biome check --write --unsafe ${files.slice(0, 8).join(" ")}` + (files.length > 8 ? " ..." : ""),
+    manualFixCommitSubject: "chore: satisfy biome"
+  };
+}
+
+// src/automation/flywheel-contract-drift.ts
+var CROSS_SUBSTAGE_CONTRACT_DRIFT = "cross-substage contract drift";
+var DRIFT_PATTERNS = [
+  /expected\s+\{[^}]*\}\s+to\s+have\s+property\s+['"]length['"]/i,
+  /\w+\s*\.\s*map\s+is\s+not\s+a\s+function/i,
+  /\w+\s*\.\s*filter\s+is\s+not\s+a\s+function/i,
+  /\w+\s*\.\s*forEach\s+is\s+not\s+a\s+function/i,
+  /\w+\s*\.\s*reduce\s+is\s+not\s+a\s+function/i,
+  /\w+\s*\.\s*find\s+is\s+not\s+a\s+function/i,
+  /is\s+not\s+iterable/i,
+  /Cannot\s+read\s+propert(?:y|ies)\s+of\s+undefined.*\.\s*(?:length|map|filter|find|reduce)/i,
+  /TypeError.*\.\s*(?:map|filter|forEach|find|reduce)\s+is\s+not\s+a\s+function/i
+];
+var SYMBOL_EXTRACTION_PATTERN = /(\b\w+(?:\.\w+)*)\s*\.\s*(?:map|filter|forEach|find|reduce|length)\b/gi;
+function detectContractDrift(output) {
+  if (!output || typeof output !== "string") {
+    return { isDrift: false, symbols: [], matchedPatterns: [] };
+  }
+  const matchedPatterns = [];
+  for (const pattern of DRIFT_PATTERNS) {
+    if (pattern.test(output)) {
+      matchedPatterns.push(pattern.source);
+    }
+  }
+  if (matchedPatterns.length === 0) {
+    return { isDrift: false, symbols: [], matchedPatterns: [] };
+  }
+  const symbolSet = /* @__PURE__ */ new Set();
+  let match;
+  const extractor = new RegExp(SYMBOL_EXTRACTION_PATTERN.source, "gi");
+  match = extractor.exec(output);
+  while (match !== null) {
+    const sym = match[1];
+    if (sym && sym.length > 0 && sym !== "a" && sym !== "is") {
+      symbolSet.add(sym);
+    }
+    match = extractor.exec(output);
+  }
+  return {
+    isDrift: true,
+    symbols: [...symbolSet],
+    matchedPatterns
+  };
+}
+function formatContractDriftMessage(detection, failedCommand) {
+  if (!detection.isDrift) {
+    return "";
+  }
+  const symbolDesc = detection.symbols.length > 0 ? `Symbols involved: ${detection.symbols.slice(0, 5).join(", ")}.` : "Symbol name could not be extracted from output.";
+  return `Failure classification: ${CROSS_SUBSTAGE_CONTRACT_DRIFT}. A sibling substage generated tests asserting an incompatible return shape for a shared symbol. ${symbolDesc} Failed command: ${failedCommand}.`;
+}
+
+// src/automation/flywheel-merge-apply.ts
+import chalk from "chalk";
+import { execa } from "execa";
+var SquashMergeConflictError = class extends Error {
+  conflictFiles;
+  constructor(message, conflictFiles) {
+    super(message);
+    this.name = "SquashMergeConflictError";
+    this.conflictFiles = conflictFiles;
+  }
+};
+function formatPathList(paths, max = 8) {
+  const shown = paths.slice(0, max);
+  const suffix = paths.length > shown.length ? ` ... (+${paths.length - shown.length} more)` : "";
+  return shown.join(", ") + suffix;
+}
+async function squashMergeRunBranch(params) {
+  const { cwd, integrationBranch } = params;
+  console.log(chalk.cyan("  Squash-merging run branch..."));
+  const mergeResult = await execa("git", ["merge", "--squash", integrationBranch], {
+    cwd,
+    stdio: "pipe",
+    timeout: 6e4,
+    reject: false
+  });
+  if (mergeResult.timedOut) {
+    throw new Error("Squash merge timed out after 60000ms");
+  }
+  if (mergeResult.exitCode !== 0) {
+    if (mergeResult.exitCode === 128) {
+      const fatalMsg = (mergeResult.stderr ?? "").trim() || "Fatal git error during squash merge";
+      throw new Error(`Fatal git error: ${fatalMsg}`);
+    }
+    if (mergeResult.exitCode !== 1) {
+      const genericMsg = (mergeResult.stderr ?? "").trim() || `Squash merge failed with exit code ${mergeResult.exitCode}`;
+      throw new Error(`Squash merge failed: ${genericMsg}`);
+    }
+    const { stdout: conflictStdout } = await execa(
+      "git",
+      ["diff", "--name-only", "--diff-filter=U"],
+      {
+        cwd,
+        stdio: "pipe",
+        timeout: 3e4,
+        reject: false
+      }
+    );
+    const conflicts = conflictStdout.split("\n").map((l) => l.trim()).filter(Boolean);
+    const msg = `Squash-merge failed due to conflicts (${conflicts.length}).
+Conflicts: ${conflicts.length > 0 ? formatPathList(conflicts) : "(unknown)"}`;
+    throw new SquashMergeConflictError(msg, conflicts);
+  }
+  if (mergeResult.stdout) process.stdout.write(mergeResult.stdout);
+  if (mergeResult.stderr) process.stderr.write(mergeResult.stderr);
+}
+var PlanningSnapshotError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlanningSnapshotError";
+  }
+};
+async function snapshotDirtyPlanningPaths(params) {
+  const { cwd, allowlistPrefixes } = params;
+  const status = await execa(
+    "git",
+    ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...allowlistPrefixes],
+    { cwd, stdio: "pipe", timeout: 3e4, reject: false }
+  );
+  if (status.timedOut || status.failed === true || status.exitCode !== void 0 && status.exitCode !== 0) {
+    throw new PlanningSnapshotError(
+      `git status failed while snapshotting planning paths (exit ${status.exitCode ?? "none"}): ${String(status.stderr ?? "").trim()}`
+    );
+  }
+  const dirty = /* @__PURE__ */ new Set();
+  const fields = status.stdout.split("\0");
+  for (let i = 0; i < fields.length; i++) {
+    const entry = fields[i];
+    if (entry === void 0 || entry.length < 4) continue;
+    const x = entry[0];
+    const y = entry[1];
+    dirty.add(entry.slice(3));
+    if (x === "R" || x === "C" || y === "R" || y === "C") {
+      const source = fields[i + 1];
+      if (source !== void 0 && source.length > 0) {
+        dirty.add(source);
+      }
+      i++;
+    }
+  }
+  return dirty;
+}
+async function snapshotStageablePlanningPaths(params) {
+  const status = await execGitChecked(
+    ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...params.allowlistPrefixes],
+    { cwd: params.cwd, timeoutMs: 3e4 }
+  );
+  return new Set(selectStageablePaths(status.stdout));
+}
+
+// src/automation/flywheel-merge-commit.ts
+var FlywheelCommitError = class extends Error {
+  phase;
+  constructor(phase, message) {
+    super(message);
+    this.name = "FlywheelCommitError";
+    this.phase = phase;
+  }
+};
+var OUTPUT_TAIL_LINES = 40;
+function indentedTail(output) {
+  return output.split(/\r?\n/).filter((line) => line.trim().length > 0).slice(-OUTPUT_TAIL_LINES).map((line) => `  ${line}`).join("\n");
+}
+function describeFailure(error) {
+  const failure = error ?? {};
+  const text = (value) => typeof value === "string" ? value : "";
+  const reason = failure.timedOut ? "timed out; a commit hook may be hanging" : typeof failure.exitCode === "number" ? `exit code ${failure.exitCode}` : (text(failure.message).split("\n")[0] ?? "") || "could not run";
+  return { reason, output: [text(failure.stderr), text(failure.stdout)].join("\n").trim() };
+}
+function formatFlywheelCommitRecovery(params) {
+  const rerun = `rerun \`build run flywheel merge-result ${params.workflowId} --force\`. --force retries this candidate; it does not skip verification or your commit hooks.`;
+  if (!params.staged) return `Resolve the git error above, then ${rerun}`;
+  const restore = params.restoreSha ? `restore the checkout to ${params.restoreSha.slice(0, 12)}` : "restore the checkout to its pre-merge state";
+  return `The merged changes remain staged at ${params.cwd}. Resolve the git error above, ${restore} (keep any edits you still need), then ${rerun}`;
+}
+async function runFlywheelCommit(params) {
+  try {
+    await params.run();
+  } catch (error) {
+    const { reason, output } = describeFailure(error);
+    const label = params.phase === "code" ? "merge-result commit" : "task/sprint metadata commit";
+    const lines = [`Commit failed: git did not create the ${label} (${reason}).`];
+    if (params.quiet && output) lines.push("git output:", indentedTail(output));
+    if (params.priorCommit) {
+      lines.push(
+        `The changes for the ${label} remain staged at ${params.cwd}, and the earlier commit is kept.`
+      );
+    }
+    if (params.style !== "conventional") {
+      lines.push(
+        "If the repository enforces Conventional Commits, set git.messageStyle to conventional (build config set git.messageStyle conventional)."
+      );
+    }
+    throw new FlywheelCommitError(params.phase, lines.join("\n"));
+  }
+}
+var MAX_LISTED_PATHS = 10;
+async function readStagedTree(cwd) {
+  const result = await execGit(["write-tree"], { cwd, timeoutMs: 3e4 });
+  const tree = result.stdout.trim();
+  return result.exitCode === 0 && /^[0-9a-f]{40,64}$/u.test(tree) ? tree : void 0;
+}
+async function describeCommitChangedTree(params) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const commit of params.commits) {
+    const diff = await execGit(
+      ["diff", "--name-only", "-z", "--no-renames", commit.preCommitTree, `${commit.sha}^{tree}`],
+      { cwd: params.cwd, timeoutMs: 3e4 }
+    );
+    if (diff.exitCode !== 0) continue;
+    for (const entry of diff.stdout.split("\0")) {
+      if (entry) changed.add(entry);
+    }
+  }
+  const head = params.commits.at(-1);
+  if (changed.size === 0 || !head) return void 0;
+  const paths = [...changed];
+  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
+  const more = paths.length > MAX_LISTED_PATHS ? ` and ${paths.length - MAX_LISTED_PATHS} more` : "";
+  const onBranch = params.branch ? ` of branch ${params.branch}` : "";
+  const discard = params.restoreSha ? `, or restore the branch to ${params.restoreSha.slice(0, 12)} to discard it` : "";
+  return `${params.headline ?? "Committed HEAD tree does not match the final verified tree."} These files changed during the commit; a hook may have changed them: ${listed}${more}. Commit ${head.sha} is HEAD${onBranch}. Workflow ${params.workflowId} is not marked applied, and Build did not re-verify the changed tree. Review the commit and keep it${discard}.`;
+}
+
+// src/automation/flywheel-merge-commit-message.ts
+var MERGE_SUBJECT = {
+  plain: "Merge Build workflow result",
+  conventional: "chore(build): merge workflow result"
+};
+var METADATA_SUBJECT = {
+  plain: "Sync task and sprint metadata",
+  conventional: "chore(build): sync task and sprint metadata"
+};
+var LEGACY_METADATA_SUBJECT = "chore: sync task/sprint metadata [flywheel]";
+function flywheelMergeCommitSubject(style) {
+  return capCommitSubject(MERGE_SUBJECT[style]);
+}
+function flywheelMetadataCommitSubject(style) {
+  return capCommitSubject(METADATA_SUBJECT[style]);
+}
+function legacyFlywheelMergeCommitSubject(workflowId) {
+  return `[Build Flywheel] Merge workflow result ${workflowId}`;
+}
+function isFlywheelMergeCommitSubject(subject, workflowId) {
+  return subject === legacyFlywheelMergeCommitSubject(workflowId) || subject === flywheelMergeCommitSubject("plain") || subject === flywheelMergeCommitSubject("conventional");
+}
+function isFlywheelMetadataCommitSubject(subject) {
+  return subject === LEGACY_METADATA_SUBJECT || subject === flywheelMetadataCommitSubject("plain") || subject === flywheelMetadataCommitSubject("conventional");
+}
+
+// src/automation/flywheel-merge-failed-run.ts
+import fs from "fs/promises";
+async function readRecordedFailure(resultPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await fs.readFile(resultPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const result = parsed;
+  if (result.success === false) return "recorded a failed outcome";
+  if (result.materialized === false) return "did not materialize its result";
+  return null;
+}
+async function assertFailedRunHasCodeToApply(gate, resultPath) {
+  const reason = gate?.passed === false && gate.blockingStageIds.length > 0 ? `failed its gate (${gate.reason})` : await readRecordedFailure(resultPath);
+  if (!reason) return;
+  throw new Error(`Workflow ${reason} and produced no code to commit; nothing was applied.`);
+}
+
+// src/automation/flywheel-merge-outcomes.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function listAppliedCompetitionStages(result) {
+  if (!isRecord2(result) || !Array.isArray(result.stageResults)) return [];
+  const stages = [];
+  for (const stage of result.stageResults) {
+    if (!isRecord2(stage) || stage.stageType !== "competition") continue;
+    if (stage.winnerApplied !== true || stage.winnerNoOp === true) continue;
+    const taskId = nonEmpty(stage.competitionTaskId);
+    const winner = isRecord2(stage.winner) ? stage.winner : void 0;
+    const spec = winner && isRecord2(winner.variant) ? winner.variant : void 0;
+    const provider = nonEmpty(spec?.provider);
+    if (!taskId || !provider) continue;
+    const model = nonEmpty(spec?.model);
+    const effort = normalizeReasoningEffortInput(spec?.reasoning);
+    const effortSegment = effort ? `:effort-${effort}` : "";
+    const winnerId = canonicalizeVariantIdentifier({
+      variant: `${provider}:${model ?? "default"}${effortSegment}`,
+      provider,
+      ...model ? { model } : {},
+      executionMode: "local"
+    });
+    stages.push({ stageId: nonEmpty(stage.stageId) ?? "(unknown)", taskId, winnerId });
+  }
+  return stages;
+}
+function recordAppliedStageOutcomes(db, input) {
+  let recorded = 0;
+  for (const stage of listAppliedCompetitionStages(input.result)) {
+    const evaluationId = resolveLatestEvaluationId(db, input.projectId, stage.taskId);
+    if (!evaluationId) continue;
+    const event = buildCompetitionOutcomeEvent({
+      eventType: "completion_applied",
+      competitionId: stage.taskId,
+      taskId: stage.taskId,
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      finalJudgeWinner: { canonicalKey: stage.winnerId },
+      appliedArtifact: {
+        kind: "variant",
+        identity: stage.winnerId,
+        variantId: stage.winnerId,
+        ...input.targetBranch ? { branch: input.targetBranch } : {},
+        ...input.commitSha ? { commitSha: input.commitSha } : {}
+      }
+    });
+    const inserted = recordCompetitionOutcomeEvent(db, {
+      projectId: input.projectId,
+      evaluationId,
+      outcomeKind: "applied",
+      event,
+      commitSha: input.commitSha ?? null,
+      metadata: {
+        mode: "flywheel-merge-result",
+        workflowId: input.workflowId,
+        stageId: stage.stageId,
+        appliedVariant: stage.winnerId,
+        ...input.targetBranch ? { targetBranch: input.targetBranch } : {}
+      }
+    });
+    if (inserted) recorded += 1;
+  }
+  return recorded;
+}
+async function recordWorkflowCompetitionOutcomes(input) {
+  try {
+    const result = JSON.parse(await fs2.readFile(getResultPath(input.workflowId), "utf-8"));
+    if (listAppliedCompetitionStages(result).length === 0) return;
+    const projectId = TelemetryPathResolver.getInstance().getProjectId(
+      path2.join(getProjectRoot(), ".build-project"),
+      { register: false }
+    );
+    const { db } = openConfiguredTelemetryDb({ writable: true });
+    if (!db) return;
+    try {
+      recordAppliedStageOutcomes(db, { ...input, projectId, result });
+    } finally {
+      db.close();
+    }
+  } catch {
+  }
+}
+
+// src/automation/flywheel-merge-retry.ts
+async function detectFailedApplyCorrection(params) {
+  const { cwd, integrationBranch, applyFailedIntegrationSha } = params;
+  if (!applyFailedIntegrationSha) return { corrected: false, commits: [] };
+  const ancestry = await execGit(
+    ["merge-base", "--is-ancestor", applyFailedIntegrationSha, integrationBranch],
+    { cwd, timeoutMs: 3e4 }
+  );
+  if (ancestry.exitCode !== 0) return { corrected: false, commits: [] };
+  const range = `${applyFailedIntegrationSha}..${integrationBranch}`;
+  const count = await execGit(["rev-list", "--count", range], { cwd, timeoutMs: 3e4 });
+  const commitsPast = count.exitCode === 0 ? Number.parseInt(count.stdout.trim(), 10) : 0;
+  if (!Number.isFinite(commitsPast) || commitsPast <= 0) return { corrected: false, commits: [] };
+  const log = await execGit(["log", "--reverse", "--format=%h %s", range], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  const commits = log.exitCode === 0 ? log.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0) : [];
+  return { corrected: true, commits };
+}
+async function resolveIntegrationTipForRecovery(cwd, branch) {
+  if (!branch) return void 0;
+  try {
+    const tip = await execGit(["rev-parse", branch], { cwd, timeoutMs: 1e4 });
+    return tip.exitCode === 0 ? tip.stdout.trim() || void 0 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function reconciliationApplyTarget(manifest) {
+  return manifest.branchRoleRefused ? void 0 : manifest.applyTargetBranch ?? void 0;
+}
+
+// src/automation/flywheel-merge-signal.ts
+import { randomUUID } from "crypto";
+function registerMergeSignalFinalizer(workflowId) {
+  const controller = new AbortController();
+  const cleanupName = `FlywheelMerge:${workflowId}:${randomUUID()}`;
+  let settle = () => {
+  };
+  const settled = new Promise((resolve2) => {
+    settle = resolve2;
+  });
+  signalCoordinator.register(
+    cleanupName,
+    async ({ reason }) => {
+      if (reason !== "SIGINT" && reason !== "SIGTERM") return;
+      controller.abort(new Error(`Merge-result cancelled by ${reason}`));
+      await settled;
+    },
+    // Stash restore may need apply + list + drop, each with its existing timeout.
+    { priority: "critical", phase: "rollback", budgetMs: 12e4 }
+  );
+  return {
+    signal: controller.signal,
+    finish: () => {
+      settle();
+      signalCoordinator.unregister(cleanupName);
+    }
+  };
+}
+
+// src/automation/flywheel-merge-stash-outcome.ts
+import chalk2 from "chalk";
+async function collectUnmergedPaths(cwd) {
+  const unmerged = await execGit(["diff", "--name-only", "--diff-filter=U"], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  if (unmerged.exitCode !== 0) return [];
+  return unmerged.stdout.split("\n").map((entry) => entry.trim()).filter(Boolean);
+}
+function describeUnrestoredAutoStash(params) {
+  const { reason, stashSha, conflictPaths = [] } = params;
+  return `Auto-stashed changes were NOT restored: ${reason}. The stash is preserved${stashSha ? ` at ${stashSha}` : ""}` + (conflictPaths.length > 0 ? `, and these paths are left unmerged in the checkout: ${conflictPaths.join(", ")}` : "") + (stashSha ? `. Recover manually with: git stash apply ${stashSha}` : '. Recover manually with: git stash list | grep "Build Flywheel"');
+}
+function describeRetainedAutoStash(stashSha) {
+  return describeUnrestoredAutoStash({
+    reason: "the staged merge was left in the checkout",
+    stashSha
+  });
+}
+function reportMergeOutcome(warnings) {
+  if (warnings.length === 0) {
+    console.log(chalk2.bold.green("\nMerge complete!\n"));
+    return;
+  }
+  console.log(
+    chalk2.bold.yellow(
+      `
+Merge applied with ${warnings.length} warning(s) - review the warnings above.
+`
+    )
+  );
+}
+
+// src/automation/flywheel-post-merge-unavailable.ts
+function classifyPostMergeVerifyUnavailable(failed, checkoutRoot) {
+  if (failed.exitCode === 0) return void 0;
+  const output = failed.outputTail ?? `${failed.stdoutTail ?? ""}
+${failed.stderrTail ?? ""}`;
+  const detect = failed.complete === false ? detectUnavailableSignal : detectResolverUnavailableSignal;
+  const signal = detect(failed.command, output, failed.exitCode);
+  if (signal?.unavailableReason === "zero_tests" || failed.unavailableReason === "zero_tests") {
+    return {
+      reason: signal?.message ?? "Verification unavailable: the command ran no tests.",
+      setupCommands: [],
+      emptyRun: true
+    };
+  }
+  const reason = signal?.message ?? detectMissingInstallForVerification(checkoutRoot, failed.command, output, failed.exitCode) ?? (failed.unavailable ? "Verification tool unavailable: the command could not be launched." : void 0);
+  if (!reason) return void 0;
+  return {
+    reason,
+    setupCommands: deriveDependencySetupCommandsForVerification(checkoutRoot, failed.command)
+  };
+}
+function describePostMergeVerifySetup(unavailable) {
+  if (unavailable.emptyRun) {
+    return "The command executed no tests on the merged tree, so it verified nothing. Check what it selects, then retry.";
+  }
+  return unavailable.setupCommands.length > 0 ? `Build does not install into your checkout. Install the dependencies there (${unavailable.setupCommands.join("; ")}), then retry.` : "Build does not install into your checkout, and the project resolver derives no install command for this command. Install its dependencies there, then retry.";
+}
+
+// src/automation/flywheel-task-transitions.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import chalk3 from "chalk";
+function readArrayField(obj, key) {
+  const value = obj[key];
+  return Array.isArray(value) ? value : void 0;
+}
+function readStringField(obj, key) {
+  const value = obj[key];
+  return typeof value === "string" ? value : void 0;
+}
+var VALID_TASK_TRANSITION_STATUSES = /* @__PURE__ */ new Set([
+  "todo",
+  "in_progress",
+  "review",
+  "done",
+  "blocked"
+]);
+function extractTaskTransitionsFromResult(parsed) {
+  if (!isRecord(parsed)) return null;
+  const stageResults = readArrayField(parsed, "stageResults");
+  const allTransitions = [];
+  const collectTransitions = (transitions) => {
+    if (!Array.isArray(transitions)) return;
+    for (const transition of transitions) {
+      if (!isRecord(transition)) continue;
+      const taskId = readStringField(transition, "taskId");
+      const targetStatus = readStringField(transition, "targetStatus");
+      if (!taskId || !targetStatus) continue;
+      if (!VALID_TASK_TRANSITION_STATUSES.has(targetStatus)) {
+        console.log(
+          chalk3.yellow(
+            `  Warning: Skipping task transition for ${taskId}: invalid targetStatus '${targetStatus}'`
+          )
+        );
+        continue;
+      }
+      const hoursLogged = typeof transition.hoursLogged === "number" ? transition.hoursLogged : void 0;
+      const reason = readStringField(transition, "reason");
+      const resultArtifactPath = readStringField(transition, "resultArtifactPath");
+      const transitionId = readStringField(transition, "transitionId");
+      allTransitions.push({
+        taskId,
+        targetStatus,
+        hoursLogged,
+        reason,
+        ...resultArtifactPath ? { resultArtifactPath } : {},
+        ...transitionId ? { transitionId } : {}
+      });
+    }
+  };
+  for (const stageResult of stageResults ?? []) {
+    if (!isRecord(stageResult)) continue;
+    collectTransitions(readArrayField(stageResult, "taskTransitions"));
+  }
+  collectTransitions(readArrayField(parsed, "taskTransitions"));
+  return allTransitions.length > 0 ? allTransitions : null;
+}
+async function loadRecordedTaskTransitions(workflowId, sprintId) {
+  let workflowResult;
+  try {
+    workflowResult = JSON.parse(await fs3.readFile(getResultPath(workflowId), "utf-8"));
+  } catch (error) {
+    console.log(
+      chalk3.yellow(
+        `  Warning: Failed to load workflow result for status sync: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+  const transitions = extractTaskTransitionsFromResult(workflowResult);
+  if (transitions) return transitions;
+  emitWarning(
+    "FM-002",
+    { taskId: sprintId, subsystem: "flywheel-merge", executionPhase: "cleanup" },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: { workflowId, sprintId, operation: "task-transition-artifact-missing" }
+    }
+  );
+  console.log(
+    chalk3.yellow(
+      `  Warning: taskTransitions artifact missing for sprint workflow '${sprintId}'. Legacy task-status sync skipped (stageIds are not task IDs for sprint workflows). Ensure sprint-bridge.ts populates taskTransitions on stageResults.`
+    )
+  );
+  return null;
+}
+async function applyVerifiedTaskCompletions(sprintId, transitions) {
+  return applyTaskTransitions(sprintId, transitions, { promoteToDone: true });
+}
+function summarizeTaskSyncFailures(result) {
+  if (result.tasksFailed <= 0) return void 0;
+  return {
+    count: result.tasksFailed,
+    details: (result.details ?? []).filter((detail) => detail.error !== void 0).map((detail) => ({ taskId: detail.taskId, error: detail.error ?? "unknown error" }))
+  };
+}
+function reportTaskSyncFailures(params) {
+  const failures = summarizeTaskSyncFailures(params.result);
+  if (!failures) return void 0;
+  params.onWarning(
+    `  Warning: ${failures.count} task transition(s) failed (merge still succeeded):
+` + failures.details.map((d) => `    - ${d.taskId}: ${d.error}`).join("\n")
+  );
+  emitWarning(
+    "FM-001",
+    { subsystem: "flywheel", taskId: params.workflowId },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        type: "task_sync_partial_failure",
+        workflowId: params.workflowId,
+        tasksFailed: failures.count,
+        failedTaskIds: failures.details.map((d) => d.taskId)
+      }
+    }
+  );
+  return failures;
+}
+async function adoptStatusWriteTreeDelta(cwd, expectedTreeFingerprint, stagedStatusWritePaths) {
+  const current = await execGit(["write-tree"], { cwd, timeoutMs: 3e4 });
+  const candidate = current.stdout.trim();
+  if (current.exitCode !== 0 || candidate.length === 0) {
+    throw new Error("Could not fingerprint the staged tree after task status transitions.");
+  }
+  if (candidate === expectedTreeFingerprint) return expectedTreeFingerprint;
+  const allowed = new Set([...stagedStatusWritePaths].map(normalizeRepoPath));
+  const changed = await execGit(["diff", "--name-only", expectedTreeFingerprint, candidate], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  const changedPaths = changed.stdout.split("\n").map((entry) => entry.trim()).filter(Boolean);
+  if (changed.exitCode !== 0 || changedPaths.length === 0 || changedPaths.some((pathname) => !allowed.has(normalizeRepoPath(pathname)))) {
+    throw new Error(
+      "Task status transitions changed content outside this apply's staged task/sprint status-write targets after final verification; refusing to commit or report apply success."
+    );
+  }
+  return candidate;
+}
+function bucketRelative(mergeCwd, bucketPath) {
+  return path3.relative(mergeCwd, bucketPath).replace(/\\/g, "/");
+}
+function taskActivePath(mergeCwd, taskId) {
+  const taskPrefix = bucketRelative(mergeCwd, getBucketPathByKind("task", mergeCwd));
+  return `${taskPrefix}/${taskId}.md`;
+}
+function dirtyArchivePathsForId(dirtyPaths, archivePrefix, id) {
+  const suffix = `/${id}.md`;
+  return [...dirtyPaths].filter(
+    (pathname) => pathname.startsWith(`${archivePrefix}/`) && pathname.endsWith(suffix)
+  );
+}
+function wroteThisRun(detail) {
+  return detail.updated || detail.fileUpdated === true;
+}
+function buildTaskSyncTargetCandidates(params) {
+  const { mergeCwd, sprintId, details, dirtyAfterSync } = params;
+  const sprintPrefix = bucketRelative(mergeCwd, getBucketPathByKind("sprint", mergeCwd));
+  const sprintArchivePrefix = bucketRelative(
+    mergeCwd,
+    getBucketArchivePathByKind("sprint", mergeCwd)
+  );
+  const candidates = /* @__PURE__ */ new Set([
+    `${sprintPrefix}/${sprintId}.md`,
+    ...dirtyArchivePathsForId(dirtyAfterSync, sprintArchivePrefix, sprintId)
+  ]);
+  for (const detail of details) {
+    if (!wroteThisRun(detail)) continue;
+    candidates.add(taskActivePath(mergeCwd, detail.taskId));
+    if (detail.archivedPath !== void 0 && detail.archivedPath.length > 0) {
+      candidates.add(bucketRelative(mergeCwd, detail.archivedPath));
+    }
+    for (const unblockedId of detail.unblockedTaskIds ?? []) {
+      candidates.add(taskActivePath(mergeCwd, unblockedId));
+    }
+  }
+  return candidates;
+}
+function buildResumeClaimCandidates(params) {
+  const { mergeCwd, sprintId, transitions, dirty } = params;
+  const claimed = buildTaskSyncTargetCandidates({
+    mergeCwd,
+    sprintId,
+    details: [],
+    dirtyAfterSync: dirty
+  });
+  const taskArchivePrefix = bucketRelative(mergeCwd, getBucketArchivePathByKind("task", mergeCwd));
+  for (const transition of transitions) {
+    claimed.add(taskActivePath(mergeCwd, transition.taskId));
+    for (const archived of dirtyArchivePathsForId(dirty, taskArchivePrefix, transition.taskId)) {
+      claimed.add(archived);
+    }
+  }
+  return claimed;
+}
+function describeUnreconciledTaskSync(params) {
+  const { mergeCwd, details, dirtyAfterSync } = params;
+  const taskArchivePrefix = bucketRelative(mergeCwd, getBucketArchivePathByKind("task", mergeCwd));
+  const taskIds = details.filter((detail) => !wroteThisRun(detail)).filter(
+    (detail) => dirtyAfterSync.has(taskActivePath(mergeCwd, detail.taskId)) && dirtyArchivePathsForId(dirtyAfterSync, taskArchivePrefix, detail.taskId).length > 0
+  ).map((detail) => detail.taskId);
+  if (taskIds.length === 0) return void 0;
+  return `Task sync incomplete: ${taskIds.join(", ")} - uncommitted content exists in both the active and archive location, and this apply did not write it. Those files were left untouched and are not part of this commit; reconcile them manually before re-running merge.`;
+}
+function selectTaskSyncStagePaths(params) {
+  const { dirtyAfterSync, syncTargetCandidates } = params;
+  return [...dirtyAfterSync].filter((pathname) => syncTargetCandidates.has(pathname));
+}
+async function reopenTasksArchivedWithoutCommit(details) {
+  const warnings = [];
+  for (const detail of details) {
+    if (!detail.archivedPath) continue;
+    try {
+      await restoreTask(detail.taskId, { status: "review" });
+    } catch (error) {
+      warnings.push(
+        `Task ${detail.taskId} was archived as done but the apply commit failed; reopen it manually (${error instanceof Error ? error.message : String(error)}).`
+      );
+    }
+  }
+  return warnings;
+}
+function unclaimedStorageResidue(mergeCwd, dirty, claimed) {
+  const prefixes = [];
+  const localArchives = [];
+  for (const kind of ["task", "sprint"]) {
+    const activePrefix = bucketRelative(mergeCwd, getBucketPathByKind(kind, mergeCwd));
+    const archivePrefix = bucketRelative(mergeCwd, getBucketArchivePathByKind(kind, mergeCwd));
+    prefixes.push(`${activePrefix}/`, `${archivePrefix}/`);
+    if (getBucketByName(kind, mergeCwd)?.archivePublished === false) {
+      localArchives.push(`${archivePrefix}/`);
+    }
+  }
+  return [...dirty].filter(
+    (pathname) => !claimed.has(pathname) && prefixes.some((prefix) => pathname.startsWith(prefix)) && !localArchives.some((prefix) => pathname.startsWith(prefix))
+  );
+}
+async function publishCompletionToStorage(params, completion) {
+  const { workflowId, sprintId, mergeCwd } = params;
+  const fail = (paths, error) => {
+    const reason = error instanceof Error ? error.message : String(error);
+    completion.publication = { outcome: "failed", paths, reason };
+    const message = `Task completion not published to planning storage (${reason})` + (paths.length > 0 ? `; these writes remain uncommitted in the storage worktree: ${paths.join(", ")}` : "");
+    params.onWarning(`  Warning: ${message}`);
+    completion.warnings.push(message);
+    return void 0;
+  };
+  let ctx;
+  let storageDirty;
+  try {
+    ctx = await beginManagedSync(mergeCwd);
+    storageDirty = await snapshotDirtyPlanningPaths({
+      cwd: ctx.storageRoot,
+      allowlistPrefixes: []
+    });
+  } catch (error) {
+    return fail([], error);
+  }
+  const storageRoot = ctx.storageRoot;
+  const dirty = new Set(
+    [...storageDirty].map((pathname) => bucketRelative(mergeCwd, path3.join(storageRoot, pathname)))
+  );
+  const candidates = buildTaskSyncTargetCandidates({
+    mergeCwd,
+    sprintId,
+    details: completion.details,
+    dirtyAfterSync: dirty
+  });
+  if (params.resume) {
+    for (const claimed of buildResumeClaimCandidates({
+      mergeCwd,
+      sprintId,
+      transitions: params.transitions,
+      dirty
+    })) {
+      candidates.add(claimed);
+    }
+    completion.unclaimedStoragePaths = unclaimedStorageResidue(mergeCwd, dirty, candidates);
+  }
+  const owned = selectTaskSyncStagePaths({
+    dirtyAfterSync: dirty,
+    syncTargetCandidates: candidates
+  });
+  for (const detail of completion.details) {
+    if (!wroteThisRun(detail) || !detail.archivedPath) continue;
+    const archived = bucketRelative(mergeCwd, detail.archivedPath);
+    if (!owned.includes(archived)) owned.push(archived);
+  }
+  if (owned.length === 0) return dirty;
+  try {
+    await params.assertApplyLockOwned();
+    const published = await publishManagedSync(ctx, {
+      paths: owned,
+      message: `chore: sync task/sprint metadata [flywheel] (${workflowId})`,
+      // The pending line is rendered once, below, through the merge warnings.
+      reportPending: "caller"
+    });
+    completion.publication = {
+      outcome: published.publishOutcome,
+      paths: owned,
+      ...published.reason ? { reason: published.reason } : {},
+      ...published.pendingRef ? { pendingRef: published.pendingRef } : {}
+    };
+    if (published.pendingWarning) {
+      params.onWarning(`  Warning: Task completion: ${published.pendingWarning}`);
+      completion.warnings.push(`Task completion: ${published.pendingWarning}`);
+    } else if (published.publishOutcome === "published") {
+      params.onInfo(`  Task completion published to planning storage (${owned.length} path(s))`);
+    } else {
+      const reason = published.reason ?? "nothing to publish";
+      params.onInfo(`  Task completion not published: ${reason}`);
+    }
+    if (published.localByPolicyPaths.length > 0) {
+      params.onInfo(`  Kept local by archive policy: ${published.localByPolicyPaths.join(", ")}`);
+    }
+  } catch (error) {
+    return fail(owned, error);
+  }
+  return dirty;
+}
+async function completeAndStageVerifiedTasks(params) {
+  const { workflowId, sprintId, mergeCwd } = params;
+  const completion = { details: [], stagedPaths: [], warnings: [] };
+  try {
+    await params.assertApplyLockOwned();
+    const syncResult = await applyVerifiedTaskCompletions(sprintId, params.transitions);
+    completion.details = syncResult.details ?? [];
+    params.onInfo(formatSyncSummary(syncResult));
+    completion.failures = reportTaskSyncFailures({
+      workflowId,
+      result: syncResult,
+      onWarning: params.onWarning
+    });
+    let dirtyAfterSync;
+    if (codeCheckoutCarriesSharedBuckets(mergeCwd)) {
+      dirtyAfterSync = await snapshotDirtyPlanningPaths({
+        cwd: mergeCwd,
+        allowlistPrefixes: params.allowlistPrefixes
+      });
+      completion.stagedPaths = selectTaskSyncStagePaths({
+        dirtyAfterSync,
+        syncTargetCandidates: buildTaskSyncTargetCandidates({
+          mergeCwd,
+          sprintId,
+          details: completion.details,
+          dirtyAfterSync
+        })
+      });
+      if (completion.stagedPaths.length > 0) {
+        await execGitChecked(["add", "--", ...completion.stagedPaths], {
+          cwd: mergeCwd,
+          timeoutMs: 3e4
+        });
+      }
+    } else {
+      dirtyAfterSync = await publishCompletionToStorage(params, completion);
+    }
+    const unreconciled = params.resume || !dirtyAfterSync ? void 0 : describeUnreconciledTaskSync({ mergeCwd, details: completion.details, dirtyAfterSync });
+    if (unreconciled) {
+      params.onWarning(`  Warning: ${unreconciled}`);
+      completion.warnings.push(unreconciled);
+    }
+  } catch (error) {
+    if (error instanceof PlanningSnapshotError) throw error;
+    params.onWarning(
+      `  Warning: Task transition application failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return completion;
+}
+var HELD_METADATA_TRAILER = "Build-Held-Metadata: ";
+function formatHeldMetadataTrailers(paths) {
+  return paths.map((pathname) => `${HELD_METADATA_TRAILER}${pathname}`).join("\n");
+}
+function parseHeldMetadataTrailers(body) {
+  return body.split(/\r?\n/).filter((line) => line.startsWith(HELD_METADATA_TRAILER)).map((line) => line.slice(HELD_METADATA_TRAILER.length)).filter((pathname) => pathname.length > 0);
+}
+async function finishCompletionAfterCodeCommit(params) {
+  const { mergeCwd, sprintId } = params;
+  const headBody = await execGit(["log", "-1", "--format=%B", "HEAD"], {
+    cwd: mergeCwd,
+    timeoutMs: 3e4
+  });
+  if (headBody.exitCode !== 0) {
+    return { kind: "refused", reason: "Could not read the code commit message to resume." };
+  }
+  const heldBack = parseHeldMetadataTrailers(headBody.stdout);
+  const completion = sprintId && params.transitions ? await completeAndStageVerifiedTasks({
+    workflowId: params.workflowId,
+    sprintId,
+    transitions: params.transitions,
+    mergeCwd,
+    allowlistPrefixes: params.allowlistPrefixes,
+    assertApplyLockOwned: params.assertApplyLockOwned,
+    onInfo: params.onInfo,
+    onWarning: params.onWarning,
+    resume: true
+  }) : void 0;
+  if (completion?.failures) {
+    return {
+      kind: "refused",
+      reason: `Task transitions failed while finishing ${params.workflowId}: ${completion.failures.details.map((d) => `${d.taskId} (${d.error})`).join("; ")}. Repair those tasks, then rerun merge-result.`
+    };
+  }
+  if (completion?.publication?.outcome === "failed") {
+    return {
+      kind: "refused",
+      reason: `The task completion for ${params.workflowId} was not published to planning storage (${completion.publication.reason ?? "unknown error"}). Resolve the cause, then rerun merge-result.`
+    };
+  }
+  const dirty = await snapshotDirtyPlanningPaths({ cwd: mergeCwd, allowlistPrefixes: [] });
+  const owned = /* @__PURE__ */ new Set([...heldBack, ...completion?.stagedPaths ?? []]);
+  if (sprintId && params.transitions) {
+    for (const candidate of buildResumeClaimCandidates({
+      mergeCwd,
+      sprintId,
+      transitions: params.transitions,
+      dirty
+    })) {
+      owned.add(candidate);
+    }
+  }
+  const unowned = [
+    ...[...dirty].filter(
+      (p) => params.bucketPrefixes.some((prefix) => p.startsWith(prefix)) && !owned.has(p)
+    ),
+    ...completion?.unclaimedStoragePaths ?? []
+  ];
+  if (unowned.length > 0) {
+    return {
+      kind: "refused",
+      reason: `The code commit for ${params.workflowId} landed but its task metadata was not committed, and other uncommitted task/sprint/backlog changes are present: ${unowned.join(", ")}. Set them aside without committing (for example with git stash), rerun merge-result to finish the completion, then restore them.`
+    };
+  }
+  const toStage = [...dirty].filter((p) => owned.has(p));
+  if (toStage.length > 0) {
+    await params.assertApplyLockOwned();
+    await execGitChecked(["add", "--", ...toStage], { cwd: mergeCwd, timeoutMs: 3e4 });
+  }
+  const stagedResult = await execGitChecked(["diff", "--cached", "--name-only", "-z"], {
+    cwd: mergeCwd,
+    timeoutMs: 3e4
+  });
+  const staged = stagedResult.stdout.split("\0").filter(Boolean);
+  const stray = staged.filter((p) => !owned.has(p));
+  if (stray.length > 0) {
+    return {
+      kind: "refused",
+      reason: `Refusing to finish the completion for ${params.workflowId}: changes this apply does not own are staged (${stray.join(", ")}). Unstage them, then rerun merge-result.`
+    };
+  }
+  const warnings = completion?.warnings ?? [];
+  if (staged.length === 0) {
+    return { kind: "finished", warnings };
+  }
+  const authorizedTree = await execGit(["write-tree"], { cwd: mergeCwd, timeoutMs: 3e4 });
+  if (authorizedTree.exitCode !== 0 || authorizedTree.stdout.trim().length === 0) {
+    return { kind: "refused", reason: "Could not fingerprint the staged metadata to resume." };
+  }
+  await params.assertApplyLockOwned();
+  const codeCommit = await execGit(["rev-parse", "HEAD"], { cwd: mergeCwd, timeoutMs: 3e4 });
+  try {
+    await runFlywheelCommit({
+      cwd: mergeCwd,
+      phase: "metadata",
+      run: () => execGitChecked(["commit", "-m", params.metadataCommitMessage], {
+        cwd: mergeCwd,
+        timeoutMs: GIT_HOOK_COMMIT_TIMEOUT_MS,
+        env: { BUILD_BACKLOG_SYNC: "1" }
+      }),
+      // execGitChecked captures git's output, so the failure message carries it.
+      quiet: true,
+      style: params.commitStyle,
+      priorCommit: true
+    });
+  } catch (error) {
+    if (!(error instanceof FlywheelCommitError)) throw error;
+    return {
+      kind: "refused",
+      reason: `${error.message}
+Resolve the git error above, then rerun \`build run flywheel merge-result ${params.workflowId}\` to finish the completion.`
+    };
+  }
+  const [head, headTree] = await Promise.all([
+    execGit(["rev-parse", "HEAD"], { cwd: mergeCwd, timeoutMs: 3e4 }),
+    execGit(["rev-parse", "HEAD^{tree}"], { cwd: mergeCwd, timeoutMs: 3e4 })
+  ]);
+  if (headTree.exitCode !== 0 || headTree.stdout.trim() !== authorizedTree.stdout.trim()) {
+    const branch = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: mergeCwd,
+      timeoutMs: 3e4
+    });
+    const changed = head.exitCode === 0 ? await describeCommitChangedTree({
+      cwd: mergeCwd,
+      workflowId: params.workflowId,
+      commits: [{ preCommitTree: authorizedTree.stdout.trim(), sha: head.stdout.trim() }],
+      branch: branch.exitCode === 0 ? branch.stdout.trim() : void 0,
+      restoreSha: codeCommit.exitCode === 0 ? codeCommit.stdout.trim() : void 0,
+      headline: "The metadata commit does not carry the staged task metadata."
+    }).catch(() => void 0) : void 0;
+    return {
+      kind: "refused",
+      reason: changed ?? `The metadata commit for ${params.workflowId} does not carry the staged task metadata (a commit hook may have changed it). The commit was preserved for inspection and is not a verified apply.`,
+      unverifiedCommitTree: authorizedTree.stdout.trim()
+    };
+  }
+  return {
+    kind: "finished",
+    metadataCommitSha: head.exitCode === 0 ? head.stdout.trim() || void 0 : void 0,
+    warnings
+  };
+}
+
+// src/automation/flywheel-verify-stage-status.ts
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getWorkflowVerifyStageStatusFromResult(parsed) {
+  if (!isRecord3(parsed)) return null;
+  const stageResults = Array.isArray(parsed.stageResults) ? parsed.stageResults : void 0;
+  if (!stageResults) return null;
+  const statuses = [];
+  for (const r of stageResults) {
+    if (!isRecord3(r)) continue;
+    const stageType = typeof r.stageType === "string" ? r.stageType : void 0;
+    const verifyCommands = Array.isArray(r.verifyCommands) ? r.verifyCommands : void 0;
+    const isVerifyStage = stageType === "verify" || Boolean(verifyCommands);
+    if (!isVerifyStage) continue;
+    const stageId = typeof r.stageId === "string" ? r.stageId : "(unknown)";
+    const validationPassed = r.validationPassed === true;
+    const durationMs = typeof r.durationMs === "number" && Number.isFinite(r.durationMs) ? r.durationMs : void 0;
+    const commandsCount = Array.isArray(verifyCommands) ? verifyCommands.length : 0;
+    const unverified = validationPassed && readStagesUnverifiedDisposition([r]) !== void 0;
+    statuses.push({
+      stageId,
+      validationPassed,
+      durationMs,
+      commandsCount,
+      ...unverified ? { unverified: true } : {}
+    });
+  }
+  return statuses;
+}
+function formatVerifyStatusForCommitMessage(parsed) {
+  const verifyStages = getWorkflowVerifyStageStatusFromResult(parsed);
+  if (!verifyStages || verifyStages.length === 0) return null;
+  const totalStages = verifyStages.length;
+  const unverifiedStages = verifyStages.filter((s) => s.unverified).length;
+  const passedStages = verifyStages.filter((s) => s.validationPassed && !s.unverified).length;
+  const totalCommands = verifyStages.reduce((sum, s) => sum + s.commandsCount, 0);
+  const stageLabel = totalStages === 1 ? ` (${verifyStages[0]?.stageId ?? "(unknown)"})` : ` (${passedStages}/${totalStages} stages)`;
+  const commandsLabel = totalCommands === 1 ? "1 cmd" : `${totalCommands} cmds`;
+  const unverifiedLabel = unverifiedStages > 0 ? `, ${unverifiedStages} unverified` : "";
+  return `Verify: ${passedStages}/${totalStages} passed${unverifiedLabel}, ${commandsLabel}${stageLabel}`;
+}
+
+// src/automation/merge-gate-refusal.ts
+function mergeResultCommand(input) {
+  const base = input.pr && input.baseBranch ? ` --base ${shellPath(input.baseBranch)}` : "";
+  return `build run flywheel merge-result ${input.workflowId}${input.pr ? " --pr" : ""}${base}`;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function shellPath(path5) {
+  return /^[\w./@%+=:,-]+$/.test(path5) ? path5 : escapeShellArg(path5);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function preservedStageWork(stageResults) {
+  if (!Array.isArray(stageResults)) return [];
+  return stageResults.flatMap((stage) => {
+    const work = asRecord(asRecord(stage)?.preservedWork);
+    if (!work) return [];
+    const location = {
+      worktreePath: nonEmptyString(work.worktreePath),
+      branch: nonEmptyString(work.branch)
+    };
+    return location.worktreePath || location.branch ? [location] : [];
+  });
+}
+function preservedStageBranches(stageResults) {
+  return preservedStageWork(stageResults).flatMap((work) => work.branch ? [work.branch] : []);
+}
+var FAILED_VERIFICATION_PART = /\b\d+ stage\(s\) failed verification\b/;
+function displayedGateReason(input) {
+  const reason = input.summary?.reason ?? "Workflow gate failed";
+  if (reason.includes("stage(s) verification unavailable")) return reason;
+  if (!FAILED_VERIFICATION_PART.test(reason) || !Array.isArray(input.stageResults)) return reason;
+  const blocking = new Set(input.blockingStageIds);
+  const stages = input.stageResults.filter((stage) => {
+    const record = asRecord(stage);
+    return typeof record?.stageId === "string" && blocking.has(record.stageId) && record.winnerNeedsRepair !== true;
+  });
+  if (stages.length === 0) return reason;
+  return reason.replace(
+    FAILED_VERIFICATION_PART,
+    describeVerificationFailedStages(stages).join(", ")
+  );
+}
+function manualFixSteps(input, needsRepair) {
+  const preserved = preservedStageWork(input.stageResults);
+  if (preserved.length > 0) {
+    const locations = preserved.map(
+      (work) => work.worktreePath ? `   cd ${shellPath(work.worktreePath)}${work.branch ? `   # branch ${work.branch}` : ""}
+` : `   # branch ${work.branch} (no retained worktree)
+`
+    ).join("");
+    const merges = preserved.flatMap((work) => work.branch ? [`   git merge --squash ${work.branch}
+`] : []).join("");
+    return `   ${input.integrationBranch} does not hold the failed stage work; it is kept
+   on the preserved stage branch, checked out in its retained worktree:
+
+` + locations + "   # Committing a fix there does not clear the recorded gate result, and\n   # merge-result applies the integration branch, which does not hold this work.\n" + (merges ? `   # To land it by hand, verify it there and commit any uncommitted changes,
+   # then from your target branch:
+${merges}` : "") + "\n";
+  }
+  if (needsRepair) {
+    return `   git checkout ${input.integrationBranch}
+   # Fix the findings and commit, then re-run the failed gates; reverify clears
+   # the recorded result only when they pass (<stage-id> is under "Blocking stages"):
+   build run flywheel reverify ${input.workflowId} <stage-id>
+   ${mergeResultCommand(input)}
+
+`;
+  }
+  return `   git checkout ${input.integrationBranch}
+   # Fix and commit. Committing does not clear the recorded gate result:
+   # merge-result stays refused until a new run passes, or until you verify by
+   # hand and use the --skip-verify override below.
+
+`;
+}
+function rerunSteps(input) {
+  if (input.activeSprintExists === false) {
+    return `   No active sprint exists to re-run (a failed planned build rolls its temporary
+   sprint back), so 'build plan sprint run --apply' has nothing to run. Start the
+   work again; on a fix/*, docs/* or test/* branch it applies directly:
+
+   build --planned "<intent>"
+`;
+  }
+  return "   build plan sprint run --apply --verification-policy findings\n   # Sprint runs default to --verification-policy blocking, which disqualifies failing\n   # candidates; findings records failures so repair can run on the winner\n";
+}
+function whySection(input, unavailable) {
+  const needsRepair = (input.summary?.needsRepairCount ?? 0) > 0;
+  const manual = manualFixSteps(input, needsRepair);
+  if (needsRepair) {
+    return "Why did this happen?\n   Automatic repair was either disabled (--no-repair-on-findings) or failed to resolve all issues.\n\nRECOMMENDED: Re-run with automatic repair enabled (default behavior)\n   This will allow the system to automatically fix verification findings:\n\n" + rerunSteps(input) + "\nALTERNATIVE: Manually fix on the run branch\n   If you prefer manual control:\n\n" + manual;
+  }
+  if (unavailable) {
+    return "Why did this happen?\n   Verification unavailable: the verify commands could not run (a missing tool or\n   no verify command for this project), so the change was never checked. Nothing\n   ran and failed, so repair had nothing to fix.\n\nRECOMMENDED: Make verification runnable, then re-run\n   Install the missing tool or declare verify commands for this project.\n\n" + (preservedStageWork(input.stageResults).length > 0 ? "ALTERNATIVE: Verify by hand on the preserved stage branch\n" : "ALTERNATIVE: Verify by hand on the run branch\n") + manual;
+  }
+  if (input.verificationPolicy === "blocking") {
+    return "Why did this happen?\n   Verification failed in blocking mode (--verification-policy blocking).\n   In blocking mode, failing candidates are disqualified and the workflow gate stays closed.\n\nRECOMMENDED: Re-run with non-blocking verification (--verification-policy findings)\n   This allows repair to fix issues automatically:\n\n" + rerunSteps(input) + "\nALTERNATIVE: Manually fix verification failures\n" + manual;
+  }
+  return "Why did this happen?\n   Verification failed during execution and the workflow was recorded as not mergeable.\n   Repair was not sufficient to clear the gate.\n\nRECOMMENDED: Re-run with automatic repair enabled (default behavior)\n   This allows the system to automatically fix verification issues:\n\n" + rerunSteps(input) + "\nALTERNATIVE: Manually fix verification failures\n" + manual;
+}
+function stageIdsWithIntegrationWork(stageResults) {
+  if (!Array.isArray(stageResults)) return /* @__PURE__ */ new Set();
+  return new Set(
+    stageResults.flatMap((stage) => {
+      const stageId = asRecord(stage)?.stageId;
+      return typeof stageId === "string" && preservedStageWork([stage]).length === 0 ? [stageId] : [];
+    })
+  );
+}
+function overrideSection(input) {
+  const command = `   ${mergeResultCommand(input)} --skip-verify
+`;
+  if (preservedStageWork(input.stageResults).length === 0) {
+    return "OVERRIDE (not recommended): Skip verification gate\n   Only use this if you understand the risks:\n\n" + command + "\n";
+  }
+  const withIntegrationWork = stageIdsWithIntegrationWork(input.stageResults);
+  const stageOnly = !input.blockingStageIds.some((stageId) => withIntegrationWork.has(stageId));
+  const cannotLand = `   --skip-verify applies only ${input.integrationBranch}, which does not hold the
+   preserved stage work, so it cannot land that work; use the steps above for it.
+`;
+  if (stageOnly) {
+    return `NOTE: Skipping the verification gate does not help here
+${cannotLand}
+`;
+  }
+  return "OVERRIDE (not recommended): Skip verification gate\n" + cannotLand + "   For the work the integration branch does hold, and only if you understand the risks:\n\n" + command + "\n";
+}
+function buildMergeGateRefusalMessage(input) {
+  const { workflowId } = input;
+  const unavailable = failedOnlyOnUnavailableVerification(input.stageResults);
+  const lines = input.blockingStageIds.slice(0, 6).map((stageId) => `- ${stageId}`).join("\n");
+  const preserved = preservedStageBranches(input.stageResults);
+  return "Cannot apply workflow result: " + displayedGateReason(input) + "\n" + (lines ? `
+Blocking stages:
+${lines}
+` : "") + (preserved.length > 0 ? `
+Preserved stage work: ${preserved.map((b) => `branch ${b}`).join(", ")}
+` : "") + "\n" + whySection(input, unavailable) + (input.blockingStageIds.some((stageId) => input.stageProgress?.[stageId]?.reviewGate) ? `REVIEWER FINDINGS: Dispose a halted review gate with a recorded decision
+   Reject a false-positive finding or accept a real one; the gate re-runs and
+   merge-result becomes eligible without skipping verification:
+
+   build run flywheel gate ${workflowId} <gate-stage-id> --reject <finding-id> --reason "<why>"
+   build run flywheel gate ${workflowId} <gate-stage-id> --accept <finding-id> --reason "<why>"
+   # <gate-stage-id> is listed under "Blocking stages" above
+
+` : "") + overrideSection(input) + `Learn more: Run 'build plan sprint run --help' to see all verification and repair options.`;
+}
+
+// src/automation/flywheel-merge.ts
+function commandUsesVitest(command) {
+  return /(?:^|\s)(?:(?:npx|pnpm exec|pnpx|yarn|bunx)\s+)?vitest(?:\s|$)/.test(command);
+}
+function resolvePostMergeFocusedTestCommand(params) {
+  const { testFile, capabilities, existingCommands } = params;
+  const hasVitest = existingCommands.some(commandUsesVitest) || targetSignalsVitest(capabilities.root);
+  if (hasVitest && isNodeVerificationPath(testFile) && isRunnableProjectTestFile(testFile)) {
+    const run = resolverVitestRun(capabilities, [testFile]);
+    if (run !== "whole-suite" && Object.keys(run?.env ?? {}).length === 0) {
+      const args = run?.args ?? ["--no-install", "vitest", "run", testFile];
+      const operands = args.map((arg) => arg === testFile ? quotePosixShellArg(arg) : arg);
+      return { kind: "focused", command: ["npx", ...operands].join(" ") };
+    }
+  }
+  const guidance = buildProjectVerificationGuidance(capabilities.root, [testFile], {
+    capabilities
+  });
+  const wholeSuite = guidance.commands.filter((entry) => entry.kind === "test").map((entry) => entry.command);
+  if (wholeSuite.length > 0 && verificationCommandsCoverChangedPaths(capabilities, wholeSuite, guidance.relevantLanguages, [
+    testFile
+  ])) {
+    return { kind: "whole-suite", commands: wholeSuite };
+  }
+  return { kind: "unavailable" };
+}
+async function applyTriageDecisions(workflowId, options = {}) {
+  const triage = await loadTriage(workflowId);
+  if (!triage) return { followUpFailures: [] };
+  const manifest = await loadManifest(workflowId);
+  const cwd = options.cwd ?? getProjectRoot();
+  const currentBranch = await getCurrentBranch(cwd);
+  if (options.expectedBranch && currentBranch !== options.expectedBranch) {
+    throw new Error(
+      `Triage apply target branch changed: expected ${options.expectedBranch}, found ${currentBranch}`
+    );
+  }
+  assertBranchAllowsCodeApply({
+    allowMain: options.allowMain,
+    allowProtected: options.allowProtected,
+    command: `run flywheel merge-result ${workflowId}`,
+    cwd,
+    currentBranch
+  });
+  const sprintId = manifest.sprintId;
+  const followUpFailures = [];
+  for (const [stageId, stageTriage] of Object.entries(triage.stages)) {
+    const decisions = stageTriage.decisions;
+    const toDiscard = [];
+    const followUps = [];
+    for (const decision of decisions) {
+      if (decision.outcome === "accept") {
+        continue;
+      }
+      toDiscard.push(decision.file);
+      if (decision.outcome === "follow-up") {
+        followUps.push(decision.file);
+      }
+    }
+    if (toDiscard.length > 0) {
+      console.log(
+        chalk4.cyan(
+          `  Applying triage for stage ${stageId}: discarding ${toDiscard.length} file(s)...`
+        )
+      );
+      await execa2("git", ["reset", "HEAD", "--", ...toDiscard], {
+        cwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      const tracked = [];
+      const untracked = [];
+      for (const f of toDiscard) {
+        const check = await execa2("git", ["ls-files", "--error-unmatch", "--", f], {
+          cwd,
+          stdio: "pipe",
+          timeout: 1e4,
+          reject: false
+        });
+        if (check.exitCode === 0) {
+          tracked.push(f);
+        } else {
+          untracked.push(f);
+        }
+      }
+      if (tracked.length > 0) {
+        await execa2("git", ["checkout", "--", ...tracked], {
+          cwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+      if (untracked.length > 0) {
+        await execa2("git", ["clean", "-f", "--", ...untracked], {
+          cwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+      console.log(chalk4.dim(`    Discarded: ${formatPathList(toDiscard)}`));
+    }
+    if (followUps.length > 0 && sprintId) {
+      console.log(chalk4.cyan(`  Creating ${followUps.length} follow-up task(s)...`));
+      for (const file of followUps) {
+        try {
+          const task = await createTask(`Follow-up: Refine drift in ${file}`, sprintId, {
+            priority: "P2",
+            estimatedHours: 2
+          });
+          console.log(chalk4.dim(`    - Created task ${task.id} for ${file}`));
+        } catch (error) {
+          const errMsg = error instanceof Error ? error.message : String(error);
+          console.log(
+            chalk4.yellow(`    Warning: Failed to create follow-up task for ${file}: ${errMsg}`)
+          );
+          followUpFailures.push(`Follow-up: Refine drift in ${file}: ${errMsg}`);
+        }
+      }
+    } else if (followUps.length > 0 && !sprintId) {
+      console.log(
+        chalk4.yellow(`  Warning: ${followUps.length} follow-up(s) skipped: no sprintId in manifest`)
+      );
+    }
+  }
+  return { followUpFailures };
+}
+function parseGitStatusPorcelain(output) {
+  return parseGitStatus(output).map((entry) => ({
+    status: `${entry.indexStatus}${entry.worktreeStatus}`,
+    path: entry.path,
+    ...entry.originalPath ? { originalPath: entry.originalPath } : {}
+  }));
+}
+function getStatusEntryPathspecs(entry) {
+  return Array.from(new Set([entry.originalPath, entry.path].filter(Boolean)));
+}
+function isStatusEntryInAllowlist(entry, allowlistPrefixes) {
+  return getStatusEntryPathspecs(entry).every(
+    (pathname) => isPathInAllowlist(pathname, allowlistPrefixes)
+  );
+}
+function normalizeDirPrefix(prefix) {
+  const normalized = prefix.trim().replace(/\\/g, "/");
+  if (normalized.length === 0) return normalized;
+  return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+function getPlanningBucketPrefixes(repoRoot) {
+  return getBuckets(repoRoot).map((b) => normalizeDirPrefix(b.path));
+}
+function getPlanningDirtyAllowlistPrefixes(repoRoot) {
+  return [
+    ...getPlanningBucketPrefixes(repoRoot),
+    ...[".build-project/", "planning/"].map(normalizeDirPrefix)
+  ];
+}
+function isPathInAllowlist(pathname, allowlistPrefixes) {
+  const normalized = pathname.replace(/\\/g, "/");
+  return allowlistPrefixes.some((prefix) => normalized.startsWith(prefix));
+}
+async function resolveStashShaByMessage(cwd, message) {
+  const listResult = await execa2("git", ["stash", "list", "--format=%H %gs"], {
+    cwd,
+    stdio: "pipe",
+    timeout: 3e4,
+    reject: false
+  });
+  if ((listResult.exitCode ?? 1) !== 0) return void 0;
+  const matches = listResult.stdout.split("\n").map((line) => line.replace(/\r$/, "")).filter((line) => line.length > 0).map((line) => {
+    const sep = line.indexOf(" ");
+    if (sep < 0) return void 0;
+    return { sha: line.slice(0, sep), subject: line.slice(sep + 1) };
+  }).filter((entry) => entry !== void 0).filter((entry) => entry.subject.endsWith(message) || entry.subject.includes(message));
+  if (matches.length === 1) return matches[0]?.sha;
+  return void 0;
+}
+function hasUnstagedTrackedChange(status) {
+  const worktreeStatus = status[1] ?? " ";
+  return worktreeStatus !== " " && worktreeStatus !== "?";
+}
+function isTrackedStatusChange(status) {
+  const indexStatus = status[0] ?? " ";
+  const worktreeStatus = status[1] ?? " ";
+  if (indexStatus === "?" || worktreeStatus === "?") return false;
+  return indexStatus !== " " || worktreeStatus !== " ";
+}
+function relevantPostVerifyMutations(entries, trackedRoots) {
+  return entries.filter(
+    (entry) => entry.status === "??" || isTrackedStatusChange(entry.status) && hasUnstagedTrackedChange(entry.status)
+  ).flatMap(
+    (entry) => getStatusEntryPathspecs(entry).filter(
+      (pathname) => classifyRepoPath(pathname) !== "managed-metadata" && !isWorktreeRunSentinelPath(pathname) && !shouldExcludeStatusPath(pathname, entry.status === "??", trackedRoots)
+    )
+  );
+}
+async function captureProspectiveTreeFingerprint(cwd) {
+  const prospectiveTree = await execGit(["write-tree"], { cwd, timeoutMs: 3e4 });
+  const fingerprint = prospectiveTree.stdout.trim();
+  if (prospectiveTree.exitCode !== 0 || fingerprint.length === 0) {
+    throw new Error("Post-merge verify gate could not fingerprint the prospective commit tree.");
+  }
+  return fingerprint;
+}
+async function relevantStatusPaths(cwd) {
+  const status = await execGit(["status", "--porcelain=v1", "--untracked-files=all"], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  if (status.exitCode !== 0) {
+    throw new Error("Post-merge verify gate could not inspect the verified worktree state.");
+  }
+  return relevantPostVerifyMutations(
+    parseGitStatusPorcelain(status.stdout),
+    await readTrackedToolOutputRoots(cwd)
+  );
+}
+async function hashWorktreeFiles(cwd, paths) {
+  if (paths.length === 0) return [];
+  const hashed = await execGit(["hash-object", "--", ...paths], { cwd, timeoutMs: 3e4 });
+  return hashed.exitCode === 0 ? hashed.stdout.trim().split("\n") : [];
+}
+async function snapshotPreVerifyUntracked(cwd) {
+  const status = await execGit(["status", "--porcelain=v1", "--untracked-files=all"], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  if (status.exitCode !== 0) return /* @__PURE__ */ new Map();
+  const untracked = relevantPostVerifyMutations(
+    parseGitStatusPorcelain(status.stdout).filter((entry) => entry.status === "??"),
+    await readTrackedToolOutputRoots(cwd)
+  );
+  const hashes = await hashWorktreeFiles(cwd, untracked);
+  return new Map(
+    hashes.length === untracked.length ? untracked.map((p, i) => [p, hashes[i] ?? ""]) : []
+  );
+}
+async function finalizeVerifiedTreeFingerprint(cwd, prospectiveFingerprint, preVerifyUntracked = /* @__PURE__ */ new Map()) {
+  const changed = await relevantStatusPaths(cwd);
+  const carried = changed.filter((pathname) => preVerifyUntracked.has(pathname));
+  const carriedHashes = await hashWorktreeFiles(cwd, carried);
+  const unchanged = new Set(
+    carried.filter((pathname, i) => carriedHashes[i] === preVerifyUntracked.get(pathname))
+  );
+  const verifyMutations = changed.filter((pathname) => !unchanged.has(pathname));
+  if (verifyMutations.length > 0) {
+    throw new Error(
+      `Post-merge verify mutated relevant worktree content: ${formatPathList(verifyMutations)}`
+    );
+  }
+  const tree = await execGit(["write-tree"], { cwd, timeoutMs: 3e4 });
+  const treeSha = tree.stdout.trim();
+  if (tree.exitCode !== 0 || treeSha.length === 0) {
+    throw new Error("Post-merge verify gate could not fingerprint the verified tree.");
+  }
+  if (treeSha !== prospectiveFingerprint) {
+    throw new Error("Post-merge verify changed the prospective commit tree.");
+  }
+  return treeSha;
+}
+async function assertCommittedTreeMatchesFingerprint(cwd, verifiedTreeFingerprint) {
+  const finalHead = await execGit(["rev-parse", "HEAD"], { cwd, timeoutMs: 3e4 });
+  const finalTree = await execGit(["rev-parse", "HEAD^{tree}"], { cwd, timeoutMs: 3e4 });
+  if (finalHead.exitCode !== 0 || finalHead.stdout.trim().length === 0 || finalTree.exitCode !== 0) {
+    throw new Error("Committed HEAD tree does not match the final verified tree.");
+  }
+  if (finalTree.stdout.trim() !== verifiedTreeFingerprint) {
+    const changed = await execGit(
+      ["diff", "--name-only", verifiedTreeFingerprint, finalTree.stdout.trim()],
+      { cwd, timeoutMs: 3e4 }
+    );
+    const paths = changed.stdout.split("\n").map((entry) => entry.trim()).filter(Boolean);
+    if (changed.exitCode !== 0 || paths.length === 0 || paths.some((pathname) => classifyRepoPath(pathname) !== "managed-metadata")) {
+      throw new Error("Committed HEAD tree does not match the final verified tree.");
+    }
+  }
+  return finalHead.stdout.trim();
+}
+function buildApplyOnlyProofStatus(verifiedTreeFingerprint, stagedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return { stagedAt, verifiedTreeFingerprint };
+}
+function getAutomergeDeprecationWarning() {
+  const envMode = process.env[BUILD_AUTOMERGE_MODE.name]?.trim();
+  if (envMode === "label" || envMode === "auto") {
+    return "Auto-merge configuration is deprecated and has no effect; Build creates the PR but never labels or merges it.";
+  }
+  return void 0;
+}
+function readArrayField2(obj, key) {
+  const value = obj[key];
+  return Array.isArray(value) ? value : void 0;
+}
+function readStringField2(obj, key) {
+  const value = obj[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readBooleanField(obj, key) {
+  const value = obj[key];
+  return typeof value === "boolean" ? value : void 0;
+}
+function readNumberField(obj, key) {
+  const value = obj[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readStringArrayField(obj, key) {
+  const value = obj[key];
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((v) => typeof v === "string");
+  return strings.length === value.length ? strings : void 0;
+}
+function summarizeWorkflowGateFromVerificationStatuses(statuses, stageResults = []) {
+  if (statuses.length === 0) {
+    return {
+      passed: false,
+      source: "execution",
+      decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: "Workflow verification evidence missing or empty",
+      blockingStageIds: [],
+      needsRepairCount: 0,
+      verificationFailedCount: 0
+    };
+  }
+  const blockingStages = statuses.filter(
+    (status) => status.winnerNeedsRepair || !status.verificationPassed
+  );
+  const needsRepairCount = blockingStages.filter((status) => status.winnerNeedsRepair).length;
+  const verificationFailedCount = blockingStages.length - needsRepairCount;
+  const passed = blockingStages.length === 0;
+  const verificationFailedStages = statuses.flatMap(
+    (status, index) => !status.winnerNeedsRepair && !status.verificationPassed ? [stageResults[index]] : []
+  );
+  return {
+    passed,
+    source: "execution",
+    decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reason: passed ? "All stage gates passed" : [
+      needsRepairCount > 0 ? `${needsRepairCount} stage(s) need repair` : null,
+      ...describeVerificationFailedStages(verificationFailedStages)
+    ].filter((part) => typeof part === "string" && part.length > 0).join(", ") || "Workflow gate failed",
+    blockingStageIds: blockingStages.map((status) => status.stageId),
+    needsRepairCount,
+    verificationFailedCount
+  };
+}
+function isCoherentStructuralWorkflowGate(params) {
+  const { passed, blockingStageIds, needsRepairCount, verificationFailedCount } = params;
+  if (!Number.isInteger(needsRepairCount) || !Number.isInteger(verificationFailedCount) || needsRepairCount < 0 || verificationFailedCount < 0) {
+    return false;
+  }
+  if (needsRepairCount + verificationFailedCount !== blockingStageIds.length) {
+    return false;
+  }
+  if (passed) {
+    return blockingStageIds.length === 0 && needsRepairCount === 0 && verificationFailedCount === 0;
+  }
+  return true;
+}
+function failClosedWorkflowGateSummary(params) {
+  const blockingStageIds = params.blockingStageIds ?? [];
+  return {
+    passed: false,
+    source: "execution",
+    decidedAt: typeof params.decidedAt === "string" && params.decidedAt.trim().length > 0 ? params.decidedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    reason: params.reason,
+    blockingStageIds,
+    needsRepairCount: 0,
+    verificationFailedCount: blockingStageIds.length
+  };
+}
+function getWorkflowGateSummaryFromResult(parsed) {
+  if (!isRecord(parsed)) return null;
+  if ("workflowGate" in parsed) {
+    const workflowGate = isRecord(parsed.workflowGate) ? parsed.workflowGate : null;
+    if (!workflowGate || typeof workflowGate.passed !== "boolean") {
+      return failClosedWorkflowGateSummary({
+        reason: "Workflow gate evidence is malformed or incomplete"
+      });
+    }
+    const decidedAt = typeof workflowGate.decidedAt === "string" && workflowGate.decidedAt.trim().length > 0 ? workflowGate.decidedAt : (/* @__PURE__ */ new Date()).toISOString();
+    const blockingStageIds = readStringArrayField(workflowGate, "blockingStageIds");
+    const needsRepairCount = typeof workflowGate.needsRepairCount === "number" && Number.isFinite(workflowGate.needsRepairCount) ? workflowGate.needsRepairCount : void 0;
+    const verificationFailedCount = typeof workflowGate.verificationFailedCount === "number" && Number.isFinite(workflowGate.verificationFailedCount) ? workflowGate.verificationFailedCount : void 0;
+    if (blockingStageIds === void 0 || needsRepairCount === void 0 || verificationFailedCount === void 0) {
+      return failClosedWorkflowGateSummary({
+        decidedAt,
+        reason: "Workflow gate evidence is incomplete"
+      });
+    }
+    if (!isCoherentStructuralWorkflowGate({
+      passed: workflowGate.passed,
+      blockingStageIds,
+      needsRepairCount,
+      verificationFailedCount
+    })) {
+      return failClosedWorkflowGateSummary({
+        decidedAt,
+        reason: "Workflow gate evidence is contradictory",
+        // Preserve declared blockers for diagnostics when they look like strings.
+        blockingStageIds
+      });
+    }
+    return {
+      passed: workflowGate.passed,
+      source: "execution",
+      decidedAt,
+      reason: typeof workflowGate.reason === "string" && workflowGate.reason.trim().length > 0 ? workflowGate.reason : workflowGate.passed ? "All stage gates passed" : "Workflow gate failed",
+      blockingStageIds,
+      needsRepairCount,
+      verificationFailedCount
+    };
+  }
+  const stageStatuses = getWorkflowVerificationGateStatusFromResult(parsed);
+  return stageStatuses ? summarizeWorkflowGateFromVerificationStatuses(
+    stageStatuses,
+    readArrayField2(parsed, "stageResults")
+  ) : null;
+}
+function getStagesWithDriftFromWorkflowResult(parsed) {
+  if (!isRecord(parsed)) return null;
+  const stageResults = readArrayField2(parsed, "stageResults");
+  if (!stageResults) return null;
+  const stagesWithDrift = [];
+  for (const stageResult of stageResults) {
+    if (!isRecord(stageResult)) continue;
+    const drift = stageResult.driftContext;
+    if (!isRecord(drift)) continue;
+    const violations = readStringArrayField(drift, "violations");
+    if (!violations || violations.length === 0) continue;
+    stagesWithDrift.push({
+      stageId: readStringField2(stageResult, "stageId") ?? "(unknown)",
+      violations,
+      mode: readStringField2(drift, "mode") ?? "warn"
+    });
+  }
+  return stagesWithDrift;
+}
+async function listStagedFiles(cwd, options = {}) {
+  const { stdout } = await execa2(
+    "git",
+    [
+      "diff",
+      "--cached",
+      "--name-only",
+      "-z",
+      ...options.includeDeletions ? [] : ["--diff-filter=d"]
+    ],
+    {
+      cwd,
+      stdio: "pipe",
+      timeout: 3e4
+    }
+  );
+  return stdout.split("\0").filter(Boolean);
+}
+async function runNormalization(invocation, cwd) {
+  const env = createVerificationCommandEnv(process.env, cwd);
+  const sandboxed = wrapWithSandbox({
+    workingDir: cwd,
+    command: invocation.command,
+    args: invocation.args,
+    providerName: "project-verification",
+    env,
+    allowGitWrites: false,
+    providerId: "project-verification"
+  });
+  const result = await execa2(sandboxed.command, sandboxed.args, {
+    cwd,
+    env,
+    extendEnv: false,
+    stdio: "pipe",
+    timeout: 3e5,
+    reject: false,
+    shell: false
+  });
+  return {
+    ok: result.exitCode === 0,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function formatNormalizationFailureSummary(result) {
+  const combined = [result.stdout, result.stderr].filter(Boolean).join("\n");
+  const lines = combined.split("\n");
+  const clipped = lines.slice(0, 60).join("\n");
+  const suffix = lines.length > 60 ? `
+... (${lines.length - 60} more lines)` : "";
+  return `${clipped}${suffix}`.trim();
+}
+function getWorkflowVerificationGateStatusFromResult(parsed) {
+  if (!isRecord(parsed)) return null;
+  const stageResults = readArrayField2(parsed, "stageResults");
+  if (!stageResults || stageResults.length === 0) return null;
+  const statuses = [];
+  for (const r of stageResults) {
+    if (!isRecord(r)) {
+      statuses.push({
+        stageId: "(malformed)",
+        winnerNeedsRepair: false,
+        verificationPassed: false
+      });
+      continue;
+    }
+    const stageId = readStringField2(r, "stageId") ?? "(unknown)";
+    const winnerNeedsRepair = Boolean(readBooleanField(r, "winnerNeedsRepair"));
+    const mergeGate = isRecord(r.mergeGate) ? r.mergeGate : void 0;
+    const verification = r.verification;
+    const stageType = readStringField2(r, "stageType");
+    const verifyCommands = readArrayField2(r, "verifyCommands");
+    const isVerifyStage = stageType === "verify" || Boolean(verifyCommands);
+    const canonicalMergeGatePassed = isRecord(mergeGate) && typeof mergeGate.passed === "boolean" ? mergeGate.passed : void 0;
+    const effectiveWinnerNeedsRepair = canonicalMergeGatePassed === true ? false : winnerNeedsRepair;
+    const explicitVerificationPassed = isRecord(verification) && typeof verification.passed === "boolean" ? verification.passed : void 0;
+    const validationPassed = readBooleanField(r, "validationPassed");
+    const resolvedVerification = canonicalMergeGatePassed ?? explicitVerificationPassed ?? (isVerifyStage || stageType === "orchestrator" ? validationPassed : void 0);
+    const verificationPassed = resolvedVerification === true;
+    statuses.push({
+      stageId,
+      winnerNeedsRepair: effectiveWinnerNeedsRepair,
+      verificationPassed
+    });
+  }
+  if (statuses.length === 0) return null;
+  return statuses;
+}
+async function loadWorkflowResultForGate(workflowId) {
+  let content;
+  try {
+    const resultPath = getResultPath(workflowId);
+    content = await fs4.readFile(resultPath, "utf-8");
+  } catch {
+    return {
+      kind: "unreadable",
+      summary: failClosedWorkflowGateSummary({
+        reason: "Workflow gate evidence cannot be read"
+      })
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return {
+      kind: "unreadable",
+      summary: failClosedWorkflowGateSummary({
+        reason: "Workflow gate evidence cannot be parsed"
+      })
+    };
+  }
+  if (!isRecord(parsed)) {
+    return {
+      kind: "unreadable",
+      summary: failClosedWorkflowGateSummary({
+        reason: "Workflow gate evidence cannot be parsed"
+      })
+    };
+  }
+  return { kind: "ok", parsed };
+}
+async function getWorkflowVerificationGateStatus(workflowId) {
+  const loaded = await loadWorkflowResultForGate(workflowId);
+  if (loaded.kind === "absent") return null;
+  if (loaded.kind === "unreadable") {
+    return [
+      {
+        stageId: "(unreadable)",
+        winnerNeedsRepair: false,
+        verificationPassed: false
+      }
+    ];
+  }
+  return getWorkflowVerificationGateStatusFromResult(loaded.parsed);
+}
+async function getWorkflowGateSummary(workflowId) {
+  const loaded = await loadWorkflowResultForGate(workflowId);
+  if (loaded.kind === "absent") return null;
+  if (loaded.kind === "unreadable") return loaded.summary;
+  return getWorkflowGateSummaryFromResult(loaded.parsed) ?? failClosedWorkflowGateSummary({
+    reason: "Workflow verification evidence missing or empty"
+  });
+}
+async function getMergeGateRefusal(workflowId, manifest, summary, invocation) {
+  const blockingStageIds = summary !== null ? summary.passed === false ? summary.blockingStageIds : [] : (await getWorkflowVerificationGateStatus(workflowId))?.filter((s) => s.winnerNeedsRepair || !s.verificationPassed).map((s) => s.stageId) ?? [];
+  if (summary?.passed !== false && blockingStageIds.length === 0) return null;
+  const loaded = await loadWorkflowResultForGate(workflowId);
+  const activeSprintExists = await getCurrentSprint().then((sprint) => sprint !== null).catch(() => void 0);
+  return buildMergeGateRefusalMessage({
+    ...manifest,
+    workflowId,
+    summary,
+    blockingStageIds,
+    stageResults: loaded.kind === "ok" ? loaded.parsed.stageResults : void 0,
+    pr: invocation.pr,
+    baseBranch: invocation.baseBranch,
+    activeSprintExists
+  });
+}
+function collectHistoricalVerifyCommandResults(parsed) {
+  const results = [];
+  const stack = [parsed];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (Array.isArray(current)) {
+      stack.push(...current);
+      continue;
+    }
+    if (!isRecord(current)) continue;
+    const verifyCommands = readArrayField2(current, "verifyCommands");
+    if (verifyCommands) {
+      for (const entry of verifyCommands) {
+        if (!isRecord(entry)) continue;
+        const command = readStringField2(entry, "command");
+        const exitCode = readNumberField(entry, "exitCode");
+        const durationMs = readNumberField(entry, "durationMs");
+        if (!command || exitCode === void 0 || durationMs === void 0) continue;
+        results.push({
+          command,
+          exitCode,
+          durationMs,
+          outputTail: readStringField2(entry, "outputTail"),
+          stdoutTail: readStringField2(entry, "stdoutTail"),
+          stderrTail: readStringField2(entry, "stderrTail"),
+          baselineErrorCount: readNumberField(entry, "baselineErrorCount"),
+          currentErrorCount: readNumberField(entry, "currentErrorCount"),
+          newErrorCount: readNumberField(entry, "newErrorCount")
+        });
+      }
+    }
+    for (const value of Object.values(current)) {
+      if (value && typeof value === "object") {
+        stack.push(value);
+      }
+    }
+  }
+  return results;
+}
+function formatBaselineComparison(value) {
+  return value === void 0 ? "n/a" : String(value);
+}
+function buildPostMergeBaselineDivergenceMessage(params) {
+  const { command, stageResult, mergeResult, stageBaseSha, mergeBaseSha } = params;
+  if (!stageBaseSha || !mergeBaseSha || stageBaseSha === mergeBaseSha) return null;
+  return [
+    `Historical stage verify passed for "${command}", but post-merge verify failed against a different baseline.`,
+    `Stage baseline counts (base ${stageBaseSha ?? "unknown"}): baseline=${formatBaselineComparison(stageResult.baselineErrorCount)}, current=${formatBaselineComparison(stageResult.currentErrorCount)}, new=${formatBaselineComparison(stageResult.newErrorCount)}.`,
+    `Post-merge baseline counts (base ${mergeBaseSha ?? "unknown"}): baseline=${formatBaselineComparison(mergeResult.baselineErrorCount)}, current=${formatBaselineComparison(mergeResult.currentErrorCount)}, new=${formatBaselineComparison(mergeResult.newErrorCount)}.`
+  ].join(" ");
+}
+function buildBaselineWorktreeCleanupWarning(params) {
+  const { baselineCwd, projectRoot, stillPresent, registrationState } = params;
+  if (!stillPresent && registrationState === "removed") return void 0;
+  const recovery = `Check it with: git -C ${projectRoot} worktree list --porcelain. Reclaim it with: git -C ${projectRoot} worktree remove --force ${baselineCwd} && git -C ${projectRoot} worktree prune`;
+  if (!stillPresent && registrationState === "indeterminate") {
+    return `Post-merge verify baseline worktree removal could not be verified because its git registration lookup failed (path: ${baselineCwd}). ${recovery}`;
+  }
+  return `Post-merge verify baseline worktree could not be fully removed (path: ${baselineCwd}). ` + recovery;
+}
+async function runPostMergeVerifyGate(params) {
+  const {
+    workflowId,
+    manifest,
+    preMergeHeadSha,
+    projectRoot,
+    mergeCwd,
+    ambientUnstagedAllowlistedPaths = [],
+    onVerificationStarted
+  } = params;
+  let orphanedStashWarning;
+  let verifyPassed = false;
+  let verifiedTreeFingerprint;
+  const commands = await resolvePostMergeVerifyCommands({
+    workflowId,
+    manifest,
+    projectRoot,
+    verificationRoot: mergeCwd,
+    onWarning: (message) => renderWarn(chalk4.yellow(`  Warning: ${message}`))
+  });
+  const capabilities = detectProjectCapabilities(projectRoot);
+  const pushCommand = (cmd) => {
+    if (!commands.includes(cmd)) {
+      commands.push(cmd);
+    }
+  };
+  const stagedFiles = await listStagedFiles(mergeCwd);
+  const stagedTestFiles = stagedFiles.filter(isProjectTestPath);
+  let unverifiableStagedTest = false;
+  for (const testFile of stagedTestFiles) {
+    const augmentation = resolvePostMergeFocusedTestCommand({
+      testFile,
+      capabilities,
+      existingCommands: commands
+    });
+    if (augmentation.kind === "focused") {
+      if (!commands.some((c) => c.includes(testFile))) {
+        pushCommand(augmentation.command);
+      }
+    } else if (augmentation.kind === "whole-suite") {
+      for (const cmd of augmentation.commands) pushCommand(cmd);
+    } else {
+      unverifiableStagedTest = true;
+    }
+  }
+  if (unverifiableStagedTest) {
+    console.log(
+      chalk4.yellow(
+        "  Warning: staged test file(s) detected but no resolver test command is available for this target language; augmented post-merge verification is unavailable for them."
+      )
+    );
+  }
+  if (commands.length === 0) {
+    throw new Error(
+      "Post-merge verify gate cannot prove the final tree: no verify commands found."
+    );
+  }
+  console.log(
+    chalk4.cyan(`  Post-merge verify (${commands.length} cmd${commands.length === 1 ? "" : "s"})...`)
+  );
+  const { runVerifyCommands } = await import("./verify-commands-LOHMOFKC.js");
+  let baselineCwd;
+  let historicalVerifyResults = [];
+  let verifyAllowlistStashSha;
+  if (preMergeHeadSha && commands.some((command) => isBaselineComparableTypeScriptCommand(command))) {
+    const baselinePrefix = path4.join(projectRoot, ".build-project", "tmp", "post-merge-verify-");
+    baselineCwd = await fs4.mkdtemp(baselinePrefix);
+    try {
+      const addResult = await execGit(
+        ["worktree", "add", "--detach", baselineCwd, preMergeHeadSha],
+        {
+          cwd: projectRoot,
+          timeoutMs: 6e4
+        }
+      );
+      if (addResult.exitCode !== 0) {
+        throw new Error(addResult.stderr.trim() || "git worktree add failed");
+      }
+    } catch (error) {
+      await fs4.rm(baselineCwd, { recursive: true, force: true });
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to create baseline worktree for post-merge verify: ${message}`);
+    }
+  }
+  try {
+    const resultPath = getResultPath(workflowId);
+    const raw = await fs4.readFile(resultPath, "utf-8");
+    historicalVerifyResults = collectHistoricalVerifyCommandResults(JSON.parse(raw));
+  } catch {
+    historicalVerifyResults = [];
+  }
+  const ambientAllowlistedPaths = Array.from(
+    new Set(
+      ambientUnstagedAllowlistedPaths.map((candidate) => candidate.trim()).filter((candidate) => candidate.length > 0)
+    )
+  );
+  const restoreAllowlistStash = async () => {
+    if (verifyAllowlistStashSha) {
+      const applyResult = await execa2("git", ["stash", "apply", verifyAllowlistStashSha], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 6e4,
+        reject: false
+      });
+      if ((applyResult.exitCode ?? 1) === 0) {
+        const listResult = await execa2("git", ["stash", "list", "--format=%gd %H"], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4,
+          reject: false
+        });
+        const matchingRef = listResult.stdout.split("\n").map((line) => line.trim()).find((line) => line.endsWith(` ${verifyAllowlistStashSha}`))?.split(" ")[0];
+        if (matchingRef) {
+          await execa2("git", ["stash", "drop", matchingRef], {
+            cwd: mergeCwd,
+            stdio: "pipe",
+            timeout: 3e4,
+            reject: false
+          });
+        }
+      } else {
+        orphanedStashWarning = `Post-merge verify allowlist stash ${verifyAllowlistStashSha} could not be reapplied and was preserved (worktree: ${mergeCwd}). Recover it with: git -C ${mergeCwd} stash apply ${verifyAllowlistStashSha}`;
+        console.log(
+          chalk4.yellow(
+            `  Warning: Failed to restore post-merge verify allowlist stash (${verifyAllowlistStashSha.slice(0, 7)}); it is preserved.`
+          )
+        );
+      }
+    }
+  };
+  const removeBaselineWorktree = async () => {
+    if (!baselineCwd) return;
+    let worktreeRemoved = false;
+    try {
+      const removeResult = await execGit(["worktree", "remove", "--force", baselineCwd], {
+        cwd: projectRoot,
+        timeoutMs: 6e4
+      });
+      worktreeRemoved = removeResult.exitCode === 0;
+    } catch {
+    }
+    try {
+      await fs4.rm(baselineCwd, { recursive: true, force: true });
+    } catch {
+    }
+    try {
+      await pruneGitWorktreeEntries({ cwd: projectRoot, timeoutMs: 1e4, paths: [baselineCwd] });
+    } catch {
+    }
+    let stillPresent = false;
+    try {
+      stillPresent = existsSync(baselineCwd);
+    } catch {
+      stillPresent = false;
+    }
+    let registrationState = worktreeRemoved ? "removed" : "indeterminate";
+    if (!worktreeRemoved) {
+      try {
+        const listResult = await execGit(["worktree", "list", "--porcelain"], {
+          cwd: projectRoot,
+          timeoutMs: 1e4
+        });
+        if (listResult.exitCode === 0) {
+          const resolvedBaseline = path4.resolve(baselineCwd);
+          registrationState = listResult.stdout.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => path4.resolve(line.slice("worktree ".length).trim())).includes(resolvedBaseline) ? "registered" : "removed";
+        }
+      } catch {
+      }
+    }
+    const residualWarning = buildBaselineWorktreeCleanupWarning({
+      baselineCwd,
+      projectRoot,
+      stillPresent,
+      registrationState
+    });
+    if (residualWarning) {
+      orphanedStashWarning = orphanedStashWarning ? `${orphanedStashWarning} ${residualWarning}` : residualWarning;
+      console.log(
+        chalk4.yellow(
+          "  Warning: post-merge verify baseline worktree may not have been fully removed."
+        )
+      );
+    }
+  };
+  try {
+    const existingAmbientAllowlistedPaths = [];
+    for (const candidate of ambientAllowlistedPaths) {
+      const normalizedCandidate = candidate.replace(/\\/g, "/");
+      if (path4.posix.isAbsolute(normalizedCandidate) || normalizedCandidate === ".." || normalizedCandidate.startsWith("../") || normalizedCandidate.includes("/../")) {
+        throw new Error(
+          `Failed to isolate allowlisted unstaged changes before post-merge verify gate. Unsafe pathspec: ${candidate}`
+        );
+      }
+      const tracked = await execGit(["ls-files", "--error-unmatch", "--", candidate], {
+        cwd: mergeCwd,
+        timeoutMs: 3e4
+      });
+      if (tracked.exitCode === 0) {
+        existingAmbientAllowlistedPaths.push(candidate);
+      }
+    }
+    if (existingAmbientAllowlistedPaths.length > 0) {
+      const stashMessage = `[Build Flywheel] post-merge verify allowlist stash ${workflowId} ${randomUUID2()}`;
+      const stashResult = await execa2(
+        "git",
+        [
+          "stash",
+          "push",
+          "--keep-index",
+          "-m",
+          stashMessage,
+          "--",
+          ...existingAmbientAllowlistedPaths
+        ],
+        {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 6e4,
+          reject: false
+        }
+      );
+      const stashOutput = `${stashResult.stdout ?? ""}
+${stashResult.stderr ?? ""}`;
+      if ((stashResult.exitCode ?? 1) !== 0) {
+        const stderr = String(stashResult.stderr ?? "").trim();
+        const offendingPath = existingAmbientAllowlistedPaths.join(", ");
+        const details = [
+          stderr ? `git stash stderr: ${stderr}` : void 0,
+          offendingPath ? `offending path: ${offendingPath}` : void 0
+        ].filter((part) => Boolean(part)).join("; ");
+        throw new Error(
+          details ? `Failed to isolate allowlisted unstaged changes before post-merge verify gate. ${details}` : "Failed to isolate allowlisted unstaged changes before post-merge verify gate."
+        );
+      }
+      if (!/No local changes/i.test(stashOutput)) {
+        try {
+          verifyAllowlistStashSha = await resolveStashShaByMessage(mergeCwd, stashMessage);
+        } catch {
+          verifyAllowlistStashSha = void 0;
+        }
+        if (!verifyAllowlistStashSha) {
+          orphanedStashWarning = `Post-merge verify allowlist stash was created but its commit SHA could not be resolved (worktree: ${mergeCwd}). Your allowlisted changes are preserved on the stash stack. Recover with: git -C ${mergeCwd} stash list | grep -F ${JSON.stringify(stashMessage)}`;
+          console.log(
+            chalk4.yellow(
+              "  Warning: post-merge verify allowlist stash created but unresolved; preserved on the stash stack."
+            )
+          );
+        }
+      }
+    }
+    const prospectiveTreeFingerprint = await captureProspectiveTreeFingerprint(mergeCwd);
+    const preVerifyUntracked = await snapshotPreVerifyUntracked(mergeCwd);
+    onVerificationStarted?.();
+    const verifyOutput = await runVerifyCommands({
+      cwd: mergeCwd,
+      commands,
+      baselineCwd,
+      signal: params.signal
+    });
+    if (verifyOutput.passed) {
+      const { summarizeVerifyCommandRun } = await import("./verify-commands-LOHMOFKC.js");
+      console.log(
+        chalk4.green(`  ok ${summarizeVerifyCommandRun(verifyOutput.results, commands.length)}`)
+      );
+      verifyPassed = true;
+      verifiedTreeFingerprint = await finalizeVerifiedTreeFingerprint(
+        mergeCwd,
+        prospectiveTreeFingerprint,
+        preVerifyUntracked
+      );
+    }
+    if (!verifyPassed) {
+      const failedCmd = verifyOutput.results.find((r) => r.exitCode !== 0);
+      const failedLabel = failedCmd?.command ?? "(unknown)";
+      const outputSnippet = selectFailureOutputTail(failedCmd ?? {});
+      const matchingStageVerify = failedCmd ? historicalVerifyResults.find(
+        (result) => result.command === failedCmd.command && result.exitCode === 0
+      ) : void 0;
+      const unavailable = failedCmd ? classifyPostMergeVerifyUnavailable(failedCmd, mergeCwd) : void 0;
+      const baselineDivergenceMessage = failedCmd && matchingStageVerify && !unavailable ? buildPostMergeBaselineDivergenceMessage({
+        command: failedCmd.command,
+        stageResult: matchingStageVerify,
+        mergeResult: failedCmd,
+        stageBaseSha: manifest.baseSha,
+        mergeBaseSha: preMergeHeadSha
+      }) : null;
+      const driftDetection = detectContractDrift(outputSnippet);
+      const unavailableGuidance = unavailable ? describePostMergeVerifySetup(unavailable) : "";
+      if (unavailable) {
+        console.error(chalk4.red("\n  Post-merge verify UNAVAILABLE"));
+        console.error(
+          chalk4.red(
+            `    ${failedLabel} could not complete on the merged tree (exit ${failedCmd?.exitCode ?? 1}); the merge stays blocked.`
+          )
+        );
+        console.error(chalk4.yellow(`    ${unavailable.reason}`));
+        console.error(chalk4.yellow(`    ${unavailableGuidance}`));
+      } else {
+        console.error(chalk4.red("\n  Post-merge verify FAILED"));
+        console.error(
+          chalk4.red("    Verify passed on orchestrator-root but failed on squash-merged tree.")
+        );
+        console.error(
+          chalk4.red(`    Failed command: ${failedLabel} (exit ${failedCmd?.exitCode ?? 1})`)
+        );
+      }
+      if (baselineDivergenceMessage) {
+        console.error(chalk4.yellow(`    ${baselineDivergenceMessage}`));
+      }
+      if (driftDetection.isDrift) {
+        console.error(
+          chalk4.yellow(
+            `
+    Failure classification: ${CROSS_SUBSTAGE_CONTRACT_DRIFT}` + (driftDetection.symbols.length > 0 ? ` (symbols: ${driftDetection.symbols.slice(0, 5).join(", ")})` : "")
+          )
+        );
+        console.error(
+          chalk4.yellow(
+            "    A sibling substage generated tests asserting an incompatible return shape for a shared symbol."
+          )
+        );
+      }
+      console.error(chalk4.dim(outputSnippet.split("\n").slice(-20).join("\n")));
+      console.error(
+        chalk4.yellow(`
+    Integration branch preserved: ${manifest.integrationBranch}`)
+      );
+      console.error(chalk4.yellow(`    Workflow: ${workflowId}`));
+      console.error(
+        chalk4.gray(
+          "\n    To retry after fixing: build run flywheel merge-result " + workflowId + "\n    To skip this gate:     build run flywheel merge-result " + workflowId + " --skip-verify"
+        )
+      );
+      const baseErrorMessage = unavailable ? `Post-merge verify unavailable: ${failedLabel} could not complete (exit ${failedCmd?.exitCode ?? 1}). ${unavailable.reason} ${unavailableGuidance} Integration branch preserved.` : driftDetection.isDrift ? formatContractDriftMessage(driftDetection, failedLabel) : `Post-merge verify failed: ${failedLabel} (exit ${failedCmd?.exitCode ?? 1}). Integration branch preserved for debugging.`;
+      throw new Error(
+        baselineDivergenceMessage ? `${baseErrorMessage} ${baselineDivergenceMessage}` : baseErrorMessage
+      );
+    }
+  } finally {
+    try {
+      await restoreAllowlistStash();
+    } finally {
+      await removeBaselineWorktree();
+    }
+  }
+  return { orphanedStashWarning, verifiedTreeFingerprint };
+}
+function extractVerifyCommandsFromPlan(planData) {
+  if (!isRecord(planData)) return [];
+  const payload = isRecord(planData.payload) ? planData.payload : planData;
+  const plan = isRecord(payload.plan) ? payload.plan : payload;
+  const subStages = Array.isArray(plan.subStages) ? plan.subStages : [];
+  const commands = [];
+  for (const stage of subStages) {
+    if (!isRecord(stage)) continue;
+    if (stage.type !== "verify") continue;
+    const verify = isRecord(stage.verify) ? stage.verify : null;
+    if (!verify) continue;
+    const cmds = Array.isArray(verify.commands) ? verify.commands : [];
+    for (const cmd of cmds) {
+      if (typeof cmd === "string" && cmd.trim().length > 0 && !commands.includes(cmd)) {
+        commands.push(cmd);
+      }
+    }
+  }
+  return commands;
+}
+function extractVerifyCommandsFromWorkflow(workflow) {
+  const commands = [];
+  const collect = (stage) => {
+    for (const command of stage.verify?.commands ?? []) {
+      if (command.trim().length > 0 && !commands.includes(command)) {
+        commands.push(command);
+      }
+    }
+    for (const subStage of stage.seededPlan?.subStages ?? []) {
+      collect(subStage);
+    }
+  };
+  for (const stage of workflow.stages) collect(stage);
+  return commands;
+}
+function isExecutionReviewGateCommand(command) {
+  return /\bbuild\s+internal\s+review-gate\b/.test(command);
+}
+async function resolvePostMergeVerifyCommands(params) {
+  const { workflowId, manifest, projectRoot, verificationRoot = projectRoot, onWarning } = params;
+  let commands;
+  let generatedWorkflow = false;
+  if (manifest.planArtifactPath) {
+    try {
+      const planPath = resolvePlanArtifactPath(manifest.planArtifactPath, projectRoot);
+      const raw = await fs4.readFile(planPath, "utf-8");
+      commands = extractVerifyCommandsFromPlan(JSON.parse(raw));
+    } catch (error) {
+      throw new Error(
+        `Post-merge verify gate cannot run: unable to read plan artifact ${manifest.planArtifactPath}. Cause: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  } else {
+    generatedWorkflow = true;
+    const workflowSource = manifest.generatedYamlPath || path4.join(getArtifactDirForRoot(projectRoot, workflowId), "workflow.yaml");
+    try {
+      const workflowPath = path4.resolve(projectRoot, workflowSource);
+      const raw = await fs4.readFile(workflowPath, "utf-8");
+      const parsed = yaml.load(raw);
+      if (isRecord(parsed) && Array.isArray(parsed.stages)) {
+        const explicitCommands = extractVerifyCommandsFromWorkflow(
+          parsed
+        );
+        const rejected = explicitCommands.filter((command) => !isAllowedVerifyCommand(command));
+        if (rejected.length > 0) {
+          throw new Error(
+            "Post-merge verify gate rejected explicit verify command(s): " + rejected.map((command) => JSON.stringify(command)).join(", ")
+          );
+        }
+      }
+      const { WorkflowExecutor } = await import("./flywheel-executor-JWU43KAY.js");
+      const workflow = await new WorkflowExecutor().loadWorkflow(workflowPath);
+      commands = extractVerifyCommandsFromWorkflow(workflow).filter(
+        (command) => !isExecutionReviewGateCommand(command)
+      );
+    } catch (error) {
+      throw new Error(
+        `Post-merge verify gate cannot run: unable to load generated workflow ${workflowSource}. Cause: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (!generatedWorkflow) {
+    const partitioned = partitionVerifyCommands(commands);
+    if (partitioned.rejected.length > 0) {
+      onWarning?.(
+        `Post-merge verify gate dropped ${partitioned.rejected.length} plan command(s): ${partitioned.rejected.map(
+          ({ command, reason }) => `${JSON.stringify(command)} (${reason.replace(/^Verify command rejected:\s*/i, "")})`
+        ).join(", ")}`
+      );
+    }
+    if (commands.length > 0) return partitioned.accepted;
+  }
+  if (commands.length > 0) {
+    const rejected = commands.filter((command) => !isAllowedVerifyCommand(command));
+    if (rejected.length > 0) {
+      throw new Error(
+        "Post-merge verify gate rejected explicit verify command(s): " + rejected.map((command) => JSON.stringify(command)).join(", ")
+      );
+    }
+    return commands;
+  }
+  return buildProjectVerificationGuidance(verificationRoot).commands.map(({ command }) => command).filter(isAllowedVerifyCommand);
+}
+function flywheelApplyTrailers(workflowId, role) {
+  return `Build-Workflow-Id: ${workflowId}
+Build-Apply-Role: ${role}`;
+}
+function flywheelMetadataCommitMessage(workflowId, style) {
+  return `${flywheelMetadataCommitSubject(style)}
+
+${flywheelApplyTrailers(workflowId, "metadata")}`;
+}
+function flywheelPrTitle(workflowId) {
+  return `[Flywheel] Merge workflow result ${workflowId}`;
+}
+async function reconcileAppliedFromGitLog(params) {
+  const { verifiedTreeFingerprint, ...topologyParams } = params;
+  const match = await matchAppliedCommitTopology(topologyParams);
+  if (match.kind !== "adopt" || !verifiedTreeFingerprint) return match;
+  try {
+    await assertCommittedTreeMatchesFingerprint(params.cwd, verifiedTreeFingerprint);
+  } catch (error) {
+    return {
+      kind: "ambiguous",
+      reason: `HEAD ${match.value.sha.slice(0, 12)} carries this workflow's apply trailers but its tree does not match the verified tree fingerprint recorded in the manifest (${error instanceof Error ? error.message : String(error)}). The commit was preserved after a failed committed-tree authority check; inspect it and reset the branch before retrying.`
+    };
+  }
+  return match;
+}
+async function matchAppliedCommitTopology(params) {
+  const { cwd, workflowId, baseSha, integrationBranch, expectedBranch } = params;
+  const legacySubject = legacyFlywheelMergeCommitSubject(workflowId);
+  if (expectedBranch) {
+    const branchResult = await execGit([...CURRENT_BRANCH_REV_PARSE_ARGS], {
+      cwd,
+      timeoutMs: 1e4
+    });
+    if (branchResult.exitCode !== 0) {
+      return {
+        kind: "ambiguous",
+        reason: `Could not resolve current branch while reconciling appliedAt for ${workflowId}`
+      };
+    }
+    const currentBranch = parseCurrentBranchRef(branchResult.stdout);
+    if (currentBranch !== expectedBranch) {
+      return {
+        kind: "ambiguous",
+        reason: `Applied-commit reconciliation refused: current branch '${currentBranch}' does not match expected apply target '${expectedBranch}'`
+      };
+    }
+  }
+  const logResult = await execGit(["log", "-1", "--format=%H%x1f%s%x1f%cI%x1f%B", "HEAD"], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  if (logResult.exitCode !== 0) {
+    return { kind: "none" };
+  }
+  const [sha, msgSubject, committedAt, ...bodyParts] = logResult.stdout.replace(/\r?\n$/, "").split("");
+  if (!sha || !committedAt?.trim()) return { kind: "none" };
+  const body = bodyParts.join("");
+  const applyRoleFromBody = (value) => {
+    const workflowIds = [];
+    const roles = [];
+    for (const line of value.split(/\r?\n/)) {
+      if (line.startsWith("Build-Workflow-Id: ")) {
+        workflowIds.push(line.slice("Build-Workflow-Id: ".length));
+      } else if (line.startsWith("Build-Apply-Role: ")) {
+        roles.push(line.slice("Build-Apply-Role: ".length));
+      }
+    }
+    if (workflowIds.length !== 1 || workflowIds[0] !== workflowId || roles.length !== 1) {
+      return void 0;
+    }
+    return roles[0] === "code" || roles[0] === "metadata" ? roles[0] : void 0;
+  };
+  const headRole = applyRoleFromBody(body);
+  const hasApplyTrailerLines = body.split(/\r?\n/).some(
+    (line) => line.startsWith("Build-Workflow-Id: ") || line.startsWith("Build-Apply-Role: ")
+  );
+  const [parentResult, headTreeResult, integrationTreeResult] = await Promise.all([
+    execGit(["rev-parse", "HEAD^"], { cwd, timeoutMs: 1e4 }),
+    execGit(["rev-parse", "HEAD^{tree}"], { cwd, timeoutMs: 1e4 }),
+    execGit(["rev-parse", `${integrationBranch}^{tree}`], { cwd, timeoutMs: 1e4 })
+  ]);
+  if (parentResult.exitCode !== 0 || headTreeResult.exitCode !== 0 || integrationTreeResult.exitCode !== 0) {
+    return { kind: "none" };
+  }
+  const parentSha = parentResult.stdout.trim();
+  if (!hasApplyTrailerLines && msgSubject === legacySubject && parentSha === baseSha && headTreeResult.stdout.trim() === integrationTreeResult.stdout.trim()) {
+    return { kind: "adopt", value: { sha, committedAt: committedAt.trim() } };
+  }
+  if (headRole === "code" && isFlywheelMergeCommitSubject(msgSubject ?? "", workflowId) && parentSha === baseSha) {
+    return { kind: "adopt", value: { sha, committedAt: committedAt.trim(), role: "code" } };
+  }
+  if (headRole !== "metadata" || !isFlywheelMetadataCommitSubject(msgSubject ?? ""))
+    return { kind: "none" };
+  if (parentSha === baseSha) {
+    return { kind: "adopt", value: { sha, committedAt: committedAt.trim() } };
+  }
+  const parentDetails = await execGit(["show", "-s", "--format=%P%x1f%s%x1f%B", parentSha], {
+    cwd,
+    timeoutMs: 1e4
+  });
+  if (parentDetails.exitCode !== 0) return { kind: "none" };
+  const [grandparents, parentSubject, ...parentBodyParts] = parentDetails.stdout.replace(/\r?\n$/, "").split("");
+  const parentBody = parentBodyParts.join("");
+  if (grandparents?.trim() !== baseSha || !isFlywheelMergeCommitSubject(parentSubject ?? "", workflowId) || applyRoleFromBody(parentBody) !== "code") {
+    return { kind: "none" };
+  }
+  return { kind: "adopt", value: { sha, committedAt: committedAt.trim() } };
+}
+async function reconcileApplyOnlyStagedEvidence(params) {
+  const { cwd, baseSha, integrationBranch } = params;
+  const headResult = await execGit(["rev-parse", "HEAD"], { cwd, timeoutMs: 1e4 });
+  if (headResult.exitCode !== 0 || headResult.stdout.trim() !== baseSha) {
+    return { kind: "none" };
+  }
+  const stagedQuiet = await execGit(["diff", "--cached", "--quiet"], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  if (stagedQuiet.exitCode === 0) {
+    return { kind: "none" };
+  }
+  if (stagedQuiet.exitCode !== 1) {
+    return {
+      kind: "ambiguous",
+      reason: `Could not inspect staged apply-only evidence (git exit ${stagedQuiet.exitCode})`
+    };
+  }
+  const indexTree = await execGit(["write-tree"], { cwd, timeoutMs: 3e4 });
+  const integTree = await execGit(["rev-parse", `${integrationBranch}^{tree}`], {
+    cwd,
+    timeoutMs: 1e4
+  });
+  if (indexTree.exitCode !== 0 || integTree.exitCode !== 0) {
+    return { kind: "none" };
+  }
+  const indexSha = indexTree.stdout.trim();
+  const integSha = integTree.stdout.trim();
+  if (!indexSha || !integSha) return { kind: "none" };
+  if (indexSha === integSha) {
+    return { kind: "adopt", value: { stagedTree: indexSha } };
+  }
+  return { kind: "none" };
+}
+async function reconcilePrFromGh(params) {
+  const { cwd, workflowId, headBranch, baseBranch } = params;
+  const expectedTitle = flywheelPrTitle(workflowId);
+  const localTipResult = await execGit(["rev-parse", headBranch], { cwd, timeoutMs: 1e4 });
+  if (localTipResult.exitCode !== 0 || !localTipResult.stdout.trim()) return { kind: "none" };
+  const localHeadOid = localTipResult.stdout.trim();
+  let stdout = "";
+  try {
+    const listResult = await execa2(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--head",
+        headBranch,
+        "--state",
+        "open",
+        "--json",
+        "url,number,title,headRefName,headRefOid,baseRefName",
+        "--limit",
+        "20"
+      ],
+      {
+        cwd,
+        stdio: "pipe",
+        timeout: 6e4,
+        reject: false
+      }
+    );
+    if ((listResult.exitCode ?? 1) !== 0) {
+      return { kind: "none" };
+    }
+    stdout = typeof listResult.stdout === "string" ? listResult.stdout : String(listResult.stdout ?? "");
+  } catch {
+    return { kind: "none" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return { kind: "none" };
+  }
+  if (!Array.isArray(parsed)) return { kind: "none" };
+  const candidates = [];
+  for (const entry of parsed) {
+    if (!isRecord(entry)) continue;
+    const headRef = typeof entry.headRefName === "string" ? entry.headRefName : void 0;
+    const baseRef = typeof entry.baseRefName === "string" ? entry.baseRefName : void 0;
+    const headRefOid = typeof entry.headRefOid === "string" ? entry.headRefOid : void 0;
+    const title = typeof entry.title === "string" ? entry.title : void 0;
+    const url = typeof entry.url === "string" ? entry.url : void 0;
+    const number = typeof entry.number === "number" ? entry.number : void 0;
+    if (!headRef || !headRefOid || !baseRef || !title || !url || number === void 0 || !Number.isFinite(number))
+      continue;
+    if (headRef !== headBranch) continue;
+    if (headRefOid !== localHeadOid) continue;
+    if (baseRef !== baseBranch) continue;
+    if (title !== expectedTitle) continue;
+    candidates.push({
+      prUrl: url,
+      prNumber: number,
+      prHeadSha: headRefOid
+    });
+  }
+  if (candidates.length === 0) return { kind: "none" };
+  if (candidates.length > 1) {
+    return {
+      kind: "ambiguous",
+      reason: `Found ${candidates.length} exact open PRs for head '${headBranch}' base '${baseBranch}'; refusing to adopt prUrl under ambiguity`
+    };
+  }
+  const chosen = candidates[0];
+  return { kind: "adopt", value: chosen };
+}
+async function readPrHeadAndState(cwd, prUrl) {
+  const result = await execa2("gh", ["pr", "view", prUrl, "--json", "headRefOid,state"], {
+    cwd,
+    stdio: "pipe",
+    timeout: 6e4,
+    reject: false
+  });
+  if ((result.exitCode ?? 0) !== 0) {
+    throw new Error("Failed to read PR head OID after PR creation");
+  }
+  const parsed = JSON.parse(
+    typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "")
+  );
+  if (typeof parsed.headRefOid !== "string" || parsed.headRefOid.length === 0) {
+    throw new Error("PR head OID is missing");
+  }
+  const state = typeof parsed.state === "string" ? parsed.state.toUpperCase() : "OPEN";
+  return { headSha: parsed.headRefOid, state };
+}
+async function readPrHeadSha(cwd, prUrl) {
+  return (await readPrHeadAndState(cwd, prUrl)).headSha;
+}
+async function mergeWorkflowResult(options) {
+  const { workflowId } = options;
+  const mergeCwd = getProjectRoot();
+  const mergeLockPath = path4.join(getArtifactDir(workflowId), ".merge.lock");
+  const legacyLockPath = path4.join(getArtifactDir(workflowId), ".integrate.lock");
+  const thisPid = String(process.pid);
+  function buildLockPayload() {
+    const payload = {
+      pid: process.pid,
+      host: os.hostname(),
+      lockedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return JSON.stringify(payload);
+  }
+  async function readLockPid(lockFilePath) {
+    try {
+      const raw = (await fs4.readFile(lockFilePath, "utf-8")).trim();
+      try {
+        const parsed = JSON.parse(raw);
+        if (parsed !== null && typeof parsed === "object" && "pid" in parsed && typeof parsed.pid === "number") {
+          return String(parsed.pid);
+        }
+      } catch {
+      }
+      return raw;
+    } catch {
+      return "";
+    }
+  }
+  async function breakLocks() {
+    await fs4.unlink(mergeLockPath).catch(() => {
+    });
+    await fs4.unlink(legacyLockPath).catch(() => {
+    });
+  }
+  let integrationBranchForRecovery;
+  let preMergeHeadSha;
+  let didCommit = false;
+  let mergeMutationStarted = false;
+  let applyMaterialized = false;
+  let currentBranchForRecovery;
+  let didAutoStash = false;
+  let autoStashSha;
+  let autoStashIncludesStagedPlanning = false;
+  let dirtyPlanningUnstagedPaths = [];
+  let taskSyncFailures;
+  let completionSyncDetails = [];
+  let followUpFailures;
+  const postMergeWarnings = [];
+  let verifiedTreeFingerprint;
+  let adoptedApplyTreeFingerprint;
+  const applyProofTreeFingerprint = () => adoptedApplyTreeFingerprint ?? verifiedTreeFingerprint;
+  let postMergeVerificationStarted = false;
+  let normalizationStarted = false;
+  let appliedCommitSha;
+  let committedTreeAuthorityFailed = false;
+  let uncommittedCommitFailure = false;
+  let codeCommitAwaitingCompletion = false;
+  let codeCommitOnBase = false;
+  const recordCommitMaterialized = async () => {
+    didCommit = true;
+    applyMaterialized = true;
+    try {
+      const currentHead = await execGit(["rev-parse", "HEAD"], {
+        cwd: mergeCwd,
+        timeoutMs: 3e4
+      });
+      if (currentHead.exitCode === 0 && currentHead.stdout.trim().length > 0) {
+        appliedCommitSha = currentHead.stdout.trim();
+      }
+    } catch {
+    }
+  };
+  const recordedCommits = [];
+  let committedTreeChangeReported = false;
+  const committedTreeFailure = async (fallback) => {
+    committedTreeAuthorityFailed = true;
+    const detail = await describeCommitChangedTree({
+      cwd: mergeCwd,
+      workflowId,
+      commits: recordedCommits,
+      branch: currentBranchForRecovery,
+      restoreSha: preMergeHeadSha
+    }).catch(() => void 0);
+    if (!detail) return fallback;
+    committedTreeChangeReported = true;
+    return new Error(detail);
+  };
+  const assertCommittedTreeAuthority = async (fingerprint) => {
+    try {
+      return await assertCommittedTreeMatchesFingerprint(mergeCwd, fingerprint);
+    } catch (authorityError) {
+      throw await committedTreeFailure(
+        authorityError instanceof Error ? authorityError : new Error(String(authorityError))
+      );
+    }
+  };
+  let hadPreExistingTrackedPlanningEdits = false;
+  let branchRoleApplyTarget;
+  let mergeLockAcquired = false;
+  let releaseApplyLock;
+  let signalFinalizer;
+  const assertApplyLockOwned = async (allowCancelled = false) => {
+    if (!allowCancelled) signalFinalizer?.signal.throwIfAborted();
+    if (releaseApplyLock) {
+      await releaseApplyLock.assertOwned();
+    }
+  };
+  const acquireMergeLock = async () => {
+    if (options.dryRun || mergeLockAcquired) return;
+    await fs4.mkdir(getArtifactDir(workflowId), { recursive: true });
+    try {
+      await fs4.access(legacyLockPath);
+      if (!options.force) {
+        const existingPid = await readLockPid(legacyLockPath);
+        throw new Error(
+          `Another merge is already in progress (lock file exists).
+If you're sure it's stale, retry with --force.
+Lock: ${legacyLockPath}${existingPid ? ` (pid: ${existingPid})` : ""}`
+        );
+      }
+      await breakLocks();
+    } catch (error) {
+      const code = error.code;
+      if (code && code !== "ENOENT") throw error;
+    }
+    try {
+      await fs4.writeFile(mergeLockPath, buildLockPayload(), { flag: "wx" });
+      mergeLockAcquired = true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (!options.force) {
+        const existingPid = await readLockPid(mergeLockPath);
+        throw new Error(
+          `Another merge is already in progress (lock file exists).
+If you're sure it's stale, retry with --force.
+Lock: ${mergeLockPath}${existingPid ? ` (pid: ${existingPid})` : ""}`
+        );
+      }
+      await breakLocks();
+      await fs4.writeFile(mergeLockPath, buildLockPayload(), { flag: "wx" });
+      mergeLockAcquired = true;
+    }
+  };
+  const restoreAutoStash = async () => {
+    if (!didAutoStash) return;
+    didAutoStash = false;
+    const quiet = isQuietOutputRequested();
+    if (!quiet) {
+      console.log(chalk4.cyan("  Restoring auto-stashed changes..."));
+    }
+    if (releaseApplyLock) {
+      try {
+        await releaseApplyLock.assertOwned();
+      } catch (ownershipError) {
+        const detail = ownershipError instanceof Error ? ownershipError.message : String(ownershipError);
+        const warning = describeUnrestoredAutoStash({
+          reason: `checkout apply-lock ownership was lost (${detail})`,
+          stashSha: autoStashSha
+        });
+        console.error(chalk4.yellow(`  Warning: ${warning}`));
+        postMergeWarnings.push(warning);
+        return;
+      }
+    }
+    if (!autoStashSha) {
+      const warning = describeUnrestoredAutoStash({
+        reason: "the auto-stash commit could not be identified, so it was left stashed rather than popped positionally"
+      });
+      console.error(chalk4.yellow(`  Warning: ${warning}`));
+      postMergeWarnings.push(warning);
+      return;
+    }
+    try {
+      const applyResult = await execa2(
+        "git",
+        ["stash", "apply", ...autoStashIncludesStagedPlanning ? ["--index"] : [], autoStashSha],
+        {
+          cwd: mergeCwd,
+          stdio: quiet ? "pipe" : "inherit",
+          timeout: 6e4,
+          reject: false
+        }
+      );
+      if ((applyResult.exitCode ?? 1) !== 0) {
+        const warning = describeUnrestoredAutoStash({
+          reason: `git stash apply ${autoStashSha.slice(0, 7)} exited ${applyResult.exitCode ?? "unknown"}`,
+          stashSha: autoStashSha,
+          conflictPaths: await collectUnmergedPaths(mergeCwd)
+        });
+        console.error(chalk4.yellow(`  Warning: ${warning}`));
+        postMergeWarnings.push(warning);
+        return;
+      }
+      const listResult = await execa2("git", ["stash", "list", "--format=%gd %H"], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4,
+        reject: false
+      });
+      const matchingRef = listResult.stdout.split("\n").map((line) => line.trim()).find((line) => line.endsWith(` ${autoStashSha}`))?.split(" ")[0];
+      if (matchingRef) {
+        await execa2("git", ["stash", "drop", matchingRef], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4,
+          reject: false
+        });
+      }
+    } catch (restoreError) {
+      const detail = restoreError instanceof Error ? restoreError.message : String(restoreError);
+      const warning = describeUnrestoredAutoStash({ reason: detail, stashSha: autoStashSha });
+      console.error(chalk4.yellow(`  Warning: ${warning}`));
+      postMergeWarnings.push(warning);
+    }
+  };
+  try {
+    console.log(chalk4.bold(`
+Merging Workflow Result: ${workflowId}
+`));
+    const manifest = await loadManifest(workflowId);
+    integrationBranchForRecovery = manifest.integrationBranch;
+    const status = getManifestStatus(manifest);
+    const branchRoleApplyStatus = (action) => {
+      const sourceBranch = integrationBranchForRecovery ?? null;
+      const sourceBranchRole = sourceBranch ? classifyBranchRole(sourceBranch) : null;
+      const applyTargetBranch = branchRoleApplyTarget;
+      const applyTargetBranchRole = applyTargetBranch ? classifyBranchRole(applyTargetBranch, void 0, mergeCwd) : void 0;
+      const branchRoleOverride = applyTargetBranchRole === "protected" ? options.allowProtected ? "--allow-protected" : options.allowMain ? "--allow-main" : null : null;
+      return {
+        sourceBranch,
+        sourceBranchRole,
+        applyTargetBranch,
+        applyTargetBranchRole,
+        branchRoleAction: action ?? (branchRoleOverride ? "overridden" : "product-fix"),
+        branchRoleOverride,
+        branchRoleRefused: false
+      };
+    };
+    const markApplied = async () => {
+      await updateManifestApplyStatus(workflowId, {
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        appliedBy: await getGitUsername(),
+        verifiedTreeFingerprint: applyProofTreeFingerprint(),
+        appliedCommitSha,
+        ...branchRoleApplyStatus()
+      });
+      console.log(chalk4.green("  Manifest updated"));
+      const target = { commitSha: appliedCommitSha, targetBranch: branchRoleApplyTarget };
+      await recordWorkflowCompetitionOutcomes({ workflowId, ...target });
+    };
+    const refuseWithBranchRoleProvenance = async (message) => {
+      console.error(chalk4.red(message));
+      if (!options.dryRun) {
+        try {
+          await updateManifestApplyStatus(workflowId, {
+            sourceBranch: manifest.integrationBranch ?? null,
+            sourceBranchRole: manifest.integrationBranch ? classifyBranchRole(manifest.integrationBranch) : null,
+            applyTargetBranch: branchRoleApplyTarget,
+            applyTargetBranchRole: branchRoleApplyTarget ? classifyBranchRole(branchRoleApplyTarget, void 0, mergeCwd) : void 0,
+            branchRoleAction: "refused",
+            branchRoleRefused: true
+          });
+        } catch {
+        }
+      }
+      return { success: false, workflowId, error: message };
+    };
+    const assertCurrentBranchStillMatchesApplyTarget = async () => {
+      if (!branchRoleApplyTarget) return;
+      const liveBranch = await getCurrentBranch(mergeCwd);
+      if (liveBranch !== branchRoleApplyTarget) {
+        throw new Error(
+          `Apply target branch changed during merge-result: expected ${branchRoleApplyTarget}, found ${liveBranch}`
+        );
+      }
+      assertBranchAllowsCodeApply({
+        allowMain: options.allowMain,
+        allowProtected: options.allowProtected,
+        command: `run flywheel merge-result ${workflowId}`,
+        cwd: mergeCwd,
+        currentBranch: liveBranch
+      });
+    };
+    const integrationBranchRole = classifyBranchRole(manifest.integrationBranch);
+    if (integrationBranchRole !== "generated-artifact") {
+      return await refuseWithBranchRoleProvenance(
+        `Refusing to merge workflow result from non-generated branch ${manifest.integrationBranch} (role: ${integrationBranchRole})`
+      );
+    }
+    await acquireMergeLock();
+    if (status === "applied" && !options.force) {
+      console.log(chalk4.yellow(`  Already merged on ${manifest.appliedAt}`));
+      console.log(chalk4.yellow("  Use --force to re-merge"));
+      if (!options.dryRun) {
+        return { success: true, workflowId, alreadyMerged: true };
+      }
+    }
+    if (!options.dryRun && !options.pr && !manifest.appliedAt) {
+      const appliedReconcile = await reconcileAppliedFromGitLog({
+        cwd: mergeCwd,
+        workflowId,
+        baseSha: manifest.baseSha,
+        integrationBranch: manifest.integrationBranch,
+        expectedBranch: reconciliationApplyTarget(manifest),
+        verifiedTreeFingerprint: manifest.verifiedTreeFingerprint
+      });
+      if (appliedReconcile.kind === "ambiguous") {
+        return {
+          success: false,
+          workflowId,
+          error: `Cannot reconcile applied state: ${appliedReconcile.reason}`
+        };
+      }
+      if (appliedReconcile.kind === "adopt") {
+        let adopted = appliedReconcile.value;
+        let resumeWarnings = [];
+        if (adopted.role === "code") {
+          if (options.applyOnly) {
+            return {
+              success: false,
+              workflowId,
+              applied: true,
+              error: `The code commit ${adopted.sha.slice(0, 12)} for ${workflowId} already landed; rerun merge-result without --apply-only to finish its task completion.`
+            };
+          }
+          releaseApplyLock = await acquireFlywheelApplyLock(getProjectRoot());
+          signalFinalizer = registerMergeSignalFinalizer(workflowId);
+          const sprintId = manifest.sourceType === "sprint" ? manifest.sprintId : void 0;
+          const resumeCommitStyle = resolveGitMessageStyle(mergeCwd);
+          const resumed = await finishCompletionAfterCodeCommit({
+            mergeCwd,
+            workflowId,
+            sprintId,
+            transitions: sprintId && (options.taskStatus ?? "apply") === "apply" ? await loadRecordedTaskTransitions(workflowId, sprintId) : null,
+            allowlistPrefixes: getPlanningDirtyAllowlistPrefixes(mergeCwd),
+            bucketPrefixes: getPlanningBucketPrefixes(mergeCwd),
+            metadataCommitMessage: flywheelMetadataCommitMessage(workflowId, resumeCommitStyle),
+            commitStyle: resumeCommitStyle,
+            assertApplyLockOwned,
+            onInfo: (message) => console.log(chalk4.dim(message)),
+            onWarning: (message) => console.log(chalk4.yellow(message))
+          });
+          if (resumed.kind === "refused") {
+            if (resumed.unverifiedCommitTree) {
+              await updateManifestApplyStatus(workflowId, {
+                applyError: resumed.reason,
+                verifiedTreeFingerprint: resumed.unverifiedCommitTree
+              });
+            }
+            return { success: false, workflowId, applied: true, error: resumed.reason };
+          }
+          if (resumed.metadataCommitSha) {
+            console.log(chalk4.green("  Finished task completion for the existing code commit"));
+            adopted = { sha: resumed.metadataCommitSha, committedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          }
+          resumeWarnings = resumed.warnings;
+        }
+        console.log(
+          chalk4.yellow(
+            `  Reconciled appliedAt from existing merge commit ${adopted.sha.slice(0, 7)}`
+          )
+        );
+        try {
+          await updateManifestApplyStatus(workflowId, {
+            appliedAt: adopted.committedAt,
+            appliedBy: await getGitUsername(),
+            appliedCommitSha: adopted.sha,
+            ...branchRoleApplyStatus()
+          });
+        } catch {
+        }
+        return {
+          success: true,
+          workflowId,
+          alreadyMerged: true,
+          applied: true,
+          ...resumeWarnings.length > 0 ? { degraded: true, warnings: resumeWarnings } : {}
+        };
+      }
+    }
+    if (!options.dryRun && !options.force && options.applyOnly && status === "staged" && manifest.stagedAt) {
+      console.log(chalk4.yellow(`  Already staged on ${manifest.stagedAt}`));
+      console.log(chalk4.yellow("  Use --force to re-stage"));
+      return { success: true, workflowId, alreadyStaged: true };
+    }
+    if (!options.dryRun && options.applyOnly && !manifest.stagedAt && !manifest.applyError) {
+      const stagedReconcile = await reconcileApplyOnlyStagedEvidence({
+        cwd: mergeCwd,
+        baseSha: manifest.baseSha,
+        integrationBranch: manifest.integrationBranch
+      });
+      if (stagedReconcile.kind === "adopt") {
+        console.log(
+          chalk4.yellow(
+            `  Reconciled stagedAt from exact apply-only index residue (tree ${stagedReconcile.value.stagedTree.slice(0, 7)})`
+          )
+        );
+        try {
+          await updateManifestApplyStatus(workflowId, {
+            ...buildApplyOnlyProofStatus(stagedReconcile.value.stagedTree),
+            ...branchRoleApplyStatus()
+          });
+        } catch {
+        }
+        return { success: true, workflowId, alreadyStaged: true };
+      }
+    }
+    if (status === "failed" && manifest.applyError) {
+      console.log(chalk4.red("  Previous merge failed:"));
+      console.log(chalk4.red(`  ${manifest.applyError}`));
+      if (!options.dryRun && !options.force) {
+        const correction = await detectFailedApplyCorrection({
+          cwd: mergeCwd,
+          integrationBranch: manifest.integrationBranch,
+          applyFailedIntegrationSha: manifest.applyFailedIntegrationSha
+        });
+        if (!correction.corrected) {
+          console.log(
+            chalk4.yellow(
+              "  Use --force to retry the same candidate, or commit a correction on the integration branch and rerun"
+            )
+          );
+          return { success: false, workflowId, error: manifest.applyError };
+        }
+        console.log(
+          chalk4.yellow(
+            `  Integration branch moved past the failed candidate; retrying on the corrected candidate (${correction.commits.length} commit(s)):`
+          )
+        );
+        for (const line of correction.commits) {
+          console.log(chalk4.yellow(`    ${line}`));
+        }
+      } else if (!options.dryRun) {
+        console.log(chalk4.yellow("  Retrying the same candidate with --force"));
+      }
+    }
+    if (!options.dryRun && !options.pr) {
+      const { stdout: branchStdout } = await execa2(
+        "git",
+        ["rev-parse", "--symbolic-full-name", "HEAD"],
+        {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 1e4
+        }
+      );
+      const currentBranch2 = parseCurrentBranchRef(branchStdout);
+      branchRoleApplyTarget = currentBranch2;
+      try {
+        assertBranchAllowsCodeApply({
+          allowMain: options.allowMain,
+          allowProtected: options.allowProtected,
+          command: `run flywheel merge-result ${workflowId}`,
+          cwd: mergeCwd,
+          currentBranch: currentBranch2
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const validationDryRunHint = message.includes("validation branch") ? `
+
+Preview safely from this validation branch with:
+  build run flywheel merge-result ${workflowId} --dry-run` : "";
+        return await refuseWithBranchRoleProvenance(`${message}${validationDryRunHint}`);
+      }
+    }
+    const branches = await listFlywheelBranches();
+    const branchExists = branches.some((b) => b.name === manifest.integrationBranch);
+    if (!branchExists) {
+      if (options.dryRun && !options.force) {
+        if (status === "applied") {
+          console.log(chalk4.dim("  Run branch already cleaned up; no merge preview available."));
+          return { success: true, workflowId, alreadyMerged: true };
+        }
+        if (status === "failed" && manifest.applyError) {
+          console.log(chalk4.dim("  Run branch already cleaned up; no failure preview available."));
+          return { success: true, workflowId };
+        }
+      }
+      throw new Error(
+        `Run branch not found: ${manifest.integrationBranch}
+The branch may have been deleted. Cannot merge.`
+      );
+    }
+    const workflowGateSummary = await getWorkflowGateSummary(workflowId);
+    const gateRefusal = options.skipVerify ? null : await getMergeGateRefusal(workflowId, manifest, workflowGateSummary, options);
+    if (options.pr) {
+      if (gateRefusal) return { success: false, workflowId, error: gateRefusal };
+      const warnings2 = [getAutomergeDeprecationWarning()].filter(
+        (warning) => Boolean(warning)
+      );
+      if (options.dryRun) {
+        console.log(chalk4.cyan("  Would create PR for workflow result\n"));
+        console.log(chalk4.dim("  No changes made (--dry-run)"));
+        return { success: true, workflowId };
+      }
+      if (manifest.prUrl && !options.force) {
+        const localHeadResult = await execGit(["rev-parse", manifest.integrationBranch], {
+          cwd: mergeCwd,
+          timeoutMs: 1e4
+        });
+        const localHeadSha = localHeadResult.stdout.trim();
+        if (localHeadResult.exitCode !== 0 || localHeadSha.length === 0) {
+          return {
+            success: false,
+            workflowId,
+            error: "Failed to capture source branch HEAD for recorded PR verification"
+          };
+        }
+        let prHeadSha;
+        let prState;
+        try {
+          ({ headSha: prHeadSha, state: prState } = await readPrHeadAndState(
+            mergeCwd,
+            manifest.prUrl
+          ));
+        } catch (error) {
+          return {
+            success: false,
+            workflowId,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+        if (prState === "MERGED") {
+          console.log(chalk4.yellow(`  PR already merged: ${manifest.prUrl}`));
+          return {
+            success: true,
+            workflowId,
+            alreadyMerged: true,
+            prUrl: manifest.prUrl,
+            prNumber: manifest.prNumber
+          };
+        }
+        if (prState === "CLOSED") {
+          return {
+            success: false,
+            workflowId,
+            error: `Recorded PR ${manifest.prUrl} is closed without merging; reopen it or clear the recorded PR (--force creates a new one)`
+          };
+        }
+        if (prHeadSha !== localHeadSha) {
+          return {
+            success: false,
+            workflowId,
+            error: `PR head mismatch: expected ${localHeadSha}, found ${prHeadSha}`
+          };
+        }
+        await updateManifestApplyStatus(workflowId, { prHeadSha });
+        console.log(chalk4.yellow(`  PR already recorded: ${manifest.prUrl}`));
+        return {
+          success: true,
+          workflowId,
+          prUrl: manifest.prUrl,
+          prNumber: manifest.prNumber,
+          prHeadSha,
+          degraded: warnings2.length > 0,
+          warnings: warnings2.length > 0 ? warnings2 : void 0
+        };
+      }
+      console.log(chalk4.cyan("  Creating PR for workflow result..."));
+      const prBaseBranch = options.baseBranch ?? await getCurrentBranch(mergeCwd);
+      branchRoleApplyTarget = prBaseBranch;
+      const prBaseRole = classifyBranchRole(prBaseBranch, void 0, mergeCwd);
+      if (prBaseRole === "detached" || prBaseRole === "local-scratch" || isDisposableBranchRole(prBaseRole)) {
+        return await refuseWithBranchRoleProvenance(
+          `Refusing to create PR targeting ${prBaseRole} branch '${prBaseBranch}'. Choose a product or protected base branch with --base.`
+        );
+      }
+      const sourceHeadResult = await execGit(["rev-parse", manifest.integrationBranch], {
+        cwd: mergeCwd,
+        timeoutMs: 1e4
+      });
+      const sourceHeadSha = sourceHeadResult.stdout.trim();
+      if (sourceHeadResult.exitCode !== 0 || sourceHeadSha.length === 0) {
+        return {
+          success: false,
+          workflowId,
+          error: `Failed to capture source branch HEAD before push: ${(sourceHeadResult.stderr ?? "").trim() || "unknown git error"}`
+        };
+      }
+      try {
+        const pushResult = await execGit(["push", "origin", manifest.integrationBranch], {
+          cwd: mergeCwd,
+          timeoutMs: 6e4
+        });
+        if (pushResult.exitCode !== 0) {
+          throw new Error((pushResult.stderr ?? "").trim() || "git push failed");
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+          success: false,
+          workflowId,
+          error: `Failed to push run branch to origin: ${errorMsg}`
+        };
+      }
+      {
+        const existingPr = await reconcilePrFromGh({
+          cwd: mergeCwd,
+          workflowId,
+          headBranch: manifest.integrationBranch,
+          baseBranch: prBaseBranch
+        });
+        if (existingPr.kind === "ambiguous") {
+          return {
+            success: false,
+            workflowId,
+            error: `Cannot reconcile PR state: ${existingPr.reason}`
+          };
+        }
+        if (existingPr.kind === "adopt") {
+          console.log(chalk4.yellow(`  Reconciled existing open PR: ${existingPr.value.prUrl}`));
+          if (existingPr.value.prHeadSha !== sourceHeadSha) {
+            return {
+              success: false,
+              workflowId,
+              error: `PR head mismatch: expected ${sourceHeadSha}, found ${existingPr.value.prHeadSha}`
+            };
+          }
+          await updateManifestApplyStatus(workflowId, {
+            prUrl: existingPr.value.prUrl,
+            prNumber: existingPr.value.prNumber,
+            prHeadSha: existingPr.value.prHeadSha,
+            applyError: null,
+            ...branchRoleApplyStatus("pr-created")
+          });
+          return {
+            success: true,
+            degraded: warnings2.length > 0,
+            workflowId,
+            prUrl: existingPr.value.prUrl,
+            prNumber: existingPr.value.prNumber,
+            prHeadSha: existingPr.value.prHeadSha,
+            warnings: warnings2.length > 0 ? warnings2 : void 0
+          };
+        }
+      }
+      const prTitle = flywheelPrTitle(workflowId);
+      const observabilityLines = [];
+      const stageCount = (manifest.stageIds ?? []).length;
+      if (stageCount > 0) {
+        observabilityLines.push(`| Stages | ${stageCount} |`);
+      }
+      if (workflowGateSummary) {
+        observabilityLines.push(
+          `| Workflow gate | ${workflowGateSummary.passed ? "pass" : "fail"} |`
+        );
+      }
+      const observabilitySection = observabilityLines.length > 0 ? `
+
+### Observability
+
+| Field | Value |
+|---|---|
+${observabilityLines.join("\n")}` : "";
+      const prBody = `## Workflow Result
+
+**Source**: ${manifest.sourceType}${manifest.sprintId ? ` (${manifest.sprintId})` : ""}
+**Branch**: ${manifest.integrationBranch}
+**Base**: ${manifest.baseSha.slice(0, 7)}
+**Executed**: ${manifest.executedAt}
+**Executed by**: ${manifest.executedBy}${observabilitySection}
+
+This PR contains the result of a Flywheel workflow execution.
+Review it and satisfy the repository's required checks before merging.
+
+---
+*Generated by Build Flywheel*`;
+      try {
+        const prResult = await execa2(
+          "gh",
+          [
+            "pr",
+            "create",
+            "--title",
+            prTitle,
+            "--body",
+            prBody,
+            "--head",
+            manifest.integrationBranch,
+            "--base",
+            prBaseBranch
+          ],
+          {
+            stdio: "pipe",
+            timeout: 6e4
+          }
+        );
+        const stdout = typeof prResult.stdout === "string" ? prResult.stdout : String(prResult.stdout);
+        const prUrl = stdout.match(/https:\/\/github\.com[^\s]+/)?.[0]?.trim() ?? "";
+        if (!prUrl) {
+          throw new Error("Failed to extract PR URL from gh CLI output");
+        }
+        const prNumber = parseInt(prUrl.split("/").pop() || "0", 10);
+        console.log(chalk4.green(`  PR created: ${prUrl}`));
+        const prHeadSha = await readPrHeadSha(mergeCwd, prUrl);
+        if (prHeadSha !== sourceHeadSha) {
+          return {
+            success: false,
+            workflowId,
+            error: `PR head mismatch: expected ${sourceHeadSha}, found ${prHeadSha}`
+          };
+        }
+        await updateManifestApplyStatus(workflowId, {
+          prUrl,
+          prNumber: Number.isFinite(prNumber) && prNumber > 0 ? prNumber : void 0,
+          prHeadSha,
+          applyError: null,
+          ...branchRoleApplyStatus("pr-created")
+        });
+        return {
+          success: true,
+          degraded: warnings2.length > 0,
+          workflowId,
+          prUrl,
+          prNumber: prNumber > 0 ? prNumber : void 0,
+          prHeadSha,
+          warnings: warnings2.length > 0 ? warnings2 : void 0
+        };
+      } catch (error) {
+        const existingAfterCreate = await reconcilePrFromGh({
+          cwd: mergeCwd,
+          workflowId,
+          headBranch: manifest.integrationBranch,
+          baseBranch: prBaseBranch
+        });
+        if (existingAfterCreate.kind === "adopt") {
+          console.log(
+            chalk4.yellow(
+              `  PR create failed but exact open PR exists; adopting ${existingAfterCreate.value.prUrl}`
+            )
+          );
+          if (existingAfterCreate.value.prHeadSha !== sourceHeadSha) {
+            return {
+              success: false,
+              workflowId,
+              error: `PR head mismatch: expected ${sourceHeadSha}, found ${existingAfterCreate.value.prHeadSha}`
+            };
+          }
+          await updateManifestApplyStatus(workflowId, {
+            prUrl: existingAfterCreate.value.prUrl,
+            prNumber: existingAfterCreate.value.prNumber,
+            prHeadSha: existingAfterCreate.value.prHeadSha,
+            applyError: null,
+            ...branchRoleApplyStatus("pr-created")
+          });
+          return {
+            success: true,
+            degraded: warnings2.length > 0,
+            workflowId,
+            prUrl: existingAfterCreate.value.prUrl,
+            prNumber: existingAfterCreate.value.prNumber,
+            prHeadSha: existingAfterCreate.value.prHeadSha,
+            warnings: warnings2.length > 0 ? warnings2 : void 0
+          };
+        }
+        if (existingAfterCreate.kind === "ambiguous") {
+          return {
+            success: false,
+            workflowId,
+            error: `Cannot reconcile PR state: ${existingAfterCreate.reason}`
+          };
+        }
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        let hint;
+        if (isNotGithubHostMessage(errorMsg)) {
+          hint = "The git remote is not a GitHub host, so no PR can be opened. For a backlog item rerun with --no-open-pr";
+        } else if (errorMsg.includes("command not found") || errorMsg.includes("ENOENT")) {
+          hint = "Install gh CLI: https://cli.github.com/";
+        } else if (errorMsg.includes("unable to access") || errorMsg.includes("Could not resolve host") || errorMsg.includes("rate limit") || errorMsg.includes("timed out")) {
+          hint = "Network or rate-limit error; check connectivity and retry";
+        } else {
+          hint = "Ensure gh CLI is authenticated: gh auth login";
+        }
+        const err = `Failed to create PR: ${errorMsg}
+${hint}`;
+        return { success: false, workflowId, error: err };
+      }
+    }
+    if (options.dryRun) {
+      if (gateRefusal) return { success: false, workflowId, error: gateRefusal };
+      console.log(chalk4.cyan("  Merge Preview:\n"));
+      const { stdout: diffStat } = await execa2(
+        "git",
+        ["diff", "--stat", `${manifest.baseSha}..${manifest.integrationBranch}`],
+        { stdio: "pipe", timeout: 3e4 }
+      );
+      console.log(diffStat);
+      console.log("");
+      console.log(chalk4.dim("  No changes made (--dry-run)"));
+      return { success: true, workflowId };
+    }
+    const allowlistPrefixes = getPlanningDirtyAllowlistPrefixes(mergeCwd);
+    const { stdout: currentBranchStdout } = await execa2(
+      "git",
+      ["rev-parse", "--symbolic-full-name", "HEAD"],
+      {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4
+      }
+    );
+    const currentBranch = parseCurrentBranchRef(currentBranchStdout);
+    currentBranchForRecovery = currentBranch;
+    if (currentBranch === "HEAD") {
+      throw new Error("Cannot merge in detached HEAD state. Checkout a branch and retry.");
+    }
+    if (currentBranch === manifest.integrationBranch) {
+      throw new Error(
+        `You are currently on the run branch (${manifest.integrationBranch}).
+Checkout the target branch and re-run merge.`
+      );
+    }
+    const { stdout: headShaStdout } = await execa2("git", ["rev-parse", "HEAD"], {
+      cwd: mergeCwd,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    const headSha = headShaStdout.trim();
+    preMergeHeadSha = headSha;
+    if (headSha !== manifest.baseSha) {
+      const msg = `Current HEAD (${headSha.slice(0, 7)}) does not match workflow base (${manifest.baseSha.slice(0, 7)}).`;
+      if (!options.force) {
+        throw new Error(
+          `${msg}
+For safest merge, checkout the base commit/branch and retry.
+Use --force to merge anyway.`
+        );
+      }
+      console.log(chalk4.yellow(`  Warning: ${msg}`));
+    }
+    if (gateRefusal) return { success: false, workflowId, error: gateRefusal };
+    if (!options.dryRun) {
+      releaseApplyLock = await acquireFlywheelApplyLock(getProjectRoot());
+      signalFinalizer = registerMergeSignalFinalizer(workflowId);
+      await assertApplyLockOwned();
+    }
+    if (!options.dryRun) {
+      const { stdout: lockedHeadStdout } = await execa2("git", ["rev-parse", "HEAD"], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      const lockedHeadSha = lockedHeadStdout.trim();
+      if (lockedHeadSha !== preMergeHeadSha) {
+        if (!options.force && lockedHeadSha !== manifest.baseSha) {
+          throw new Error(
+            `Apply target advanced while waiting for the merge lock (now ${lockedHeadSha.slice(0, 7)}, workflow base ${manifest.baseSha.slice(0, 7)}).
+Another merge landed first. Re-run merge from the current base, or use --force.`
+          );
+        }
+        preMergeHeadSha = lockedHeadSha;
+      }
+      await assertCurrentBranchStillMatchesApplyTarget();
+    }
+    {
+      const { stdout: statusOutput } = await execa2("git", ["status", "--porcelain=v1"], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      const entries = parseGitStatusPorcelain(statusOutput);
+      const dirtyEntries = entries.filter(
+        (e) => !getStatusEntryPathspecs(e).every((pathname) => isWorktreeRunSentinelPath(pathname))
+      );
+      const dirtyPlanning = dirtyEntries.filter(
+        (e) => isStatusEntryInAllowlist(e, allowlistPrefixes) && (e.status[0] === " " || e.status[0] === "?")
+      );
+      const dirtyOther = dirtyEntries.filter((e) => !dirtyPlanning.includes(e));
+      dirtyPlanningUnstagedPaths = dirtyPlanning.filter((entry) => hasUnstagedTrackedChange(entry.status)).flatMap((entry) => getStatusEntryPathspecs(entry));
+      hadPreExistingTrackedPlanningEdits = dirtyPlanning.some(
+        (entry) => isTrackedStatusChange(entry.status)
+      );
+      const stagedOther = dirtyOther.filter((entry) => {
+        const indexStatus = entry.status[0] ?? " ";
+        return indexStatus !== " " && indexStatus !== "?";
+      });
+      if (manifest.applyError && stagedOther.length > 0) {
+        throw new Error(
+          `A previous merge-result attempt left staged changes in ${mergeCwd} (${formatPathList(stagedOther.flatMap(getStatusEntryPathspecs))}). Auto-stash would re-apply them on top of this merge. Review them, keep anything you need elsewhere, clear them (for example: git restore --staged --worktree -- <paths>), and rerun merge-result.`
+        );
+      }
+      if (dirtyOther.length > 0) {
+        autoStashIncludesStagedPlanning = dirtyOther.some(
+          (entry) => isStatusEntryInAllowlist(entry, allowlistPrefixes)
+        );
+        console.log(
+          chalk4.yellow(
+            `  Isolating ${dirtyOther.length} uncommitted file(s), including pre-staged planning/config edits, for merge.`
+          )
+        );
+        console.log(
+          chalk4.dim(`    ${formatPathList(dirtyOther.flatMap(getStatusEntryPathspecs))}`)
+        );
+        const stashMessage = `[Build Flywheel] auto-stash before merge-result ${workflowId} ${randomUUID2()}`;
+        const dirtyOtherPaths = Array.from(new Set(dirtyOther.flatMap(getStatusEntryPathspecs)));
+        const stashResult = await execa2(
+          "git",
+          ["stash", "push", "-u", "-m", stashMessage, "--", ...dirtyOtherPaths],
+          { cwd: mergeCwd, stdio: "pipe", timeout: 6e4, reject: false }
+        );
+        const stashOutput = `${stashResult.stdout ?? ""}
+${stashResult.stderr ?? ""}`;
+        didAutoStash = stashResult.exitCode === 0 && !/No local changes/i.test(stashOutput);
+        if (!didAutoStash) {
+          throw new Error(
+            "Working tree is not clean and auto-stash did not succeed. Commit/stash changes and retry."
+          );
+        }
+        autoStashSha = await resolveStashShaByMessage(mergeCwd, stashMessage);
+        const { stdout: postStashStatusOutput } = await execa2("git", ["status", "--porcelain=v1"], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+        const postStashDirtyOther = parseGitStatusPorcelain(postStashStatusOutput).filter(
+          (e) => !getStatusEntryPathspecs(e).every((pathname) => isWorktreeRunSentinelPath(pathname))
+        ).filter(
+          (e) => !isStatusEntryInAllowlist(e, allowlistPrefixes) || e.status[0] !== " " && e.status[0] !== "?"
+        );
+        if (postStashDirtyOther.length > 0) {
+          throw new Error(
+            "Working tree is not clean after auto-stash. Remaining non-planning changes: " + formatPathList(postStashDirtyOther.flatMap(getStatusEntryPathspecs))
+          );
+        }
+      }
+      if (dirtyPlanning.length > 0) {
+        console.log(
+          chalk4.dim(
+            `  Ignoring ${dirtyPlanning.length} dirty planning file(s) for merge-result (${formatPathList(
+              dirtyPlanning.map((d) => d.path)
+            )})`
+          )
+        );
+      }
+    }
+    const dirtyPlanningBaseline = options.dryRun ? /* @__PURE__ */ new Set() : await snapshotDirtyPlanningPaths({ cwd: mergeCwd, allowlistPrefixes });
+    await assertApplyLockOwned();
+    mergeMutationStarted = true;
+    await squashMergeRunBranch({
+      cwd: mergeCwd,
+      integrationBranch: manifest.integrationBranch
+    });
+    await assertApplyLockOwned();
+    async function runPostSquashValidationPipeline() {
+      const triageResult = await applyTriageDecisions(workflowId, {
+        cwd: mergeCwd,
+        expectedBranch: branchRoleApplyTarget ?? void 0,
+        allowMain: options.allowMain,
+        allowProtected: options.allowProtected
+      });
+      if (triageResult.followUpFailures.length > 0) {
+        followUpFailures = [...followUpFailures ?? [], ...triageResult.followUpFailures];
+      }
+    }
+    await runPostSquashValidationPipeline();
+    await assertCurrentBranchStillMatchesApplyTarget();
+    async function runNormalizationMergeGate() {
+      const stagedFiles = await listStagedFiles(mergeCwd);
+      const plan = resolveMergeNormalization(mergeCwd, stagedFiles);
+      if (plan.kind === "unavailable") {
+        console.log(chalk4.dim(plan.message));
+        return { ok: true };
+      }
+      if (plan.kind === "not-required") return { ok: true };
+      console.log(chalk4.cyan(`  ${plan.label} check (merged files): ${plan.files.length}`));
+      await assertApplyLockOwned();
+      normalizationStarted = true;
+      await runNormalization(plan.safeWrite, mergeCwd);
+      await assertApplyLockOwned();
+      await execa2("git", ["add", "--", ...plan.files], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      const checkResult = await runNormalization(plan.check, mergeCwd);
+      if (!checkResult.ok) {
+        return {
+          ok: false,
+          summary: formatNormalizationFailureSummary(checkResult),
+          plan
+        };
+      }
+      return { ok: true };
+    }
+    {
+      const gate = await runNormalizationMergeGate();
+      if (!gate.ok) {
+        throw new Error(
+          `${gate.plan.label} check failed for merged files; merge stopped to avoid landing new lint/format errors.
+
+The staged merge, including normalization edits, was left in the checkout at ${mergeCwd}. Inspect it with:
+  git -C ${mergeCwd} status
+  git -C ${mergeCwd} diff --cached
+Fix the reported files there and commit, or discard the merge with:
+  git -C ${mergeCwd} reset --hard ${preMergeHeadSha ?? "HEAD"}
+Suggested fix: ${gate.plan.manualFixCommand}
+
+${gate.plan.label} output:
+${gate.summary}`
+        );
+      }
+      normalizationStarted = false;
+    }
+    await assertCurrentBranchStillMatchesApplyTarget();
+    {
+      let workflowResultForDrift;
+      try {
+        const resultPath = getResultPath(workflowId);
+        const content = await fs4.readFile(resultPath, "utf-8");
+        workflowResultForDrift = JSON.parse(content);
+      } catch {
+      }
+      const stagesWithDrift = getStagesWithDriftFromWorkflowResult(workflowResultForDrift);
+      if (stagesWithDrift && stagesWithDrift.length > 0) {
+        const totalViolations = stagesWithDrift.reduce((sum, s) => sum + s.violations.length, 0);
+        console.log(
+          chalk4.yellow(
+            `
+  Drift detected: ${totalViolations} file(s) outside allowlist across ${stagesWithDrift.length} stage(s)`
+          )
+        );
+        for (const stage of stagesWithDrift.slice(0, 3)) {
+          console.log(chalk4.dim(`    - ${stage.stageId}: ${stage.violations.length} file(s)`));
+        }
+        if (stagesWithDrift.length > 3) {
+          console.log(chalk4.dim(`    ... and ${stagesWithDrift.length - 3} more stage(s)`));
+        }
+        console.log(chalk4.dim("    (Drift was committed in warn mode - review changes if needed)"));
+        console.log("");
+      }
+    }
+    if (!options.dryRun) {
+      await assertApplyLockOwned();
+      const dirtyPlanningNow = await snapshotDirtyPlanningPaths({
+        cwd: mergeCwd,
+        allowlistPrefixes
+      });
+      const stageable = await snapshotStageablePlanningPaths({
+        cwd: mergeCwd,
+        allowlistPrefixes
+      });
+      const mergeDirtiedPlanningPaths = [...dirtyPlanningNow].filter(
+        (p) => !dirtyPlanningBaseline.has(p) && isPathInAllowlist(p, allowlistPrefixes) && stageable.has(p)
+      );
+      if (mergeDirtiedPlanningPaths.length > 0) {
+        await execa2("git", ["add", "--", ...mergeDirtiedPlanningPaths], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+    }
+    if (!options.skipVerify) {
+      let gateResult;
+      gateResult = await runPostMergeVerifyGate({
+        workflowId,
+        manifest,
+        preMergeHeadSha,
+        projectRoot: getProjectRoot(),
+        mergeCwd,
+        ambientUnstagedAllowlistedPaths: dirtyPlanningUnstagedPaths,
+        signal: signalFinalizer?.signal,
+        onVerificationStarted: () => {
+          postMergeVerificationStarted = true;
+        }
+      });
+      verifiedTreeFingerprint = gateResult.verifiedTreeFingerprint;
+      if (gateResult.orphanedStashWarning) {
+        postMergeWarnings.push(gateResult.orphanedStashWarning);
+      }
+    }
+    adoptedApplyTreeFingerprint = verifiedTreeFingerprint;
+    let stagedStatusWritePaths = /* @__PURE__ */ new Set();
+    const adoptStatusWriteStagedDelta = async () => {
+      if (!adoptedApplyTreeFingerprint) return;
+      adoptedApplyTreeFingerprint = await adoptStatusWriteTreeDelta(
+        mergeCwd,
+        adoptedApplyTreeFingerprint,
+        stagedStatusWritePaths
+      );
+    };
+    const taskStatus = options.taskStatus ?? "apply";
+    const completionSprintId = manifest.sourceType === "sprint" ? manifest.sprintId : void 0;
+    const runTaskCompletion = async () => {
+      if (!completionSprintId) return;
+      if (taskStatus !== "apply" && taskStatus !== "preview") {
+        console.log(chalk4.dim("  Task status sync skipped (--task-status=skip)"));
+        return;
+      }
+      const taskTransitions = await loadRecordedTaskTransitions(workflowId, completionSprintId);
+      if (!taskTransitions) return;
+      if (taskStatus === "preview") {
+        console.log(chalk4.cyan("  Task transition preview (artifact-driven):"));
+        for (const t of taskTransitions) {
+          console.log(
+            chalk4.dim(
+              `    - ${t.taskId}: ${t.targetStatus}${t.hoursLogged ? ` (${t.hoursLogged.toFixed(2)}h)` : ""}`
+            )
+          );
+        }
+        return;
+      }
+      console.log(chalk4.cyan("  Applying task transitions (artifact-driven)..."));
+      const completion = await completeAndStageVerifiedTasks({
+        workflowId,
+        sprintId: completionSprintId,
+        transitions: taskTransitions,
+        mergeCwd,
+        allowlistPrefixes,
+        assertApplyLockOwned,
+        onInfo: (message) => console.log(chalk4.dim(message)),
+        onWarning: (message) => console.log(chalk4.yellow(message))
+      });
+      completionSyncDetails = completion.details;
+      if (completion.failures) taskSyncFailures = completion.failures;
+      stagedStatusWritePaths = new Set(completion.stagedPaths);
+      postMergeWarnings.push(...completion.warnings);
+      await adoptStatusWriteStagedDelta();
+    };
+    const assertVerifiedTreeStillCurrent = async () => {
+      if (!adoptedApplyTreeFingerprint) return;
+      const current = await execGit(["write-tree"], { cwd: mergeCwd, timeoutMs: 3e4 });
+      if (current.exitCode !== 0 || current.stdout.trim() !== adoptedApplyTreeFingerprint) {
+        throw new Error(
+          "The staged tree changed after final verification; refusing to commit or report apply success."
+        );
+      }
+    };
+    await assertVerifiedTreeStillCurrent();
+    await assertApplyLockOwned();
+    if (options.applyOnly) {
+      console.log(chalk4.yellow("  Changes staged (--apply-only)"));
+      console.log(chalk4.yellow("  Review and commit manually"));
+      if (completionSprintId && taskStatus === "apply") {
+        console.log(
+          chalk4.yellow(
+            "  Tasks were left open; after committing, complete each with `build plan task complete <task-id>`"
+          )
+        );
+      }
+      if (!options.dryRun) {
+        try {
+          const stagedProofTree = applyProofTreeFingerprint();
+          await updateManifestApplyStatus(workflowId, {
+            ...stagedProofTree ? buildApplyOnlyProofStatus(stagedProofTree) : { stagedAt: (/* @__PURE__ */ new Date()).toISOString() },
+            ...branchRoleApplyStatus()
+          });
+        } catch {
+        }
+      }
+      return { success: true, workflowId };
+    }
+    const partitionSystemWrites = codeCheckoutCarriesSharedBuckets(mergeCwd);
+    const stagedBeforeCompletion = await listStagedFiles(mergeCwd, { includeDeletions: true });
+    const codeFirst = stagedBeforeCompletion.some((f) => !isSystemWritePath(f));
+    if (!codeFirst) {
+      await assertFailedRunHasCodeToApply(workflowGateSummary, getResultPath(workflowId));
+      await runTaskCompletion();
+      await assertVerifiedTreeStillCurrent();
+    }
+    const diffCheck = await execa2("git", ["diff", "--cached", "--quiet"], {
+      cwd: mergeCwd,
+      stdio: "pipe",
+      timeout: 3e4,
+      reject: false
+    });
+    if (diffCheck.exitCode === 0) {
+      console.log(chalk4.dim("  No changes to commit (workflow produced no diff)."));
+      applyMaterialized = true;
+      const currentHead = await execGit(["rev-parse", "HEAD"], {
+        cwd: mergeCwd,
+        timeoutMs: 3e4
+      });
+      if (!options.skipVerify) {
+        if (!verifiedTreeFingerprint) {
+          throw new Error("Final verification did not produce a tree fingerprint.");
+        }
+        appliedCommitSha = await assertCommittedTreeAuthority(
+          applyProofTreeFingerprint() ?? verifiedTreeFingerprint
+        );
+      } else {
+        appliedCommitSha = currentHead.exitCode === 0 && currentHead.stdout.trim().length > 0 ? currentHead.stdout.trim() : void 0;
+      }
+      await assertApplyLockOwned();
+      await restoreAutoStash();
+      await assertApplyLockOwned();
+      await markApplied();
+      if (options.cleanup && !options.keepArtifacts) {
+        const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+        await cleanupArtifacts({
+          integrationBranch: manifest.integrationBranch,
+          workflowId,
+          relatedTaskIds: manifest.relatedTaskIds ?? [],
+          trackedBranches: trackedCleanupTargets.trackedBranches,
+          trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+        });
+      } else if (!options.keepArtifacts) {
+        console.log(chalk4.cyan("  Cleaning up run branch/worktree..."));
+        await cleanupBranchAndWorktree(manifest.integrationBranch, workflowId);
+        const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+        await cleanupRelatedBranchesAndWorktrees({
+          integrationBranch: manifest.integrationBranch,
+          relatedTaskIds: manifest.relatedTaskIds ?? [],
+          trackedBranches: trackedCleanupTargets.trackedBranches,
+          trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+        });
+      } else {
+        await logPreservedRunArtifacts(manifest.integrationBranch);
+      }
+      const warnings2 = [
+        ...taskSyncFailures ? [`Task sync completed with ${taskSyncFailures.count} failure(s)`] : [],
+        ...followUpFailures ?? [],
+        ...postMergeWarnings
+      ];
+      reportMergeOutcome(warnings2);
+      return {
+        success: true,
+        degraded: warnings2.length > 0,
+        workflowId,
+        applied: true,
+        ...taskSyncFailures ? { taskSyncFailures } : {},
+        ...followUpFailures ? { followUpFailures } : {},
+        ...warnings2.length > 0 ? { warnings: warnings2 } : {}
+      };
+    }
+    const messageStyle = resolveGitMessageStyle(mergeCwd);
+    const commitMsg = `${flywheelMergeCommitSubject(messageStyle)}
+
+Source: ${manifest.sourceType}${manifest.sprintId ? ` (${manifest.sprintId})` : ""}
+Branch: ${manifest.integrationBranch}
+Base: ${manifest.baseSha.slice(0, 7)}`;
+    let finalCommitMsg = commitMsg;
+    try {
+      const parsed = JSON.parse(await fs4.readFile(getResultPath(workflowId), "utf-8"));
+      const verifySummary = formatVerifyStatusForCommitMessage(parsed);
+      if (verifySummary) finalCommitMsg = `${commitMsg}
+${verifySummary}`;
+    } catch {
+    }
+    finalCommitMsg = `${finalCommitMsg}
+
+${flywheelApplyTrailers(workflowId, "code")}`;
+    const metadataCommitMsg = flywheelMetadataCommitMessage(workflowId, messageStyle);
+    const quiet = isQuietOutputRequested();
+    const commitStaged = async (message, metadata) => {
+      await assertApplyLockOwned();
+      const preCommitTree = await readStagedTree(mergeCwd).catch(() => void 0);
+      try {
+        await runFlywheelCommit({
+          cwd: mergeCwd,
+          phase: metadata ? "metadata" : "code",
+          run: () => execa2("git", ["commit", "-m", message], {
+            cwd: mergeCwd,
+            stdio: quiet ? "pipe" : "inherit",
+            timeout: GIT_HOOK_COMMIT_TIMEOUT_MS,
+            ...metadata ? { env: { ...process.env, BUILD_BACKLOG_SYNC: "1" } } : {}
+          }),
+          quiet,
+          style: messageStyle,
+          priorCommit: didCommit
+        });
+      } catch (error) {
+        if (error instanceof FlywheelCommitError && !didCommit) uncommittedCommitFailure = true;
+        throw error;
+      }
+      await recordCommitMaterialized();
+      if (preCommitTree && appliedCommitSha) {
+        recordedCommits.push({ preCommitTree, sha: appliedCommitSha });
+      }
+    };
+    if (codeFirst) {
+      const heldBackFiles = partitionSystemWrites ? stagedBeforeCompletion.filter(isSystemWritePath) : [];
+      await assertVerifiedTreeStillCurrent();
+      if (heldBackFiles.length > 0) {
+        await execGitChecked(["restore", "--staged", ...heldBackFiles], {
+          cwd: mergeCwd,
+          timeoutMs: 3e4
+        });
+      }
+      await commitStaged(
+        heldBackFiles.length > 0 ? `${finalCommitMsg}
+${formatHeldMetadataTrailers(heldBackFiles)}` : finalCommitMsg,
+        false
+      );
+      const codeTree = await execGit(["rev-parse", "HEAD^{tree}"], {
+        cwd: mergeCwd,
+        timeoutMs: 3e4
+      });
+      const codeCommitTree = codeTree.exitCode === 0 ? codeTree.stdout.trim() : void 0;
+      if (!options.skipVerify && verifiedTreeFingerprint) {
+        const moved = codeCommitTree === verifiedTreeFingerprint ? { exitCode: 0, stdout: "" } : codeCommitTree ? await execGit(
+          ["diff", "--name-only", "--no-renames", verifiedTreeFingerprint, codeCommitTree],
+          { cwd: mergeCwd, timeoutMs: 3e4 }
+        ) : { exitCode: 1, stdout: "" };
+        const heldBack = new Set(heldBackFiles);
+        if (moved.exitCode !== 0 || moved.stdout.split("\n").map((entry) => entry.trim()).some((pathname) => pathname.length > 0 && !heldBack.has(pathname))) {
+          throw await committedTreeFailure(
+            new Error("Committed HEAD tree does not match the final verified tree.")
+          );
+        }
+      }
+      codeCommitOnBase = preMergeHeadSha === manifest.baseSha;
+      codeCommitAwaitingCompletion = true;
+      if (!quiet) console.log(chalk4.green("  Code changes committed"));
+      if (heldBackFiles.length > 0) {
+        await execa2("git", ["add", ...heldBackFiles], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+      await runTaskCompletion();
+      await assertVerifiedTreeStillCurrent();
+      if (heldBackFiles.length > 0 || stagedStatusWritePaths.size > 0) {
+        await commitStaged(metadataCommitMsg, true);
+        if (!quiet) console.log(chalk4.green("  Task/sprint metadata committed separately"));
+      }
+      codeCommitAwaitingCompletion = false;
+    } else {
+      const allStagedFiles = await listStagedFiles(mergeCwd);
+      const systemWriteFiles = partitionSystemWrites ? allStagedFiles.filter(isSystemWritePath) : [];
+      const otherFiles = allStagedFiles.filter((f) => !isSystemWritePath(f));
+      await assertVerifiedTreeStillCurrent();
+      if (systemWriteFiles.length > 0 && otherFiles.length > 0) {
+        await execa2("git", ["restore", "--staged", ...systemWriteFiles], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+        await commitStaged(finalCommitMsg, false);
+        await execa2("git", ["add", ...systemWriteFiles], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+        await commitStaged(metadataCommitMsg, true);
+        if (!quiet) console.log(chalk4.green("  Changes and task/sprint metadata committed"));
+      } else if (systemWriteFiles.length > 0) {
+        await commitStaged(metadataCommitMsg, true);
+        if (!quiet) console.log(chalk4.green("  Task/sprint metadata committed"));
+      } else {
+        await commitStaged(finalCommitMsg, false);
+        if (!quiet) console.log(chalk4.green("  Changes committed"));
+      }
+    }
+    await assertApplyLockOwned();
+    const finalHead = await execGit(["rev-parse", "HEAD"], { cwd: mergeCwd, timeoutMs: 3e4 });
+    if (finalHead.exitCode !== 0 || finalHead.stdout.trim().length === 0) {
+      throw new Error("Could not resolve the applied commit SHA.");
+    }
+    if (!options.skipVerify) {
+      if (!verifiedTreeFingerprint) {
+        throw new Error("Final verification did not produce a tree fingerprint.");
+      }
+      await assertCommittedTreeAuthority(applyProofTreeFingerprint() ?? verifiedTreeFingerprint);
+    }
+    appliedCommitSha = finalHead.stdout.trim();
+    await assertApplyLockOwned();
+    await restoreAutoStash();
+    await assertApplyLockOwned();
+    if (releaseApplyLock) {
+      try {
+        await releaseApplyLock();
+        releaseApplyLock = void 0;
+      } catch {
+      }
+    }
+    await markApplied();
+    if (options.cleanup && !options.keepArtifacts) {
+      const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+      await cleanupArtifacts({
+        integrationBranch: manifest.integrationBranch,
+        workflowId,
+        relatedTaskIds: manifest.relatedTaskIds ?? [],
+        trackedBranches: trackedCleanupTargets.trackedBranches,
+        trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+      });
+    } else if (!options.keepArtifacts) {
+      console.log(chalk4.cyan("  Cleaning up run branch/worktree..."));
+      await cleanupBranchAndWorktree(manifest.integrationBranch, workflowId);
+      const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+      await cleanupRelatedBranchesAndWorktrees({
+        integrationBranch: manifest.integrationBranch,
+        relatedTaskIds: manifest.relatedTaskIds ?? [],
+        trackedBranches: trackedCleanupTargets.trackedBranches,
+        trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+      });
+    } else {
+      await logPreservedRunArtifacts(manifest.integrationBranch);
+    }
+    const warnings = [
+      ...taskSyncFailures ? [`Task sync completed with ${taskSyncFailures.count} failure(s)`] : [],
+      ...followUpFailures ?? [],
+      ...postMergeWarnings
+    ];
+    reportMergeOutcome(warnings);
+    return {
+      success: true,
+      degraded: warnings.length > 0,
+      workflowId,
+      applied: true,
+      ...taskSyncFailures ? { taskSyncFailures } : {},
+      ...followUpFailures ? { followUpFailures } : {},
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+  } catch (error) {
+    let errorMsg = error instanceof Error ? error.message : String(error);
+    let leftMidMergeWarning;
+    let commitFailureLeftStaged = false;
+    let cleanupRan = false;
+    try {
+      if (!didCommit) {
+        if (uncommittedCommitFailure && postMergeVerificationStarted) {
+          commitFailureLeftStaged = true;
+          if (didAutoStash) {
+            leftMidMergeWarning = "Rollback was skipped; the staged merge was left in place.";
+          }
+        } else if (postMergeVerificationStarted) {
+          leftMidMergeWarning = `Post-merge verification failed; staged merge state was preserved at ${mergeCwd}. Destructive rollback was skipped because checkout ownership cannot be proven against external actors.`;
+        } else if (normalizationStarted) {
+          leftMidMergeWarning = `Merge normalization failed; staged merge state was preserved at ${mergeCwd}. Destructive rollback was skipped because normalization may have edited tracked files.`;
+        } else if (applyMaterialized) {
+          leftMidMergeWarning = `Merge applied with no new commit, then failed afterwards; the checkout was preserved at ${mergeCwd}. Destructive rollback was skipped because the apply had already materialized and restored auto-stashed changes.`;
+        } else if (mergeMutationStarted && hadPreExistingTrackedPlanningEdits) {
+          leftMidMergeWarning = `Merge failed after checkout mutation began; staged merge state was preserved at ${mergeCwd}. Destructive rollback was skipped because pre-existing tracked planning edits were present.`;
+        } else if (mergeMutationStarted) {
+          const stillOwned = await assertApplyLockOwned(true).then(
+            () => true,
+            () => false
+          );
+          if (stillOwned) {
+            cleanupRan = true;
+            await abortPendingSquashMerge(mergeCwd, preMergeHeadSha);
+          } else {
+            leftMidMergeWarning = `Merge failed after the apply lock was lost; the checkout at ${mergeCwd} was preserved. Rollback was skipped because another merge may now own it.`;
+            console.warn(chalk4.yellow(`
+  Warning: ${leftMidMergeWarning}
+`));
+            postMergeWarnings.push(leftMidMergeWarning);
+          }
+        }
+      } else {
+        cleanupRan = true;
+        await execa2("git", ["merge", "--abort"], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4,
+          reject: false
+        });
+      }
+      if (cleanupRan && !postMergeVerificationStarted) {
+        const { stdout: postAbortStatus } = await execa2("git", ["status", "--porcelain=v1"], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4,
+          reject: false
+        });
+        const residue = parseGitStatusPorcelain(postAbortStatus).filter(
+          (e) => !getStatusEntryPathspecs(e).every((p) => isWorktreeRunSentinelPath(p)) && !isStatusEntryInAllowlist(e, getPlanningDirtyAllowlistPrefixes(mergeCwd))
+        );
+        if (residue.length > 0) {
+          leftMidMergeWarning = `Worktree left mid-merge after rollback; manual cleanup needed at ${mergeCwd}. Unexpected residue: ${formatPathList(residue.flatMap(getStatusEntryPathspecs))}`;
+        }
+      }
+    } catch (cleanupError) {
+      leftMidMergeWarning = `Worktree cleanup after merge failure did not complete; manual cleanup may be needed at ${mergeCwd}. Cause: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`;
+    }
+    if (uncommittedCommitFailure) {
+      errorMsg = `${errorMsg}
+${formatFlywheelCommitRecovery({
+        cwd: mergeCwd,
+        workflowId,
+        restoreSha: preMergeHeadSha,
+        staged: commitFailureLeftStaged
+      })}`;
+    }
+    if (leftMidMergeWarning && didAutoStash) {
+      didAutoStash = false;
+      leftMidMergeWarning += ` ${describeRetainedAutoStash(autoStashSha)}`;
+    }
+    if (leftMidMergeWarning) {
+      console.warn(chalk4.yellow(`
+  Warning: ${leftMidMergeWarning}
+`));
+      postMergeWarnings.push(leftMidMergeWarning);
+    }
+    if (!didCommit && !applyMaterialized && completionSyncDetails.length > 0) {
+      for (const warning of await reopenTasksArchivedWithoutCommit(completionSyncDetails)) {
+        console.warn(chalk4.yellow(`  Warning: ${warning}`));
+        postMergeWarnings.push(warning);
+      }
+    }
+    if (codeCommitAwaitingCompletion) {
+      const pendingError = `Code committed as ${appliedCommitSha?.slice(0, 12) ?? "(unknown SHA)"}, but task completion did not finish: ${errorMsg} ` + (codeCommitOnBase ? `Rerun \`build run flywheel merge-result ${workflowId}\` to finish it.` : "The code commit is not on the workflow base, so a rerun cannot resume it; commit the staged task metadata manually.");
+      if (!options.dryRun && mergeLockAcquired) {
+        try {
+          await updateManifestApplyStatus(workflowId, { applyError: pendingError });
+        } catch {
+        }
+      }
+      console.error(chalk4.red(`
+  Merge incomplete: ${pendingError}
+`));
+      return {
+        success: false,
+        workflowId,
+        applied: true,
+        error: pendingError,
+        ...leftMidMergeWarning ? { warnings: [leftMidMergeWarning] } : {}
+      };
+    }
+    const unverifiedCommitError = applyMaterialized && committedTreeAuthorityFailed ? committedTreeChangeReported ? errorMsg : `${errorMsg} The materialized commit ${appliedCommitSha ?? "(unknown SHA)"} was preserved for recovery and is not a verified apply.` : void 0;
+    if (!options.dryRun && mergeLockAcquired && (mergeMutationStarted || applyMaterialized)) {
+      try {
+        const sourceBranch = integrationBranchForRecovery ?? null;
+        const sourceBranchRole = sourceBranch ? classifyBranchRole(sourceBranch) : null;
+        const applyTargetBranch = branchRoleApplyTarget;
+        const applyTargetBranchRole = applyTargetBranch ? classifyBranchRole(applyTargetBranch, void 0, mergeCwd) : void 0;
+        const branchRoleOverride = applyTargetBranchRole === "protected" ? options.allowProtected ? "--allow-protected" : options.allowMain ? "--allow-main" : null : null;
+        const branchRoleErrorStatus = {
+          sourceBranch,
+          sourceBranchRole,
+          applyTargetBranch,
+          applyTargetBranchRole,
+          branchRoleAction: branchRoleOverride ? "overridden" : "product-fix",
+          branchRoleOverride,
+          branchRoleRefused: false
+        };
+        const applyFailedIntegrationSha = await resolveIntegrationTipForRecovery(
+          mergeCwd,
+          integrationBranchForRecovery
+        );
+        await updateManifestApplyStatus(
+          workflowId,
+          applyMaterialized && !unverifiedCommitError ? {
+            appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            postApplyError: errorMsg,
+            verifiedTreeFingerprint: applyProofTreeFingerprint(),
+            appliedCommitSha,
+            ...branchRoleErrorStatus
+          } : {
+            applyError: unverifiedCommitError ?? errorMsg,
+            ...applyFailedIntegrationSha ? { applyFailedIntegrationSha } : {},
+            // Same proof as the success path: the tree this apply was
+            // authorized to commit. Recording it keeps reentry's refusal of
+            // the preserved, authority-failed commit exact.
+            ...unverifiedCommitError ? { verifiedTreeFingerprint: applyProofTreeFingerprint() } : {},
+            ...branchRoleErrorStatus
+          }
+        );
+      } catch {
+      }
+    }
+    if (unverifiedCommitError) {
+      console.error(chalk4.red(`
+  Merge failed: ${unverifiedCommitError}
+`));
+      return {
+        success: false,
+        workflowId,
+        applied: true,
+        error: unverifiedCommitError,
+        ...leftMidMergeWarning ? { warnings: [leftMidMergeWarning] } : {}
+      };
+    }
+    if (applyMaterialized) {
+      console.warn(chalk4.yellow(`
+  Post-apply cleanup failed: ${errorMsg}
+`));
+      console.warn(
+        chalk4.yellow("  Applied changes were preserved; post-apply cleanup needs follow-up.")
+      );
+      return {
+        success: true,
+        degraded: true,
+        workflowId,
+        applied: true,
+        cleanupFailed: true,
+        postApplyError: errorMsg,
+        warnings: [errorMsg, ...leftMidMergeWarning ? [leftMidMergeWarning] : []]
+      };
+    }
+    console.error(chalk4.red(`
+  Merge failed: ${errorMsg}
+`));
+    if (error instanceof SquashMergeConflictError && integrationBranchForRecovery && currentBranchForRecovery) {
+      try {
+        const conflictBranch = buildConflictBranchName(workflowId);
+        const worktreePath = path4.join(
+          mergeCwd,
+          ".build-project",
+          "tmp",
+          "merge-conflicts",
+          workflowId.replace(/[^a-zA-Z0-9._-]/g, "_")
+        );
+        await fs4.mkdir(worktreePath, { recursive: true });
+        const conflictWorktreeResult = await execGit(
+          ["worktree", "add", "-b", conflictBranch, worktreePath, currentBranchForRecovery],
+          {
+            cwd: mergeCwd,
+            timeoutMs: 6e4
+          }
+        );
+        if (conflictWorktreeResult.exitCode !== 0) {
+          throw new Error(
+            conflictWorktreeResult.stderr.trim() || "git worktree add for conflict recovery failed"
+          );
+        }
+        await execa2("git", ["merge", "--squash", integrationBranchForRecovery], {
+          cwd: worktreePath,
+          stdio: isQuietOutputRequested() ? "pipe" : "inherit",
+          timeout: 6e4,
+          reject: false
+        });
+        console.error(chalk4.yellow("  Conflict-resolution worktree created:"));
+        console.error(chalk4.yellow(`    ${worktreePath}`));
+        console.error(
+          chalk4.yellow(
+            `  Resolve conflicts there, commit, then cherry-pick onto ${currentBranchForRecovery} (or open a PR).`
+          )
+        );
+      } catch {
+      }
+    }
+    console.error(chalk4.yellow("  Run branch preserved for manual recovery:"));
+    console.error(
+      chalk4.yellow(`    ${integrationBranchForRecovery ?? "(unknown - manifest unavailable)"}`)
+    );
+    return {
+      success: false,
+      workflowId,
+      error: errorMsg,
+      ...leftMidMergeWarning ? { degraded: true, warnings: [leftMidMergeWarning] } : {}
+    };
+  } finally {
+    try {
+      await restoreAutoStash();
+      if (releaseApplyLock) {
+        try {
+          await releaseApplyLock();
+        } catch {
+        }
+      }
+      if (mergeLockAcquired) {
+        try {
+          const currentLockPid = await readLockPid(mergeLockPath);
+          if (currentLockPid === thisPid) {
+            await fs4.unlink(mergeLockPath);
+          }
+        } catch {
+        }
+      }
+    } finally {
+      signalFinalizer?.finish();
+    }
+  }
+}
+async function cleanupBranchAndWorktree(integrationBranch, workflowId) {
+  const preserveWorktrees = readEnv(BUILD_PRESERVE_WORKTREES).value || isLabModeFromEnv();
+  if (classifyBranchRole(integrationBranch) !== "generated-artifact") {
+    console.log(
+      chalk4.yellow(`    Warning: Refusing to delete non-generated branch ${integrationBranch}`)
+    );
+    return;
+  }
+  const worktreeManager = WorktreeManagerPresets.orchestrator();
+  try {
+    const worktreePath = await findWorktreePathForBranch(integrationBranch);
+    if (worktreePath) {
+      await worktreeManager.cleanup(worktreePath, {
+        preserve: preserveWorktrees
+      });
+      if (workflowId) {
+        await trackWorktreeCleaned(workflowId, worktreePath);
+      }
+      console.log(chalk4.dim("    Worktree cleaned up"));
+    }
+  } catch (error) {
+    console.log(
+      chalk4.yellow(
+        `    Warning: Failed to cleanup worktree: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+  try {
+    const deleteResult = await execGit(["branch", "-D", integrationBranch], {
+      cwd: getProjectRoot(),
+      timeoutMs: 1e4
+    });
+    if (deleteResult.exitCode !== 0) {
+      throw new Error(deleteResult.stderr.trim() || "git branch -D failed");
+    }
+    console.log(chalk4.dim(`    Integration branch deleted: ${integrationBranch}`));
+  } catch (error) {
+    console.log(
+      chalk4.yellow(
+        `    Warning: Failed to delete branch: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function cleanupRelatedBranchesAndWorktrees(opts) {
+  const preserveWorktrees = readEnv(BUILD_PRESERVE_WORKTREES).value || isLabModeFromEnv();
+  if (preserveWorktrees) return;
+  await cleanupWorkflowRelatedBranchesAndWorktrees({
+    integrationBranch: opts.integrationBranch,
+    relatedTaskIds: opts.relatedTaskIds,
+    trackedBranches: opts.trackedBranches,
+    trackedWorktrees: opts.trackedWorktrees,
+    dryRun: false
+  });
+}
+async function cleanupArtifacts(opts) {
+  console.log(chalk4.cyan("  Cleaning up run branch/worktree and artifacts..."));
+  await cleanupBranchAndWorktree(opts.integrationBranch, opts.workflowId);
+  await cleanupRelatedBranchesAndWorktrees({
+    integrationBranch: opts.integrationBranch,
+    relatedTaskIds: opts.relatedTaskIds,
+    trackedBranches: opts.trackedBranches,
+    trackedWorktrees: opts.trackedWorktrees
+  });
+  try {
+    const artifactDir = getArtifactDir(opts.workflowId);
+    await fs4.rm(artifactDir, { recursive: true, force: true });
+    console.log(chalk4.dim("    Artifact directory removed"));
+  } catch (error) {
+    console.log(
+      chalk4.yellow(
+        `    Warning: Failed to remove artifacts: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function logPreservedRunArtifacts(integrationBranch) {
+  const worktreePath = await findWorktreePathForBranch(integrationBranch);
+  console.log(chalk4.dim("  Run branch/worktree preserved (--keep-artifacts)"));
+  console.log(chalk4.dim(`    Branch: ${integrationBranch}`));
+  if (worktreePath) {
+    console.log(chalk4.dim(`    Worktree: ${worktreePath}`));
+  }
+}
+async function findWorktreePathForBranch(branchName, repoCwd = getProjectRoot()) {
+  const { stdout } = await execa2("git", ["worktree", "list", "--porcelain"], {
+    cwd: repoCwd,
+    stdio: "pipe",
+    timeout: 1e4
+  });
+  const targetRef = `refs/heads/${branchName}`;
+  let currentWorktreePath;
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      currentWorktreePath = line.slice("worktree ".length).trim();
+      continue;
+    }
+    if (line.startsWith("branch ") && currentWorktreePath) {
+      const ref = line.slice("branch ".length).trim();
+      if (ref === targetRef) {
+        return currentWorktreePath;
+      }
+    }
+  }
+  return void 0;
+}
+async function getGitUsername() {
+  try {
+    const { stdout } = await execa2("git", ["config", "user.name"], {
+      timeout: 5e3
+    });
+    return stdout.trim();
+  } catch {
+    return "unknown";
+  }
+}
+async function getCurrentBranch(cwd = getProjectRoot()) {
+  const { stdout } = await execa2("git", ["rev-parse", "--symbolic-full-name", "HEAD"], {
+    cwd,
+    stdio: "pipe",
+    timeout: 5e3
+  });
+  return parseCurrentBranchRef(stdout);
+}
+
+export {
+  probeGithubHost,
+  applyTaskTransitions,
+  preservedStageBranches,
+  mergeWorkflowResult
+};
+//# sourceMappingURL=chunk-6KZKRTG3.js.map