@hua-labs/tap 0.5.1 → 0.6.0

package/dist/bridges/codex-bridge-runner.mjs

@@ -148,6 +148,7 @@ var init_termination = __esm({
 import * as fs6 from "fs";
 import * as path5 from "path";
 import * as crypto2 from "crypto";
+import { spawnSync } from "child_process";
 function trimAddress(value) {
   return value.trim();
 }
@@ -177,26 +178,70 @@ function extractPrNumber(text) {
   }
   return null;
 }
+function computePendingRequestKey(request) {
+  return request.messageId ? `message:${request.messageId}` : `source:${request.sourcePath}`;
+}
+function parseInboxContentFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match?.[1]) return null;
+  const fields = {};
+  for (const line of match[1].split("\n")) {
+    const kv = line.match(/^(\w+):\s*(.+)$/);
+    if (kv?.[1] && kv[2]) fields[kv[1]] = kv[2].trim();
+  }
+  return {
+    sent_at: fields.sent_at,
+    message_id: fields.message_id,
+    to: fields.to
+  };
+}
 function detectReviewRequest(filePath, content, generation) {
   const parsed = parseInboxFilename(filePath);
   if (!parsed) return null;
+  if (parsed.subject.startsWith("headless-dispatch-")) return null;
   const fullText = `${parsed.subject} ${content}`;
   const isReview = REVIEW_KEYWORDS.some((re) => re.test(fullText));
   const isReReview = REREVIEW_KEYWORDS.some((re) => re.test(fullText));
   if (!isReview && !isReReview) return null;
   const prNumber = extractPrNumber(fullText);
   if (!prNumber) return null;
+  const sourceMtimeMs = fs6.existsSync(filePath) ? fs6.statSync(filePath).mtimeMs : 0;
+  const fm = parseInboxContentFrontmatter(content);
   return {
     sourcePath: filePath,
+    sourceMtimeMs,
+    requestTimestampMs: extractRequestTimestampMs(
+      parsed.date,
+      fm,
+      sourceMtimeMs
+    ),
     sender: parsed.sender,
     recipient: parsed.recipient,
     prNumber,
     generation,
     isReReview,
-    round: isReReview ? 2 : 1
+    round: isReReview ? 2 : 1,
     // Will be adjusted by session tracking
+    messageId: fm?.message_id || void 0,
+    dedupeRecipient: fm?.to || void 0
   };
 }
+function extractRequestTimestampMs(inboxDate, fm, fallbackMtimeMs) {
+  if (fm?.sent_at) {
+    const sentAtMs = new Date(fm.sent_at).getTime();
+    if (Number.isFinite(sentAtMs) && sentAtMs > 0) return sentAtMs;
+  }
+  const dateMatch = inboxDate.match(/^(\d{4})(\d{2})(\d{2})$/);
+  if (dateMatch) {
+    const [, year, month, day] = dateMatch;
+    return Date.UTC(
+      Number.parseInt(year, 10),
+      Number.parseInt(month, 10) - 1,
+      Number.parseInt(day, 10)
+    );
+  }
+  return fallbackMtimeMs;
+}
 function buildReviewPrompt(request, agentName, round) {
   const roundLabel = round > 1 ? ` (re-review round ${round})` : "";
   return [
@@ -311,17 +356,17 @@ function parseReviewOutput(reviewFilePath2, round) {
     findingHash: computeFindingHash(findings)
   };
 }
-function reviewFilePath(commsDir, generation, prNumber, agentName) {
+function reviewFilePath(repoRoot, generation, prNumber, agentName) {
   return path5.join(
-    commsDir,
+    repoRoot,
     "reviews",
     generation,
     `review-PR${prNumber}-${agentName}.md`
   );
 }
-function isStaleReviewRequest(request, commsDir, agentName) {
+function isStaleReviewRequest(request, repoRoot, agentName) {
   const revPath = reviewFilePath(
-    commsDir,
+    repoRoot,
     request.generation,
     request.prNumber,
     agentName
@@ -333,29 +378,87 @@ function isStaleReviewRequest(request, commsDir, agentName) {
   }
   return false;
 }
-function computeRequestMarkerId(filePath) {
-  const stat = fs6.statSync(filePath);
-  const input = `${filePath}|${stat.mtimeMs}`;
+function resolvePrHead(repoRoot, request, cache) {
+  const cacheKey = request.messageId ? `message:${request.messageId}` : `source:${request.sourcePath}:mtime:${request.sourceMtimeMs}`;
+  const cached = cache.get(cacheKey);
+  if (cached && Date.now() - cached.checkedAtMs < PR_HEAD_CACHE_REVALIDATE_MS) {
+    return cached.value;
+  }
+  let result = null;
+  try {
+    const command = spawnSync(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(request.prNumber),
+        "--json",
+        "headRefName,headRefOid"
+      ],
+      { cwd: repoRoot, encoding: "utf-8", timeout: 1e4 }
+    );
+    if (command.status === 0 && command.stdout.trim()) {
+      const parsed = JSON.parse(command.stdout);
+      result = {
+        headRefName: parsed.headRefName,
+        headRefOid: parsed.headRefOid
+      };
+    }
+  } catch {
+    result = null;
+  }
+  cache.set(cacheKey, {
+    value: result,
+    checkedAtMs: Date.now()
+  });
+  return result;
+}
+function computeRequestMarkerId(request) {
+  const recipient = request.dedupeRecipient || request.recipient;
+  if (request.prTipSha) {
+    return crypto2.createHash("sha1").update(
+      `pr:${request.prNumber}:tip:${request.prTipSha}:recipient:${recipient}`
+    ).digest("hex");
+  }
+  if (request.messageId) {
+    return crypto2.createHash("sha1").update(`message_id:${request.messageId}:recipient:${recipient}`).digest("hex");
+  }
+  let contentHash = "";
+  try {
+    const content = fs6.readFileSync(request.sourcePath, "utf-8");
+    contentHash = crypto2.createHash("sha1").update(content).digest("hex");
+  } catch {
+  }
+  const input = JSON.stringify({
+    sourcePath: request.sourcePath,
+    sender: request.sender,
+    recipient: request.recipient,
+    prNumber: request.prNumber,
+    generation: request.generation,
+    isReReview: request.isReReview,
+    contentHash
+  });
   return crypto2.createHash("sha1").update(input).digest("hex");
 }
-function isAlreadyProcessed(stateDir, filePath) {
-  const markerId = computeRequestMarkerId(filePath);
+function isAlreadyProcessed(stateDir, request) {
+  const markerId = computeRequestMarkerId(request);
   return fs6.existsSync(path5.join(stateDir, "processed", `${markerId}.done`));
 }
 function unmarkProcessed(stateDir, request) {
-  const markerId = computeRequestMarkerId(request.sourcePath);
+  const markerId = computeRequestMarkerId(request);
   const markerPath = path5.join(stateDir, "processed", `${markerId}.done`);
   if (fs6.existsSync(markerPath)) {
     fs6.unlinkSync(markerPath);
   }
 }
 function markAsProcessed(stateDir, request) {
-  const markerId = computeRequestMarkerId(request.sourcePath);
+  const markerId = computeRequestMarkerId(request);
   const markerDir = path5.join(stateDir, "processed");
   fs6.mkdirSync(markerDir, { recursive: true });
   const markerPath = path5.join(markerDir, `${markerId}.done`);
   const payload = {
     prNumber: request.prNumber,
+    prTipSha: request.prTipSha ?? null,
     sourcePath: request.sourcePath,
     processedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -392,11 +495,13 @@ function getHeadlessEnvConfig() {
     qualityFloor: process.env.TAP_QUALITY_FLOOR ?? "high"
   };
 }
-function scanInboxForReviews(commsDir, stateDir, generation, agentName, agentId = agentName) {
+function scanInboxForReviews(commsDir, stateDir, repoRoot, generation, agentName, agentId = agentName, activeSessionPrNumber, prHeadCache) {
   const inboxDir = path5.join(commsDir, "inbox");
   if (!fs6.existsSync(inboxDir)) return [];
   const files = fs6.readdirSync(inboxDir).filter((f) => f.endsWith(".md"));
   const requests = [];
+  const shouldResolvePrHead = fs6.existsSync(path5.join(repoRoot, ".git"));
+  const activePrHeadCache = shouldResolvePrHead ? prHeadCache ?? /* @__PURE__ */ new Map() : null;
   for (const file of files) {
     const filePath = path5.join(inboxDir, file);
     const content = fs6.readFileSync(filePath, "utf-8");
@@ -407,13 +512,34 @@ function scanInboxForReviews(commsDir, stateDir, generation, agentName, agentId
       continue;
     }
     if (isOwnMessageAddress(request.sender, agentId, agentName)) continue;
-    if (isStaleReviewRequest(request, commsDir, agentName)) continue;
-    if (isAlreadyProcessed(stateDir, filePath)) continue;
+    if (activePrHeadCache) {
+      const prHead = resolvePrHead(repoRoot, request, activePrHeadCache);
+      if (prHead?.headRefName) request.branch = prHead.headRefName;
+      if (prHead?.headRefOid) request.prTipSha = prHead.headRefOid;
+    }
+    const bypassProcessedCheck = request.isReReview && activeSessionPrNumber != null && request.prNumber === activeSessionPrNumber;
+    const bypassStaleCheck = request.isReReview && activeSessionPrNumber != null && request.prNumber === activeSessionPrNumber;
+    if (!bypassStaleCheck && isStaleReviewRequest(request, repoRoot, agentName))
+      continue;
+    if (!bypassProcessedCheck && isAlreadyProcessed(stateDir, request))
+      continue;
     requests.push(request);
   }
+  requests.sort((a, b) => {
+    if (a.isReReview !== b.isReReview) {
+      return Number(b.isReReview) - Number(a.isReReview);
+    }
+    if (a.requestTimestampMs !== b.requestTimestampMs) {
+      return b.requestTimestampMs - a.requestTimestampMs;
+    }
+    if (a.sourceMtimeMs !== b.sourceMtimeMs) {
+      return b.sourceMtimeMs - a.sourceMtimeMs;
+    }
+    return b.prNumber - a.prNumber;
+  });
   return requests;
 }
-var REVIEW_KEYWORDS, REREVIEW_KEYWORDS, PR_NUMBER_PATTERNS, SEVERITY_PATTERNS, CATEGORY_PATTERNS;
+var REVIEW_KEYWORDS, REREVIEW_KEYWORDS, PR_NUMBER_PATTERNS, PR_HEAD_CACHE_REVALIDATE_MS, SEVERITY_PATTERNS, CATEGORY_PATTERNS;
 var init_review = __esm({
   "src/engine/review.ts"() {
     "use strict";
@@ -425,6 +551,7 @@ var init_review = __esm({
       /pull\/(\d+)/,
       /review[-_ ]?(\d+)/i
     ];
+    PR_HEAD_CACHE_REVALIDATE_MS = 3e4;
     SEVERITY_PATTERNS = {
       critical: /\bcritical\b/i,
       high: /\bhigh\b/i,
@@ -447,10 +574,37 @@ var init_review = __esm({
 // src/engine/headless-loop.ts
 var headless_loop_exports = {};
 __export(headless_loop_exports, {
-  createHeadlessLoop: () => createHeadlessLoop
+  createHeadlessLoop: () => createHeadlessLoop,
+  mergePendingRequests: () => mergePendingRequests,
+  sortRequests: () => sortRequests
 });
 import * as fs7 from "fs";
 import * as path6 from "path";
+function sortRequests(requests, consecutiveReReviews) {
+  const reReviewQuotaExhausted = consecutiveReReviews >= MAX_CONSECUTIVE_REREVIEWS;
+  return [...requests].sort((a, b) => {
+    if (a.isReReview !== b.isReReview) {
+      if (reReviewQuotaExhausted) {
+        return Number(a.isReReview) - Number(b.isReReview);
+      }
+      return Number(b.isReReview) - Number(a.isReReview);
+    }
+    if (a.requestTimestampMs !== b.requestTimestampMs) {
+      return b.requestTimestampMs - a.requestTimestampMs;
+    }
+    if (a.sourceMtimeMs !== b.sourceMtimeMs) {
+      return b.sourceMtimeMs - a.sourceMtimeMs;
+    }
+    return b.prNumber - a.prNumber;
+  });
+}
+function mergePendingRequests(queued, scanned, consecutiveReReviews) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const request of [...queued, ...scanned]) {
+    merged.set(computePendingRequestKey(request), request);
+  }
+  return sortRequests([...merged.values()], consecutiveReReviews);
+}
 function createHeadlessLoop(options) {
   const envConfig = getHeadlessEnvConfig();
   const terminationConfig = {
@@ -461,14 +615,143 @@ function createHeadlessLoop(options) {
   const state = {
     running: false,
     activeSession: null,
+    pendingRequests: [],
     completedSessions: 0,
     lastPollAt: null
   };
+  let sessionTimeouts = 0;
+  let roundTimeouts = 0;
+  let consecutiveReReviews = 0;
+  let lastCompletionAt = null;
+  const PROCESSED_MARKER_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+  const GC_INTERVAL_MS = 60 * 60 * 1e3;
+  let lastGcAt = 0;
   let timer = null;
+  const prHeadCache = /* @__PURE__ */ new Map();
+  let watcher = null;
+  let watchRestartTimer = null;
+  const WATCH_DEBOUNCE_MS = 150;
+  const WATCH_RESTART_MS = 2e3;
+  let lastWatchWakeMs = 0;
+  function startInboxWatcher() {
+    disposeInboxWatcher();
+    const inboxDir = path6.join(options.commsDir, "inbox");
+    if (!fs7.existsSync(inboxDir)) {
+      fs7.mkdirSync(inboxDir, { recursive: true });
+    }
+    try {
+      watcher = fs7.watch(inboxDir, (eventType, filename) => {
+        if (!filename || !filename.endsWith(".md")) return;
+        if (filename.includes("headless-dispatch-")) return;
+        const now = Date.now();
+        if (now - lastWatchWakeMs < WATCH_DEBOUNCE_MS) return;
+        lastWatchWakeMs = now;
+        log2(`fs.watch wake: ${eventType} ${filename}`);
+        pollOnce();
+      });
+      watcher.on("error", (error) => {
+        log2(
+          `fs.watch error: ${error instanceof Error ? error.message : String(error)}`
+        );
+        scheduleWatchRestart("error");
+      });
+      watcher.on("close", () => {
+        scheduleWatchRestart("close");
+      });
+      log2("fs.watch active on inbox");
+    } catch (error) {
+      log2(
+        `fs.watch start failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      scheduleWatchRestart("start-failed");
+    }
+  }
+  function disposeInboxWatcher() {
+    if (!watcher) return;
+    watcher.removeAllListeners();
+    try {
+      watcher.close();
+    } catch {
+    }
+    watcher = null;
+  }
+  function scheduleWatchRestart(reason) {
+    if (watchRestartTimer) return;
+    log2(`fs.watch restart scheduled (${reason})`);
+    watchRestartTimer = setTimeout(() => {
+      watchRestartTimer = null;
+      if (!state.running) return;
+      startInboxWatcher();
+    }, WATCH_RESTART_MS);
+    if (watchRestartTimer.unref) watchRestartTimer.unref();
+  }
   function log2(msg) {
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     console.error(`[${ts}] [headless-loop] ${msg}`);
   }
+  function dispatchSender() {
+    return "headless";
+  }
+  function dispatchSubject(prNumber, round) {
+    return round == null ? `headless-dispatch-pr${prNumber}` : `headless-dispatch-pr${prNumber}-r${round}`;
+  }
+  function dispatchFilename(prNumber, round) {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0].replace(/-/g, "");
+    return `${date}-${dispatchSender()}-${options.agentName}-${dispatchSubject(prNumber, round)}.md`;
+  }
+  function dispatchFileMatch(prNumber) {
+    return `-${dispatchSender()}-${options.agentName}-headless-dispatch-pr${prNumber}`;
+  }
+  function computeOldestPendingMs() {
+    if (state.pendingRequests.length === 0) return null;
+    const oldest = Math.min(
+      ...state.pendingRequests.map((r) => r.requestTimestampMs)
+    );
+    return Date.now() - oldest;
+  }
+  function computeActiveSessionAgeMs() {
+    if (!state.activeSession) return null;
+    return Date.now() - new Date(state.activeSession.startedAt).getTime();
+  }
+  function countProcessedMarkers() {
+    const markerDir = path6.join(options.stateDir, "processed");
+    if (!fs7.existsSync(markerDir)) return 0;
+    try {
+      return fs7.readdirSync(markerDir).filter((f) => f.endsWith(".done")).length;
+    } catch {
+      return 0;
+    }
+  }
+  function maybeGcProcessedMarkers() {
+    const now = Date.now();
+    if (now - lastGcAt < GC_INTERVAL_MS) return;
+    lastGcAt = now;
+    gcProcessedMarkers();
+  }
+  function gcProcessedMarkers() {
+    const markerDir = path6.join(options.stateDir, "processed");
+    if (!fs7.existsSync(markerDir)) return 0;
+    const now = Date.now();
+    let removed = 0;
+    try {
+      for (const file of fs7.readdirSync(markerDir)) {
+        if (!file.endsWith(".done")) continue;
+        const filePath = path6.join(markerDir, file);
+        try {
+          const age = now - fs7.statSync(filePath).mtimeMs;
+          if (age > PROCESSED_MARKER_MAX_AGE_MS) {
+            fs7.unlinkSync(filePath);
+            removed++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    if (removed > 0)
+      log2(`GC: removed ${removed} stale processed markers (>7d)`);
+    return removed;
+  }
   function writeStateFile() {
     try {
       const payload = {
@@ -478,6 +761,13 @@ function createHeadlessLoop(options) {
         pollIntervalMs: options.pollIntervalMs,
         completedSessions: state.completedSessions,
         lastPollAt: state.lastPollAt,
+        pendingReviewCount: state.pendingRequests.length,
+        pendingReviews: state.pendingRequests.map((request) => ({
+          prNumber: request.prNumber,
+          sender: request.sender,
+          isReReview: request.isReReview,
+          round: request.round
+        })),
         activeReview: state.activeSession ? {
           prNumber: state.activeSession.request.prNumber,
           round: state.activeSession.rounds.length + 1,
@@ -488,6 +778,16 @@ function createHeadlessLoop(options) {
           maxRounds: terminationConfig.maxRounds,
           qualitySeverityFloor: terminationConfig.qualitySeverityFloor
         },
+        // M326: Operational metrics for queue health monitoring
+        metrics: {
+          oldestPendingMs: computeOldestPendingMs(),
+          activeSessionAgeMs: computeActiveSessionAgeMs(),
+          lastCompletionAt,
+          sessionTimeouts,
+          roundTimeouts,
+          consecutiveReReviews,
+          processedMarkerCount: countProcessedMarkers()
+        },
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       const filePath = path6.join(options.stateDir, "headless-state.json");
@@ -497,25 +797,55 @@ function createHeadlessLoop(options) {
     } catch {
     }
   }
+  function requestStillEligible(request) {
+    if (!fs7.existsSync(request.sourcePath)) return false;
+    const bypassProcessedCheck = request.isReReview && state.activeSession?.request.prNumber === request.prNumber;
+    if (!bypassProcessedCheck && isAlreadyProcessed(options.stateDir, request))
+      return false;
+    const bypassStaleCheck = request.isReReview && state.activeSession?.request.prNumber === request.prNumber;
+    if (!bypassStaleCheck && isStaleReviewRequest(request, options.repoRoot, options.agentName))
+      return false;
+    return true;
+  }
+  function refreshPendingQueue() {
+    const queued = state.pendingRequests.filter(requestStillEligible);
+    const scanned = scanInboxForReviews(
+      options.commsDir,
+      options.stateDir,
+      options.repoRoot,
+      options.generation,
+      options.agentName,
+      options.agentId,
+      state.activeSession?.request.prNumber ?? null,
+      prHeadCache
+    );
+    state.pendingRequests = mergePendingRequests(
+      queued,
+      scanned,
+      consecutiveReReviews
+    );
+  }
   function pollOnce() {
+    if (!state.running) return;
     state.lastPollAt = (/* @__PURE__ */ new Date()).toISOString();
+    maybeGcProcessedMarkers();
+    refreshPendingQueue();
     if (state.activeSession) {
       checkActiveSession();
+      if (state.activeSession) {
+        writeStateFile();
+        return;
+      }
+    }
+    if (state.pendingRequests.length === 0) {
       writeStateFile();
       return;
     }
-    const requests = scanInboxForReviews(
-      options.commsDir,
-      options.stateDir,
-      options.generation,
-      options.agentName,
-      options.agentId
-    );
-    if (requests.length === 0) {
+    const request = state.pendingRequests.shift();
+    if (!request) {
       writeStateFile();
       return;
     }
-    const request = requests[0];
     startReviewSession(request);
     writeStateFile();
   }
@@ -525,11 +855,12 @@ function createHeadlessLoop(options) {
     try {
       writeReviewReceipt(options.commsDir, request, options.agentName);
       const prompt = buildReviewPrompt(request, options.agentName, 1);
-      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0].replace(/-/g, "");
-      const dispatchFilename = `${date}-headless-${options.agentName}-review-PR${request.prNumber}.md`;
       const inboxDir = path6.join(options.commsDir, "inbox");
       fs7.mkdirSync(inboxDir, { recursive: true });
-      const dispatchFile = path6.join(inboxDir, dispatchFilename);
+      const dispatchFile = path6.join(
+        inboxDir,
+        dispatchFilename(request.prNumber)
+      );
       const tmp = `${dispatchFile}.tmp.${process.pid}`;
       fs7.writeFileSync(tmp, prompt, "utf-8");
       fs7.renameSync(tmp, dispatchFile);
@@ -540,7 +871,7 @@ function createHeadlessLoop(options) {
         rounds: [],
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         reviewFilePath: reviewFilePath(
-          options.commsDir,
+          options.repoRoot,
           request.generation,
           request.prNumber,
           options.agentName
@@ -600,6 +931,7 @@ function createHeadlessLoop(options) {
       log2(
         `PR #${session.request.prNumber} timed out \u2014 no output after ${Math.round(elapsed / 6e4)}min. Releasing session.`
       );
+      sessionTimeouts++;
       state.activeSession = null;
       return;
     }
@@ -612,6 +944,7 @@ function createHeadlessLoop(options) {
         log2(
           `PR #${session.request.prNumber} round timeout \u2014 no new output after ${Math.round((Date.now() - lastRoundTime) / 6e4)}min. Completing session.`
         );
+        roundTimeouts++;
         completeSession(session);
         return;
       }
@@ -619,20 +952,27 @@ function createHeadlessLoop(options) {
   }
   function dispatchFollowUp(session, round) {
     const prompt = buildReviewPrompt(session.request, options.agentName, round);
-    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0].replace(/-/g, "");
-    const dispatchFilename = `${date}-headless-${options.agentName}-review-PR${session.request.prNumber}-r${round}.md`;
     const inboxDir = path6.join(options.commsDir, "inbox");
     fs7.mkdirSync(inboxDir, { recursive: true });
-    const dispatchFile = path6.join(inboxDir, dispatchFilename);
+    const dispatchFile = path6.join(
+      inboxDir,
+      dispatchFilename(session.request.prNumber, round)
+    );
     const tmp = `${dispatchFile}.tmp.${process.pid}`;
     fs7.writeFileSync(tmp, prompt, "utf-8");
     fs7.renameSync(tmp, dispatchFile);
   }
   function completeSession(session) {
     session.terminatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    lastCompletionAt = session.terminatedAt;
+    if (session.request.isReReview) {
+      consecutiveReReviews++;
+    } else {
+      consecutiveReReviews = 0;
+    }
     const inboxDir = path6.join(options.commsDir, "inbox");
     if (fs7.existsSync(inboxDir)) {
-      const prefix = `headless-${options.agentName}-review-PR${session.request.prNumber}`;
+      const prefix = dispatchFileMatch(session.request.prNumber);
       const files = fs7.readdirSync(inboxDir).filter((f) => f.includes(prefix));
       for (const f of files) {
         fs7.unlinkSync(path6.join(inboxDir, f));
@@ -654,8 +994,11 @@ function createHeadlessLoop(options) {
       log2(
         `Headless review loop started (${envConfig?.role ?? "reviewer"}, poll ${options.pollIntervalMs}ms, max ${terminationConfig.maxRounds} rounds)`
       );
+      gcProcessedMarkers();
+      lastGcAt = Date.now();
       writeStateFile();
       pollOnce();
+      startInboxWatcher();
       timer = setInterval(pollOnce, options.pollIntervalMs);
     },
     stop() {
@@ -664,6 +1007,11 @@ function createHeadlessLoop(options) {
         clearInterval(timer);
         timer = null;
       }
+      disposeInboxWatcher();
+      if (watchRestartTimer) {
+        clearTimeout(watchRestartTimer);
+        watchRestartTimer = null;
+      }
       writeStateFile();
       log2("Headless review loop stopped");
     },
@@ -672,11 +1020,13 @@ function createHeadlessLoop(options) {
     }
   };
 }
+var MAX_CONSECUTIVE_REREVIEWS;
 var init_headless_loop = __esm({
   "src/engine/headless-loop.ts"() {
     "use strict";
     init_review();
     init_termination();
+    MAX_CONSECUTIVE_REREVIEWS = 3;
   }
 });
 
@@ -693,6 +1043,19 @@ import * as path2 from "path";
 // src/utils.ts
 import * as fs from "fs";
 import * as path from "path";
+function normalizeTapPath(input, platform = process.platform) {
+  const trimmed = input.trim().replace(/^["'`]+|["'`]+$/g, "");
+  if (/^[A-Za-z]:[\\/]/.test(trimmed)) {
+    return trimmed;
+  }
+  if (platform === "win32") {
+    const match = trimmed.match(/^\/([A-Za-z])\/(.*)$/);
+    if (match) {
+      return `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
+    }
+  }
+  return trimmed;
+}
 var _noGitWarned = false;
 function _setNoGitWarned() {
   _noGitWarned = true;
@@ -775,7 +1138,9 @@ function resolveConfig(overrides = {}, startDir) {
     stateDir: "auto",
     runtimeCommand: "auto",
     appServerUrl: "auto",
-    towerName: "auto"
+    towerName: "auto",
+    remoteAgents: "auto",
+    portMap: "auto"
   };
   let commsDir;
   if (overrides.commsDir) {
@@ -845,6 +1210,19 @@ function resolveConfig(overrides = {}, startDir) {
     appServerUrl = DEFAULT_APP_SERVER_URL;
   }
   const towerName = local.towerName ?? shared.towerName ?? null;
+  const remoteAgents = [
+    ...shared.remoteAgents ?? [],
+    ...local.remoteAgents ?? []
+  ];
+  const portMap = {};
+  if (shared.portMap) {
+    Object.assign(portMap, shared.portMap);
+    sources.portMap = "shared-config";
+  }
+  if (local.portMap) {
+    Object.assign(portMap, local.portMap);
+    sources.portMap = "local-config";
+  }
   return {
     config: {
       repoRoot,
@@ -852,7 +1230,9 @@ function resolveConfig(overrides = {}, startDir) {
       stateDir,
       runtimeCommand,
       appServerUrl,
-      towerName
+      towerName,
+      remoteAgents,
+      portMap
     },
     sources
   };
@@ -861,19 +1241,6 @@ function resolvePath(repoRoot, p) {
   const normalized = normalizeTapPath(p);
   return path2.isAbsolute(normalized) ? normalized : path2.resolve(repoRoot, normalized);
 }
-function normalizeTapPath(input) {
-  const trimmed = input.trim().replace(/^["'`]+|["'`]+$/g, "");
-  if (/^[A-Za-z]:[\\/]/.test(trimmed)) {
-    return trimmed;
-  }
-  if (process.platform === "win32") {
-    const match = trimmed.match(/^\/([A-Za-z])\/(.*)$/);
-    if (match) {
-      return `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
-    }
-  }
-  return trimmed;
-}
 
 // src/runtime/resolve-node.ts
 import * as fs3 from "fs";
@@ -1053,12 +1420,21 @@ function resolveAppServerUrl(baseUrl, port) {
 }
 
 // src/bridges/codex-bridge-runner.ts
-function findRepoRootFromRunner() {
-  let dir = path7.resolve(path7.dirname(fileURLToPath(import.meta.url)));
+function resolveRepoRootHintFromRunner(runnerUrl = import.meta.url, env = process.env, fileExists = fs8.existsSync) {
+  const envRepoRoot = env.TAP_REPO_ROOT?.trim();
+  if (envRepoRoot) {
+    return path7.resolve(envRepoRoot);
+  }
+  let dir = path7.resolve(path7.dirname(fileURLToPath(runnerUrl)));
   while (true) {
-    if (fs8.existsSync(path7.join(dir, SHARED_CONFIG_FILE))) return dir;
-    if (fs8.existsSync(path7.join(dir, LOCAL_CONFIG_FILE))) return dir;
-    if (fs8.existsSync(path7.join(dir, "scripts", "codex-app-server-bridge.ts")))
+    if (fileExists(path7.join(dir, SHARED_CONFIG_FILE))) return dir;
+    if (fileExists(path7.join(dir, LOCAL_CONFIG_FILE))) return dir;
+    if (fileExists(
+      path7.join(dir, "scripts", "codex", "codex-app-server-bridge.ts")
+    )) {
+      return dir;
+    }
+    if (fileExists(path7.join(dir, "scripts", "codex-app-server-bridge.ts")))
       return dir;
     const parent = path7.dirname(dir);
     if (parent === dir) return null;
@@ -1070,7 +1446,7 @@ function maybeStartHeadlessLoop(repoRoot, commsDir, stateDir) {
   Promise.resolve().then(() => (init_headless_loop(), headless_loop_exports)).then(({ createHeadlessLoop: createHeadlessLoop2 }) => {
     const agentName = process.env.TAP_AGENT_NAME ?? process.env.CODEX_TAP_AGENT_NAME ?? "reviewer";
     const agentId = process.env.TAP_AGENT_ID ?? process.env.TAP_BRIDGE_INSTANCE_ID ?? agentName;
-    const generation = process.env.TAP_REVIEW_GENERATION ?? "gen11";
+    const generation = resolveHeadlessReviewGeneration(repoRoot, commsDir);
     const resolvedStateDir = stateDir ?? path7.join(repoRoot, ".tap-comms");
     const loop = createHeadlessLoop2({
       commsDir,
@@ -1089,6 +1465,45 @@ function maybeStartHeadlessLoop(repoRoot, commsDir, stateDir) {
     console.error("[headless-loop] Failed to start:", err);
   });
 }
+function resolveHeadlessReviewGeneration(repoRoot, commsDir, env = process.env) {
+  const explicit = env.TAP_REVIEW_GENERATION?.trim();
+  if (explicit) return explicit;
+  const envGeneration = normalizeGenerationValue(env.TAP_GENERATION);
+  if (envGeneration) return envGeneration;
+  try {
+    const reviewsDir = path7.join(repoRoot, "reviews");
+    const generations = readGenerationNumbers(reviewsDir);
+    if (generations.length > 0) {
+      return `gen${generations[0]}`;
+    }
+  } catch {
+  }
+  const resolvedCommsDir = commsDir?.trim() || env.TAP_COMMS_DIR?.trim() || null;
+  if (resolvedCommsDir) {
+    const commsGenerations = [
+      ...readGenerationNumbers(path7.join(resolvedCommsDir, "retros")),
+      ...readGenerationNumbers(path7.join(resolvedCommsDir, "letters"))
+    ].sort((a, b) => b - a);
+    if (commsGenerations.length > 0) {
+      return `gen${commsGenerations[0]}`;
+    }
+  }
+  return "gen1";
+}
+function normalizeGenerationValue(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(/^gen(\d+)$/i) ?? trimmed.match(/^(\d+)$/);
+  if (!match?.[1]) return null;
+  return `gen${Number.parseInt(match[1], 10)}`;
+}
+function readGenerationNumbers(dir) {
+  try {
+    return fs8.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => normalizeGenerationValue(entry.name)).filter((value) => Boolean(value)).map((value) => Number.parseInt(value.slice(3), 10)).filter(Number.isFinite).sort((a, b) => b - a);
+  } catch {
+    return [];
+  }
+}
 function resolveBridgeDaemonScript(repoRoot, runnerUrl = import.meta.url, fileExists = fs8.existsSync) {
   const moduleDir = path7.dirname(fileURLToPath(runnerUrl));
   const candidates = [
@@ -1114,7 +1529,9 @@ function resolveBridgeDaemonScript(repoRoot, runnerUrl = import.meta.url, fileEx
       "bridges",
       "codex-app-server-bridge.ts"
     ),
-    // 5. Legacy monorepo root script
+    // 5. Monorepo scripts/codex/ subfolder
+    path7.join(repoRoot, "scripts", "codex", "codex-app-server-bridge.ts"),
+    // 6. Legacy monorepo root script (pre-cleanup)
     path7.join(repoRoot, "scripts", "codex-app-server-bridge.ts")
   ];
   for (const candidate of candidates) {
@@ -1148,8 +1565,37 @@ function buildBridgeDaemonEnv(parentEnv, runtimeEnv) {
     ...runtimeEnv
   };
 }
+function normalizeRoutingSlot(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return null;
+  if (normalized === "tower") return "tower";
+  if (normalized === "reviewer") return "reviewer";
+  const worktreeMatch = normalized.match(/^wt[-_]?(\d+)$/);
+  if (worktreeMatch) {
+    return `wt-${Number.parseInt(worktreeMatch[1], 10)}`;
+  }
+  return null;
+}
+function resolveBridgeRoutingSlot(repoRoot, env = process.env) {
+  const explicit = normalizeRoutingSlot(env.TAP_ROUTING_SLOT);
+  if (explicit) return explicit;
+  const instanceId = env.TAP_INSTANCE_ID?.trim() || env.TAP_BRIDGE_INSTANCE_ID?.trim() || "";
+  const normalizedInstance = instanceId.toLowerCase().replace(/_/g, "-");
+  if (normalizedInstance === "tower" || normalizedInstance === "claude-main" || normalizedInstance === "codex-main") {
+    return "tower";
+  }
+  if (normalizedInstance === "reviewer" || normalizedInstance === "claude-reviewer" || normalizedInstance === "codex-reviewer") {
+    return "reviewer";
+  }
+  if (/^(?:(?:claude|codex)-)?wt-?(\d+)$/.test(normalizedInstance)) {
+    return normalizeRoutingSlot(
+      normalizedInstance.replace(/^(?:claude|codex)-/, "")
+    );
+  }
+  return normalizeRoutingSlot(path7.basename(repoRoot));
+}
 async function main() {
-  const repoRootHint = findRepoRootFromRunner() ?? void 0;
+  const repoRootHint = resolveRepoRootHintFromRunner() ?? void 0;
   const { config } = resolveConfig({}, repoRootHint);
   const repoRoot = config.repoRoot;
   const commsDir = config.commsDir;
@@ -1224,6 +1670,10 @@ Expected a packaged dist/bridges/codex-app-server-bridge.mjs or monorepo bridge
     args.push("--process-existing-messages");
   const runtimeEnv = buildRuntimeEnv(repoRoot);
   const daemonEnv = buildBridgeDaemonEnv(process.env, runtimeEnv);
+  const routingSlot = resolveBridgeRoutingSlot(repoRoot, daemonEnv);
+  if (routingSlot && !daemonEnv.TAP_ROUTING_SLOT) {
+    daemonEnv.TAP_ROUTING_SLOT = routingSlot;
+  }
   const child = spawn(command, args, {
     cwd: repoRoot,
     env: daemonEnv,
@@ -1245,6 +1695,7 @@ Expected a packaged dist/bridges/codex-app-server-bridge.mjs or monorepo bridge
 function isDirectExecution() {
   const entry = process.argv[1];
   if (!entry) return false;
+  if (!path7.basename(entry).startsWith("codex-bridge-runner")) return false;
   return import.meta.url === pathToFileURL(path7.resolve(entry)).href;
 }
 if (isDirectExecution()) {
@@ -1256,6 +1707,9 @@ if (isDirectExecution()) {
 export {
   buildBridgeDaemonEnv,
   buildBridgeScriptArgs,
-  resolveBridgeDaemonScript
+  resolveBridgeDaemonScript,
+  resolveBridgeRoutingSlot,
+  resolveHeadlessReviewGeneration,
+  resolveRepoRootHintFromRunner
 };
 //# sourceMappingURL=codex-bridge-runner.mjs.map