@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-CVMVZWG4.js

@@ -0,0 +1,3544 @@
+import {
+  resolvePlanArtifactPath
+} from "./chunk-RJAAKDRX.js";
+import {
+  abortPendingSquashMerge,
+  acquireFlywheelApplyLock,
+  trackWorktreeCleaned
+} from "./chunk-EX3OM35G.js";
+import {
+  listFlywheelBranches
+} from "./chunk-HY3ESWCA.js";
+import {
+  isSystemWritePath
+} from "./chunk-ZIPWI2LY.js";
+import {
+  applyTaskTransitionOutcome,
+  completeTask,
+  createTask,
+  deriveTransitionIdentity,
+  getTask
+} from "./chunk-SUZ7UYZH.js";
+import {
+  cleanupWorkflowRelatedBranchesAndWorktrees
+} from "./chunk-V6YLL5WA.js";
+import {
+  WorktreeManagerPresets
+} from "./chunk-66CIO2SV.js";
+import {
+  listTasksInSprint,
+  refreshSprintMarkdown
+} from "./chunk-XUSRFFA7.js";
+import {
+  getPlanningRoot,
+  withDeferredIndexRegeneration
+} from "./chunk-OPYFYTWQ.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind,
+  getBuckets
+} from "./chunk-HOYBYAOA.js";
+import {
+  getArtifactDir,
+  getManifestStatus,
+  getProjectRoot,
+  getResultPath,
+  getTrackedCleanupTargets,
+  loadManifest,
+  loadTriage,
+  updateManifestApplyStatus
+} from "./chunk-CQM3A35X.js";
+import {
+  shouldExcludeFile
+} from "./chunk-NS33V3IM.js";
+import {
+  buildProjectVerificationGuidance
+} from "./chunk-MCPQNJMK.js";
+import {
+  isRecord
+} from "./chunk-S54MKU6V.js";
+import {
+  createVerificationCommandEnv
+} from "./chunk-FEQ4HXL7.js";
+import {
+  wrapWithSandbox
+} from "./chunk-2AICM4P3.js";
+import {
+  isWorktreeRunSentinelPath
+} from "./chunk-I5WRT7ZR.js";
+import {
+  pruneGitWorktreeEntries
+} from "./chunk-5EERLVZB.js";
+import {
+  assertBranchAllowsCodeApply,
+  classifyBranchRole,
+  isDisposableBranchRole
+} from "./chunk-XQD2B6BB.js";
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  isAllowedVerifyCommand,
+  isBaselineComparableTypeScriptCommand
+} from "./chunk-QU6JQJMH.js";
+import {
+  resolveExecutionBoundary
+} from "./chunk-7R2WLDOS.js";
+import {
+  detectProjectCapabilities
+} from "./chunk-GNH3QGTL.js";
+import {
+  isProjectTestPath
+} from "./chunk-UDMS5AD3.js";
+import {
+  isQuietOutputRequested
+} from "./chunk-FKAUPHMR.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  isLabModeFromEnv
+} from "./chunk-PGSPX4SU.js";
+import {
+  emitCustomWarning,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_AUTOMERGE_MODE,
+  POETIC_PRESERVE_WORKTREES,
+  readEnv
+} from "./chunk-5DLKYTQX.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);
+    if (tasks.length === 0) return 0;
+    const completedTasks = tasks.filter((t) => t.status === "done");
+    return completedTasks.length / tasks.length * 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)}%`);
+  if (result.details.some((d) => d.error)) {
+    lines.push("");
+    lines.push("Errors:");
+    for (const detail of result.details) {
+      if (detail.error) {
+        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.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);
+        if (errorMsg.includes("ENOENT") || errorMsg.includes("not found")) {
+          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 {
+      await completeTask(pending.taskId, { completionContractRoot: planningRoot });
+      completionsSucceeded++;
+      pending.detail.previousStatus = pending.previousStatus;
+      pending.detail.newStatus = "done";
+      pending.detail.updated = true;
+      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 { existsSync as existsSync2, readFileSync } from "fs";
+import * as fs2 from "fs/promises";
+import * as os from "os";
+import * as path2 from "path";
+import chalk3 from "chalk";
+import { execa as execa4 } from "execa";
+import yaml from "js-yaml";
+
+// 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);
+}
+async function snapshotDirtyPlanningPaths(params) {
+  const { cwd, allowlistPrefixes } = params;
+  const status = await execa(
+    "git",
+    ["status", "--porcelain=v1", "-z", "--", ...allowlistPrefixes],
+    { cwd, stdio: "pipe", timeout: 3e4, reject: false }
+  );
+  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;
+}
+
+// src/automation/flywheel-merge-biome-repair.ts
+import * as fs from "fs/promises";
+import chalk2 from "chalk";
+import { execa as execa3 } from "execa";
+
+// src/automation/flywheel-biome-repair.ts
+var MAX_TIMEBOX_MS = resolveExecutionBoundary("short-command").hardCeilingMs;
+
+// src/automation/sandboxed-project-bin.ts
+import { existsSync } from "fs";
+import path from "path";
+import { execa as execa2 } from "execa";
+
+// src/automation/flywheel-merge.ts
+function readPackageJson(projectRoot) {
+  try {
+    const raw = readFileSync(path2.join(projectRoot, "package.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function packageJsonDeclaresDependency(pkg, name) {
+  if (!pkg) return false;
+  for (const key of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ]) {
+    const value = pkg[key];
+    if (isRecord(value) && typeof value[name] === "string") return true;
+  }
+  return false;
+}
+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 packageJson = readPackageJson(capabilities.root);
+  const hasVitest = existingCommands.some(commandUsesVitest) || packageJsonDeclaresDependency(packageJson, "vitest");
+  if (hasVitest) {
+    return {
+      kind: "focused",
+      command: `npx --no-install vitest run ${quotePosixShellArg(testFile)}`
+    };
+  }
+  const wholeSuite = capabilities.verification.test;
+  if (wholeSuite.length > 0) {
+    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: `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(
+        chalk3.cyan(
+          `  Applying triage for stage ${stageId}: discarding ${toDiscard.length} file(s)...`
+        )
+      );
+      await execa4("git", ["reset", "HEAD", "--", ...toDiscard], {
+        cwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      const tracked = [];
+      const untracked = [];
+      for (const f of toDiscard) {
+        const check = await execa4("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 execa4("git", ["checkout", "--", ...tracked], {
+          cwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+      if (untracked.length > 0) {
+        await execa4("git", ["clean", "-f", "--", ...untracked], {
+          cwd,
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+      console.log(chalk3.dim(`    Discarded: ${formatPathList(toDiscard)}`));
+    }
+    if (followUps.length > 0 && sprintId) {
+      console.log(chalk3.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(chalk3.dim(`    - Created task ${task.id} for ${file}`));
+        } catch (error) {
+          const errMsg = error instanceof Error ? error.message : String(error);
+          console.log(
+            chalk3.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(
+        chalk3.yellow(`  Warning: ${followUps.length} follow-up(s) skipped: no sprintId in manifest`)
+      );
+    }
+  }
+  return { followUpFailures };
+}
+function parseGitStatusPorcelain(output) {
+  const lines = output.split("\n").map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  return lines.map((line) => {
+    const status = line.slice(0, 2);
+    const filePath = line.slice(3);
+    const arrowIndex = filePath.indexOf(" -> ");
+    if (arrowIndex >= 0) {
+      return {
+        status,
+        originalPath: filePath.slice(0, arrowIndex),
+        path: filePath.slice(arrowIndex + " -> ".length)
+      };
+    }
+    return { status, path: filePath };
+  });
+}
+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 toPosixRelative(fromDir, toPath) {
+  return path2.relative(fromDir, toPath).replace(/\\/g, "/");
+}
+function getPlanningDirtyAllowlistPrefixes(repoRoot) {
+  const bucketPaths = getBuckets(repoRoot).map((b) => b.path);
+  const extraPaths = [".poetic/", "planning/"];
+  return [...bucketPaths, ...extraPaths].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 execa4("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) {
+  return entries.filter(
+    (entry) => entry.status === "??" || isTrackedStatusChange(entry.status) && hasUnstagedTrackedChange(entry.status)
+  ).flatMap(getStatusEntryPathspecs).filter((pathname) => !isWorktreeRunSentinelPath(pathname) && !shouldExcludeFile(pathname));
+}
+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 finalizeVerifiedTreeFingerprint(cwd, prospectiveFingerprint) {
+  const statusAfterVerify = await execGit(["status", "--porcelain=v1", "--untracked-files=all"], {
+    cwd,
+    timeoutMs: 3e4
+  });
+  if (statusAfterVerify.exitCode !== 0) {
+    throw new Error("Post-merge verify gate could not inspect the verified worktree state.");
+  }
+  const verifyMutations = relevantPostVerifyMutations(
+    parseGitStatusPorcelain(statusAfterVerify.stdout)
+  );
+  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 || finalTree.stdout.trim() !== verifiedTreeFingerprint) {
+    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[POETIC_AUTOMERGE_MODE.name]?.trim();
+  if (envMode === "label" || envMode === "auto") {
+    return "Auto-merge configuration is deprecated and has no effect; Poetic creates the PR but never labels or merges it.";
+  }
+  return void 0;
+}
+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;
+}
+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) {
+  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;
+  return {
+    passed,
+    source: "execution",
+    decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reason: passed ? "All stage gates passed" : [
+      needsRepairCount > 0 ? `${needsRepairCount} stage(s) need repair` : null,
+      verificationFailedCount > 0 ? `${verificationFailedCount} stage(s) failed verification` : null
+    ].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) : null;
+}
+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;
+}
+function getStagesWithDriftFromWorkflowResult(parsed) {
+  if (!isRecord(parsed)) return null;
+  const stageResults = readArrayField(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: readStringField(stageResult, "stageId") ?? "(unknown)",
+      violations,
+      mode: readStringField(drift, "mode") ?? "warn"
+    });
+  }
+  return stagesWithDrift;
+}
+async function listStagedFiles(cwd) {
+  const { stdout } = await execa4("git", ["diff", "--cached", "--name-only", "--diff-filter=d"], {
+    cwd,
+    stdio: "pipe",
+    timeout: 3e4
+  });
+  return stdout.split("\n").map((line) => line.replace(/\r$/, "")).filter(Boolean);
+}
+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(path2.extname(file).toLowerCase()));
+}
+async function runBiome(args, cwd) {
+  const env = createVerificationCommandEnv();
+  const sandboxed = wrapWithSandbox({
+    workingDir: cwd,
+    command: "npx",
+    args: ["--no-install", "biome", ...args],
+    providerName: "project-verification",
+    env,
+    allowGitWrites: false,
+    providerId: "project-verification"
+  });
+  const result = await execa4(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 isResolverBiomeAvailable(root) {
+  const guidance = buildProjectVerificationGuidance(root, []);
+  return guidance.commands.some(
+    (command) => (command.kind === "format" || command.kind === "lint") && /(?:^|\s)biome(?:\s|$)/.test(command.command)
+  );
+}
+function formatBiomeFailureSummary(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 = readArrayField(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 = readStringField(r, "stageId") ?? "(unknown)";
+    const winnerNeedsRepair = Boolean(readBooleanField(r, "winnerNeedsRepair"));
+    const mergeGate = isRecord(r.mergeGate) ? r.mergeGate : void 0;
+    const verification = r.verification;
+    const stageType = readStringField(r, "stageType");
+    const verifyCommands = readArrayField(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;
+}
+function getWorkflowVerifyStageStatusFromResult(parsed) {
+  if (!isRecord(parsed)) return null;
+  const stageResults = readArrayField(parsed, "stageResults");
+  if (!stageResults) return null;
+  const statuses = [];
+  for (const r of stageResults) {
+    if (!isRecord(r)) continue;
+    const stageType = readStringField(r, "stageType");
+    const verifyCommands = readArrayField(r, "verifyCommands");
+    const isVerifyStage = stageType === "verify" || Boolean(verifyCommands);
+    if (!isVerifyStage) continue;
+    const stageId = readStringField(r, "stageId") ?? "(unknown)";
+    const validationPassed = Boolean(readBooleanField(r, "validationPassed"));
+    const durationMs = typeof r.durationMs === "number" && Number.isFinite(r.durationMs) ? r.durationMs : void 0;
+    const commandsCount = Array.isArray(verifyCommands) ? verifyCommands.length : 0;
+    statuses.push({ stageId, validationPassed, durationMs, commandsCount });
+  }
+  return statuses;
+}
+function formatVerifyStatusForCommitMessage(parsed) {
+  const verifyStages = getWorkflowVerifyStageStatusFromResult(parsed);
+  if (!verifyStages || verifyStages.length === 0) return null;
+  const totalStages = verifyStages.length;
+  const passedStages = verifyStages.filter((s) => s.validationPassed).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`;
+  return `Verify: ${passedStages}/${totalStages} passed, ${commandsLabel}${stageLabel}`;
+}
+async function loadWorkflowResultForGate(workflowId) {
+  let content;
+  try {
+    const resultPath = getResultPath(workflowId);
+    content = await fs2.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"
+  });
+}
+function isPostMergeDiscoveredTestFile(filePath) {
+  return isProjectTestPath(filePath);
+}
+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 = readArrayField(current, "verifyCommands");
+    if (verifyCommands) {
+      for (const entry of verifyCommands) {
+        if (!isRecord(entry)) continue;
+        const command = readStringField(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: readStringField(entry, "outputTail"),
+          stdoutTail: readStringField(entry, "stdoutTail"),
+          stderrTail: readStringField(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;
+  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
+  });
+  const capabilities = detectProjectCapabilities(projectRoot);
+  const pushCommand = (cmd) => {
+    if (!commands.includes(cmd)) {
+      commands.push(cmd);
+    }
+  };
+  const stagedFiles = await listStagedFiles(mergeCwd);
+  const stagedTestFiles = stagedFiles.filter(isPostMergeDiscoveredTestFile);
+  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(
+      chalk3.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(
+    chalk3.cyan(`  Post-merge verify (${commands.length} cmd${commands.length === 1 ? "" : "s"})...`)
+  );
+  const { runVerifyCommands } = await import("./verify-commands-5F6CJV4B.js");
+  let baselineCwd;
+  let historicalVerifyResults = [];
+  let verifyAllowlistStashSha;
+  if (preMergeHeadSha && commands.some((command) => isBaselineComparableTypeScriptCommand(command))) {
+    const baselinePrefix = path2.join(projectRoot, ".poetic", "tmp", "post-merge-verify-");
+    baselineCwd = await fs2.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 fs2.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 fs2.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 execa4("git", ["stash", "apply", verifyAllowlistStashSha], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 6e4,
+        reject: false
+      });
+      if ((applyResult.exitCode ?? 1) === 0) {
+        const listResult = await execa4("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 execa4("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(
+          chalk3.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 fs2.rm(baselineCwd, { recursive: true, force: true });
+    } catch {
+    }
+    try {
+      await pruneGitWorktreeEntries({ cwd: projectRoot, timeoutMs: 1e4 });
+    } catch {
+    }
+    let stillPresent = false;
+    try {
+      stillPresent = existsSync2(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 = path2.resolve(baselineCwd);
+          registrationState = listResult.stdout.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => path2.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(
+        chalk3.yellow(
+          "  Warning: post-merge verify baseline worktree may not have been fully removed."
+        )
+      );
+    }
+  };
+  try {
+    if (ambientAllowlistedPaths.length > 0) {
+      const stashMessage = `[Poetic Flywheel] post-merge verify allowlist stash ${workflowId}`;
+      const stashResult = await execa4(
+        "git",
+        ["stash", "push", "--keep-index", "-m", stashMessage, "--", ...ambientAllowlistedPaths],
+        {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 6e4,
+          reject: false
+        }
+      );
+      const stashOutput = `${stashResult.stdout ?? ""}
+${stashResult.stderr ?? ""}`;
+      if ((stashResult.exitCode ?? 1) !== 0) {
+        throw new Error(
+          "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(
+            chalk3.yellow(
+              "  Warning: post-merge verify allowlist stash created but unresolved; preserved on the stash stack."
+            )
+          );
+        }
+      }
+    }
+    const prospectiveTreeFingerprint = await captureProspectiveTreeFingerprint(mergeCwd);
+    onVerificationStarted?.();
+    const verifyOutput = await runVerifyCommands({
+      cwd: mergeCwd,
+      commands,
+      baselineCwd
+    });
+    if (verifyOutput.passed) {
+      const { summarizeVerifyCommandRun } = await import("./verify-commands-5F6CJV4B.js");
+      console.log(
+        chalk3.green(`  ok ${summarizeVerifyCommandRun(verifyOutput.results, commands.length)}`)
+      );
+      verifyPassed = true;
+      verifiedTreeFingerprint = await finalizeVerifiedTreeFingerprint(
+        mergeCwd,
+        prospectiveTreeFingerprint
+      );
+    }
+    if (!verifyPassed) {
+      const failedCmd = verifyOutput.results.find((r) => r.exitCode !== 0);
+      const failedLabel = failedCmd?.command ?? "(unknown)";
+      const outputSnippet = failedCmd?.stderrTail || failedCmd?.stdoutTail || "";
+      const matchingStageVerify = failedCmd ? historicalVerifyResults.find(
+        (result) => result.command === failedCmd.command && result.exitCode === 0
+      ) : void 0;
+      const baselineDivergenceMessage = failedCmd && matchingStageVerify ? buildPostMergeBaselineDivergenceMessage({
+        command: failedCmd.command,
+        stageResult: matchingStageVerify,
+        mergeResult: failedCmd,
+        stageBaseSha: manifest.baseSha,
+        mergeBaseSha: preMergeHeadSha
+      }) : null;
+      const driftDetection = detectContractDrift(outputSnippet);
+      console.error(chalk3.red("\n  Post-merge verify FAILED"));
+      console.error(
+        chalk3.red("    Verify passed on orchestrator-root but failed on squash-merged tree.")
+      );
+      console.error(
+        chalk3.red(`    Failed command: ${failedLabel} (exit ${failedCmd?.exitCode ?? 1})`)
+      );
+      if (baselineDivergenceMessage) {
+        console.error(chalk3.yellow(`    ${baselineDivergenceMessage}`));
+      }
+      if (driftDetection.isDrift) {
+        console.error(
+          chalk3.yellow(
+            `
+    Failure classification: ${CROSS_SUBSTAGE_CONTRACT_DRIFT}` + (driftDetection.symbols.length > 0 ? ` (symbols: ${driftDetection.symbols.slice(0, 5).join(", ")})` : "")
+          )
+        );
+        console.error(
+          chalk3.yellow(
+            "    A sibling substage generated tests asserting an incompatible return shape for a shared symbol."
+          )
+        );
+      }
+      if (outputSnippet) {
+        const truncated = outputSnippet.split("\n").slice(-20).join("\n");
+        console.error(chalk3.dim(truncated));
+      }
+      console.error(
+        chalk3.yellow(`
+    Integration branch preserved: ${manifest.integrationBranch}`)
+      );
+      console.error(chalk3.yellow(`    Workflow: ${workflowId}`));
+      console.error(
+        chalk3.gray(
+          "\n    To retry after fixing: poetic flywheel merge-result " + workflowId + "\n    To skip this gate:     poetic flywheel merge-result " + workflowId + " --skip-verify"
+        )
+      );
+      const baseErrorMessage = 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) => {
+    if (stage.type === "verify") {
+      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;
+}
+async function resolvePostMergeVerifyCommands(params) {
+  const { workflowId, manifest, projectRoot, verificationRoot = projectRoot } = params;
+  let commands;
+  let generatedWorkflow = false;
+  if (manifest.planArtifactPath) {
+    try {
+      const planPath = resolvePlanArtifactPath(manifest.planArtifactPath, projectRoot);
+      const raw = await fs2.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;
+    if (!manifest.generatedYamlPath) {
+      throw new Error(
+        `Post-merge verify gate cannot run: workflow ${workflowId} has neither a plan artifact nor generated workflow YAML.`
+      );
+    }
+    try {
+      const workflowPath = path2.isAbsolute(manifest.generatedYamlPath) ? manifest.generatedYamlPath : path2.resolve(projectRoot, manifest.generatedYamlPath);
+      const raw = await fs2.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-LTSIZN2L.js");
+      const workflow = await new WorkflowExecutor().loadWorkflow(workflowPath);
+      commands = extractVerifyCommandsFromWorkflow(workflow);
+    } catch (error) {
+      throw new Error(
+        `Post-merge verify gate cannot run: unable to load generated workflow ${manifest.generatedYamlPath}. Cause: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (!generatedWorkflow) {
+    return commands.filter(isAllowedVerifyCommand);
+  }
+  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 flywheelMergeCommitSubject(workflowId) {
+  return `[Poetic Flywheel] Merge workflow result ${workflowId}`;
+}
+function flywheelApplyTrailers(workflowId, role) {
+  return `Poetic-Workflow-Id: ${workflowId}
+Poetic-Apply-Role: ${role}`;
+}
+function flywheelPrTitle(workflowId) {
+  return `[Flywheel] Merge workflow result ${workflowId}`;
+}
+async function reconcileAppliedFromGitLog(params) {
+  const { cwd, workflowId, baseSha, integrationBranch, expectedBranch } = params;
+  const subject = flywheelMergeCommitSubject(workflowId);
+  if (expectedBranch) {
+    const branchResult = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      timeoutMs: 1e4
+    });
+    if (branchResult.exitCode !== 0) {
+      return {
+        kind: "ambiguous",
+        reason: `Could not resolve current branch while reconciling appliedAt for ${workflowId}`
+      };
+    }
+    const currentBranch = branchResult.stdout.trim();
+    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("Poetic-Workflow-Id: ")) {
+        workflowIds.push(line.slice("Poetic-Workflow-Id: ".length));
+      } else if (line.startsWith("Poetic-Apply-Role: ")) {
+        roles.push(line.slice("Poetic-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("Poetic-Workflow-Id: ") || line.startsWith("Poetic-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 === subject && parentSha === baseSha && headTreeResult.stdout.trim() === integrationTreeResult.stdout.trim()) {
+    return { kind: "adopt", value: { sha, committedAt: committedAt.trim() } };
+  }
+  if (headRole === "code" && msgSubject === subject && parentSha === baseSha) {
+    const statusResult = await execGit(["status", "--porcelain=v1", "--untracked-files=all"], {
+      cwd,
+      timeoutMs: 1e4
+    });
+    if (statusResult.exitCode !== 0) return { kind: "none" };
+    const hasPendingSystemWrites = parseGitStatusPorcelain(statusResult.stdout).some(
+      (entry) => getStatusEntryPathspecs(entry).some((filePath) => isSystemWritePath(filePath))
+    );
+    if (hasPendingSystemWrites) return { kind: "none" };
+    return { kind: "adopt", value: { sha, committedAt: committedAt.trim() } };
+  }
+  if (headRole !== "metadata" || msgSubject !== "chore: sync task/sprint metadata [flywheel]")
+    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 || parentSubject !== subject || 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 execa4(
+      "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 readPrHeadSha(cwd, prUrl) {
+  const result = await execa4("gh", ["pr", "view", prUrl, "--json", "headRefOid"], {
+    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");
+  }
+  return parsed.headRefOid;
+}
+async function mergeWorkflowResult(options) {
+  const { workflowId } = options;
+  const mergeCwd = getProjectRoot();
+  const mergeLockPath = path2.join(getArtifactDir(workflowId), ".merge.lock");
+  const legacyLockPath = path2.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 fs2.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 fs2.unlink(mergeLockPath).catch(() => {
+    });
+    await fs2.unlink(legacyLockPath).catch(() => {
+    });
+  }
+  let integrationBranchForRecovery;
+  let preMergeHeadSha;
+  let didCommit = false;
+  let mergeMutationStarted = false;
+  let applyMaterialized = false;
+  let currentBranchForRecovery;
+  let didAutoStash = false;
+  let autoStashSha;
+  let dirtyPlanningUnstagedPaths = [];
+  let taskSyncFailures;
+  let followUpFailures;
+  const postMergeWarnings = [];
+  let verifiedTreeFingerprint;
+  let postMergeVerificationStarted = false;
+  let appliedCommitSha;
+  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 {
+    }
+  };
+  let hadPreExistingTrackedPlanningEdits = false;
+  let branchRoleApplyTarget;
+  let mergeLockAcquired = false;
+  let releaseApplyLock;
+  const assertApplyLockOwned = async () => {
+    if (releaseApplyLock) {
+      await releaseApplyLock.assertOwned();
+    }
+  };
+  const acquireMergeLock = async () => {
+    if (options.dryRun || mergeLockAcquired) return;
+    await fs2.mkdir(getArtifactDir(workflowId), { recursive: true });
+    try {
+      await fs2.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 fs2.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 fs2.writeFile(mergeLockPath, buildLockPayload(), { flag: "wx" });
+      mergeLockAcquired = true;
+    }
+  };
+  const restoreAutoStash = async () => {
+    if (!didAutoStash) return;
+    didAutoStash = false;
+    const quiet = isQuietOutputRequested();
+    if (!quiet) {
+      console.log(chalk3.cyan("  Restoring auto-stashed changes..."));
+    }
+    if (releaseApplyLock) {
+      try {
+        await releaseApplyLock.assertOwned();
+      } catch (ownershipError) {
+        const detail = ownershipError instanceof Error ? ownershipError.message : String(ownershipError);
+        const warning = `Auto-stashed changes were NOT restored because checkout apply-lock ownership was lost (${detail}). The stash is preserved${autoStashSha ? ` at ${autoStashSha}` : ""}. Recover manually with: git stash list | grep "Poetic Flywheel"`;
+        console.error(chalk3.yellow(`  Warning: ${warning}`));
+        postMergeWarnings.push(warning);
+        return;
+      }
+    }
+    if (!autoStashSha) {
+      console.error(
+        chalk3.yellow(
+          '  Warning: could not identify the auto-stash commit; leaving it stashed. Recover manually with: git stash list | grep "Poetic Flywheel"'
+        )
+      );
+      return;
+    }
+    try {
+      const applyResult = await execa4("git", ["stash", "apply", autoStashSha], {
+        cwd: mergeCwd,
+        stdio: quiet ? "pipe" : "inherit",
+        timeout: 6e4,
+        reject: false
+      });
+      if ((applyResult.exitCode ?? 1) !== 0) {
+        console.error(
+          chalk3.yellow(
+            `  Warning: failed to restore auto-stashed changes (git stash apply ${autoStashSha.slice(0, 7)} exited ${applyResult.exitCode ?? "unknown"}); the stash is preserved. Recover manually with: git stash list`
+          )
+        );
+        return;
+      }
+      const listResult = await execa4("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 execa4("git", ["stash", "drop", matchingRef], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4,
+          reject: false
+        });
+      }
+    } catch (restoreError) {
+      const detail = restoreError instanceof Error ? restoreError.message : String(restoreError);
+      console.error(
+        chalk3.yellow(
+          `  Warning: error while restoring auto-stashed changes (${detail}); the stash is preserved. Recover manually with: git stash list | grep "Poetic Flywheel"`
+        )
+      );
+    }
+  };
+  try {
+    console.log(chalk3.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 ?? null;
+      const applyTargetBranchRole = applyTargetBranch ? classifyBranchRole(applyTargetBranch) : null;
+      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 refuseWithBranchRoleProvenance = async (message) => {
+      console.error(chalk3.red(message));
+      if (!options.dryRun) {
+        try {
+          await updateManifestApplyStatus(workflowId, {
+            sourceBranch: manifest.integrationBranch ?? null,
+            sourceBranchRole: manifest.integrationBranch ? classifyBranchRole(manifest.integrationBranch) : null,
+            applyTargetBranch: branchRoleApplyTarget ?? null,
+            applyTargetBranchRole: branchRoleApplyTarget ? classifyBranchRole(branchRoleApplyTarget) : null,
+            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: `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(chalk3.yellow(`  Already merged on ${manifest.appliedAt}`));
+      console.log(chalk3.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: manifest.applyTargetBranch ?? void 0
+      });
+      if (appliedReconcile.kind === "ambiguous") {
+        return {
+          success: false,
+          workflowId,
+          error: `Cannot reconcile applied state: ${appliedReconcile.reason}`
+        };
+      }
+      if (appliedReconcile.kind === "adopt") {
+        console.log(
+          chalk3.yellow(
+            `  Reconciled appliedAt from existing merge commit ${appliedReconcile.value.sha.slice(0, 7)}`
+          )
+        );
+        try {
+          await updateManifestApplyStatus(workflowId, {
+            appliedAt: appliedReconcile.value.committedAt,
+            appliedBy: await getGitUsername(),
+            ...branchRoleApplyStatus()
+          });
+        } catch {
+        }
+        return {
+          success: true,
+          workflowId,
+          alreadyMerged: true,
+          applied: true
+        };
+      }
+    }
+    if (!options.dryRun && !options.force && options.applyOnly && status === "staged" && manifest.stagedAt) {
+      console.log(chalk3.yellow(`  Already staged on ${manifest.stagedAt}`));
+      console.log(chalk3.yellow("  Use --force to re-stage"));
+      return { success: true, workflowId, alreadyStaged: true };
+    }
+    if (!options.dryRun && options.applyOnly && !manifest.stagedAt) {
+      const stagedReconcile = await reconcileApplyOnlyStagedEvidence({
+        cwd: mergeCwd,
+        baseSha: manifest.baseSha,
+        integrationBranch: manifest.integrationBranch
+      });
+      if (stagedReconcile.kind === "adopt") {
+        console.log(
+          chalk3.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(chalk3.red("  Previous merge failed:"));
+      console.log(chalk3.red(`  ${manifest.applyError}`));
+      if (!options.dryRun) {
+        console.log(chalk3.yellow("  Use --force to retry"));
+        if (!options.force) {
+          return { success: false, workflowId, error: manifest.applyError };
+        }
+      }
+    }
+    if (!options.dryRun && !options.pr) {
+      const { stdout: branchStdout } = await execa4("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 1e4
+      });
+      const currentBranch2 = branchStdout.trim();
+      branchRoleApplyTarget = currentBranch2;
+      try {
+        assertBranchAllowsCodeApply({
+          allowMain: options.allowMain,
+          allowProtected: options.allowProtected,
+          command: `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:
+  poetic flywheel merge-result ${workflowId} --dry-run` : "";
+        return await refuseWithBranchRoleProvenance(`${message}${validationDryRunHint}`);
+      }
+    }
+    const branches = await listFlywheelBranches({ testOnly: false });
+    const branchExists = branches.some((b) => b.name === manifest.integrationBranch);
+    if (!branchExists) {
+      if (options.dryRun && !options.force) {
+        if (status === "applied") {
+          console.log(chalk3.dim("  Run branch already cleaned up; no merge preview available."));
+          return { success: true, workflowId, alreadyMerged: true };
+        }
+        if (status === "failed" && manifest.applyError) {
+          console.log(chalk3.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);
+    if (options.pr) {
+      const warnings2 = [getAutomergeDeprecationWarning()].filter(
+        (warning) => Boolean(warning)
+      );
+      if (options.dryRun) {
+        console.log(chalk3.cyan("  Would create PR for workflow result\n"));
+        console.log(chalk3.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;
+        try {
+          prHeadSha = await readPrHeadSha(mergeCwd, manifest.prUrl);
+        } catch (error) {
+          return {
+            success: false,
+            workflowId,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+        if (prHeadSha !== localHeadSha) {
+          return {
+            success: false,
+            workflowId,
+            error: `PR head mismatch: expected ${localHeadSha}, found ${prHeadSha}`
+          };
+        }
+        await updateManifestApplyStatus(workflowId, { prHeadSha });
+        console.log(chalk3.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(chalk3.cyan("  Creating PR for workflow result..."));
+      const prBaseBranch = options.baseBranch ?? await getCurrentBranch(mergeCwd);
+      branchRoleApplyTarget = prBaseBranch;
+      const prBaseRole = classifyBranchRole(prBaseBranch);
+      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(chalk3.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.
+It will go through Quality Gate validation (CI tests, auto-fix, etc.) before merging.
+
+---
+*Generated by Poetic Flywheel*`;
+      try {
+        const prResult = await execa4(
+          "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(chalk3.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(
+            chalk3.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 (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) {
+      console.log(chalk3.cyan("  Merge Preview:\n"));
+      const { stdout: diffStat } = await execa4(
+        "git",
+        ["diff", "--stat", `${manifest.baseSha}..${manifest.integrationBranch}`],
+        { stdio: "pipe", timeout: 3e4 }
+      );
+      console.log(diffStat);
+      console.log("");
+      console.log(chalk3.dim("  No changes made (--dry-run)"));
+      return { success: true, workflowId };
+    }
+    const allowlistPrefixes = getPlanningDirtyAllowlistPrefixes(mergeCwd);
+    const { stdout: currentBranchStdout } = await execa4(
+      "git",
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      { cwd: mergeCwd, stdio: "pipe", timeout: 3e4 }
+    );
+    const currentBranch = currentBranchStdout.trim();
+    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 execa4("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(chalk3.yellow(`  Warning: ${msg}`));
+    }
+    if (!options.skipVerify) {
+      const blocking = workflowGateSummary !== null ? workflowGateSummary.passed === false ? workflowGateSummary.blockingStageIds : [] : (await getWorkflowVerificationGateStatus(workflowId))?.filter((s) => s.winnerNeedsRepair || !s.verificationPassed).map((s) => s.stageId) ?? [];
+      if (workflowGateSummary?.passed === false || blocking.length > 0) {
+        const blockingLabelSource = workflowGateSummary?.reason ?? "Workflow gate failed";
+        const lines = blocking.slice(0, 6).map((stageId) => `- ${stageId}`).join("\n");
+        const verificationPolicy = manifest.verificationPolicy;
+        const whySection = (workflowGateSummary?.needsRepairCount ?? 0) > 0 ? `Why did this happen?
+   Automatic repair was either disabled (--no-repair-on-findings) or failed to resolve all issues.
+
+RECOMMENDED: Re-run with automatic repair enabled (default behavior)
+   This will allow the system to automatically fix verification findings:
+
+   poetic sprint run --apply
+   # Defaults: --verification-policy findings (non-blocking) with repair enabled
+   # The winner will automatically attempt to fix verification findings
+
+ALTERNATIVE: Manually fix on the run branch
+   If you prefer manual control:
+
+   git checkout ${manifest.integrationBranch}
+   # Review findings, fix issues, and commit changes
+   poetic flywheel merge-result ${workflowId}
+
+` : verificationPolicy === "blocking" ? `Why did this happen?
+   Verification failed in blocking mode (--verification-policy blocking).
+   In blocking mode, failing candidates are disqualified and the workflow gate stays closed.
+
+RECOMMENDED: Re-run with non-blocking verification (default)
+   This allows repair to fix issues automatically:
+
+   poetic sprint run --apply
+   # Defaults: --verification-policy findings with repair enabled
+
+ALTERNATIVE: Manually fix verification failures
+   git checkout ${manifest.integrationBranch}
+   # Review findings, fix issues, and commit changes
+   poetic flywheel merge-result ${workflowId}
+
+` : `Why did this happen?
+   Verification failed during execution and the workflow was recorded as not mergeable.
+   Repair was not sufficient to clear the gate.
+
+RECOMMENDED: Re-run with automatic repair enabled (default behavior)
+   This allows the system to automatically fix verification issues:
+
+   poetic sprint run --apply
+   # Defaults: --verification-policy findings with repair enabled
+
+ALTERNATIVE: Manually fix verification failures
+   git checkout ${manifest.integrationBranch}
+   # Review findings, fix issues, and commit changes
+   poetic flywheel merge-result ${workflowId}
+
+`;
+        throw new Error(
+          "Cannot apply workflow result: " + blockingLabelSource + "\n" + (lines ? `
+Blocking stages:
+${lines}
+` : "") + "\n" + whySection + `OVERRIDE (not recommended): Skip verification gate
+   Only use this if you understand the risks:
+
+   poetic flywheel merge-result ${workflowId} --skip-verify
+
+Learn more: Run 'poetic sprint run --help' to see all verification and repair options.`
+        );
+      }
+    }
+    if (!options.dryRun) {
+      releaseApplyLock = await acquireFlywheelApplyLock(getProjectRoot());
+      await assertApplyLockOwned();
+    }
+    if (!options.dryRun) {
+      const { stdout: lockedHeadStdout } = await execa4("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 execa4("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)
+      );
+      const dirtyOther = dirtyEntries.filter(
+        (e) => !isStatusEntryInAllowlist(e, allowlistPrefixes)
+      );
+      dirtyPlanningUnstagedPaths = dirtyPlanning.filter((entry) => hasUnstagedTrackedChange(entry.status)).flatMap((entry) => getStatusEntryPathspecs(entry));
+      hadPreExistingTrackedPlanningEdits = dirtyPlanning.some(
+        (entry) => isTrackedStatusChange(entry.status)
+      );
+      if (dirtyOther.length > 0) {
+        console.log(
+          chalk3.yellow(
+            `  Detected uncommitted changes outside planning buckets (${dirtyOther.length}); auto-stashing for merge.`
+          )
+        );
+        console.log(
+          chalk3.dim(`    ${formatPathList(dirtyOther.flatMap(getStatusEntryPathspecs))}`)
+        );
+        const stashMessage = `[Poetic Flywheel] auto-stash before merge-result ${workflowId}`;
+        const dirtyOtherPaths = Array.from(new Set(dirtyOther.flatMap(getStatusEntryPathspecs)));
+        const stashResult = await execa4(
+          "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 execa4("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));
+        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(
+          chalk3.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 runBiomeMergeGate() {
+      const biomeAvailable = isResolverBiomeAvailable(mergeCwd);
+      const stagedFiles = await listStagedFiles(mergeCwd);
+      const biomeFiles = filterBiomePaths(stagedFiles);
+      if (!biomeAvailable) {
+        if (biomeFiles.length > 0) {
+          console.log(
+            chalk3.dim(
+              `  Biome merge gate unavailable for this target (${biomeFiles.length} Biome-lintable file(s) staged but the resolver does not declare Biome available); lint/format is verified by the resolver-derived commands.`
+            )
+          );
+        } else {
+          console.log(
+            chalk3.dim(
+              "  Biome merge gate unavailable for this target language (no Node lint surface); lint/format is verified by the resolver-derived commands."
+            )
+          );
+        }
+        return { ok: true };
+      }
+      if (biomeFiles.length === 0) {
+        return { ok: true };
+      }
+      console.log(chalk3.cyan(`  Biome check (merged files): ${biomeFiles.length}`));
+      await assertApplyLockOwned();
+      await runBiome(["check", "--write", ...biomeFiles], mergeCwd);
+      await assertApplyLockOwned();
+      await execa4("git", ["add", "--", ...biomeFiles], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      const checkResult = await runBiome(
+        ["check", "--max-diagnostics", "50", ...biomeFiles],
+        mergeCwd
+      );
+      if (!checkResult.ok) {
+        return {
+          ok: false,
+          summary: formatBiomeFailureSummary(checkResult),
+          biomeFiles
+        };
+      }
+      return { ok: true };
+    }
+    {
+      const gate = await runBiomeMergeGate();
+      if (!gate.ok) {
+        throw new Error(
+          `Biome check failed for merged files; merge aborted to avoid landing new lint/format errors.
+
+Fix on the run branch, then retry merge:
+  git checkout ${manifest.integrationBranch}
+  npx --no-install biome check --write --unsafe ${gate.biomeFiles.slice(0, 8).join(" ")}${gate.biomeFiles.length > 8 ? " ..." : ""}
+  git commit -am "chore: satisfy biome"
+  git checkout ${currentBranch}
+  poetic flywheel merge-result ${workflowId}
+
+Biome output:
+${gate.summary}`
+        );
+      }
+    }
+    await assertCurrentBranchStillMatchesApplyTarget();
+    if (manifest.sourceType === "sprint" && manifest.sprintId) {
+      const taskStatus = options.taskStatus ?? "apply";
+      if (taskStatus === "apply" || taskStatus === "preview") {
+        let workflowResult;
+        try {
+          const resultPath = getResultPath(workflowId);
+          const content = await fs2.readFile(resultPath, "utf-8");
+          workflowResult = JSON.parse(content);
+        } catch (error) {
+          console.log(
+            chalk3.yellow(
+              `  Warning: Failed to load workflow result for status sync: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+        const taskTransitions = extractTaskTransitionsFromResult(workflowResult);
+        if (taskTransitions) {
+          if (taskStatus === "apply") {
+            console.log(chalk3.cyan("  Applying task transitions (artifact-driven)..."));
+            try {
+              await assertApplyLockOwned();
+              const syncResult = await applyTaskTransitions(manifest.sprintId, taskTransitions, {
+                promoteToDone: true
+              });
+              console.log(chalk3.dim(formatSyncSummary(syncResult)));
+              if (syncResult.tasksFailed > 0) {
+                const failedDetails = syncResult.details.filter((d) => d.error !== void 0).map((d) => ({
+                  taskId: d.taskId,
+                  error: d.error ?? "unknown error"
+                }));
+                console.log(
+                  chalk3.yellow(
+                    `  Warning: ${syncResult.tasksFailed} task transition(s) failed (merge still succeeded):
+` + failedDetails.map((d) => `    - ${d.taskId}: ${d.error}`).join("\n")
+                  )
+                );
+                taskSyncFailures = {
+                  count: syncResult.tasksFailed,
+                  details: failedDetails
+                };
+                emitWarning(
+                  "FM-001",
+                  { subsystem: "flywheel", taskId: workflowId },
+                  {
+                    severity: "WARN" /* WARN */,
+                    metadata: {
+                      type: "task_sync_partial_failure",
+                      workflowId,
+                      tasksFailed: syncResult.tasksFailed,
+                      failedTaskIds: failedDetails.map((d) => d.taskId)
+                    }
+                  }
+                );
+              }
+              const dirtyAfterSync = await snapshotDirtyPlanningPaths({
+                cwd: mergeCwd,
+                allowlistPrefixes
+              });
+              const sprintPrefix = toPosixRelative(
+                mergeCwd,
+                getBucketPathByKind("sprint", mergeCwd)
+              );
+              const sprintArchivePrefix = toPosixRelative(
+                mergeCwd,
+                getBucketArchivePathByKind("sprint", mergeCwd)
+              );
+              const taskPrefix = toPosixRelative(mergeCwd, getBucketPathByKind("task", mergeCwd));
+              const taskArchivePrefix = toPosixRelative(
+                mergeCwd,
+                getBucketArchivePathByKind("task", mergeCwd)
+              );
+              const syncTargetCandidates = /* @__PURE__ */ new Set([
+                `${sprintPrefix}/${manifest.sprintId}.md`,
+                `${sprintArchivePrefix}/${manifest.sprintId}.md`
+              ]);
+              for (const detail of syncResult.details ?? []) {
+                if (!detail.updated && !detail.fileUpdated) continue;
+                syncTargetCandidates.add(`${taskPrefix}/${detail.taskId}.md`);
+                syncTargetCandidates.add(`${taskArchivePrefix}/${detail.taskId}.md`);
+              }
+              const taskSyncPaths = [...dirtyAfterSync].filter(
+                (p) => !dirtyPlanningBaseline.has(p) && isPathInAllowlist(p, allowlistPrefixes) || syncTargetCandidates.has(p)
+              );
+              if (taskSyncPaths.length > 0) {
+                await execa4("git", ["add", "--", ...taskSyncPaths], {
+                  cwd: mergeCwd,
+                  stdio: "pipe",
+                  timeout: 3e4
+                });
+              }
+            } catch (error) {
+              console.log(
+                chalk3.yellow(
+                  `  Warning: Task transition application failed: ${error instanceof Error ? error.message : String(error)}`
+                )
+              );
+            }
+          } else {
+            console.log(chalk3.cyan("  Task transition preview (artifact-driven):"));
+            if (taskTransitions.length > 0) {
+              for (const t of taskTransitions) {
+                console.log(
+                  chalk3.dim(
+                    `    - ${t.taskId}: ${t.targetStatus}${t.hoursLogged ? ` (${t.hoursLogged.toFixed(2)}h)` : ""}`
+                  )
+                );
+              }
+            } else {
+              console.log(chalk3.dim("    (No transitions recorded)"));
+            }
+          }
+        } else {
+          if (manifest.sourceType === "sprint") {
+            emitWarning(
+              "FM-002",
+              {
+                taskId: manifest.sprintId ?? workflowId,
+                subsystem: "flywheel-merge",
+                executionPhase: "cleanup"
+              },
+              {
+                severity: "WARN" /* WARN */,
+                metadata: {
+                  workflowId,
+                  sprintId: manifest.sprintId ?? null,
+                  operation: "task-transition-artifact-missing"
+                }
+              }
+            );
+            console.log(
+              chalk3.yellow(
+                `  Warning: taskTransitions artifact missing for sprint workflow '${manifest.sprintId ?? workflowId}'. Legacy task-status sync skipped (stageIds are not task IDs for sprint workflows). Ensure sprint-bridge.ts populates taskTransitions on stageResults.`
+              )
+            );
+          }
+        }
+      } else {
+        console.log(chalk3.dim("  Task status sync skipped (--task-status=skip)"));
+      }
+    }
+    {
+      let workflowResultForDrift;
+      try {
+        const resultPath = getResultPath(workflowId);
+        const content = await fs2.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(
+          chalk3.yellow(
+            `
+  Drift detected: ${totalViolations} file(s) outside allowlist across ${stagesWithDrift.length} stage(s)`
+          )
+        );
+        for (const stage of stagesWithDrift.slice(0, 3)) {
+          console.log(chalk3.dim(`    - ${stage.stageId}: ${stage.violations.length} file(s)`));
+        }
+        if (stagesWithDrift.length > 3) {
+          console.log(chalk3.dim(`    ... and ${stagesWithDrift.length - 3} more stage(s)`));
+        }
+        console.log(chalk3.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 mergeDirtiedPlanningPaths = [...dirtyPlanningNow].filter(
+        (p) => !dirtyPlanningBaseline.has(p) && isPathInAllowlist(p, allowlistPrefixes)
+      );
+      if (mergeDirtiedPlanningPaths.length > 0) {
+        await execa4("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,
+        onVerificationStarted: () => {
+          postMergeVerificationStarted = true;
+        }
+      });
+      verifiedTreeFingerprint = gateResult.verifiedTreeFingerprint;
+      if (gateResult.orphanedStashWarning) {
+        postMergeWarnings.push(gateResult.orphanedStashWarning);
+      }
+    }
+    const assertVerifiedTreeStillCurrent = async () => {
+      if (!verifiedTreeFingerprint) return;
+      const current = await execGit(["write-tree"], { cwd: mergeCwd, timeoutMs: 3e4 });
+      if (current.exitCode !== 0 || current.stdout.trim() !== verifiedTreeFingerprint) {
+        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(chalk3.yellow("  Changes staged (--apply-only)"));
+      console.log(chalk3.yellow("  Review and commit manually"));
+      if (!options.dryRun) {
+        try {
+          await updateManifestApplyStatus(workflowId, {
+            ...verifiedTreeFingerprint ? buildApplyOnlyProofStatus(verifiedTreeFingerprint) : { stagedAt: (/* @__PURE__ */ new Date()).toISOString() },
+            ...branchRoleApplyStatus()
+          });
+        } catch {
+        }
+      }
+      return { success: true, workflowId };
+    }
+    const diffCheck = await execa4("git", ["diff", "--cached", "--quiet"], {
+      cwd: mergeCwd,
+      stdio: "pipe",
+      timeout: 3e4,
+      reject: false
+    });
+    if (diffCheck.exitCode === 0) {
+      console.log(chalk3.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 assertCommittedTreeMatchesFingerprint(
+          mergeCwd,
+          verifiedTreeFingerprint
+        );
+      } else {
+        appliedCommitSha = currentHead.exitCode === 0 && currentHead.stdout.trim().length > 0 ? currentHead.stdout.trim() : void 0;
+      }
+      await updateManifestApplyStatus(workflowId, {
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        appliedBy: await getGitUsername(),
+        verifiedTreeFingerprint,
+        appliedCommitSha,
+        ...branchRoleApplyStatus()
+      });
+      console.log(chalk3.green("  Manifest updated"));
+      if (options.cleanup && !options.keepArtifacts) {
+        const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+        await cleanupArtifacts({
+          integrationBranch: manifest.integrationBranch,
+          workflowId,
+          relatedTaskIds: [...manifest.relatedTaskIds ?? [], ...manifest.stageIds ?? []],
+          trackedBranches: trackedCleanupTargets.trackedBranches,
+          trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+        });
+      } else if (!options.keepArtifacts) {
+        console.log(chalk3.cyan("  Cleaning up run branch/worktree..."));
+        await cleanupBranchAndWorktree(manifest.integrationBranch, workflowId);
+        const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+        await cleanupRelatedBranchesAndWorktrees({
+          integrationBranch: manifest.integrationBranch,
+          relatedTaskIds: [...manifest.relatedTaskIds ?? [], ...manifest.stageIds ?? []],
+          trackedBranches: trackedCleanupTargets.trackedBranches,
+          trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+        });
+      } else {
+        await logPreservedRunArtifacts(manifest.integrationBranch);
+      }
+      console.log(chalk3.bold.green("\nMerge complete!\n"));
+      const warnings2 = [
+        ...taskSyncFailures ? [`Task sync completed with ${taskSyncFailures.count} failure(s)`] : [],
+        ...followUpFailures ?? [],
+        ...postMergeWarnings
+      ];
+      return {
+        success: true,
+        degraded: warnings2.length > 0,
+        workflowId,
+        applied: true,
+        ...taskSyncFailures ? { taskSyncFailures } : {},
+        ...followUpFailures ? { followUpFailures } : {},
+        ...warnings2.length > 0 ? { warnings: warnings2 } : {}
+      };
+    }
+    const commitMsg = `${flywheelMergeCommitSubject(workflowId)}
+
+Source: ${manifest.sourceType}${manifest.sprintId ? ` (${manifest.sprintId})` : ""}
+Branch: ${manifest.integrationBranch}
+Base: ${manifest.baseSha.slice(0, 7)}`;
+    let finalCommitMsg = commitMsg;
+    try {
+      const content = await fs2.readFile(getResultPath(workflowId), "utf-8");
+      const parsed = JSON.parse(content);
+      const verifySummary = formatVerifyStatusForCommitMessage(parsed);
+      if (verifySummary) {
+        finalCommitMsg = `${commitMsg}
+${verifySummary}`;
+      }
+    } catch {
+    }
+    finalCommitMsg = `${finalCommitMsg}
+
+${flywheelApplyTrailers(workflowId, "code")}`;
+    const metadataCommitMsg = "chore: sync task/sprint metadata [flywheel]\n\n" + flywheelApplyTrailers(workflowId, "metadata");
+    const allStagedFiles = await listStagedFiles(mergeCwd);
+    const systemWriteFiles = allStagedFiles.filter((f) => isSystemWritePath(f));
+    const codeFiles = allStagedFiles.filter((f) => !isSystemWritePath(f));
+    const quiet = isQuietOutputRequested();
+    const commitStdio = quiet ? "pipe" : "inherit";
+    await assertVerifiedTreeStillCurrent();
+    if (systemWriteFiles.length > 0 && codeFiles.length > 0) {
+      await execa4("git", ["restore", "--staged", ...systemWriteFiles], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      await assertApplyLockOwned();
+      await execa4("git", ["commit", "-m", finalCommitMsg], {
+        cwd: mergeCwd,
+        stdio: commitStdio,
+        timeout: 3e4
+      });
+      await recordCommitMaterialized();
+      if (!quiet) console.log(chalk3.green("  Code changes committed"));
+      await execa4("git", ["add", ...systemWriteFiles], {
+        cwd: mergeCwd,
+        stdio: "pipe",
+        timeout: 3e4
+      });
+      await assertApplyLockOwned();
+      await execa4("git", ["commit", "-m", metadataCommitMsg], {
+        cwd: mergeCwd,
+        stdio: commitStdio,
+        timeout: 3e4,
+        env: { ...process.env, POETIC_BACKLOG_SYNC: "1" }
+      });
+      await recordCommitMaterialized();
+      if (!quiet) console.log(chalk3.green("  Task/sprint metadata committed separately"));
+    } else if (systemWriteFiles.length > 0) {
+      await assertApplyLockOwned();
+      await execa4("git", ["commit", "-m", metadataCommitMsg], {
+        cwd: mergeCwd,
+        stdio: commitStdio,
+        timeout: 3e4,
+        env: { ...process.env, POETIC_BACKLOG_SYNC: "1" }
+      });
+      await recordCommitMaterialized();
+      if (!quiet) console.log(chalk3.green("  Task/sprint metadata committed"));
+    } else {
+      await assertApplyLockOwned();
+      await execa4("git", ["commit", "-m", finalCommitMsg], {
+        cwd: mergeCwd,
+        stdio: commitStdio,
+        timeout: 3e4
+      });
+      await recordCommitMaterialized();
+      if (!quiet) console.log(chalk3.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 assertCommittedTreeMatchesFingerprint(mergeCwd, verifiedTreeFingerprint);
+    }
+    appliedCommitSha = finalHead.stdout.trim();
+    await assertApplyLockOwned();
+    await restoreAutoStash();
+    await assertApplyLockOwned();
+    if (releaseApplyLock) {
+      try {
+        await releaseApplyLock();
+        releaseApplyLock = void 0;
+      } catch {
+      }
+    }
+    await updateManifestApplyStatus(workflowId, {
+      appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      appliedBy: await getGitUsername(),
+      verifiedTreeFingerprint,
+      appliedCommitSha,
+      ...branchRoleApplyStatus()
+    });
+    console.log(chalk3.green("  Manifest updated"));
+    if (options.cleanup && !options.keepArtifacts) {
+      const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+      await cleanupArtifacts({
+        integrationBranch: manifest.integrationBranch,
+        workflowId,
+        relatedTaskIds: [...manifest.relatedTaskIds ?? [], ...manifest.stageIds ?? []],
+        trackedBranches: trackedCleanupTargets.trackedBranches,
+        trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+      });
+    } else if (!options.keepArtifacts) {
+      console.log(chalk3.cyan("  Cleaning up run branch/worktree..."));
+      await cleanupBranchAndWorktree(manifest.integrationBranch, workflowId);
+      const trackedCleanupTargets = getTrackedCleanupTargets(manifest);
+      await cleanupRelatedBranchesAndWorktrees({
+        integrationBranch: manifest.integrationBranch,
+        relatedTaskIds: [...manifest.relatedTaskIds ?? [], ...manifest.stageIds ?? []],
+        trackedBranches: trackedCleanupTargets.trackedBranches,
+        trackedWorktrees: trackedCleanupTargets.trackedWorktrees
+      });
+    } else {
+      await logPreservedRunArtifacts(manifest.integrationBranch);
+    }
+    console.log(chalk3.bold.green("\nMerge complete!\n"));
+    const warnings = [
+      ...taskSyncFailures ? [`Task sync completed with ${taskSyncFailures.count} failure(s)`] : [],
+      ...followUpFailures ?? [],
+      ...postMergeWarnings
+    ];
+    return {
+      success: true,
+      degraded: warnings.length > 0,
+      workflowId,
+      applied: true,
+      ...taskSyncFailures ? { taskSyncFailures } : {},
+      ...followUpFailures ? { followUpFailures } : {},
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    let leftMidMergeWarning;
+    let cleanupRan = false;
+    try {
+      if (!didCommit) {
+        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.`;
+          console.warn(chalk3.yellow(`
+  Warning: ${leftMidMergeWarning}
+`));
+          postMergeWarnings.push(leftMidMergeWarning);
+        } 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.`;
+          console.warn(chalk3.yellow(`
+  Warning: ${leftMidMergeWarning}
+`));
+          postMergeWarnings.push(leftMidMergeWarning);
+        } else if (mergeMutationStarted) {
+          cleanupRan = true;
+          await abortPendingSquashMerge(mergeCwd, preMergeHeadSha);
+        }
+      } else {
+        cleanupRan = true;
+        await execa4("git", ["merge", "--abort"], {
+          cwd: mergeCwd,
+          stdio: "pipe",
+          timeout: 3e4,
+          reject: false
+        });
+      }
+      if (cleanupRan && !postMergeVerificationStarted) {
+        const { stdout: postAbortStatus } = await execa4("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))}`;
+          console.warn(chalk3.yellow(`
+  Warning: ${leftMidMergeWarning}
+`));
+          postMergeWarnings.push(leftMidMergeWarning);
+        }
+      }
+    } 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)}`;
+      console.warn(chalk3.yellow(`
+  Warning: ${leftMidMergeWarning}
+`));
+      postMergeWarnings.push(leftMidMergeWarning);
+    }
+    if (!options.dryRun) {
+      try {
+        const sourceBranch = integrationBranchForRecovery ?? null;
+        const sourceBranchRole = sourceBranch ? classifyBranchRole(sourceBranch) : null;
+        const applyTargetBranch = branchRoleApplyTarget ?? null;
+        const applyTargetBranchRole = applyTargetBranch ? classifyBranchRole(applyTargetBranch) : null;
+        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
+        };
+        await updateManifestApplyStatus(
+          workflowId,
+          applyMaterialized ? {
+            appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            postApplyError: errorMsg,
+            verifiedTreeFingerprint,
+            appliedCommitSha,
+            ...branchRoleErrorStatus
+          } : { applyError: errorMsg, ...branchRoleErrorStatus }
+        );
+      } catch {
+      }
+    }
+    if (applyMaterialized) {
+      console.warn(chalk3.yellow(`
+  Post-apply cleanup failed: ${errorMsg}
+`));
+      console.warn(
+        chalk3.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(chalk3.red(`
+  Merge failed: ${errorMsg}
+`));
+    if (error instanceof SquashMergeConflictError && integrationBranchForRecovery && currentBranchForRecovery) {
+      try {
+        const conflictBranch = `poetic/merge-conflict/${workflowId}`;
+        const worktreePath = path2.join(
+          mergeCwd,
+          ".poetic",
+          "tmp",
+          "merge-conflicts",
+          workflowId.replace(/[^a-zA-Z0-9._-]/g, "_")
+        );
+        await fs2.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 execa4("git", ["merge", "--squash", integrationBranchForRecovery], {
+          cwd: worktreePath,
+          stdio: isQuietOutputRequested() ? "pipe" : "inherit",
+          timeout: 6e4,
+          reject: false
+        });
+        console.error(chalk3.yellow("  Conflict-resolution worktree created:"));
+        console.error(chalk3.yellow(`    ${worktreePath}`));
+        console.error(
+          chalk3.yellow(
+            `  Resolve conflicts there, commit, then cherry-pick onto ${currentBranchForRecovery} (or open a PR).`
+          )
+        );
+      } catch {
+      }
+    }
+    console.error(chalk3.yellow("  Run branch preserved for manual recovery:"));
+    console.error(
+      chalk3.yellow(`    ${integrationBranchForRecovery ?? "(unknown - manifest unavailable)"}`)
+    );
+    return {
+      success: false,
+      workflowId,
+      error: errorMsg,
+      ...leftMidMergeWarning ? { degraded: true, warnings: [leftMidMergeWarning] } : {}
+    };
+  } finally {
+    await restoreAutoStash();
+    if (releaseApplyLock) {
+      try {
+        await releaseApplyLock();
+      } catch {
+      }
+    }
+    if (mergeLockAcquired) {
+      try {
+        const currentLockPid = await readLockPid(mergeLockPath);
+        if (currentLockPid === thisPid) {
+          await fs2.unlink(mergeLockPath);
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function cleanupBranchAndWorktree(integrationBranch, workflowId) {
+  const preserveWorktrees = readEnv(POETIC_PRESERVE_WORKTREES).value || isLabModeFromEnv();
+  if (classifyBranchRole(integrationBranch) !== "generated-artifact") {
+    console.log(
+      chalk3.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(chalk3.dim("    Worktree cleaned up"));
+    }
+  } catch (error) {
+    console.log(
+      chalk3.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(chalk3.dim("    Run branch deleted"));
+  } catch (error) {
+    console.log(
+      chalk3.yellow(
+        `    Warning: Failed to delete branch: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function cleanupRelatedBranchesAndWorktrees(opts) {
+  const preserveWorktrees = readEnv(POETIC_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(chalk3.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 fs2.rm(artifactDir, { recursive: true, force: true });
+    console.log(chalk3.dim("    Artifact directory removed"));
+  } catch (error) {
+    console.log(
+      chalk3.yellow(
+        `    Warning: Failed to remove artifacts: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function logPreservedRunArtifacts(integrationBranch) {
+  const worktreePath = await findWorktreePathForBranch(integrationBranch);
+  console.log(chalk3.dim("  Run branch/worktree preserved (--keep-artifacts)"));
+  console.log(chalk3.dim(`    Branch: ${integrationBranch}`));
+  if (worktreePath) {
+    console.log(chalk3.dim(`    Worktree: ${worktreePath}`));
+  }
+}
+async function findWorktreePathForBranch(branchName, repoCwd = getProjectRoot()) {
+  const { stdout } = await execa4("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 execa4("git", ["config", "user.name"], {
+      timeout: 5e3
+    });
+    return stdout.trim();
+  } catch {
+    return "unknown";
+  }
+}
+async function getCurrentBranch(cwd = getProjectRoot()) {
+  const { stdout } = await execa4("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    cwd,
+    stdio: "pipe",
+    timeout: 5e3
+  });
+  return stdout.trim();
+}
+
+export {
+  applyTaskTransitions,
+  mergeWorkflowResult
+};
+//# sourceMappingURL=chunk-CVMVZWG4.js.map