@pepps233/mendr 0.1.0

package/dist/daemon.js

@@ -0,0 +1,1060 @@
+import {
+  allowedEffortsForAgent,
+  appendEvent,
+  appendFixAttempt,
+  appendIssueRecord,
+  commitStaged,
+  createAgentDriver,
+  dedupeIssues,
+  defaultEffortForAgent,
+  defaultExec,
+  defaultMendrHome,
+  defaultModelForAgent,
+  ensureMergeableWithRef,
+  fetchPullRequestDetails,
+  fetchPullRequestDiff,
+  fetchPullRequestReadinessRefs,
+  fetchRemoteBranch,
+  getHeadCommitSha,
+  getPorcelainStatus,
+  isEffortForAgent,
+  issueFingerprint,
+  postPullRequestComment,
+  pushHeadToBranch,
+  readMeta,
+  readState,
+  renderReviewMarkdown,
+  resetWorktreeToCommit,
+  reviewDir,
+  stageAll,
+  waitForPullRequestChecks,
+  writeState
+} from "./chunk-EGSZLVR6.js";
+
+// src/orchestrator.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { setTimeout as delay } from "timers/promises";
+
+// src/report.ts
+import { Buffer } from "buffer";
+var REPORT_HEADING = "## Summary by Mendr";
+var LEGACY_REPORT_HEADING = "## Summary";
+var RESOLVED_ISSUES_HEADING = "### Resolved Issues";
+var UNRESOLVED_ISSUES_HEADING = "### Unresolved Issues";
+var ROUND_CAP_HEADING = "### Round Cap";
+var ISSUE_FINGERPRINT_PREFIX = "<!-- mendr-issue-fingerprint: ";
+var ISSUE_FINGERPRINT_SUFFIX = " -->";
+function appendResolvedIssue(report, entry) {
+  const original = ensureSummary(report);
+  let normalized = removeUnresolvedIssue(original, entry.issue);
+  const issueLine = `#### ${entry.issue.title}`;
+  const fingerprintLine = issueFingerprintLine(entry.issue);
+  const shaLine = `**Commit:** ${entry.sha}`;
+  const legacyBacktickedShaLine = `**Commit:** \`${entry.sha}\``;
+  const legacyIssueLine = `- Issue: ${entry.issue.title}`;
+  const legacyShaLine = `- Resolved by: ${entry.sha}`;
+  if (hasResolvedIssueEntry(normalized, entry) || normalized.includes(`${issueLine}
+${shaLine}`) || normalized.includes(`${issueLine}
+${legacyBacktickedShaLine}`) || normalized.includes(`${legacyIssueLine}
+${legacyShaLine}`)) {
+    return normalized === original ? report : normalized;
+  }
+  normalized = ensureSection(normalized, RESOLVED_ISSUES_HEADING);
+  return appendBlock(normalized, [issueLine, fingerprintLine, shaLine, entry.summary]);
+}
+function appendIssueResult(report, entry) {
+  return appendResolvedIssue(report, entry);
+}
+function appendUnresolvedIssue(report, entry) {
+  let normalized = ensureSummary(report);
+  const issueLine = `#### ${entry.issue.title}`;
+  const fingerprintLine = issueFingerprintLine(entry.issue);
+  if (hasResolvedIssue(normalized, entry.issue) || hasUnresolvedIssue(normalized, entry.issue)) {
+    return report;
+  }
+  normalized = ensureSection(normalized, UNRESOLVED_ISSUES_HEADING);
+  return appendBlock(normalized, [issueLine, fingerprintLine, entry.summary]);
+}
+function appendNoIssuesFound(report) {
+  const normalized = ensureSummary(report);
+  const line = "- No changed-scope issues found.";
+  if (normalized.includes(line)) {
+    return report;
+  }
+  return appendBlock(normalized, [line]);
+}
+function appendFailureNote(report, message) {
+  const normalized = ensureSummary(report);
+  const line = `- Failure: ${message}`;
+  if (normalized.includes(line)) {
+    return report;
+  }
+  return appendBlock(normalized, [line]);
+}
+function appendRoundCapNote(report, note) {
+  let normalized = ensureSummary(report);
+  const round = note.maxRounds === 1 ? "round" : "rounds";
+  const issue = note.openIssues.length === 1 ? "issue" : "issues";
+  const capLine = `Reached after ${note.maxRounds} ${round} with ${note.openIssues.length} open ${issue}:`;
+  const legacyCapLine = `- Round cap reached after ${note.maxRounds} ${round} with ${note.openIssues.length} open ${issue}.`;
+  const openIssueLines = note.openIssues.map((openIssue) => `- ${openIssue.title}`);
+  if (normalized.includes(capLine) || normalized.includes(legacyCapLine)) {
+    return report;
+  }
+  normalized = ensureSection(normalized, ROUND_CAP_HEADING);
+  return appendBlock(normalized, [capLine, ...openIssueLines]);
+}
+function ensureSummary(report) {
+  const trimmed = report.trim();
+  if (trimmed.length === 0) {
+    return `${REPORT_HEADING}
+`;
+  }
+  if (hasLine(trimmed, REPORT_HEADING)) {
+    return `${trimmed}
+`;
+  }
+  if (hasLine(trimmed, LEGACY_REPORT_HEADING)) {
+    return `${trimmed.replace(/^## Summary$/m, REPORT_HEADING)}
+`;
+  }
+  return `${REPORT_HEADING}
+${trimmed}
+`;
+}
+function ensureSection(report, sectionHeading) {
+  if (hasLine(report, sectionHeading)) {
+    return report;
+  }
+  return appendBlock(report, [sectionHeading]);
+}
+function appendBlock(report, lines) {
+  const base = report.trimEnd();
+  const separator = base.length === 0 ? "" : "\n\n";
+  return `${base}${separator}${lines.join("\n")}
+`;
+}
+function hasResolvedIssue(report, issue) {
+  return hasIssueBlock(report, RESOLVED_ISSUES_HEADING, issue);
+}
+function hasResolvedIssueEntry(report, entry) {
+  const shaLine = `**Commit:** ${entry.sha}`;
+  const legacyBacktickedShaLine = `**Commit:** \`${entry.sha}\``;
+  return readHeadingBlocks(report, RESOLVED_ISSUES_HEADING).some((block) => {
+    const blockText = block.join("\n");
+    return hasIssueFingerprint(block, entry.issue) && (hasLine(blockText, shaLine) || hasLine(blockText, legacyBacktickedShaLine));
+  });
+}
+function hasUnresolvedIssue(report, issue) {
+  return hasIssueBlock(report, UNRESOLVED_ISSUES_HEADING, issue);
+}
+function hasIssueBlock(report, sectionHeading, issue) {
+  return readHeadingBlocks(report, sectionHeading).some(
+    (block) => hasIssueFingerprint(block, issue)
+  );
+}
+function hasIssueFingerprint(block, issue) {
+  return hasLine(block.join("\n"), issueFingerprintLine(issue));
+}
+function removeUnresolvedIssue(report, issue) {
+  return removeHeadingBlocks(
+    report,
+    UNRESOLVED_ISSUES_HEADING,
+    (block) => hasIssueFingerprint(block, issue)
+  );
+}
+function removeHeadingBlocks(report, sectionHeading, shouldRemoveBlock) {
+  const lines = report.split("\n");
+  const sectionIndex = lines.findIndex((line) => line === sectionHeading);
+  if (sectionIndex === -1) {
+    return report;
+  }
+  const ranges = [];
+  let index = sectionIndex + 1;
+  while (index < lines.length && !isSectionHeading(lines[index])) {
+    if (!isIssueHeading(lines[index])) {
+      index += 1;
+      continue;
+    }
+    const blockStart = index;
+    const blockEnd = findHeadingBlockEnd(lines, blockStart);
+    if (shouldRemoveBlock(lines.slice(blockStart, blockEnd))) {
+      ranges.push({ start: blockStart, end: blockEnd });
+    }
+    index = blockEnd;
+  }
+  if (ranges.length === 0) {
+    return report;
+  }
+  const next = [...lines];
+  for (const range of ranges.reverse()) {
+    next.splice(range.start, range.end - range.start);
+  }
+  return removeEmptySection(`${next.join("\n").trimEnd()}
+`, sectionHeading);
+}
+function removeEmptySection(report, sectionHeading) {
+  const lines = report.split("\n");
+  const sectionIndex = lines.findIndex((line) => line === sectionHeading);
+  const nextSectionIndex = lines.findIndex(
+    (line, index) => index > sectionIndex && isSectionHeading(line)
+  );
+  const endIndex = nextSectionIndex === -1 ? lines.length : nextSectionIndex;
+  const hasBlock = lines.slice(sectionIndex + 1, endIndex).some((line) => isIssueHeading(line));
+  if (hasBlock) {
+    return report;
+  }
+  return `${[...lines.slice(0, sectionIndex), ...lines.slice(endIndex)].join("\n").trimEnd()}
+`;
+}
+function readHeadingBlocks(report, sectionHeading) {
+  const lines = report.split("\n");
+  const sectionIndex = lines.findIndex((line) => line === sectionHeading);
+  if (sectionIndex === -1) {
+    return [];
+  }
+  const blocks = [];
+  let index = sectionIndex + 1;
+  while (index < lines.length && !isSectionHeading(lines[index])) {
+    if (!isIssueHeading(lines[index])) {
+      index += 1;
+      continue;
+    }
+    const blockStart = index;
+    const blockEnd = findHeadingBlockEnd(lines, blockStart);
+    blocks.push(lines.slice(blockStart, blockEnd));
+    index = blockEnd;
+  }
+  return blocks;
+}
+function issueFingerprintLine(issue) {
+  const encodedFingerprint = encodeIssueFingerprint(issueFingerprint(issue));
+  return `${ISSUE_FINGERPRINT_PREFIX}${encodedFingerprint}${ISSUE_FINGERPRINT_SUFFIX}`;
+}
+function encodeIssueFingerprint(fingerprint) {
+  return Buffer.from(fingerprint, "utf8").toString("base64url");
+}
+function isSectionHeading(line) {
+  return /^### /.test(line);
+}
+function isIssueHeading(line) {
+  return /^#### /.test(line);
+}
+function findHeadingBlockEnd(lines, blockStart) {
+  for (let index = blockStart + 1; index < lines.length; index += 1) {
+    if (isHeading(lines[index])) {
+      return index;
+    }
+  }
+  return lines.length;
+}
+function isHeading(line) {
+  return /^#{1,4} /.test(line);
+}
+function hasLine(text, line) {
+  const escaped = line.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped}$`, "m").test(text);
+}
+
+// src/orchestrator.ts
+var PullRequestHeadChangedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PullRequestHeadChangedError";
+  }
+};
+var PR_HEAD_PROPAGATION_TIMEOUT_MS = 3e4;
+var PR_HEAD_PROPAGATION_POLL_MS = 2e3;
+async function runOrchestrator(options) {
+  const exec = options.exec ?? defaultExec;
+  const dir = reviewDir(options.mendrHome, options.reviewId);
+  const reviewPath = join(dir, "review.md");
+  const reportPath = join(dir, "report.md");
+  let state = {
+    phase: "starting",
+    currentStatus: "Starting",
+    issuesFound: 0,
+    issuesFixed: 0,
+    done: false,
+    capReached: false
+  };
+  try {
+    await mkdir(dir, { recursive: true });
+    await writeState(options.mendrHome, options.reviewId, state);
+    const meta = await readMeta(options.mendrHome, options.reviewId);
+    const agent = parseAgentName(meta.agent);
+    const model = meta.model ?? defaultModelForAgent(agent);
+    const effort = resolveEffort(agent, meta.effort);
+    const sessionRepo = meta.worktreePath ?? meta.repo;
+    const agentDriver = options.agentDriver ?? createAgentDriver({
+      agent,
+      exec,
+      outputDir: join(dir, "agent-io")
+    });
+    const details = await fetchPullRequestDetails(exec, sessionRepo, meta.pr);
+    await writeFile(reviewPath, renderReviewMarkdown(meta.pr, details), "utf8");
+    let report = await readReport(reportPath);
+    let openIssues = [];
+    const attemptedIssueFingerprints = /* @__PURE__ */ new Set();
+    for (let round = 1; round <= meta.maxRounds; round += 1) {
+      state = await updateStatus(options, state, {
+        phase: "reviewing",
+        currentStatus: "Discovering bugs"
+      });
+      await appendEvent(options.mendrHome, options.reviewId, {
+        status: "Discovering bugs",
+        detail: `review round ${round}`
+      });
+      const diff = await fetchPullRequestDiff(exec, sessionRepo, meta.pr);
+      const reviewMarkdown = await readFile(reviewPath, "utf8");
+      const ctx = buildContext({
+        repo: sessionRepo,
+        pr: meta.pr,
+        model,
+        effort,
+        diff,
+        reviewMarkdown,
+        reportMarkdown: report
+      });
+      let issues = [];
+      try {
+        issues = dedupeIssues(await agentDriver.review(ctx));
+      } catch (error) {
+        await fail(options, state, "Review failed", error);
+        return;
+      }
+      await persistIssueRecords(options, round, issues);
+      state = await updateStatus(options, state, {
+        issuesFound: state.issuesFound + issues.length
+      });
+      if (issues.length === 0) {
+        if (report.trim().length === 0) {
+          report = appendNoIssuesFound(report);
+          await writeFile(reportPath, report, "utf8");
+        }
+        openIssues = [];
+        break;
+      }
+      openIssues = issues;
+      const issueAttempts = issues.map((issue, index) => ({
+        issue,
+        round,
+        issueIndex: index + 1
+      }));
+      const newIssues = issueAttempts.filter(
+        (attempt) => !attemptedIssueFingerprints.has(issueFingerprint(attempt.issue))
+      );
+      const repeatedIssues = issueAttempts.filter(
+        (attempt) => attemptedIssueFingerprints.has(issueFingerprint(attempt.issue))
+      );
+      state = await updateStatus(options, state, {
+        phase: "fixing",
+        currentStatus: "Resolving issues"
+      });
+      await appendEvent(options.mendrHome, options.reviewId, {
+        status: "Resolving issues",
+        detail: newIssues.length > 0 ? `fix round ${round} with ${newIssues.length} new issues` : `fix round ${round} skipped because all ${issues.length} issues were already attempted`
+      });
+      for (const { issue } of repeatedIssues) {
+        await appendEvent(options.mendrHome, options.reviewId, {
+          status: "Issue still open",
+          detail: `${issue.title} was already sent to the fixer in an earlier round`
+        });
+      }
+      if (newIssues.length > 0) {
+        for (const { issue } of newIssues) {
+          attemptedIssueFingerprints.add(issueFingerprint(issue));
+        }
+        const outcome = await runFixRound({
+          options,
+          exec,
+          agentDriver,
+          ctx: {
+            ...ctx,
+            reportMarkdown: report
+          },
+          issues: newIssues,
+          report,
+          reportPath,
+          branch: meta.branch,
+          branchPushRemote: normalizeBranchPushRemote(meta.branchPushRemote),
+          state,
+          setState: (nextState) => {
+            state = nextState;
+          }
+        });
+        report = outcome.report;
+        state = outcome.state;
+      }
+      if (round === meta.maxRounds) {
+        report = appendRoundCapNote(report, {
+          maxRounds: meta.maxRounds,
+          openIssues
+        });
+        await writeFile(reportPath, report, "utf8");
+        state = await updateStatus(options, state, {
+          capReached: true
+        });
+      }
+    }
+    if (openIssues.length === 0) {
+      state = await updateStatus(options, state, {
+        capReached: false
+      });
+    }
+    const validationResult = await validatePullRequestReadyForSummary(
+      options,
+      exec,
+      sessionRepo,
+      meta.pr,
+      state
+    );
+    state = validationResult.state;
+    if (validationResult.failure) {
+      report = appendValidationFailureNote(report, validationResult.failure);
+      await writeFile(reportPath, report, "utf8");
+    }
+    state = await postReportWithRetry(options, exec, sessionRepo, meta.pr, reportPath, state);
+    if (validationResult.failure) {
+      await fail(
+        options,
+        state,
+        validationResult.failure.status,
+        validationResult.failure.error
+      );
+    }
+    await updateStatus(options, state, {
+      phase: "complete",
+      currentStatus: "Complete",
+      done: true
+    });
+    await appendEvent(options.mendrHome, options.reviewId, {
+      status: "Complete",
+      detail: "done"
+    });
+  } catch (error) {
+    if (isAlreadyRecordedFailure(state, error)) {
+      throw error;
+    }
+    await fail(options, state, "Orchestrator failed", error);
+  }
+}
+async function runFixRound(input) {
+  let report = input.report;
+  let fixedCount = 0;
+  let lastSuccessfulSha = await getHeadCommitSha(input.exec, input.ctx.repo);
+  let state = input.state;
+  for (const attempt of input.issues) {
+    const outcome = await runSingleIssueFix({
+      ...input,
+      ctx: {
+        ...input.ctx,
+        reportMarkdown: report
+      },
+      attempt,
+      lastSuccessfulSha,
+      state
+    });
+    if (outcome.status === "fixed" && outcome.sha) {
+      report = appendIssueResult(report, {
+        issue: attempt.issue,
+        sha: outcome.sha,
+        summary: outcome.summary
+      });
+    } else {
+      report = appendUnresolvedIssue(report, {
+        issue: attempt.issue,
+        summary: outcome.summary
+      });
+    }
+    await appendFixAttempt(input.options.mendrHome, input.options.reviewId, {
+      sessionId: input.options.reviewId,
+      round: attempt.round,
+      issueIndex: attempt.issueIndex,
+      fingerprint: issueFingerprint(attempt.issue),
+      title: attempt.issue.title,
+      status: outcome.status,
+      summary: outcome.summary,
+      ...outcome.sha ? { commitSha: outcome.sha } : {}
+    });
+    await writeFile(input.reportPath, report, "utf8");
+    if (outcome.status === "fixed" && outcome.sha) {
+      fixedCount += 1;
+      lastSuccessfulSha = outcome.sha;
+      state = await updateStatus(input.options, state, {
+        issuesFixed: state.issuesFixed + 1
+      });
+      input.setState(state);
+    } else {
+      await appendEvent(input.options.mendrHome, input.options.reviewId, {
+        status: "Fix failed",
+        detail: `${attempt.issue.title}: ${outcome.summary}`
+      });
+    }
+  }
+  if (fixedCount > 0) {
+    try {
+      await pushWithRetry(input.exec, input.ctx.repo, input.branchPushRemote, input.branch);
+    } catch (error) {
+      const message = errorToMessage(error);
+      const failedReport = appendFailureNote(report, `push failed: ${message}`);
+      await writeFile(input.reportPath, failedReport, "utf8");
+      await fail(input.options, state, "Push failed", error);
+    }
+  }
+  return {
+    report,
+    fixedCount,
+    pushed: fixedCount > 0,
+    state
+  };
+}
+async function runSingleIssueFix(input) {
+  const { attempt } = input;
+  let rawResults;
+  try {
+    rawResults = await input.agentDriver.fix([attempt.issue], input.ctx);
+  } catch (error) {
+    await resetFailedIssue(input);
+    return {
+      status: "failed",
+      summary: fixerCrashedSummary(errorToMessage(error))
+    };
+  }
+  const movedHeadOutcome = await failIfFixerMovedHead(input);
+  if (movedHeadOutcome) {
+    return movedHeadOutcome;
+  }
+  const result = normalizeFixResults([attempt.issue], rawResults)[0];
+  if (result.status === "failed") {
+    await resetFailedIssue(input);
+    return {
+      status: "failed",
+      summary: result.summary
+    };
+  }
+  const commitMessage = validateCommitMessage(result.commitMessage);
+  if (!commitMessage.valid) {
+    await resetFailedIssue(input);
+    return {
+      status: "failed",
+      summary: invalidCommitMessageSummary(commitMessage.reason)
+    };
+  }
+  const status = await getPorcelainStatus(input.exec, input.ctx.repo);
+  if (status.length === 0) {
+    await resetFailedIssue(input);
+    return {
+      status: "failed",
+      summary: noDiffSummary()
+    };
+  }
+  try {
+    await stageAll(input.exec, input.ctx.repo);
+    const sha = await commitStaged(
+      input.exec,
+      input.ctx.repo,
+      commitMessage.message
+    );
+    return {
+      status: "fixed",
+      summary: result.summary,
+      sha
+    };
+  } catch (error) {
+    return fail(input.options, input.state, "Commit failed", error);
+  }
+}
+async function resetFailedIssue(input) {
+  try {
+    await resetWorktreeToCommit(input.exec, input.ctx.repo, input.lastSuccessfulSha);
+  } catch (error) {
+    await fail(input.options, input.state, "Worktree reset failed", error);
+  }
+}
+async function failIfFixerMovedHead(input) {
+  const currentHead = await getHeadCommitSha(input.exec, input.ctx.repo);
+  if (currentHead === input.lastSuccessfulSha) {
+    return void 0;
+  }
+  await resetFailedIssue(input);
+  return {
+    status: "failed",
+    summary: fixerMovedHeadSummary(input.lastSuccessfulSha, currentHead)
+  };
+}
+function fixerCrashedSummary(message) {
+  return `The fixer failed before returning structured results. ${message}`;
+}
+function fixerMovedHeadSummary(expectedSha, actualSha) {
+  return `The fixer moved HEAD from ${expectedSha} to ${actualSha} before returning. mendr reset the worktree so unrecorded fixer commits are not pushed.`;
+}
+function noDiffSummary() {
+  return "The fixer reported this issue as fixed, but did not leave any file changes to commit. Manual follow-up is required to determine whether the issue still needs a code change.";
+}
+function appendValidationFailureNote(report, failure) {
+  return appendFailureNote(report, `${failure.status}: ${errorToMessage(failure.error)}`);
+}
+function validateCommitMessage(message) {
+  const normalized = message?.replace(/\r\n?/g, "\n").trim();
+  if (!normalized) {
+    return {
+      valid: false,
+      reason: "the fixer did not provide a commit message"
+    };
+  }
+  if (normalized.includes("\0")) {
+    return {
+      valid: false,
+      reason: "commit messages must not contain NUL bytes"
+    };
+  }
+  const forbiddenReason = forbiddenCommitMessageReason(normalized);
+  if (forbiddenReason) {
+    return {
+      valid: false,
+      reason: forbiddenReason
+    };
+  }
+  const lines = normalized.split("\n");
+  if (lines.length !== 4) {
+    return {
+      valid: false,
+      reason: "commit messages must contain a subject, a blank line, and exactly two bullet lines"
+    };
+  }
+  if (lines[1] !== "") {
+    return {
+      valid: false,
+      reason: "commit messages must separate the subject from the body with a blank line"
+    };
+  }
+  const subject = parseCommitSubject(lines[0]);
+  if (!subject) {
+    return {
+      valid: false,
+      reason: "commit message subjects must match <type>(<scope>): <short imperative summary>"
+    };
+  }
+  if (subject.summary.endsWith(".")) {
+    return {
+      valid: false,
+      reason: "commit message summaries must not end with a period"
+    };
+  }
+  if (looksNonImperative(subject.summary)) {
+    return {
+      valid: false,
+      reason: "commit message summaries must be imperative"
+    };
+  }
+  if (!lines[2].startsWith("- ") || lines[2].trim() === "-") {
+    return {
+      valid: false,
+      reason: "commit message bodies must use a non-empty first bullet"
+    };
+  }
+  if (!lines[3].startsWith("- ") || lines[3].trim() === "-") {
+    return {
+      valid: false,
+      reason: "commit message bodies must use a non-empty second bullet"
+    };
+  }
+  return {
+    valid: true,
+    message: normalized
+  };
+}
+function invalidCommitMessageSummary(reason) {
+  return `The fixer reported this issue as fixed, but its commit message is invalid: ${reason}. Manual follow-up is required before Mendr can safely record and push the fix.`;
+}
+function forbiddenCommitMessageReason(message) {
+  const lines = message.split("\n");
+  if (lines.some((line) => /^co-authored-by\s*:/i.test(line.trim()))) {
+    return "commit messages must not include co-author lines";
+  }
+  if (/\b(?:ai|a\.i\.|openai|chatgpt|claude|anthropic|codex|providers?)\b/i.test(message)) {
+    return "commit messages must not include AI or provider references";
+  }
+  return void 0;
+}
+function parseCommitSubject(line) {
+  const match = /^([a-z][a-z0-9-]*)\(([a-z0-9._/-]+)\): ([A-Za-z][^\n]*)$/.exec(line);
+  if (!match) {
+    return void 0;
+  }
+  const [, type, scope, summary] = match;
+  if (!summary.trim()) {
+    return void 0;
+  }
+  return {
+    type,
+    scope,
+    summary
+  };
+}
+function looksNonImperative(summary) {
+  const firstWord = summary.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+  return [
+    "added",
+    "adding",
+    "adds",
+    "changed",
+    "changing",
+    "changes",
+    "created",
+    "creating",
+    "creates",
+    "fixed",
+    "fixing",
+    "fixes",
+    "handled",
+    "handling",
+    "handles",
+    "made",
+    "makes",
+    "prevented",
+    "preventing",
+    "prevents",
+    "recorded",
+    "recording",
+    "records",
+    "rejected",
+    "rejecting",
+    "rejects",
+    "updated",
+    "updating",
+    "updates",
+    "used",
+    "using",
+    "uses",
+    "validated",
+    "validating",
+    "validates"
+  ].includes(firstWord);
+}
+async function pushWithRetry(exec, repo, remote, branch) {
+  try {
+    await pushHeadToBranch(exec, repo, remote, branch);
+  } catch {
+    await pushHeadToBranch(exec, repo, remote, branch);
+  }
+}
+function normalizeBranchPushRemote(remote) {
+  const normalized = remote?.trim();
+  return normalized && normalized.length > 0 ? normalized : "origin";
+}
+async function postReportWithRetry(options, exec, repo, pr, reportPath, state) {
+  const postingState = await updateStatus(options, state, {
+    phase: "posting",
+    currentStatus: "Posting review"
+  });
+  await appendEvent(options.mendrHome, options.reviewId, {
+    status: "Posting review",
+    detail: "posting report comment"
+  });
+  try {
+    await postPullRequestComment(exec, repo, pr, reportPath);
+  } catch {
+    try {
+      await postPullRequestComment(exec, repo, pr, reportPath);
+    } catch (error) {
+      await fail(options, postingState, "Posting review failed", error);
+    }
+  }
+  return postingState;
+}
+async function validatePullRequestReadyForSummary(options, exec, repo, pr, state) {
+  const validationState = await updateStatus(options, state, {
+    phase: "validating",
+    currentStatus: "Validating PR"
+  });
+  await appendEvent(options.mendrHome, options.reviewId, {
+    status: "Validating PR",
+    detail: "checking merge conflicts and CI"
+  });
+  let expectedHeadSha = "";
+  try {
+    expectedHeadSha = (await validateCurrentPullRequestMergeability(exec, repo, pr, {
+      waitForLocalHead: true
+    })).headSha;
+  } catch (error) {
+    return mergeabilityValidationResult(options, validationState, error);
+  }
+  try {
+    await waitForPullRequestChecks(exec, repo, pr);
+  } catch (error) {
+    return {
+      state: validationState,
+      failure: {
+        status: "CI failed",
+        error
+      }
+    };
+  }
+  try {
+    await validateCurrentPullRequestMergeability(exec, repo, pr, {
+      expectedHeadSha
+    });
+  } catch (error) {
+    return mergeabilityValidationResult(options, validationState, error);
+  }
+  return {
+    state: validationState
+  };
+}
+async function validateCurrentPullRequestMergeability(exec, repo, pr, options = {}) {
+  const localHeadSha = await getHeadCommitSha(exec, repo);
+  const readinessRefs = options.waitForLocalHead ? await waitForPullRequestHeadToMatchLocal(exec, repo, pr, localHeadSha) : await fetchPullRequestReadinessRefs(exec, repo, pr);
+  if (options.expectedHeadSha !== void 0) {
+    assertPullRequestHeadUnchanged(options.expectedHeadSha, readinessRefs.headSha);
+  }
+  assertPullRequestHeadMatchesLocal(localHeadSha, readinessRefs.headSha);
+  const baseRef = await fetchRemoteBranch(exec, repo, "origin", readinessRefs.baseBranch);
+  await ensureMergeableWithRef(exec, repo, baseRef);
+  return readinessRefs;
+}
+async function waitForPullRequestHeadToMatchLocal(exec, repo, pr, localHeadSha) {
+  const deadline = Date.now() + PR_HEAD_PROPAGATION_TIMEOUT_MS;
+  let attempt = 0;
+  let lastObservedHeadSha = "";
+  while (Date.now() <= deadline) {
+    const readinessRefs = await fetchPullRequestReadinessRefs(exec, repo, pr);
+    lastObservedHeadSha = readinessRefs.headSha;
+    if (readinessRefs.headSha === localHeadSha) {
+      return readinessRefs;
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      break;
+    }
+    const waitMs = attempt === 0 ? 0 : Math.min(PR_HEAD_PROPAGATION_POLL_MS, remainingMs);
+    attempt += 1;
+    if (waitMs > 0) {
+      await delay(waitMs);
+    }
+  }
+  throw new PullRequestHeadChangedError(
+    `Local session HEAD ${localHeadSha} does not match current PR head ${lastObservedHeadSha} after waiting for GitHub to report the pushed head. Re-run Mendr so the final summary is posted only after validating the current PR head.`
+  );
+}
+async function mergeabilityValidationResult(options, state, error) {
+  if (error instanceof PullRequestHeadChangedError) {
+    await fail(options, state, "PR head changed", error);
+  }
+  return {
+    state,
+    failure: {
+      status: "Merge conflict check failed",
+      error
+    }
+  };
+}
+function assertPullRequestHeadMatchesLocal(localHeadSha, prHeadSha) {
+  if (localHeadSha === prHeadSha) {
+    return;
+  }
+  throw new PullRequestHeadChangedError(
+    `Local session HEAD ${localHeadSha} does not match current PR head ${prHeadSha}. Re-run Mendr so the final summary is posted only after validating the current PR head.`
+  );
+}
+function assertPullRequestHeadUnchanged(expectedHeadSha, currentHeadSha) {
+  if (expectedHeadSha === currentHeadSha) {
+    return;
+  }
+  throw new PullRequestHeadChangedError(
+    `Pull request head changed from ${expectedHeadSha} to ${currentHeadSha} while Mendr was validating readiness. Re-run Mendr so the final summary is posted only after validating the current PR head.`
+  );
+}
+async function persistIssueRecords(options, round, issues) {
+  for (const [index, issue] of issues.entries()) {
+    await appendIssueRecord(options.mendrHome, options.reviewId, {
+      sessionId: options.reviewId,
+      round,
+      issueIndex: index + 1,
+      fingerprint: issueFingerprint(issue),
+      title: issue.title,
+      file: issue.file,
+      line: issue.line,
+      severity: issue.severity,
+      description: issue.description
+    });
+  }
+}
+function normalizeFixResults(issues, results) {
+  const byFingerprint = new Map(results.map((result) => [result.fingerprint, result]));
+  return issues.map((issue) => {
+    const fingerprint = issueFingerprint(issue);
+    const byExactFingerprint = byFingerprint.get(fingerprint);
+    const byTitle = results.find((result2) => result2.title === issue.title);
+    const result = byExactFingerprint ?? byTitle;
+    if (result) {
+      return {
+        ...result,
+        fingerprint
+      };
+    }
+    return {
+      title: issue.title,
+      fingerprint,
+      status: "failed",
+      summary: "The fixer did not return a result for this issue. Manual follow-up is required."
+    };
+  });
+}
+async function updateStatus(options, previous, patch) {
+  const next = {
+    ...previous,
+    ...patch
+  };
+  await writeState(options.mendrHome, options.reviewId, next);
+  return next;
+}
+async function fail(options, state, status, error) {
+  const message = errorToMessage(error);
+  await writeState(options.mendrHome, options.reviewId, {
+    ...state,
+    phase: "failed",
+    currentStatus: status,
+    done: false,
+    error: message
+  });
+  await appendEvent(options.mendrHome, options.reviewId, {
+    status,
+    detail: message
+  });
+  const recordedError = error instanceof Error ? error : new Error(message);
+  Object.defineProperty(recordedError, "mendrFailureRecorded", {
+    value: true,
+    configurable: true
+  });
+  throw recordedError;
+}
+async function readReport(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+function buildContext(ctx) {
+  return ctx;
+}
+function parseAgentName(agent) {
+  if (agent === "claude" || agent === "codex") {
+    return agent;
+  }
+  throw new Error(`Unsupported agent: ${agent}`);
+}
+function resolveEffort(agent, effort) {
+  if (!effort) {
+    return defaultEffortForAgent(agent);
+  }
+  if (isEffortForAgent(agent, effort)) {
+    return effort;
+  }
+  throw new Error(
+    `Invalid ${agent} effort "${effort}" in review metadata. Expected one of: ${allowedEffortsForAgent(agent).join(", ")}.`
+  );
+}
+function errorToMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isAlreadyRecordedFailure(state, error) {
+  return state.phase === "failed" || typeof error === "object" && error !== null && "mendrFailureRecorded" in error && error.mendrFailureRecorded === true;
+}
+
+// src/daemon.ts
+async function runDaemon(argv = process.argv) {
+  const parsed = parseDaemonArgs(argv);
+  if (!parsed.ok) {
+    throw new Error(parsed.error);
+  }
+  try {
+    await runOrchestrator({
+      mendrHome: parsed.mendrHome,
+      reviewId: parsed.reviewId
+    });
+  } catch (error) {
+    await recordDaemonFailure(parsed.mendrHome, parsed.reviewId, error);
+    throw error;
+  }
+}
+function parseDaemonArgs(argv) {
+  const args = argv.slice(2);
+  let mendrHome = defaultMendrHome();
+  let reviewId;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const value = args[index + 1];
+    if (arg === "--home" && value) {
+      mendrHome = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--id" && value) {
+      reviewId = value;
+      index += 1;
+      continue;
+    }
+    return {
+      ok: false,
+      error: `Unsupported daemon argument: ${arg}`
+    };
+  }
+  if (!reviewId) {
+    return {
+      ok: false,
+      error: "Expected --id for daemon review session."
+    };
+  }
+  return {
+    ok: true,
+    mendrHome,
+    reviewId
+  };
+}
+async function recordDaemonFailure(mendrHome, reviewId, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  let state = {
+    phase: "failed",
+    currentStatus: "Daemon failed",
+    issuesFound: 0,
+    issuesFixed: 0,
+    done: false,
+    capReached: false,
+    error: message
+  };
+  try {
+    const existing = await readState(mendrHome, reviewId);
+    if (existing.phase === "failed" && existing.error) {
+      return;
+    }
+    state = {
+      ...existing,
+      phase: "failed",
+      currentStatus: "Daemon failed",
+      done: false,
+      error: message
+    };
+  } catch {
+  }
+  await writeState(mendrHome, reviewId, state);
+  await appendEvent(mendrHome, reviewId, {
+    status: "Daemon failed",
+    detail: message
+  });
+}
+if (process.argv[1] && process.argv[1].endsWith("daemon.js")) {
+  runDaemon().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
+export {
+  runDaemon
+};