@mrkaran/hodor 0.5.0 → 0.6.1

package/dist/{chunk-QGUJENIG.js → chunk-JSLG7EOX.js}

@@ -1,263 +1,29 @@
-// 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}
-`);
-    }
-  }
-};
+import {
+  HODOR_REVIEW_MARKER,
+  bulkPublishGitlabDraftNotes,
+  cleanupHodorComments,
+  createGitlabDraftNote,
+  exec,
+  execJson,
+  fetchGitlabMrInfo,
+  getGitlabMrDiffRefs,
+  listHodorDiscussions,
+  logger,
+  postGitlabCommitStatus,
+  postGitlabMrComment,
+  renderMarkdown,
+  renderSummaryMarkdown,
+  resolveGitlabDiscussions,
+  summarizeGitlabNotes
+} from "./chunk-DVJVQTVW.js";
+import {
+  relativizeWorkspacePath
+} from "./chunk-AMUK6GDX.js";
 
 // src/prompt.ts
 import { readFileSync } from "fs";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
-
-// src/utils/exec.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-async function exec(cmd, args, opts) {
-  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());
-}
-
-// src/gitlab.ts
-var DEFAULT_GITLAB_HOST = "gitlab.com";
-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) {
-    const parsed = JSON.parse(chunk);
-    if (Array.isArray(parsed)) {
-      results.push(...parsed);
-    }
-  }
-  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,
-        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",
-        "--field",
-        `body=${body}`
-      ],
-      { env }
-    );
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new GitLabAPIError(`Failed to post comment to MR !${mrNumber}: ${msg}`);
-  }
-}
-function summarizeGitlabNotes(notes, maxEntries = 5) {
-  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) {
-    const body = (note.body ?? "").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 indentedBody = body.split("\n").join("\n  ");
-    lines.push(`${header}
-  ${indentedBody}`);
-  }
-  return lines.join("\n");
-}
-
-// src/prompt.ts
 function getTemplatesDir() {
   const currentDir = dirname(fileURLToPath(import.meta.url));
   return resolve(currentDir, "..", "templates");
@@ -308,7 +74,7 @@ function buildPrReviewPrompt(opts) {
   } else if (localMode) {
     prDiffCmd = `git --no-pager diff ${targetBranch} --name-only`;
     gitDiffCmd = `git --no-pager diff ${targetBranch}`;
-  } else if (platform === "github") {
+  } 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 {
@@ -334,10 +100,14 @@ function buildPrReviewPrompt(opts) {
   if (previousReviewSha) {
     incrementalSection = `## Incremental Review Mode
 
-This is a follow-up review. A previous hodor review was done at commit \`${previousReviewSha.slice(0, 8)}\`. The diff below shows ONLY changes since that review. Focus on:
-1. New code changes introduced since the last review
-2. Whether previous findings (shown in MR notes above) are still applicable
-3. Do NOT re-report issues that are already mentioned in existing notes
+This is a follow-up review. A previous hodor review was done at commit \`${previousReviewSha.slice(0, 8)}\`. The diff below shows ONLY changes since that review. Your job is to review that delta, not the whole MR again.
+
+Rules for incremental reviews:
+1. Only report bugs introduced or still affected by the new delta.
+2. 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.
+3. If the delta is small and self-contained, decide from the embedded diff and submit the review without broad repository exploration.
+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.
+5. If the delta does not introduce a production bug, submit no findings.
 
 `;
   }
@@ -357,8 +127,8 @@ This is a follow-up review. A previous hodor review was done at commit \`${previ
 - NEVER flag "dependency version downgrade" (branch not rebased)
 - NEVER compare entire codebase to ${targetBranch} - DIFF ONLY
 `;
-    reviewProcessSection = "## Review Process\n\n1. Analyze the embedded diff above thoroughly\n2. Use `grep` to search for patterns if needed\n3. Use `read` only when surrounding context is essential\n4. Submit your review using `submit_review`\n";
-    startInstruction = "Analyze the diff provided above, then submit your review using `submit_review`.";
+    reviewProcessSection = "## Review Process\n\n1. Analyze the embedded diff above thoroughly\n2. Use `grep` to search for patterns when needed\n3. Use `read` only when surrounding context is essential\n4. 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`.";
   } else {
     embeddedDiffSection = "";
     diffFetchInstructions = "## Step 1: List Changed Files (MANDATORY FIRST STEP)\n\n**Run this command FIRST to get the list of changed files:**\n```bash\n" + prDiffCmd + "\n```\n\nThis lists ONLY the filenames changed in this PR. **Do NOT dump the entire diff here** - you'll inspect each file individually in Step 2. Only review files that appear in this output.\n\n## Step 2: Review Changed Files Only\n\n### Critical Rules\n- ONLY review files that appear in the diff from Step 1\n- ONLY analyze actual code changes (+ and - lines in the diff)\n- Use the most reliable diff command: `" + gitDiffCmd + `\`
@@ -489,22 +259,34 @@ function normalizeLabelNames(rawLabels) {
 }
 
 // src/model.ts
+import { getEnvApiKey, getProviders } from "@earendil-works/pi-ai";
+var PROVIDER_ALIASES = {
+  bedrock: "amazon-bedrock"
+};
 function parseModelString(model) {
   const trimmed = model.trim();
   if (!trimmed) throw new Error("Model name must be provided");
   const parts = trimmed.split("/");
   if (parts.length >= 2) {
     const first = parts[0].toLowerCase();
-    if (first === "bedrock") {
+    const provider = PROVIDER_ALIASES[first] ?? first;
+    const knownProviders = new Set(getProviders());
+    if (provider === "amazon-bedrock") {
       let modelId = parts.slice(1).join("/");
       if (modelId.startsWith("converse/")) {
         modelId = modelId.slice("converse/".length);
       }
-      return { provider: "amazon-bedrock", modelId };
+      return { provider, modelId };
+    }
+    if (knownProviders.has(provider)) {
+      return { provider, modelId: parts.slice(1).join("/") };
     }
-    if (["anthropic", "openai"].includes(first)) {
-      return { provider: first, modelId: parts.slice(1).join("/") };
+    if (provider === "openrouter") {
+      return { provider, modelId: parts.slice(1).join("/") };
     }
+    throw new Error(
+      `Unsupported provider "${first}". Use a pi-ai provider prefix such as anthropic/, openai/, openrouter/, google/, mistral/, xai/, or bedrock/.`
+    );
   }
   const lower = trimmed.toLowerCase();
   if (lower.includes("claude") || lower.includes("anthropic")) {
@@ -518,41 +300,44 @@ function parseModelString(model) {
 function mapReasoningEffort(effort) {
   if (!effort) return void 0;
   switch (effort.toLowerCase()) {
+    case "minimal":
+      return "minimal";
     case "low":
       return "low";
     case "medium":
       return "medium";
     case "high":
-    case "xhigh":
       return "high";
+    case "xhigh":
+      return "xhigh";
     default:
       return void 0;
   }
 }
+function normalizeModelMatchValue(value) {
+  return value.toLowerCase().replace(/[\s_.:/]+/g, "-");
+}
+function getDefaultReasoningEffortForModel(model) {
+  const values = [model.id, model.name].filter((value) => Boolean(value));
+  const isOpus47 = values.map(normalizeModelMatchValue).some((value) => value.includes("opus-4-7"));
+  return isOpus47 ? "xhigh" : void 0;
+}
 function getApiKey(model) {
   const llmKey = process.env.LLM_API_KEY;
   if (llmKey) return llmKey;
   if (model) {
     const { provider } = parseModelString(model);
     if (provider === "amazon-bedrock") return null;
-    if (provider === "anthropic") {
-      const key = process.env.ANTHROPIC_API_KEY;
-      if (key) return key;
-    }
-    if (provider === "openai") {
-      const key = process.env.OPENAI_API_KEY;
-      if (key) return key;
-    }
+    const key = getEnvApiKey(provider);
+    if (key) return key;
   }
-  if (process.env.ANTHROPIC_API_KEY) return process.env.ANTHROPIC_API_KEY;
-  if (process.env.OPENAI_API_KEY) return process.env.OPENAI_API_KEY;
   throw new Error(
-    "No LLM API key found. Please set one of: LLM_API_KEY, ANTHROPIC_API_KEY, or OPENAI_API_KEY"
+    model ? `No API key found for provider "${parseModelString(model).provider}". Set the provider-specific environment variable or LLM_API_KEY.` : "No LLM API key found. Please set LLM_API_KEY or a provider-specific environment variable."
   );
 }
 
 // src/metrics.ts
-import chalk2 from "chalk";
+import chalk from "chalk";
 function tok(value) {
   if (value >= 1e6) return `${(value / 1e6).toFixed(2)}M`;
   if (value >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
@@ -583,9 +368,9 @@ function formatMetricsMarkdown(metrics) {
   return lines.join("\n");
 }
 function printMetrics(metrics, stream = process.stderr) {
-  const dim = chalk2.dim;
-  const bold = chalk2.bold;
-  const cyan = chalk2.cyan;
+  const dim = chalk.dim;
+  const bold = chalk.bold;
+  const cyan = chalk.cyan;
   const write = (line) => stream.write(line + "\n");
   write("");
   write(dim("\u2500".repeat(50)));
@@ -607,10 +392,18 @@ function printMetrics(metrics, stream = process.stderr) {
   write(dim("\u2500".repeat(50)));
 }
 async function pushMetrics(opts) {
-  const { pushgatewayUrl, metrics, labels = {} } = opts;
-  const labelPairs = Object.entries(labels).map(([k, v]) => `${k}="${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`).join(",");
-  const labelSuffix = labelPairs ? `{${labelPairs}}` : "";
+  const { pushgatewayUrl, metrics, findings = [], labels = {} } = opts;
+  const formatLabels = (extraLabels = {}) => {
+    const labelPairs = Object.entries({ ...labels, ...extraLabels }).map(([k, v]) => `${k}="${v.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"')}"`).join(",");
+    return labelPairs ? `{${labelPairs}}` : "";
+  };
+  const labelSuffix = formatLabels();
   const totalInput = metrics.inputTokens + metrics.cacheReadTokens;
+  const cacheHitRatio = totalInput > 0 ? metrics.cacheReadTokens / totalInput : 0;
+  const priorityCounts = [0, 1, 2, 3].map((priority) => ({
+    priority,
+    count: findings.filter((finding) => finding.priority === priority).length
+  }));
   const lines = [
     `# HELP hodor_review_input_tokens_total Total input tokens (fresh + cached)`,
     `# TYPE hodor_review_input_tokens_total gauge`,
@@ -621,6 +414,17 @@ async function pushMetrics(opts) {
     `# HELP hodor_review_cache_read_tokens_total Tokens served from prompt cache`,
     `# TYPE hodor_review_cache_read_tokens_total gauge`,
     `hodor_review_cache_read_tokens_total${labelSuffix} ${metrics.cacheReadTokens}`,
+    `# HELP hodor_review_cache_write_tokens_total Tokens written to prompt cache`,
+    `# TYPE hodor_review_cache_write_tokens_total gauge`,
+    `hodor_review_cache_write_tokens_total${labelSuffix} ${metrics.cacheWriteTokens}`,
+    `# HELP hodor_review_cache_hit_ratio Fraction of input tokens served from cache (0-1)`,
+    `# TYPE hodor_review_cache_hit_ratio gauge`,
+    `hodor_review_cache_hit_ratio${labelSuffix} ${cacheHitRatio}`,
+    `# HELP hodor_review_findings_total Number of findings at each priority level`,
+    `# TYPE hodor_review_findings_total gauge`,
+    ...priorityCounts.map(
+      ({ priority, count }) => `hodor_review_findings_total${formatLabels({ priority: `P${priority}` })} ${count}`
+    ),
     `# HELP hodor_review_cost_dollars Cost of the review in USD`,
     `# TYPE hodor_review_cost_dollars gauge`,
     `hodor_review_cost_dollars${labelSuffix} ${metrics.cost}`,
@@ -637,7 +441,7 @@ async function pushMetrics(opts) {
   ];
   const body = lines.join("\n");
   const baseUrl = pushgatewayUrl.replace(/\/+$/, "");
-  const url = `${baseUrl}/metrics/job/hodor`;
+  const url = baseUrl.endsWith("/api/v1/import/prometheus") ? baseUrl : `${baseUrl}/metrics/job/hodor`;
   try {
     const res = await fetch(url, {
       method: "POST",
@@ -647,12 +451,12 @@ async function pushMetrics(opts) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      logger.warn(`Pushgateway returned ${res.status}: ${text.slice(0, 200)}`);
+      logger.warn(`Metrics endpoint returned ${res.status}: ${text.slice(0, 200)}`);
     } else {
-      logger.info("Metrics pushed to Pushgateway");
+      logger.info("Metrics pushed successfully");
     }
   } catch (err) {
-    logger.warn(`Failed to push metrics to Pushgateway: ${err instanceof Error ? err.message : err}`);
+    logger.warn(`Failed to push metrics: ${err instanceof Error ? err.message : err}`);
   }
 }
 
@@ -683,7 +487,8 @@ var REVIEW_FINDING_SCHEMA = Type.Object(
     title: Type.String({ minLength: 1 }),
     body: Type.String({ minLength: 1 }),
     priority: Type.Integer({ minimum: 0, maximum: 3 }),
-    code_location: REVIEW_LOCATION_SCHEMA
+    code_location: REVIEW_LOCATION_SCHEMA,
+    suggestion: Type.Optional(Type.String({ minLength: 1 }))
   },
   { additionalProperties: false }
 );
@@ -702,6 +507,11 @@ function validateReviewOutput(review) {
   if (review.overall_explanation.trim().length === 0) {
     throw new Error("submit_review overall_explanation must be non-empty");
   }
+  if (review.findings.length > 0 && review.overall_correctness !== "patch is incorrect") {
+    review = { ...review, overall_correctness: "patch is incorrect" };
+  } else if (review.findings.length === 0 && review.overall_correctness !== "patch is correct") {
+    review = { ...review, overall_correctness: "patch is correct" };
+  }
   for (const [index, finding] of review.findings.entries()) {
     const label = `submit_review finding ${index + 1}`;
     if (finding.title.trim().length === 0) {
@@ -738,6 +548,7 @@ function getPriorityFromTitle(title) {
 // src/agent.ts
 import { existsSync } from "fs";
 import { join as join2 } from "path";
+import { Value } from "@sinclair/typebox/value";
 
 // src/github.ts
 var GitHubAPIError = class extends Error {
@@ -828,6 +639,168 @@ function githubCommentsToNotes(comments) {
   });
 }
 
+// src/gitea.ts
+var GiteaAPIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GiteaAPIError";
+  }
+};
+function normalizeBaseUrl(host) {
+  const candidate = host || process.env.GITEA_HOST || process.env.FORGEJO_HOST;
+  if (!candidate) {
+    throw new GiteaAPIError(
+      "No Gitea/Forgejo host configured. Set GITEA_HOST or FORGEJO_HOST, or provide a full PR URL that includes the hostname."
+    );
+  }
+  const trimmed = candidate.trim();
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return trimmed.replace(/\/+$/, "");
+  }
+  return `https://${trimmed}`.replace(/\/+$/, "");
+}
+function giteaToken() {
+  return process.env.GITEA_TOKEN ?? process.env.FORGEJO_TOKEN ?? null;
+}
+function requireGiteaToken() {
+  const token = giteaToken();
+  if (!token) {
+    throw new GiteaAPIError(
+      "No Gitea/Forgejo token found. Set GITEA_TOKEN or FORGEJO_TOKEN environment variable."
+    );
+  }
+  return token;
+}
+async function giteaFetch(host, path, options) {
+  const baseUrl = normalizeBaseUrl(host);
+  const url = `${baseUrl}/api/v1/${path}`;
+  const token = giteaToken();
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  if (token) {
+    headers.Authorization = `token ${token}`;
+  }
+  const init = {
+    method: options?.method ?? "GET",
+    headers
+  };
+  if (options?.body) {
+    init.body = JSON.stringify(options.body);
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    if (response.status === 401 || response.status === 403) {
+      throw new GiteaAPIError(
+        `Authentication failed (${response.status}): check GITEA_TOKEN/FORGEJO_TOKEN. ${text}`
+      );
+    }
+    if (response.status === 429) {
+      throw new GiteaAPIError(`Rate limited by Gitea API (429). ${text}`);
+    }
+    throw new GiteaAPIError(
+      `Gitea API error ${response.status} for ${options?.method ?? "GET"} ${path}: ${text}`
+    );
+  }
+  return await response.json();
+}
+async function fetchGiteaPrInfo(owner, repo, prNumber, host, options) {
+  let prData;
+  try {
+    prData = await giteaFetch(
+      host,
+      `repos/${owner}/${repo}/pulls/${prNumber}`
+    );
+  } catch (err) {
+    if (err instanceof GiteaAPIError) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GiteaAPIError(`Failed to fetch PR #${prNumber}: ${msg}`);
+  }
+  const user = prData.user ?? {};
+  const head = prData.head ?? {};
+  const base = prData.base ?? {};
+  const labels = prData.labels ?? [];
+  const metadata = {
+    title: prData.title,
+    description: prData.body ?? "",
+    source_branch: head.ref,
+    target_branch: base.ref,
+    changes_count: prData.changed_files,
+    labels: labels.map((lbl) => ({ name: lbl.name })),
+    author: {
+      username: user.login,
+      name: user.full_name || user.login
+    },
+    state: prData.state
+  };
+  if (options?.includeComments) {
+    try {
+      metadata.Notes = await fetchGiteaPrComments(owner, repo, prNumber, host);
+    } catch (err) {
+      logger.warn(`Failed to fetch PR comments: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  return metadata;
+}
+async function fetchGiteaPrCheckoutInfo(owner, repo, prNumber, host) {
+  const prData = await giteaFetch(
+    host,
+    `repos/${owner}/${repo}/pulls/${prNumber}`
+  );
+  const head = prData.head ?? {};
+  const base = prData.base ?? {};
+  const headRepo = head.repo ?? null;
+  const sourceBranch = head.ref;
+  if (!sourceBranch) {
+    throw new GiteaAPIError(`Could not determine source branch for PR #${prNumber}`);
+  }
+  return {
+    sourceBranch,
+    targetBranch: base.ref ?? "main",
+    sourceCloneUrl: headRepo?.clone_url
+  };
+}
+async function fetchGiteaPrComments(owner, repo, prNumber, host) {
+  const comments = [];
+  const pageSize = 100;
+  for (let page = 1; ; page++) {
+    const batch = await giteaFetch(
+      host,
+      `repos/${owner}/${repo}/issues/${prNumber}/comments?page=${page}&limit=${pageSize}`
+    );
+    comments.push(...batch);
+    if (batch.length < pageSize) break;
+  }
+  return comments.map((c) => {
+    const user = c.user ?? {};
+    return {
+      body: c.body ?? "",
+      author: {
+        username: user.login,
+        name: user.full_name || user.login
+      },
+      created_at: c.created_at,
+      system: false
+    };
+  });
+}
+async function postGiteaPrComment(owner, repo, prNumber, body, host) {
+  requireGiteaToken();
+  try {
+    await giteaFetch(
+      host,
+      `repos/${owner}/${repo}/issues/${prNumber}/comments`,
+      { method: "POST", body: { body } }
+    );
+  } catch (err) {
+    if (err instanceof GiteaAPIError) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GiteaAPIError(`Failed to post comment to PR #${prNumber}: ${msg}`);
+  }
+}
+
 // src/workspace.ts
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
@@ -838,43 +811,78 @@ var WorkspaceError = class extends Error {
     this.name = "WorkspaceError";
   }
 };
-function detectCiWorkspace(owner, repo) {
+function envOrNull(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : null;
+}
+async function detectCiWorkspace(owner, repo) {
+  const expected = `${owner}/${repo}`;
   if (process.env.GITLAB_CI === "true") {
-    const projectDir = process.env.CI_PROJECT_DIR;
-    const projectPath = process.env.CI_PROJECT_PATH;
-    const targetBranch = process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME ?? null;
-    const diffBaseSha = process.env.CI_MERGE_REQUEST_DIFF_BASE_SHA ?? null;
-    if (projectDir && projectPath) {
-      const expected = `${owner}/${repo}`;
-      if (projectPath === expected || projectPath.endsWith(`/${expected}`)) {
+    const projectDir = envOrNull("CI_PROJECT_DIR");
+    const projectPath = envOrNull("CI_PROJECT_PATH");
+    const targetBranch = envOrNull("CI_MERGE_REQUEST_TARGET_BRANCH_NAME");
+    const diffBaseSha = envOrNull("CI_MERGE_REQUEST_DIFF_BASE_SHA");
+    if (projectDir && projectPath && (projectPath === expected || projectPath.endsWith(`/${expected}`))) {
+      if (await isSameRepo(projectDir, owner, repo)) {
         logger.info(`Detected GitLab CI environment (target: ${targetBranch ?? "unknown"})`);
         return { path: projectDir, targetBranch, diffBaseSha };
       }
+      logger.warn(
+        `Detected GitLab CI for ${projectPath}, but ${projectDir} is not a git checkout of ${expected}; falling back to clone`
+      );
+    }
+  }
+  if (process.env.GITEA_ACTIONS === "true" || process.env.FORGEJO_ACTIONS === "true") {
+    const workspaceDir = envOrNull("GITHUB_WORKSPACE");
+    const repository = envOrNull("GITHUB_REPOSITORY");
+    const baseRef = envOrNull("GITHUB_BASE_REF");
+    if (workspaceDir && repository === expected) {
+      const ciType = process.env.FORGEJO_ACTIONS ? "Forgejo" : "Gitea";
+      if (await isSameRepo(workspaceDir, owner, repo)) {
+        logger.info(`Detected ${ciType} Actions environment (base: ${baseRef ?? "unknown"})`);
+        return { path: workspaceDir, targetBranch: baseRef, diffBaseSha: null };
+      }
+      logger.warn(
+        `Detected ${ciType} Actions for ${repository}, but ${workspaceDir} is not a git checkout of ${expected}; falling back to clone`
+      );
     }
   }
   if (process.env.GITHUB_ACTIONS === "true") {
-    const workspaceDir = process.env.GITHUB_WORKSPACE;
-    const repository = process.env.GITHUB_REPOSITORY;
-    const baseRef = process.env.GITHUB_BASE_REF ?? null;
-    if (workspaceDir && repository) {
-      const expected = `${owner}/${repo}`;
-      if (repository === expected) {
+    const workspaceDir = envOrNull("GITHUB_WORKSPACE");
+    const repository = envOrNull("GITHUB_REPOSITORY");
+    const baseRef = envOrNull("GITHUB_BASE_REF");
+    if (workspaceDir && repository === expected) {
+      if (await isSameRepo(workspaceDir, owner, repo)) {
         logger.info(`Detected GitHub Actions environment (base: ${baseRef ?? "unknown"})`);
         return { path: workspaceDir, targetBranch: baseRef, diffBaseSha: null };
       }
+      logger.warn(
+        `Detected GitHub Actions for ${repository}, but ${workspaceDir} is not a git checkout of ${expected}; falling back to clone`
+      );
     }
   }
   return { path: null, targetBranch: null, diffBaseSha: null };
 }
+function normalizeGitRemotePath(remoteUrl) {
+  const trimmed = remoteUrl.trim().replace(/\.git$/, "");
+  try {
+    const url = new URL(trimmed);
+    return url.pathname.replace(/^\/+/, "").replace(/\.git$/, "");
+  } catch {
+  }
+  const scpLikeMatch = trimmed.match(/^[^@\s]+@[^:\s]+:(.+)$/);
+  if (scpLikeMatch) {
+    return scpLikeMatch[1].replace(/^\/+/, "").replace(/\.git$/, "");
+  }
+  return trimmed.replace(/^\/+/, "").replace(/\.git$/, "");
+}
 async function isSameRepo(workspace, owner, repo) {
   try {
     const { stdout } = await exec("git", ["remote", "get-url", "origin"], { cwd: workspace });
     const remoteUrl = stdout.trim();
-    const match = remoteUrl.match(/[/:]([\w.\-\/]+?)(?:\.git)?$/);
-    if (!match) return false;
-    const remotePath = match[1];
-    const expectedPath = `${owner}/${repo}`;
-    return remotePath === expectedPath;
+    const expectedPath = `${owner}/${repo}`.replace(/\.git$/, "");
+    const remotePath = normalizeGitRemotePath(remoteUrl);
+    return remotePath === expectedPath || remotePath.toLowerCase() === expectedPath.toLowerCase();
   } catch {
     return false;
   }
@@ -993,16 +1001,90 @@ async function cloneAndCheckoutGitlabMr(workspace, owner, repo, prNumber, host)
   await checkoutGitlabBranch(workspace, sourceBranch);
   return targetBranch;
 }
+function normalizeGiteaBaseUrl(host) {
+  const giteaHost = host || process.env.GITEA_HOST || process.env.FORGEJO_HOST;
+  if (!giteaHost) {
+    throw new WorkspaceError("No Gitea/Forgejo host configured. Set GITEA_HOST or FORGEJO_HOST.");
+  }
+  const trimmed = giteaHost.trim().replace(/\/+$/, "");
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return trimmed;
+  }
+  return `https://${trimmed}`;
+}
+function giteaGitArgs(args) {
+  const token = process.env.GITEA_TOKEN || process.env.FORGEJO_TOKEN;
+  return token ? ["-c", `http.extraHeader=Authorization: token ${token}`, ...args] : args;
+}
+async function getGiteaPrCheckoutInfo(owner, repo, prNumber, host) {
+  try {
+    return await fetchGiteaPrCheckoutInfo(owner, repo, Number(prNumber), host);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkspaceError(`Failed to fetch PR info for #${prNumber}: ${msg}`);
+  }
+}
+async function checkoutGiteaBranch(workspace, prNumber, checkoutInfo) {
+  const { sourceBranch, sourceCloneUrl } = checkoutInfo;
+  const localBranch = `hodor-pr-${prNumber}`;
+  if (sourceCloneUrl) {
+    try {
+      await exec("git", giteaGitArgs(["fetch", sourceCloneUrl, sourceBranch]), { cwd: workspace });
+      await exec("git", ["checkout", "-B", localBranch, "FETCH_HEAD"], { cwd: workspace });
+      return;
+    } catch (err) {
+      logger.warn(`Failed to fetch Gitea PR branch from source repo, falling back to origin: ${err}`);
+    }
+  }
+  try {
+    await exec("git", ["checkout", "-B", localBranch, `origin/${sourceBranch}`], {
+      cwd: workspace
+    });
+  } catch {
+    try {
+      await exec("git", ["checkout", sourceBranch], { cwd: workspace });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new WorkspaceError(`Failed to checkout PR branch '${sourceBranch}': ${msg}`);
+    }
+  }
+}
+async function fetchAndCheckoutGiteaPr(workspace, owner, repo, prNumber, host) {
+  logger.info(`Fetching and checking out PR #${prNumber} in existing workspace`);
+  await exec("git", giteaGitArgs(["fetch", "origin"]), { cwd: workspace });
+  const checkoutInfo = await getGiteaPrCheckoutInfo(owner, repo, prNumber, host);
+  logger.info(`Source branch: ${checkoutInfo.sourceBranch}, Target branch: ${checkoutInfo.targetBranch}`);
+  await checkoutGiteaBranch(workspace, prNumber, checkoutInfo);
+  return checkoutInfo.targetBranch;
+}
+async function cloneAndCheckoutGiteaPr(workspace, owner, repo, prNumber, host) {
+  logger.info(`Setting up Gitea workspace for ${owner}/${repo}/pulls/${prNumber}`);
+  const cloneUrl = `${normalizeGiteaBaseUrl(host)}/${owner}/${repo}.git`;
+  logger.info(`Cloning from ${cloneUrl}...`);
+  try {
+    await exec("git", giteaGitArgs(["clone", cloneUrl, workspace]));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new WorkspaceError(`Failed to clone ${owner}/${repo}: ${msg}`);
+  }
+  const checkoutInfo = await getGiteaPrCheckoutInfo(owner, repo, prNumber, host);
+  logger.info(`Source branch: ${checkoutInfo.sourceBranch}, Target branch: ${checkoutInfo.targetBranch}`);
+  await checkoutGiteaBranch(workspace, prNumber, checkoutInfo);
+  return checkoutInfo.targetBranch;
+}
 async function setupWorkspace(opts) {
   const { platform, owner, repo, prNumber, host, workingDir, reuse = true } = opts;
   try {
-    const ci = detectCiWorkspace(owner, repo);
+    const ci = await detectCiWorkspace(owner, repo);
     let detectedTargetBranch = ci.targetBranch;
     const detectedDiffBaseSha = ci.diffBaseSha;
     let workspace;
     let isTemporary = false;
     if (ci.path) {
       workspace = ci.path;
+      if (platform === "github" && !detectedTargetBranch) {
+        detectedTargetBranch = await getGithubBaseBranch(workspace, prNumber);
+      }
     } else if (!workingDir) {
       workspace = await mkdtemp(join(tmpdir(), "hodor-review-"));
       isTemporary = true;
@@ -1019,6 +1101,9 @@ async function setupWorkspace(opts) {
         } else if (platform === "gitlab") {
           const tb = await fetchAndCheckoutGitlabMr(workspace, owner, repo, prNumber, host);
           if (!detectedTargetBranch) detectedTargetBranch = tb;
+        } else if (platform === "gitea") {
+          const tb = await fetchAndCheckoutGiteaPr(workspace, owner, repo, prNumber, host);
+          if (!detectedTargetBranch) detectedTargetBranch = tb;
         }
         const finalTargetBranch2 = detectedTargetBranch ?? "main";
         logger.info(
@@ -1034,6 +1119,9 @@ async function setupWorkspace(opts) {
       } else if (platform === "gitlab") {
         const tb = await cloneAndCheckoutGitlabMr(workspace, owner, repo, prNumber, host);
         if (!detectedTargetBranch) detectedTargetBranch = tb;
+      } else if (platform === "gitea") {
+        const tb = await cloneAndCheckoutGiteaPr(workspace, owner, repo, prNumber, host);
+        if (!detectedTargetBranch) detectedTargetBranch = tb;
       } else {
         throw new WorkspaceError(`Unsupported platform: ${platform}`);
       }
@@ -1086,11 +1174,14 @@ function detectPlatform(prUrl) {
   if (prUrl.includes("/-/merge_requests/") || hostname.includes("gitlab")) {
     return "gitlab";
   }
+  if (prUrl.includes("/pulls/") || hostname.includes("gitea") || hostname.includes("forgejo") || hostname.includes("codeberg")) {
+    return "gitea";
+  }
   if (prUrl.includes("/pull/") || hostname.includes("github")) {
     return "github";
   }
   throw new Error(
-    `Cannot detect platform for URL: ${prUrl}. Expected a GitHub pull request (/pull/) or GitLab merge request (/-/merge_requests/) URL.`
+    `Cannot detect platform for URL: ${prUrl}. Expected a GitHub (/pull/), GitLab (/-/merge_requests/), or Gitea/Forgejo (/pulls/) URL.`
   );
 }
 function parsePrUrl(prUrl) {
@@ -1109,6 +1200,18 @@ function parsePrUrl(prUrl) {
       host
     };
   }
+  if (pathParts.length >= 4 && pathParts[2] === "pulls") {
+    const prNumber = parseInt(pathParts[3], 10);
+    if (!Number.isSafeInteger(prNumber) || prNumber <= 0) {
+      throw new Error(`Invalid PR number in URL: ${prUrl}. Expected a positive integer after /pulls/.`);
+    }
+    return {
+      owner: pathParts[0],
+      repo: pathParts[1],
+      prNumber,
+      host
+    };
+  }
   const mrIndex = pathParts.indexOf("merge_requests");
   if (mrIndex >= 0) {
     if (mrIndex < 2 || mrIndex + 1 >= pathParts.length) {
@@ -1131,7 +1234,23 @@ function parsePrUrl(prUrl) {
     return { owner, repo, prNumber, host };
   }
   throw new Error(
-    `Invalid PR/MR URL format: ${prUrl}. Expected GitHub pull request or GitLab merge request URL.`
+    `Invalid PR/MR URL format: ${prUrl}. Expected GitHub (/pull/), GitLab (/-/merge_requests/), or Gitea/Forgejo (/pulls/) URL.`
+  );
+}
+function formatLocationRelative(loc, workspacePath) {
+  return relativizeWorkspacePath(loc.absolute_file_path, workspacePath ?? void 0);
+}
+async function postGitlabReviewCommitStatus(parsed, review, diffRefs) {
+  const blocking = review.findings.filter((f) => f.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";
+  await postGitlabCommitStatus(
+    parsed.owner,
+    parsed.repo,
+    diffRefs.head_sha,
+    state,
+    parsed.host,
+    { description }
   );
 }
 async function postReviewComment(opts) {
@@ -1175,6 +1294,16 @@ ${metricsFooter}`;
       ]);
       logger.info(`Successfully posted review to GitHub PR #${parsed.prNumber}`);
       return { success: true, platform: "github", prNumber: parsed.prNumber };
+    } else if (platform === "gitea") {
+      await postGiteaPrComment(
+        parsed.owner,
+        parsed.repo,
+        parsed.prNumber,
+        body,
+        parsed.host
+      );
+      logger.info(`Successfully posted review to Gitea PR #${parsed.prNumber}`);
+      return { success: true, platform: "gitea", prNumber: parsed.prNumber };
     } else {
       await postGitlabMrComment(
         parsed.owner,
@@ -1198,6 +1327,361 @@ ${metricsFooter}`;
     return { success: false, error: msg };
   }
 }
+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;
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const shas = [];
+  for (const { sha } of candidates) {
+    if (seen.has(sha)) continue;
+    seen.add(sha);
+    shas.push(sha);
+  }
+  return shas;
+}
+async function findLatestValidReviewSha(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 {
+      const { stdout: objType } = await exec("git", ["cat-file", "-t", sha], { cwd: workspacePath });
+      if (objType.trim() !== "commit") throw new Error("not a commit");
+      await exec("git", ["merge-base", "--is-ancestor", sha, "HEAD"], { cwd: workspacePath });
+      return sha;
+    } catch {
+      logger.info(`Skipping previous review SHA ${sha.slice(0, 8)}; not a valid ancestor of HEAD`);
+    }
+  }
+  return null;
+}
+async function postReviewStructured(opts) {
+  const {
+    prUrl,
+    review,
+    model,
+    metricsFooter,
+    reviewStyle,
+    commitStatus,
+    codeQualityPath,
+    headSha,
+    workspacePath
+  } = opts;
+  const platform = detectPlatform(prUrl);
+  if (platform === "github") {
+    return postReviewComment({
+      prUrl,
+      reviewText: renderMarkdown(review),
+      model,
+      metricsFooter,
+      headSha
+    });
+  }
+  if (reviewStyle === "summary") {
+    return postReviewComment({
+      prUrl,
+      reviewText: renderMarkdown(review),
+      model,
+      metricsFooter,
+      headSha
+    });
+  }
+  const parsed = parsePrUrl(prUrl);
+  try {
+    const discussions = await listHodorDiscussions(
+      parsed.owner,
+      parsed.repo,
+      parsed.prNumber,
+      parsed.host
+    );
+    const unresolvedIds = [...new Set(
+      discussions.filter((d) => !d.resolved).map((d) => d.discussionId)
+    )];
+    if (unresolvedIds.length > 0) {
+      const resolved = await resolveGitlabDiscussions(
+        parsed.owner,
+        parsed.repo,
+        parsed.prNumber,
+        unresolvedIds,
+        parsed.host
+      );
+      if (resolved > 0) logger.info(`Resolved ${resolved} old Hodor discussion(s)`);
+    }
+  } catch (err) {
+    logger.warn(`Failed to resolve old discussions: ${err instanceof Error ? err.message : err}`);
+  }
+  try {
+    const deleted = await cleanupHodorComments(
+      parsed.owner,
+      parsed.repo,
+      parsed.prNumber,
+      parsed.host
+    );
+    if (deleted > 0) logger.info(`Cleaned up ${deleted} old Hodor comment(s)`);
+  } catch (err) {
+    logger.warn(`Failed to cleanup old comments: ${err instanceof Error ? err.message : err}`);
+  }
+  let diffRefs = null;
+  try {
+    diffRefs = await getGitlabMrDiffRefs(
+      parsed.owner,
+      parsed.repo,
+      parsed.prNumber,
+      parsed.host
+    );
+  } catch (err) {
+    logger.warn(`Failed to get diff_refs, falling back to summary mode: ${err instanceof Error ? err.message : err}`);
+  }
+  if (!diffRefs) {
+    return postReviewComment({
+      prUrl,
+      reviewText: renderMarkdown(review),
+      model,
+      metricsFooter,
+      headSha
+    });
+  }
+  let inlineCount = 0;
+  let failedCount = 0;
+  let summaryPosted = false;
+  let draftsPublished = false;
+  let statusPosted = false;
+  const postingErrors = [];
+  for (const finding of review.findings) {
+    const relPath = formatLocationRelative(finding.code_location, workspacePath);
+    const priorityTag = `[P${finding.priority}]`;
+    const title = /^\[P[0-3]\]/.test(finding.title) ? finding.title : `${priorityTag} ${finding.title}`;
+    let body = `${HODOR_REVIEW_MARKER}
+**${title}**
+
+${finding.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 {
+      await createGitlabDraftNote(
+        parsed.owner,
+        parsed.repo,
+        parsed.prNumber,
+        body,
+        parsed.host,
+        {
+          filePath: relPath,
+          line: finding.code_location.line_range.start,
+          diffRefs
+        }
+      );
+      inlineCount++;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`Failed to create inline note for "${finding.title}": ${msg}`);
+      postingErrors.push(`inline note: ${msg}`);
+      failedCount++;
+    }
+  }
+  logger.info(`Created ${inlineCount} inline draft note(s)${failedCount > 0 ? ` (${failedCount} failed)` : ""}`);
+  if (reviewStyle === "hybrid" || reviewStyle === void 0) {
+    let summaryBody = renderSummaryMarkdown(review);
+    if (headSha) summaryBody = `<!-- hodor:sha:${headSha} -->
+${summaryBody}`;
+    if (model) summaryBody += `
+---
+
+Review generated by Hodor (model: \`${model}\`)`;
+    if (metricsFooter) summaryBody += `
+
+${metricsFooter}`;
+    try {
+      await postGitlabMrComment(
+        parsed.owner,
+        parsed.repo,
+        parsed.prNumber,
+        summaryBody,
+        parsed.host
+      );
+      summaryPosted = true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`Failed to post summary comment: ${msg}`);
+      postingErrors.push(`summary comment: ${msg}`);
+    }
+  }
+  if (inlineCount > 0) {
+    try {
+      await bulkPublishGitlabDraftNotes(
+        parsed.owner,
+        parsed.repo,
+        parsed.prNumber,
+        parsed.host
+      );
+      logger.info("Published all draft notes");
+      draftsPublished = true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`Failed to bulk publish draft notes: ${msg}`);
+      postingErrors.push(`draft publish: ${msg}`);
+    }
+  }
+  if (commitStatus && diffRefs) {
+    try {
+      await postGitlabReviewCommitStatus(parsed, review, diffRefs);
+      logger.info("Posted commit status");
+      statusPosted = true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`Failed to post commit status: ${msg}`);
+      postingErrors.push(`commit status: ${msg}`);
+    }
+  }
+  if (codeQualityPath) {
+    try {
+      const { formatCodeQualityReport } = await import("./codequality-DTJK2LGF.js");
+      const report = formatCodeQualityReport(review, workspacePath ?? void 0);
+      const { writeFileSync } = await import("fs");
+      writeFileSync(codeQualityPath, report, "utf-8");
+      logger.info(`Wrote code quality report to ${codeQualityPath}`);
+    } catch (err) {
+      logger.warn(`Failed to write code quality report: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  const visibleResult = summaryPosted || inlineCount > 0 && draftsPublished || statusPosted;
+  const expectedInlineComments = reviewStyle === "inline" && review.findings.length > 0;
+  if (postingErrors.length > 0 && !visibleResult || expectedInlineComments && inlineCount === 0) {
+    return {
+      success: false,
+      platform: "gitlab",
+      mrNumber: parsed.prNumber,
+      error: postingErrors[0] ?? "No GitLab inline comments were created"
+    };
+  }
+  return {
+    success: true,
+    platform: "gitlab",
+    mrNumber: parsed.prNumber
+  };
+}
+var DIFF_SKIP_PATTERNS = [
+  /(?:^|\/)testdata\//,
+  // test fixture directories
+  /(?:^|\/)(?:package-lock\.json|yarn\.lock|pnpm-lock\.yaml|go\.sum|Cargo\.lock|poetry\.lock|Gemfile\.lock|composer\.lock)$/,
+  /\.mdx?$/
+  // markdown docs
+];
+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((re) => re.test(filePath))) {
+      skippedFiles.push(filePath);
+    } else {
+      kept.push(section);
+    }
+  }
+  return { filtered: kept.join(""), skippedFiles };
+}
+var SUBMIT_REVIEW_RECOVERY_ATTEMPTS = 2;
+function buildSubmitReviewRecoveryPrompt(attempt, maxAttempts) {
+  const finalAttempt = attempt >= maxAttempts ? "\nThis is the final automatic recovery attempt; do not end the turn without calling `submit_review`." : "";
+  return [
+    "Your previous assistant turn ended without a valid `submit_review` tool call, so Hodor cannot capture the review.",
+    "Continue from the existing review context. Use only read-only tools and only the changed files/diff already identified.",
+    "If more evidence is needed, inspect the relevant diff or file context now.",
+    "When analysis is complete, call `submit_review` exactly once. Do not write the review as normal text.",
+    'If there are no findings, call `submit_review` with `"findings": []` and `"overall_correctness": "patch is correct"`.',
+    finalAttempt
+  ].filter(Boolean).join("\n");
+}
+function parseReviewFromAssistantText(text) {
+  const candidates = getJsonCandidates(text);
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (!Value.Check(SUBMIT_REVIEW_SCHEMA, parsed)) {
+        continue;
+      }
+      return validateReviewOutput(parsed);
+    } catch {
+    }
+  }
+  return null;
+}
+function getJsonCandidates(text) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addCandidate = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    candidates.push(trimmed);
+  };
+  addCandidate(text);
+  const fencedJson = /```(?:json)?\s*([\s\S]*?)```/gi;
+  for (const match of text.matchAll(fencedJson)) {
+    addCandidate(match[1] ?? "");
+  }
+  const firstBrace = text.indexOf("{");
+  const lastBrace = text.lastIndexOf("}");
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    addCandidate(text.slice(firstBrace, lastBrace + 1));
+  }
+  return candidates;
+}
+function summarizeLastAssistantMessage(session) {
+  const messages = session.messages;
+  const lastAssistant = [...messages].reverse().find((msg) => msg.role === "assistant");
+  if (!lastAssistant) {
+    return "no assistant message";
+  }
+  const stopReason = typeof lastAssistant.stopReason === "string" ? lastAssistant.stopReason : "unknown";
+  const errorMessage = typeof lastAssistant.errorMessage === "string" ? `, error=${JSON.stringify(truncateForLog(lastAssistant.errorMessage, 300))}` : "";
+  const content = Array.isArray(lastAssistant.content) ? lastAssistant.content.map((item) => {
+    const block = item;
+    const type = typeof block.type === "string" ? block.type : "unknown";
+    if (type === "toolCall" && typeof block.name === "string") {
+      return `toolCall:${block.name}`;
+    }
+    return type;
+  }).join(",") : "unknown";
+  const rawText = session.getLastAssistantText()?.trim();
+  const textSummary = rawText ? `, text=${JSON.stringify(truncateForLog(rawText.replace(/\s+/g, " "), 500))}` : "";
+  return `stopReason=${stopReason}, content=[${content || "none"}]${errorMessage}${textSummary}`;
+}
+function truncateForLog(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1)}\u2026`;
+}
 async function reviewPr(opts) {
   const {
     prUrl,
@@ -1227,36 +1711,23 @@ async function reviewPr(opts) {
     logger.info(`Platform: ${platform}, Repo: ${owner}/${repo}, PR: ${prNumber}, Host: ${host}`);
   }
   const parsed = parseModelString(model);
-  const thinkingLevel = mapReasoningEffort(reasoningEffort);
-  const apiKey = getApiKey(model);
   const envSnapshot = {
-    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
-    OPENAI_API_KEY: process.env.OPENAI_API_KEY,
     AWS_REGION: process.env.AWS_REGION
   };
-  if (apiKey) {
-    if (parsed.provider === "anthropic") {
-      process.env.ANTHROPIC_API_KEY = apiKey;
-    } else if (parsed.provider === "openai") {
-      process.env.OPENAI_API_KEY = apiKey;
-    }
-  }
   const {
+    AuthStorage,
     createAgentSession,
     DefaultResourceLoader,
+    ModelRegistry,
     SessionManager,
     SettingsManager,
-    createReadTool,
-    createBashTool,
-    createGrepTool,
-    createFindTool,
-    createLsTool,
-    AuthStorage,
-    ModelRegistry
-  } = await import("@mariozechner/pi-coding-agent");
-  const { getModel } = await import("@mariozechner/pi-ai");
+    getAgentDir
+  } = await import("@earendil-works/pi-coding-agent");
   const authStorage = AuthStorage.inMemory();
-  const modelRegistry = new ModelRegistry(authStorage);
+  if (process.env.LLM_API_KEY) {
+    authStorage.setRuntimeApiKey(parsed.provider, process.env.LLM_API_KEY);
+  }
+  const modelRegistry = ModelRegistry.inMemory(authStorage);
   let piModel;
   if (parsed.modelId.startsWith("arn:")) {
     const arnParts = parsed.modelId.split(":");
@@ -1278,11 +1749,38 @@ async function reviewPr(opts) {
     };
     logger.info(`Custom bedrock ARN model \u2014 region: ${region}`);
   } else {
-    try {
-      piModel = getModel(parsed.provider, parsed.modelId);
-    } catch (err) {
+    const registryModel = modelRegistry.find(parsed.provider, parsed.modelId);
+    if (registryModel) {
+      piModel = registryModel;
+    } else if (parsed.provider === "openrouter") {
+      piModel = {
+        id: parsed.modelId,
+        name: parsed.modelId,
+        api: "openai-completions",
+        provider: "openrouter",
+        baseUrl: "https://openrouter.ai/api/v1",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 256e3,
+        maxTokens: 65536
+      };
+      logger.warn(`Using best-effort unregistered OpenRouter model \u2014 ${parsed.modelId}`);
+    } else {
+      throw new Error(
+        `Unsupported model "${model}". Provider "${parsed.provider}" is recognized by pi-ai, but model "${parsed.modelId}" was not found in the installed registry.`
+      );
+    }
+  }
+  const thinkingLevel = mapReasoningEffort(reasoningEffort) ?? getDefaultReasoningEffortForModel(piModel);
+  if (!reasoningEffort && thinkingLevel) {
+    logger.info(`Default reasoning effort for ${piModel.name}: ${thinkingLevel}`);
+  }
+  if (parsed.provider !== "amazon-bedrock") {
+    const resolvedKey = await modelRegistry.getApiKeyForProvider(parsed.provider);
+    if (!resolvedKey) {
       throw new Error(
-        `Unsupported model "${model}": ${err instanceof Error ? err.message : err}`
+        `No API key found for provider "${parsed.provider}". Set the provider-specific environment variable, configure pi auth, or set LLM_API_KEY.`
       );
     }
   }
@@ -1316,6 +1814,7 @@ async function reviewPr(opts) {
     diffBaseSha = wsResult.diffBaseSha;
     isTemporary = wsResult.isTemporary;
   }
+  let activeSession;
   try {
     let formatToolArgs2 = function(_toolName, args) {
       if (typeof args === "string") return args.slice(0, 200);
@@ -1357,26 +1856,18 @@ async function reviewPr(opts) {
       } catch (err) {
         logger.warn(`Failed to fetch GitHub metadata: ${err}`);
       }
-    }
-    let previousReviewSha = null;
-    if (mrMetadata?.Notes) {
-      for (const note of mrMetadata.Notes) {
-        const match = note.body?.match(/<!-- hodor:sha:([a-f0-9]{40}) -->/);
-        if (match) {
-          previousReviewSha = match[1];
-        }
+    } else if (!localMode && platform === "gitea") {
+      try {
+        mrMetadata = await fetchGiteaPrInfo(owner, repo, prNumber, host, {
+          includeComments: true
+        });
+      } catch (err) {
+        logger.warn(`Failed to fetch Gitea metadata: ${err}`);
       }
     }
+    const previousReviewSha = await findLatestValidReviewSha(mrMetadata?.Notes, workspacePath);
     if (previousReviewSha) {
-      try {
-        const { stdout: objType } = await exec("git", ["cat-file", "-t", previousReviewSha], { cwd: workspacePath });
-        if (objType.trim() !== "commit") throw new Error("not a commit");
-        await exec("git", ["merge-base", "--is-ancestor", previousReviewSha, "HEAD"], { cwd: workspacePath });
-        logger.info(`Incremental mode: previous review at ${previousReviewSha.slice(0, 8)}`);
-      } catch {
-        logger.info(`Previous review SHA ${previousReviewSha.slice(0, 8)} not valid ancestor of HEAD, doing full review`);
-        previousReviewSha = null;
-      }
+      logger.info(`Incremental mode: previous review at ${previousReviewSha.slice(0, 8)}`);
     }
     let headSha = null;
     if (!localMode) {
@@ -1388,11 +1879,15 @@ async function reviewPr(opts) {
     try {
       const diffArgs = previousReviewSha ? ["--no-pager", "diff", `${previousReviewSha}...HEAD`] : diffBaseSha ? ["--no-pager", "diff", diffBaseSha, "HEAD"] : localMode ? ["--no-pager", "diff", targetBranch] : ["--no-pager", "diff", `origin/${targetBranch}...HEAD`];
       const { stdout: rawDiff } = await exec("git", diffArgs, { cwd: workspacePath });
-      if (Buffer.byteLength(rawDiff, "utf-8") <= MAX_EMBED_BYTES) {
-        embeddedDiff = rawDiff;
-        logger.info(`Embedding diff in prompt (${Buffer.byteLength(rawDiff, "utf-8")} bytes)`);
+      const { filtered: filteredDiff, skippedFiles } = filterEmbeddedDiff(rawDiff);
+      if (skippedFiles.length > 0) {
+        logger.info(`Filtered ${skippedFiles.length} file(s) from embedded diff: ${skippedFiles.join(", ")}`);
+      }
+      if (Buffer.byteLength(filteredDiff, "utf-8") <= MAX_EMBED_BYTES) {
+        embeddedDiff = filteredDiff;
+        logger.info(`Embedding diff in prompt (${Buffer.byteLength(filteredDiff, "utf-8")} bytes, raw: ${Buffer.byteLength(rawDiff, "utf-8")} bytes)`);
       } else {
-        logger.info(`Diff too large to embed (${Buffer.byteLength(rawDiff, "utf-8")} bytes), using command mode`);
+        logger.info(`Diff too large to embed (${Buffer.byteLength(filteredDiff, "utf-8")} bytes filtered, ${Buffer.byteLength(rawDiff, "utf-8")} bytes raw), using command mode`);
       }
     } catch (err) {
       logger.warn(`Failed to pre-fetch diff, falling back to command mode: ${err}`);
@@ -1413,15 +1908,13 @@ async function reviewPr(opts) {
     const settingsManager = SettingsManager.inMemory({
       compaction: { enabled: true }
     });
-    const skillPaths = [
-      join2(workspacePath, ".pi", "skills"),
-      join2(workspacePath, ".hodor", "skills")
-    ].filter((p) => existsSync(p));
+    const skillPaths = [join2(workspacePath, ".agents", "skills")].filter((p) => existsSync(p));
     const resourceLoader = new DefaultResourceLoader({
       cwd: workspacePath,
+      agentDir: getAgentDir(),
       settingsManager,
       systemPrompt: REVIEW_SYSTEM_PROMPT,
-      appendSystemPrompt: "",
+      appendSystemPrompt: [],
       noExtensions: true,
       noSkills: true,
       noPromptTemplates: true,
@@ -1461,7 +1954,12 @@ async function reviewPr(opts) {
             details: { ignoredDuplicate: true }
           };
         }
-        submittedReview = validateReviewOutput(params);
+        try {
+          submittedReview = validateReviewOutput(params);
+        } catch (err) {
+          logger.warn(`Invalid submit_review payload: ${err instanceof Error ? err.message : err}`);
+          throw err;
+        }
         logger.info(
           `Received structured review via submit_review (${submittedReview.findings.length} finding(s))`
         );
@@ -1470,7 +1968,8 @@ async function reviewPr(opts) {
             type: "text",
             text: "Review received. Do not output the review as normal text."
           }],
-          details: {}
+          details: {},
+          terminate: true
         };
       }
     };
@@ -1478,21 +1977,20 @@ async function reviewPr(opts) {
       cwd: workspacePath,
       model: piModel,
       thinkingLevel,
-      tools: [
-        createReadTool(workspacePath),
-        createBashTool(workspacePath),
-        createGrepTool(workspacePath),
-        createFindTool(workspacePath),
-        createLsTool(workspacePath)
-      ],
+      // pi v0.74 filters customTools through the same allowlist as built-ins
+      // (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: ["read", "bash", "grep", "find", "ls", "submit_review"],
       customTools: [submitReviewTool],
+      authStorage,
+      modelRegistry,
       sessionManager: SessionManager.inMemory(),
       settingsManager,
-      resourceLoader,
-      authStorage,
-      modelRegistry
+      resourceLoader
     });
-    if (bedrockTags && parsed.provider === "bedrock") {
+    activeSession = session;
+    if (bedrockTags && parsed.provider === "amazon-bedrock") {
       const agent = session.agent;
       const originalStreamFn = agent.streamFn;
       agent.streamFn = (...args) => {
@@ -1549,25 +2047,47 @@ async function reviewPr(opts) {
         }
       }
     });
+    const throwIfAgentErrored = () => {
+      const agentError = session.state.errorMessage;
+      if (agentError) {
+        throw new Error(`LLM request failed: ${agentError}`);
+      }
+    };
+    const recoverReviewFromAssistantText = (source) => {
+      const rawText = session.getLastAssistantText() ?? "";
+      if (!rawText.trim()) return false;
+      const parsedReview = parseReviewFromAssistantText(rawText);
+      if (!parsedReview) return false;
+      submittedReview = parsedReview;
+      logger.warn(
+        `Recovered structured review from assistant text after ${source}; model did not call submit_review`
+      );
+      return true;
+    };
     logger.info("Sending prompt to agent...");
     await session.prompt(prompt);
-    const agentError = session.state?.error;
-    if (agentError) {
-      throw new Error(`LLM request failed: ${agentError}`);
+    throwIfAgentErrored();
+    if (!submittedReview) {
+      recoverReviewFromAssistantText("initial agent run");
+    }
+    for (let attempt = 1; !submittedReview && attempt <= SUBMIT_REVIEW_RECOVERY_ATTEMPTS; attempt++) {
+      logger.warn(
+        `Agent ended without a valid submit_review (${summarizeLastAssistantMessage(session)}); requesting recovery ${attempt}/${SUBMIT_REVIEW_RECOVERY_ATTEMPTS}`
+      );
+      await session.prompt(buildSubmitReviewRecoveryPrompt(attempt, SUBMIT_REVIEW_RECOVERY_ATTEMPTS));
+      throwIfAgentErrored();
+      recoverReviewFromAssistantText(`recovery attempt ${attempt}`);
     }
     if (!submittedReview) {
-      const rawText = session.getLastAssistantText() ?? "";
-      if (rawText) {
-        logger.debug(`Last assistant text without submit_review (first 500 chars): ${rawText.slice(0, 500)}`);
-      } else {
-        const messages = session.state?.messages;
-        const lastMsg = messages?.[messages.length - 1];
-        logger.debug(`Last message: ${JSON.stringify(lastMsg)?.slice(0, 500)}`);
-      }
+      const diagnostic = summarizeLastAssistantMessage(session);
       if (submitReviewCalls > 0) {
-        throw new Error("Agent called submit_review but did not provide a valid review payload");
+        throw new Error(
+          `Agent called submit_review but did not provide a valid review payload after ${SUBMIT_REVIEW_RECOVERY_ATTEMPTS} recovery attempt(s): ${diagnostic}`
+        );
       }
-      throw new Error("Agent did not call submit_review");
+      throw new Error(
+        `Agent did not call submit_review after ${SUBMIT_REVIEW_RECOVERY_ATTEMPTS} recovery attempt(s): ${diagnostic}`
+      );
     }
     const review = submittedReview;
     if (submitReviewCalls > 1) {
@@ -1578,7 +2098,7 @@ async function reviewPr(opts) {
     );
     const durationSeconds = (Date.now() - startTime) / 1e3;
     logger.info(`Review complete (${review.findings.length} finding(s))`);
-    const allMessages = session.state?.messages ?? [];
+    const allMessages = session.messages;
     let inputTokens = 0;
     let outputTokens = 0;
     let cacheReadTokens = 0;
@@ -1611,8 +2131,9 @@ async function reviewPr(opts) {
     if (includeMetricsFooter) {
       metricsFooter = formatMetricsMarkdown(metrics);
     }
-    return { review, metricsFooter, headSha, metrics };
+    return { review, metricsFooter, headSha, metrics, workspacePath };
   } finally {
+    activeSession?.dispose();
     for (const [key, val] of Object.entries(envSnapshot)) {
       if (val === void 0) {
         delete process.env[key];
@@ -1627,84 +2148,7 @@ async function reviewPr(opts) {
   }
 }
 
-// src/render.ts
-function renderMarkdown(review) {
-  const lines = [];
-  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 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}`;
-}
-
 export {
-  setLogLevel,
   buildPrReviewPrompt,
   parseModelString,
   mapReasoningEffort,
@@ -1715,8 +2159,9 @@ export {
   validateReviewOutput,
   detectPlatform,
   parsePrUrl,
+  postGitlabReviewCommitStatus,
   postReviewComment,
-  reviewPr,
-  renderMarkdown
+  postReviewStructured,
+  reviewPr
 };
-//# sourceMappingURL=chunk-QGUJENIG.js.map
+//# sourceMappingURL=chunk-JSLG7EOX.js.map