revdeck 0.0.0-stage → 0.1.0

package/dist/daemon.js

@@ -0,0 +1,3715 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/redact.ts
+function redact(value) {
+  let text2 = String(value ?? "").replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, " ");
+  for (const [pattern, replacement] of TOKEN_PATTERNS) {
+    text2 = text2.replace(pattern, replacement);
+  }
+  return text2.slice(0, 4e3);
+}
+function redactLine(value, max = 300) {
+  return redact(value).replace(/\s+/g, " ").trim().slice(0, max);
+}
+var TOKEN_PATTERNS;
+var init_redact = __esm({
+  "src/core/redact.ts"() {
+    "use strict";
+    TOKEN_PATTERNS = [
+      [/\bgl[a-z]{2,6}-[A-Za-z0-9_-]{10,}/g, "gl-***"],
+      [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, "gh-***"],
+      [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, "gh-***"],
+      [/\bxox[baprs]-[A-Za-z0-9-]{10,}/g, "xox-***"],
+      [/\bAKIA[0-9A-Z]{16}\b/g, "AKIA***"],
+      [/\bsk-[A-Za-z0-9]{20,}/g, "sk-***"],
+      [/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, "jwt-***"],
+      [/\b[0-9a-f]{40,}\b/gi, "hex-***"],
+      [/((?:private[-_]token|access[-_]token|authorization|bearer|password|passwd|secret)\s*[:=]\s*)(?:"[^"]*"|'[^']*'|\S+)/gi, "$1***"],
+      [/([?&](?:private_token|access_token|token|key)=)[^&\s]+/gi, "$1***"]
+    ];
+  }
+});
+
+// src/core/locale.ts
+function detectLocale(explicit) {
+  const value = (explicit ?? process.env.REVDECK_LANG ?? process.env.LC_ALL ?? process.env.LANG ?? "").toLowerCase();
+  return value.startsWith("ru") ? "ru" : "en";
+}
+function setLocale(value) {
+  current = value;
+  process.env.REVDECK_LANG = value;
+}
+function tr(ru, en) {
+  return current === "ru" ? ru : en;
+}
+function detectTextLocale(text2, fallback = current) {
+  const cyrillic = (text2.match(/[А-Яа-яЁё]/g) ?? []).length;
+  const latin = (text2.match(/[A-Za-z]/g) ?? []).length;
+  if (cyrillic === 0 && latin === 0) return fallback;
+  return cyrillic >= latin ? "ru" : "en";
+}
+function resolveOutputLanguage(setting, texts) {
+  if (setting === "ru" || setting === "en") return setting;
+  return detectTextLocale(texts.join("\n"), "en");
+}
+var current;
+var init_locale = __esm({
+  "src/core/locale.ts"() {
+    "use strict";
+    current = detectLocale();
+  }
+});
+
+// src/core/errors.ts
+function messageOf(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+var MrReviewError, ConfigError, ProviderError, AuthError;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+    MrReviewError = class extends Error {
+      code;
+      hint;
+      constructor(message, code = "REVDECK_ERROR", hint) {
+        super(message);
+        this.name = "MrReviewError";
+        this.code = code;
+        this.hint = hint;
+      }
+    };
+    ConfigError = class extends MrReviewError {
+      constructor(message, hint) {
+        super(message, "CONFIG", hint);
+        this.name = "ConfigError";
+      }
+    };
+    ProviderError = class extends MrReviewError {
+      constructor(message, hint) {
+        super(message, "PROVIDER", hint);
+        this.name = "ProviderError";
+      }
+    };
+    AuthError = class extends MrReviewError {
+      constructor(message, hint) {
+        super(message, "AUTH", hint);
+        this.name = "AuthError";
+      }
+    };
+  }
+});
+
+// src/core/diff.ts
+function cleanPath(raw) {
+  let value = raw.trim();
+  if (value.startsWith('"') && value.endsWith('"')) {
+    value = value.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  }
+  value = value.replace(/\t.*$/, "");
+  return value.replace(/^[ab]\//, "");
+}
+function splitGitHeader(line) {
+  const body = line.slice("diff --git ".length).trim();
+  const quoted = /^"(.*)"\s+"(.*)"$/.exec(body);
+  if (quoted) return { oldPath: cleanPath(quoted[1]), newPath: cleanPath(quoted[2]) };
+  const index = body.lastIndexOf(" b/");
+  if (index > 0) {
+    return { oldPath: cleanPath(body.slice(0, index)), newPath: cleanPath(body.slice(index + 1)) };
+  }
+  const [left, right] = body.split(/\s+/);
+  return { oldPath: cleanPath(left ?? ""), newPath: cleanPath(right ?? left ?? "") };
+}
+function parseHunkHeader(line) {
+  const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(line);
+  if (!match) throw new DiffParseError(`invalid hunk header: ${line.slice(0, 120)}`);
+  return {
+    header: line,
+    oldStart: Number(match[1]),
+    oldLines: match[2] === void 0 ? 1 : Number(match[2]),
+    newStart: Number(match[3]),
+    newLines: match[4] === void 0 ? 1 : Number(match[4]),
+    lines: []
+  };
+}
+function parseUnifiedDiff(patch) {
+  if (patch.length > MAX_DIFF_BYTES) {
+    throw new DiffParseError(`diff is larger than ${Math.round(MAX_DIFF_BYTES / 1024 / 1024)} MB: open a smaller range`);
+  }
+  const lines = patch.replace(/\r\n/g, "\n").split("\n");
+  const files = [];
+  let current2 = null;
+  let index = 0;
+  const start = (oldPath, newPath) => {
+    const file = {
+      path: newPath || oldPath,
+      oldPath: oldPath || newPath,
+      status: "modified",
+      binary: false,
+      hunks: []
+    };
+    files.push(file);
+    return file;
+  };
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.startsWith("diff --git ")) {
+      const { oldPath, newPath } = splitGitHeader(line);
+      current2 = start(oldPath, newPath);
+      index++;
+      continue;
+    }
+    if (!current2 && line.startsWith("--- ")) {
+      current2 = start(cleanPath(line.slice(4)), "");
+      current2.status = "modified";
+      index++;
+      continue;
+    }
+    if (!current2) {
+      index++;
+      continue;
+    }
+    if (line.startsWith("new file mode")) {
+      current2.status = "added";
+      index++;
+      continue;
+    }
+    if (line.startsWith("deleted file mode")) {
+      current2.status = "deleted";
+      index++;
+      continue;
+    }
+    if (line.startsWith("rename from ")) {
+      current2.oldPath = cleanPath(line.slice("rename from ".length));
+      current2.status = "renamed";
+      index++;
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      current2.path = cleanPath(line.slice("rename to ".length));
+      current2.status = "renamed";
+      index++;
+      continue;
+    }
+    if (line.startsWith("Binary files ") || line === "GIT binary patch") {
+      current2.binary = true;
+      index++;
+      continue;
+    }
+    if (current2.hunks.length === 0 && line.startsWith("--- ")) {
+      const value = line.slice(4).trim();
+      if (value === "/dev/null") {
+        current2.status = "added";
+      } else {
+        current2.oldPath = cleanPath(value);
+      }
+      index++;
+      continue;
+    }
+    if (current2.hunks.length === 0 && line.startsWith("+++ ")) {
+      const value = line.slice(4).trim();
+      if (value === "/dev/null") {
+        current2.status = "deleted";
+      } else {
+        current2.path = cleanPath(value);
+      }
+      index++;
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      const hunk = parseHunkHeader(line);
+      current2.hunks.push(hunk);
+      index++;
+      let oldLeft = hunk.oldLines;
+      let newLeft = hunk.newLines;
+      let oldNo = hunk.oldStart;
+      let newNo = hunk.newStart;
+      while (index < lines.length) {
+        const body = lines[index];
+        if (body.startsWith("diff --git ") || body.startsWith("@@")) break;
+        if (body === "" && index === lines.length - 1) break;
+        if (body.startsWith("\\")) {
+          index++;
+          continue;
+        }
+        const marker = body[0] ?? "";
+        let parsed;
+        if (marker === "+") {
+          parsed = { kind: "+", text: body.slice(1), oldLine: null, newLine: newNo };
+          newNo++;
+          newLeft--;
+        } else if (marker === "-") {
+          parsed = { kind: "-", text: body.slice(1), oldLine: oldNo, newLine: null };
+          oldNo++;
+          oldLeft--;
+        } else {
+          parsed = { kind: " ", text: marker === " " ? body.slice(1) : body, oldLine: oldNo, newLine: newNo };
+          oldNo++;
+          newNo++;
+          oldLeft--;
+          newLeft--;
+        }
+        hunk.lines.push(parsed);
+        index++;
+        if (oldLeft <= 0 && newLeft <= 0) break;
+      }
+      continue;
+    }
+    index++;
+  }
+  return files.filter((file) => file.path && file.path !== "/dev/null");
+}
+function diffStats(files) {
+  let additions = 0;
+  let deletions = 0;
+  for (const file of files) {
+    for (const hunk of file.hunks) {
+      for (const line of hunk.lines) {
+        if (line.kind === "+") additions++;
+        else if (line.kind === "-") deletions++;
+      }
+    }
+  }
+  return { files: files.length, additions, deletions };
+}
+function changedPaths(files) {
+  return files.map((file) => file.path);
+}
+function findFile(files, path8) {
+  return files.find((file) => file.path === path8) ?? files.find((file) => file.oldPath === path8);
+}
+function findNewLine(files, path8, line) {
+  const file = findFile(files, path8);
+  if (!file) return void 0;
+  for (const hunk of file.hunks) {
+    for (const item of hunk.lines) {
+      if (item.newLine === line) return item;
+    }
+  }
+  return void 0;
+}
+function snippetAround(files, path8, line, radius = 6) {
+  const file = findFile(files, path8);
+  if (!file || line == null) return null;
+  const flat = file.hunks.flatMap((hunk) => hunk.lines);
+  const target = flat.findIndex((item) => item.newLine === line);
+  if (target < 0) return null;
+  return flat.slice(Math.max(0, target - radius), target + radius + 1).map((item) => ({
+    kind: item.kind,
+    oldLine: item.oldLine,
+    newLine: item.newLine,
+    text: item.text.length > 400 ? `${item.text.slice(0, 400)}\u2026` : item.text,
+    target: item.newLine === line
+  }));
+}
+function linePosition(files, path8, line) {
+  const file = findFile(files, path8);
+  const found = findNewLine(files, path8, line);
+  if (!file || !found) return null;
+  return { newPath: file.path, newLine: line, oldPath: file.oldPath, oldLine: found.kind === " " ? found.oldLine : null };
+}
+var MAX_DIFF_BYTES, DiffParseError;
+var init_diff = __esm({
+  "src/core/diff.ts"() {
+    "use strict";
+    MAX_DIFF_BYTES = 32 * 1024 * 1024;
+    DiffParseError = class extends Error {
+    };
+  }
+});
+
+// src/core/exec.ts
+import { execFile } from "node:child_process";
+function scrubEnv(extra) {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (SECRET_ENV.includes(key)) continue;
+    env[key] = value;
+  }
+  env.PAGER = "cat";
+  env.GIT_PAGER = "cat";
+  env.GIT_TERMINAL_PROMPT = "0";
+  env.NO_COLOR = "1";
+  env.CLICOLOR = "0";
+  env.FORCE_COLOR = "0";
+  env.TERM = "dumb";
+  return { ...env, ...extra };
+}
+var SECRET_ENV, run;
+var init_exec = __esm({
+  "src/core/exec.ts"() {
+    "use strict";
+    SECRET_ENV = [
+      "GITLAB_TOKEN",
+      "GITLAB_PRIVATE_TOKEN",
+      "GLAB_TOKEN",
+      "CI_JOB_TOKEN",
+      "GH_TOKEN",
+      "GITHUB_TOKEN",
+      "GITHUB_ENTERPRISE_TOKEN",
+      "GIT_ASKPASS",
+      "SSH_ASKPASS",
+      "REVDECK_TOKEN"
+    ];
+    run = (command, args, options = {}) => new Promise((resolve, reject) => {
+      const child = execFile(
+        command,
+        args,
+        {
+          cwd: options.cwd,
+          env: scrubEnv(options.env),
+          timeout: options.timeoutMs ?? 12e4,
+          maxBuffer: options.maxBuffer ?? 64 * 1024 * 1024,
+          encoding: "utf8",
+          windowsHide: true,
+          shell: false
+        },
+        (error, stdout, stderr) => {
+          const exitCode = error?.code;
+          const code = typeof exitCode === "number" ? exitCode : error ? 1 : 0;
+          if (error && !(options.allowExitCodes ?? []).includes(code)) {
+            const reason = (stderr || stdout || error.message).trim();
+            reject(Object.assign(new Error(reason.slice(0, 4e3)), { command, code, stderr, stdout }));
+            return;
+          }
+          resolve({ stdout, stderr, code });
+        }
+      );
+      if (options.input !== void 0) {
+        child.stdin?.end(options.input);
+      }
+    });
+  }
+});
+
+// src/providers/util.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path5 from "node:path";
+function parseJson(stdout, source) {
+  const text2 = stdout.trim();
+  if (!text2) throw new ProviderError(tr(`${source}: \u043F\u0443\u0441\u0442\u043E\u0439 \u043E\u0442\u0432\u0435\u0442`, `${source}: empty response`));
+  try {
+    return JSON.parse(text2);
+  } catch {
+    throw new ProviderError(tr(`${source}: \u043E\u0442\u0432\u0435\u0442 \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F JSON (${redact(text2).slice(0, 200)})`, `${source}: response is not JSON (${redact(text2).slice(0, 200)})`));
+  }
+}
+function cliError(error, platform, host) {
+  const message = redact(error?.message ?? error).trim();
+  const lower = message.toLowerCase();
+  if (/(auth|unauthor|401|403|not logged|token|credential|forbidden)/.test(lower)) {
+    const hint = platform === "gitlab" ? tr(`\u0432\u043E\u0439\u0434\u0438\u0442\u0435 \u0432 glab \u043D\u0430 \u044D\u0442\u043E\u043C \u0445\u043E\u0441\u0442\u0435: glab auth login --hostname ${host}`, `log in to glab for this host: glab auth login --hostname ${host}`) : tr(`\u0432\u043E\u0439\u0434\u0438\u0442\u0435 \u0432 gh: GH_HOST=${host} gh auth login`, `log in to gh: GH_HOST=${host} gh auth login`);
+    throw new AuthError(`${platform}: ${message || tr("\u043D\u0435\u0442 \u0430\u0432\u0442\u043E\u0440\u0438\u0437\u0430\u0446\u0438\u0438", "not authenticated")}`, hint);
+  }
+  if (/(not found|404)/.test(lower)) throw new ProviderError(`${platform}: ${message}`, tr("\u043F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 \u043D\u043E\u043C\u0435\u0440 \u0440\u0435\u0432\u044C\u044E \u0438 \u0434\u043E\u0441\u0442\u0443\u043F \u043A \u043F\u0440\u043E\u0435\u043A\u0442\u0443", "check the review number and project access"));
+  throw new ProviderError(`${platform}: ${message || tr("\u043A\u043E\u043C\u0430\u043D\u0434\u0430 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0430\u0441\u044C \u0441 \u043E\u0448\u0438\u0431\u043A\u043E\u0439", "the command failed")}`);
+}
+async function withTempJson(data, fn) {
+  const dir = await mkdtemp(path5.join(tmpdir(), "revdeck-"));
+  const file = path5.join(dir, "payload.json");
+  try {
+    await writeFile(file, JSON.stringify(data), { mode: 384, flag: "wx" });
+    return await fn(file);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+function query(path8, params) {
+  const url = new URL(path8.startsWith("/") ? path8 : `/${path8}`, "http://local");
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== "") url.searchParams.set(key, String(value));
+  }
+  return `${url.pathname.replace(/^\//, "")}${url.search}`;
+}
+var init_util = __esm({
+  "src/providers/util.ts"() {
+    "use strict";
+    init_errors();
+    init_redact();
+    init_locale();
+  }
+});
+
+// src/providers/gitlab.ts
+var gitlab_exports = {};
+__export(gitlab_exports, {
+  GitLabProvider: () => GitLabProvider,
+  isAuthError: () => isAuthError
+});
+import { tmpdir as tmpdir2 } from "node:os";
+function isAuthError(error) {
+  return /auth|401|403|unauthor|forbidden|not logged/i.test(redact(error));
+}
+var EMPTY_SHA, GitLabProvider;
+var init_gitlab = __esm({
+  "src/providers/gitlab.ts"() {
+    "use strict";
+    init_diff();
+    init_errors();
+    init_redact();
+    init_exec();
+    init_util();
+    init_locale();
+    EMPTY_SHA = "0000000000000000000000000000000000000000";
+    GitLabProvider = class {
+      constructor(ref, options) {
+        this.ref = ref;
+        this.options = options;
+        this.run = options.runImpl ?? run;
+      }
+      ref;
+      options;
+      platform = "gitlab";
+      capabilities = { reactions: true, resolve: true, nativeDrafts: true };
+      run;
+      me = null;
+      infoCache = null;
+      get projectRef() {
+        return encodeURIComponent(this.ref.project);
+      }
+      endpoint(suffix) {
+        return `projects/${this.projectRef}/merge_requests/${this.ref.number}${suffix}`;
+      }
+      async call(args) {
+        const inputIndex = args.indexOf("--input");
+        const withHeaders = inputIndex >= 0 && !args.includes("-H") ? [...args.slice(0, inputIndex), "-H", "Content-Type: application/json", ...args.slice(inputIndex)] : args;
+        try {
+          const { stdout } = await this.run("glab", ["api", "--hostname", this.ref.host, ...withHeaders], {
+            // Вне рабочей копии: `.git/config`, который может менять агент, не участвует.
+            cwd: tmpdir2(),
+            timeoutMs: 9e4,
+            maxBuffer: 64 * 1024 * 1024
+          });
+          return stdout;
+        } catch (error) {
+          cliError(error, "gitlab", this.ref.host);
+        }
+      }
+      async json(args) {
+        return parseJson(await this.call(args), `GitLab ${this.ref.project}!${this.ref.number}`);
+      }
+      async paged(endpoint, params = {}) {
+        const items = [];
+        for (let page = 1; page <= 50; page++) {
+          const chunk = await this.json([query(endpoint, { ...params, per_page: 100, page })]);
+          if (!Array.isArray(chunk)) throw new ProviderError(tr("GitLab: \u043E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u043C\u0430\u0441\u0441\u0438\u0432 \u0432 \u043E\u0442\u0432\u0435\u0442\u0435 \u043D\u0430 \u0441\u043F\u0438\u0441\u043E\u043A", "GitLab: expected an array in the list response"));
+          items.push(...chunk);
+          if (chunk.length < 100) break;
+        }
+        return items;
+      }
+      async info() {
+        if (this.infoCache) return this.infoCache;
+        const mr = await this.json([this.endpoint("")]);
+        const refs = mr.diff_refs ?? {};
+        const base = refs.base_sha || mr.sha || EMPTY_SHA;
+        const start = refs.start_sha || base;
+        const head = refs.head_sha || mr.sha || EMPTY_SHA;
+        const files = Number.parseInt(String(mr.changes_count ?? "0"), 10);
+        const info = {
+          ref: this.ref,
+          title: String(mr.title ?? ""),
+          description: String(mr.description ?? ""),
+          author: mr.author?.username ?? "",
+          authorName: mr.author?.name ?? "",
+          state: String(mr.state ?? ""),
+          draft: Boolean(mr.draft ?? mr.work_in_progress),
+          sourceBranch: String(mr.source_branch ?? ""),
+          targetBranch: String(mr.target_branch ?? ""),
+          webUrl: String(mr.web_url ?? ""),
+          commit: { base, start, head },
+          updatedAt: String(mr.updated_at ?? ""),
+          stats: { files: Number.isFinite(files) ? files : 0, additions: 0, deletions: 0 }
+        };
+        this.infoCache = info;
+        return info;
+      }
+      async diff() {
+        const items = await this.paged(this.endpoint("/diffs"));
+        const chunks = [];
+        for (const file of items) {
+          const oldPath = file.old_path;
+          const newPath = file.new_path;
+          let header = `diff --git a/${oldPath} b/${newPath}
+`;
+          if (file.new_file) header += "new file mode 100644\n";
+          if (file.deleted_file) header += "deleted file mode 100644\n";
+          if (file.renamed_file) header += `rename from ${oldPath}
+rename to ${newPath}
+`;
+          if (file.binary || file.too_large || !file.diff) {
+            header += "Binary files differ\n";
+            chunks.push(header);
+            continue;
+          }
+          header += `--- ${file.new_file ? "/dev/null" : `a/${oldPath}`}
++++ ${file.deleted_file ? "/dev/null" : `b/${newPath}`}
+`;
+          chunks.push(header + file.diff);
+        }
+        return parseUnifiedDiff(chunks.join("\n"));
+      }
+      async threads() {
+        const discussions = await this.paged(this.endpoint("/discussions"));
+        const threads = [];
+        for (const discussion of discussions) {
+          const notes = (discussion.notes ?? []).filter((note) => !note.system);
+          if (!notes.length) continue;
+          const placed = discussion.notes.find((note) => note.position) ?? discussion.notes[0];
+          const position = placed?.position ?? null;
+          const head = discussion.notes.find((note) => note.resolvable !== void 0) ?? discussion.notes[0];
+          threads.push({
+            id: String(discussion.id),
+            path: position?.new_path ?? position?.old_path ?? null,
+            line: position?.new_line ?? position?.old_line ?? null,
+            side: position?.new_line ? "new" : position?.old_line ? "old" : null,
+            resolvable: Boolean(head?.resolvable),
+            resolved: Boolean(head?.resolved),
+            notes: notes.map((note) => this.mapNote(note)),
+            updatedAt: String(notes[notes.length - 1]?.created_at ?? "")
+          });
+        }
+        return threads;
+      }
+      mapNote(note) {
+        return {
+          id: String(note.id),
+          author: note.author?.username ?? "?",
+          authorName: note.author?.name ?? "",
+          createdAt: String(note.created_at ?? ""),
+          body: String(note.body ?? ""),
+          system: Boolean(note.system)
+        };
+      }
+      async currentUser() {
+        if (this.me) return this.me;
+        const user = await this.json(["user"]);
+        this.me = { username: user.username, name: user.name };
+        return this.me;
+      }
+      async list(options = {}) {
+        const scope = options.scope ?? "open";
+        const limit = Math.min(options.limit ?? 50, 100);
+        const params = {
+          state: "opened",
+          order_by: "updated_at",
+          sort: "desc",
+          per_page: limit
+        };
+        if (scope === "mine") params.scope = "created_by_me";
+        if (scope === "reviewing") {
+          const me = await this.currentUser();
+          params.scope = "all";
+          params.reviewer_username = me.username;
+        }
+        const items = await this.json([query(`projects/${this.projectRef}/merge_requests`, params)]);
+        return (Array.isArray(items) ? items : []).map((mr) => ({
+          ref: { ...this.ref, number: mr.iid },
+          title: String(mr.title ?? ""),
+          author: mr.author?.username ?? "",
+          updatedAt: String(mr.updated_at ?? ""),
+          state: String(mr.state ?? ""),
+          draft: Boolean(mr.draft ?? mr.work_in_progress),
+          webUrl: String(mr.web_url ?? "")
+        }));
+      }
+      async findByBranch(branch) {
+        const items = await this.json([query(`projects/${this.projectRef}/merge_requests`, { state: "opened", source_branch: branch, per_page: 1 })]);
+        const first = Array.isArray(items) ? items[0] : void 0;
+        return first ? { ...this.ref, number: first.iid } : null;
+      }
+      async reply(thread, body) {
+        const endpoint = this.endpoint(`/discussions/${encodeURIComponent(thread.id)}/notes`);
+        const note = await withTempJson({ body }, async (file) => this.json(["--method", "POST", endpoint, "--input", file]));
+        return this.mapNote(note);
+      }
+      async resolve(threadId, resolved) {
+        await withTempJson({ resolved }, async (file) => {
+          await this.call(["--method", "PUT", this.endpoint(`/discussions/${encodeURIComponent(threadId)}`), "--input", file]);
+        });
+      }
+      async react(noteId, emoji) {
+        const base = this.endpoint(`/notes/${encodeURIComponent(noteId)}/award_emoji`);
+        const existing = await this.json([query(base, { per_page: 100 })]);
+        const me = await this.currentUser();
+        const mine = existing.find((item) => item.name === emoji && item.user?.username === me.username);
+        if (mine) {
+          await this.call(["--method", "DELETE", `${base}/${mine.id}`]);
+          return { active: false };
+        }
+        await withTempJson({ name: emoji }, async (file) => {
+          await this.call(["--method", "POST", base, "--input", file]);
+        });
+        return { active: true };
+      }
+      async createThread(input) {
+        const info = await this.info();
+        if (!info.commit.head || info.commit.head === EMPTY_SHA) {
+          throw new ProviderError(tr("GitLab \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B SHA \u0440\u0435\u0432\u0438\u0437\u0438\u0439: \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 \u043A \u0441\u0442\u0440\u043E\u043A\u0435 \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u0435\u043D", "GitLab did not return revision SHAs: a line comment is not possible"));
+        }
+        const payload = input.line === null ? { body: input.body } : {
+          body: input.body,
+          position: {
+            position_type: "text",
+            base_sha: info.commit.base,
+            start_sha: info.commit.start,
+            head_sha: info.commit.head,
+            new_path: input.file,
+            old_path: input.file,
+            new_line: input.line,
+            ...input.oldLine !== null ? { old_line: input.oldLine } : {}
+          }
+        };
+        const created = await withTempJson(
+          payload,
+          async (file) => this.json(["--method", "POST", this.endpoint("/discussions"), "--input", file])
+        );
+        const note = created.notes?.[0];
+        if (!note) throw new ProviderError(tr("GitLab \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B \u0441\u043E\u0437\u0434\u0430\u043D\u043D\u043E\u0435 \u043E\u0431\u0441\u0443\u0436\u0434\u0435\u043D\u0438\u0435", "GitLab did not return the created discussion"));
+        return { discussionId: String(created.id), noteId: String(note.id) };
+      }
+    };
+  }
+});
+
+// src/providers/github.ts
+var github_exports = {};
+__export(github_exports, {
+  GitHubProvider: () => GitHubProvider
+});
+import { tmpdir as tmpdir3 } from "node:os";
+var THREADS_QUERY, REACTIONS, GitHubProvider;
+var init_github = __esm({
+  "src/providers/github.ts"() {
+    "use strict";
+    init_diff();
+    init_errors();
+    init_exec();
+    init_util();
+    init_locale();
+    THREADS_QUERY = `query($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id isResolved isOutdated path line originalLine diffSide
+          comments(first: 100) {
+            nodes { databaseId id author { login } body createdAt }
+          }
+        }
+      }
+    }
+  }
+}`;
+    REACTIONS = {
+      thumbsup: "+1",
+      thumbsdown: "-1",
+      smile: "laugh",
+      tada: "hooray",
+      confused: "confused",
+      heart: "heart",
+      rocket: "rocket",
+      eyes: "eyes"
+    };
+    GitHubProvider = class {
+      constructor(ref, options) {
+        this.ref = ref;
+        this.options = options;
+        this.run = options.runImpl ?? run;
+        const [owner, name, ...rest] = ref.project.split("/");
+        if (!owner || !name || rest.length) {
+          throw new ProviderError(tr(`GitHub: \u043F\u0440\u043E\u0435\u043A\u0442 \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C owner/repo, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${ref.project}`, `GitHub: project must be owner/repo, got ${ref.project}`));
+        }
+        this.owner = owner;
+        this.name = name;
+      }
+      ref;
+      options;
+      platform = "github";
+      capabilities = { reactions: true, resolve: true, nativeDrafts: false };
+      run;
+      owner;
+      name;
+      me = null;
+      infoCache = null;
+      get repo() {
+        return `${this.owner}/${this.name}`;
+      }
+      get pullBase() {
+        return `repos/${this.repo}/pulls/${this.ref.number}`;
+      }
+      async call(args) {
+        const inputIndex = args.indexOf("--input");
+        const withHeaders = inputIndex >= 0 && !args.includes("-H") ? [...args.slice(0, inputIndex), "-H", "Content-Type: application/json", ...args.slice(inputIndex)] : args;
+        try {
+          const { stdout } = await this.run("gh", ["api", ...withHeaders], {
+            cwd: tmpdir3(),
+            env: { GH_HOST: this.ref.host },
+            timeoutMs: 9e4,
+            maxBuffer: 64 * 1024 * 1024
+          });
+          return stdout;
+        } catch (error) {
+          cliError(error, "github", this.ref.host);
+        }
+      }
+      async json(args) {
+        return parseJson(await this.call(args), `GitHub ${this.ref.project}#${this.ref.number}`);
+      }
+      async paged(endpoint, params = {}) {
+        const items = [];
+        for (let page = 1; page <= 50; page++) {
+          const chunk = await this.json([query(endpoint, { ...params, per_page: 100, page })]);
+          if (!Array.isArray(chunk)) throw new ProviderError(tr("GitHub: \u043E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u043C\u0430\u0441\u0441\u0438\u0432 \u0432 \u043E\u0442\u0432\u0435\u0442\u0435 \u043D\u0430 \u0441\u043F\u0438\u0441\u043E\u043A", "GitHub: expected an array in the list response"));
+          items.push(...chunk);
+          if (chunk.length < 100) break;
+        }
+        return items;
+      }
+      async graphql(queryText, variables) {
+        const args = ["graphql", "-f", `query=${queryText}`];
+        for (const [key, value] of Object.entries(variables)) {
+          if (value === null || value === void 0) continue;
+          args.push(typeof value === "number" ? "-F" : "-f", `${key}=${value}`);
+        }
+        const data = await this.json(args);
+        if (data.errors?.length) throw new ProviderError(`GitHub GraphQL: ${data.errors.map((item) => item.message).join("; ")}`);
+        if (!data.data) throw new ProviderError(tr("GitHub GraphQL: \u043F\u0443\u0441\u0442\u043E\u0439 \u043E\u0442\u0432\u0435\u0442", "GitHub GraphQL: empty response"));
+        return data.data;
+      }
+      async info() {
+        if (this.infoCache) return this.infoCache;
+        const pr = await this.json([this.pullBase]);
+        const state = pr.merged_at ? "merged" : String(pr.state ?? "");
+        const info = {
+          ref: this.ref,
+          title: String(pr.title ?? ""),
+          description: String(pr.body ?? ""),
+          author: pr.user?.login ?? "",
+          authorName: pr.user?.name ?? "",
+          state,
+          draft: Boolean(pr.draft),
+          sourceBranch: String(pr.head?.ref ?? ""),
+          targetBranch: String(pr.base?.ref ?? ""),
+          webUrl: String(pr.html_url ?? ""),
+          commit: { base: String(pr.base?.sha ?? ""), start: String(pr.base?.sha ?? ""), head: String(pr.head?.sha ?? "") },
+          updatedAt: String(pr.updated_at ?? ""),
+          stats: {
+            files: Number(pr.changed_files ?? 0),
+            additions: Number(pr.additions ?? 0),
+            deletions: Number(pr.deletions ?? 0)
+          }
+        };
+        this.infoCache = info;
+        return info;
+      }
+      async diff() {
+        const files = await this.paged(`${this.pullBase}/files`);
+        const chunks = [];
+        for (const file of files) {
+          const oldPath = file.previous_filename ?? file.filename;
+          const newPath = file.filename;
+          let header = `diff --git a/${oldPath} b/${newPath}
+`;
+          if (file.status === "added") header += "new file mode 100644\n--- /dev/null\n+++ b/";
+          else if (file.status === "removed") header += "deleted file mode 100644\n--- a/";
+          else if (file.status === "renamed") header += `rename from ${oldPath}
+rename to ${newPath}
+--- a/${oldPath}
++++ b/`;
+          else header += `--- a/${oldPath}
++++ b/`;
+          header += file.status === "removed" ? "/dev/null\n" : `${newPath}
+`;
+          if (!file.patch) {
+            chunks.push(`${header}Binary files differ
+`);
+            continue;
+          }
+          chunks.push(header + file.patch);
+        }
+        return parseUnifiedDiff(chunks.join("\n"));
+      }
+      async threads() {
+        const nodes = [];
+        let after = null;
+        for (let page = 0; page < 10; page++) {
+          const data = await this.graphql(THREADS_QUERY, {
+            owner: this.owner,
+            name: this.name,
+            number: this.ref.number,
+            after
+          });
+          const connection = data.repository?.pullRequest?.reviewThreads;
+          if (!connection) throw new ProviderError(tr("GitHub: \u0442\u0440\u0435\u0434\u044B \u0440\u0435\u0432\u044C\u044E \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u044B (\u043D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430?)", "GitHub: review threads not found (no access?)"));
+          nodes.push(...connection.nodes);
+          if (!connection.pageInfo.hasNextPage) break;
+          after = connection.pageInfo.endCursor;
+        }
+        return nodes.filter((node) => node.comments.nodes.length > 0).map((node) => {
+          const notes = node.comments.nodes.map((comment) => this.mapGqlNote(comment));
+          return {
+            id: node.id,
+            path: node.path,
+            line: node.line ?? node.originalLine,
+            side: node.diffSide === "LEFT" ? "old" : "new",
+            resolvable: true,
+            resolved: node.isResolved,
+            notes,
+            updatedAt: notes[notes.length - 1]?.createdAt ?? ""
+          };
+        });
+      }
+      mapGqlNote(comment) {
+        return {
+          id: String(comment.databaseId ?? comment.id),
+          author: comment.author?.login ?? "?",
+          authorName: "",
+          createdAt: String(comment.createdAt ?? ""),
+          body: String(comment.body ?? ""),
+          system: false
+        };
+      }
+      async currentUser() {
+        if (this.me) return this.me;
+        const user = await this.json(["user"]);
+        this.me = { username: user.login, name: user.name ?? "" };
+        return this.me;
+      }
+      async list(options = {}) {
+        const limit = Math.min(options.limit ?? 50, 100);
+        if (options.scope === "reviewing") {
+          const search = await this.json([
+            query("search/issues", { q: `repo:${this.repo} is:pr is:open review-requested:@me`, per_page: limit })
+          ]);
+          return (search.items ?? []).map((item) => ({
+            ref: { ...this.ref, number: item.number },
+            title: item.title,
+            author: item.user?.login ?? "",
+            updatedAt: item.updated_at,
+            state: item.state,
+            draft: Boolean(item.draft),
+            webUrl: item.html_url
+          }));
+        }
+        const pulls = await this.paged(`repos/${this.repo}/pulls`, { state: "open", sort: "updated", direction: "desc" });
+        const me = options.scope === "mine" ? (await this.currentUser()).username : null;
+        return pulls.filter((pull) => !me || pull.user?.login === me).slice(0, limit).map((pull) => ({
+          ref: { ...this.ref, number: pull.number },
+          title: pull.title,
+          author: pull.user?.login ?? "",
+          updatedAt: pull.updated_at,
+          state: pull.state,
+          draft: Boolean(pull.draft),
+          webUrl: pull.html_url
+        }));
+      }
+      async findByBranch(branch) {
+        const pulls = await this.json([query(`repos/${this.repo}/pulls`, { state: "open", head: `${this.owner}:${branch}`, per_page: 1 })]);
+        const first = Array.isArray(pulls) ? pulls[0] : void 0;
+        return first ? { ...this.ref, number: first.number } : null;
+      }
+      async reply(thread, body) {
+        const root = thread.notes[0]?.id;
+        if (!root) throw new ProviderError(tr("\u0432 \u0442\u0440\u0435\u0434\u0435 \u043D\u0435\u0442 \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u044F, \u043D\u0430 \u043A\u043E\u0442\u043E\u0440\u044B\u0439 \u043C\u043E\u0436\u043D\u043E \u043E\u0442\u0432\u0435\u0442\u0438\u0442\u044C", "the thread has no comment to reply to"));
+        const comment = await withTempJson(
+          { body },
+          async (file) => this.json(["--method", "POST", `${this.pullBase}/comments/${root}/replies`, "--input", file])
+        );
+        return {
+          id: String(comment.id),
+          author: comment.user?.login ?? "?",
+          authorName: "",
+          createdAt: comment.created_at,
+          body: comment.body,
+          system: false
+        };
+      }
+      async resolve(threadId, resolved) {
+        const mutation = resolved ? "mutation($id: ID!) { resolveReviewThread(input: { threadId: $id }) { thread { isResolved } } }" : "mutation($id: ID!) { unresolveReviewThread(input: { threadId: $id }) { thread { isResolved } } }";
+        await this.graphql(mutation, { id: threadId });
+      }
+      async react(noteId, emoji) {
+        const content = REACTIONS[emoji];
+        if (!content) throw new ProviderError(tr(`GitHub \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442 \u0440\u0435\u0430\u043A\u0446\u0438\u044E ${emoji}`, `GitHub does not support reaction ${emoji}`));
+        const base = `repos/${this.repo}/pulls/comments/${noteId}/reactions`;
+        const existing = await this.json([query(base, { per_page: 100 })]);
+        const me = await this.currentUser();
+        const mine = existing.find((item) => item.content === content && item.user?.login === me.username);
+        if (mine) {
+          await this.call(["--method", "DELETE", `${base}/${mine.id}`]);
+          return { active: false };
+        }
+        await withTempJson({ content }, async (file) => {
+          await this.call(["--method", "POST", base, "--input", file]);
+        });
+        return { active: true };
+      }
+      async createThread(input) {
+        if (input.line === null) {
+          const comment2 = await withTempJson(
+            { body: input.body },
+            async (file) => this.json(["--method", "POST", `repos/${this.repo}/issues/${this.ref.number}/comments`, "--input", file])
+          );
+          return { discussionId: `issue-${comment2.id}`, noteId: String(comment2.id) };
+        }
+        const info = await this.info();
+        if (!info.commit.head) throw new ProviderError(tr("GitHub \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B head SHA: \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 \u043A \u0441\u0442\u0440\u043E\u043A\u0435 \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u0435\u043D", "GitHub did not return the head SHA: a line comment is not possible"));
+        const payload = {
+          body: input.body,
+          commit_id: info.commit.head,
+          path: input.file,
+          line: input.line,
+          side: "RIGHT"
+        };
+        const comment = await withTempJson(
+          payload,
+          async (file) => this.json(["--method", "POST", `${this.pullBase}/comments`, "--input", file])
+        );
+        return { discussionId: `gh-${comment.id}`, noteId: String(comment.id) };
+      }
+    };
+  }
+});
+
+// src/daemon/main.ts
+import { existsSync as existsSync4, readFileSync } from "node:fs";
+import { appendFile, open as open2, readFile as readFile3, unlink as unlink3 } from "node:fs/promises";
+import net2 from "node:net";
+import path7 from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+// src/core/paths.ts
+import { existsSync } from "node:fs";
+import { lstat, mkdir, open, realpath, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+function findRepoRoot(start = process.cwd()) {
+  let dir = path.resolve(start);
+  for (; ; ) {
+    if (existsSync(path.join(dir, ".git"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return path.resolve(start);
+    dir = parent;
+  }
+}
+var CONFIG_FILES = [".revdeck.yml", ".revdeck.yaml"];
+function findConfigFile(root) {
+  for (const name of CONFIG_FILES) {
+    const candidate = path.join(root, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function stateDir() {
+  if (process.env.REVDECK_STATE_DIR) return path.resolve(process.env.REVDECK_STATE_DIR);
+  const base = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+  return path.join(base, "revdeck");
+}
+function runtimeDir() {
+  if (process.env.REVDECK_RUNTIME_DIR) return path.resolve(process.env.REVDECK_RUNTIME_DIR);
+  const base = process.env.XDG_RUNTIME_DIR || path.join(os.tmpdir(), `revdeck-${process.getuid?.() ?? "user"}`);
+  return path.join(base, "revdeck");
+}
+function socketPath() {
+  return path.join(runtimeDir(), "daemon.sock");
+}
+function daemonInfoPath() {
+  return path.join(stateDir(), "daemon.json");
+}
+function logPath() {
+  return path.join(stateDir(), "daemon.log");
+}
+function databasePath() {
+  return path.join(stateDir(), "revdeck.sqlite3");
+}
+async function ensureDir(dir, mode = 448) {
+  await mkdir(dir, { recursive: true, mode });
+  const info = await lstat(dir);
+  if (!info.isDirectory()) throw new Error(`${dir}: expected a directory`);
+  if (process.platform !== "win32") {
+    const { chmod: chmod2 } = await import("node:fs/promises");
+    await chmod2(dir, mode);
+  }
+}
+async function readTextNoFollow(file, maxBytes = 4 * 1024 * 1024) {
+  const info = await lstat(file);
+  if (info.isSymbolicLink()) throw new Error(`${path.basename(file)}: symbolic link, read refused`);
+  if (!info.isFile()) throw new Error(`${path.basename(file)}: not a regular file`);
+  if (info.size > maxBytes) throw new Error(`${path.basename(file)}: file is larger than ${Math.round(maxBytes / 1024)} KB`);
+  const handle = await open(file, "r");
+  try {
+    return await handle.readFile({ encoding: "utf8" });
+  } finally {
+    await handle.close();
+  }
+}
+async function writeFileAtomic(file, data, mode = 384) {
+  await ensureDir(path.dirname(file));
+  const tmp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Date.now().toString(36)}.tmp`);
+  let handle;
+  try {
+    handle = await open(tmp, "wx", mode);
+    await handle.writeFile(data, "utf8");
+    await handle.sync();
+  } finally {
+    await handle?.close();
+  }
+  try {
+    await rename(tmp, file);
+  } catch (error) {
+    await unlink(tmp).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/daemon/main.ts
+init_redact();
+
+// src/version.ts
+var VERSION = "0.1.0";
+var PROTOCOL_VERSION = 1;
+
+// src/daemon/main.ts
+init_locale();
+
+// src/daemon/store.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import path2 from "node:path";
+
+// src/core/types.ts
+var LEVELS = ["blocker", "major", "minor", "question"];
+
+// src/core/refs.ts
+function reviewId(ref) {
+  return `${ref.platform}:${ref.host}/${ref.project}!${ref.number}`;
+}
+var GITLAB_URL = /^(?:https?:\/\/)?([^/]+)\/(.+?)\/-\/merge_requests\/(\d+)(?:[/?#].*)?$/;
+var GITHUB_URL = /^(?:https?:\/\/)?([^/]+)\/([^/]+\/[^/]+)\/pull\/(\d+)(?:[/?#].*)?$/;
+function parseReviewUrl(input) {
+  const value = input.trim();
+  const gitlab = GITLAB_URL.exec(value);
+  if (gitlab) {
+    return { platform: "gitlab", host: gitlab[1], project: gitlab[2], number: Number(gitlab[3]) };
+  }
+  const github = GITHUB_URL.exec(value);
+  if (github) {
+    return { platform: "github", host: github[1], project: github[2], number: Number(github[3]) };
+  }
+  const short = /^(.+?)([#!])(\d+)$/.exec(value);
+  if (short) {
+    return {
+      platform: short[2] === "!" ? "gitlab" : "github",
+      host: short[2] === "!" ? "gitlab.com" : "github.com",
+      project: short[1],
+      number: Number(short[3])
+    };
+  }
+  throw new Error(
+    "could not parse the MR/PR reference: expected https://<host>/<project>/-/merge_requests/<N> or https://<host>/<owner>/<repo>/pull/<N>, or project!N / owner/repo#N"
+  );
+}
+function isLevel(value) {
+  return typeof value === "string" && LEVELS.includes(value);
+}
+function normalizeLevel(value) {
+  return isLevel(value) ? value : "question";
+}
+
+// src/daemon/store.ts
+function text(row, key) {
+  const value = row[key];
+  return value === null || value === void 0 ? "" : String(value);
+}
+function json(row, key, fallback) {
+  const value = row[key];
+  if (typeof value !== "string" || !value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+var Store = class {
+  db;
+  constructor(file) {
+    if (file !== ":memory:") mkdirSync(path2.dirname(file), { recursive: true, mode: 448 });
+    this.db = new DatabaseSync(file);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.db.exec("PRAGMA busy_timeout = 5000");
+    this.migrate();
+  }
+  close() {
+    this.db.close();
+  }
+  migrate() {
+    this.db.exec(`
+            CREATE TABLE IF NOT EXISTS reviews (
+                id TEXT PRIMARY KEY,
+                platform TEXT NOT NULL,
+                host TEXT NOT NULL,
+                project TEXT NOT NULL,
+                number INTEGER NOT NULL,
+                title TEXT NOT NULL,
+                author TEXT NOT NULL,
+                state TEXT NOT NULL,
+                web_url TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                synced_at TEXT NOT NULL,
+                root TEXT NOT NULL,
+                info_json TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS review_data (
+                review_id TEXT PRIMARY KEY REFERENCES reviews(id) ON DELETE CASCADE,
+                diff_json TEXT NOT NULL,
+                threads_json TEXT NOT NULL,
+                config_json TEXT NOT NULL,
+                config_path TEXT,
+                errors_json TEXT NOT NULL,
+                synced_at TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS summaries (
+                review_id TEXT PRIMARY KEY REFERENCES reviews(id) ON DELETE CASCADE,
+                title TEXT NOT NULL,
+                scope TEXT NOT NULL,
+                summary TEXT NOT NULL,
+                changes_json TEXT NOT NULL,
+                focus_json TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS findings (
+                review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+                id TEXT NOT NULL,
+                fingerprint TEXT NOT NULL,
+                level TEXT NOT NULL,
+                file TEXT NOT NULL,
+                line INTEGER,
+                end_line INTEGER,
+                title TEXT NOT NULL,
+                body TEXT NOT NULL,
+                comment TEXT NOT NULL,
+                status TEXT NOT NULL,
+                discussion_id TEXT,
+                published_at TEXT,
+                decision TEXT,
+                note TEXT NOT NULL,
+                publish_error TEXT NOT NULL DEFAULT '',
+                updated_at TEXT NOT NULL,
+                PRIMARY KEY (review_id, id)
+            );
+            CREATE TABLE IF NOT EXISTS drafts (
+                review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+                thread_id TEXT NOT NULL,
+                body TEXT NOT NULL,
+                resolve INTEGER NOT NULL,
+                note_for_agent TEXT NOT NULL,
+                agent_action TEXT NOT NULL,
+                posted TEXT NOT NULL,
+                replied INTEGER NOT NULL,
+                resolved INTEGER NOT NULL,
+                error TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                PRIMARY KEY (review_id, thread_id)
+            );
+            CREATE TABLE IF NOT EXISTS notes (
+                review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+                id TEXT NOT NULL,
+                file TEXT NOT NULL,
+                line INTEGER NOT NULL,
+                side TEXT NOT NULL,
+                text TEXT NOT NULL,
+                to_agent INTEGER NOT NULL,
+                agent_action TEXT NOT NULL,
+                agent_reply TEXT NOT NULL,
+                posted TEXT NOT NULL,
+                discussion_id TEXT NOT NULL,
+                note_id TEXT NOT NULL,
+                error TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                PRIMARY KEY (review_id, id)
+            );
+            CREATE TABLE IF NOT EXISTS decisions (
+                review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+                finding_id TEXT NOT NULL,
+                decision TEXT,
+                note TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                PRIMARY KEY (review_id, finding_id)
+            );
+            CREATE TABLE IF NOT EXISTS approvals (
+                id TEXT PRIMARY KEY,
+                review_id TEXT NOT NULL,
+                kind TEXT NOT NULL,
+                hash TEXT NOT NULL,
+                items_json TEXT NOT NULL,
+                expires_at TEXT NOT NULL,
+                used_at TEXT,
+                created_at TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS audit (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                at TEXT NOT NULL,
+                review_id TEXT,
+                action TEXT NOT NULL,
+                detail TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS audit_review ON audit(review_id, at);
+        `);
+  }
+  saveReview(info, root, syncedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+    const id = reviewId(info.ref);
+    this.db.prepare(
+      `INSERT INTO reviews (id, platform, host, project, number, title, author, state, web_url, updated_at, synced_at, root, info_json)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(id) DO UPDATE SET
+                   title = excluded.title, author = excluded.author, state = excluded.state,
+                   web_url = excluded.web_url, updated_at = excluded.updated_at,
+                   synced_at = excluded.synced_at, root = excluded.root, info_json = excluded.info_json`
+    ).run(
+      id,
+      info.ref.platform,
+      info.ref.host,
+      info.ref.project,
+      info.ref.number,
+      info.title,
+      info.author,
+      info.state,
+      info.webUrl,
+      info.updatedAt,
+      syncedAt,
+      root,
+      JSON.stringify(info)
+    );
+    return id;
+  }
+  saveSnapshot(id, snapshot) {
+    this.db.prepare(
+      `INSERT INTO review_data (review_id, diff_json, threads_json, config_json, config_path, errors_json, synced_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(review_id) DO UPDATE SET
+                   diff_json = excluded.diff_json, threads_json = excluded.threads_json,
+                   config_json = excluded.config_json, config_path = excluded.config_path,
+                   errors_json = excluded.errors_json, synced_at = excluded.synced_at`
+    ).run(
+      id,
+      JSON.stringify(snapshot.diff),
+      JSON.stringify(snapshot.threads),
+      JSON.stringify(snapshot.config),
+      snapshot.configPath,
+      JSON.stringify(snapshot.errors),
+      snapshot.syncedAt
+    );
+    this.db.prepare("UPDATE reviews SET synced_at = ? WHERE id = ?").run(snapshot.syncedAt, id);
+  }
+  listReviews() {
+    const rows = this.db.prepare("SELECT * FROM reviews ORDER BY synced_at DESC").all();
+    return rows.map((row) => ({
+      id: text(row, "id"),
+      platform: text(row, "platform"),
+      host: text(row, "host"),
+      project: text(row, "project"),
+      number: Number(row.number),
+      title: text(row, "title"),
+      author: text(row, "author"),
+      state: text(row, "state"),
+      webUrl: text(row, "web_url"),
+      updatedAt: text(row, "updated_at"),
+      syncedAt: text(row, "synced_at"),
+      root: text(row, "root")
+    }));
+  }
+  getReview(id) {
+    const row = this.db.prepare("SELECT * FROM reviews WHERE id = ?").get(id);
+    if (!row) return null;
+    const data = this.db.prepare("SELECT * FROM review_data WHERE review_id = ?").get(id);
+    if (!data) return null;
+    return {
+      row: {
+        id: text(row, "id"),
+        platform: text(row, "platform"),
+        host: text(row, "host"),
+        project: text(row, "project"),
+        number: Number(row.number),
+        title: text(row, "title"),
+        author: text(row, "author"),
+        state: text(row, "state"),
+        web_url: text(row, "web_url"),
+        updated_at: text(row, "updated_at"),
+        synced_at: text(row, "synced_at"),
+        root: text(row, "root")
+      },
+      snapshot: {
+        diff: json(data, "diff_json", []),
+        threads: json(data, "threads_json", []),
+        config: json(data, "config_json", {}),
+        configPath: data.config_path ? String(data.config_path) : null,
+        errors: json(data, "errors_json", []),
+        syncedAt: text(data, "synced_at")
+      }
+    };
+  }
+  info(id) {
+    const row = this.db.prepare("SELECT info_json FROM reviews WHERE id = ?").get(id);
+    if (!row) return null;
+    return json(row, "info_json", null);
+  }
+  removeReview(id) {
+    this.db.prepare("DELETE FROM reviews WHERE id = ?").run(id);
+  }
+  // --- summary ---
+  getSummary(id) {
+    const row = this.db.prepare("SELECT * FROM summaries WHERE review_id = ?").get(id);
+    if (!row) return null;
+    return {
+      title: text(row, "title"),
+      scope: text(row, "scope"),
+      summary: text(row, "summary"),
+      changes: json(row, "changes_json", []),
+      focus: json(row, "focus_json", [])
+    };
+  }
+  setSummary(id, summary) {
+    this.db.prepare(
+      `INSERT INTO summaries (review_id, title, scope, summary, changes_json, focus_json, updated_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(review_id) DO UPDATE SET
+                   title = excluded.title, scope = excluded.scope, summary = excluded.summary,
+                   changes_json = excluded.changes_json, focus_json = excluded.focus_json, updated_at = excluded.updated_at`
+    ).run(id, summary.title, summary.scope, summary.summary, JSON.stringify(summary.changes), JSON.stringify(summary.focus), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  // --- findings ---
+  listFindings(id) {
+    const rows = this.db.prepare("SELECT * FROM findings WHERE review_id = ? ORDER BY rowid").all(id);
+    return rows.map((row) => ({
+      id: text(row, "id"),
+      fingerprint: text(row, "fingerprint"),
+      level: text(row, "level"),
+      file: text(row, "file"),
+      line: row.line === null || row.line === void 0 ? null : Number(row.line),
+      endLine: row.end_line === null || row.end_line === void 0 ? null : Number(row.end_line),
+      title: text(row, "title"),
+      body: text(row, "body"),
+      comment: text(row, "comment"),
+      status: text(row, "status"),
+      discussionId: row.discussion_id ? String(row.discussion_id) : null,
+      publishedAt: row.published_at ? String(row.published_at) : null,
+      decision: row.decision ? String(row.decision) : null,
+      note: text(row, "note"),
+      publishError: text(row, "publish_error")
+    }));
+  }
+  replaceFindings(id, findings) {
+    this.transaction(() => {
+      this.db.prepare("DELETE FROM findings WHERE review_id = ?").run(id);
+      const insert = this.db.prepare(
+        `INSERT INTO findings (review_id, id, fingerprint, level, file, line, end_line, title, body, comment, status, discussion_id, published_at, decision, note, publish_error, updated_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const finding of findings) {
+        insert.run(
+          id,
+          finding.id,
+          finding.fingerprint,
+          finding.level,
+          finding.file,
+          finding.line,
+          finding.endLine,
+          finding.title,
+          finding.body,
+          finding.comment,
+          finding.status,
+          finding.discussionId,
+          finding.publishedAt,
+          finding.decision,
+          finding.note,
+          finding.publishError,
+          now
+        );
+      }
+    });
+  }
+  updateFinding(id, finding) {
+    this.db.prepare(
+      `UPDATE findings SET level = ?, file = ?, line = ?, end_line = ?, title = ?, body = ?, comment = ?,
+                   status = ?, discussion_id = ?, published_at = ?, decision = ?, note = ?, publish_error = ?, updated_at = ?
+                 WHERE review_id = ? AND id = ?`
+    ).run(
+      finding.level,
+      finding.file,
+      finding.line,
+      finding.endLine,
+      finding.title,
+      finding.body,
+      finding.comment,
+      finding.status,
+      finding.discussionId,
+      finding.publishedAt,
+      finding.decision,
+      finding.note,
+      finding.publishError,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      id,
+      finding.id
+    );
+  }
+  // --- drafts ---
+  listDrafts(id) {
+    const rows = this.db.prepare("SELECT * FROM drafts WHERE review_id = ? ORDER BY rowid").all(id);
+    return rows.map((row) => ({
+      threadId: text(row, "thread_id"),
+      body: text(row, "body"),
+      resolve: Number(row.resolve) === 1,
+      noteForAgent: text(row, "note_for_agent"),
+      agentAction: text(row, "agent_action"),
+      posted: text(row, "posted"),
+      replied: Number(row.replied) === 1,
+      resolved: Number(row.resolved) === 1,
+      error: text(row, "error"),
+      updatedAt: text(row, "updated_at")
+    }));
+  }
+  getDraft(id, threadId) {
+    return this.listDrafts(id).find((draft) => draft.threadId === threadId) ?? null;
+  }
+  upsertDraft(id, draft) {
+    this.db.prepare(
+      `INSERT INTO drafts (review_id, thread_id, body, resolve, note_for_agent, agent_action, posted, replied, resolved, error, updated_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(review_id, thread_id) DO UPDATE SET
+                   body = excluded.body, resolve = excluded.resolve, note_for_agent = excluded.note_for_agent,
+                   agent_action = excluded.agent_action, posted = excluded.posted, replied = excluded.replied,
+                   resolved = excluded.resolved, error = excluded.error, updated_at = excluded.updated_at`
+    ).run(
+      id,
+      draft.threadId,
+      draft.body,
+      draft.resolve ? 1 : 0,
+      draft.noteForAgent,
+      draft.agentAction,
+      draft.posted,
+      draft.replied ? 1 : 0,
+      draft.resolved ? 1 : 0,
+      draft.error,
+      draft.updatedAt
+    );
+  }
+  // --- notes ---
+  listNotes(id) {
+    const rows = this.db.prepare("SELECT * FROM notes WHERE review_id = ? ORDER BY created_at").all(id);
+    return rows.map((row) => ({
+      id: text(row, "id"),
+      file: text(row, "file"),
+      line: Number(row.line),
+      side: text(row, "side"),
+      text: text(row, "text"),
+      toAgent: Number(row.to_agent) === 1,
+      agentAction: text(row, "agent_action"),
+      agentReply: text(row, "agent_reply"),
+      posted: text(row, "posted"),
+      discussionId: text(row, "discussion_id"),
+      noteId: text(row, "note_id"),
+      error: text(row, "error"),
+      createdAt: text(row, "created_at"),
+      updatedAt: text(row, "updated_at")
+    }));
+  }
+  upsertNote(id, note) {
+    this.db.prepare(
+      `INSERT INTO notes (review_id, id, file, line, side, text, to_agent, agent_action, agent_reply, posted, discussion_id, note_id, error, created_at, updated_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(review_id, id) DO UPDATE SET
+                   file = excluded.file, line = excluded.line, side = excluded.side, text = excluded.text,
+                   to_agent = excluded.to_agent, agent_action = excluded.agent_action, agent_reply = excluded.agent_reply,
+                   posted = excluded.posted, discussion_id = excluded.discussion_id, note_id = excluded.note_id,
+                   error = excluded.error, updated_at = excluded.updated_at`
+    ).run(
+      id,
+      note.id,
+      note.file,
+      note.line,
+      note.side,
+      note.text,
+      note.toAgent ? 1 : 0,
+      note.agentAction,
+      note.agentReply,
+      note.posted,
+      note.discussionId,
+      note.noteId,
+      note.error,
+      note.createdAt,
+      note.updatedAt
+    );
+  }
+  deleteNote(id, noteId) {
+    this.db.prepare("DELETE FROM notes WHERE review_id = ? AND id = ?").run(id, noteId);
+  }
+  // --- decisions ---
+  listDecisions(id) {
+    const rows = this.db.prepare("SELECT * FROM decisions WHERE review_id = ?").all(id);
+    const out = {};
+    for (const row of rows) {
+      out[text(row, "finding_id")] = {
+        decision: row.decision ? String(row.decision) : null,
+        note: text(row, "note")
+      };
+    }
+    return out;
+  }
+  setDecisions(id, patch) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.transaction(() => {
+      const stmt = this.db.prepare(
+        `INSERT INTO decisions (review_id, finding_id, decision, note, updated_at) VALUES (?, ?, ?, ?, ?)
+                 ON CONFLICT(review_id, finding_id) DO UPDATE SET decision = excluded.decision, note = excluded.note, updated_at = excluded.updated_at`
+      );
+      for (const [findingId, value] of Object.entries(patch)) {
+        stmt.run(id, findingId, value.decision, value.note, now);
+      }
+    });
+  }
+  // --- approvals ---
+  createApproval(record) {
+    this.db.prepare("INSERT INTO approvals (id, review_id, kind, hash, items_json, expires_at, used_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(record.id, record.reviewId, record.kind, record.hash, JSON.stringify(record.items), record.expiresAt, record.usedAt, record.createdAt);
+  }
+  getApproval(id) {
+    const row = this.db.prepare("SELECT * FROM approvals WHERE id = ?").get(id);
+    if (!row) return null;
+    return {
+      id: text(row, "id"),
+      reviewId: text(row, "review_id"),
+      kind: text(row, "kind"),
+      hash: text(row, "hash"),
+      items: json(row, "items_json", []),
+      expiresAt: text(row, "expires_at"),
+      usedAt: row.used_at ? String(row.used_at) : null,
+      createdAt: text(row, "created_at")
+    };
+  }
+  markApprovalUsed(id) {
+    this.db.prepare("UPDATE approvals SET used_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  // --- audit ---
+  audit(reviewId2, action, detail) {
+    this.db.prepare("INSERT INTO audit (at, review_id, action, detail) VALUES (?, ?, ?, ?)").run((/* @__PURE__ */ new Date()).toISOString(), reviewId2, action, JSON.stringify(detail));
+  }
+  auditTail(limit = 100) {
+    const rows = this.db.prepare("SELECT * FROM audit ORDER BY id DESC LIMIT ?").all(limit);
+    return rows.map((row) => ({
+      at: text(row, "at"),
+      reviewId: text(row, "review_id"),
+      action: text(row, "action"),
+      detail: text(row, "detail")
+    }));
+  }
+  transaction(fn) {
+    this.db.exec("BEGIN");
+    try {
+      fn();
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+};
+
+// src/daemon/service.ts
+init_redact();
+init_errors();
+import { EventEmitter } from "node:events";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+
+// src/core/config.ts
+import { z } from "zod";
+init_errors();
+import { parse as parseYaml } from "yaml";
+import { existsSync as existsSync2 } from "node:fs";
+import path3 from "node:path";
+
+// src/core/glob.ts
+function globToRegExp(glob) {
+  let source = "";
+  let index = 0;
+  const pattern = glob.replace(/^\.\//, "").replace(/^\/+/, "");
+  while (index < pattern.length) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        if (pattern[index + 2] === "/") {
+          source += "(?:[^/]+/)*";
+          index += 3;
+        } else {
+          source += ".*";
+          index += 2;
+        }
+      } else {
+        source += "[^/]*";
+        index += 1;
+      }
+      continue;
+    }
+    if (char === "?") {
+      source += "[^/]";
+      index += 1;
+      continue;
+    }
+    if (char === "{") {
+      const end = pattern.indexOf("}", index);
+      if (end > index) {
+        const options = pattern.slice(index + 1, end).split(",").map((item) => escapeRegExp(item.trim()));
+        source += `(?:${options.join("|")})`;
+        index = end + 1;
+        continue;
+      }
+    }
+    source += escapeRegExp(char);
+    index += 1;
+  }
+  return new RegExp(`^${source}$`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function classifyFile(path8) {
+  const lower = path8.toLowerCase();
+  if (/(^|\/)(node_modules|dist|build|coverage|vendor)\//.test(lower)) return "generated";
+  if (/\.(md|mdx|rst|txt|adoc)$/.test(lower) || /(^|\/)(docs?|adr)\//.test(lower)) return "docs";
+  if (/(^|\/)(__tests__|tests?|spec|e2e)\//.test(lower) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(lower) || /_test\.go$/.test(lower)) return "test";
+  if (/\.(css|scss|sass|less|styl)$/.test(lower)) return "style";
+  if (/(^|\/)(package(-lock)?\.json|pnpm-lock\.yaml|yarn\.lock|tsconfig[^/]*\.json|[^/]*\.config\.[cm]?[jt]s|\.eslintrc[^/]*|\.prettierrc[^/]*|Dockerfile|Makefile|\.github\/workflows\/|\.gitlab-ci\.yml)/.test(lower)) return "config";
+  if (/\.(generated|g)\.[cm]?[jt]s$|\.d\.ts$|(^|\/)generated\//.test(lower)) return "generated";
+  if (/\.(ts|tsx|js|jsx|mjs|cjs|vue|svelte|py|go|rs|java|kt|rb|php|cs|c|cpp|h|hpp|swift|scala|ex|exs)$/.test(lower)) return "app";
+  return "other";
+}
+
+// src/core/config.ts
+init_locale();
+var matchSchema = z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]);
+var reviewConfigSchema = z.object({
+  version: z.literal(1).default(1),
+  provider: z.object({
+    /** auto — по git remote; иначе явная платформа. */
+    type: z.enum(["auto", "gitlab", "github"]).default("auto"),
+    host: z.string().min(1).optional(),
+    /** GitLab: group/project. GitHub: owner/repo. */
+    project: z.string().min(1).optional(),
+    /** База для локального diff, когда ревью идёт по ветке. */
+    base: z.string().min(1).optional()
+  }).prefault({}),
+  output: z.object({
+    language: z.enum(["auto", "ru", "en"]).default("auto")
+  }).prefault({}),
+  rules: z.object({
+    /** Общие документы, если ни одна строка map не подошла. Пусто — автообнаружение. */
+    sources: z.array(z.string().min(1)).default([]),
+    /** Привязка путей к документам: match — glob, docs — пути с необязательной секцией `#…`. */
+    map: z.array(
+      z.object({
+        match: matchSchema,
+        docs: z.array(z.string().min(1)).min(1),
+        note: z.string().optional()
+      })
+    ).default([]),
+    /** Пути, которые не ревьюятся (сгенерированный код и т.п.). */
+    ignore: z.array(z.string().min(1)).default([])
+  }).prefault({}),
+  checks: z.array(
+    z.object({
+      id: z.string().min(1),
+      name: z.string().optional(),
+      /** argv без shell: первым идёт исполняемый файл. */
+      argv: z.array(z.string()).min(1),
+      /** Запускать, только если diff затронул эти glob-пути. */
+      when: z.array(z.string()).default([]),
+      consent: z.boolean().default(true),
+      timeoutMs: z.number().int().positive().max(36e5).default(3e5)
+    })
+  ).default([]),
+  publish: z.object({
+    requireApproval: z.boolean().default(true),
+    maxComments: z.number().int().positive().max(200).default(50)
+  }).prefault({})
+});
+var DISCOVERED_SOURCES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "CONTRIBUTING.md",
+  "docs/ARCHITECTURE.md",
+  "docs/Architecture.md",
+  "docs/STYLEGUIDE.md",
+  "docs/Styleguide.md",
+  "docs/CONTRIBUTING.md"
+];
+function parseConfig(text2, source = ".revdeck.yml") {
+  let data;
+  try {
+    data = parseYaml(text2);
+  } catch (error) {
+    throw new ConfigError(tr(`${source}: \u043D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 YAML: ${error.message}`, `${source}: invalid YAML: ${error.message}`));
+  }
+  if (data === null || data === void 0) data = {};
+  const result = reviewConfigSchema.safeParse(data);
+  if (!result.success) {
+    const issues = result.error.issues.slice(0, 10).map((issue) => `${issue.path.join(".") || "<\u043A\u043E\u0440\u0435\u043D\u044C>"}: ${issue.message}`).join("; ");
+    throw new ConfigError(`${source}: ${issues}`, tr("\u043F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 \u0441\u0445\u0435\u043C\u0443 \u0432 docs/configuration.md", "check the schema in docs/configuration.md"));
+  }
+  return result.data;
+}
+async function loadConfig(root = findRepoRoot()) {
+  const warnings = [];
+  const file = findConfigFile(root);
+  let config;
+  if (file) {
+    config = parseConfig(await readTextNoFollow(file), path3.relative(root, file) || file);
+  } else {
+    config = reviewConfigSchema.parse({});
+    warnings.push(tr("\u0444\u0430\u0439\u043B .revdeck.yml \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: \u043F\u0440\u0430\u0432\u0438\u043B\u0430 \u0432\u0437\u044F\u0442\u044B \u0438\u0437 \u0430\u0432\u0442\u043E\u043E\u0431\u043D\u0430\u0440\u0443\u0436\u0435\u043D\u043D\u044B\u0445 \u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u043E\u0432", ".revdeck.yml not found: rules come from auto-discovered documents"));
+  }
+  if (!config.rules.sources.length && !config.rules.map.length) {
+    const found = DISCOVERED_SOURCES.filter((item) => existsSync2(path3.join(root, item)));
+    config.rules.sources = found;
+    if (!found.length) {
+      warnings.push(tr("\u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u044B \u0441 \u043F\u0440\u0430\u0432\u0438\u043B\u0430\u043C\u0438 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u044B: \u0440\u0435\u0432\u044C\u044E \u0431\u0443\u0434\u0435\u0442 \u043E\u043F\u0438\u0440\u0430\u0442\u044C\u0441\u044F \u0442\u043E\u043B\u044C\u043A\u043E \u043D\u0430 \u043A\u043E\u0434 \u0438 \u0437\u0434\u0440\u0430\u0432\u044B\u0439 \u0441\u043C\u044B\u0441\u043B", "no rule documents found: the review will rely on the code only"));
+    }
+  }
+  return { config, path: file, warnings };
+}
+function assertConfigPath(root, relative) {
+  const cleaned = relative.split("#")[0];
+  const resolved = path3.resolve(root, cleaned);
+  const rel = path3.relative(root, resolved);
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
+    throw new ConfigError(tr(`\u043F\u0443\u0442\u044C ${relative} \u0432\u044B\u0445\u043E\u0434\u0438\u0442 \u0437\u0430 \u043F\u0440\u0435\u0434\u0435\u043B\u044B \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F`, `path ${relative} escapes the repository`));
+  }
+  return resolved;
+}
+function checksForPaths(config, paths) {
+  return config.checks.map((check) => {
+    const matched = !check.when.length || paths.some((file) => check.when.some((pattern) => globToRegExp(pattern).test(file)));
+    return { id: check.id, name: check.name ?? check.id, argv: check.argv, consent: check.consent, matched };
+  });
+}
+
+// src/core/rules.ts
+import path4 from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+init_redact();
+var MAX_DOC_BYTES = 96 * 1024;
+var MAX_TOTAL_BYTES = 320 * 1024;
+async function buildEffectiveRules(options) {
+  const { root, config, configPath } = options;
+  const language = options.language ?? "ru";
+  const t = (ru, en) => language === "ru" ? ru : en;
+  const warnings = [];
+  const files = options.files.filter((file) => !config.rules.ignore.some((pattern) => globToRegExp(pattern).test(file)));
+  const ignored = options.files.length - files.length;
+  if (ignored > 0) warnings.push(`${ignored} ${t("\u0444\u0430\u0439\u043B(\u043E\u0432) \u0438\u0441\u043A\u043B\u044E\u0447\u0435\u043D\u044B \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u043E\u0439 rules.ignore", "file(s) excluded by rules.ignore")}`);
+  const cache = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  const readDoc = async (selector) => {
+    const [rawPath] = selector.split("#");
+    const relative = rawPath;
+    let resolved;
+    try {
+      resolved = assertConfigPath(root, relative);
+    } catch (error) {
+      warnings.push(`${relative}: ${error.message}`);
+      return { path: relative, exists: false, sections: [], excerpt: "", truncated: false };
+    }
+    let cached = cache.get(resolved);
+    if (!cached) {
+      if (!existsSync3(resolved)) {
+        cached = { exists: false, text: "", truncated: false };
+        warnings.push(`${t("\u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442", "document")} ${relative} ${t("\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D", "not found")}`);
+      } else {
+        try {
+          const raw = await readTextNoFollow(resolved, MAX_DOC_BYTES * 2);
+          const truncated = raw.length > MAX_DOC_BYTES;
+          cached = { exists: true, text: truncated ? raw.slice(0, MAX_DOC_BYTES) : raw, truncated };
+        } catch (error) {
+          cached = { exists: false, text: "", truncated: false };
+          warnings.push(`${relative}: ${redactLine(error)}`);
+        }
+      }
+      cache.set(resolved, cached);
+    }
+    const selectors = selector.includes("#") ? [selector.slice(selector.indexOf("#") + 1)] : [];
+    const excerpt = extractExcerpt(cached.text, selectors, relative, warnings, language);
+    totalBytes += excerpt.length;
+    return { path: relative, exists: cached.exists, sections: selectors, excerpt, truncated: cached.truncated };
+  };
+  const scopes = [];
+  for (const file of files) {
+    const docs = /* @__PURE__ */ new Set();
+    for (const entry of config.rules.map) {
+      const patterns = Array.isArray(entry.match) ? entry.match : [entry.match];
+      if (patterns.some((pattern) => globToRegExp(pattern).test(file))) {
+        for (const doc of entry.docs) docs.add(doc);
+      }
+    }
+    if (!docs.size) {
+      for (const doc of config.rules.sources) docs.add(doc);
+      if (!docs.size) {
+        warnings.push(`${file}: ${t("\u043D\u0435\u0442 \u043F\u0440\u0430\u0432\u0438\u043B \u2014 \u043F\u0443\u0442\u044C \u043D\u0435 \u0441\u043E\u043F\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D \u0432 rules.map, \u0430 rules.sources \u043F\u0443\u0441\u0442", "no rules \u2014 the path is not mapped in rules.map and rules.sources is empty")}`);
+      }
+    }
+    const documents = [];
+    for (const doc of docs) {
+      if (totalBytes > MAX_TOTAL_BYTES) {
+        warnings.push(t("\u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442 \u043F\u0440\u0430\u0432\u0438\u043B \u043E\u0431\u0440\u0435\u0437\u0430\u043D: \u043F\u0440\u0435\u0432\u044B\u0448\u0435\u043D \u043B\u0438\u043C\u0438\u0442 \u0440\u0430\u0437\u043C\u0435\u0440\u0430", "rules context truncated: size limit exceeded"));
+        break;
+      }
+      documents.push(await readDoc(doc));
+    }
+    scopes.push({ file, kind: classifyFile(file), documents });
+  }
+  if (!files.length) {
+    const documents = [];
+    for (const doc of config.rules.sources) documents.push(await readDoc(doc));
+    if (!documents.length) warnings.push(t("\u043E\u0431\u0449\u0438\u0435 \u043F\u0440\u0430\u0432\u0438\u043B\u0430: rules.sources \u043F\u0443\u0441\u0442, \u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u044B \u043D\u0435 \u0432\u044B\u0431\u0440\u0430\u043D\u044B", "general rules: rules.sources is empty, no documents selected"));
+    scopes.push({ file: "", kind: "other", documents });
+  }
+  return {
+    configPath: configPath ? path4.relative(root, configPath) : null,
+    scopes,
+    checks: checksForPaths(config, files),
+    warnings: [...new Set(warnings)]
+  };
+}
+function extractExcerpt(text2, selectors, label, warnings, language = "ru") {
+  const t = (ru, en) => language === "ru" ? ru : en;
+  if (!text2) return "";
+  if (!selectors.length) return text2;
+  const parts = [];
+  for (const selector of selectors) {
+    const range = /^L?(\d+)(?:-L?(\d+))?$/.exec(selector.trim());
+    if (range) {
+      const start = Number(range[1]);
+      const end = range[2] ? Number(range[2]) : start;
+      const lines = text2.split("\n");
+      if (start < 1 || end < start || start > lines.length) {
+        warnings.push(`${label}#${selector}: ${t("\u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D \u0441\u0442\u0440\u043E\u043A \u0432\u043D\u0435 \u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442\u0430", "line range is outside the document")}`);
+        continue;
+      }
+      parts.push(lines.slice(start - 1, Math.min(end, lines.length)).join("\n"));
+      continue;
+    }
+    const section = headingSection(text2, selector);
+    if (section === null) {
+      warnings.push(`${label}#${selector}: ${t("\u0441\u0435\u043A\u0446\u0438\u044F \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430", "section not found")}`);
+      continue;
+    }
+    parts.push(section);
+  }
+  return parts.join("\n\n");
+}
+var HEADING = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
+function headingSection(text2, wanted) {
+  const lines = text2.split("\n");
+  const target = normalizeHeading(wanted);
+  let start = -1;
+  let level = 0;
+  for (let index = 0; index < lines.length; index++) {
+    const match = HEADING.exec(lines[index]);
+    if (!match) continue;
+    if (normalizeHeading(match[2]) === target) {
+      start = index;
+      level = match[1].length;
+      break;
+    }
+  }
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index++) {
+    const match = HEADING.exec(lines[index]);
+    if (match && match[1].length <= level) {
+      end = index;
+      break;
+    }
+  }
+  return lines.slice(start, end).join("\n").trimEnd();
+}
+function normalizeHeading(value) {
+  return value.replace(/^#+/, "").replace(/[*_`]/g, "").replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function renderRules(rules, options = {}) {
+  const maxBytes = options.maxBytes ?? 2e5;
+  const withExcerpts = options.withExcerpts ?? true;
+  const language = options.language ?? "ru";
+  const t = (ru, en) => language === "ru" ? ru : en;
+  const out = [];
+  out.push(`# ${t("\u041F\u0440\u0430\u0432\u0438\u043B\u0430 \u0440\u0435\u0432\u044C\u044E", "Review rules")}${rules.configPath ? ` (${rules.configPath})` : ` (${t("\u0430\u0432\u0442\u043E\u043E\u0431\u043D\u0430\u0440\u0443\u0436\u0435\u043D\u0438\u0435", "auto-discovery")})`}`);
+  if (rules.warnings.length) out.push(`${t("\u041F\u0440\u0435\u0434\u0443\u043F\u0440\u0435\u0436\u0434\u0435\u043D\u0438\u044F", "Warnings")}:
+${rules.warnings.map((item) => `- ${item}`).join("\n")}`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const scope of rules.scopes) {
+    out.push(`
+## ${scope.file || `(${t("\u043E\u0431\u0449\u0438\u0435 \u043F\u0440\u0430\u0432\u0438\u043B\u0430", "general rules")})`} \u2014 ${scope.kind}`);
+    for (const doc of scope.documents) {
+      const key = `${doc.path}#${doc.sections.join(",")}`;
+      const label = `${doc.path}${doc.sections.length ? `#${doc.sections.join(", ")}` : ""}`;
+      out.push(`- ${label}${doc.exists ? "" : ` (${t("\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D", "not found")})`}`);
+      if (!withExcerpts || !doc.exists) continue;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(`
+> ${label}
+
+${doc.excerpt}${doc.truncated ? `
+
+[${t("\u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442 \u043E\u0431\u0440\u0435\u0437\u0430\u043D", "document truncated")}]` : ""}`);
+      if (out.join("\n").length > maxBytes) {
+        out.push(`
+[${t("\u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442 \u043F\u0440\u0430\u0432\u0438\u043B \u043E\u0431\u0440\u0435\u0437\u0430\u043D \u043F\u043E \u0440\u0430\u0437\u043C\u0435\u0440\u0443", "rules context truncated by size")}]`);
+        return out.join("\n");
+      }
+    }
+  }
+  if (rules.checks.length) {
+    out.push(`
+## ${t("\u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0438 \u043F\u0440\u043E\u0435\u043A\u0442\u0430", "Project checks")}`);
+    for (const check of rules.checks) {
+      out.push(`- ${check.id}${check.matched ? "" : ` (${t("\u043D\u0435 \u043E\u0442\u043D\u043E\u0441\u0438\u0442\u0441\u044F \u043A diff", "does not match the diff")})`}: \`${check.argv.join(" ")}\`${check.consent ? ` \u2014 ${t("\u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u0441\u043E\u0433\u043B\u0430\u0441\u0438\u044F \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F", "requires user consent")}` : ""}`);
+    }
+  }
+  return out.join("\n");
+}
+
+// src/daemon/service.ts
+init_diff();
+
+// src/core/sanitize.ts
+init_locale();
+var CONTROL_OR_HIDDEN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u00ad\u061c\u115f\u1160\u180e\u200b-\u200f\u2028-\u202e\u2060-\u206f\u2800\u3164\ufeff\uffa0]/;
+var QUICK_ACTION = /^[\s\p{Z}\p{Cf}]*\/[a-z_]+(?=[\s\p{Z}\p{Cf}]|$)/imu;
+var MASS_MENTION = /(^|[^\w@./-])@(all|here|everyone)(?![\w-])/i;
+var MD_IMAGE = /!\[[^\]]*\]\s*\(|!\[[^\]]*\]\s*\[/;
+var HTML_TAG = /<(?:img|script|iframe|style|video|audio|object|embed|svg|math)\b/i;
+var HTML_COMMENT = /<!--/;
+var MAX_LENGTH = 64 * 1024;
+function sanitizeBody(body, platform, options = {}) {
+  const text2 = String(body ?? "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const maxLength = options.maxLength ?? MAX_LENGTH;
+  const checkQuickActions = options.quickActions ?? platform === "gitlab";
+  if (text2.trim() === "") return { ok: false, reason: tr("\u0442\u0435\u043A\u0441\u0442 \u043F\u0443\u0441\u0442", "the text is empty"), text: text2 };
+  if (text2.length > maxLength) return { ok: false, reason: tr(`\u0442\u0435\u043A\u0441\u0442 \u0434\u043B\u0438\u043D\u043D\u0435\u0435 ${maxLength} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432`, `the text is longer than ${maxLength} characters`), text: text2 };
+  if (CONTROL_OR_HIDDEN.test(text2)) return { ok: false, reason: tr("\u0432 \u0442\u0435\u043A\u0441\u0442\u0435 \u0435\u0441\u0442\u044C \u0443\u043F\u0440\u0430\u0432\u043B\u044F\u044E\u0449\u0438\u0435 \u0438\u043B\u0438 \u043D\u0435\u0432\u0438\u0434\u0438\u043C\u044B\u0435 \u0441\u0438\u043C\u0432\u043E\u043B\u044B", "the text contains control or invisible characters"), text: text2 };
+  if (HTML_COMMENT.test(text2)) return { ok: false, reason: tr("\u0432 \u0442\u0435\u043A\u0441\u0442\u0435 \u0435\u0441\u0442\u044C HTML-\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439", "the text contains an HTML comment"), text: text2 };
+  if (HTML_TAG.test(text2)) return { ok: false, reason: tr("\u0432 \u0442\u0435\u043A\u0441\u0442\u0435 \u0435\u0441\u0442\u044C HTML-\u0442\u0435\u0433", "the text contains an HTML tag"), text: text2 };
+  if (MD_IMAGE.test(text2)) return { ok: false, reason: tr("\u0432 \u0442\u0435\u043A\u0441\u0442\u0435 \u0435\u0441\u0442\u044C \u043A\u0430\u0440\u0442\u0438\u043D\u043A\u0430: \u0437\u0430\u043C\u0435\u043D\u0438\u0442\u0435 \u0441\u0441\u044B\u043B\u043A\u043E\u0439", "the text contains an image: replace it with a link"), text: text2 };
+  if (MASS_MENTION.test(text2)) return { ok: false, reason: tr("\u043C\u0430\u0441\u0441\u043E\u0432\u043E\u0435 \u0443\u043F\u043E\u043C\u0438\u043D\u0430\u043D\u0438\u0435: \u0443\u043A\u0430\u0436\u0438\u0442\u0435 \u043A\u043E\u043D\u043A\u0440\u0435\u0442\u043D\u044B\u0445 \u043B\u044E\u0434\u0435\u0439", "mass mention: name specific people"), text: text2 };
+  if (checkQuickActions && QUICK_ACTION.test(text2)) {
+    return { ok: false, reason: tr("\u0441\u0442\u0440\u043E\u043A\u0430-\u043A\u043E\u043C\u0430\u043D\u0434\u0430 GitLab (/approve, /merge \u2026): \u043F\u0435\u0440\u0435\u0444\u0440\u0430\u0437\u0438\u0440\u0443\u0439\u0442\u0435", "GitLab quick action line (/approve, /merge \u2026): rephrase it"), text: text2 };
+  }
+  return { ok: true, reason: "", text: text2 };
+}
+
+// src/core/findings.ts
+import { createHash } from "node:crypto";
+init_locale();
+var LEVEL_ORDER = { blocker: 0, major: 1, minor: 2, question: 3 };
+function validateFinding(raw) {
+  if (!raw || typeof raw !== "object") return { value: null, error: tr("\u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043E\u0431\u044A\u0435\u043A\u0442\u043E\u043C", "a finding must be an object") };
+  const item = raw;
+  const file = typeof item.file === "string" ? item.file.trim() : "";
+  const title = typeof item.title === "string" ? item.title.trim() : "";
+  const body = typeof item.body === "string" ? item.body.trim() : "";
+  const comment = typeof item.comment === "string" ? item.comment.trim() : body;
+  if (!file) return { value: null, error: tr("\u043D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D file", "file is required") };
+  if (!title) return { value: null, error: tr("\u043D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D title", "title is required") };
+  if (!comment) return { value: null, error: tr("\u043F\u0443\u0441\u0442\u043E\u0439 comment", "comment is empty") };
+  const line = item.line === null || item.line === void 0 || item.line === "" ? null : Number(item.line);
+  if (line !== null && (!Number.isInteger(line) || line < 1)) return { value: null, error: tr(`\u043D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 line: ${String(item.line)}`, `invalid line: ${String(item.line)}`) };
+  const endLine = item.endLine === null || item.endLine === void 0 ? null : Number(item.endLine);
+  if (endLine !== null && (!Number.isInteger(endLine) || line === null || endLine < line)) {
+    return { value: null, error: tr("endLine \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 line", "endLine must be greater than or equal to line") };
+  }
+  const level = normalizeLevel(item.level);
+  if (item.level !== void 0 && !LEVELS.includes(String(item.level))) {
+    return { value: null, error: tr(`\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 level: ${String(item.level)} (\u043E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${LEVELS.join(", ")})`, `unknown level: ${String(item.level)} (expected ${LEVELS.join(", ")})`) };
+  }
+  return {
+    value: {
+      ...typeof item.id === "string" && item.id ? { id: item.id } : {},
+      level,
+      file,
+      line,
+      endLine,
+      title,
+      body,
+      comment
+    },
+    error: ""
+  };
+}
+function fingerprintOf(input) {
+  return createHash("sha256").update(`${input.file.trim().toLowerCase()}|${input.level}|${input.title.trim().toLowerCase().replace(/\s+/g, " ")}`).digest("hex");
+}
+function mergeFindings(previous, incoming, options = {}) {
+  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const byId = new Map(previous.map((item) => [item.id, item]));
+  const byFingerprint = new Map(previous.map((item) => [item.fingerprint, item]));
+  const byPlace = new Map(previous.filter((item) => item.line !== null).map((item) => [`${item.file}:${item.line}:${item.level}`, item]));
+  const used = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const draft of incoming) {
+    const fingerprint = fingerprintOf(draft);
+    const match = (draft.id ? byId.get(draft.id) : void 0) ?? byFingerprint.get(fingerprint) ?? (draft.line !== null ? byPlace.get(`${draft.file}:${draft.line}:${draft.level}`) : void 0);
+    if (match) {
+      used.add(match.id);
+      result.push({
+        ...match,
+        level: draft.level,
+        file: draft.file,
+        line: draft.line,
+        endLine: draft.endLine ?? null,
+        title: draft.title,
+        body: draft.body,
+        // Опубликованный текст не переписываем: он уже виден автору MR.
+        comment: match.status === "published" ? match.comment : draft.comment,
+        status: match.status === "stale" ? "draft" : match.status,
+        fingerprint
+      });
+      continue;
+    }
+    const id = draft.id && !used.has(draft.id) ? draft.id : uniqueId(fingerprint, used, byId);
+    used.add(id);
+    result.push({
+      id,
+      fingerprint,
+      level: draft.level,
+      file: draft.file,
+      line: draft.line,
+      endLine: draft.endLine ?? null,
+      title: draft.title,
+      body: draft.body,
+      comment: draft.comment,
+      status: "draft",
+      discussionId: null,
+      publishedAt: null,
+      decision: null,
+      note: "",
+      publishError: ""
+    });
+  }
+  for (const old of previous) {
+    if (used.has(old.id)) continue;
+    result.push({
+      ...old,
+      status: old.status === "published" ? "published" : "stale"
+    });
+  }
+  return result.sort((a, b) => levelOrder(a.level) - levelOrder(b.level) || a.file.localeCompare(b.file) || (a.line ?? 0) - (b.line ?? 0));
+}
+function uniqueId(fingerprint, used, byId) {
+  for (let length = 8; length <= fingerprint.length; length += 2) {
+    const candidate = `f-${fingerprint.slice(0, length)}`;
+    if (!used.has(candidate) && !byId.has(candidate)) return candidate;
+  }
+  return `f-${fingerprint}`;
+}
+function levelOrder(level) {
+  return LEVEL_ORDER[level];
+}
+function applyDecisions(findings, decisions) {
+  return findings.map((item) => {
+    const decision = decisions[item.id];
+    if (!decision) return item;
+    return { ...item, decision: decision.decision, note: decision.note };
+  });
+}
+
+// src/core/canonical.ts
+function canonicalJson(value) {
+  return JSON.stringify(normalize(value));
+}
+function normalize(value) {
+  if (Array.isArray(value)) return value.map(normalize);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const item = value[key];
+      if (item !== void 0) out[key] = normalize(item);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/daemon/service.ts
+init_locale();
+
+// src/core/git.ts
+init_exec();
+var SSH_SCP = /^(?:ssh:\/\/)?(?:[^@/]+@)?([^:/]+)(?::(\d+))?[:/](.+?)(?:\.git)?\/?$/;
+function parseRemote(url) {
+  const value = url.trim();
+  if (!value) return null;
+  let host = "";
+  let projectPath = "";
+  const http2 = /^(?:https?|git|ssh):\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/.exec(value);
+  if (http2) {
+    host = http2[1];
+    projectPath = http2[2];
+  } else {
+    const scp = SSH_SCP.exec(value);
+    if (!scp) return null;
+    host = scp[1];
+    projectPath = scp[3];
+  }
+  projectPath = projectPath.replace(/\/+$/, "").replace(/\.git$/, "");
+  if (!host || !projectPath || !projectPath.includes("/")) return null;
+  return { host, project: projectPath, platform: detectPlatform(host), url: value };
+}
+function detectPlatform(host) {
+  const lower = host.toLowerCase();
+  if (lower === "github.com" || lower.endsWith(".github.com") || lower.includes("github")) return "github";
+  if (lower === "gitlab.com" || lower.endsWith(".gitlab.com") || lower.includes("gitlab")) return "gitlab";
+  return null;
+}
+async function gitRemote(root, remote = "origin") {
+  try {
+    const { stdout } = await run("git", ["config", "--get", `remote.${remote}.url`], { cwd: root, timeoutMs: 1e4 });
+    return parseRemote(stdout.trim());
+  } catch {
+    return null;
+  }
+}
+async function currentBranch(root) {
+  try {
+    const { stdout } = await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: root, timeoutMs: 1e4 });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+
+// src/providers/provider.ts
+init_errors();
+init_locale();
+async function projectContext(root, config, overrides = {}) {
+  const remote = await gitRemote(root);
+  const platform = overrides.platform ?? (config.provider.type !== "auto" ? config.provider.type : remote?.platform ?? void 0);
+  const host = overrides.host ?? config.provider.host ?? remote?.host;
+  const project = overrides.project ?? config.provider.project ?? remote?.project;
+  if (!platform) {
+    throw new ProviderError(
+      tr("\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043F\u043B\u0430\u0442\u0444\u043E\u0440\u043C\u0443: \u0443\u043A\u0430\u0436\u0438\u0442\u0435 provider.type \u0432 .revdeck.yml \u0438\u043B\u0438 --platform", "could not determine the platform: set provider.type in .revdeck.yml or pass --platform"),
+      tr("git remote \u043D\u0435 \u043F\u043E\u0445\u043E\u0436 \u043D\u0430 GitHub/GitLab (\u0441\u0430\u043C\u043E\u0441\u0442\u043E\u044F\u0442\u0435\u043B\u044C\u043D\u044B\u0439 \u0445\u043E\u0441\u0442 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u0435 \u044F\u0432\u043D\u043E)", "git remote does not look like GitHub/GitLab (set a self-hosted platform explicitly)")
+    );
+  }
+  if (!host || !project) {
+    throw new ProviderError(tr("\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u0445\u043E\u0441\u0442 \u0438 \u043F\u0440\u043E\u0435\u043A\u0442", "could not determine host and project"), tr("\u0443\u043A\u0430\u0436\u0438\u0442\u0435 project \u0438 host \u0432 .revdeck.yml \u0438\u043B\u0438 \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 URL \u0440\u0435\u0432\u044C\u044E", "set project and host in .revdeck.yml or pass the review URL"));
+  }
+  return { platform, host, project };
+}
+async function resolveReviewRef(options) {
+  const { root, config, input } = options;
+  if (input && /^(https?:)?\/\//.test(input.trim())) {
+    return parseReviewUrl(input);
+  }
+  const context = await projectContext(root, config, {
+    ...options.platform ? { platform: options.platform } : {},
+    ...options.project ? { project: options.project } : {},
+    ...options.host ? { host: options.host } : {}
+  });
+  if (input && /^\d+$/.test(input.trim())) {
+    return { ...context, number: Number(input.trim()) };
+  }
+  if (input && /^[^#!]+[#!]\d+$/.test(input.trim())) {
+    return parseReviewUrl(input);
+  }
+  if (input) throw new ProviderError(tr(`\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u0442\u044C \u0440\u0435\u0432\u044C\u044E: ${input}`, `could not parse the review: ${input}`));
+  const branch = options.branch ?? await currentBranch(root);
+  if (!branch || branch === "HEAD") {
+    throw new ProviderError(tr("\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u0432\u0435\u0442\u043A\u0443 \u0434\u043B\u044F \u043F\u043E\u0438\u0441\u043A\u0430 \u0440\u0435\u0432\u044C\u044E", "could not determine the branch to search for a review"), tr("\u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u043D\u043E\u043C\u0435\u0440 \u0440\u0435\u0432\u044C\u044E \u044F\u0432\u043D\u043E", "pass the review number explicitly"));
+  }
+  const probe = await createProvider({ ...context, number: 0 }, { root });
+  const found = await probe.findByBranch(branch);
+  if (!found) throw new ProviderError(tr(`\u043E\u0442\u043A\u0440\u044B\u0442\u043E\u0435 \u0440\u0435\u0432\u044C\u044E \u0434\u043B\u044F \u0432\u0435\u0442\u043A\u0438 ${branch} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`, `no open review found for branch ${branch}`), tr("\u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u043D\u043E\u043C\u0435\u0440 \u0440\u0435\u0432\u044C\u044E \u044F\u0432\u043D\u043E", "pass the review number explicitly"));
+  return found;
+}
+async function createProvider(ref, options) {
+  if (ref.platform === "gitlab") {
+    const { GitLabProvider: GitLabProvider2 } = await Promise.resolve().then(() => (init_gitlab(), gitlab_exports));
+    return new GitLabProvider2(ref, options);
+  }
+  const { GitHubProvider: GitHubProvider2 } = await Promise.resolve().then(() => (init_github(), github_exports));
+  return new GitHubProvider2(ref, options);
+}
+
+// src/daemon/service.ts
+init_exec();
+
+// src/daemon/view.ts
+init_diff();
+var STALE_AFTER_MS = 9e4;
+function fileSummaries(diff) {
+  return diff.map((file) => {
+    let additions = 0;
+    let deletions = 0;
+    for (const hunk of file.hunks) {
+      for (const line of hunk.lines) {
+        if (line.kind === "+") additions++;
+        else if (line.kind === "-") deletions++;
+      }
+    }
+    return { path: file.path, oldPath: file.oldPath, status: file.status, binary: file.binary, additions, deletions };
+  });
+}
+function toReviewView(review, now = Date.now()) {
+  const { diff, threads, findings, ...rest } = review;
+  return {
+    ...rest,
+    threads: threads.map((thread) => ({
+      ...thread,
+      snippet: thread.path && thread.line ? snippetAround(diff, thread.path, thread.line, 4) : null
+    })),
+    findings: findings.map((finding) => ({
+      ...finding,
+      snippet: finding.file && finding.line ? snippetAround(diff, finding.file, finding.line, 4) : null
+    })),
+    files: fileSummaries(diff),
+    stats: diffStats(diff),
+    stale: now - new Date(review.syncedAt).getTime() > STALE_AFTER_MS
+  };
+}
+
+// src/daemon/service.ts
+var EMPTY_DRAFT = (threadId) => ({
+  threadId,
+  body: "",
+  resolve: false,
+  noteForAgent: "",
+  agentAction: "",
+  posted: "",
+  replied: false,
+  resolved: false,
+  error: "",
+  updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+});
+var APPROVAL_TTL_MS = 10 * 60 * 1e3;
+var ReviewService = class {
+  events = new EventEmitter();
+  store;
+  providerFactory;
+  runImpl;
+  now;
+  refreshTtlMs;
+  syncIntervalMs;
+  timer = null;
+  syncing = false;
+  constructor(options) {
+    this.store = options.store;
+    this.runImpl = options.runImpl ?? run;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.refreshTtlMs = options.refreshTtlMs ?? 6e4;
+    this.syncIntervalMs = options.syncIntervalMs ?? 12e4;
+    this.providerFactory = options.providerFactory ?? (async (ref, root) => createProvider(ref, { root }));
+    this.events.setMaxListeners(50);
+  }
+  close() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.store.close();
+  }
+  // ---------------------------------------------------------------- reviews
+  async openReview(rootInput, options = {}) {
+    const root = findRepoRoot(rootInput);
+    const loaded = await loadConfig(root);
+    const ref = await resolveReviewRef({
+      root,
+      config: loaded.config,
+      ...options.input ? { input: options.input } : {},
+      ...options.platform ? { platform: options.platform } : {},
+      ...options.project ? { project: options.project } : {},
+      ...options.host ? { host: options.host } : {},
+      ...options.branch ? { branch: options.branch } : {}
+    });
+    const id = reviewId(ref);
+    const provider = await this.providerFactory(ref, root);
+    await this.refresh(id, root, provider, loaded);
+    this.store.audit(id, "review.open", { ref, root });
+    return this.getReview(id);
+  }
+  async refreshReview(id) {
+    const meta = this.store.getReview(id);
+    if (!meta) throw new Error(tr(`\u0440\u0435\u0432\u044C\u044E ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E: \u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u043E\u0442\u043A\u0440\u043E\u0439\u0442\u0435 \u0435\u0433\u043E`, `review ${id} not found: open it first`));
+    const loaded = await loadConfig(meta.row.root).catch((error) => ({
+      config: meta.snapshot.config,
+      path: meta.snapshot.configPath,
+      warnings: [tr(`\u043A\u043E\u043D\u0444\u0438\u0433 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${redact(messageOf(error))}`, `config unavailable: ${redact(messageOf(error))}`)]
+    }));
+    const provider = await this.providerFactory(
+      { platform: meta.row.platform, host: meta.row.host, project: meta.row.project, number: meta.row.number },
+      meta.row.root
+    );
+    await this.refresh(id, meta.row.root, provider, loaded);
+    return this.getReview(id);
+  }
+  async refresh(id, root, provider, loaded) {
+    const errors = [...loaded.warnings];
+    const previous = this.store.getReview(id)?.snapshot;
+    let info;
+    try {
+      info = await provider.info();
+    } catch (error) {
+      throw new Error(tr(`\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C \u0440\u0435\u0432\u044C\u044E: ${redact(messageOf(error))}`, `could not read the review: ${redact(messageOf(error))}`));
+    }
+    const syncedAt = this.now().toISOString();
+    let diff = previous?.diff ?? [];
+    try {
+      diff = await provider.diff();
+    } catch (error) {
+      errors.push(`diff: ${redact(messageOf(error))}`);
+    }
+    let threads = previous?.threads ?? [];
+    try {
+      threads = await provider.threads();
+    } catch (error) {
+      errors.push(`${tr("\u0442\u0440\u0435\u0434\u044B", "threads")}: ${redact(messageOf(error))}`);
+    }
+    info.stats = diffStats(diff);
+    this.store.saveReview(info, root, syncedAt);
+    this.store.saveSnapshot(id, {
+      diff,
+      threads,
+      config: loaded.config,
+      configPath: loaded.path,
+      errors,
+      syncedAt
+    });
+    if (diff.length) this.markStaleFindings(id, diff);
+    this.emit(id);
+  }
+  markStaleFindings(id, diff) {
+    const findings = this.store.listFindings(id);
+    if (!findings.length) return;
+    let changed = false;
+    for (const finding of findings) {
+      if (finding.status === "published" || finding.status === "stale") continue;
+      if (finding.line === null) continue;
+      if (!findNewLine(diff, finding.file, finding.line)) {
+        this.store.updateFinding(id, { ...finding, status: "stale" });
+        changed = true;
+      }
+    }
+    if (changed) this.emit(id);
+  }
+  getReview(id) {
+    const stored = this.store.getReview(id);
+    if (!stored) throw new Error(tr(`\u0440\u0435\u0432\u044C\u044E ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`, `review ${id} not found`));
+    const { row, snapshot } = stored;
+    const info = this.store.info(id) ?? fallbackInfo(row);
+    const draftMap = new Map(this.store.listDrafts(id).map((draft) => [draft.threadId, draft]));
+    const threads = snapshot.threads;
+    const drafts = threads.map((thread) => {
+      const saved = draftMap.get(thread.id) ?? EMPTY_DRAFT(thread.id);
+      const desired = saved.resolve !== saved.resolved ? saved.resolve : thread.resolved;
+      return {
+        ...saved,
+        resolved: thread.resolved,
+        resolve: desired,
+        replied: saved.posted.trim() !== "" && saved.body.trim() === saved.posted.trim()
+      };
+    });
+    for (const [threadId, draft] of draftMap) {
+      if (!threads.some((thread) => thread.id === threadId)) drafts.push(draft);
+    }
+    const findings = applyDecisions(this.store.listFindings(id), this.store.listDecisions(id)).sort(
+      (a, b) => levelOrder(a.level) - levelOrder(b.level) || a.file.localeCompare(b.file) || (a.line ?? 0) - (b.line ?? 0)
+    );
+    return {
+      id,
+      info,
+      diff: snapshot.diff,
+      threads,
+      summary: this.store.getSummary(id),
+      findings,
+      drafts,
+      notes: this.store.listNotes(id),
+      decisions: this.store.listDecisions(id),
+      user: null,
+      syncedAt: snapshot.syncedAt,
+      errors: snapshot.errors
+    };
+  }
+  getView(id) {
+    return toReviewView(this.getReview(id), this.now().getTime());
+  }
+  listReviews() {
+    return this.store.listReviews();
+  }
+  async listRemote(rootInput, scope, limit = 50) {
+    const root = findRepoRoot(rootInput);
+    const loaded = await loadConfig(root);
+    const context = await projectContext(root, loaded.config);
+    const provider = await this.providerFactory({ ...context, number: 0 }, root);
+    return { items: await provider.list({ scope, limit }), platform: context.platform, project: context.project };
+  }
+  isStale(id) {
+    const stored = this.store.getReview(id);
+    if (!stored) return true;
+    return this.now().getTime() - new Date(stored.snapshot.syncedAt).getTime() > this.refreshTtlMs;
+  }
+  async refreshIfStale(id) {
+    if (this.isStale(id)) {
+      try {
+        await this.refreshReview(id);
+      } catch {
+      }
+    }
+    return this.getView(id);
+  }
+  diffFile(id, file) {
+    const stored = this.store.getReview(id);
+    if (!stored) return null;
+    const found = stored.snapshot.diff.find((item) => item.path === file);
+    if (!found) return null;
+    return { path: found.path, status: found.status, binary: found.binary, hunks: found.hunks };
+  }
+  // ---------------------------------------------------------------- summary
+  setSummary(id, input) {
+    this.requireReview(id);
+    const value = input ?? {};
+    const list = (item, limit) => (Array.isArray(item) ? item : []).map((entry) => String(entry ?? "").trim()).filter(Boolean).slice(0, limit).map((entry) => entry.slice(0, 2e3));
+    const summary = {
+      title: String(value.title ?? "").slice(0, 500),
+      scope: String(value.scope ?? "").slice(0, 1e3),
+      summary: String(value.summary ?? "").slice(0, 5e3),
+      changes: list(value.changes, 50),
+      focus: list(value.focus, 50)
+    };
+    this.store.setSummary(id, summary);
+    this.emit(id);
+    return summary;
+  }
+  // ---------------------------------------------------------------- findings
+  setFindings(id, raw) {
+    const review = this.getReview(id);
+    if (!Array.isArray(raw)) throw new Error(tr("findings: \u043E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u043C\u0430\u0441\u0441\u0438\u0432", "findings: expected an array"));
+    const existing = this.store.listFindings(id);
+    const knownIds = new Set(existing.map((finding) => finding.id));
+    const knownPrints = new Set(existing.map((finding) => finding.fingerprint));
+    const drafts = [];
+    const errors = [];
+    for (const [index, item] of raw.entries()) {
+      const { value, error } = validateFinding(item);
+      if (!value) {
+        errors.push(`#${index + 1}: ${error}`);
+        continue;
+      }
+      const known = (value.id ? knownIds.has(value.id) : false) || knownPrints.has(fingerprintOf(value));
+      if (!known) {
+        const file = review.diff.find((entry) => entry.path === value.file);
+        if (!file) {
+          errors.push(tr(`#${index + 1}: \u0444\u0430\u0439\u043B\u0430 ${value.file} \u043D\u0435\u0442 \u0432 diff`, `#${index + 1}: file ${value.file} is not in the diff`));
+          continue;
+        }
+        if (value.line !== null && !findNewLine(review.diff, value.file, value.line)) {
+          errors.push(tr(`#${index + 1}: \u0441\u0442\u0440\u043E\u043A\u0430 ${value.file}:${value.line} \u043D\u0435 \u0432\u0445\u043E\u0434\u0438\u0442 \u0432 diff`, `#${index + 1}: line ${value.file}:${value.line} is not in the diff`));
+          continue;
+        }
+      }
+      drafts.push(value);
+    }
+    if (errors.length) throw new Error(tr(`\u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u044F \u043E\u0442\u043A\u043B\u043E\u043D\u0435\u043D\u044B:
+${errors.join("\n")}`, `findings rejected:
+${errors.join("\n")}`));
+    const merged = mergeFindings(this.store.listFindings(id), drafts, { now: this.now().toISOString() });
+    this.store.replaceFindings(id, merged);
+    this.emit(id);
+    return merged;
+  }
+  setDecisions(id, raw) {
+    this.requireReview(id);
+    const patch = {};
+    const input = raw ?? {};
+    for (const [findingId, value] of Object.entries(input)) {
+      const item = value ?? {};
+      const decision = item.decision;
+      patch[findingId] = {
+        decision: decision === "accept" || decision === "reject" || decision === "discuss" ? decision : null,
+        note: String(item.note ?? "").slice(0, 4e3)
+      };
+    }
+    this.store.setDecisions(id, patch);
+    this.emit(id);
+    return this.store.listDecisions(id);
+  }
+  // ---------------------------------------------------------------- drafts
+  setDraft(id, threadId, patch) {
+    const review = this.getReview(id);
+    const thread = review.threads.find((item) => item.id === threadId);
+    if (!thread) throw new Error(tr(`\u0442\u0440\u0435\u0434\u0430 ${threadId} \u043D\u0435\u0442 \u0432 \u044D\u0442\u043E\u043C \u0440\u0435\u0432\u044C\u044E`, `thread ${threadId} is not in this review`));
+    const previous = this.store.getDraft(id, threadId) ?? EMPTY_DRAFT(threadId);
+    const body = patch.body !== void 0 ? String(patch.body).slice(0, 64 * 1024) : previous.body;
+    const resolve = patch.resolve !== void 0 ? Boolean(patch.resolve) : previous.resolve;
+    const next = {
+      ...previous,
+      body,
+      resolve,
+      noteForAgent: patch.noteForAgent !== void 0 ? String(patch.noteForAgent).slice(0, 8e3) : previous.noteForAgent,
+      agentAction: ["fix", "reply", "revise", "skip"].includes(String(patch.agentAction)) ? patch.agentAction : previous.agentAction,
+      resolved: thread.resolved,
+      updatedAt: this.now().toISOString()
+    };
+    next.replied = next.posted.trim() !== "" && next.body.trim() === next.posted.trim();
+    if (body !== previous.body || resolve !== previous.resolve) next.error = "";
+    this.store.upsertDraft(id, next);
+    this.emit(id);
+    return next;
+  }
+  // ---------------------------------------------------------------- notes
+  addNote(id, input) {
+    const review = this.getReview(id);
+    if (!findNewLine(review.diff, input.file, input.line)) {
+      throw new Error(tr(`\u0441\u0442\u0440\u043E\u043A\u0430 ${input.file}:${input.line} \u043D\u0435 \u0432\u0445\u043E\u0434\u0438\u0442 \u0432 diff`, `line ${input.file}:${input.line} is not in the diff`));
+    }
+    const timestamp = this.now().toISOString();
+    const note = {
+      id: `u-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`,
+      file: input.file,
+      line: input.line,
+      side: input.side ?? "new",
+      text: String(input.text ?? "").slice(0, 16e3),
+      toAgent: input.toAgent ?? true,
+      agentAction: "",
+      agentReply: "",
+      posted: "",
+      discussionId: "",
+      noteId: "",
+      error: "",
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    this.store.upsertNote(id, note);
+    this.emit(id);
+    return note;
+  }
+  updateNote(id, noteId, patch) {
+    const existing = this.store.listNotes(id).find((note) => note.id === noteId);
+    if (!existing) throw new Error(tr(`\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u044F ${noteId} \u043D\u0435\u0442`, `comment ${noteId} not found`));
+    const next = {
+      ...existing,
+      text: patch.text !== void 0 ? String(patch.text).slice(0, 16e3) : existing.text,
+      toAgent: patch.toAgent !== void 0 ? Boolean(patch.toAgent) : existing.toAgent,
+      agentAction: ["fix", "reply", ""].includes(String(patch.agentAction)) ? patch.agentAction : existing.agentAction,
+      agentReply: patch.agentReply !== void 0 ? String(patch.agentReply).slice(0, 8e3) : existing.agentReply,
+      posted: patch.posted !== void 0 ? String(patch.posted) : existing.posted,
+      discussionId: patch.discussionId ?? existing.discussionId,
+      noteId: patch.noteId ?? existing.noteId,
+      error: patch.error ?? existing.error,
+      updatedAt: this.now().toISOString()
+    };
+    if (patch.text !== void 0 && patch.text !== existing.text) next.agentReply = patch.agentReply ?? "";
+    this.store.upsertNote(id, next);
+    this.emit(id);
+    return next;
+  }
+  deleteNote(id, noteId) {
+    const existing = this.store.listNotes(id).find((note) => note.id === noteId);
+    if (!existing) return;
+    if (existing.posted) throw new Error(tr("\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 \u0443\u0436\u0435 \u043E\u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u043D: \u0443\u0434\u0430\u043B\u044F\u0442\u044C \u0435\u0433\u043E \u043D\u0443\u0436\u043D\u043E \u0432 \u043F\u043B\u0430\u0442\u0444\u043E\u0440\u043C\u0435", "the comment is already published: delete it in the platform"));
+    this.store.deleteNote(id, noteId);
+    this.emit(id);
+  }
+  // ---------------------------------------------------------------- publish
+  previewPublish(id, kind, ids) {
+    const review = this.getReview(id);
+    const items = [];
+    const warnings = [];
+    const max = this.configOf(id)?.publish?.maxComments ?? 50;
+    for (const itemId of ids) {
+      if (items.length >= max) {
+        warnings.push(tr(`\u0434\u043E\u0441\u0442\u0438\u0433\u043D\u0443\u0442 \u043B\u0438\u043C\u0438\u0442 ${max} \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0435\u0432 \u0437\u0430 \u0440\u0430\u0437`, `limit of ${max} comments per batch reached`));
+        break;
+      }
+      if (kind === "reply") {
+        const thread = review.threads.find((item) => item.id === itemId);
+        const draft = review.drafts.find((item) => item.threadId === itemId);
+        if (!thread || !draft) {
+          warnings.push(tr(`\u0442\u0440\u0435\u0434 ${itemId} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D`, `thread ${itemId} not found`));
+          continue;
+        }
+        const body = draft.body.trim();
+        const alreadyPosted = body !== "" && draft.posted.trim() === body;
+        const resolveChanged = draft.resolve !== thread.resolved;
+        if (!body && !resolveChanged) {
+          warnings.push(tr(`\u0442\u0440\u0435\u0434 ${thread.id.substring(0, 8)}: \u043D\u0435\u0447\u0435\u0433\u043E \u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u0442\u044C`, `thread ${thread.id.substring(0, 8)}: nothing to publish`));
+          continue;
+        }
+        if (body && alreadyPosted && !resolveChanged) {
+          warnings.push(tr(`\u0442\u0440\u0435\u0434 ${thread.id.substring(0, 8)}: \u043E\u0442\u0432\u0435\u0442 \u0443\u0436\u0435 \u043E\u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u043D`, `thread ${thread.id.substring(0, 8)}: reply already published`));
+          continue;
+        }
+        if (body) {
+          const check2 = sanitizeBody(body, review.info.ref.platform);
+          if (!check2.ok) {
+            warnings.push(tr(`\u0442\u0440\u0435\u0434 ${thread.id.substring(0, 8)}: ${check2.reason}`, `thread ${thread.id.substring(0, 8)}: ${check2.reason}`));
+            continue;
+          }
+        }
+        items.push({ kind, id: thread.id, body, resolve: draft.resolve });
+        continue;
+      }
+      if (kind === "finding") {
+        const finding = review.findings.find((item) => item.id === itemId);
+        if (!finding) {
+          warnings.push(tr(`\u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0435 ${itemId} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`, `finding ${itemId} not found`));
+          continue;
+        }
+        if (finding.status === "published") {
+          warnings.push(tr(`\u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0435 ${finding.id} \u0443\u0436\u0435 \u043E\u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u043D\u043E`, `finding ${finding.id} is already published`));
+          continue;
+        }
+        const body = finding.comment.trim();
+        const check2 = sanitizeBody(body, review.info.ref.platform);
+        if (!check2.ok) {
+          warnings.push(tr(`\u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0435 ${finding.id}: ${check2.reason}`, `finding ${finding.id}: ${check2.reason}`));
+          continue;
+        }
+        const finalBody = finding.file && finding.line === null ? `\`${finding.file}\`: ${body}` : body;
+        items.push({
+          kind,
+          id: finding.id,
+          body: finalBody,
+          file: finding.file,
+          line: finding.line,
+          ...finding.line === null ? {} : { side: "new" }
+        });
+        continue;
+      }
+      const note = review.notes.find((item) => item.id === itemId);
+      if (!note) {
+        warnings.push(tr(`\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 ${itemId} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D`, `comment ${itemId} not found`));
+        continue;
+      }
+      if (note.posted) {
+        warnings.push(tr(`\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 ${note.id} \u0443\u0436\u0435 \u043E\u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u043D`, `comment ${note.id} is already published`));
+        continue;
+      }
+      const check = sanitizeBody(note.text, review.info.ref.platform);
+      if (!check.ok) {
+        warnings.push(tr(`\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 ${note.id}: ${check.reason}`, `comment ${note.id}: ${check.reason}`));
+        continue;
+      }
+      items.push({ kind, id: note.id, body: note.text, file: note.file, line: note.line, side: note.side });
+    }
+    return { plan: this.makePlan(id, kind, items), warnings };
+  }
+  makePlan(id, kind, items) {
+    const hash = canonicalHash(id, kind, items);
+    return { reviewId: id, kind, items, hash, createdAt: this.now().toISOString() };
+  }
+  approve(id, kind, ids, expectedHash) {
+    const preview = this.previewPublish(id, kind, ids);
+    if (preview.plan.hash !== expectedHash) {
+      throw new Error(tr("\u043D\u0430\u0431\u043E\u0440 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0441\u044F \u043F\u043E\u0441\u043B\u0435 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F: \u043E\u0431\u043D\u043E\u0432\u0438\u0442\u0435 \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u0443 \u0438 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0434\u0438\u0442\u0435 \u0437\u0430\u043D\u043E\u0432\u043E", "the plan changed after confirmation: refresh and confirm again"));
+    }
+    if (!preview.plan.items.length) throw new Error(tr("\u043D\u0435\u0447\u0435\u0433\u043E \u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u0442\u044C: \u0432 \u0432\u044B\u0431\u0440\u0430\u043D\u043D\u044B\u0445 \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u0445 \u043D\u0435\u0442 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439", "nothing to publish: the selected items have no changes"));
+    const approval = {
+      id: randomBytes(16).toString("hex"),
+      reviewId: id,
+      hash: preview.plan.hash,
+      kind,
+      expiresAt: new Date(this.now().getTime() + APPROVAL_TTL_MS).toISOString(),
+      usedAt: null,
+      createdAt: this.now().toISOString()
+    };
+    this.store.createApproval({
+      id: approval.id,
+      reviewId: id,
+      kind,
+      hash: approval.hash,
+      items: preview.plan.items,
+      expiresAt: approval.expiresAt,
+      usedAt: null,
+      createdAt: approval.createdAt
+    });
+    this.store.audit(id, "publish.approve", { approvalId: approval.id, kind, count: preview.plan.items.length });
+    return approval;
+  }
+  async publish(id, approvalId) {
+    const approval = this.store.getApproval(approvalId);
+    if (!approval) throw new Error(tr("\u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E", "approval not found"));
+    if (approval.reviewId !== id) throw new Error(tr("\u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 \u0432\u044B\u0434\u0430\u043D\u043E \u0434\u043B\u044F \u0434\u0440\u0443\u0433\u043E\u0433\u043E \u0440\u0435\u0432\u044C\u044E", "the approval belongs to another review"));
+    if (approval.usedAt) throw new Error(tr("\u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 \u0443\u0436\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u043E", "the approval has already been used"));
+    if (new Date(approval.expiresAt).getTime() < this.now().getTime()) throw new Error(tr("\u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 \u0438\u0441\u0442\u0435\u043A\u043B\u043E", "the approval has expired"));
+    this.store.markApprovalUsed(approvalId);
+    const stored = this.store.getReview(id);
+    if (!stored) throw new Error(tr(`\u0440\u0435\u0432\u044C\u044E ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`, `review ${id} not found`));
+    const provider = await this.providerFactory(
+      { platform: stored.row.platform, host: stored.row.host, project: stored.row.project, number: stored.row.number },
+      stored.row.root
+    );
+    const review = this.getReview(id);
+    const platform = review.info.ref.platform;
+    const results = [];
+    const startedAt = this.now().toISOString();
+    for (const item of approval.items) {
+      const result = { kind: item.kind, id: item.id, ok: false };
+      results.push(result);
+      try {
+        if (item.kind === "reply") {
+          const thread = review.threads.find((entry) => entry.id === item.id);
+          const draft = this.store.getDraft(id, item.id) ?? EMPTY_DRAFT(item.id);
+          if (!thread) throw new Error(tr("\u0442\u0440\u0435\u0434 \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442", "the thread no longer exists"));
+          const body = String(item.body ?? "").trim();
+          if (body && draft.posted.trim() !== body) {
+            const check = sanitizeBody(body, platform);
+            if (!check.ok) throw new Error(check.reason);
+            await provider.reply(thread, body);
+            draft.posted = body;
+            draft.replied = true;
+            result.ok = true;
+          }
+          if (typeof item.resolve === "boolean" && item.resolve !== thread.resolved) {
+            await provider.resolve(thread.id, item.resolve);
+            draft.resolved = item.resolve;
+            thread.resolved = item.resolve;
+            result.ok = true;
+          }
+          draft.error = "";
+          draft.updatedAt = this.now().toISOString();
+          this.store.upsertDraft(id, draft);
+          this.saveThreads(id, review.threads);
+          result.discussionId = thread.id;
+          continue;
+        }
+        if (item.kind === "finding") {
+          const finding = review.findings.find((entry) => entry.id === item.id);
+          if (!finding) throw new Error(tr("\u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0435 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E", "finding not found"));
+          if (finding.status === "published") {
+            result.ok = true;
+            result.skipped = true;
+            result.discussionId = finding.discussionId ?? void 0;
+            continue;
+          }
+          const body = String(item.body ?? "").trim();
+          const position2 = finding.line !== null ? linePosition(review.diff, finding.file, finding.line) : null;
+          if (finding.line !== null && !position2) throw new Error(tr(`\u0441\u0442\u0440\u043E\u043A\u0430 ${finding.file}:${finding.line} \u043D\u0435 \u0432\u0445\u043E\u0434\u0438\u0442 \u0432 diff`, `line ${finding.file}:${finding.line} is not in the diff`));
+          const created2 = await provider.createThread({
+            file: finding.file,
+            line: finding.line,
+            oldLine: position2?.oldLine ?? null,
+            body
+          });
+          finding.status = "published";
+          finding.discussionId = created2.discussionId;
+          finding.publishedAt = this.now().toISOString();
+          this.store.updateFinding(id, finding);
+          result.ok = true;
+          result.discussionId = created2.discussionId;
+          result.noteId = created2.noteId;
+          continue;
+        }
+        const note = review.notes.find((entry) => entry.id === item.id);
+        if (!note) throw new Error(tr("\u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0439 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D", "comment not found"));
+        if (note.posted) {
+          result.ok = true;
+          result.skipped = true;
+          continue;
+        }
+        const position = linePosition(review.diff, note.file, note.line);
+        if (!position) throw new Error(tr(`\u0441\u0442\u0440\u043E\u043A\u0430 ${note.file}:${note.line} \u043D\u0435 \u0432\u0445\u043E\u0434\u0438\u0442 \u0432 diff`, `line ${note.file}:${note.line} is not in the diff`));
+        const created = await provider.createThread({
+          file: note.file,
+          line: note.line,
+          oldLine: position.oldLine,
+          body: String(item.body ?? "").trim()
+        });
+        note.posted = String(item.body ?? "").trim();
+        note.discussionId = created.discussionId;
+        note.noteId = created.noteId;
+        note.updatedAt = this.now().toISOString();
+        this.store.upsertNote(id, note);
+        result.ok = true;
+        result.discussionId = created.discussionId;
+        result.noteId = created.noteId;
+      } catch (error) {
+        result.error = redact(messageOf(error));
+        this.recordPublishError(id, item, result.error);
+      }
+    }
+    const finishedAt = this.now().toISOString();
+    this.store.audit(id, "publish.commit", {
+      approvalId,
+      kind: approval.kind,
+      ok: results.filter((item) => item.ok).length,
+      failed: results.filter((item) => !item.ok).length
+    });
+    this.emit(id);
+    return { reviewId: id, results, startedAt, finishedAt };
+  }
+  recordPublishError(id, item, error) {
+    if (item.kind === "reply") {
+      const draft = this.store.getDraft(id, item.id);
+      if (draft) this.store.upsertDraft(id, { ...draft, error, updatedAt: this.now().toISOString() });
+      return;
+    }
+    if (item.kind === "finding") {
+      const finding = this.store.listFindings(id).find((entry) => entry.id === item.id);
+      if (finding) this.store.updateFinding(id, { ...finding, publishError: error });
+      return;
+    }
+    const note = this.store.listNotes(id).find((entry) => entry.id === item.id);
+    if (note) this.store.upsertNote(id, { ...note, error, updatedAt: this.now().toISOString() });
+  }
+  saveThreads(id, threads) {
+    const stored = this.store.getReview(id);
+    if (!stored) return;
+    this.store.saveSnapshot(id, { ...stored.snapshot, threads });
+  }
+  // ---------------------------------------------------------------- rules & checks
+  async rules(id) {
+    const stored = this.store.getReview(id);
+    if (!stored) throw new Error(tr(`\u0440\u0435\u0432\u044C\u044E ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`, `review ${id} not found`));
+    const info = this.store.info(id);
+    const texts = [
+      info?.title ?? "",
+      info?.description ?? "",
+      ...stored.snapshot.threads.flatMap((thread) => thread.notes.map((note) => note.body))
+    ];
+    let config = stored.snapshot.config;
+    let configPath = stored.snapshot.configPath;
+    if (!config?.rules) {
+      const loaded = await loadConfig(stored.row.root);
+      config = loaded.config;
+      configPath = loaded.path;
+    }
+    const language = resolveOutputLanguage(config.output?.language ?? "auto", texts);
+    const effective = await buildEffectiveRules({
+      root: stored.row.root,
+      config,
+      configPath,
+      files: changedPaths(stored.snapshot.diff),
+      language
+    });
+    return {
+      markdown: renderRules(effective, { language }),
+      configPath: effective.configPath,
+      warnings: effective.warnings,
+      checks: effective.checks,
+      language
+    };
+  }
+  async runChecks(id, options) {
+    const stored = this.store.getReview(id);
+    if (!stored) throw new Error(tr(`\u0440\u0435\u0432\u044C\u044E ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`, `review ${id} not found`));
+    const { checks } = await this.rules(id);
+    const matched = checks.filter((check) => check.matched && (!options.ids?.length || options.ids.includes(check.id)));
+    const results = [];
+    for (const check of matched) {
+      if (!options.allowRun) {
+        results.push({
+          id: check.id,
+          name: check.name,
+          argv: check.argv,
+          status: "skipped",
+          output: tr("\u0437\u0430\u043F\u0443\u0441\u043A \u043D\u0435 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0451\u043D: \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 revdeck checks --run --yes", "run not confirmed: use revdeck checks --run --yes"),
+          durationMs: 0
+        });
+        continue;
+      }
+      const started = Date.now();
+      try {
+        const { stdout, stderr, code } = await this.runImpl(check.argv[0], check.argv.slice(1), {
+          cwd: stored.row.root,
+          timeoutMs: stored.snapshot.config.checks?.find((item) => item.id === check.id)?.timeoutMs ?? 3e5,
+          maxBuffer: 16 * 1024 * 1024
+        });
+        results.push({
+          id: check.id,
+          name: check.name,
+          argv: check.argv,
+          status: code === 0 ? "passed" : "failed",
+          output: redact(`${stdout}
+${stderr}`.trim()).slice(0, 2e4),
+          durationMs: Date.now() - started
+        });
+      } catch (error) {
+        results.push({
+          id: check.id,
+          name: check.name,
+          argv: check.argv,
+          status: "error",
+          output: redact(messageOf(error)).slice(0, 2e4),
+          durationMs: Date.now() - started
+        });
+      }
+    }
+    this.store.audit(id, "checks.run", { count: results.length });
+    return results;
+  }
+  // ---------------------------------------------------------------- sync
+  startSync() {
+    if (this.timer || this.syncIntervalMs <= 0) return;
+    this.timer = setInterval(() => {
+      void this.syncAll();
+    }, this.syncIntervalMs);
+    this.timer.unref?.();
+  }
+  async syncAll() {
+    if (this.syncing) return;
+    this.syncing = true;
+    try {
+      const reviews = this.store.listReviews();
+      for (let index = 0; index < reviews.length; index += 2) {
+        const chunk = reviews.slice(index, index + 2);
+        await Promise.allSettled(
+          chunk.map(async (item) => {
+            const age = this.now().getTime() - new Date(item.syncedAt).getTime();
+            if (age < this.syncIntervalMs / 2) return;
+            try {
+              await this.refreshReview(item.id);
+            } catch {
+            }
+          })
+        );
+      }
+    } finally {
+      this.syncing = false;
+    }
+  }
+  // ---------------------------------------------------------------- helpers
+  emit(id) {
+    this.events.emit("review", { reviewId: id, at: this.now().toISOString() });
+  }
+  requireReview(id) {
+    if (!this.store.getReview(id)) throw new Error(`\u0440\u0435\u0432\u044C\u044E ${id} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E`);
+  }
+  changedFiles(id) {
+    const stored = this.store.getReview(id);
+    return stored ? changedPaths(stored.snapshot.diff) : [];
+  }
+  diffFor(id) {
+    return this.store.getReview(id)?.snapshot.diff ?? [];
+  }
+  threadSnippet(id, file, line) {
+    if (line === null) return null;
+    return snippetAround(this.diffFor(id), file, line, 4);
+  }
+  configOf(id) {
+    return this.store.getReview(id)?.snapshot.config ?? null;
+  }
+  rootOf(id) {
+    return this.store.getReview(id)?.row.root ?? null;
+  }
+};
+function canonicalHash(reviewId2, kind, items) {
+  return createHash2("sha256").update(canonicalJson({ reviewId: reviewId2, kind, items })).digest("hex");
+}
+function fallbackInfo(row) {
+  return {
+    ref: { platform: row.platform, host: row.host, project: row.project, number: row.number },
+    title: row.title,
+    description: "",
+    author: row.author,
+    authorName: "",
+    state: row.state,
+    draft: false,
+    sourceBranch: "",
+    targetBranch: "",
+    webUrl: row.web_url,
+    commit: { base: "", start: "", head: "" },
+    updatedAt: row.updated_at,
+    stats: { files: 0, additions: 0, deletions: 0 }
+  };
+}
+
+// src/daemon/http.ts
+init_redact();
+init_errors();
+import http from "node:http";
+import { createReadStream } from "node:fs";
+import { readFile as readFile2, stat } from "node:fs/promises";
+import path6 from "node:path";
+import { timingSafeEqual } from "node:crypto";
+
+// src/daemon/rpc.ts
+import net from "node:net";
+import { chmod, unlink as unlink2 } from "node:fs/promises";
+init_redact();
+init_errors();
+var MAX_LINE = 4 * 1024 * 1024;
+async function dispatch(service, method, params) {
+  switch (method) {
+    case "ping":
+      return { ok: true, version: VERSION, protocol: PROTOCOL_VERSION, pid: process.pid };
+    case "reviews.list":
+      return { reviews: service.listReviews() };
+    case "reviews.open": {
+      const root = String(params.root ?? "");
+      if (!root) throw new MrReviewError("\u043D\u0443\u0436\u0435\u043D root \u0440\u0430\u0431\u043E\u0447\u0435\u0439 \u043A\u043E\u043F\u0438\u0438");
+      const review = await service.openReview(root, {
+        ...typeof params.input === "string" ? { input: params.input } : {},
+        ...typeof params.platform === "string" ? { platform: params.platform } : {},
+        ...typeof params.project === "string" ? { project: params.project } : {},
+        ...typeof params.host === "string" ? { host: params.host } : {},
+        ...typeof params.branch === "string" ? { branch: params.branch } : {}
+      });
+      return { review: service.getView(review.id), reviews: service.listReviews() };
+    }
+    case "reviews.refresh": {
+      const review = await service.refreshReview(String(params.review ?? ""));
+      return { review: service.getView(review.id), reviews: service.listReviews() };
+    }
+    case "reviews.remoteList": {
+      const scope = ["open", "mine", "reviewing"].includes(params.scope) ? params.scope : "open";
+      return service.listRemote(String(params.root ?? process.cwd()), scope, Number(params.limit ?? 50));
+    }
+    case "reviews.get": {
+      const id = String(params.review ?? "");
+      if (params.refresh === true) await service.refreshReview(id);
+      return { review: service.getView(id), reviews: service.listReviews() };
+    }
+    case "reviews.remove":
+      return { ok: true };
+    case "diff.get": {
+      const file = service.diffFile(String(params.review ?? ""), String(params.file ?? ""));
+      return { file };
+    }
+    case "drafts.put":
+      return { draft: service.setDraft(String(params.review ?? ""), String(params.threadId ?? ""), params.patch ?? {}) };
+    case "findings.put":
+      return { findings: service.setFindings(String(params.review ?? ""), params.findings) };
+    case "findings.list":
+      return { findings: service.getReview(String(params.review ?? "")).findings };
+    case "summary.put":
+      return { summary: service.setSummary(String(params.review ?? ""), params.summary) };
+    case "decisions.put":
+      return { decisions: service.setDecisions(String(params.review ?? ""), params.decisions) };
+    case "notes.add":
+      return {
+        note: service.addNote(String(params.review ?? ""), {
+          file: String(params.file ?? ""),
+          line: Number(params.line ?? 0),
+          side: params.side === "old" ? "old" : "new",
+          text: String(params.text ?? ""),
+          toAgent: params.toAgent !== false
+        })
+      };
+    case "notes.update":
+      return { note: service.updateNote(String(params.review ?? ""), String(params.noteId ?? ""), params.patch ?? {}) };
+    case "notes.delete":
+      service.deleteNote(String(params.review ?? ""), String(params.noteId ?? ""));
+      return { ok: true };
+    case "publish.preview":
+      return {
+        preview: service.previewPublish(
+          String(params.review ?? ""),
+          String(params.kind ?? "reply"),
+          Array.isArray(params.ids) ? params.ids.map(String) : []
+        )
+      };
+    case "publish.approve": {
+      const approval = service.approve(
+        String(params.review ?? ""),
+        String(params.kind ?? "reply"),
+        Array.isArray(params.ids) ? params.ids.map(String) : [],
+        String(params.hash ?? "")
+      );
+      return { approval: { id: approval.id, expiresAt: approval.expiresAt } };
+    }
+    case "publish.commit":
+      return { result: await service.publish(String(params.review ?? ""), String(params.approvalId ?? "")) };
+    case "rules.get":
+      return { rules: await service.rules(String(params.review ?? "")) };
+    case "checks.run":
+      return {
+        results: await service.runChecks(String(params.review ?? ""), {
+          allowRun: params.allowRun === true,
+          ...Array.isArray(params.ids) ? { ids: params.ids.map(String) } : {}
+        })
+      };
+    default:
+      throw new MrReviewError(`\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u043C\u0435\u0442\u043E\u0434 RPC: ${method}`, "METHOD", "\u043E\u0431\u043D\u043E\u0432\u0438\u0442\u0435 revdeck: \u0432\u0435\u0440\u0441\u0438\u044F \u0434\u0435\u043C\u043E\u043D\u0430 \u0438 \u043A\u043B\u0438\u0435\u043D\u0442\u0430 \u0434\u043E\u043B\u0436\u043D\u044B \u0441\u043E\u0432\u043F\u0430\u0434\u0430\u0442\u044C");
+  }
+}
+async function startRpcServer(service, socketFile) {
+  await ensureDir(pathDirname(socketFile), 448);
+  await unlink2(socketFile).catch(() => void 0);
+  const server = net.createServer((socket) => {
+    socket.setEncoding("utf8");
+    let buffer = "";
+    let queue = Promise.resolve();
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      if (buffer.length > MAX_LINE) {
+        socket.destroy();
+        return;
+      }
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        const line = buffer.slice(0, index);
+        buffer = buffer.slice(index + 1);
+        if (line.trim()) {
+          const request = parseRequest(line);
+          queue = queue.then(async () => {
+            if (!request) return;
+            const response = await respond(service, request);
+            if (!socket.destroyed) socket.write(`${JSON.stringify(response)}
+`);
+          });
+        }
+        index = buffer.indexOf("\n");
+      }
+    });
+    socket.on("error", () => void 0);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketFile, () => resolve());
+  });
+  await chmod(socketFile, 384);
+  return {
+    path: socketFile,
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+      setTimeout(() => resolve(), 1e3).unref?.();
+      unlink2(socketFile).catch(() => void 0);
+    })
+  };
+}
+function pathDirname(file) {
+  return file.replace(/[/\\][^/\\]+$/, "");
+}
+function parseRequest(line) {
+  try {
+    const value = JSON.parse(line);
+    if (!value || typeof value !== "object") return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+async function respond(service, request) {
+  const id = request.id ?? null;
+  if (typeof request.method !== "string") return { id, error: { message: "\u043D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D method" } };
+  try {
+    const result = await dispatch(service, request.method, request.params ?? {});
+    return { id, result };
+  } catch (error) {
+    return {
+      id,
+      error: {
+        message: redact(messageOf(error)),
+        ...error instanceof MrReviewError ? { code: error.code, hint: error.hint } : {}
+      }
+    };
+  }
+}
+
+// src/daemon/http.ts
+var MAX_BODY = 4 * 1024 * 1024;
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ico": "image/x-icon",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8"
+};
+var SECURITY_HEADERS = {
+  "x-content-type-options": "nosniff",
+  "x-frame-options": "DENY",
+  "referrer-policy": "no-referrer",
+  "content-security-policy": "default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"
+};
+var COOKIE = "revdeck_session";
+function safeEqual(left, right) {
+  const a = Buffer.from(left);
+  const b = Buffer.from(right);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function cookies(header) {
+  const out = {};
+  for (const part of (header ?? "").split(";")) {
+    const index = part.indexOf("=");
+    if (index > 0) out[part.slice(0, index).trim()] = decodeURIComponent(part.slice(index + 1).trim());
+  }
+  return out;
+}
+async function readBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_BODY) throw Object.assign(new Error("\u0441\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0439 \u0437\u0430\u043F\u0440\u043E\u0441"), { status: 413 });
+    chunks.push(chunk);
+  }
+  const text2 = Buffer.concat(chunks).toString("utf8").trim();
+  if (!text2) return {};
+  const parsed = JSON.parse(text2);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw Object.assign(new Error("\u043E\u0436\u0438\u0434\u0430\u043B\u0441\u044F JSON-\u043E\u0431\u044A\u0435\u043A\u0442"), { status: 400 });
+  return parsed;
+}
+function reply(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    ...SECURITY_HEADERS,
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(body);
+}
+async function startHttpServer(options) {
+  const { service, token } = options;
+  const host = options.host ?? "127.0.0.1";
+  const server = http.createServer(async (req, res) => {
+    const port2 = server.address()?.port ?? 0;
+    const expectedHosts = /* @__PURE__ */ new Set([`127.0.0.1:${port2}`, `localhost:${port2}`, `[::1]:${port2}`]);
+    if (!expectedHosts.has(String(req.headers.host ?? ""))) {
+      reply(res, 403, { ok: false, error: "\u043D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 Host" });
+      return;
+    }
+    if (req.method !== "GET" && req.headers.origin && !expectedHosts.has(String(req.headers.origin).replace(/^http:\/\//, ""))) {
+      reply(res, 403, { ok: false, error: "\u043D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 Origin" });
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://127.0.0.1:${port2}`);
+    const jar = cookies(req.headers.cookie);
+    const authorized = safeEqual(String(jar[COOKIE] ?? ""), token);
+    try {
+      if (req.method === "GET" && url.pathname === "/") {
+        const provided = url.searchParams.get("t");
+        if (provided && safeEqual(provided, token)) {
+          const next = new URL("/", url);
+          next.searchParams.delete("t");
+          res.writeHead(302, {
+            ...SECURITY_HEADERS,
+            "set-cookie": `${COOKIE}=${encodeURIComponent(token)}; HttpOnly; SameSite=Strict; Path=/; Max-Age=86400`,
+            location: `${next.pathname}${next.search}`
+          });
+          res.end();
+          return;
+        }
+        if (!authorized) {
+          res.writeHead(401, { ...SECURITY_HEADERS, "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+          res.end('<meta charset="utf-8"><h1>\u041D\u0443\u0436\u043D\u0430 \u0441\u0441\u044B\u043B\u043A\u0430 \u0437\u0430\u043F\u0443\u0441\u043A\u0430</h1><p>\u041E\u0442\u043A\u0440\u043E\u0439\u0442\u0435 \u0430\u0434\u0440\u0435\u0441 \u0438\u0437 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0430: \u043E\u043D \u0441\u043E\u0434\u0435\u0440\u0436\u0438\u0442 \u043E\u0434\u043D\u043E\u0440\u0430\u0437\u043E\u0432\u044B\u0439 \u0442\u043E\u043A\u0435\u043D.</p>');
+          return;
+        }
+        const html = await readFile2(path6.join(options.uiDir, "index.html"));
+        res.writeHead(200, { ...SECURITY_HEADERS, "content-type": MIME[".html"], "cache-control": "no-store" });
+        res.end(html);
+        return;
+      }
+      if (req.method === "GET" && (url.pathname.startsWith("/assets/") || url.pathname === "/favicon.svg")) {
+        const relative = url.pathname === "/favicon.svg" ? "favicon.svg" : url.pathname.slice("/assets/".length);
+        const target = path6.resolve(options.uiDir, url.pathname === "/favicon.svg" ? "" : "assets", relative);
+        if (!target.startsWith(path6.resolve(options.uiDir) + path6.sep) || relative.includes("..")) {
+          reply(res, 404, { ok: false, error: "\u043D\u0435\u0442 \u0444\u0430\u0439\u043B\u0430" });
+          return;
+        }
+        const info = await stat(target).catch(() => null);
+        if (!info?.isFile()) {
+          reply(res, 404, { ok: false, error: "\u043D\u0435\u0442 \u0444\u0430\u0439\u043B\u0430" });
+          return;
+        }
+        res.writeHead(200, {
+          ...SECURITY_HEADERS,
+          "content-type": MIME[path6.extname(target)] ?? "application/octet-stream",
+          "cache-control": "public, max-age=31536000, immutable"
+        });
+        createReadStream(target).pipe(res);
+        return;
+      }
+      if (!url.pathname.startsWith("/api/")) {
+        reply(res, 404, { ok: false, error: "\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E" });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/events") {
+        if (!authorized) {
+          reply(res, 401, { ok: false, error: "\u043D\u0435\u0442 \u0430\u0432\u0442\u043E\u0440\u0438\u0437\u0430\u0446\u0438\u0438" });
+          return;
+        }
+        res.writeHead(200, {
+          ...SECURITY_HEADERS,
+          "content-type": "text/event-stream; charset=utf-8",
+          "cache-control": "no-store",
+          connection: "keep-alive"
+        });
+        res.write(`event: hello
+data: ${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString() })}
+
+`);
+        const listener = (event) => {
+          res.write(`event: review
+data: ${JSON.stringify(event)}
+
+`);
+        };
+        service.events.on("review", listener);
+        const heartbeat = setInterval(() => res.write(": ping\n\n"), 25e3);
+        heartbeat.unref?.();
+        req.on("close", () => {
+          clearInterval(heartbeat);
+          service.events.off("review", listener);
+        });
+        return;
+      }
+      if (!authorized) {
+        reply(res, 401, { ok: false, error: "\u043D\u0435\u0442 \u0430\u0432\u0442\u043E\u0440\u0438\u0437\u0430\u0446\u0438\u0438" });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/health") {
+        reply(res, 200, { ok: true, version: options.version ?? "dev", reviews: service.listReviews().length });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/reviews") {
+        reply(res, 200, { ok: true, reviews: service.listReviews() });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/state") {
+        const review = url.searchParams.get("review");
+        if (!review) {
+          reply(res, 400, { ok: false, error: "\u043D\u0443\u0436\u0435\u043D \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 review" });
+          return;
+        }
+        const view = await service.refreshIfStale(review);
+        reply(res, 200, { ok: true, review: view, reviews: service.listReviews() });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/diff") {
+        const review = url.searchParams.get("review") ?? "";
+        const file = url.searchParams.get("file") ?? "";
+        const diff = service.diffFile(review, file);
+        if (!diff) {
+          reply(res, 404, { ok: false, error: "\u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442 \u0432 diff" });
+          return;
+        }
+        reply(res, 200, { ok: true, file: diff });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/rules") {
+        const review = url.searchParams.get("review") ?? "";
+        reply(res, 200, { ok: true, rules: await service.rules(review) });
+        return;
+      }
+      if (req.method === "POST") {
+        const body = await readBody(req);
+        const review = String(body.review ?? "");
+        switch (url.pathname) {
+          case "/api/reviews/open": {
+            const root = String(body.root ?? "");
+            if (!root) throw Object.assign(new Error("\u043D\u0443\u0436\u0435\u043D root \u0440\u0430\u0431\u043E\u0447\u0435\u0439 \u043A\u043E\u043F\u0438\u0438"), { status: 400 });
+            const opened = await service.openReview(root, {
+              ...typeof body.input === "string" ? { input: body.input } : {},
+              ...typeof body.platform === "string" ? { platform: body.platform } : {},
+              ...typeof body.project === "string" ? { project: body.project } : {},
+              ...typeof body.host === "string" ? { host: body.host } : {},
+              ...typeof body.branch === "string" ? { branch: body.branch } : {}
+            });
+            reply(res, 200, { ok: true, review: service.getView(opened.id), reviews: service.listReviews() });
+            return;
+          }
+          case "/api/reviews/refresh": {
+            const updated = await service.refreshReview(review);
+            reply(res, 200, { ok: true, review: service.getView(updated.id), reviews: service.listReviews() });
+            return;
+          }
+          case "/api/drafts": {
+            const draft = service.setDraft(review, String(body.threadId ?? ""), body.patch ?? {});
+            reply(res, 200, { ok: true, draft });
+            return;
+          }
+          case "/api/findings": {
+            const findings = service.setFindings(review, body.findings);
+            reply(res, 200, { ok: true, findings });
+            return;
+          }
+          case "/api/summary": {
+            const summary = service.setSummary(review, body.summary);
+            reply(res, 200, { ok: true, summary });
+            return;
+          }
+          case "/api/decisions": {
+            const decisions = service.setDecisions(review, body.decisions);
+            reply(res, 200, { ok: true, decisions });
+            return;
+          }
+          case "/api/notes": {
+            const action = String(body.action ?? "add");
+            if (action === "add") {
+              const note2 = service.addNote(review, {
+                file: String(body.file ?? ""),
+                line: Number(body.line ?? 0),
+                side: body.side === "old" ? "old" : "new",
+                text: String(body.text ?? ""),
+                toAgent: body.toAgent !== false
+              });
+              reply(res, 200, { ok: true, note: note2 });
+              return;
+            }
+            if (action === "delete") {
+              service.deleteNote(review, String(body.noteId ?? ""));
+              reply(res, 200, { ok: true });
+              return;
+            }
+            const note = service.updateNote(review, String(body.noteId ?? ""), body.patch ?? {});
+            reply(res, 200, { ok: true, note });
+            return;
+          }
+          case "/api/publish/preview": {
+            const preview = service.previewPublish(review, String(body.kind ?? "reply"), Array.isArray(body.ids) ? body.ids.map(String) : []);
+            reply(res, 200, { ok: true, preview });
+            return;
+          }
+          case "/api/publish/approve": {
+            const approval = service.approve(
+              review,
+              String(body.kind ?? "reply"),
+              Array.isArray(body.ids) ? body.ids.map(String) : [],
+              String(body.hash ?? "")
+            );
+            reply(res, 200, { ok: true, approval: { id: approval.id, expiresAt: approval.expiresAt } });
+            return;
+          }
+          case "/api/publish/commit": {
+            const result = await service.publish(review, String(body.approvalId ?? ""));
+            reply(res, 200, { ok: true, result });
+            return;
+          }
+          case "/api/rpc": {
+            const result = await dispatch(service, String(body.method ?? ""), body.params ?? {});
+            reply(res, 200, { ok: true, result });
+            return;
+          }
+          case "/api/checks": {
+            const results = await service.runChecks(review, { allowRun: body.run === true, ids: Array.isArray(body.ids) ? body.ids.map(String) : void 0 });
+            reply(res, 200, { ok: true, results });
+            return;
+          }
+          default:
+            reply(res, 404, { ok: false, error: "\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E" });
+            return;
+        }
+      }
+      reply(res, 404, { ok: false, error: "\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E" });
+    } catch (error) {
+      const status = error.status ?? 500;
+      reply(res, status, { ok: false, error: redact(messageOf(error)) });
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? 0, host, () => resolve());
+  });
+  const port = server.address().port;
+  return {
+    url: `http://127.0.0.1:${port}`,
+    port,
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+      setTimeout(() => resolve(), 1500).unref?.();
+    })
+  };
+}
+
+// src/daemon/main.ts
+async function main() {
+  setLocale(detectLocale());
+  const { values } = parseArgs({
+    options: {
+      port: { type: "string" },
+      "state-dir": { type: "string" },
+      "runtime-dir": { type: "string" },
+      "ui-dir": { type: "string" },
+      foreground: { type: "boolean", default: false },
+      "sync-interval": { type: "string" }
+    },
+    allowPositionals: false
+  });
+  if (values["state-dir"]) process.env.REVDECK_STATE_DIR = values["state-dir"];
+  if (values["runtime-dir"]) process.env.REVDECK_RUNTIME_DIR = values["runtime-dir"];
+  const foreground = values.foreground === true;
+  const log = async (line) => {
+    const message = `${(/* @__PURE__ */ new Date()).toISOString()} ${redactLine(line, 4e3)}
+`;
+    if (foreground) process.stderr.write(message);
+    try {
+      await appendFile(logPath(), message, { mode: 384 });
+    } catch {
+    }
+  };
+  const existing = await runningDaemon();
+  if (existing) {
+    process.stdout.write(`revdeck daemon ${tr("\u0443\u0436\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D", "is already running")} (pid ${existing.pid}): ${existing.url}/
+`);
+    return;
+  }
+  await ensureDir(stateDir(), 448);
+  await ensureDir(runtimeDir(), 448);
+  const lock = await acquireLock();
+  if (!lock) {
+    process.stdout.write(`revdeck daemon ${tr("\u0443\u0436\u0435 \u0437\u0430\u043F\u0443\u0441\u043A\u0430\u0435\u0442\u0441\u044F \u0438\u043B\u0438 \u0437\u0430\u043F\u0443\u0449\u0435\u043D", "is already starting or running")}
+`);
+    return;
+  }
+  const token = (await import("node:crypto")).randomBytes(32).toString("hex");
+  const store = new Store(databasePath());
+  const service = new ReviewService({
+    store,
+    syncIntervalMs: values["sync-interval"] ? Number(values["sync-interval"]) : 12e4
+  });
+  const socket = socketPath();
+  const rpc = await startRpcServer(service, socket);
+  const uiDir = values["ui-dir"] ? path7.resolve(values["ui-dir"]) : path7.join(packageRoot(), "dist", "ui");
+  const http2 = await startHttpServer({
+    service,
+    token,
+    uiDir,
+    ...values.port ? { port: Number(values.port) } : {},
+    version: VERSION
+  });
+  const info = {
+    pid: process.pid,
+    port: http2.port,
+    token,
+    url: http2.url,
+    socket,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: VERSION,
+    protocol: PROTOCOL_VERSION
+  };
+  await writeFileAtomic(daemonInfoPath(), `${JSON.stringify(info, null, 2)}
+`, 384);
+  service.startSync();
+  process.stdout.write(
+    [
+      `revdeck daemon ${VERSION} (pid ${process.pid})`,
+      `UI:      ${http2.url}/?t=${token}`,
+      `${tr("\u0441\u043E\u043A\u0435\u0442", "socket")}:   ${socket}`,
+      `${tr("\u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435", "state")}: ${stateDir()}`,
+      ""
+    ].join("\n")
+  );
+  await log(`daemon started pid=${process.pid} port=${http2.port}`);
+  let closing = false;
+  const shutdown = async (signal) => {
+    if (closing) return;
+    closing = true;
+    await log(`daemon stopping (${signal})`);
+    try {
+      await rpc.close();
+      await http2.close();
+    } finally {
+      service.close();
+      await unlink3(daemonInfoPath()).catch(() => void 0);
+      await lock.close().catch(() => void 0);
+      await unlink3(path7.join(stateDir(), "daemon.lock")).catch(() => void 0);
+      process.exit(0);
+    }
+  };
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => {
+      if (signal === "SIGHUP" && !foreground) return;
+      void shutdown(signal);
+    });
+  }
+}
+function packageRoot() {
+  let dir = path7.dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const candidate = path7.join(dir, "package.json");
+    if (existsSync4(candidate)) {
+      try {
+        const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+        if (parsed.name === "revdeck") return dir;
+      } catch {
+      }
+    }
+    const parent = path7.dirname(dir);
+    if (parent === dir) return process.cwd();
+    dir = parent;
+  }
+}
+async function runningDaemon() {
+  const infoPath = daemonInfoPath();
+  if (!existsSync4(infoPath)) return null;
+  let info;
+  try {
+    info = JSON.parse(readFileSync(infoPath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!info?.pid || !info?.socket) return null;
+  try {
+    process.kill(info.pid, 0);
+  } catch {
+    return null;
+  }
+  const reachable = await new Promise((resolve) => {
+    const socket = net2.connect(info.socket);
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 500);
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+  return reachable ? info : null;
+}
+async function acquireLock() {
+  const file = path7.join(stateDir(), "daemon.lock");
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const handle = await open2(file, "wx", 384);
+      await handle.writeFile(String(process.pid));
+      return handle;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const pid = Number(await readFile3(file, "utf8").catch(() => ""));
+      if (pid) {
+        try {
+          process.kill(pid, 0);
+          return null;
+        } catch {
+        }
+      }
+      await unlink3(file).catch(() => void 0);
+    }
+  }
+  return null;
+}
+void main().catch((error) => {
+  process.stderr.write(`revdeck: ${redactLine(error instanceof Error ? error.message : error)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map