panopticon-cli 0.5.4 → 0.5.6

package/dist/merge-agent-WM7ZKUET.js

@@ -0,0 +1,1725 @@
+import {
+  resolveGitHubIssue
+} from "./chunk-YAAT66RT.js";
+import {
+  getTmuxSessionName,
+  init_specialists,
+  isRunning,
+  recordWake,
+  spawnEphemeralSpecialist,
+  wakeSpecialist
+} from "./chunk-WJJ3ZIQ6.js";
+import "./chunk-JQBV3Q2W.js";
+import {
+  init_workspace_config,
+  replacePlaceholders
+} from "./chunk-AAP4G6U7.js";
+import "./chunk-ZN5RHWGR.js";
+import "./chunk-USYP2SBE.js";
+import {
+  init_config,
+  loadConfig
+} from "./chunk-QAJAJBFW.js";
+import {
+  init_projects,
+  loadProjectsConfig,
+  resolveProjectFromIssue
+} from "./chunk-ZMJFEHGF.js";
+import {
+  init_tmux,
+  sendKeysAsync,
+  sessionExists
+} from "./chunk-W2OTF6OS.js";
+import "./chunk-ZP6EWSZV.js";
+import {
+  PANOPTICON_HOME,
+  init_paths
+} from "./chunk-ZTFNYOC7.js";
+import {
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/cloister/merge-agent.ts
+init_esm_shims();
+init_tmux();
+init_paths();
+import { readFileSync, existsSync as existsSync3, mkdirSync, appendFileSync } from "fs";
+import { join as join3, dirname, basename, relative } from "path";
+import { fileURLToPath } from "url";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+init_specialists();
+init_projects();
+
+// src/lib/cloister/validation.ts
+init_esm_shims();
+init_workspace_config();
+init_config();
+import { exec } from "child_process";
+import { promisify } from "util";
+import { join } from "path";
+import { existsSync } from "fs";
+var execAsync = promisify(exec);
+function parseValidationOutput(output, exitCode) {
+  const lines = output.split("\n");
+  const failures = [];
+  let conflictMarkersFound = false;
+  let buildPassed = null;
+  let testsPassed = null;
+  let inConflictCheck = false;
+  let inBuildCheck = false;
+  let inTestCheck = false;
+  const conflictFiles = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("Checking for conflict markers")) {
+      inConflictCheck = true;
+      inBuildCheck = false;
+      inTestCheck = false;
+    } else if (trimmed.startsWith("Running build")) {
+      inConflictCheck = false;
+      inBuildCheck = true;
+      inTestCheck = false;
+    } else if (trimmed.startsWith("Running tests")) {
+      inConflictCheck = false;
+      inBuildCheck = false;
+      inTestCheck = true;
+    }
+    if (inConflictCheck) {
+      if (trimmed.startsWith("ERROR: Conflict")) {
+        conflictMarkersFound = true;
+      } else if (trimmed.includes("/") && !trimmed.startsWith("ERROR")) {
+        conflictFiles.push(trimmed);
+      } else if (trimmed.startsWith("\u2713 No conflict markers found")) {
+        conflictMarkersFound = false;
+      }
+    }
+    if (inBuildCheck) {
+      if (trimmed.startsWith("\u2713 Build passed")) {
+        buildPassed = true;
+      } else if (trimmed.startsWith("ERROR: Build failed") || trimmed.includes("VALIDATION FAILED: Build errors detected")) {
+        buildPassed = false;
+      } else if (trimmed.includes("skipping build check")) {
+        buildPassed = null;
+      }
+    }
+    if (inTestCheck) {
+      if (trimmed.startsWith("\u2713 Tests passed")) {
+        testsPassed = true;
+      } else if (trimmed.startsWith("ERROR: Tests failed") || trimmed.includes("VALIDATION FAILED: Test failures detected")) {
+        testsPassed = false;
+      } else if (trimmed.includes("skipping test check")) {
+        testsPassed = null;
+      }
+    }
+  }
+  if (conflictMarkersFound) {
+    failures.push({
+      type: "conflict",
+      files: conflictFiles.length > 0 ? conflictFiles : void 0,
+      message: "Conflict markers detected in merged code"
+    });
+  }
+  if (buildPassed === false) {
+    failures.push({
+      type: "build",
+      message: "Build failed after merge"
+    });
+  }
+  if (testsPassed === false) {
+    failures.push({
+      type: "test",
+      message: "Tests failed after merge"
+    });
+  }
+  const valid = exitCode === 0 && !conflictMarkersFound && (buildPassed === null || buildPassed === true) && (testsPassed === null || testsPassed === true);
+  return {
+    success: true,
+    // Script ran successfully
+    valid,
+    conflictMarkersFound,
+    buildPassed,
+    testsPassed,
+    failures,
+    output
+  };
+}
+async function runMergeValidation(context) {
+  const { projectPath, validationScript } = context;
+  const scriptPath = validationScript || join(projectPath, "scripts", "validate-merge.sh");
+  if (!existsSync(scriptPath)) {
+    console.log(`[validation] No validation script at ${scriptPath}, skipping (specialist already validated)`);
+    return {
+      success: true,
+      valid: true,
+      skipped: true,
+      conflictMarkersFound: false,
+      buildPassed: null,
+      testsPassed: null,
+      failures: [],
+      output: ""
+    };
+  }
+  console.log(`[validation] Running validation script: ${scriptPath}`);
+  console.log(`[validation] Project path: ${projectPath}`);
+  try {
+    const env = { ...process.env };
+    if (context.baselineTestFailures !== void 0) {
+      env.BASELINE_FAILURES = String(context.baselineTestFailures);
+      console.log(`[validation] Baseline comparison mode: ${context.baselineTestFailures} pre-existing failures`);
+    }
+    const { stdout, stderr } = await execAsync(
+      `bash "${scriptPath}" "${projectPath}"`,
+      {
+        cwd: projectPath,
+        env,
+        maxBuffer: 10 * 1024 * 1024,
+        // 10MB buffer for large outputs
+        timeout: 10 * 60 * 1e3
+        // 10 minute timeout
+      }
+    );
+    const output = stdout + stderr;
+    console.log(`[validation] \u2713 Validation passed`);
+    return parseValidationOutput(output, 0);
+  } catch (error) {
+    const exitCode = error.code || 1;
+    const output = (error.stdout || "") + (error.stderr || "");
+    console.log(`[validation] \u2717 Validation failed (exit code ${exitCode})`);
+    const result = parseValidationOutput(output, exitCode);
+    return result;
+  }
+}
+async function autoRevertMerge(projectPath) {
+  console.log(`[validation] Auto-reverting merge in ${projectPath}`);
+  try {
+    const { stdout: beforeCommit } = await execAsync("git rev-parse HEAD", {
+      cwd: projectPath
+    });
+    await execAsync("git reset --hard ORIG_HEAD", {
+      cwd: projectPath
+    });
+    const { stdout: afterCommit } = await execAsync("git rev-parse HEAD", {
+      cwd: projectPath
+    });
+    console.log(
+      `[validation] \u2713 Auto-revert successful: ${beforeCommit.trim()} -> ${afterCommit.trim()} (via ORIG_HEAD)`
+    );
+    return true;
+  } catch (error) {
+    console.error(`[validation] \u2717 Auto-revert failed:`, error.message);
+    return false;
+  }
+}
+async function runQualityGates(gates, projectPath, phase = "pre_push", opts = {}) {
+  if (opts.isRemote && !opts.vmName) {
+    throw new Error("Remote workspace requires vmName");
+  }
+  if (opts.isRemote && opts.vmName) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(opts.vmName)) {
+      throw new Error(`Invalid vmName for SSH: ${opts.vmName}`);
+    }
+    if (!/^[a-zA-Z0-9/_\-.]+$/.test(projectPath)) {
+      throw new Error(`Workspace path contains unsafe characters: ${projectPath}`);
+    }
+  }
+  const results = [];
+  for (const [name, gate] of Object.entries(gates)) {
+    const gatePhase = gate.phase || "pre_push";
+    if (gatePhase !== phase) continue;
+    const required = gate.required !== false;
+    const cwd = gate.path ? join(projectPath, gate.path) : projectPath;
+    console.log(`[quality-gate] Running "${name}" (${required ? "required" : "optional"}) in ${cwd}`);
+    const startTime = Date.now();
+    if (gate.type === "http_health") {
+      const result = await runHttpHealthGate(name, gate, required);
+      results.push(result);
+      if (!result.passed && required) {
+        console.log(`[quality-gate] \u2717 Required gate "${name}" failed \u2014 stopping`);
+        break;
+      }
+      continue;
+    }
+    const isRemote = opts.isRemote && opts.vmName;
+    let resolvedCommand;
+    if (isRemote) {
+      if (!/^[a-zA-Z0-9/_\-.]+$/.test(cwd)) {
+        throw new Error(`Gate "${name}" path resolves to unsafe characters for SSH: ${cwd}`);
+      }
+      if (gate.command.includes('"')) {
+        throw new Error(`Gate "${name}" command contains double quotes which are unsafe in SSH context`);
+      }
+      const flyAppName = loadConfig().remote?.fly?.app ?? "pan-workspaces";
+      resolvedCommand = `fly ssh console -a ${flyAppName} -C "cd ${cwd} && ${gate.command}"`;
+    } else if (gate.container && gate.container_name) {
+      let containerName = gate.container_name;
+      if (opts.placeholders) {
+        containerName = replacePlaceholders(containerName, opts.placeholders);
+      }
+      const containerWorkdir = gate.path ? `/workspaces/feature/${gate.path}` : "/workspaces/feature";
+      const envFlags = gate.env ? Object.entries(gate.env).map(([k, v]) => `-e ${k}="${v}"`).join(" ") : "";
+      resolvedCommand = `docker exec ${envFlags} -w "${containerWorkdir}" "${containerName}" ${gate.command}`;
+      console.log(`[quality-gate] Running in container: ${containerName} (workdir: ${containerWorkdir})`);
+    } else {
+      resolvedCommand = gate.command;
+    }
+    try {
+      const useHostCwd = !isRemote && !(gate.container && gate.container_name);
+      const env = { ...process.env, ...gate.env };
+      const { stdout, stderr } = await execAsync(resolvedCommand, {
+        cwd: useHostCwd ? cwd : void 0,
+        env,
+        maxBuffer: 10 * 1024 * 1024,
+        // 10MB
+        timeout: 5 * 60 * 1e3
+        // 5 minute timeout per gate
+      });
+      const durationMs = Date.now() - startTime;
+      console.log(`[quality-gate] \u2713 "${name}" passed (${durationMs}ms)`);
+      results.push({
+        name,
+        passed: true,
+        required,
+        output: (stdout + stderr).slice(-2e3),
+        // keep last 2KB
+        durationMs
+      });
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      const output = ((error.stdout || "") + (error.stderr || "")).slice(-2e3);
+      console.log(`[quality-gate] \u2717 "${name}" failed (${durationMs}ms): ${error.message?.slice(0, 200)}`);
+      results.push({
+        name,
+        passed: false,
+        required,
+        output,
+        durationMs,
+        error: error.message?.slice(0, 500)
+      });
+      if (required) {
+        console.log(`[quality-gate] \u2717 Required gate "${name}" failed \u2014 stopping`);
+        break;
+      }
+    }
+  }
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  console.log(`[quality-gate] Complete: ${passed} passed, ${failed} failed out of ${results.length} gates`);
+  return results;
+}
+async function runHttpHealthGate(name, gate, required) {
+  const url = gate.url;
+  if (!url) {
+    return {
+      name,
+      passed: false,
+      required,
+      output: "",
+      durationMs: 0,
+      error: "http_health gate missing url"
+    };
+  }
+  const waitSeconds = gate.wait || 120;
+  const expectStatus = gate.expect_status || 200;
+  const startTime = Date.now();
+  console.log(`[quality-gate] Waiting ${waitSeconds}s for deployment, then checking ${url}`);
+  await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1e3));
+  try {
+    const { stdout } = await execAsync(
+      `curl -sL -o /dev/null -w '%{http_code}' --max-time 30 '${url}'`,
+      { timeout: 60 * 1e3 }
+    );
+    const statusCode = parseInt(stdout.trim(), 10);
+    const passed = statusCode === expectStatus;
+    const durationMs = Date.now() - startTime;
+    console.log(`[quality-gate] Health check ${url}: ${statusCode} (expected ${expectStatus}) \u2014 ${passed ? "PASS" : "FAIL"}`);
+    return {
+      name,
+      passed,
+      required,
+      output: `HTTP ${statusCode} from ${url}`,
+      durationMs,
+      error: passed ? void 0 : `Expected HTTP ${expectStatus}, got ${statusCode}`
+    };
+  } catch (error) {
+    return {
+      name,
+      passed: false,
+      required,
+      output: error.message || "",
+      durationMs: Date.now() - startTime,
+      error: `Health check failed: ${error.message?.slice(0, 200)}`
+    };
+  }
+}
+
+// src/lib/cloister/merge-agent.ts
+init_projects();
+
+// src/lib/git-utils.ts
+init_esm_shims();
+import { existsSync as existsSync2, unlinkSync, readdirSync } from "fs";
+import { join as join2 } from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+async function hasRunningGitProcesses(repoPath) {
+  try {
+    try {
+      const gitDir = join2(repoPath, ".git");
+      const { stdout } = await execAsync2(`fuser "${gitDir}" 2>/dev/null`, {
+        encoding: "utf-8"
+      });
+      return stdout.trim().length > 0;
+    } catch {
+      try {
+        const { stdout } = await execAsync2(
+          `ps aux | grep -E "git.*${repoPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}" | grep -v grep`,
+          { encoding: "utf-8" }
+        );
+        return stdout.trim().length > 0;
+      } catch {
+        return false;
+      }
+    }
+  } catch {
+    return false;
+  }
+}
+function findGitLockFiles(repoPath) {
+  const lockFiles = [];
+  const indexLock = join2(repoPath, ".git", "index.lock");
+  if (existsSync2(indexLock)) {
+    lockFiles.push(indexLock);
+  }
+  const refsDir = join2(repoPath, ".git", "refs");
+  if (existsSync2(refsDir)) {
+    const findLocksRecursive = (dir) => {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join2(dir, entry.name);
+        if (entry.isDirectory()) {
+          findLocksRecursive(fullPath);
+        } else if (entry.name.endsWith(".lock")) {
+          lockFiles.push(fullPath);
+        }
+      }
+    };
+    try {
+      findLocksRecursive(refsDir);
+    } catch {
+    }
+  }
+  return lockFiles;
+}
+async function cleanupStaleLocks(repoPath) {
+  const result = {
+    found: [],
+    removed: [],
+    errors: []
+  };
+  const lockFiles = findGitLockFiles(repoPath);
+  result.found = lockFiles;
+  if (lockFiles.length === 0) {
+    return result;
+  }
+  const hasGitProcesses = await hasRunningGitProcesses(repoPath);
+  if (hasGitProcesses) {
+    result.errors.push({
+      file: "N/A",
+      error: "Git processes are running - not safe to remove locks"
+    });
+    return result;
+  }
+  for (const lockFile of lockFiles) {
+    try {
+      unlinkSync(lockFile);
+      result.removed.push(lockFile);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      result.errors.push({ file: lockFile, error: msg });
+    }
+  }
+  return result;
+}
+
+// src/lib/cloister/merge-agent.ts
+var execAsync3 = promisify3(exec3);
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var SPECIALISTS_DIR = join3(PANOPTICON_HOME, "specialists");
+var MERGE_HISTORY_DIR = join3(SPECIALISTS_DIR, "merge-agent");
+var MERGE_HISTORY_FILE = join3(MERGE_HISTORY_DIR, "history.jsonl");
+var MERGE_TIMEOUT_MS = 15 * 60 * 1e3;
+function buildMergePrompt(context) {
+  const templatePath = join3(__dirname2, "prompts", "merge-agent.md");
+  if (!existsSync3(templatePath)) {
+    throw new Error(`Merge agent prompt template not found at ${templatePath}`);
+  }
+  const template = readFileSync(templatePath, "utf-8");
+  const prompt = template.replace(/\{\{projectPath\}\}/g, context.projectPath).replace(/\{\{sourceBranch\}\}/g, context.sourceBranch).replace(/\{\{targetBranch\}\}/g, context.targetBranch).replace(/\{\{issueId\}\}/g, context.issueId).replace(
+    /\{\{conflictFiles\}\}/g,
+    context.conflictFiles.map((f) => `  - ${f}`).join("\n")
+  ).replace(/\{\{testCommand\}\}/g, context.testCommand || "skip").replace(/\{\{apiUrl\}\}/g, process.env.DASHBOARD_URL || `http://localhost:${process.env.API_PORT || process.env.PORT || "3011"}`);
+  return `<!-- panopticon:orchestration-context-start -->
+${prompt}
+<!-- panopticon:orchestration-context-end -->`;
+}
+function detectTestCommand(projectPath) {
+  const packageJsonPath = join3(projectPath, "package.json");
+  if (existsSync3(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.scripts?.test) {
+        return "npm test";
+      }
+    } catch {
+    }
+  }
+  if (existsSync3(join3(projectPath, "pom.xml"))) {
+    return "mvn test";
+  }
+  if (existsSync3(join3(projectPath, "Cargo.toml"))) {
+    return "cargo test";
+  }
+  if (existsSync3(join3(projectPath, "pytest.ini")) || existsSync3(join3(projectPath, "setup.py"))) {
+    return "pytest";
+  }
+  return "skip";
+}
+async function notifyTldrDaemon(projectPath, sourceBranch) {
+  try {
+    console.log(`[merge-agent] Notifying TLDR daemon to reindex changed files...`);
+    const venvPath = join3(projectPath, ".venv");
+    if (!existsSync3(venvPath)) {
+      console.log(`[merge-agent] No .venv found, skipping TLDR notification`);
+      return;
+    }
+    const { stdout } = await execAsync3(`git diff --name-only HEAD~1 HEAD`, {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    const changedFiles = stdout.trim().split("\n").filter((f) => f.trim().length > 0).filter((f) => {
+      const ext = f.split(".").pop()?.toLowerCase();
+      return ext && ["ts", "js", "tsx", "jsx", "py", "java", "go", "rs", "cpp", "c", "h"].includes(ext);
+    });
+    if (changedFiles.length === 0) {
+      console.log(`[merge-agent] No source files changed, skipping TLDR notification`);
+      return;
+    }
+    console.log(`[merge-agent] Found ${changedFiles.length} changed source files to reindex`);
+    const { getTldrDaemonService } = await import("./tldr-daemon-T3THOUGT.js");
+    const tldrService = getTldrDaemonService(projectPath, venvPath);
+    const status = await tldrService.getStatus();
+    if (!status.running) {
+      console.log(`[merge-agent] TLDR daemon not running, skipping notification`);
+      return;
+    }
+    console.log(`[merge-agent] Triggering TLDR index warm...`);
+    await tldrService.warm(true);
+    console.log(`[merge-agent] \u2713 TLDR daemon notified to reindex`);
+    logActivity("tldr_notified", `Notified TLDR daemon to reindex ${changedFiles.length} files`);
+  } catch (error) {
+    console.warn(`[merge-agent] Failed to notify TLDR daemon: ${error.message}`);
+    logActivity("tldr_notify_error", `TLDR notification failed: ${error.message}`);
+  }
+}
+var _completedPostMerge = /* @__PURE__ */ new Set();
+var _closeIssueFailures = /* @__PURE__ */ new Map();
+var MAX_CLOSE_RETRIES = 3;
+async function postMergeLifecycle(issueId, projectPath) {
+  if (_completedPostMerge.has(issueId)) {
+    console.log(`[merge-agent] postMergeLifecycle already completed for ${issueId}, skipping`);
+    return;
+  }
+  console.log(`[merge-agent] Running post-merge cleanup for ${issueId}`);
+  try {
+    const { movePrd } = await import("./archive-planning-U3AZAKWI.js");
+    const prdResult = await movePrd({ issueId, projectPath });
+    if (prdResult.success && !prdResult.skipped) {
+      console.log(`[merge-agent] \u2713 ${prdResult.details?.join("; ")}`);
+      logActivity("prd_moved", `Moved ${issueId} PRD to completed directory`);
+    } else if (prdResult.skipped) {
+      console.log(`[merge-agent] PRD move skipped: ${prdResult.details?.join("; ")}`);
+    } else {
+      console.warn(`[merge-agent] PRD move failed: ${prdResult.error}`);
+    }
+  } catch (err) {
+    console.warn(`[merge-agent] Could not move PRD: ${err}`);
+  }
+  try {
+    const { cleanPlanningArtifacts } = await import("./clean-planning-7Z5YY64X.js");
+    const cleanResult = await cleanPlanningArtifacts({ issueId, projectPath });
+    if (cleanResult.success && !cleanResult.skipped) {
+      console.log(`[merge-agent] \u2713 ${cleanResult.details?.join("; ")}`);
+      logActivity("planning_artifacts_cleaned", cleanResult.details?.join("; ") || "Planning artifacts removed");
+    } else if (cleanResult.skipped) {
+      console.log(`[merge-agent] Planning artifact cleanup skipped: ${cleanResult.details?.join("; ")}`);
+    } else {
+      console.warn(`[merge-agent] Planning artifact cleanup failed: ${cleanResult.error}`);
+    }
+  } catch (err) {
+    console.warn(`[merge-agent] Could not clean planning artifacts: ${err}`);
+  }
+  closeIssueWithCircuitBreaker(issueId, projectPath);
+  try {
+    const { cleanupMergedLabels } = await import("./label-cleanup-4HJVX6NP.js");
+    const ghResolved = resolveGitHubIssue(issueId);
+    const labelCtx = ghResolved.isGitHub ? { issueId, projectPath, github: { owner: ghResolved.owner, repo: ghResolved.repo, number: ghResolved.number } } : { issueId, projectPath };
+    const labelResult = await cleanupMergedLabels(labelCtx);
+    if (labelResult.success && !labelResult.skipped) {
+      console.log(`[merge-agent] \u2713 ${labelResult.details?.join("; ")}`);
+      logActivity("labels_cleaned", labelResult.details?.join("; ") || "Labels cleaned");
+    } else if (labelResult.skipped) {
+      console.log(`[merge-agent] Label cleanup skipped: ${labelResult.details?.join("; ")}`);
+    } else {
+      console.warn(`[merge-agent] Label cleanup failed (non-fatal): ${labelResult.error}`);
+    }
+  } catch (err) {
+    console.warn(`[merge-agent] Could not clean labels: ${err}`);
+  }
+  try {
+    const { compactBeads } = await import("./compact-beads-72SHALOL.js");
+    const beadsResult = await compactBeads({ issueId, projectPath });
+    if (beadsResult.success && !beadsResult.skipped) {
+      console.log(`[merge-agent] \u2713 ${beadsResult.details?.join("; ")}`);
+      logActivity("beads_compaction_complete", beadsResult.details?.join("; ") || "Beads compacted");
+    }
+  } catch (err) {
+    console.warn(`[merge-agent] Beads compaction failed: ${err}`);
+  }
+  try {
+    const { getAgentState, saveAgentState } = await import("./agents-5HWTDR4S.js");
+    const { killSession, sessionExists: sessionExists2 } = await import("./tmux-X2I5SAIJ.js");
+    const agentId = `agent-${issueId.toLowerCase()}`;
+    const agentState = getAgentState(agentId);
+    if (agentState && sessionExists2(agentId)) {
+      killSession(agentId);
+      agentState.status = "stopped";
+      saveAgentState(agentState);
+      console.log(`[merge-agent] \u2713 Killed work agent session ${agentId} to free resources`);
+      logActivity("agent_session_killed", `Freed resources: killed tmux session for ${agentId}`);
+    }
+    const planningId = `planning-${issueId.toLowerCase()}`;
+    if (sessionExists2(planningId)) {
+      killSession(planningId);
+      console.log(`[merge-agent] \u2713 Killed planning agent session ${planningId}`);
+    }
+  } catch (err) {
+    console.warn(`[merge-agent] Could not kill agent sessions: ${err}`);
+  }
+  try {
+    const { findWorkspacePath } = await import("./archive-planning-U3AZAKWI.js");
+    const { stopWorkspaceDocker } = await import("./workspace-manager-G6TTBPC3.js");
+    const issueLower = issueId.toLowerCase();
+    const workspacePath = findWorkspacePath(projectPath, issueLower);
+    if (workspacePath) {
+      const projName = basename(projectPath);
+      const dockerResult = await stopWorkspaceDocker(workspacePath, projName, issueLower);
+      if (dockerResult.containersFound) {
+        console.log(`[merge-agent] \u2713 Stopped Docker containers: ${dockerResult.steps.join("; ")}`);
+        logActivity("docker_cleanup", `Stopped Docker for ${issueId}: ${dockerResult.steps.join("; ")}`);
+      }
+    }
+  } catch (err) {
+    console.warn(`[merge-agent] Docker cleanup failed (non-fatal): ${err}`);
+  }
+  _completedPostMerge.add(issueId);
+  console.log(`[merge-agent] Post-merge cleanup completed for ${issueId}. Issue moved to Done \u2014 awaiting close-out.`);
+  logActivity("merge_complete", `Merged ${issueId}. Issue moved to Done \u2014 awaiting close-out.`);
+}
+function closeIssueWithCircuitBreaker(issueId, projectPath) {
+  const failures = _closeIssueFailures.get(issueId) || 0;
+  if (failures >= MAX_CLOSE_RETRIES) {
+    console.log(`[merge-agent] Circuit breaker open for ${issueId} issue close (${failures} failures). Will be closed during close-out ceremony.`);
+    return;
+  }
+  (async () => {
+    try {
+      const { closeIssue } = await import("./close-issue-CTZK777I.js");
+      const ghResolved = resolveGitHubIssue(issueId);
+      const ctx = ghResolved.isGitHub ? { issueId, projectPath, github: { owner: ghResolved.owner, repo: ghResolved.repo, number: ghResolved.number } } : { issueId, projectPath };
+      const results = await closeIssue(ctx, { applyLabel: false, comment: "Merged to main via Panopticon merge-agent" });
+      let anyFailure = false;
+      for (const r of results) {
+        if (r.success && !r.skipped) {
+          console.log(`[merge-agent] \u2713 ${r.details?.join("; ")}`);
+          logActivity(r.step, r.details?.join("; ") || r.step);
+        } else if (!r.skipped) {
+          console.warn(`[merge-agent] \u2717 ${r.step} failed: ${r.error}`);
+          anyFailure = true;
+        }
+      }
+      if (anyFailure) {
+        const newCount = (_closeIssueFailures.get(issueId) || 0) + 1;
+        _closeIssueFailures.set(issueId, newCount);
+        if (newCount >= MAX_CLOSE_RETRIES) {
+          console.warn(`[merge-agent] Circuit breaker tripped for ${issueId} after ${newCount} failures. Issue close deferred to close-out ceremony.`);
+        }
+      } else {
+        _closeIssueFailures.delete(issueId);
+      }
+    } catch (err) {
+      const newCount = (_closeIssueFailures.get(issueId) || 0) + 1;
+      _closeIssueFailures.set(issueId, newCount);
+      console.warn(`[merge-agent] Could not move issue to Done (attempt ${newCount}/${MAX_CLOSE_RETRIES}): ${err}`);
+    }
+  })();
+}
+function resetPostMergeState(issueId) {
+  _completedPostMerge.delete(issueId);
+  _closeIssueFailures.delete(issueId);
+}
+function parseAgentOutput(output) {
+  const lines = output.split("\n");
+  let mergeResult = null;
+  let resolvedFiles = [];
+  let failedFiles = [];
+  let testsStatus = null;
+  let validationStatus = null;
+  let reason = "";
+  let notes = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("MERGE_RESULT:")) {
+      const value = trimmed.substring("MERGE_RESULT:".length).trim();
+      if (value === "SUCCESS" || value === "FAILURE") {
+        mergeResult = value;
+      }
+    }
+    if (trimmed.startsWith("RESOLVED_FILES:")) {
+      const value = trimmed.substring("RESOLVED_FILES:".length).trim();
+      resolvedFiles = value.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
+    }
+    if (trimmed.startsWith("FAILED_FILES:")) {
+      const value = trimmed.substring("FAILED_FILES:".length).trim();
+      failedFiles = value.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
+    }
+    if (trimmed.startsWith("TESTS:")) {
+      const value = trimmed.substring("TESTS:".length).trim();
+      if (value === "PASS" || value === "FAIL" || value === "SKIP") {
+        testsStatus = value;
+      }
+    }
+    if (trimmed.startsWith("VALIDATION:")) {
+      const value = trimmed.substring("VALIDATION:".length).trim();
+      if (value === "PASS" || value === "FAIL") {
+        validationStatus = value;
+      }
+    }
+    if (trimmed.startsWith("REASON:")) {
+      reason = trimmed.substring("REASON:".length).trim();
+    }
+    if (trimmed.startsWith("NOTES:")) {
+      notes = trimmed.substring("NOTES:".length).trim();
+    }
+  }
+  if (mergeResult === "SUCCESS") {
+    return {
+      success: true,
+      resolvedFiles,
+      testsStatus: testsStatus || "SKIP",
+      validationStatus: validationStatus || "NOT_RUN",
+      notes,
+      output
+    };
+  } else if (mergeResult === "FAILURE") {
+    return {
+      success: false,
+      failedFiles,
+      validationStatus: validationStatus || "NOT_RUN",
+      reason,
+      notes,
+      output
+    };
+  } else {
+    const lowerOutput = output.toLowerCase();
+    const successIndicators = [
+      "merge task complete",
+      "successfully merged",
+      "merge complete",
+      "pushed merge commit",
+      "successfully merged and pushed"
+    ];
+    const failureIndicators = [
+      "merge failed",
+      "merge task failed",
+      "could not merge",
+      "conflict not resolved"
+    ];
+    const hasSuccessIndicator = successIndicators.some((i) => lowerOutput.includes(i));
+    const hasFailureIndicator = failureIndicators.some((i) => lowerOutput.includes(i));
+    if (hasSuccessIndicator && !hasFailureIndicator) {
+      let detectedTestStatus = "SKIP";
+      if (lowerOutput.includes("tests: pass") || lowerOutput.includes("tests passed") || output.match(/\d+ passed/)) {
+        detectedTestStatus = "PASS";
+      } else if (lowerOutput.includes("tests: fail") || lowerOutput.includes("tests failed")) {
+        detectedTestStatus = "FAIL";
+      }
+      console.log("[merge-agent] Detected success from human-readable output");
+      return {
+        success: true,
+        testsStatus: detectedTestStatus,
+        validationStatus: "PASS",
+        notes: "Detected from human-readable output (agent did not use structured format)",
+        output
+      };
+    }
+    if (hasFailureIndicator) {
+      console.log("[merge-agent] Detected failure from human-readable output");
+      return {
+        success: false,
+        validationStatus: "NOT_RUN",
+        reason: "Detected merge failure from agent output",
+        output
+      };
+    }
+    return {
+      success: false,
+      validationStatus: "NOT_RUN",
+      reason: "Agent did not report result in expected format",
+      output
+    };
+  }
+}
+async function getConflictFiles(projectPath) {
+  try {
+    const { stdout: status } = await execAsync3("git diff --name-only --diff-filter=U", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    return status.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  } catch (error) {
+    console.error("Failed to get conflict files:", error);
+    return [];
+  }
+}
+function logMergeHistory(context, result, sessionId) {
+  if (!existsSync3(MERGE_HISTORY_DIR)) {
+    mkdirSync(MERGE_HISTORY_DIR, { recursive: true });
+  }
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    issueId: context.issueId,
+    sourceBranch: context.sourceBranch,
+    targetBranch: context.targetBranch,
+    conflictFiles: context.conflictFiles,
+    result: {
+      ...result,
+      output: void 0
+      // Don't store full output in history
+    },
+    sessionId
+  };
+  appendFileSync(MERGE_HISTORY_FILE, JSON.stringify(entry) + "\n", "utf-8");
+}
+function logActivity(action, details) {
+  const ACTIVITY_LOG = "/tmp/panopticon-activity.log";
+  try {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "merge-agent",
+      action,
+      details
+    };
+    appendFileSync(ACTIVITY_LOG, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+async function captureTmuxOutput(sessionName) {
+  try {
+    const { stdout } = await execAsync3(`tmux capture-pane -t "${sessionName}" -p`, { encoding: "utf-8" });
+    return stdout;
+  } catch {
+    return "";
+  }
+}
+async function isMergeAgentRunning() {
+  try {
+    await execAsync3(`tmux has-session -t specialist-merge-agent 2>/dev/null`, { encoding: "utf-8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sendMessageToAgent(issueId, message) {
+  const sessionName = `agent-${issueId.toLowerCase()}`;
+  try {
+    if (!sessionExists(sessionName)) {
+      console.log(`[merge-agent] Could not send message to ${sessionName} (session does not exist)`);
+      return false;
+    }
+    await sendKeysAsync(sessionName, message);
+    console.log(`[merge-agent] Sent message to ${sessionName}`);
+    logActivity("agent_message", `Sent to ${sessionName}: ${message.slice(0, 100)}...`);
+    return true;
+  } catch {
+    console.log(`[merge-agent] Could not send message to ${sessionName} (session may not exist)`);
+    return false;
+  }
+}
+async function spawnMergeAgent(context) {
+  console.log(`[merge-agent] Starting conflict resolution for ${context.issueId}`);
+  logActivity("merge_start", `Starting merge for ${context.issueId}: ${context.conflictFiles.join(", ")}`);
+  if (!context.testCommand) {
+    context.testCommand = detectTestCommand(context.projectPath);
+  }
+  const tmuxSession = getTmuxSessionName("merge-agent");
+  console.log(`[merge-agent] Using tmux session: ${tmuxSession}`);
+  console.log(`[merge-agent] Test command: ${context.testCommand}`);
+  if (!await isMergeAgentRunning()) {
+    console.log(`[merge-agent] Session not running, cannot proceed`);
+    logActivity("merge_error", `Session ${tmuxSession} not running`);
+    return {
+      success: false,
+      reason: `Specialist ${tmuxSession} is not running. Start Cloister first.`
+    };
+  }
+  const prompt = buildMergePrompt(context);
+  try {
+    console.log(`[merge-agent] Sending task to ${tmuxSession}...`);
+    await sendKeysAsync(tmuxSession, prompt);
+    recordWake("merge-agent");
+    logActivity("merge_task_sent", `Task sent to ${tmuxSession}`);
+    console.log(`[merge-agent] Task sent, waiting for completion...`);
+    const startTime = Date.now();
+    const POLL_INTERVAL = 5e3;
+    let lastOutput = "";
+    while (Date.now() - startTime < MERGE_TIMEOUT_MS) {
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+      const output = await captureTmuxOutput(tmuxSession);
+      if (output !== lastOutput) {
+        lastOutput = output;
+        const lowerOutput = output.toLowerCase();
+        const hasStructuredResult = output.includes("MERGE_RESULT:");
+        const hasHumanReadableResult = lowerOutput.includes("merge task complete") || lowerOutput.includes("successfully merged") || lowerOutput.includes("merge complete") || lowerOutput.includes("merge failed") || lowerOutput.includes("merge task failed");
+        if (hasStructuredResult || hasHumanReadableResult) {
+          console.log(`[merge-agent] Found result markers in output (structured: ${hasStructuredResult}, human-readable: ${hasHumanReadableResult})`);
+          const result = parseAgentOutput(output);
+          if (result.success) {
+            console.log(`[merge-agent] Agent reported success, running post-merge validation...`);
+            logActivity("merge_validation_start", `Running validation for ${context.issueId}`);
+            const baselineMatch = output.match(/Failed\s*│\s*(\d+)\s*│/);
+            const baselineTestFailures = baselineMatch ? parseInt(baselineMatch[1], 10) : void 0;
+            if (baselineTestFailures !== void 0) {
+              console.log(`[merge-agent] Extracted baseline failure count from agent: ${baselineTestFailures}`);
+            }
+            const validationResult = await runMergeValidation({
+              projectPath: context.projectPath,
+              issueId: context.issueId,
+              baselineTestFailures
+            });
+            if (validationResult.valid) {
+              console.log(`[merge-agent] \u2713 Validation passed`);
+              const gateResults = await runProjectQualityGates(context.projectPath, "pre_push");
+              const failedRequired = gateResults.filter((g) => !g.passed && g.required);
+              if (failedRequired.length > 0) {
+                const failedNames = failedRequired.map((g) => g.name).join(", ");
+                console.log(`[merge-agent] \u2717 Quality gates failed: ${failedNames}`);
+                logActivity("merge_quality_gate_fail", `Quality gates failed for ${context.issueId}: ${failedNames}`);
+                const revertSuccess = await autoRevertMerge(context.projectPath);
+                const revertNote = revertSuccess ? "Merge auto-reverted to clean state" : "WARNING: Auto-revert failed - manual cleanup required";
+                const failedResult = {
+                  success: false,
+                  validationStatus: "FAIL",
+                  reason: `Quality gate(s) failed: ${failedNames}. ${revertNote}`,
+                  notes: result.notes,
+                  output
+                };
+                logMergeHistory(context, failedResult);
+                return failedResult;
+              }
+              logActivity("merge_success", `Merge and validation completed for ${context.issueId}`);
+              result.validationStatus = "PASS";
+              logMergeHistory(context, result);
+              await postMergeLifecycle(context.issueId, context.projectPath);
+              await notifyTldrDaemon(context.projectPath, context.sourceBranch);
+              return result;
+            } else {
+              console.log(`[merge-agent] \u2717 Validation failed:`, validationResult.failures);
+              logActivity("merge_validation_fail", `Validation failed for ${context.issueId}: ${validationResult.failures.map((f) => f.type).join(", ")}`);
+              const revertSuccess = await autoRevertMerge(context.projectPath);
+              const failureReason = validationResult.failures.map((f) => `${f.type}: ${f.message}`).join("; ");
+              const revertNote = revertSuccess ? "Merge auto-reverted to clean state" : "WARNING: Auto-revert failed - manual cleanup required";
+              console.log(`[merge-agent] ${revertNote}`);
+              logActivity("merge_auto_revert", revertNote);
+              const failedResult = {
+                success: false,
+                validationStatus: "FAIL",
+                reason: `Validation failed: ${failureReason}. ${revertNote}`,
+                notes: result.notes,
+                output
+              };
+              logMergeHistory(context, failedResult);
+              return failedResult;
+            }
+          } else {
+            logActivity("merge_failure", `Merge failed for ${context.issueId}: ${result.reason}`);
+            logMergeHistory(context, result);
+            return result;
+          }
+        }
+      }
+      const elapsed = Math.round((Date.now() - startTime) / 1e3);
+      if (elapsed % 30 === 0) {
+        console.log(`[merge-agent] Still working... (${elapsed}s elapsed)`);
+      }
+    }
+    console.log(`[merge-agent] Timeout after ${MERGE_TIMEOUT_MS / 1e3} seconds`);
+    logActivity("merge_timeout", `Merge timed out for ${context.issueId}`);
+    return {
+      success: false,
+      reason: `Timeout after ${MERGE_TIMEOUT_MS / 6e4} minutes`,
+      output: lastOutput
+    };
+  } catch (error) {
+    console.error(`[merge-agent] Failed:`, error);
+    logActivity("merge_error", `Error: ${error.message}`);
+    const result = {
+      success: false,
+      reason: error.message || "Unknown error"
+    };
+    logMergeHistory(context, result);
+    return result;
+  }
+}
+async function spawnMergeAgentForBranches(projectPath, sourceBranch, targetBranch, issueId, options) {
+  console.log(`[merge-agent] Waking specialist for merge of ${sourceBranch} into ${targetBranch}`);
+  logActivity("merge_attempt", `Waking specialist for merge: ${sourceBranch} -> ${targetBranch}`);
+  try {
+    console.log(`[merge-agent] Checking for stale git lock files...`);
+    const lockCleanup = await cleanupStaleLocks(projectPath);
+    if (lockCleanup.found.length > 0) {
+      console.log(`[merge-agent] Found ${lockCleanup.found.length} lock file(s)`);
+      if (lockCleanup.removed.length > 0) {
+        console.log(`[merge-agent] \u2713 Cleaned up ${lockCleanup.removed.length} stale lock file(s):`);
+        lockCleanup.removed.forEach((f) => console.log(`  - ${f}`));
+        logActivity("git_lock_cleanup", `Removed ${lockCleanup.removed.length} stale lock file(s)`);
+      }
+      if (lockCleanup.errors.length > 0) {
+        console.warn(`[merge-agent] \u26A0\uFE0F Failed to clean up some locks:`, lockCleanup.errors);
+        if (lockCleanup.errors.some((e) => e.error.includes("Git processes are running"))) {
+          const message = "Git processes are still running - cannot safely start merge";
+          console.error(`[merge-agent] ${message}`);
+          logActivity("merge_blocked", message);
+          return { success: false, reason: message };
+        }
+      }
+    }
+    try {
+      const { stdout: remoteBranches } = await execAsync3(`git ls-remote --heads origin ${sourceBranch}`, {
+        cwd: projectPath,
+        encoding: "utf-8"
+      });
+      if (!remoteBranches.trim()) {
+        const message = `Branch ${sourceBranch} is not pushed to remote.`;
+        console.error(`[merge-agent] ${message}`);
+        logActivity("merge_blocked", message);
+        const { writeFeedbackFile } = await import("./feedback-writer-T2WCT6EZ.js");
+        const blockMsg = `# Merge Blocked
+
+Branch "${sourceBranch}" is not pushed to remote.
+
+## Required Action
+
+Run: \`git push -u origin ${sourceBranch}\``;
+        const fileResult = await writeFeedbackFile({
+          issueId,
+          specialist: "merge-agent",
+          outcome: "blocked",
+          summary: `Branch ${sourceBranch} not pushed`,
+          markdownBody: blockMsg
+        });
+        if (fileResult.success) {
+          await sendMessageToAgent(issueId, `SPECIALIST FEEDBACK: merge-agent reported BLOCKED for ${issueId}.
+Read and address: ${fileResult.relativePath}`);
+        } else {
+          console.error(`[merge-agent] Failed to write feedback file for ${issueId}: ${fileResult.error}`);
+        }
+        return { success: false, reason: message };
+      }
+    } catch {
+      const message = `Cannot verify remote branch ${sourceBranch}.`;
+      console.error(`[merge-agent] ${message}`);
+      logActivity("merge_blocked", message);
+      return { success: false, reason: message };
+    }
+  } catch (error) {
+    return { success: false, reason: `Pre-flight check failed: ${error.message}` };
+  }
+  try {
+    await execAsync3(`git fetch origin ${sourceBranch} ${targetBranch}`, {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    let isAlreadyMerged = false;
+    try {
+      await execAsync3(
+        `git merge-base --is-ancestor origin/${sourceBranch} origin/${targetBranch}`,
+        { cwd: projectPath, encoding: "utf-8" }
+      );
+      isAlreadyMerged = true;
+    } catch (e) {
+      if (e.code !== 1) {
+        throw e;
+      }
+    }
+    if (isAlreadyMerged) {
+      const message = `Branch ${sourceBranch} is already integrated into ${targetBranch} \u2014 no merge needed`;
+      console.log(`[merge-agent] ${message}`);
+      logActivity("merge_skipped", message);
+      return { success: true, reason: message };
+    }
+  } catch (ancestorErr) {
+    console.warn(`[merge-agent] Ancestor check failed: ${ancestorErr.message} (continuing)`);
+  }
+  const { stdout: headBeforeRaw } = await execAsync3("git rev-parse HEAD", {
+    cwd: projectPath,
+    encoding: "utf-8"
+  });
+  const headBefore = headBeforeRaw.trim();
+  let stashCreated = false;
+  try {
+    const { stdout: statusOut } = await execAsync3("git status --porcelain", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    if (statusOut.trim()) {
+      await execAsync3('git stash push -u -m "Pre-merge stash for ' + issueId + '"', {
+        cwd: projectPath,
+        encoding: "utf-8"
+      });
+      stashCreated = true;
+      console.log(`[merge-agent] Stashed uncommitted changes before merge`);
+    }
+  } catch (stashErr) {
+    console.warn(`[merge-agent] Failed to stash: ${stashErr.message} (continuing anyway)`);
+  }
+  const apiPort = process.env.API_PORT || process.env.PORT || "3011";
+  const apiUrl = process.env.DASHBOARD_URL || `http://localhost:${apiPort}`;
+  const skipDoneReport = options?.skipDoneReport ?? false;
+  const doneReportInstructions = skipDoneReport ? `DO NOT call /api/specialists/done \u2014 the server manages status for this merge.
+    After pushing, simply STOP. If you need to rollback, rollback and STOP.` : `Then report by calling the Panopticon API:
+    curl -s -X POST ${apiUrl}/api/specialists/done \\
+      -H "Content-Type: application/json" \\
+      -d '{"specialist":"merge","issueId":"${issueId}","status":"<passed or failed>","notes":"<reason if failed>"}'
+
+CRITICAL: You MUST call the /api/specialists/done endpoint whether you succeed or fail.`;
+  const taskPrompt = `MERGE TASK for ${issueId}:
+
+PROJECT: ${projectPath}
+SOURCE BRANCH: ${sourceBranch}
+TARGET BRANCH: ${targetBranch}
+
+INSTRUCTIONS:
+
+PHASE 1 \u2014 SYNC & BASELINE (before merge):
+1. cd ${projectPath}
+2. git checkout ${targetBranch}
+3. git fetch origin ${targetBranch}
+4. Sync local ${targetBranch} with origin/${targetBranch}:
+   Run: git rev-list --left-right --count ${targetBranch}...origin/${targetBranch}
+   (Output: "LOCAL_AHEAD  REMOTE_AHEAD". If REMOTE_AHEAD > 0, local is behind origin.)
+   If local is behind origin (REMOTE_AHEAD > 0):
+     a. git rebase origin/${targetBranch}
+        (Replays local commits on top of origin \u2014 preserves linear history, no merge commits, no data loss)
+     b. If rebase conflicts: abort with git rebase --abort, then STOP \u2014 human intervention needed.
+     c. If rebase succeeds: continue to next step
+   If local is up-to-date or ahead-only (REMOTE_AHEAD = 0): continue to next step
+5. Run tests on the CURRENT ${targetBranch} to establish a baseline:
+   - Use the Task tool with subagent_type="Bash" to run: npm test 2>&1 || true
+   - Record the number of passing and failing tests as BASELINE_PASS and BASELINE_FAIL
+   - This baseline is critical \u2014 you will compare post-merge results against it
+
+PHASE 2 \u2014 MERGE:
+6. git merge ${sourceBranch}
+7. If clean merge: the merge commit is auto-created (or fast-forward). Skip to Phase 3.
+8. If conflicts: resolve them following these steps EXACTLY:
+   a. For each conflicted file, read it, find all \`<<<<<<<\`, \`=======\`, \`>>>>>>>\` markers,
+      and edit the file to resolve the conflict (keeping the correct code from both sides).
+   b. After resolving EACH file, stage it immediately: \`git add <file>\`
+      CRITICAL: You MUST run \`git add\` for every resolved file. Without this, git still
+      considers the file unmerged and the merge commit will fail.
+   c. If you use a subagent to resolve conflicts, the subagent MUST run \`git add <file>\`
+      after editing each file. Include this instruction explicitly in any subagent prompt.
+   d. After all files are resolved and staged, verify no conflict markers remain:
+      \`grep -rn '<<<<<<< ' src/ tests/ --include='*.ts' --include='*.tsx' --include='*.js'\`
+      (Ignore matches in documentation/prompt files that reference markers as examples.)
+   e. If markers remain, resolve them and \`git add\` again.
+   f. Complete the merge: \`git commit --no-edit\` (uses the auto-generated merge message)
+   g. Verify the commit succeeded: \`git log --oneline -1\` should show a merge commit.
+
+   For .planning/ files: accept the source branch version or delete \u2014 these are ephemeral.
+   For .claude/settings.local.json: merge both permission entries.
+
+PHASE 3 \u2014 VERIFY:
+9. Build the project to verify no compile errors:
+   - Use the Task tool with subagent_type="Bash" to run the build command
+   - For Node.js: NODE_OPTIONS="--max-old-space-size=8192" npm run build
+   - For Java/Maven: ./mvnw compile
+   - Check package.json or pom.xml to determine the right command
+10. Run tests using the Task tool with subagent_type="Bash":
+    - For Node.js: npm test
+    - Record the number of passing and failing tests as MERGE_PASS and MERGE_FAIL
+
+PHASE 4 \u2014 DECIDE:
+11. Compare results:
+    - If build failed: ROLLBACK (go to step 12)
+    - If MERGE_FAIL > BASELINE_FAIL (NEW test failures introduced): ROLLBACK (go to step 12)
+    - If MERGE_FAIL <= BASELINE_FAIL (no new failures): PUSH (go to step 13)
+    - Pre-existing failures on ${targetBranch} are NOT a reason to rollback
+12. ROLLBACK: git reset --hard ORIG_HEAD
+    (ORIG_HEAD is set by git at merge time \u2014 always points to pre-merge state)
+    ${doneReportInstructions.includes("DO NOT") ? "Then STOP." : `Then report failure by calling the Panopticon API:
+    curl -s -X POST ${apiUrl}/api/specialists/done \\
+      -H "Content-Type: application/json" \\
+      -d '{"specialist":"merge","issueId":"${issueId}","status":"failed","notes":"<reason for rollback>"}'
+    Then STOP.`}
+13. PUSH: git push origin ${targetBranch}
+    If push is rejected (non-fast-forward / "tip of your current branch is behind"):
+      a. git fetch origin ${targetBranch}
+      b. git rebase origin/${targetBranch}
+         (Replay on top of any new remote commits \u2014 safe, no data loss)
+      c. If rebase conflicts: abort with git rebase --abort, ROLLBACK (go to step 12)
+      d. If rebase succeeds: retry git push origin ${targetBranch}
+      e. If push fails again after one retry: ROLLBACK (go to step 12)
+    ${doneReportInstructions}
+
+CRITICAL: You MUST complete this merge. The approve operation is waiting.
+
+WHY USE SUBAGENTS FOR BUILD/TEST:
+- Subagents have isolated context and won't pollute your working memory
+- Build and test output can be verbose - subagents handle this cleanly
+- If tests fail, the subagent returns a clear summary
+
+DO NOT:
+- Delete the feature branch (locally or remotely)
+- Clean up workspaces
+- Use git push --force or --force-with-lease \u2014 NEVER force-push under any circumstances
+- Skip the build step - compile errors after merge are common
+- Skip the baseline test run \u2014 without it you cannot distinguish new failures from pre-existing ones
+- Use HEAD~1 for rollback \u2014 use ORIG_HEAD which git sets automatically at merge time
+- Run git stash \u2014 the TypeScript layer handles stash/restore automatically
+- Do anything beyond the sync, merge, build, test, and push steps above
+
+Report any issues or conflicts you encountered.`;
+  const resolvedProject = resolveProjectFromIssue(issueId);
+  const mergeProjectKey = resolvedProject?.projectKey ?? null;
+  const mergeSession = getTmuxSessionName("merge-agent", mergeProjectKey ?? void 0);
+  if (!resolvedProject) {
+    console.warn(`[merge-agent] Could not resolve project for ${issueId} \u2014 falling back to global specialist. Check projects.yaml configuration.`);
+  }
+  if (mergeProjectKey) {
+    const { getAgentRuntimeState, saveAgentRuntimeState } = await import("./agents-5HWTDR4S.js");
+    const IDLE_POLL_INTERVAL = 3e3;
+    const IDLE_MAX_WAIT = 36e4;
+    const idleStart = Date.now();
+    while (Date.now() - idleStart < IDLE_MAX_WAIT) {
+      const state = getAgentRuntimeState(mergeSession);
+      if (!state || state.state === "idle" || state.state === "suspended") {
+        break;
+      }
+      try {
+        await execAsync3(`tmux has-session -t "${mergeSession}" 2>/dev/null`);
+      } catch {
+        console.log(`[merge-agent] Specialist session ${mergeSession} is dead (state was ${state.state}), resetting to idle`);
+        saveAgentRuntimeState(mergeSession, { state: "idle", lastActivity: (/* @__PURE__ */ new Date()).toISOString() });
+        break;
+      }
+      console.log(`[merge-agent] Specialist busy (state: ${state.state}, issue: ${state.currentIssue}), waiting...`);
+      await new Promise((resolve) => setTimeout(resolve, IDLE_POLL_INTERVAL));
+    }
+    const finalState = getAgentRuntimeState(mergeSession);
+    if (finalState && finalState.state !== "idle" && finalState.state !== "suspended") {
+      console.warn(`[merge-agent] Specialist still busy after ${IDLE_MAX_WAIT / 1e3}s, proceeding anyway`);
+    }
+  }
+  let wakeResult;
+  if (mergeProjectKey) {
+    console.log(`[merge-agent] Using per-project ephemeral specialist for ${issueId} (${mergeProjectKey})`);
+    wakeResult = await spawnEphemeralSpecialist(mergeProjectKey, "merge-agent", {
+      issueId,
+      branch: sourceBranch,
+      workspace: projectPath,
+      promptOverride: taskPrompt
+    });
+  } else {
+    console.log(`[merge-agent] Project resolution failed, falling back to legacy global specialist for ${issueId}`);
+    wakeResult = await wakeSpecialist("merge-agent", taskPrompt, {
+      waitForReady: true,
+      startIfNotRunning: true,
+      issueId
+    });
+  }
+  if (!wakeResult.success) {
+    console.error(`[merge-agent] Failed to wake specialist: ${wakeResult.message}`);
+    logActivity("merge_error", `Failed to wake specialist: ${wakeResult.message}`);
+    return {
+      success: false,
+      reason: `Failed to wake merge-agent specialist: ${wakeResult.message}`
+    };
+  }
+  console.log(`[merge-agent] Specialist woken, waiting for merge completion...`);
+  logActivity("merge_specialist_woken", `Specialist woken, task sent`);
+  const POLL_INTERVAL = 5e3;
+  const MAX_WAIT = 15 * 60 * 1e3;
+  const startTime = Date.now();
+  while (Date.now() - startTime < MAX_WAIT) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+    try {
+      const { stdout: currentBranchRaw } = await execAsync3("git branch --show-current", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      });
+      const currentBranch = currentBranchRaw.trim();
+      if (currentBranch !== targetBranch) {
+        continue;
+      }
+      const { stdout: currentHeadRaw } = await execAsync3("git rev-parse HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      });
+      const currentHead = currentHeadRaw.trim();
+      if (currentHead !== headBefore) {
+        {
+          try {
+            await execAsync3(`git fetch origin ${targetBranch}`, {
+              cwd: projectPath,
+              encoding: "utf-8",
+              timeout: 1e4
+            }).catch(() => {
+            });
+            const { stdout: remoteHeadRaw } = await execAsync3(`git rev-parse origin/${targetBranch}`, {
+              cwd: projectPath,
+              encoding: "utf-8"
+            });
+            const remoteHead = remoteHeadRaw.trim();
+            if (remoteHead === currentHead) {
+              console.log(`[merge-agent] Merge completed and pushed, running validation...`);
+              logActivity("merge_validation_start", `Running post-merge validation for ${issueId}`);
+              let specialistBaseline;
+              try {
+                const specialistOutput = await captureTmuxOutput(mergeSession);
+                const baselineMatch = specialistOutput.match(/Failed\s*│\s*(\d+)\s*│/);
+                specialistBaseline = baselineMatch ? parseInt(baselineMatch[1], 10) : void 0;
+                if (specialistBaseline !== void 0) {
+                  console.log(`[merge-agent] Extracted baseline from specialist: ${specialistBaseline}`);
+                }
+              } catch {
+              }
+              const validationResult = await runMergeValidation({
+                projectPath,
+                issueId,
+                baselineTestFailures: specialistBaseline
+              });
+              if (validationResult.valid) {
+                const skipNote = validationResult.skipped ? " (no validation script, specialist already validated)" : "";
+                console.log(`[merge-agent] \u2713 Merge validation passed${skipNote}`);
+                const gateResults = await runProjectQualityGates(projectPath, "pre_push");
+                const failedRequired = gateResults.filter((g) => !g.passed && g.required);
+                if (failedRequired.length > 0) {
+                  const failedNames = failedRequired.map((g) => g.name).join(", ");
+                  console.log(`[merge-agent] \u2717 Quality gates failed: ${failedNames}`);
+                  logActivity("merge_quality_gate_fail", `Quality gates failed for ${issueId}: ${failedNames}`);
+                  const revertSuccess = await autoRevertMerge(projectPath);
+                  const revertNote = revertSuccess ? "Merge auto-reverted to clean state" : "WARNING: Auto-revert failed";
+                  return {
+                    success: false,
+                    validationStatus: "FAIL",
+                    reason: `Quality gate(s) failed: ${failedNames}. ${revertNote}`
+                  };
+                }
+                logActivity("merge_complete", `Merge completed by specialist${skipNote}`);
+                await postMergeLifecycle(issueId, projectPath);
+                if (stashCreated) {
+                  try {
+                    await execAsync3("git stash pop", { cwd: projectPath, encoding: "utf-8" });
+                    console.log(`[merge-agent] \u2713 Restored stashed changes after successful merge`);
+                  } catch (popErr) {
+                    console.warn(`[merge-agent] \u26A0 Failed to restore stash after merge: ${popErr.message}`);
+                  }
+                }
+                return {
+                  success: true,
+                  validationStatus: "PASS",
+                  testsStatus: "SKIP",
+                  // Specialist ran tests, we trust the result
+                  notes: "Merge completed by merge-agent specialist and validation passed"
+                };
+              } else {
+                console.log(`[merge-agent] \u2717 Validation failed:`, validationResult.failures);
+                logActivity("merge_validation_fail", `Validation failed: ${validationResult.failures.map((f) => f.type).join(", ")}`);
+                const revertSuccess = await autoRevertMerge(projectPath);
+                if (revertSuccess) {
+                  try {
+                    await execAsync3(`git push --force-with-lease origin ${targetBranch}`, {
+                      cwd: projectPath,
+                      encoding: "utf-8"
+                    });
+                    console.log(`[merge-agent] \u2713 Auto-revert pushed to remote`);
+                    logActivity("merge_auto_revert", "Merge auto-reverted and pushed to remote");
+                  } catch (pushError) {
+                    console.error(`[merge-agent] \u2717 Failed to push revert: ${pushError.message}`);
+                    logActivity("merge_revert_push_fail", "Auto-revert successful but push failed");
+                  }
+                }
+                if (stashCreated) {
+                  try {
+                    await execAsync3("git stash pop", { cwd: projectPath, encoding: "utf-8" });
+                    console.log(`[merge-agent] \u2713 Restored stashed changes after revert`);
+                  } catch (popErr) {
+                    console.warn(`[merge-agent] \u26A0 Failed to restore stash after revert: ${popErr.message}`);
+                  }
+                }
+                const failureReason = validationResult.failures.map((f) => `${f.type}: ${f.message}`).join("; ");
+                const revertNote = revertSuccess ? "Merge auto-reverted and force-pushed to remote" : "WARNING: Auto-revert failed - manual cleanup required";
+                return {
+                  success: false,
+                  validationStatus: "FAIL",
+                  reason: `Validation failed: ${failureReason}. ${revertNote}`,
+                  notes: "Merge completed but validation failed, auto-reverted"
+                };
+              }
+            }
+          } catch {
+            console.log(`[merge-agent] Merge completed locally, push status unknown`);
+          }
+          console.log(`[merge-agent] Merge commit detected, waiting for push...`);
+        }
+      }
+      if (!await isRunning("merge-agent", mergeProjectKey ?? void 0)) {
+        console.error(`[merge-agent] Specialist stopped unexpectedly \u2014 checking for stranded merge commit`);
+        logActivity("merge_error", "Specialist stopped unexpectedly");
+        const salvageResult2 = await salvageStrandedMerge(projectPath, targetBranch, headBefore, issueId, logActivity);
+        if (salvageResult2) return salvageResult2;
+        return {
+          success: false,
+          reason: "merge-agent specialist stopped before completing the merge"
+        };
+      }
+    } catch (pollError) {
+      console.warn(`[merge-agent] Poll error: ${pollError.message}`);
+    }
+  }
+  console.error(`[merge-agent] Timeout waiting for merge completion \u2014 checking for stranded merge commit`);
+  logActivity("merge_timeout", "Timeout waiting for specialist to complete merge");
+  const salvageResult = await salvageStrandedMerge(projectPath, targetBranch, headBefore, issueId, logActivity);
+  if (salvageResult) return salvageResult;
+  return {
+    success: false,
+    reason: "Timeout waiting for merge-agent specialist to complete merge (15 minutes)"
+  };
+}
+async function salvageStrandedMerge(projectPath, targetBranch, headBefore, issueId, logActivity2) {
+  try {
+    const { stdout: currentHeadRaw } = await execAsync3("git rev-parse HEAD", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    const currentHead = currentHeadRaw.trim();
+    if (currentHead === headBefore) {
+      return null;
+    }
+    await execAsync3(`git fetch origin ${targetBranch}`, {
+      cwd: projectPath,
+      encoding: "utf-8",
+      timeout: 1e4
+    }).catch(() => {
+    });
+    const { stdout: remoteHeadRaw } = await execAsync3(`git rev-parse origin/${targetBranch}`, {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    if (remoteHeadRaw.trim() === currentHead) {
+      console.log(`[merge-agent] Salvage check: merge already pushed`);
+      return { success: true };
+    }
+    console.log(`[merge-agent] SALVAGING stranded merge for ${issueId}: local HEAD ${currentHead.slice(0, 8)} != remote ${remoteHeadRaw.trim().slice(0, 8)}`);
+    logActivity2("merge_salvage", `Pushing stranded merge commit ${currentHead.slice(0, 8)} for ${issueId}`);
+    await execAsync3(`git push origin ${targetBranch}`, {
+      cwd: projectPath,
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    console.log(`[merge-agent] Salvage push successful for ${issueId}`);
+    logActivity2("merge_salvage_success", `Stranded merge pushed successfully`);
+    return { success: true };
+  } catch (error) {
+    console.error(`[merge-agent] Salvage failed: ${error.message}`);
+    logActivity2("merge_salvage_failed", `Salvage push failed: ${error.message}`);
+    return null;
+  }
+}
+async function scanForConflictMarkers(projectPath) {
+  try {
+    const { stdout } = await execAsync3("git diff --check 2>&1 || true", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    const files = stdout.split("\n").filter((line) => line.includes("leftover conflict marker")).map((line) => line.split(":")[0].trim()).filter((f) => f.length > 0);
+    return [...new Set(files)];
+  } catch {
+    return [];
+  }
+}
+async function syncMainIntoWorkspace(projectPath, issueId) {
+  console.log(`[sync-main] Starting sync of main into workspace for ${issueId}`);
+  logActivity("sync_main_start", `Starting sync for ${issueId}`);
+  try {
+    const { stdout: statusOut } = await execAsync3("git status --porcelain", {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    if (statusOut.trim()) {
+      console.log(`[sync-main] Uncommitted changes detected, auto-committing...`);
+      logActivity("sync_main_auto_commit", `Auto-committing uncommitted changes before sync`);
+      try {
+        await execAsync3('git add -A && git commit -m "WIP: auto-commit before sync with main"', {
+          cwd: projectPath,
+          encoding: "utf-8"
+        });
+        console.log(`[sync-main] Auto-commit successful`);
+      } catch (commitErr) {
+        const message = `Failed to auto-commit uncommitted changes: ${commitErr.message}`;
+        console.error(`[sync-main] ${message}`);
+        logActivity("sync_main_blocked", message);
+        return { success: false, reason: message };
+      }
+      const { stdout: postCommitStatus } = await execAsync3("git status --porcelain", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      });
+      if (postCommitStatus.trim()) {
+        const message = "Uncommitted changes remain after auto-commit \u2014 aborting sync";
+        console.error(`[sync-main] ${message}`);
+        logActivity("sync_main_blocked", message);
+        return { success: false, reason: message };
+      }
+    }
+  } catch (error) {
+    return { success: false, reason: `Failed to check git status: ${error.message}` };
+  }
+  try {
+    const lockCleanup = await cleanupStaleLocks(projectPath);
+    if (lockCleanup.found.length > 0) {
+      console.log(`[sync-main] Found ${lockCleanup.found.length} lock file(s)`);
+      if (lockCleanup.removed.length > 0) {
+        console.log(`[sync-main] Cleaned up ${lockCleanup.removed.length} stale lock file(s)`);
+        logActivity("git_lock_cleanup", `Removed ${lockCleanup.removed.length} stale lock file(s)`);
+      }
+      if (lockCleanup.errors.some((e) => e.error.includes("Git processes are running"))) {
+        const message = "Git processes are still running \u2014 cannot safely start sync";
+        console.error(`[sync-main] ${message}`);
+        logActivity("sync_main_blocked", message);
+        return { success: false, reason: message };
+      }
+    }
+  } catch (lockErr) {
+    console.warn(`[sync-main] Lock cleanup warning: ${lockErr.message} (continuing)`);
+  }
+  try {
+    console.log(`[sync-main] Fetching origin/main...`);
+    await execAsync3("git fetch origin main", { cwd: projectPath, encoding: "utf-8" });
+  } catch (error) {
+    return { success: false, reason: `Failed to fetch origin/main: ${error.message}` };
+  }
+  let mergeOutput = "";
+  let hasConflicts = false;
+  try {
+    const result = await execAsync3("git merge origin/main", { cwd: projectPath, encoding: "utf-8" });
+    mergeOutput = (result.stdout || "") + (result.stderr || "");
+  } catch (error) {
+    mergeOutput = (error.stdout || "") + (error.stderr || "");
+    hasConflicts = true;
+  }
+  if (mergeOutput.includes("Already up to date") || mergeOutput.includes("Already up-to-date")) {
+    console.log(`[sync-main] Already up to date`);
+    logActivity("sync_main_noop", `${issueId} already up to date with main`);
+    return { success: true, alreadyUpToDate: true };
+  }
+  if (!hasConflicts) {
+    console.log(`[sync-main] Clean merge completed`);
+    logActivity("sync_main_success", `Clean merge of main into ${issueId}`);
+    let changedFiles = [];
+    let commitCount = 0;
+    try {
+      const { stdout: diffFiles } = await execAsync3(
+        "git diff --name-only ORIG_HEAD HEAD 2>/dev/null || git diff --name-only HEAD~1 HEAD",
+        { cwd: projectPath, encoding: "utf-8" }
+      );
+      changedFiles = diffFiles.trim().split("\n").filter((f) => f.length > 0);
+    } catch {
+    }
+    try {
+      const { stdout: logOut } = await execAsync3(
+        'git log ORIG_HEAD..HEAD --oneline 2>/dev/null || echo ""',
+        { cwd: projectPath, encoding: "utf-8" }
+      );
+      commitCount = logOut.trim().split("\n").filter((l) => l.length > 0).length;
+    } catch {
+    }
+    return { success: true, commitCount, changedFiles };
+  }
+  const conflictFiles = await getConflictFiles(projectPath);
+  console.log(`[sync-main] ${conflictFiles.length} conflict(s), waking merge-agent...`);
+  logActivity("sync_main_conflicts", `${conflictFiles.length} conflict(s) in ${issueId}: ${conflictFiles.join(", ")}`);
+  const workspaceBranch = await execAsync3("git branch --show-current", { cwd: projectPath, encoding: "utf-8" }).then((r) => r.stdout.trim()).catch(() => `feature/${issueId.toLowerCase()}`);
+  const promptPath = join3(__dirname2, "prompts", "sync-main.md");
+  let taskPrompt;
+  try {
+    const template = readFileSync(promptPath, "utf-8");
+    taskPrompt = template.replace(/{{projectPath}}/g, projectPath).replace(/{{workspaceBranch}}/g, workspaceBranch).replace(/{{issueId}}/g, issueId).replace(/{{conflictFiles}}/g, conflictFiles.map((f) => `- ${f}`).join("\n"));
+  } catch (templateErr) {
+    console.error(`[sync-main] Could not load sync-main.md template: ${templateErr.message}`);
+    logActivity("sync_main_error", `Template load failed: ${templateErr.message}`);
+    try {
+      await execAsync3("git merge --abort", { cwd: projectPath, encoding: "utf-8" });
+    } catch {
+    }
+    return { success: false, conflictFiles, reason: "Internal error: sync-main prompt template not found" };
+  }
+  const syncResolvedProject = resolveProjectFromIssue(issueId);
+  const syncProjectKey = syncResolvedProject?.projectKey ?? null;
+  let syncWakeResult;
+  if (syncProjectKey) {
+    syncWakeResult = await spawnEphemeralSpecialist(syncProjectKey, "merge-agent", {
+      issueId,
+      branch: workspaceBranch,
+      workspace: projectPath,
+      promptOverride: taskPrompt
+    });
+  } else {
+    syncWakeResult = await wakeSpecialist("merge-agent", taskPrompt, {
+      waitForReady: true,
+      startIfNotRunning: true,
+      issueId
+    });
+  }
+  if (!syncWakeResult.success) {
+    try {
+      await execAsync3("git merge --abort", { cwd: projectPath, encoding: "utf-8" });
+    } catch {
+    }
+    const message = `Failed to wake merge-agent specialist: ${syncWakeResult.message}`;
+    console.error(`[sync-main] ${message}`);
+    logActivity("sync_main_error", message);
+    return { success: false, conflictFiles, reason: message };
+  }
+  console.log(`[sync-main] Specialist woken, waiting for conflict resolution...`);
+  logActivity("sync_main_agent_woken", `Agent resolving ${conflictFiles.length} conflict(s) for ${issueId}`);
+  const tmuxSession = getTmuxSessionName("merge-agent", syncProjectKey ?? void 0);
+  const startTime = Date.now();
+  const POLL_INTERVAL = 5e3;
+  const SYNC_TIMEOUT_MS = 15 * 60 * 1e3;
+  let lastOutput = "";
+  while (Date.now() - startTime < SYNC_TIMEOUT_MS) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
+    const output = await captureTmuxOutput(tmuxSession);
+    if (output !== lastOutput) {
+      lastOutput = output;
+      const hasStructured = output.includes("MERGE_RESULT:");
+      const lowerOutput = output.toLowerCase();
+      const hasHumanReadable = lowerOutput.includes("merge task complete") || lowerOutput.includes("successfully merged") || lowerOutput.includes("merge complete") || lowerOutput.includes("merge failed") || lowerOutput.includes("merge task failed");
+      if (hasStructured || hasHumanReadable) {
+        const agentResult = parseAgentOutput(output);
+        if (agentResult.success) {
+          const remaining = await scanForConflictMarkers(projectPath);
+          if (remaining.length > 0) {
+            try {
+              await execAsync3("git merge --abort", { cwd: projectPath, encoding: "utf-8" });
+            } catch {
+            }
+            const msg = `Agent reported success but ${remaining.length} conflict marker(s) remain in: ${remaining.join(", ")}`;
+            console.error(`[sync-main] ${msg}`);
+            logActivity("sync_main_markers_remain", msg);
+            return { success: false, conflictFiles, reason: msg };
+          }
+          console.log(`[sync-main] \u2713 Conflicts resolved by agent`);
+          logActivity("sync_main_success", `Merge agent resolved conflicts for ${issueId}`);
+          let changedFiles = [];
+          let commitCount = 0;
+          try {
+            const { stdout: diffFiles } = await execAsync3(
+              "git diff --name-only ORIG_HEAD HEAD",
+              { cwd: projectPath, encoding: "utf-8" }
+            );
+            changedFiles = diffFiles.trim().split("\n").filter((f) => f.length > 0);
+            const { stdout: logOut } = await execAsync3(
+              "git log ORIG_HEAD..HEAD --oneline",
+              { cwd: projectPath, encoding: "utf-8" }
+            );
+            commitCount = logOut.trim().split("\n").filter((l) => l.length > 0).length;
+          } catch {
+          }
+          return { success: true, commitCount, changedFiles };
+        } else {
+          try {
+            await execAsync3("git merge --abort", { cwd: projectPath, encoding: "utf-8" });
+          } catch {
+          }
+          console.log(`[sync-main] \u2717 Agent could not resolve conflicts`);
+          logActivity("sync_main_agent_failed", `Agent failed to resolve conflicts for ${issueId}`);
+          return {
+            success: false,
+            conflictFiles,
+            reason: agentResult.reason || "Merge agent could not resolve conflicts"
+          };
+        }
+      }
+    }
+    const elapsed = Math.round((Date.now() - startTime) / 1e3);
+    if (elapsed % 30 === 0) {
+      console.log(`[sync-main] Still waiting for agent... (${elapsed}s elapsed)`);
+    }
+  }
+  try {
+    await execAsync3("git merge --abort", { cwd: projectPath, encoding: "utf-8" });
+  } catch {
+  }
+  logActivity("sync_main_timeout", `Sync timed out for ${issueId}`);
+  return {
+    success: false,
+    conflictFiles,
+    reason: `Timeout: merge agent did not complete within ${SYNC_TIMEOUT_MS / 6e4} minutes`
+  };
+}
+async function runProjectQualityGates(projectPath, phase) {
+  try {
+    const config = loadProjectsConfig();
+    const project = Object.values(config.projects).find((p) => projectPath.startsWith(p.path));
+    if (!project?.quality_gates || Object.keys(project.quality_gates).length === 0) {
+      console.log(`[merge-agent] No quality gates configured for ${projectPath}`);
+      return [];
+    }
+    const repoRelPath = relative(project.path, projectPath);
+    let gatesToRun = project.quality_gates;
+    if (repoRelPath && !repoRelPath.startsWith("..")) {
+      const filtered = Object.entries(project.quality_gates).filter(
+        ([, gate]) => gate.path === repoRelPath
+      );
+      if (filtered.length === 0) {
+        console.log(`[merge-agent] No quality gates configured for repo path "${repoRelPath}"`);
+        return [];
+      }
+      gatesToRun = Object.fromEntries(filtered);
+      console.log(
+        `[merge-agent] Polyrepo: running ${Object.keys(gatesToRun).length} gate(s) for path "${repoRelPath}"`
+      );
+    }
+    console.log(`[merge-agent] Running ${phase} quality gates for project "${project.name}"`);
+    return await runQualityGates(gatesToRun, projectPath, phase);
+  } catch (error) {
+    console.error(`[merge-agent] Failed to load quality gates: ${error.message}`);
+    return [];
+  }
+}
+export {
+  postMergeLifecycle,
+  resetPostMergeState,
+  runProjectQualityGates,
+  scanForConflictMarkers,
+  spawnMergeAgent,
+  spawnMergeAgentForBranches,
+  syncMainIntoWorkspace
+};
+//# sourceMappingURL=merge-agent-WM7ZKUET.js.map