@mrkaran/hodor 0.7.2 → 0.7.4

package/dist/{chunk-YKB3BRJM.js → chunk-AFEJ4DRL.js}

@@ -1,25 +1,724 @@
-import {
-  HODOR_REVIEW_MARKER,
-  bulkPublishGitlabDraftNotes,
-  createGitlabDraftNote,
-  exec,
-  execJson,
-  fetchGitlabMrInfo,
-  getGitlabMrDiffRefs,
-  listHodorDiscussions,
-  logger,
-  postGitlabCommitStatus,
-  postGitlabMrComment,
-  publishGitlabDraftNote,
-  renderMarkdown,
-  renderSummaryMarkdown,
-  resolveGitlabDiscussions,
-  summarizeGitlabNotes,
-  summarizeHodorNotes
-} from "./chunk-DALI4QRT.js";
-import {
-  relativizeWorkspacePath
-} from "./chunk-AMUK6GDX.js";
+// src/utils/logger.ts
+import chalk from "chalk";
+var currentLevel = "warn";
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function shouldLog(level) {
+  return LEVELS[level] >= LEVELS[currentLevel];
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var logger = {
+  debug(msg) {
+    if (shouldLog("debug")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.gray("DEBUG")} ${msg}
+`);
+    }
+  },
+  info(msg) {
+    if (shouldLog("info")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.blue("INFO")}  ${msg}
+`);
+    }
+  },
+  warn(msg) {
+    if (shouldLog("warn")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.yellow("WARN")}  ${msg}
+`);
+    }
+  },
+  error(msg) {
+    if (shouldLog("error")) {
+      process.stderr.write(`${chalk.gray(timestamp())} ${chalk.red("ERROR")} ${msg}
+`);
+    }
+  }
+};
+
+// src/render.ts
+var HODOR_REVIEW_MARKER = "<!-- hodor-review -->";
+var HODOR_SUMMARY_MARKER = "<!-- hodor:summary:v1 -->";
+function renderMarkdown(review) {
+  const lines = [HODOR_REVIEW_MARKER];
+  const critical = [];
+  const important = [];
+  const minor = [];
+  for (const f of review.findings) {
+    const p = f.priority;
+    if (p <= 1) critical.push(f);
+    else if (p === 2) important.push(f);
+    else minor.push(f);
+  }
+  lines.push("### Issues Found");
+  lines.push("");
+  if (review.findings.length === 0) {
+    lines.push("No issues found.");
+    lines.push("");
+  }
+  if (critical.length > 0) {
+    lines.push("**Critical (P0/P1)**");
+    for (const f of critical) {
+      lines.push(formatFinding(f));
+    }
+    lines.push("");
+  }
+  if (important.length > 0) {
+    lines.push("**Important (P2)**");
+    for (const f of important) {
+      lines.push(formatFinding(f));
+    }
+    lines.push("");
+  }
+  if (minor.length > 0) {
+    lines.push("**Minor (P3)**");
+    for (const f of minor) {
+      lines.push(formatFinding(f));
+    }
+    lines.push("");
+  }
+  lines.push("### Summary");
+  lines.push(
+    `Total issues: ${critical.length} critical, ${important.length} important, ${minor.length} minor.`
+  );
+  lines.push("");
+  lines.push("### Overall Verdict");
+  const isCorrect = review.overall_correctness === "patch is correct";
+  lines.push(
+    `**Status**: ${isCorrect ? "Patch is correct" : "Patch has blocking issues"}`
+  );
+  lines.push("");
+  if (review.overall_explanation) {
+    lines.push(`**Explanation**: ${review.overall_explanation}`);
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function renderSummaryMarkdown(review, options = {}) {
+  const lines = [HODOR_REVIEW_MARKER, HODOR_SUMMARY_MARKER];
+  lines.push("", "### Hodor review");
+  const openFindings = options.openFindings ?? review.findings;
+  const fallbackFindings = options.fallbackFindings ?? review.findings;
+  const counts = { blocking: 0, important: 0, minor: 0 };
+  for (const finding of openFindings) {
+    if (finding.priority <= 1) counts.blocking++;
+    else if (finding.priority === 2) counts.important++;
+    else counts.minor++;
+  }
+  lines.push("");
+  lines.push(
+    `**Open findings:** ${counts.blocking} blocking \xB7 ${counts.important} important \xB7 ${counts.minor} minor`
+  );
+  if (options.inlineCreated != null || options.inlineDeduplicated != null) {
+    lines.push("");
+    lines.push(
+      `**Inline delivery:** ${options.inlineCreated ?? 0} new \xB7 ${options.inlineDeduplicated ?? 0} already open`
+    );
+  }
+  const scope = options.reviewMode ? `${options.reviewMode} review` : "Latest review";
+  lines.push("");
+  lines.push(`**${scope}:** ${review.overall_explanation}`);
+  if (fallbackFindings.length > 0) {
+    lines.push("");
+    lines.push(`### ${options.fallbackHeading ?? "Findings"}`);
+    for (const finding of fallbackFindings) {
+      lines.push(formatFinding(finding));
+    }
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function formatFinding(f) {
+  const loc = ` (\`${formatLocation(f.code_location)}\`)`;
+  const title = `- **${f.title}**${loc}`;
+  const body = `  - ${f.body}`;
+  return `${title}
+${body}`;
+}
+function formatLocation(loc) {
+  let filePath = loc.absolute_file_path;
+  const buildsMatch = filePath.match(/\/builds\/[^/]+\/[^/]+\/(.+)/);
+  if (buildsMatch) {
+    filePath = buildsMatch[1];
+  } else if (filePath.includes("/workspace/")) {
+    filePath = filePath.slice(filePath.indexOf("/workspace/") + "/workspace/".length);
+  } else {
+    filePath = filePath.replace(/^.*\/hodor-review-[^/]+\//, "");
+  }
+  const { start, end } = loc.line_range;
+  return start === end ? `${filePath}:${start}` : `${filePath}:${start}-${end}`;
+}
+
+// src/utils/exec.ts
+import { execFile, spawn } from "child_process";
+import { accessSync, constants } from "fs";
+import { delimiter, join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function exec(cmd, args, opts) {
+  if (typeof opts?.input === "string") {
+    return new Promise((resolve4, reject) => {
+      const child = spawn(cmd, args, {
+        cwd: opts.cwd,
+        env: opts.env ?? process.env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout2 = "";
+      let stderr2 = "";
+      child.stdout.on("data", (chunk) => {
+        stdout2 += chunk.toString();
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr2 += chunk.toString();
+      });
+      child.on("error", (error) => {
+        reject(error);
+      });
+      child.on("close", (code, signal) => {
+        if (code === 0) {
+          resolve4({ stdout: stdout2, stderr: stderr2 });
+          return;
+        }
+        const parts = [`Command failed: ${cmd} ${args.join(" ")}`];
+        if (stderr2.trim()) {
+          parts.push(`stderr:
+${stderr2.trim()}`);
+        }
+        if (stdout2.trim()) {
+          parts.push(`stdout:
+${stdout2.trim()}`);
+        }
+        if (signal) {
+          parts.push(`signal: ${signal}`);
+        }
+        const error = new Error(parts.join("\n"));
+        reject(error);
+      });
+      child.stdin.write(opts.input);
+      child.stdin.end();
+    });
+  }
+  const { stdout, stderr } = await execFileAsync(cmd, args, {
+    cwd: opts?.cwd,
+    env: opts?.env ?? process.env,
+    maxBuffer: 50 * 1024 * 1024
+    // 50MB
+  });
+  return { stdout, stderr };
+}
+async function execJson(cmd, args, opts) {
+  const { stdout } = await exec(cmd, args, opts);
+  return JSON.parse(stdout.trim());
+}
+function commandOnPath(cmd) {
+  return (process.env.PATH ?? "").split(delimiter).filter((dir) => dir !== "").some((dir) => {
+    try {
+      accessSync(join(dir, cmd), constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+
+// src/gitlab.ts
+var DEFAULT_GITLAB_HOST = "gitlab.com";
+var HODOR_NOTE_PREFIX_RE = /^\s*<!--\s*hodor[-:]/;
+var HODOR_CACHE_MARKER_RE = /<!--\s*hodor:cache:v1:[A-Za-z0-9_-]+\s*-->\s*/g;
+var HODOR_SHA_PREFIX_RE = /^\s*<!--\s*hodor:sha:[a-f0-9]{40}\s*-->/i;
+function isHodorNote(body, marker = HODOR_REVIEW_MARKER) {
+  if (typeof body !== "string") return false;
+  if (body.trimStart().startsWith(marker)) return true;
+  if (marker === HODOR_REVIEW_MARKER && HODOR_NOTE_PREFIX_RE.test(body)) {
+    return body.includes(HODOR_REVIEW_MARKER);
+  }
+  return false;
+}
+function parseGlabPaginatedJson(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  const chunks = [];
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let start = -1;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "[") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === "]") {
+      depth--;
+      if (depth === 0 && start >= 0) {
+        chunks.push(trimmed.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  const results = [];
+  for (const chunk of chunks) {
+    try {
+      const parsed = JSON.parse(chunk);
+      if (Array.isArray(parsed)) results.push(...parsed);
+    } catch (err) {
+      logger.warn(
+        `Skipping malformed glab pagination chunk: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  return results;
+}
+var GitLabAPIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitLabAPIError";
+  }
+};
+function normalizeBaseUrl(host) {
+  const candidate = host || process.env.GITLAB_HOST || process.env.CI_SERVER_URL || DEFAULT_GITLAB_HOST;
+  const trimmed = candidate.trim() || DEFAULT_GITLAB_HOST;
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return trimmed.replace(/\/+$/, "");
+  }
+  return `https://${trimmed}`.replace(/\/+$/, "");
+}
+function encodedProjectPath(owner, repo) {
+  const projectPath = [owner.replace(/^\/+|\/+$/g, ""), repo.replace(/^\/+|\/+$/g, "")].filter(Boolean).join("/");
+  return encodeURIComponent(projectPath);
+}
+function glabEnv(host) {
+  const env = { ...process.env };
+  const baseUrl = normalizeBaseUrl(host);
+  const hostname = baseUrl.replace(/^https?:\/\//, "");
+  env.GITLAB_HOST = hostname;
+  return env;
+}
+async function fetchGitlabMrInfo(owner, repo, mrNumber, host, options) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  let mrData;
+  try {
+    mrData = await execJson(
+      "glab",
+      ["api", `projects/${encoded}/merge_requests/${mrNumber}`],
+      { env }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to fetch MR !${mrNumber}: ${msg}`);
+  }
+  const metadata = {
+    title: mrData.title,
+    description: mrData.description ?? "",
+    source_branch: mrData.source_branch,
+    target_branch: mrData.target_branch,
+    changes_count: mrData.changes_count,
+    labels: mrData.labels,
+    author: mrData.author,
+    pipeline: mrData.pipeline,
+    state: mrData.state
+  };
+  if (options?.includeComments) {
+    try {
+      const { stdout: rawNotes } = await exec(
+        "glab",
+        ["api", `projects/${encoded}/merge_requests/${mrNumber}/notes`, "--paginate"],
+        { env }
+      );
+      const notes = parseGlabPaginatedJson(rawNotes);
+      metadata.Notes = notes.map((n) => ({
+        body: n.body ?? "",
+        author: n.author,
+        created_at: n.created_at,
+        updated_at: n.updated_at,
+        system: n.system
+      }));
+    } catch (err) {
+      logger.warn(`Failed to fetch MR notes: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  return metadata;
+}
+async function postGitlabMrComment(owner, repo, mrNumber, body, host) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  try {
+    await exec(
+      "glab",
+      [
+        "api",
+        `projects/${encoded}/merge_requests/${mrNumber}/notes`,
+        "--method",
+        "POST",
+        "-H",
+        "Content-Type: application/json",
+        "--input",
+        "-"
+      ],
+      { env, input: JSON.stringify({ body }) }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to post comment to MR !${mrNumber}: ${msg}`);
+  }
+}
+async function upsertGitlabMrSummary(owner, repo, mrNumber, body, host) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  try {
+    const [currentUser, notesResult] = await Promise.all([
+      execJson("glab", ["api", "user"], { env }),
+      exec(
+        "glab",
+        [
+          "api",
+          `projects/${encoded}/merge_requests/${mrNumber}/notes?per_page=100`,
+          "--paginate"
+        ],
+        { env }
+      )
+    ]);
+    const username = currentUser.username;
+    if (typeof username !== "string" || !username) {
+      throw new Error("authenticated GitLab user has no username");
+    }
+    const candidates = parseGlabPaginatedJson(notesResult.stdout).filter((note) => {
+      const noteBody = note.body;
+      const author = note.author;
+      const authorUsername = author && typeof author === "object" ? author.username : void 0;
+      if (typeof noteBody !== "string" || authorUsername !== username || note.system === true || note.type != null || note.position != null) {
+        return false;
+      }
+      return noteBody.includes(HODOR_SUMMARY_MARKER) || HODOR_SHA_PREFIX_RE.test(noteBody) && noteBody.includes(HODOR_REVIEW_MARKER);
+    }).sort((a, b) => {
+      const aTime = Date.parse(String(a.updated_at ?? a.created_at ?? ""));
+      const bTime = Date.parse(String(b.updated_at ?? b.created_at ?? ""));
+      return (Number.isFinite(bTime) ? bTime : 0) - (Number.isFinite(aTime) ? aTime : 0);
+    });
+    const noteId = candidates[0]?.id;
+    if (typeof noteId !== "number" && typeof noteId !== "string") {
+      await postGitlabMrComment(owner, repo, mrNumber, body, host);
+      return "created";
+    }
+    await exec(
+      "glab",
+      [
+        "api",
+        `projects/${encoded}/merge_requests/${mrNumber}/notes/${noteId}`,
+        "--method",
+        "PUT",
+        "-H",
+        "Content-Type: application/json",
+        "--input",
+        "-"
+      ],
+      { env, input: JSON.stringify({ body }) }
+    );
+    return "updated";
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to upsert summary for MR !${mrNumber}: ${msg}`);
+  }
+}
+function summarizeGitlabNotes(notes, maxEntries = 5) {
+  return summarizeNotes(notes, maxEntries, (note) => !isHodorNote(note.body));
+}
+function summarizeHodorNotes(notes, maxEntries = 5) {
+  return summarizeNotes(notes, maxEntries, (note) => isHodorNote(note.body));
+}
+function summarizeNotes(notes, maxEntries, include) {
+  if (!notes || notes.length === 0) return "";
+  const trivialPatterns = /* @__PURE__ */ new Set([
+    "lgtm",
+    "+1",
+    "-1",
+    "\u{1F44D}",
+    "\u{1F44E}",
+    "thanks",
+    "thank you",
+    "looks good",
+    "approved",
+    "\u{1F680}",
+    "\u2705",
+    "\u274C"
+  ]);
+  const filtered = [];
+  for (const note of notes) {
+    if (!include(note)) continue;
+    const body = (note.body ?? "").replace(HODOR_CACHE_MARKER_RE, "").trim();
+    if (!body) continue;
+    if (note.system) continue;
+    if (body.length < 20) continue;
+    const bodyLower = body.toLowerCase();
+    let isTrivial = false;
+    for (const pattern of trivialPatterns) {
+      if (bodyLower.includes(pattern) && body.length < 50) {
+        isTrivial = true;
+        break;
+      }
+    }
+    if (isTrivial) continue;
+    const username = note.author?.username ?? note.author?.name ?? "unknown";
+    filtered.push({ username, body, createdAt: note.created_at ?? "" });
+  }
+  filtered.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const recent = filtered.slice(-maxEntries);
+  const lines = [];
+  for (const { username, body, createdAt } of recent) {
+    let timestampStr = "";
+    if (createdAt) {
+      try {
+        const dt = new Date(createdAt);
+        timestampStr = dt.toISOString().replace("T", " ").slice(0, 16);
+      } catch {
+        timestampStr = createdAt.slice(0, 10);
+      }
+    }
+    const header = timestampStr ? `- ${timestampStr} @${username}:` : `- @${username}:`;
+    const boundedBody = body.length > 2e3 ? `${body.slice(0, 1999).trimEnd()}\u2026` : body;
+    const indentedBody = boundedBody.split("\n").join("\n  ");
+    lines.push(`${header}
+  ${indentedBody}`);
+  }
+  return lines.join("\n");
+}
+async function getGitlabMrDiffRefs(owner, repo, mrNumber, host) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  let mrData;
+  try {
+    mrData = await execJson(
+      "glab",
+      ["api", `projects/${encoded}/merge_requests/${mrNumber}`],
+      { env }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to fetch diff refs for MR !${mrNumber}: ${msg}`);
+  }
+  const diffRefs = mrData.diff_refs;
+  const base_sha = diffRefs?.base_sha;
+  const head_sha = diffRefs?.head_sha;
+  const start_sha = diffRefs?.start_sha;
+  if (typeof base_sha !== "string" || typeof head_sha !== "string" || typeof start_sha !== "string" || !base_sha || !head_sha || !start_sha) {
+    throw new GitLabAPIError(`MR !${mrNumber} has missing or incomplete diff_refs`);
+  }
+  return { base_sha, head_sha, start_sha };
+}
+async function createGitlabDraftNote(owner, repo, mrNumber, body, host, opts) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  const endpoint = `projects/${encoded}/merge_requests/${mrNumber}/draft_notes`;
+  const payload = {
+    note: body
+  };
+  if (opts?.filePath && typeof opts.line === "number" && opts.diffRefs) {
+    payload.position = {
+      base_sha: opts.diffRefs.base_sha,
+      head_sha: opts.diffRefs.head_sha,
+      start_sha: opts.diffRefs.start_sha,
+      position_type: "text",
+      old_path: opts.filePath,
+      new_path: opts.filePath,
+      new_line: opts.line
+    };
+  }
+  try {
+    return await execJson(
+      "glab",
+      ["api", endpoint, "--method", "POST", "-H", "Content-Type: application/json", "--input", "-"],
+      {
+        env,
+        input: JSON.stringify(payload)
+      }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to create draft note for MR !${mrNumber}: ${msg}`);
+  }
+}
+async function bulkPublishGitlabDraftNotes(owner, repo, mrNumber, host) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  try {
+    await exec(
+      "glab",
+      [
+        "api",
+        `projects/${encoded}/merge_requests/${mrNumber}/draft_notes/bulk_publish`,
+        "--method",
+        "POST"
+      ],
+      { env }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to bulk publish draft notes for MR !${mrNumber}: ${msg}`);
+  }
+}
+async function publishGitlabDraftNote(owner, repo, mrNumber, draftNoteId, host) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  try {
+    await exec(
+      "glab",
+      [
+        "api",
+        `projects/${encoded}/merge_requests/${mrNumber}/draft_notes/${draftNoteId}/publish`,
+        "--method",
+        "PUT"
+      ],
+      { env }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to publish draft note ${draftNoteId} for MR !${mrNumber}: ${msg}`);
+  }
+}
+async function postGitlabCommitStatus(owner, repo, sha, state, host, opts) {
+  const allowedStates = /* @__PURE__ */ new Set([
+    "pending",
+    "running",
+    "success",
+    "failed",
+    "canceled"
+  ]);
+  if (!allowedStates.has(state)) {
+    throw new GitLabAPIError(`Invalid GitLab commit status state: ${state}`);
+  }
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  const endpoint = `projects/${encoded}/statuses/${sha}`;
+  const payload = {
+    state,
+    name: opts?.name ?? "hodor"
+  };
+  if (opts?.description) {
+    payload.description = opts.description;
+  }
+  if (opts?.targetUrl) {
+    payload.target_url = opts.targetUrl;
+  }
+  try {
+    await exec(
+      "glab",
+      ["api", endpoint, "--method", "POST", "-H", "Content-Type: application/json", "--input", "-"],
+      {
+        env,
+        input: JSON.stringify(payload)
+      }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to post commit status for ${sha}: ${msg}`);
+  }
+}
+async function listHodorDiscussions(owner, repo, mrNumber, host, marker = HODOR_REVIEW_MARKER) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  let discussions;
+  try {
+    const { stdout: rawDiscussions } = await exec(
+      "glab",
+      [
+        "api",
+        `projects/${encoded}/merge_requests/${mrNumber}/discussions?per_page=100`,
+        "--paginate"
+      ],
+      { env }
+    );
+    discussions = parseGlabPaginatedJson(rawDiscussions);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitLabAPIError(`Failed to list discussions for MR !${mrNumber}: ${msg}`);
+  }
+  const results = [];
+  for (const discussion of discussions) {
+    const discussionId = discussion.id;
+    if (typeof discussionId !== "string") {
+      continue;
+    }
+    const notes = discussion.notes;
+    if (!Array.isArray(notes)) {
+      continue;
+    }
+    for (const note of notes) {
+      if (!note || typeof note !== "object") {
+        continue;
+      }
+      const noteObj = note;
+      const noteId = noteObj.id;
+      const body = noteObj.body;
+      if (typeof noteId !== "number" || typeof body !== "string" || !isHodorNote(body, marker)) {
+        continue;
+      }
+      const position = noteObj.position && typeof noteObj.position === "object" ? noteObj.position : void 0;
+      const filePath = typeof position?.new_path === "string" ? position.new_path : typeof position?.old_path === "string" ? position.old_path : void 0;
+      const line = typeof position?.new_line === "number" ? position.new_line : typeof position?.old_line === "number" ? position.old_line : void 0;
+      if (noteObj.resolvable !== true) {
+        continue;
+      }
+      results.push({
+        discussionId,
+        noteId,
+        body,
+        resolved: Boolean(noteObj.resolved),
+        filePath,
+        line
+      });
+    }
+  }
+  return results;
+}
+async function resolveGitlabDiscussions(owner, repo, mrNumber, discussionIds, host) {
+  const encoded = encodedProjectPath(owner, repo);
+  const env = glabEnv(host);
+  let resolvedCount = 0;
+  for (const discussionId of discussionIds) {
+    try {
+      await exec(
+        "glab",
+        [
+          "api",
+          `projects/${encoded}/merge_requests/${mrNumber}/discussions/${discussionId}`,
+          "--method",
+          "PUT",
+          "-H",
+          "Content-Type: application/json",
+          "--input",
+          "-"
+        ],
+        {
+          env,
+          input: JSON.stringify({ resolved: true })
+        }
+      );
+      resolvedCount += 1;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`Failed to resolve discussion ${discussionId} on MR !${mrNumber}: ${msg}`);
+    }
+  }
+  return resolvedCount;
+}
 
 // src/prompt.ts
 import { readFileSync } from "fs";
@@ -31,6 +730,135 @@ function getTemplatePath(name) {
   return resolve(dirname(fileURLToPath(import.meta.url)), "..", "templates", name);
 }
 
+// src/review-diff.ts
+var HODOR_REVIEW_SHA_RE = /^\s*<!--\s*hodor:sha:([a-f0-9]{40})\s*-->/i;
+function getReviewDiffArgs(options) {
+  const {
+    platform,
+    targetBranch,
+    diffBaseSha,
+    previousReviewSha,
+    reviewDiffMode,
+    localMode = false
+  } = options;
+  const rebasedGitlabReview = platform === "gitlab" && reviewDiffMode === "snapshot";
+  if (previousReviewSha && !rebasedGitlabReview) {
+    return reviewDiffMode === "snapshot" ? ["--no-pager", "diff", previousReviewSha, "HEAD"] : ["--no-pager", "diff", `${previousReviewSha}...HEAD`];
+  }
+  if (localMode) return ["--no-pager", "diff", targetBranch];
+  if (diffBaseSha) return ["--no-pager", "diff", diffBaseSha, "HEAD"];
+  return ["--no-pager", "diff", `origin/${targetBranch}...HEAD`];
+}
+function getHodorReviewShaCandidates(notes) {
+  if (!notes || notes.length === 0) return [];
+  const candidates = [];
+  for (const [index, note] of notes.entries()) {
+    const match = note.body?.match(HODOR_REVIEW_SHA_RE);
+    if (!match) continue;
+    const reviewedAtMs = Date.parse(note.updated_at ?? note.created_at ?? "");
+    candidates.push({
+      sha: match[1],
+      reviewedAtMs: Number.isFinite(reviewedAtMs) ? reviewedAtMs : null,
+      index
+    });
+  }
+  candidates.sort((a, b) => {
+    if (a.reviewedAtMs != null && b.reviewedAtMs != null && a.reviewedAtMs !== b.reviewedAtMs) {
+      return b.reviewedAtMs - a.reviewedAtMs;
+    }
+    if (a.reviewedAtMs != null && b.reviewedAtMs == null) return -1;
+    if (a.reviewedAtMs == null && b.reviewedAtMs != null) return 1;
+    return a.index - b.index;
+  });
+  return [...new Set(candidates.map(({ sha }) => sha))];
+}
+async function findLatestReviewBase(notes, workspacePath) {
+  const candidates = getHodorReviewShaCandidates(notes);
+  if (candidates.length === 0) return null;
+  logger.info(`Found ${candidates.length} previous Hodor review marker(s)`);
+  for (const sha of candidates) {
+    try {
+      let objectType;
+      try {
+        ({ stdout: objectType } = await exec("git", ["cat-file", "-t", sha], {
+          cwd: workspacePath
+        }));
+      } catch {
+        await exec("git", ["fetch", "--quiet", "origin", sha], {
+          cwd: workspacePath
+        });
+        ({ stdout: objectType } = await exec("git", ["cat-file", "-t", sha], {
+          cwd: workspacePath
+        }));
+      }
+      if (objectType.trim() !== "commit") throw new Error("not a commit");
+      try {
+        await exec("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
+          cwd: workspacePath
+        });
+        return { sha, mode: "incremental" };
+      } catch {
+        logger.info(
+          `Previous review SHA ${sha.slice(0, 8)} is not an ancestor; using snapshot delta`
+        );
+        return { sha, mode: "snapshot" };
+      }
+    } catch {
+      logger.info(
+        `Skipping previous review SHA ${sha.slice(0, 8)}; commit is unavailable`
+      );
+    }
+  }
+  return null;
+}
+function getDiffStats(diff) {
+  let files = 0;
+  let additions = 0;
+  let deletions = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("diff --git ")) files++;
+    else if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+    else if (line.startsWith("-") && !line.startsWith("---")) deletions++;
+  }
+  return {
+    files,
+    additions,
+    deletions,
+    bytes: Buffer.byteLength(diff, "utf-8")
+  };
+}
+function getChangedFiles(diff) {
+  const files = [];
+  for (const match of diff.matchAll(/^diff --git a\/(.*?) b\/(.*?)$/gm)) {
+    files.push(match[2]);
+  }
+  return [...new Set(files)];
+}
+var DIFF_SKIP_PATTERNS = [
+  /(?:^|\/)testdata\//,
+  /(?:^|\/)(?:package-lock\.json|yarn\.lock|pnpm-lock\.yaml|go\.sum|Cargo\.lock|poetry\.lock|Gemfile\.lock|composer\.lock)$/,
+  /\.mdx?$/
+];
+function filterEmbeddedDiff(rawDiff) {
+  const skippedFiles = [];
+  const sections = rawDiff.split(/(?=^diff --git )/m);
+  const kept = [];
+  for (const section of sections) {
+    const match = section.match(/^diff --git a\/(.*?) b\//);
+    if (!match) {
+      kept.push(section);
+      continue;
+    }
+    const filePath = match[1];
+    if (DIFF_SKIP_PATTERNS.some((pattern) => pattern.test(filePath))) {
+      skippedFiles.push(filePath);
+    } else {
+      kept.push(section);
+    }
+  }
+  return { filtered: kept.join(""), skippedFiles };
+}
+
 // src/prompt.ts
 function buildPrReviewPrompt(opts) {
   const {
@@ -44,8 +872,12 @@ function buildPrReviewPrompt(opts) {
     reviewDiffMode,
     changedFiles = [],
     localMode = false,
-    singleTurn = false
+    singleTurn = false,
+    findToolAvailable = false
   } = opts;
+  const rebasedGitlabReview = platform === "gitlab" && reviewDiffMode === "snapshot";
+  const hasPreviousReviewDelta = Boolean(previousReviewSha && !rebasedGitlabReview);
+  const previousReviewShaText = previousReviewSha ?? "";
   let templateText;
   try {
     templateText = readFileSync(getTemplatePath("review-task.md"), "utf-8");
@@ -62,44 +894,36 @@ function buildPrReviewPrompt(opts) {
   if (previousReviewSha && !/^[a-f0-9]{40}$/.test(previousReviewSha)) {
     throw new Error(`Invalid previous review SHA: ${previousReviewSha}`);
   }
-  let prDiffCmd;
-  let gitDiffCmd;
-  if (previousReviewSha) {
-    const separator = reviewDiffMode === "snapshot" ? " " : "...";
-    prDiffCmd = `git --no-pager diff ${previousReviewSha}${separator}HEAD --name-only`;
-    gitDiffCmd = `git --no-pager diff ${previousReviewSha}${separator}HEAD`;
-    logger.info(`${reviewDiffMode === "snapshot" ? "Snapshot" : "Incremental"} review: diffing from ${previousReviewSha.slice(0, 8)} to HEAD`);
-  } else if (localMode) {
-    prDiffCmd = `git --no-pager diff ${targetBranch} --name-only`;
-    gitDiffCmd = `git --no-pager diff ${targetBranch}`;
-  } else if (platform === "github" || platform === "gitea") {
-    prDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD --name-only`;
-    gitDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD`;
-  } else {
-    if (diffBaseSha) {
-      prDiffCmd = `git --no-pager diff ${diffBaseSha} HEAD --name-only`;
-      gitDiffCmd = `git --no-pager diff ${diffBaseSha} HEAD`;
-      logger.info(`Using GitLab CI_MERGE_REQUEST_DIFF_BASE_SHA: ${diffBaseSha.slice(0, 8)}`);
-    } else {
-      prDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD --name-only`;
-      gitDiffCmd = `git --no-pager diff origin/${targetBranch}...HEAD`;
-    }
+  const diffArgs = getReviewDiffArgs({
+    platform,
+    targetBranch,
+    diffBaseSha,
+    previousReviewSha,
+    reviewDiffMode,
+    localMode
+  });
+  const gitDiffCmd = `git ${diffArgs.join(" ")}`;
+  const prDiffCmd = `${gitDiffCmd} --name-only`;
+  if (hasPreviousReviewDelta) {
+    logger.info(`${reviewDiffMode === "snapshot" ? "Snapshot" : "Incremental"} review: diffing from ${previousReviewSha?.slice(0, 8)} to HEAD`);
+  } else if (rebasedGitlabReview) {
+    logger.info("Rebased GitLab review: diffing from the current MR base to HEAD");
   }
   let diffExplanation;
-  if (previousReviewSha) {
-    diffExplanation = reviewDiffMode === "snapshot" ? `**Snapshot delta mode**: The MR history was rewritten. This directly compares the last reviewed snapshot (commit \`${previousReviewSha.slice(0, 8)}\`) with the current HEAD; it does not imply ancestry.` : `**Incremental mode**: Showing only changes since the last hodor review (commit \`${previousReviewSha.slice(0, 8)}\`).`;
+  if (hasPreviousReviewDelta) {
+    diffExplanation = reviewDiffMode === "snapshot" ? `**Snapshot delta mode**: The MR history was rewritten. This directly compares the last reviewed snapshot (commit \`${previousReviewShaText.slice(0, 8)}\`) with the current HEAD; it does not imply ancestry.` : `**Incremental mode**: Showing only changes since the last hodor review (commit \`${previousReviewShaText.slice(0, 8)}\`).`;
   } else if (diffBaseSha) {
-    diffExplanation = `**GitLab CI Advantage**: This uses GitLab's pre-calculated merge base SHA (\`CI_MERGE_REQUEST_DIFF_BASE_SHA\`), which matches exactly what the GitLab UI shows. This is more reliable than three-dot syntax because it handles force pushes, rebases, and messy histories correctly.`;
+    diffExplanation = `**GitLab CI Advantage**: This uses the merge base resolved from the current target branch, which matches the current GitLab MR diff after force pushes and rebases.`;
   } else {
     diffExplanation = `**Three-dot syntax** shows ONLY changes introduced on the source branch, excluding changes already on \`${targetBranch}\`.`;
   }
   const { contextSection, notesSection, reminderSection } = buildMrSections(mrMetadata);
   const oneTurn = singleTurn && Boolean(embeddedDiff);
   let incrementalSection = "";
-  if (previousReviewSha) {
+  if (hasPreviousReviewDelta) {
     incrementalSection = `## ${reviewDiffMode === "snapshot" ? "Snapshot Delta" : "Incremental Review"} Mode
 
-This is a follow-up review. A previous hodor review was done at commit \`${previousReviewSha.slice(0, 8)}\`. ` + (reviewDiffMode === "snapshot" ? "The branch history was rewritten, so the diff below compares that reviewed snapshot directly with the current HEAD. " : "The diff below shows ONLY changes since that review. ") + "Your job is to review that delta, not the whole MR again.\n\nRules for incremental reviews:\n1. Only report findings introduced or still affected by the new delta.\n2. Do not re-report issues that are already mentioned in existing notes unless the new delta changes the same code and the issue remains newly relevant.\n3. If the delta is small and self-contained, decide from the embedded diff and submit the review without broad repository exploration.\n" + (oneTurn ? "4. No file-inspection tools are available; if a mechanical change like a route/path/string rename leaves a compatibility question you cannot settle from the diff, do not report it.\n" : "4. For mechanical changes like route/path/string renames, verify the direct call sites or tests only when the diff itself leaves a concrete compatibility question.\n") + "5. If the delta does not produce a qualifying finding under the selected review instructions, submit no findings.\n\n";
+This is a follow-up review. A previous hodor review was done at commit \`${previousReviewShaText.slice(0, 8)}\`. ` + (reviewDiffMode === "snapshot" ? "The branch history was rewritten, so the diff below compares that reviewed snapshot directly with the current HEAD. " : "The diff below shows ONLY changes since that review. ") + "Your job is to review that delta, not the whole MR again.\n\nRules for incremental reviews:\n1. Only report findings introduced or still affected by the new delta.\n2. Do not re-report issues that are already mentioned in existing notes unless the new delta changes the same code and the issue remains newly relevant.\n3. If the delta is small and self-contained, decide from the embedded diff and submit the review without broad repository exploration.\n" + (oneTurn ? "4. No file-inspection tools are available; if a mechanical change like a route/path/string rename leaves a compatibility question you cannot settle from the diff, do not report it.\n" : "4. For mechanical changes like route/path/string renames, verify the direct call sites or tests only when the diff itself leaves a concrete compatibility question.\n") + "5. If the delta does not produce a qualifying finding under the selected review instructions, submit no findings.\n\n";
   }
   let embeddedDiffSection;
   let diffFetchInstructions;
@@ -127,7 +951,7 @@ ${changedFiles.map((file) => `- \`${file}\``).join("\n")}
       startInstruction = "Analyze the diff above and call `submit_review` now, in this turn.";
     } else {
       reviewProcessSection = "## Review Process\n\n1. Analyze the embedded diff above thoroughly\n2. Use `grep` to search for patterns when needed\n3. Use bounded line-range reads when surrounding context is essential; avoid reading entire large files\n4. Do not repeat a diff, grep, or read operation whose result is already in context\n5. Submit your review using `submit_review`\n";
-      startInstruction = previousReviewSha ? "Analyze only the incremental diff provided above. If it is self-contained, submit your review without extra tool calls." : "Analyze the diff provided above, then submit your review using `submit_review`.";
+      startInstruction = hasPreviousReviewDelta ? "Analyze only the incremental diff provided above. If it is self-contained, submit your review without extra tool calls." : "Analyze the diff provided above, then submit your review using `submit_review`.";
     }
   } else {
     embeddedDiffSection = "";
@@ -157,12 +981,13 @@ ${changedFiles.map((file) => `- \`${file}\``).join("\n")}
   }
   runtimeToolsSection = oneTurn ? "## Runtime Tools\n\n- `submit_review` submits the completed review. It is the only tool available for this review.\n" : `## Runtime Tools
 
+This list is exhaustive. No other tool is available.
+
 - \`${prDiffCmd}\` lists the changed files when a diff is not embedded.
 - \`${gitDiffCmd} -- path/to/file\` shows the delta for one changed file.
 - \`read\` provides bounded surrounding context.
 - \`grep\` searches for directly relevant code and contracts.
-- \`submit_review\` submits the completed review.
-`;
+` + (findToolAvailable ? "- `find` locates files by glob when the path is unknown.\n" : "") + "- `ls` lists the entries of one directory.\n- `bash` runs the git diff commands above and other read-only shell inspection.\n- `submit_review` submits the completed review.\n";
   return templateText.replace(/\{pr_url\}/g, prUrl).replace(/\{pr_diff_cmd\}/g, prDiffCmd).replace(/\{git_diff_cmd\}/g, gitDiffCmd).replace(/\{mr_context_section\}/g, contextSection).replace(/\{mr_notes_section\}/g, notesSection).replace(/\{mr_reminder_section\}/g, reminderSection).replace(/\{incremental_section\}/g, incrementalSection).replace(/\{embedded_diff_section\}/g, embeddedDiffSection).replace(/\{diff_fetch_instructions\}/g, diffFetchInstructions).replace(/\{runtime_tools_section\}/g, runtimeToolsSection).replace(/\{review_process_section\}/g, reviewProcessSection).replace(/\{start_instruction\}/g, startInstruction);
 }
 function buildMrSections(mrMetadata) {
@@ -314,6 +1139,31 @@ function parseModelString(model) {
   }
   return { provider: "anthropic", modelId: trimmed };
 }
+var BEDROCK_REGIONAL_PREFIXES = ["global", "us", "eu", "apac", "in", "jp", "au", "ca"];
+function stripBedrockRegionalPrefix(modelId) {
+  const dot = modelId.indexOf(".");
+  if (dot <= 0) return null;
+  const prefix = modelId.slice(0, dot).toLowerCase();
+  if (!BEDROCK_REGIONAL_PREFIXES.includes(prefix)) return null;
+  return modelId.slice(dot + 1);
+}
+function isOpenAiBedrockModel(model) {
+  if (model.provider !== "amazon-bedrock") return false;
+  return [model.id, model.name].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes("openai"));
+}
+function addOpenAiBedrockReasoning(payload, effort) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return payload;
+  const request = payload;
+  const existingFields = request.additionalModelRequestFields;
+  const additionalModelRequestFields = existingFields && typeof existingFields === "object" && !Array.isArray(existingFields) ? existingFields : {};
+  return {
+    ...request,
+    additionalModelRequestFields: {
+      ...additionalModelRequestFields,
+      reasoning: { effort }
+    }
+  };
+}
 function extractBedrockArnRegion(arn) {
   const parts = arn.split(":");
   return parts.length >= 4 && parts[3] ? parts[3] : "us-east-1";
@@ -413,7 +1263,7 @@ function getApiKey(model) {
 }
 
 // src/metrics.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 function tok(value) {
   if (value >= 1e6) return `${(value / 1e6).toFixed(2)}M`;
   if (value >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
@@ -447,9 +1297,9 @@ function formatMetricsMarkdown(metrics) {
   return lines.join("\n");
 }
 function printMetrics(metrics, stream = process.stderr) {
-  const dim = chalk.dim;
-  const bold = chalk.bold;
-  const cyan = chalk.cyan;
+  const dim = chalk2.dim;
+  const bold = chalk2.bold;
+  const cyan = chalk2.cyan;
   const write = (line) => stream.write(line + "\n");
   write("");
   write(dim("\u2500".repeat(50)));
@@ -655,7 +1505,7 @@ The selected review instructions and additional instructions are reviewer policy
 
 ## Read-Only Review
 
-Analyze only the changed delta and report findings at changed-line locations. Do not modify or create files, commit, install dependencies, run package managers, or write plans or agent instructions. Do not review unrelated files or report issues that exist only because the branch lacks changes already present on the target branch.
+Analyze only the changed delta and report findings at changed-line locations. Do not modify or create files, commit, install dependencies, run package managers, or write plans or agent instructions. Do not build, compile, run tests, or run linters or formatters. The review environment is a read-only inspection container: language toolchains, compilers, and test runners are not installed, and their absence is never a finding. Establish every finding by reading the delta and the code around it. Do not review unrelated files or report issues that exist only because the branch lacks changes already present on the target branch.
 
 ## Priority Mapping
 
@@ -668,7 +1518,7 @@ Every finding title begins with its matching [P0], [P1], [P2], or [P3] tag, and
 
 ## Tool Discipline and Efficiency
 
-Use available tools only when they establish evidence for the changed delta. Start with the runtime task's supplied diff or changed-file command. Use bounded reads and targeted searches for directly relevant context; avoid redundant reads, searches, and diffs. Scale investigation to the delta size. Do not use unavailable tools or substitute shell commands for supplied file-search tools.
+Use available tools only when they establish evidence for the changed delta. Start with the runtime task's supplied diff or changed-file command. Use bounded reads and targeted searches for directly relevant context; avoid redundant reads, searches, and diffs. Never repeat a read, search, or diff whose result is already in context, and prefer a scoped diff or bounded read over one that returns the whole change or the whole file. Scale investigation to the delta size. The runtime task's tool list is exhaustive: do not call a tool it does not name, and do not probe for executables through the shell to discover what else exists. Do not substitute shell commands for supplied file-search tools.
 
 ## Submission
 
@@ -820,9 +1670,101 @@ function parsePositiveNumber(raw, kind, prUrl, segment) {
   return number;
 }
 
-// src/publisher.ts
+// src/review-state.ts
 import { createHash } from "crypto";
 
+// src/utils/path.ts
+function relativizeWorkspacePath(absolutePath, workspacePrefix) {
+  let filePath = absolutePath;
+  const prefix = workspacePrefix ?? process.env.CI_PROJECT_DIR;
+  if (prefix) {
+    const trimmed = prefix.replace(/\/+$/, "");
+    if (filePath.startsWith(`${trimmed}/`)) {
+      return filePath.slice(trimmed.length + 1);
+    }
+  }
+  const buildsMatch = filePath.match(/\/builds\/[^/]+\/[^/]+\/(.+)/);
+  if (buildsMatch) return buildsMatch[1];
+  if (filePath.includes("/workspace/")) {
+    return filePath.slice(filePath.indexOf("/workspace/") + "/workspace/".length);
+  }
+  const stripped = filePath.replace(/^.*\/hodor-review-[^/]+\//, "");
+  return stripped !== filePath ? stripped : filePath;
+}
+
+// src/review-state.ts
+var FINDING_MARKER_RE = /<!--\s*hodor:finding:([a-f0-9]{64})\s*-->/i;
+var FINDING_TITLE_RE = /^\*\*(\[P([0-3])\]\s+.+)\*\*\s*$/m;
+function getFindingFingerprint(finding, workspacePath) {
+  const path = relativizeWorkspacePath(
+    finding.code_location.absolute_file_path,
+    workspacePath ?? void 0
+  );
+  const title = finding.title.replace(/^\[P[0-3]\]\s*/, "").trim().toLowerCase();
+  return createHash("sha256").update(`${path}
+${title}`).digest("hex");
+}
+function getDiscussionFingerprint(body) {
+  return body.match(FINDING_MARKER_RE)?.[1]?.toLowerCase() ?? null;
+}
+function parseDiscussionFinding(discussion) {
+  const fingerprint = getDiscussionFingerprint(discussion.body);
+  const titleMatch = discussion.body.match(FINDING_TITLE_RE);
+  if (!fingerprint || !titleMatch) return null;
+  const titleLineEnd = discussion.body.indexOf("\n", titleMatch.index ?? 0);
+  const remainder = titleLineEnd >= 0 ? discussion.body.slice(titleLineEnd + 1).trim() : "";
+  const suggestionStart = remainder.indexOf("\n\n```suggestion");
+  const body = (suggestionStart >= 0 ? remainder.slice(0, suggestionStart) : remainder).trim();
+  const priority = Number(titleMatch[2]);
+  return {
+    fingerprint,
+    title: titleMatch[1],
+    body,
+    priority,
+    filePath: discussion.filePath,
+    lineRange: discussion.line == null ? void 0 : { start: discussion.line, end: discussion.line }
+  };
+}
+function mergeReviewStateFindings(currentFindings, discussions, workspacePath, options = {}) {
+  const { includeExisting = true, suppressResolvedCurrent = false } = options;
+  const merged = /* @__PURE__ */ new Map();
+  const openFingerprints = /* @__PURE__ */ new Set();
+  const resolvedFingerprints = /* @__PURE__ */ new Set();
+  for (const discussion of discussions) {
+    const fingerprint = getDiscussionFingerprint(discussion.body);
+    if (!fingerprint) continue;
+    if (discussion.resolved) resolvedFingerprints.add(fingerprint);
+    else openFingerprints.add(fingerprint);
+  }
+  for (const finding of currentFindings) {
+    const fingerprint = getFindingFingerprint(finding, workspacePath);
+    if (suppressResolvedCurrent && resolvedFingerprints.has(fingerprint) && !openFingerprints.has(fingerprint)) {
+      continue;
+    }
+    merged.set(fingerprint, {
+      fingerprint,
+      title: finding.title,
+      body: finding.body,
+      priority: finding.priority,
+      filePath: relativizeWorkspacePath(
+        finding.code_location.absolute_file_path,
+        workspacePath ?? void 0
+      ),
+      lineRange: finding.code_location.line_range
+    });
+  }
+  if (includeExisting) {
+    for (const discussion of discussions) {
+      if (discussion.resolved) continue;
+      const finding = parseDiscussionFinding(discussion);
+      if (finding && !merged.has(finding.fingerprint)) {
+        merged.set(finding.fingerprint, finding);
+      }
+    }
+  }
+  return [...merged.values()];
+}
+
 // src/gitea.ts
 var GiteaAPIError = class extends Error {
   constructor(message) {
@@ -830,7 +1772,7 @@ var GiteaAPIError = class extends Error {
     this.name = "GiteaAPIError";
   }
 };
-function normalizeBaseUrl(host) {
+function normalizeBaseUrl2(host) {
   const candidate = host || process.env.GITEA_HOST || process.env.FORGEJO_HOST;
   if (!candidate) {
     throw new GiteaAPIError(
@@ -856,7 +1798,7 @@ function requireGiteaToken() {
   return token;
 }
 async function giteaFetch(host, path, options) {
-  const baseUrl = normalizeBaseUrl(host);
+  const baseUrl = normalizeBaseUrl2(host);
   const url = `${baseUrl}/api/v1/${path}`;
   const token = giteaToken();
   const headers = {
@@ -986,23 +1928,10 @@ async function postGiteaPrComment(owner, repo, prNumber, body, host) {
 }
 
 // src/publisher.ts
-var FINDING_MARKER_RE = /<!--\s*hodor:finding:([a-f0-9]{64})\s*-->/i;
-function getFindingFingerprint(finding, workspacePath) {
-  const path = relativizeWorkspacePath(
-    finding.code_location.absolute_file_path,
-    workspacePath ?? void 0
-  );
-  const title = finding.title.replace(/^\[P[0-3]\]\s*/, "").trim().toLowerCase();
-  return createHash("sha256").update(`${path}
-${title}`).digest("hex");
-}
-function getDiscussionFingerprint(body) {
-  return body.match(FINDING_MARKER_RE)?.[1]?.toLowerCase() ?? null;
-}
-async function postGitlabReviewCommitStatus(parsed, review, diffRefs) {
-  const blocking = review.findings.filter((finding) => finding.priority <= 1).length;
+async function postGitlabReviewCommitStatus(parsed, findings, diffRefs) {
+  const blocking = findings.filter((finding) => finding.priority <= 1).length;
   const state = blocking > 0 ? "failed" : "success";
-  const description = blocking > 0 ? `${blocking} blocking issue(s) found` : review.findings.length > 0 ? `${review.findings.length} non-blocking issue(s)` : "No issues found";
+  const description = blocking > 0 ? `${blocking} blocking issue(s) found` : findings.length > 0 ? `${findings.length} non-blocking issue(s)` : "No issues found";
   await postGitlabCommitStatus(
     parsed.owner,
     parsed.repo,
@@ -1012,23 +1941,38 @@ async function postGitlabReviewCommitStatus(parsed, review, diffRefs) {
     { description }
   );
 }
+function appendReviewDetails(body, model, metricsFooter) {
+  if (!model && !metricsFooter) return body;
+  const details = ["<details>", "<summary>Review details</summary>", ""];
+  if (model) details.push(`- Model: \`${model}\``);
+  if (metricsFooter) {
+    if (model) details.push("");
+    details.push(metricsFooter);
+  }
+  details.push("", "</details>");
+  return `${body.trimEnd()}
+
+${details.join("\n")}
+`;
+}
 async function postReviewComment(opts) {
   const { prUrl, reviewText, model, metricsFooter, headSha, cacheMarker } = opts;
   const platform = detectPlatform(prUrl);
   const parsed = parsePrUrl(prUrl);
   let body = reviewText;
+  if (platform === "gitlab" && !body.includes(HODOR_SUMMARY_MARKER)) {
+    body = body.replace(
+      HODOR_REVIEW_MARKER,
+      `${HODOR_REVIEW_MARKER}
+${HODOR_SUMMARY_MARKER}`
+    );
+  }
   if (headSha) body = `<!-- hodor:sha:${headSha} -->
 ${body}`;
   if (cacheMarker) body = body.replace("\n", `
 ${cacheMarker}
 `);
-  if (model) body += `
----
-
-Review generated by Hodor (model: \`${model}\`)`;
-  if (metricsFooter) body += `
-
-${metricsFooter}`;
+  body = appendReviewDetails(body, model, metricsFooter);
   try {
     if (platform === "github") {
       await exec("gh", [
@@ -1053,7 +1997,7 @@ ${metricsFooter}`;
       );
       return { success: true, platform, prNumber: parsed.prNumber };
     }
-    await postGitlabMrComment(
+    await upsertGitlabMrSummary(
       parsed.owner,
       parsed.repo,
       parsed.prNumber,
@@ -1084,10 +2028,13 @@ async function postReviewStructured(opts) {
     workspacePath,
     reconcileDiscussions = false,
     cacheMarker,
-    skipSummary = false
+    skipSummary = false,
+    existingDiscussions,
+    skipInline = false,
+    reviewMode
   } = opts;
   const platform = detectPlatform(prUrl);
-  if (platform !== "gitlab" || reviewStyle === "summary") {
+  if (platform !== "gitlab") {
     return postReviewComment({
       prUrl,
       reviewText: renderMarkdown(review),
@@ -1120,13 +2067,17 @@ async function postReviewStructured(opts) {
     });
   }
   const existingByFingerprint = /* @__PURE__ */ new Map();
+  let discussions = existingDiscussions ?? [];
+  let discussionListingFailed = false;
   try {
-    const discussions = await listHodorDiscussions(
-      parsed.owner,
-      parsed.repo,
-      parsed.prNumber,
-      parsed.host
-    );
+    if (!existingDiscussions) {
+      discussions = await listHodorDiscussions(
+        parsed.owner,
+        parsed.repo,
+        parsed.prNumber,
+        parsed.host
+      );
+    }
     for (const discussion of discussions) {
       if (discussion.resolved) continue;
       const fingerprint = getDiscussionFingerprint(discussion.body);
@@ -1136,63 +2087,77 @@ async function postReviewStructured(opts) {
       existingByFingerprint.set(fingerprint, ids);
     }
   } catch (error) {
+    discussionListingFailed = true;
     const message = error instanceof Error ? error.message : String(error);
-    if (reconcileDiscussions) {
+    if (reconcileDiscussions || commitStatus) {
       errors.push(`discussion listing: ${message}`);
     }
-    logger.warn(`Failed to list open Hodor discussions for deduplication: ${message}`);
+    logger.warn(`Failed to list open Hodor discussions for review state: ${message}`);
   }
+  const reviewFindings = mergeReviewStateFindings(
+    review.findings,
+    discussions,
+    workspacePath,
+    {
+      includeExisting: !reconcileDiscussions,
+      suppressResolvedCurrent: skipInline
+    }
+  );
   let inlineCreated = 0;
   let inlineFailed = 0;
   let inlineDeduplicated = 0;
   const draftNoteIds = [];
-  for (const finding of review.findings) {
-    const fingerprint = getFindingFingerprint(finding, workspacePath);
-    if (existingByFingerprint.has(fingerprint)) {
-      inlineDeduplicated++;
-      continue;
-    }
-    const relPath = relativizeWorkspacePath(
-      finding.code_location.absolute_file_path,
-      workspacePath ?? void 0
-    );
-    const title = /^\[P[0-3]\]/.test(finding.title) ? finding.title : `[P${finding.priority}] ${finding.title}`;
-    let body = `${HODOR_REVIEW_MARKER}
+  const failedFindings = [];
+  if (reviewStyle !== "summary" && !skipInline) {
+    for (const finding of review.findings) {
+      const fingerprint = getFindingFingerprint(finding, workspacePath);
+      if (existingByFingerprint.has(fingerprint)) {
+        inlineDeduplicated++;
+        continue;
+      }
+      const relPath = relativizeWorkspacePath(
+        finding.code_location.absolute_file_path,
+        workspacePath ?? void 0
+      );
+      const title = /^\[P[0-3]\]/.test(finding.title) ? finding.title : `[P${finding.priority}] ${finding.title}`;
+      let body = `${HODOR_REVIEW_MARKER}
 <!-- hodor:finding:${fingerprint} -->
 **${title}**
 
 ${finding.body}`;
-    if (finding.suggestion) {
-      const { start, end } = finding.code_location.line_range;
-      const span = Math.max(0, end - start);
-      body += `
+      if (finding.suggestion) {
+        const { start, end } = finding.code_location.line_range;
+        const span = Math.max(0, end - start);
+        body += `
 
 \`\`\`suggestion:-0+${span}
 ${finding.suggestion}
 \`\`\``;
-    }
-    try {
-      const draftNote = await createGitlabDraftNote(
-        parsed.owner,
-        parsed.repo,
-        parsed.prNumber,
-        body,
-        parsed.host,
-        {
-          filePath: relPath,
-          line: finding.code_location.line_range.start,
-          diffRefs
+      }
+      try {
+        const draftNote = await createGitlabDraftNote(
+          parsed.owner,
+          parsed.repo,
+          parsed.prNumber,
+          body,
+          parsed.host,
+          {
+            filePath: relPath,
+            line: finding.code_location.line_range.start,
+            diffRefs
+          }
+        );
+        if (typeof draftNote.id === "number" || typeof draftNote.id === "string") {
+          draftNoteIds.push(draftNote.id);
         }
-      );
-      if (typeof draftNote.id === "number" || typeof draftNote.id === "string") {
-        draftNoteIds.push(draftNote.id);
+        inlineCreated++;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`inline note for ${finding.title}: ${message}`);
+        logger.warn(`Failed to create inline note for "${finding.title}": ${message}`);
+        inlineFailed++;
+        failedFindings.push(finding);
       }
-      inlineCreated++;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      errors.push(`inline note for ${finding.title}: ${message}`);
-      logger.warn(`Failed to create inline note for "${finding.title}": ${message}`);
-      inlineFailed++;
     }
   }
   logger.info(
@@ -1239,22 +2204,24 @@ ${finding.suggestion}
     }
   }
   let summaryPosted = false;
-  if (!skipSummary && (reviewStyle === "hybrid" || review.findings.length === 0)) {
-    let summaryBody = renderSummaryMarkdown(review);
+  if (!skipSummary && (reviewStyle === "summary" || reviewStyle === "hybrid" || review.findings.length === 0 || failedFindings.length > 0)) {
+    const fallbackFindings = reviewStyle === "summary" ? review.findings : failedFindings;
+    let summaryBody = renderSummaryMarkdown(review, {
+      openFindings: reviewFindings,
+      fallbackFindings,
+      fallbackHeading: reviewStyle === "summary" ? "Findings" : "Findings not posted inline",
+      inlineCreated: reviewStyle === "summary" ? void 0 : inlineCreated,
+      inlineDeduplicated: reviewStyle === "summary" ? void 0 : inlineDeduplicated,
+      reviewMode
+    });
     if (headSha) summaryBody = `<!-- hodor:sha:${headSha} -->
 ${summaryBody}`;
     if (cacheMarker) summaryBody = summaryBody.replace("\n", `
 ${cacheMarker}
 `);
-    if (model) summaryBody += `
----
-
-Review generated by Hodor (model: \`${model}\`)`;
-    if (metricsFooter) summaryBody += `
-
-${metricsFooter}`;
+    summaryBody = appendReviewDetails(summaryBody, model, metricsFooter);
     try {
-      await postGitlabMrComment(
+      await upsertGitlabMrSummary(
         parsed.owner,
         parsed.repo,
         parsed.prNumber,
@@ -1265,13 +2232,13 @@ ${metricsFooter}`;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       errors.push(`summary comment: ${message}`);
-      logger.warn(`Failed to post summary comment: ${message}`);
+      logger.warn(`Failed to upsert summary comment: ${message}`);
     }
   }
   let commitStatusPosted = false;
-  if (commitStatus) {
+  if (commitStatus && (!discussionListingFailed || reconcileDiscussions)) {
     try {
-      await postGitlabReviewCommitStatus(parsed, review, diffRefs);
+      await postGitlabReviewCommitStatus(parsed, reviewFindings, diffRefs);
       commitStatusPosted = true;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -1280,7 +2247,7 @@ ${metricsFooter}`;
     }
   }
   let reconciledDiscussions = 0;
-  const baseDeliveryComplete = reviewStyle === "hybrid" ? (summaryPosted || skipSummary) && inlineFailed === 0 && (inlineCreated === 0 || draftsPublished) : inlineFailed === 0 && (review.findings.length === 0 ? summaryPosted : inlineCreated === 0 || draftsPublished);
+  const baseDeliveryComplete = reviewStyle === "summary" ? summaryPosted || skipSummary : reviewStyle === "hybrid" ? (summaryPosted || skipSummary) && (inlineCreated === 0 || draftsPublished) : (inlineFailed === 0 || summaryPosted) && (inlineCreated === 0 || draftsPublished) && (review.findings.length > 0 || summaryPosted);
   if (reconcileDiscussions && baseDeliveryComplete) {
     const currentFingerprints = new Set(
       review.findings.map((finding) => getFindingFingerprint(finding, workspacePath))
@@ -1313,13 +2280,15 @@ ${metricsFooter}`;
     inlineFailed,
     draftsPublished,
     commitStatusPosted,
-    reconciledDiscussions
+    reconciledDiscussions,
+    reviewStateComplete: !discussionListingFailed || reconcileDiscussions,
+    reviewFindings
   };
 }
 
 // src/agent.ts
 import { existsSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import {
   createAgentSession,
   DefaultResourceLoader,
@@ -1427,7 +2396,7 @@ function githubCommentsToNotes(comments) {
 // src/workspace.ts
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 var WorkspaceError = class extends Error {
   constructor(message) {
     super(message);
@@ -1486,6 +2455,31 @@ async function detectCiWorkspace(owner, repo) {
   }
   return { path: null, targetBranch: null, diffBaseSha: null };
 }
+async function resolveGitlabDiffBaseSha(workspace, targetBranch, fallbackSha) {
+  if (!targetBranch) return fallbackSha;
+  try {
+    await exec("git", ["fetch", "--no-tags", "origin", targetBranch], { cwd: workspace });
+    const { stdout } = await exec("git", ["merge-base", "HEAD", "FETCH_HEAD"], { cwd: workspace });
+    const mergeBase = stdout.trim();
+    if (mergeBase) {
+      logger.info(`Calculated current GitLab MR diff base: ${mergeBase.slice(0, 8)}`);
+      return mergeBase;
+    }
+  } catch (err) {
+    logger.warn(`Could not calculate current GitLab MR diff base: ${err}`);
+  }
+  try {
+    const { stdout } = await exec("git", ["merge-base", "HEAD", `origin/${targetBranch}`], { cwd: workspace });
+    const mergeBase = stdout.trim();
+    if (mergeBase) {
+      logger.info(`Calculated GitLab MR diff base from origin/${targetBranch}: ${mergeBase.slice(0, 8)}`);
+      return mergeBase;
+    }
+  } catch {
+  }
+  if (fallbackSha) logger.warn(`Falling back to CI_MERGE_REQUEST_DIFF_BASE_SHA: ${fallbackSha.slice(0, 8)}`);
+  return fallbackSha;
+}
 function normalizeGitRemotePath(remoteUrl) {
   const trimmed = remoteUrl.trim().replace(/\.git$/, "");
   try {
@@ -1700,16 +2694,23 @@ async function setupWorkspace(opts) {
   try {
     const ci = await detectCiWorkspace(owner, repo);
     let detectedTargetBranch = ci.targetBranch;
-    const detectedDiffBaseSha = ci.diffBaseSha;
+    let detectedDiffBaseSha = ci.diffBaseSha;
     let workspace;
     let isTemporary = false;
     if (ci.path) {
       workspace = ci.path;
+      if (platform === "gitlab" && ci.targetBranch) {
+        detectedDiffBaseSha = await resolveGitlabDiffBaseSha(
+          workspace,
+          ci.targetBranch,
+          detectedDiffBaseSha
+        );
+      }
       if (platform === "github" && !detectedTargetBranch) {
         detectedTargetBranch = await getGithubBaseBranch(workspace, prNumber);
       }
     } else if (!workingDir) {
-      workspace = await mkdtemp(join(tmpdir(), "hodor-review-"));
+      workspace = await mkdtemp(join2(tmpdir(), "hodor-review-"));
       isTemporary = true;
       logger.info(`Created temporary workspace: ${workspace}`);
     } else {
@@ -1954,118 +2955,6 @@ function resolveReviewLocations(review, opts) {
   return { review: { ...review, findings }, stats };
 }
 
-// src/review-diff.ts
-var HODOR_REVIEW_SHA_RE = /^\s*<!--\s*hodor:sha:([a-f0-9]{40})\s*-->/i;
-function getHodorReviewShaCandidates(notes) {
-  if (!notes || notes.length === 0) return [];
-  const candidates = [];
-  for (const [index, note] of notes.entries()) {
-    const match = note.body?.match(HODOR_REVIEW_SHA_RE);
-    if (!match) continue;
-    const createdAtMs = Date.parse(note.created_at ?? "");
-    candidates.push({
-      sha: match[1],
-      createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : null,
-      index
-    });
-  }
-  candidates.sort((a, b) => {
-    if (a.createdAtMs != null && b.createdAtMs != null && a.createdAtMs !== b.createdAtMs) {
-      return b.createdAtMs - a.createdAtMs;
-    }
-    if (a.createdAtMs != null && b.createdAtMs == null) return -1;
-    if (a.createdAtMs == null && b.createdAtMs != null) return 1;
-    return a.index - b.index;
-  });
-  return [...new Set(candidates.map(({ sha }) => sha))];
-}
-async function findLatestReviewBase(notes, workspacePath) {
-  const candidates = getHodorReviewShaCandidates(notes);
-  if (candidates.length === 0) return null;
-  logger.info(`Found ${candidates.length} previous Hodor review marker(s)`);
-  for (const sha of candidates) {
-    try {
-      let objectType;
-      try {
-        ({ stdout: objectType } = await exec("git", ["cat-file", "-t", sha], {
-          cwd: workspacePath
-        }));
-      } catch {
-        await exec("git", ["fetch", "--quiet", "origin", sha], {
-          cwd: workspacePath
-        });
-        ({ stdout: objectType } = await exec("git", ["cat-file", "-t", sha], {
-          cwd: workspacePath
-        }));
-      }
-      if (objectType.trim() !== "commit") throw new Error("not a commit");
-      try {
-        await exec("git", ["merge-base", "--is-ancestor", sha, "HEAD"], {
-          cwd: workspacePath
-        });
-        return { sha, mode: "incremental" };
-      } catch {
-        logger.info(
-          `Previous review SHA ${sha.slice(0, 8)} is not an ancestor; using snapshot delta`
-        );
-        return { sha, mode: "snapshot" };
-      }
-    } catch {
-      logger.info(
-        `Skipping previous review SHA ${sha.slice(0, 8)}; commit is unavailable`
-      );
-    }
-  }
-  return null;
-}
-function getDiffStats(diff) {
-  let files = 0;
-  let additions = 0;
-  let deletions = 0;
-  for (const line of diff.split("\n")) {
-    if (line.startsWith("diff --git ")) files++;
-    else if (line.startsWith("+") && !line.startsWith("+++")) additions++;
-    else if (line.startsWith("-") && !line.startsWith("---")) deletions++;
-  }
-  return {
-    files,
-    additions,
-    deletions,
-    bytes: Buffer.byteLength(diff, "utf-8")
-  };
-}
-function getChangedFiles(diff) {
-  const files = [];
-  for (const match of diff.matchAll(/^diff --git a\/(.*?) b\/(.*?)$/gm)) {
-    files.push(match[2]);
-  }
-  return [...new Set(files)];
-}
-var DIFF_SKIP_PATTERNS = [
-  /(?:^|\/)testdata\//,
-  /(?:^|\/)(?:package-lock\.json|yarn\.lock|pnpm-lock\.yaml|go\.sum|Cargo\.lock|poetry\.lock|Gemfile\.lock|composer\.lock)$/,
-  /\.mdx?$/
-];
-function filterEmbeddedDiff(rawDiff) {
-  const skippedFiles = [];
-  const sections = rawDiff.split(/(?=^diff --git )/m);
-  const kept = [];
-  for (const section of sections) {
-    const match = section.match(/^diff --git a\/(.*?) b\//);
-    if (!match) {
-      kept.push(section);
-      continue;
-    }
-    const filePath = match[1];
-    if (DIFF_SKIP_PATTERNS.some((pattern) => pattern.test(filePath))) {
-      skippedFiles.push(filePath);
-    } else {
-      kept.push(section);
-    }
-  }
-  return { filtered: kept.join(""), skippedFiles };
-}
-
 // src/review-cache.ts
 import { createHash as createHash2 } from "crypto";
 import { gzipSync, gunzipSync } from "zlib";
@@ -2104,7 +2993,7 @@ function buildReviewCacheMarker(key, review, workspacePath) {
 function findCachedReview(notes, key) {
   if (!notes) return null;
   const newestFirst = [...notes].sort(
-    (a, b) => Date.parse(b.created_at ?? "") - Date.parse(a.created_at ?? "")
+    (a, b) => Date.parse(b.updated_at ?? b.created_at ?? "") - Date.parse(a.updated_at ?? a.created_at ?? "")
   );
   for (const note of newestFirst) {
     const encoded = note.body?.match(CACHE_MARKER_RE)?.[1];
@@ -2258,7 +3147,22 @@ async function reviewPr(opts) {
       );
     }
   } else if (!piModel) {
-    if (parsed.provider === "openrouter") {
+    if (parsed.provider === "amazon-bedrock") {
+      const inferredBaseModelId = stripBedrockRegionalPrefix(parsed.modelId);
+      const baseModelId = parsed.baseModelId ?? inferredBaseModelId;
+      const baseModel = baseModelId ? modelRuntime.getModel(parsed.provider, baseModelId) : void 0;
+      if (!baseModel) {
+        const hint = parsed.baseModelId ? `Base model "${parsed.baseModelId}" was not found in the installed pi-ai registry.` : `Append "@<base-model-id>" if this is a custom inference profile.`;
+        throw new Error(
+          `Unsupported Bedrock model "${parsed.modelId}". ${hint}`
+        );
+      }
+      const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1";
+      piModel = buildBedrockArnModel({ arn: parsed.modelId, baseModel, region });
+      logger.info(
+        `Regional bedrock model, region: ${region}, capabilities from ${baseModel.id}`
+      );
+    } else if (parsed.provider === "openrouter") {
       piModel = {
         id: parsed.modelId,
         name: parsed.modelId,
@@ -2459,7 +3363,14 @@ async function reviewPr(opts) {
     let diffStats = null;
     let changedFiles = [];
     try {
-      const diffArgs = previousReviewSha ? previousReviewBase?.mode === "snapshot" ? ["--no-pager", "diff", previousReviewSha, "HEAD"] : ["--no-pager", "diff", `${previousReviewSha}...HEAD`] : diffBaseSha ? ["--no-pager", "diff", diffBaseSha, "HEAD"] : localMode ? ["--no-pager", "diff", targetBranch] : ["--no-pager", "diff", `origin/${targetBranch}...HEAD`];
+      const diffArgs = getReviewDiffArgs({
+        platform,
+        targetBranch,
+        diffBaseSha,
+        previousReviewSha,
+        reviewDiffMode: previousReviewBase?.mode,
+        localMode
+      });
       const { stdout: rawDiff } = await exec("git", diffArgs, { cwd: workspacePath });
       const { filtered: filteredDiff, skippedFiles } = filterEmbeddedDiff(rawDiff);
       if (skippedFiles.length > 0) {
@@ -2498,6 +3409,10 @@ async function reviewPr(opts) {
         `Single-turn fast path: tiny low-risk diff (${diffStats?.files} file(s), ${(diffStats?.additions ?? 0) + (diffStats?.deletions ?? 0)} changed line(s)); exposing only submit_review`
       );
     }
+    const findToolAvailable = commandOnPath("fd") || commandOnPath("fdfind");
+    if (!findToolAvailable) {
+      logger.warn("fd not found on PATH; disabling the agent's `find` tool");
+    }
     const prompt = buildPrReviewPrompt({
       prUrl: prUrl ?? `local diff (against ${targetBranch})`,
       platform,
@@ -2509,13 +3424,14 @@ async function reviewPr(opts) {
       reviewDiffMode: reviewMode,
       changedFiles,
       localMode,
-      singleTurn
+      singleTurn,
+      findToolAvailable
     });
     const startTime = Date.now();
     const settingsManager = SettingsManager.inMemory({
       compaction: { enabled: true }
     });
-    const skillPaths = [join2(workspacePath, ".agents", "skills")].filter((p) => existsSync(p));
+    const skillPaths = [join3(workspacePath, ".agents", "skills")].filter((p) => existsSync(p));
     const resourceLoader = new DefaultResourceLoader({
       cwd: workspacePath,
       agentDir: getAgentDir(),
@@ -2588,7 +3504,14 @@ async function reviewPr(opts) {
       // (see _refreshToolRegistry in @earendil-works/pi-coding-agent's
       // agent-session.ts). The submit_review custom tool must be named here
       // or the LLM never sees it and the agent loop exits without calling it.
-      tools: singleTurn ? ["submit_review"] : ["read", "bash", "grep", "find", "ls", "submit_review"],
+      tools: singleTurn ? ["submit_review"] : [
+        "read",
+        "bash",
+        "grep",
+        ...findToolAvailable ? ["find"] : [],
+        "ls",
+        "submit_review"
+      ],
       customTools: [submitReviewTool],
       modelRuntime,
       sessionManager: SessionManager.inMemory(),
@@ -2596,14 +3519,29 @@ async function reviewPr(opts) {
       resourceLoader
     });
     activeSession = session;
-    if (bedrockTags && parsed.provider === "amazon-bedrock") {
+    const openAiReasoning = thinkingLevel && isOpenAiBedrockModel(piModel) ? thinkingLevel : void 0;
+    if (parsed.provider === "amazon-bedrock" && (bedrockTags || openAiReasoning)) {
       const agent = session.agent;
       const originalStreamFn = agent.streamFn;
       agent.streamFn = (...args) => {
         const options = args[2] ?? {};
-        return originalStreamFn(args[0], args[1], { ...options, requestMetadata: bedrockTags });
+        const originalOnPayload = options.onPayload;
+        const onPayload = openAiReasoning ? async (payload, model2) => {
+          const transformed = originalOnPayload ? await originalOnPayload(payload, model2) : void 0;
+          return addOpenAiBedrockReasoning(
+            transformed === void 0 ? payload : transformed,
+            openAiReasoning
+          );
+        } : originalOnPayload;
+        return originalStreamFn(args[0], args[1], {
+          ...options,
+          ...bedrockTags ? { requestMetadata: bedrockTags } : {},
+          ...onPayload ? { onPayload } : {}
+        });
       };
-      logger.info(`Bedrock cost allocation tags: ${JSON.stringify(bedrockTags)}`);
+      if (bedrockTags) {
+        logger.info(`Bedrock cost allocation tags: ${JSON.stringify(bedrockTags)}`);
+      }
     }
     let turnCount = 0;
     let toolCallCount = 0;
@@ -2804,6 +3742,10 @@ async function reviewPr(opts) {
 }
 
 export {
+  setLogLevel,
+  logger,
+  renderMarkdown,
+  listHodorDiscussions,
   buildPrReviewPrompt,
   parseModelString,
   mapReasoningEffort,
@@ -2820,9 +3762,9 @@ export {
   loadDefaultReviewInstructions,
   detectPlatform,
   parsePrUrl,
-  postGitlabReviewCommitStatus,
+  mergeReviewStateFindings,
   postReviewComment,
   postReviewStructured,
   reviewPr
 };
-//# sourceMappingURL=chunk-YKB3BRJM.js.map
+//# sourceMappingURL=chunk-AFEJ4DRL.js.map