@mrkaran/hodor 0.7.3 → 0.7.5

package/dist/{chunk-GISFKKMM.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";
@@ -56,19 +755,19 @@ function getHodorReviewShaCandidates(notes) {
   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 ?? "");
+    const reviewedAtMs = Date.parse(note.updated_at ?? note.created_at ?? "");
     candidates.push({
       sha: match[1],
-      createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : null,
+      reviewedAtMs: Number.isFinite(reviewedAtMs) ? reviewedAtMs : null,
       index
     });
   }
   candidates.sort((a, b) => {
-    if (a.createdAtMs != null && b.createdAtMs != null && a.createdAtMs !== b.createdAtMs) {
-      return b.createdAtMs - a.createdAtMs;
+    if (a.reviewedAtMs != null && b.reviewedAtMs != null && a.reviewedAtMs !== b.reviewedAtMs) {
+      return b.reviewedAtMs - a.reviewedAtMs;
     }
-    if (a.createdAtMs != null && b.createdAtMs == null) return -1;
-    if (a.createdAtMs == null && b.createdAtMs != null) return 1;
+    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))];
@@ -173,7 +872,8 @@ 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);
@@ -281,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) {
@@ -562,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`;
@@ -596,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)));
@@ -804,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
 
@@ -817,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
 
@@ -969,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) {
@@ -979,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(
@@ -1005,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 = {
@@ -1135,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,
@@ -1161,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", [
@@ -1202,7 +1997,7 @@ ${metricsFooter}`;
       );
       return { success: true, platform, prNumber: parsed.prNumber };
     }
-    await postGitlabMrComment(
+    await upsertGitlabMrSummary(
       parsed.owner,
       parsed.repo,
       parsed.prNumber,
@@ -1233,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),
@@ -1269,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);
@@ -1285,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(
@@ -1388,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,
@@ -1414,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);
@@ -1429,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))
@@ -1462,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,
@@ -1576,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);
@@ -1890,7 +2710,7 @@ async function setupWorkspace(opts) {
         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 {
@@ -2173,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];
@@ -2589,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,
@@ -2600,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(),
@@ -2679,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(),
@@ -2910,6 +3742,10 @@ async function reviewPr(opts) {
 }
 
 export {
+  setLogLevel,
+  logger,
+  renderMarkdown,
+  listHodorDiscussions,
   buildPrReviewPrompt,
   parseModelString,
   mapReasoningEffort,
@@ -2926,9 +3762,9 @@ export {
   loadDefaultReviewInstructions,
   detectPlatform,
   parsePrUrl,
-  postGitlabReviewCommitStatus,
+  mergeReviewStateFindings,
   postReviewComment,
   postReviewStructured,
   reviewPr
 };
-//# sourceMappingURL=chunk-GISFKKMM.js.map
+//# sourceMappingURL=chunk-AFEJ4DRL.js.map