gyojeong 0.2.0 → 0.3.0

package/scripts/review-cli.mjs

@@ -9,8 +9,8 @@ var __export = (target, all) => {
 // ../../scripts/review-cli.mjs
 import { spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { closeSync, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
-import path3 from "node:path";
+import { chmodSync as chmodSync3, closeSync, existsSync as existsSync5, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
@@ -256,10 +256,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -668,11 +668,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -819,16 +819,16 @@ function flattenError(error2, mapper = (issue2) => issue2.message) {
 }
 function formatError(error2, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error3, path4 = []) => {
+  const processError = (error3, path6 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -2072,7 +2072,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   const _normalized = cached(() => normalizeDef(def));
   const generateFastpass = (shape) => {
     const doc = new Doc(["shape", "payload", "ctx"]);
-    const normalized = _normalized.value;
+    const normalized2 = _normalized.value;
     const parseStr = (key) => {
       const k = esc(key);
       return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
@@ -2080,11 +2080,11 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
     let counter = 0;
-    for (const key of normalized.keys) {
+    for (const key of normalized2.keys) {
       ids[key] = `key_${counter++}`;
     }
     doc.write(`const newResult = {};`);
-    for (const key of normalized.keys) {
+    for (const key of normalized2.keys) {
       const id = ids[key];
       const k = esc(key);
       const schema = shape[key];
@@ -5296,10 +5296,107 @@ function trimUrl(url3) {
 function maskCode(text) {
   return text.replace(CODE_SPAN_RE, " ");
 }
-function stripComments(text) {
+var HASH_COMMENT_LANGUAGES = /* @__PURE__ */ new Set([
+  "bash",
+  "dockerfile",
+  "make",
+  "makefile",
+  "perl",
+  "php",
+  "pl",
+  "powershell",
+  "ps1",
+  "py",
+  "python",
+  "r",
+  "rb",
+  "ruby",
+  "sh",
+  "shell",
+  "toml",
+  "yaml",
+  "yml",
+  "zsh"
+]);
+var SHELL_COMMENT_LANGUAGES = /* @__PURE__ */ new Set(["bash", "sh", "shell", "zsh"]);
+var WHITESPACE_HASH_COMMENT_LANGUAGES = /* @__PURE__ */ new Set(["yaml", "yml"]);
+var ANYWHERE_HASH_COMMENT_LANGUAGES = /* @__PURE__ */ new Set([
+  "perl",
+  "php",
+  "pl",
+  "powershell",
+  "ps1",
+  "rb",
+  "ruby"
+]);
+var MAKE_LANGUAGES = /* @__PURE__ */ new Set(["make", "makefile"]);
+var PHP_ATTRIBUTE_LANGUAGES = /* @__PURE__ */ new Set(["php"]);
+var LINE_HASH_COMMENT_LANGUAGES = /* @__PURE__ */ new Set(["dockerfile"]);
+var SLASH_COMMENT_LANGUAGES = /* @__PURE__ */ new Set([
+  "c",
+  "c++",
+  "cc",
+  "cpp",
+  "cs",
+  "csharp",
+  "cxx",
+  "go",
+  "h",
+  "hpp",
+  "java",
+  "javascript",
+  "js",
+  "jsonc",
+  "jsx",
+  "kotlin",
+  "kt",
+  "less",
+  "php",
+  "rs",
+  "rust",
+  "scala",
+  "scss",
+  "swift",
+  "ts",
+  "tsx",
+  "typescript"
+]);
+var C_STYLE_BLOCK_COMMENT_LANGUAGES = /* @__PURE__ */ new Set([...SLASH_COMMENT_LANGUAGES, "css"]);
+var HTML_COMMENT_LANGUAGES = /* @__PURE__ */ new Set(["html", "markdown", "md", "svelte", "svg", "vue", "xml"]);
+var PAIRED_DELIMITERS = /* @__PURE__ */ new Map([["(", ")"], ["{", "}"], ["[", "]"], ["<", ">"]]);
+var delimitedLiteralStart = (rest, previous, language) => {
+  if (language === "ruby" || language === "rb") {
+    return rest.match(/^%(?:[qQrwWixI])?([^\w\s])/u);
+  }
+  if ((language === "perl" || language === "pl") && !/[\w$@%]/u.test(previous)) {
+    return rest.match(/^(?:qq|qw|qx|qr|q)([^\w\s])/u);
+  }
+  return null;
+};
+var slashLiteralStart = (text, index, language) => {
+  if (!["perl", "pl", "rb", "ruby"].includes(language) || text[index] !== "/") return false;
+  const beforeText = text.slice(0, index);
+  const before = beforeText.match(/\S\s*$/u)?.[0].trim() ?? "";
+  if (before === "" || /[=(:,!\[\{;~]/u.test(before.at(-1) ?? "")) return true;
+  const word = beforeText.match(/([A-Za-z]+)\s*$/u)?.[1]?.toLowerCase();
+  if (["rb", "ruby"].includes(language)) {
+    return ["and", "if", "not", "or", "return", "then", "unless", "when", "while"].includes(word ?? "");
+  }
+  return ["m", "qr", "s"].includes(word ?? "");
+};
+function stripComments(text, language = "") {
+  const normalizedLanguage = language.toLowerCase();
+  const hashComments = HASH_COMMENT_LANGUAGES.has(normalizedLanguage);
+  const slashComments = SLASH_COMMENT_LANGUAGES.has(normalizedLanguage);
+  const cStyleBlockComments = C_STYLE_BLOCK_COMMENT_LANGUAGES.has(normalizedLanguage);
+  const htmlComments = HTML_COMMENT_LANGUAGES.has(normalizedLanguage);
+  const knownLanguage = hashComments || slashComments || cStyleBlockComments || htmlComments;
   let out = "";
   let quote = null;
+  let quoteOpen = null;
+  let quoteDepth = 0;
   let block = null;
+  let lineStart = 0;
   for (let i = 0; i < text.length; i += 1) {
     const rest = text.slice(i);
     if (block) {
@@ -5307,48 +5404,92 @@ function stripComments(text) {
         i += block.length - 1;
         block = null;
       }
+      if (text[i] === "\n") {
+        lineStart = i + 1;
+      }
       continue;
     }
     const char = text[i];
+    const atLineStart = /^\s*$/.test(text.slice(lineStart, i));
+    const genericSlashComment = !knownLanguage && atLineStart && rest.startsWith("//");
+    const genericHashComment = !knownLanguage && atLineStart && char === "#" && !rest.startsWith("#!") && !/^#[\w-]+\s*\{/u.test(rest);
+    const genericCStyleBlockComment = !knownLanguage && atLineStart && rest.startsWith("/*");
+    const genericHtmlComment = !knownLanguage && atLineStart && rest.startsWith("<!--");
+    const previous = text[i - 1] ?? "";
+    const makeRecipe = MAKE_LANGUAGES.has(normalizedLanguage) && text[lineStart] === "	";
+    const shellHashComment = (SHELL_COMMENT_LANGUAGES.has(normalizedLanguage) || makeRecipe) && char === "#" && (i === 0 || /[\s;&|()<>]/u.test(previous));
+    const whitespaceHashComment = WHITESPACE_HASH_COMMENT_LANGUAGES.has(normalizedLanguage) && char === "#" && (i === 0 || /\s/u.test(previous)) && !(PHP_ATTRIBUTE_LANGUAGES.has(normalizedLanguage) && rest.startsWith("#["));
+    const lineHashComment = LINE_HASH_COMMENT_LANGUAGES.has(normalizedLanguage) && char === "#" && atLineStart;
+    const anywhereHashComment = ANYWHERE_HASH_COMMENT_LANGUAGES.has(normalizedLanguage) && char === "#" && !(PHP_ATTRIBUTE_LANGUAGES.has(normalizedLanguage) && rest.startsWith("#["));
+    const makeHashComment = MAKE_LANGUAGES.has(normalizedLanguage) && char === "#" && (makeRecipe ? shellHashComment : true);
+    const languageHashComment = hashComments && char === "#" && (SHELL_COMMENT_LANGUAGES.has(normalizedLanguage) || makeRecipe ? shellHashComment : WHITESPACE_HASH_COMMENT_LANGUAGES.has(normalizedLanguage) ? whitespaceHashComment : LINE_HASH_COMMENT_LANGUAGES.has(normalizedLanguage) ? lineHashComment : MAKE_LANGUAGES.has(normalizedLanguage) ? makeHashComment : anywhereHashComment);
     if (quote) {
       out += char;
       if (char === "\\") {
         out += text[i + 1] ?? "";
         i += 1;
+      } else if (quoteOpen && char === quoteOpen) {
+        quoteDepth += 1;
       } else if (char === quote) {
-        quote = null;
+        if (quoteDepth > 0) {
+          quoteDepth -= 1;
+        } else {
+          quote = null;
+          quoteOpen = null;
+        }
       }
       continue;
     }
+    const delimitedLiteral = delimitedLiteralStart(rest, previous, normalizedLanguage);
+    if (delimitedLiteral) {
+      const opener = delimitedLiteral[1];
+      const token = delimitedLiteral[0];
+      quoteOpen = PAIRED_DELIMITERS.has(opener) ? opener : null;
+      quote = PAIRED_DELIMITERS.get(opener) ?? opener;
+      quoteDepth = 0;
+      out += token;
+      i += token.length - 1;
+      continue;
+    }
     if (char === '"' || char === "'" || char === "`") {
       quote = char;
       out += char;
       continue;
     }
-    if (rest.startsWith("/*")) {
+    if (slashLiteralStart(text, i, normalizedLanguage)) {
+      quote = "/";
+      out += char;
+      continue;
+    }
+    if (cStyleBlockComments && rest.startsWith("/*") || genericCStyleBlockComment) {
       block = "*/";
       continue;
     }
-    if (rest.startsWith("<!--")) {
+    if (htmlComments && rest.startsWith("<!--") || genericHtmlComment) {
       block = "-->";
       continue;
     }
-    if (rest.startsWith("//") || char === "#") {
+    if (slashComments && rest.startsWith("//") || languageHashComment || genericSlashComment || genericHashComment) {
       const end = text.indexOf("\n", i);
       if (end === -1) break;
       i = end - 1;
+      lineStart = end;
       continue;
     }
     out += char;
+    if (char === "\n") {
+      lineStart = i + 1;
+    }
   }
   return out;
 }
 function normalizeCodeBlock(text) {
   const raw = text.split("\n");
   const open = raw[0] ?? "";
+  const language = open.match(/^\s*(?:`{3,}|~{3,})\s*([^\s{]+)/)?.[1] ?? "";
   const closes = raw.length > 1 && /^\s*(`{3,}|~{3,})\s*$/.test(raw[raw.length - 1] ?? "");
   const body = raw.slice(1, closes ? -1 : void 0).join("\n");
-  const lines = [open, ...stripComments(body).split("\n")];
+  const lines = [open, ...stripComments(body, language).split("\n")];
   const indent = lines[0].match(/^\s*/)[0].length;
   return lines.map((line) => line.slice(Math.min(indent, line.match(/^\s*/)[0].length))).map((line) => line.replace(/\s+$/, "")).filter((line) => line.trim() !== "").join("\n");
 }
@@ -5463,25 +5604,18 @@ var ENGLISH_NUMBER_WORDS = {
   triple: 3,
   both: 2,
   dozen: 12,
-  half: 50,
-  hex: 16,
-  hexadecimal: 16,
-  octal: 8,
-  binary: 2,
-  decimal: 10,
-  january: 1,
-  february: 2,
-  march: 3,
-  april: 4,
-  may: 5,
-  june: 6,
-  july: 7,
-  august: 8,
-  september: 9,
-  october: 10,
-  november: 11,
-  december: 12
+  half: 50
 };
+var MONTHS = { january: 1, february: 2, march: 3, april: 4, may: 5, june: 6, july: 7, august: 8, september: 9, october: 10, november: 11, december: 12 };
+var MONTH_DATE_RE = new RegExp(`\\b(${Object.keys(MONTHS).join("|")})\\s+\\d|\\d\\s+(${Object.keys(MONTHS).join("|")})\\b`, "g");
+var SECOND_UNIT_RE = /\b(?:\d+(?:\.\d+)?|a|an|one|per|each|every)\s+second\b|\bseconds\b/g;
+var KOREAN_BASE_RE = /(\d+)\s*진/g;
+var ENGLISH_BASES = { hex: 16, hexadecimal: 16, octal: 8, binary: 2, decimal: 10 };
+var ENGLISH_BASE_RE = new RegExp(`\\b(${Object.keys(ENGLISH_BASES).join("|")})\\b`, "g");
+function sourceBases(prose, language) {
+  if (language === "en") return new Set([...prose.toLowerCase().matchAll(ENGLISH_BASE_RE)].map((m) => String(ENGLISH_BASES[m[1]])));
+  return new Set([...prose.matchAll(KOREAN_BASE_RE)].map((m) => normalizeNumber(m[1])));
+}
 var KOREAN_NUMBER_WORDS = { \uD55C: 1, \uD558\uB098: 1, \uB450: 2, \uB458: 2, \uC138: 3, \uC14B: 3, \uB124: 4, \uB137: 4, \uB2E4\uC12F: 5, \uC5EC\uC12F: 6, \uC77C\uACF1: 7, \uC5EC\uB35F: 8, \uC544\uD649: 9, \uC5F4: 10 };
 var KOREAN_NUMERAL = "\uD55C|\uD558\uB098|\uB450|\uB458|\uC138|\uC14B|\uB124|\uB137|\uB2E4\uC12F|\uC5EC\uC12F|\uC77C\uACF1|\uC5EC\uB35F|\uC544\uD649|\uC5F4";
 var KOREAN_COUNTER = "\uAC1C|\uBC88|\uAC00\uC9C0|\uBA85|\uB300|\uC904|\uB2E8\uACC4|\uBC30|\uC2DC\uAC04|\uBD84|\uCD08|\uC77C|\uC8FC|\uB2EC|\uACF3|\uCABD|\uC7A5|\uCE78";
@@ -5500,13 +5634,15 @@ function normalizeNumber(raw) {
   return /^\d+(\.\d+)?$/.test(plain) ? String(Number(plain)) : plain;
 }
 function digitNumbers(prose) {
-  const normalized = prose.replace(KOREAN_DATE_RE, (_, y, m, d) => ` ${y} ${Number(m)} ${Number(d)} `).replace(KOREAN_UNIT_RE, (_, n, unit) => ` ${Number(n) * KOREAN_UNITS[unit]} `);
-  return new Set((normalized.match(NUM_RE) ?? []).map(normalizeNumber));
+  const normalized2 = prose.replace(KOREAN_DATE_RE, (_, y, m, d) => ` ${y} ${Number(m)} ${Number(d)} `).replace(KOREAN_UNIT_RE, (_, n, unit) => ` ${Number(n) * KOREAN_UNITS[unit]} `);
+  return new Set((normalized2.match(NUM_RE) ?? []).map(normalizeNumber));
 }
 function justifiedNumbers(prose, language) {
   const out = /* @__PURE__ */ new Set();
   if (language === "en") {
-    for (const m of prose.toLowerCase().matchAll(/\b[a-z]+\b/g)) {
+    const lower = prose.toLowerCase();
+    for (const m of lower.matchAll(MONTH_DATE_RE)) out.add(String(MONTHS[m[1] ?? m[2]]));
+    for (const m of lower.replace(SECOND_UNIT_RE, " ").matchAll(/\b[a-z]+\b/g)) {
       if (Object.hasOwn(ENGLISH_NUMBER_WORDS, m[0])) out.add(String(ENGLISH_NUMBER_WORDS[m[0]]));
     }
     if (/\bnon-?negative\b|\bzero-based\b/i.test(prose)) out.add("0");
@@ -5521,14 +5657,17 @@ function justifiedNumbers(prose, language) {
 }
 function checkNumbers(sourceBlocks, draftBlocks, sourceLanguage, add) {
   const sourceProse = numberProse(sourceBlocks);
-  const draftProse = numberProse(draftBlocks);
+  const draftText = numberProse(draftBlocks);
+  const bases = sourceBases(sourceProse, sourceLanguage);
+  const draftBases = new Set([...draftText.matchAll(KOREAN_BASE_RE)].map((m) => normalizeNumber(m[1])));
+  const draftProse = draftText.replace(KOREAN_BASE_RE, " ");
   const sourceDigits = digitNumbers(sourceProse);
   const draftDigits = digitNumbers(draftProse);
   const justified = /* @__PURE__ */ new Set([...sourceDigits, ...justifiedNumbers(sourceProse, sourceLanguage)]);
   const draftWords = justifiedNumbers(draftProse, "ko");
-  const draftAll = /* @__PURE__ */ new Set([...draftDigits, ...draftWords]);
+  const draftAll = /* @__PURE__ */ new Set([...draftDigits, ...draftWords, ...draftBases]);
   const addedWords = [...draftWords].filter((n) => Number(n) >= 3);
-  for (const n of [...draftDigits, ...addedWords]) {
+  for (const n of [...draftDigits, ...addedWords, ...[...draftBases].filter((b) => !bases.has(b))]) {
     if (!justified.has(n)) add("fail", "number", `\uC6D0\uBB38\uC5D0 \uC5C6\uB294 \uC22B\uC790\uAC00 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4: ${n}`, { token: n });
   }
   for (const n of sourceDigits) {
@@ -5539,7 +5678,7 @@ var EN_WEAK_PROHIBITION = [/\bavoid(?:s|ing)?\b/i, /\b(?:forbid|forbids|disallow
 var EN_PERMISSION = /\b(?:may|allowed|permitted|optional|optionally|free to|fine|okay|ok|need not|needn't|not required|no need|(?:do|does)n't need|(?:do|does) not need|(?:do|does)n't have to|(?:do|does) not have to|acceptable)\b/i;
 var EN = {
   prohibition: [
-    /(?:^|[.!?:]\s+|\n\s*(?:[-*+]|\d+[.)])?\s*|\*\*|>\s*)(?:do not|don't|never|avoid)\b(?!\s+(?:need|have to|require))/i,
+    /(?:^|[.!?:;]\s+|\n\s*(?:[-*+]|\d+[.)])?\s*|\*\*|>\s*)(?:do not|don't|never|avoid)\b(?!\s+(?:need|have to|require))/i,
     // "should not", and "should, however, not"
     /\b(?:must|shall|should)(?:\s+not|n't|,[^,.;!?\n]{1,25},\s+not)\b/i,
     /\b(?:is|are|isn't|aren't)\s+not\s+(?:allowed|permitted)\b/i,
@@ -5913,30 +6052,156 @@ var occurrenceDelta = (beforeText, afterText, value) => ({
   before: countOccurrences(beforeText, value),
   after: countOccurrences(afterText, value)
 });
-var exactReplacementStatus = (beforeText, afterText, selectedText, correction) => {
+var overlappingRanges = (text, value) => {
+  const ranges = [];
+  let cursor = 0;
+  while (cursor <= text.length - value.length) {
+    const start = text.indexOf(value, cursor);
+    if (start === -1) {
+      break;
+    }
+    ranges.push({ start, end: start + value.length });
+    cursor = start + 1;
+  }
+  return ranges;
+};
+var sourceInsideReplacementStatus = (region, source, replacement) => {
+  if (replacement === source || !replacement.includes(source)) {
+    return { replaced: false, ambiguous: false };
+  }
+  const replacementRanges = overlappingRanges(region, replacement);
+  const ambiguous = replacementRanges.some((range, index) => index > 0 && range.start < replacementRanges[index - 1].end);
+  if (ambiguous) {
+    return { replaced: false, ambiguous: true };
+  }
+  const sourceRanges = overlappingRanges(region, source);
+  const replaced = sourceRanges.length > 0 && sourceRanges.every(
+    (candidate) => replacementRanges.some((container) => candidate.start >= container.start && candidate.end <= container.end)
+  );
+  return { replaced, ambiguous: false };
+};
+var nearestIndexOf = (text, value, expected, from = 0) => {
+  let best = -1;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let clusters = 0;
+  let clusterEnd = -1;
+  let tied = false;
+  let cursor = from;
+  while (cursor <= text.length - value.length) {
+    const found = text.indexOf(value, cursor);
+    if (found === -1) {
+      break;
+    }
+    if (found >= clusterEnd) {
+      clusters += 1;
+    }
+    clusterEnd = Math.max(clusterEnd, found + value.length);
+    const distance = Math.abs(found - expected);
+    if (distance < bestDistance) {
+      best = found;
+      bestDistance = distance;
+      tied = false;
+    } else if (distance === bestDistance) {
+      tied = true;
+    }
+    cursor = found + 1;
+  }
+  return { index: best, ambiguous: tied || clusters > 1 };
+};
+var locateContext = (afterText, context, expected, side, from = 0) => {
+  const points = Array.from(context);
+  const minimum = Math.min(8, points.length);
+  for (let length = points.length; length >= minimum; length -= 1) {
+    const value = side === "prefix" ? points.slice(-length).join("") : points.slice(0, length).join("");
+    const found = nearestIndexOf(afterText, value, expected, from);
+    if (found.ambiguous) {
+      return null;
+    }
+    if (found.index !== -1) {
+      return side === "prefix" ? found.index + value.length : found.index;
+    }
+  }
+  return null;
+};
+var revisedSelectionRegion = (beforeText, afterText, selection) => {
+  const before = Array.from(beforeText);
+  const unchangedSelectionRegion = () => {
+    const selectedText = selection.selected_text;
+    const selectedAt = afterText.indexOf(selectedText);
+    if (selectedAt === -1 || afterText.indexOf(selectedText, selectedAt + selectedText.length) !== -1) {
+      return null;
+    }
+    return afterText.slice(selectedAt, selectedAt + selectedText.length);
+  };
+  const context = 48;
+  const prefix = before.slice(Math.max(0, selection.start - context), selection.start).join("");
+  const suffix = before.slice(selection.end, Math.min(before.length, selection.end + context)).join("");
+  const selectionStart = before.slice(0, selection.start).join("").length;
+  const selectionEnd = before.slice(0, selection.end).join("").length;
+  const start = prefix.length === 0 ? 0 : locateContext(afterText, prefix, selectionStart - prefix.length, "prefix");
+  if (start === null) {
+    return unchangedSelectionRegion();
+  }
+  const end = suffix.length === 0 ? afterText.length : locateContext(afterText, suffix, selectionEnd, "suffix", start);
+  if (end === null || end < start) {
+    return unchangedSelectionRegion();
+  }
+  return afterText.slice(start, end);
+};
+var exactReplacementStatus = (beforeText, afterText, feedback2, correction) => {
+  const selectedText = feedback2.selection.selected_text;
+  let region = revisedSelectionRegion(beforeText, afterText, feedback2.selection);
+  if (region === null) {
+    const selection = feedback2.selection;
+    const beforePoints = Array.from(beforeText);
+    const leading = beforePoints.slice(0, selection.start).join("");
+    const trailing = beforePoints.slice(selection.end).join("");
+    const boundaryOnly = (value) => /^[\s\p{P}]*$/u.test(value);
+    const atStart = boundaryOnly(leading) && afterText.startsWith(leading + correction);
+    const atEnd = boundaryOnly(trailing) && afterText.endsWith(correction + trailing);
+    if (atStart || atEnd) {
+      region = correction;
+    }
+  }
+  if (region === null) {
+    return { resolved: false, selectedReduced: false, notVerifiable: true, checks: ["selection_location_not_verifiable"] };
+  }
   const selected = occurrenceDelta(beforeText, afterText, selectedText);
   const corrected = occurrenceDelta(beforeText, afterText, correction);
-  const correctionAdded = corrected.after > corrected.before;
+  const correctionAdded = corrected.after > corrected.before && region.includes(correction);
   const selectedReduced = selected.after < selected.before;
-  const selectedSurvivesInsideCorrection = correction.includes(selectedText);
+  const containment = correction.includes(selectedText) ? sourceInsideReplacementStatus(region, selectedText, correction) : null;
+  if (containment?.ambiguous) {
+    return { resolved: false, selectedReduced, notVerifiable: true, checks: ["overlapping_replacement_not_verifiable"] };
+  }
+  const selectedReplaced = containment ? containment.replaced : selectedReduced && !region.includes(selectedText);
   return {
-    resolved: correctionAdded && (selectedReduced || selectedSurvivesInsideCorrection),
+    resolved: correctionAdded && selectedReplaced,
     selectedReduced,
     checks: [
       ...correctionAdded ? ["correction_occurrence_increased"] : ["correction_occurrence_not_increased"],
-      ...selectedReduced || selectedSurvivesInsideCorrection ? ["selected_occurrence_replaced"] : ["selected_occurrence_not_reduced"]
+      ...selectedReplaced ? ["selected_occurrence_replaced"] : ["selected_occurrence_not_reduced"]
     ]
   };
 };
-var inlineReplacementStatus = (beforeText, afterText, selectedText, correction) => {
+var inlineReplacementStatus = (beforeText, afterText, feedback2, correction) => {
+  const selectedText = feedback2.selection.selected_text;
   const match = correction.match(/^\s*(.+?)\s*(?:->|→)\s*(.+?)\s*$/su);
   if (!match || !selectedText.includes(match[1])) {
     return null;
   }
+  const region = revisedSelectionRegion(beforeText, afterText, feedback2.selection);
+  if (region === null) {
+    return { resolved: false, sourceReduced: false, notVerifiable: true, checks: ["selection_location_not_verifiable"] };
+  }
   const source = occurrenceDelta(beforeText, afterText, match[1]);
   const target = occurrenceDelta(beforeText, afterText, match[2]);
-  const sourceReduced = source.after < source.before;
-  const targetAdded = target.after > target.before;
+  const containment = match[2].includes(match[1]) ? sourceInsideReplacementStatus(region, match[1], match[2]) : null;
+  if (containment?.ambiguous) {
+    return { resolved: false, sourceReduced: false, notVerifiable: true, checks: ["overlapping_replacement_not_verifiable"] };
+  }
+  const sourceReduced = containment ? containment.replaced : source.after < source.before && !region.includes(match[1]);
+  const targetAdded = target.after > target.before && region.includes(match[2]);
   return {
     resolved: sourceReduced && targetAdded,
     sourceReduced,
@@ -5953,8 +6218,20 @@ var classifyFeedback = (beforeText, afterText, feedback2, correction) => {
   }
   if (feedback2.category === "deletion") {
     const target = feedback2.term ?? selectedText;
+    const region = revisedSelectionRegion(beforeText, afterText, feedback2.selection);
+    if (region === null) {
+      if (countOccurrences(beforeText, target) === 1) {
+        const occurrences2 = occurrenceDelta(beforeText, afterText, target);
+        const resolved2 = occurrences2.after < occurrences2.before;
+        return {
+          status: resolved2 ? "resolved" : "unresolved",
+          checks: [resolved2 ? "unique_target_occurrence_decreased" : "unique_target_occurrence_not_decreased"]
+        };
+      }
+      return { status: "not_verifiable", checks: ["selection_location_not_verifiable"] };
+    }
     const occurrences = occurrenceDelta(beforeText, afterText, target);
-    const resolved = occurrences.after < occurrences.before;
+    const resolved = occurrences.after < occurrences.before && !region.includes(target);
     return {
       status: resolved ? "resolved" : "unresolved",
       checks: [resolved ? "target_occurrence_decreased" : "target_occurrence_not_decreased"]
@@ -5969,7 +6246,10 @@ var classifyFeedback = (beforeText, afterText, feedback2, correction) => {
         checks: [selectedReduced ? "selected_occurrence_decreased" : "selected_occurrence_not_decreased"]
       };
     }
-    const exact2 = exactReplacementStatus(beforeText, afterText, selectedText, correction.correction);
+    const exact2 = exactReplacementStatus(beforeText, afterText, feedback2, correction.correction);
+    if (exact2.notVerifiable) {
+      return { status: "not_verifiable", checks: exact2.checks };
+    }
     return { status: exact2.resolved ? "resolved" : "unresolved", checks: exact2.checks };
   }
   if (!correction) {
@@ -5978,10 +6258,13 @@ var classifyFeedback = (beforeText, afterText, feedback2, correction) => {
   const inlineReplacement = inlineReplacementStatus(
     beforeText,
     afterText,
-    selectedText,
+    feedback2,
     correction.correction
   );
   if (inlineReplacement) {
+    if (inlineReplacement.notVerifiable) {
+      return { status: "not_verifiable", checks: inlineReplacement.checks };
+    }
     if (!inlineReplacement.resolved && feedback2.category === "unspecified" && inlineReplacement.sourceReduced) {
       return {
         status: "not_verifiable",
@@ -5994,8 +6277,12 @@ var classifyFeedback = (beforeText, afterText, feedback2, correction) => {
     };
   }
   if (feedback2.category === "omission") {
+    const region = revisedSelectionRegion(beforeText, afterText, feedback2.selection);
+    if (region === null) {
+      return { status: "not_verifiable", checks: ["selection_location_not_verifiable"] };
+    }
     const corrected = occurrenceDelta(beforeText, afterText, correction.correction);
-    const resolved = corrected.after > corrected.before;
+    const resolved = corrected.after > corrected.before && region.includes(correction.correction);
     return {
       status: resolved ? "resolved" : "unresolved",
       checks: [resolved ? "correction_occurrence_increased" : "correction_occurrence_not_increased"]
@@ -6003,10 +6290,18 @@ var classifyFeedback = (beforeText, afterText, feedback2, correction) => {
   }
   if (feedback2.category === "terminology") {
     const target = feedback2.term ?? selectedText;
+    const region = revisedSelectionRegion(beforeText, afterText, feedback2.selection);
+    if (region === null) {
+      return { status: "not_verifiable", checks: ["selection_location_not_verifiable"] };
+    }
     const targetDelta = occurrenceDelta(beforeText, afterText, target);
     const correctionDelta = occurrenceDelta(beforeText, afterText, correction.correction);
-    const correctionAdded = correctionDelta.after > correctionDelta.before;
-    const targetReplaced = targetDelta.after < targetDelta.before || correction.correction.includes(target);
+    const correctionAdded = correctionDelta.after > correctionDelta.before && region.includes(correction.correction);
+    const containment = correction.correction.includes(target) ? sourceInsideReplacementStatus(region, target, correction.correction) : null;
+    if (containment?.ambiguous) {
+      return { status: "not_verifiable", checks: ["overlapping_replacement_not_verifiable"] };
+    }
+    const targetReplaced = containment ? containment.replaced : targetDelta.after < targetDelta.before && !region.includes(target);
     const resolved = correctionAdded && targetReplaced;
     return {
       status: resolved ? "resolved" : "unresolved",
@@ -6016,7 +6311,10 @@ var classifyFeedback = (beforeText, afterText, feedback2, correction) => {
       ]
     };
   }
-  const exact = exactReplacementStatus(beforeText, afterText, selectedText, correction.correction);
+  const exact = exactReplacementStatus(beforeText, afterText, feedback2, correction.correction);
+  if (exact.notVerifiable) {
+    return { status: "not_verifiable", checks: exact.checks };
+  }
   if (!exact.resolved && feedback2.category === "unspecified" && exact.selectedReduced) {
     return {
       status: "not_verifiable",
@@ -6067,21 +6365,777 @@ var loadIdleConfig = (env = process.env, configPath = path.join(homedir(), ".con
   };
 };
 
+// ../../scripts/gist-rules.mjs
+import { spawnSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { chmodSync, existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { homedir as homedir2, hostname, tmpdir } from "node:os";
+import path2 from "node:path";
+var GIST_ID = /^[a-f0-9]{20,64}$/iu;
+var CONFIG_DIR = path2.join(homedir2(), ".config", "gyojeong");
+var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
+var DOCUMENT_ONLY_CATEGORIES = /* @__PURE__ */ new Set(["deletion", "omission", "addition", "meaning_shift"]);
+var runGh = (args, input) => {
+  const result = spawnSync("gh", args, { encoding: "utf8", input, maxBuffer: 32 * 1024 * 1024 });
+  if (result.error?.code === "ENOENT") {
+    throw new Error("gh_unavailable: install GitHub CLI from https://cli.github.com/ and run `gh auth login`");
+  }
+  if (result.error) throw new Error(`gh_unavailable: ${result.error.message}`);
+  if (result.status !== 0) throw new Error(`gist_request_failed: ${(result.stderr || result.stdout).trim()}`);
+  return result.stdout;
+};
+var runGit = (args, cwd) => {
+  const result = spawnSync("git", [
+    "-c",
+    "credential.helper=",
+    "-c",
+    "credential.helper=!gh auth git-credential",
+    ...args
+  ], { cwd, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+  if (result.error) throw new Error(`git_unavailable: ${result.error.message}`);
+  if (result.status !== 0) throw new Error(`gist_git_failed: ${(result.stderr || result.stdout).trim()}`);
+  return result.stdout;
+};
+var readLocalConfig = () => {
+  if (!existsSync2(CONFIG_PATH)) return {};
+  return JSON.parse(readFileSync2(CONFIG_PATH, "utf8"));
+};
+var readConfig = () => {
+  const local = readLocalConfig();
+  if (process.env.GYOJEONG_GIST_ID !== void 0) {
+    const gistId = process.env.GYOJEONG_GIST_ID.trim();
+    if (!GIST_ID.test(gistId)) throw new Error("invalid_GYOJEONG_GIST_ID");
+    return { ...local, gist_index_id: gistId };
+  }
+  return local;
+};
+var writeConfig = (config2) => {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  const current = existsSync2(CONFIG_PATH) ? JSON.parse(readFileSync2(CONFIG_PATH, "utf8")) : {};
+  writeFileSync(CONFIG_PATH, `${JSON.stringify({ ...current, ...config2, storage: "gist" }, null, 2)}
+`, { mode: 384 });
+  chmodSync(CONFIG_PATH, 384);
+};
+var assertPrivateOwnedGist = ({ isPublic, owner }, viewer) => {
+  if (isPublic !== false) throw new Error("gist_must_be_secret");
+  if (!owner || !viewer || owner.toLowerCase() !== viewer.toLowerCase()) {
+    throw new Error("gist_must_be_owned_by_authenticated_user");
+  }
+};
+var getVerifiedGist = (gistId) => {
+  const gist = JSON.parse(runGh(["api", `gists/${gistId}`]));
+  const viewer = runGh(["api", "user", "--jq", ".login"]).trim();
+  assertPrivateOwnedGist({ isPublic: gist.public, owner: gist.owner?.login }, viewer);
+  return gist;
+};
+var validateConfiguredGist = (gistId) => {
+  getVerifiedGist(gistId);
+};
+var ensureRuleGist = () => {
+  const found = readConfig();
+  if (GIST_ID.test(found?.gist_index_id ?? "")) {
+    validateConfiguredGist(found.gist_index_id);
+    writeConfig({ gist_index_id: found.gist_index_id });
+    return found.gist_index_id;
+  }
+  const state = { schema_version: 3, preferences: {} };
+  const body = JSON.stringify({
+    description: "gyojeong index (personal rules)",
+    public: false,
+    files: { "index.json": { content: JSON.stringify(state, null, 2) } }
+  });
+  const id = runGh(["api", "gists", "-X", "POST", "--input", "-", "--jq", ".id"], body).trim();
+  if (!GIST_ID.test(id)) throw new Error("invalid_gist_id");
+  writeConfig({ gist_index_id: id });
+  return id;
+};
+var readIndex = (gistId) => {
+  const directory = mkdtempSync(path2.join(tmpdir(), "gyojeong-rules-"));
+  try {
+    runGit(["clone", "--quiet", `https://gist.github.com/${gistId}.git`, directory]);
+  } catch (error2) {
+    rmSync(directory, { recursive: true, force: true });
+    throw error2;
+  }
+  try {
+    const indexPath = path2.join(directory, "index.json");
+    if (!existsSync2(indexPath)) throw new Error("missing_gist_index");
+    const state = JSON.parse(readFileSync2(indexPath, "utf8"));
+    if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error("invalid_gist_index");
+    state.preferences ??= {};
+    return { state, directory, indexPath, summaryPath: path2.join(directory, "rules.md") };
+  } catch (error2) {
+    rmSync(directory, { recursive: true, force: true });
+    throw error2;
+  }
+};
+var parseGistIndex = (gist) => {
+  const file = gist?.files?.["index.json"];
+  if (!file) throw new Error("missing_gist_index");
+  if (file.truncated || typeof file.content !== "string") throw new Error("gist_index_truncated");
+  const state = JSON.parse(file.content);
+  if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error("invalid_gist_index");
+  state.preferences ??= {};
+  return state;
+};
+var readGistRules = () => {
+  const found = readConfig();
+  let gistId;
+  let gist;
+  if (GIST_ID.test(found?.gist_index_id ?? "")) {
+    gistId = found.gist_index_id;
+    gist = getVerifiedGist(gistId);
+  } else {
+    gistId = ensureRuleGist();
+    gist = getVerifiedGist(gistId);
+  }
+  let state;
+  try {
+    state = parseGistIndex(gist);
+  } catch (error2) {
+    if (error2.message !== "gist_index_truncated") throw error2;
+    const cloned = readIndex(gistId);
+    try {
+      state = cloned.state;
+    } finally {
+      rmSync(cloned.directory, { recursive: true, force: true });
+    }
+  }
+  const { state: current } = migrateRuleState(state);
+  return {
+    gist_id: gistId,
+    onboarding_required: !isRulesOnboardingComplete(readConfig()),
+    active_rules: appliedRulebook(current.preferences)
+  };
+};
+var commitIndex = (state, directory, indexPath, summaryPath, message, removeOldHistory = false) => {
+  writeFileSync(indexPath, `${JSON.stringify(state)}
+`, { mode: 384 });
+  writeFileSync(summaryPath, renderRuleSummary(state.preferences), { mode: 384 });
+  if (removeOldHistory) rmSync(path2.join(directory, "review-history.json"), { force: true });
+  runGit(["config", "user.name", "gyojeong"], directory);
+  runGit(["config", "user.email", "gyojeong@local"], directory);
+  runGit(["add", "-A"], directory);
+  runGit(["commit", "--quiet", "-m", message], directory);
+};
+var normalized = (value) => String(value ?? "").normalize("NFC").trim().replace(/\s+/gu, " ").toLowerCase();
+var rulesEnvironmentKey = ({
+  machine = hostname(),
+  platform = process.platform,
+  home = homedir2(),
+  codexHome = process.env.CODEX_HOME || path2.join(home, ".codex"),
+  claudeHome = process.env.CLAUDE_CONFIG_DIR || path2.join(home, ".claude")
+} = {}) => createHash2("sha256").update(JSON.stringify([machine, platform, path2.resolve(home), path2.resolve(codexHome), path2.resolve(claudeHome)])).digest("hex").slice(0, 24);
+var isRulesOnboardingComplete = (config2, environmentKey = rulesEnvironmentKey()) => {
+  return Boolean(config2?.rules_onboarding_environments?.[environmentKey]?.completed_at);
+};
+var preferenceKey = (preference) => {
+  const category = preference?.structured_value?.category ?? preference?.category ?? "unspecified";
+  const subject = preference?.term || preference?.selected_text || "";
+  return `${category}\0${normalized(subject)}\0${normalized(preference?.correction)}`;
+};
+var distillRuleState = (state) => {
+  const preferences = {};
+  const groups = /* @__PURE__ */ new Map();
+  const mappedRules = new Set(Object.values(state.preferences ?? {}).filter((value) => value.rule_status === "active" && (value.mappings?.length || value.term)).map((value) => value.rule));
+  for (const [id, value] of Object.entries(state.preferences ?? {})) {
+    if (!["active", "candidate"].includes(value.rule_status) || !value.rule) continue;
+    if (value.rule_status === "candidate" && (!value.repeatable || !value.evidence?.length)) continue;
+    if (value.rule_status === "active" && !value.term && !value.mappings?.length && !value.context && mappedRules.has(value.rule)) continue;
+    const rawMappings = value.mappings ?? (value.term && value.correction ? [{ from: value.term, to: value.correction }] : void 0);
+    const mappings = rawMappings?.map((mapping) => ({
+      from: mapping.from,
+      to: mapping.to,
+      ...mapping.context || value.context ? { context: mapping.context ?? value.context } : {}
+    }));
+    const glossary = value.rule_status === "active" && mappings?.length;
+    const rule = glossary ? "\uAC80\uC218\uB41C \uC6A9\uC5B4 \uD45C\uAE30\uB97C \uBB38\uB9E5\uC5D0 \uB9DE\uAC8C \uC77C\uAD00\uB418\uAC8C \uC0AC\uC6A9\uD55C\uB2E4." : value.rule;
+    const groupKey = glossary ? "active-glossary" : `${value.rule_status}\0${normalized(rule)}\0${normalized(value.context)}\0${value.repeatable === true}`;
+    const existingId = groups.get(groupKey);
+    if (existingId) {
+      const existing = preferences[existingId];
+      for (const mapping of mappings ?? []) {
+        if (!existing.mappings?.some((item) => item.from === mapping.from && item.to === mapping.to && item.context === mapping.context)) (existing.mappings ??= []).push(mapping);
+      }
+      for (const evidence of value.rule_status === "candidate" ? value.evidence ?? [] : []) {
+        if (!existing.evidence?.some((item) => item.review_id === evidence.review_id && item.feedback_id === evidence.feedback_id)) {
+          (existing.evidence ??= []).push(evidence);
+        }
+      }
+      for (const sourceId of value.source_ids ?? (value.selected_text ? [id] : [])) {
+        if (!existing.source_ids?.includes(sourceId)) (existing.source_ids ??= []).push(sourceId);
+      }
+      existing.occurrences = Math.max(
+        existing.occurrences ?? 1,
+        value.occurrences ?? 1,
+        new Set((existing.evidence ?? []).map((item) => item.review_id)).size
+      );
+      continue;
+    }
+    groups.set(groupKey, id);
+    preferences[id] = {
+      category: value.category,
+      rule,
+      ...!glossary && value.context ? { context: value.context } : {},
+      ...mappings ? { mappings } : {},
+      ...value.repeatable ? { repeatable: true } : {},
+      ...value.rule_status === "candidate" && value.evidence ? { evidence: value.evidence } : {},
+      ...value.source_ids?.length || value.selected_text ? { source_ids: value.source_ids ?? [id] } : {},
+      rule_status: value.rule_status,
+      occurrences: value.occurrences,
+      promotion_reason: value.promotion_reason,
+      rule_updated_at: value.rule_updated_at
+    };
+  }
+  return { schema_version: 3, preferences };
+};
+var LEGACY_FIELDS = /* @__PURE__ */ new Set([
+  "owner_id",
+  "project_id",
+  "kind",
+  "source_language",
+  "target_language",
+  "domain",
+  "structured_value",
+  "selected_text",
+  "term",
+  "correction",
+  "created_at",
+  "evidence",
+  "occurrences",
+  "promotion_reason",
+  "rule_status",
+  "rule_updated_at",
+  "rule",
+  "context",
+  "category",
+  "repeatable",
+  "mappings",
+  "source_ids"
+]);
+var compactRuleState = (state) => {
+  const allowedTop = /* @__PURE__ */ new Set(["schema_version", "runs", "job_index", "idempotency", "preferences", "rules"]);
+  for (const key of Object.keys(state)) {
+    if (!allowedTop.has(key)) throw new Error(`unknown_gist_index_field: ${key}`);
+  }
+  const preferences = {};
+  for (const [id, value] of Object.entries(state.preferences ?? {})) {
+    for (const key of Object.keys(value)) {
+      if (!LEGACY_FIELDS.has(key)) throw new Error(`unknown_gist_preference_field: ${key}`);
+    }
+    const shadow = state.rules?.[id];
+    if (shadow && (shadow.status !== value.rule_status || shadow.occurrences !== value.occurrences || shadow.promotion_reason !== value.promotion_reason)) {
+      throw new Error(`conflicting_gist_rule: ${id}`);
+    }
+    preferences[id] = {
+      category: value.category ?? value.structured_value?.category,
+      selected_text: value.selected_text,
+      ...value.term ? { term: value.term } : {},
+      correction: value.correction,
+      ...value.rule ? { rule: value.rule } : {},
+      ...value.context ? { context: value.context } : {},
+      ...value.mappings ? { mappings: value.mappings } : {},
+      ...value.repeatable ? { repeatable: true } : {},
+      ...value.source_ids ? { source_ids: value.source_ids } : {},
+      created_at: value.created_at,
+      ...value.evidence ? { evidence: value.evidence } : {},
+      rule_status: value.rule_status,
+      occurrences: value.occurrences,
+      promotion_reason: value.promotion_reason,
+      rule_updated_at: value.rule_updated_at
+    };
+  }
+  if (state.rules && Object.keys(state.rules).some((id) => !preferences[id])) {
+    throw new Error("orphan_gist_rule");
+  }
+  return { schema_version: 3, preferences };
+};
+var migrateRuleState = (state, now = (/* @__PURE__ */ new Date()).toISOString()) => {
+  state.preferences ??= {};
+  const entries = Object.entries(state.preferences ?? {});
+  const counts = /* @__PURE__ */ new Map();
+  for (const [, preference] of entries) {
+    if (!preference.selected_text || !preference.correction) continue;
+    const key = preferenceKey(preference);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  const semanticEvidence = /* @__PURE__ */ new Map();
+  for (const [id, preference] of entries) {
+    if (!preference.repeatable || !preference.rule || DOCUMENT_ONLY_CATEGORIES.has(preference.category)) continue;
+    const key = `${normalized(preference.rule)}\0${normalized(preference.context)}`;
+    const sources = semanticEvidence.get(key) ?? /* @__PURE__ */ new Set();
+    for (const item of preference.evidence ?? []) sources.add(item.review_id ?? id);
+    if (!preference.evidence?.length) sources.add(id);
+    semanticEvidence.set(key, sources);
+  }
+  let active = 0;
+  let candidates = 0;
+  for (const [id, preference] of entries) {
+    const category = preference?.structured_value?.category ?? preference?.category;
+    const occurrences = preference.selected_text && preference.correction ? counts.get(preferenceKey(preference)) ?? 1 : preference.occurrences ?? 1;
+    const excluded = DOCUMENT_ONLY_CATEGORIES.has(category);
+    const semanticCount = semanticEvidence.get(`${normalized(preference.rule)}\0${normalized(preference.context)}`)?.size ?? 0;
+    const repeatedSemanticRule = preference.repeatable && semanticCount >= 3;
+    const status = excluded ? "excluded" : repeatedSemanticRule ? "active" : preference.rule_status ?? "candidate";
+    preference.rule_status = status;
+    preference.occurrences = Math.max(preference.occurrences ?? 1, occurrences, semanticCount);
+    preference.rule_updated_at ??= preference.created_at ?? now;
+    const automaticReason = excluded ? "document_only_category" : repeatedSemanticRule ? "repeated_semantic" : occurrences >= 2 ? "repeated_pending_agent" : "awaiting_repeat_or_agent";
+    if (excluded || repeatedSemanticRule || !preference.promotion_reason || preference.promotion_reason === "repeated_pending_agent" || preference.promotion_reason === "awaiting_repeat_or_agent") {
+      preference.promotion_reason = automaticReason;
+    }
+    if (status === "active") active += 1;
+    else if (status === "candidate") candidates += 1;
+  }
+  return { state: compactRuleState(state), active, candidates };
+};
+var preferenceId = (reviewId, feedbackId) => createHash2("sha256").update(`gyojeong-rule:${reviewId}:${feedbackId}`).digest("hex").slice(0, 32);
+var ruleCurationPreview = (reviewId, feedback2) => feedback2.filter(isDurableFeedback).map((item) => ({
+  id: preferenceId(reviewId, item.id),
+  category: item.category,
+  ...item.term ? { term: item.term } : {},
+  selected_text: item.selection.selected_text,
+  correction: item.correction
+}));
+var assertReviewCurations = (reviewId, feedback2, curations) => {
+  const curatedIds = new Set(curations.map((item) => item.id));
+  const missing = ruleCurationPreview(reviewId, feedback2).map((item) => item.id).filter((id) => !curatedIds.has(id));
+  if (missing.length) throw new Error(`missing_rule_curations: ${missing.join(",")}`);
+};
+var retainedReviewFeedback = (reviewId, feedback2, curations) => {
+  const decisions = new Map(curations.map((item) => [item.id, item.status]));
+  return feedback2.filter((item) => decisions.get(preferenceId(reviewId, item.id)) !== "discard");
+};
+var isDurableFeedback = (item) => item?.scope === "personal" && Boolean(item?.correction) && !DOCUMENT_ONLY_CATEGORIES.has(item?.category);
+var syncReviewRules = (state, reviewId, feedback2, now = (/* @__PURE__ */ new Date()).toISOString()) => {
+  state = migrateRuleState(state, now).state;
+  const seen = new Set(Object.entries(state.preferences).flatMap(([id, value]) => [id, ...value.source_ids ?? []]));
+  let added = 0;
+  for (const item of feedback2) {
+    if (!isDurableFeedback(item)) continue;
+    const id = preferenceId(reviewId, item.id);
+    if (seen.has(id)) continue;
+    state.preferences[id] = {
+      category: item.category,
+      selected_text: item.selection.selected_text,
+      ...item.term ? { term: item.term } : {},
+      correction: item.correction,
+      created_at: item.created_at ?? now,
+      evidence: [{ review_id: reviewId, feedback_id: item.id }]
+    };
+    added += 1;
+  }
+  return { ...migrateRuleState(state, now), added };
+};
+var sessionFeedbackId = (entry) => createHash2("sha256").update(JSON.stringify([entry.source, entry.session_id, entry.selected_text, entry.correction, entry.term ?? ""])).digest("hex").slice(0, 32);
+var syncSessionCorrections = (state, entries, now = (/* @__PURE__ */ new Date()).toISOString()) => {
+  if (!Array.isArray(entries) || entries.length === 0 || entries.length > 100) throw new Error("invalid_session_corrections");
+  const ids = [];
+  let added = 0;
+  for (const raw of entries) {
+    const entry = {
+      source: String(raw?.source ?? "").trim(),
+      session_id: String(raw?.session_id ?? "").trim(),
+      category: String(raw?.category ?? "unspecified").trim(),
+      selected_text: String(raw?.selected_text ?? "").normalize("NFC").trim(),
+      correction: String(raw?.correction ?? "").normalize("NFC").trim(),
+      term: raw?.term ? String(raw.term).normalize("NFC").trim() : void 0,
+      rule: raw?.rule ? String(raw.rule).normalize("NFC").trim() : void 0,
+      context: raw?.context ? String(raw.context).normalize("NFC").trim() : void 0,
+      general: raw?.general === true,
+      repeatable: raw?.repeatable === true
+    };
+    if (!["claude", "codex", "session"].includes(entry.source) || !/^[\w.:-]{1,200}$/u.test(entry.session_id) || !["unspecified", "awkward_expression", "terminology", "register"].includes(entry.category) || !entry.selected_text || !entry.correction || raw?.repeatable !== void 0 && typeof raw.repeatable !== "boolean" || entry.selected_text.length > 2e3 || entry.correction.length > 2e3 || entry.rule && entry.rule.length > 240 || entry.context && entry.context.length > 160 || /[\r\n]/u.test(entry.rule ?? "") || /[\r\n]/u.test(entry.context ?? "") || !entry.rule || entry.general && entry.repeatable) {
+      throw new Error("invalid_session_correction");
+    }
+    const feedbackId = sessionFeedbackId(entry);
+    const reviewId = `session:${entry.source}:${entry.session_id}`;
+    const id = preferenceId(reviewId, feedbackId);
+    const synced = syncReviewRules(state, reviewId, [{
+      id: feedbackId,
+      scope: "personal",
+      category: entry.category,
+      selection: { selected_text: entry.selected_text },
+      correction: entry.correction,
+      ...entry.term ? { term: entry.term } : {},
+      created_at: now
+    }], now);
+    state = synced.state;
+    added += synced.added;
+    const preference = state.preferences[id];
+    if (preference && synced.added > 0) {
+      if (entry.rule) preference.rule = entry.rule;
+      if (entry.context) preference.context = entry.context;
+      if (entry.repeatable) preference.repeatable = true;
+      preference.rule_status = entry.general ? "active" : "candidate";
+      preference.promotion_reason = entry.general ? "agent_general" : entry.repeatable ? "semantic_pending" : "agent_contextual";
+      preference.rule_updated_at = now;
+    }
+    ids.push(id);
+  }
+  return { ...migrateRuleState(state, now), added, ids };
+};
+var curateRules = (state, updates, now = (/* @__PURE__ */ new Date()).toISOString()) => {
+  if (!Array.isArray(updates) || updates.length === 0 || updates.length > 100) throw new Error("invalid_rule_curations");
+  state = migrateRuleState(state, now).state;
+  for (const raw of updates) {
+    const preference = state.preferences[raw?.id];
+    const rule = typeof raw?.rule === "string" ? raw.rule.normalize("NFC").trim() : "";
+    const context = typeof raw?.context === "string" ? raw.context.normalize("NFC").trim() : "";
+    const mappings = raw?.mappings?.map((mapping) => ({
+      from: typeof mapping?.from === "string" ? mapping.from.normalize("NFC").trim() : "",
+      to: typeof mapping?.to === "string" ? mapping.to.normalize("NFC").trim() : ""
+    }));
+    if (!preference || raw?.status !== "discard" && !rule || rule.length > 240 || context.length > 160 || /[\r\n]/u.test(rule) || /[\r\n]/u.test(context) || !["active", "candidate", "discard"].includes(raw?.status) || raw.repeatable !== void 0 && typeof raw.repeatable !== "boolean" || raw.mappings !== void 0 && (!Array.isArray(raw.mappings) || !mappings.length || mappings.length > 8 || mappings.some(({ from, to }) => !from || !to || from.length > 80 || to.length > 80 || /[\r\n]/u.test(`${from}${to}`)))) {
+      throw new Error("invalid_rule_curation");
+    }
+    if (DOCUMENT_ONLY_CATEGORIES.has(preference.category) && raw.status === "active") {
+      throw new Error(`document_only_preference: ${raw.id}`);
+    }
+    if (raw.status === "discard") {
+      delete state.preferences[raw.id];
+      continue;
+    }
+    preference.rule = rule;
+    if (mappings) preference.mappings = mappings;
+    if (context) preference.context = context;
+    else delete preference.context;
+    preference.rule_status = raw.status;
+    if (raw.repeatable === true && raw.status === "candidate") preference.repeatable = true;
+    else delete preference.repeatable;
+    preference.promotion_reason = raw.status === "active" ? "agent_general" : preference.repeatable ? "semantic_pending" : "agent_contextual";
+    preference.rule_updated_at = now;
+  }
+  return migrateRuleState(state, now);
+};
+var presentActiveRules = (preferences) => {
+  const rules2 = /* @__PURE__ */ new Map();
+  const terms = /* @__PURE__ */ new Map();
+  const termRules = /* @__PURE__ */ new Set();
+  for (const [id, value] of Object.entries(preferences)) {
+    if (value.rule_status !== "active") continue;
+    const mappings = value.mappings ?? (value.term ? [{ from: value.term, to: value.correction }] : []);
+    for (const mapping of mappings) {
+      const context = mapping.context ?? value.context;
+      const key = `${mapping.from}\0${mapping.to}\0${context ?? ""}`;
+      const entry = terms.get(key) ?? { ...mapping, ...context ? { context } : {}, ids: [] };
+      entry.ids.push(id);
+      terms.set(key, entry);
+    }
+    if (mappings.length && value.rule) termRules.add(value.rule);
+  }
+  if (terms.size) rules2.set("glossary", {
+    rule: "\uAC80\uC218\uB41C \uC6A9\uC5B4 \uD45C\uAE30\uB97C \uBB38\uB9E5\uC5D0 \uB9DE\uAC8C \uC77C\uAD00\uB418\uAC8C \uC0AC\uC6A9\uD55C\uB2E4.",
+    terms: [...terms.values()]
+  });
+  for (const [id, value] of Object.entries(preferences)) {
+    if (value.rule_status !== "active") continue;
+    if (value.term || value.mappings || value.rule && !value.context && termRules.has(value.rule)) continue;
+    if (!value.rule) {
+      rules2.set(id, {
+        id,
+        category: value.category,
+        term: value.term,
+        selected_text: value.selected_text,
+        correction: value.correction,
+        occurrences: value.occurrences,
+        reason: value.promotion_reason
+      });
+      continue;
+    }
+    const key = `${value.rule}\0${value.context ?? ""}`;
+    const existing = rules2.get(key);
+    if (existing) {
+      existing.ids.push(id);
+    } else {
+      rules2.set(key, { ids: [id], rule: value.rule, ...value.context ? { context: value.context } : {} });
+    }
+  }
+  return [...rules2.values()];
+};
+var renderRuleSummary = (preferences) => {
+  const lines = ["# gyojeong active rules", "", "Apply these to Korean text you write, revise, or save. Candidate evidence is not a rule.", ""];
+  for (const entry of presentActiveRules(preferences)) {
+    if (entry.terms) {
+      lines.push(`- ${entry.rule}`);
+      lines.push(`  ${entry.terms.map(({ from, to, context }) => `${from} -> ${to}${context ? ` (${context})` : ""}`).join(", ")}`);
+    } else if (entry.rule) lines.push(`- ${entry.rule}${entry.context ? ` (${entry.context})` : ""}`);
+    else lines.push(`- ${entry.term ?? entry.selected_text} -> ${entry.correction}`);
+  }
+  return `${lines.join("\n")}
+`;
+};
+var appliedRulebook = (preferences) => presentActiveRules(preferences).map((entry) => {
+  if (entry.terms) return { rule: entry.rule, terms: entry.terms.map(({ ids: ids2, ...term }) => term) };
+  const { id, ids, ...instruction } = entry;
+  return instruction;
+});
+var updateGistRules = ({ reviewId, feedback: feedback2 = [], promoteIds = [], candidateIds = [], sessionCorrections = [], curations = [], completeOnboarding = false, includeCandidates = false, distill = false } = {}) => {
+  if (reviewId) assertReviewCurations(reviewId, feedback2, curations);
+  const gistId = ensureRuleGist();
+  const environmentKey = rulesEnvironmentKey();
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const { state, directory, indexPath, summaryPath } = readIndex(gistId);
+    try {
+      const before = JSON.stringify(state);
+      const retainedFeedback = reviewId ? retainedReviewFeedback(reviewId, feedback2, curations) : [];
+      let synced = reviewId ? syncReviewRules(state, reviewId, retainedFeedback) : migrateRuleState(state);
+      let added = synced.added ?? 0;
+      if (sessionCorrections.length) {
+        synced = syncSessionCorrections(synced.state, sessionCorrections);
+        added += synced.added;
+      }
+      const rawState = structuredClone(synced.state);
+      if (curations.length) {
+        const seen = new Set(Object.values(synced.state.preferences).flatMap((value) => value.source_ids ?? []));
+        const pending = curations.filter((item) => (item.status !== "discard" || synced.state.preferences[item.id]) && (synced.state.preferences[item.id] || !seen.has(item.id)));
+        if (pending.length) synced = curateRules(synced.state, pending);
+      }
+      for (const id of promoteIds) {
+        const preference = synced.state.preferences[id];
+        if (!preference) throw new Error(`unknown_preference: ${id}`);
+        if (DOCUMENT_ONLY_CATEGORIES.has(preference?.structured_value?.category ?? preference?.category)) {
+          throw new Error(`document_only_preference: ${id}`);
+        }
+        if (!preference.rule) throw new Error(`missing_rule_summary: ${id}`);
+        preference.rule_status = "active";
+        preference.promotion_reason = "agent_general";
+        preference.rule_updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      for (const id of candidateIds) {
+        const preference = synced.state.preferences[id];
+        if (!preference) throw new Error(`unknown_preference: ${id}`);
+        if (DOCUMENT_ONLY_CATEGORIES.has(preference?.structured_value?.category ?? preference?.category)) {
+          throw new Error(`document_only_preference: ${id}`);
+        }
+        preference.rule_status = "candidate";
+        preference.promotion_reason = "agent_contextual";
+        preference.rule_updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      const shouldDistill = distill || added > 0 || curations.length > 0;
+      if (shouldDistill) synced.state = distillRuleState(synced.state);
+      const summary = renderRuleSummary(synced.state.preferences);
+      const oldHistory = path2.join(directory, "review-history.json");
+      const finalChanged = added > 0 || JSON.stringify(synced.state) !== before || !existsSync2(summaryPath) || readFileSync2(summaryPath, "utf8") !== summary || shouldDistill && existsSync2(oldHistory);
+      if (finalChanged) {
+        try {
+          if (added > 0) commitIndex(rawState, directory, indexPath, summaryPath, "Archive correction evidence");
+          commitIndex(synced.state, directory, indexPath, summaryPath, "Update distilled personal rules", shouldDistill);
+          runGit(["push", "--quiet", "origin", "HEAD"], directory);
+        } catch (error2) {
+          if (/rejected|fetch first|non-fast-forward/iu.test(String(error2)) && attempt < 2) continue;
+          throw error2;
+        }
+      }
+      const preferences = Object.entries(synced.state.preferences);
+      if (completeOnboarding) {
+        const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const localConfig = readLocalConfig();
+        writeConfig({
+          rules_onboarding_environments: {
+            ...localConfig.rules_onboarding_environments ?? {},
+            [environmentKey]: { completed_at: completedAt }
+          }
+        });
+      }
+      const currentConfig = readConfig();
+      const onboardingComplete = isRulesOnboardingComplete(currentConfig, environmentKey);
+      return {
+        gist_id: gistId,
+        storage: "gist",
+        added,
+        active: preferences.filter(([, value]) => value.rule_status === "active").length,
+        candidates: preferences.filter(([, value]) => value.rule_status === "candidate").length,
+        excluded: preferences.filter(([, value]) => value.rule_status === "excluded").length,
+        rules_environment_id: environmentKey,
+        onboarding_required: !onboardingComplete,
+        session_rule_ids: synced.ids ?? [],
+        active_rules: appliedRulebook(synced.state.preferences),
+        ...includeCandidates || reviewId ? { recent: preferences.filter(([, value]) => value.rule_status === "candidate").filter(([, value]) => !reviewId || value.evidence?.some((item) => item.review_id === reviewId)).sort((a, b) => String(b[1].rule_updated_at ?? b[1].created_at).localeCompare(String(a[1].rule_updated_at ?? a[1].created_at))).slice(0, 20).map(([id, value]) => ({
+          id,
+          status: value.rule_status,
+          category: value.category,
+          rule: value.rule,
+          context: value.context,
+          mappings: value.mappings,
+          occurrences: value.occurrences,
+          evidence_count: value.evidence?.length ?? 0,
+          reason: value.promotion_reason
+        })) } : {}
+      };
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  }
+  throw new Error("gist_write_conflict");
+};
+
+// ../../scripts/session-history.mjs
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { createReadStream, existsSync as existsSync3 } from "node:fs";
+import { opendir } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path3 from "node:path";
+import { createInterface } from "node:readline";
+var LANGUAGE_SIGNAL = /(영어|한글|원문|표현|단어|문구|말투|문장|번역|한국어|용어|윤문)/u;
+var CORRECTION_SIGNAL = /(해줘|써줘|바꿔|변경|고쳐|이상|어색|유지|그대로|하지\s*마|말고|통일|대신|풀어서)/u;
+var NON_LANGUAGE_SIGNAL = /(코드|구현|함수|클래스|파일|테스트|빌드|배포|서버|기능|버그|브랜치|커밋|프로젝트|api|ui|pr)/iu;
+var ARROW_REPLACEMENT = /.{1,80}\s*(?:->|=>|→)\s*.{1,80}/u;
+var EXPLICIT_REPLACEMENT = /(?:(?:대신에?|말고)\s*.{1,80}(?:써|사용|표현|바꿔|변경|고쳐))|(?:.{1,80}(?:로|으로)\s*(?:바꿔|변경|고쳐|써))/u;
+var SEARCH_SIGNAL = "(\uC601\uC5B4|\uD55C\uAE00|\uC6D0\uBB38|\uD45C\uD604|\uB2E8\uC5B4|\uBB38\uAD6C|\uB9D0\uD22C|\uBB38\uC7A5|\uBC88\uC5ED|\uD55C\uAD6D\uC5B4|\uC6A9\uC5B4|\uC724\uBB38|->|=>|\u2192|(\uB300\uC2E0\uC5D0?|\uB9D0\uACE0).{1,80}(\uC368|\uC0AC\uC6A9|\uD45C\uD604|\uBC14\uAFD4|\uBCC0\uACBD|\uACE0\uCCD0)|(\uB85C|\uC73C\uB85C)\\s*(\uBC14\uAFD4|\uBCC0\uACBD|\uACE0\uCCD0|\uC368))";
+var SEARCH_SIGNAL_JS = new RegExp(SEARCH_SIGNAL, "iu");
+var historyRecordPrefix = (source) => source === "codex" ? '^\\{(?=.{0,2048}$)(?=.*"type"\\s*:\\s*"response_item")(?=.*"role"\\s*:\\s*"user").*' : '^\\{(?=.{0,2048}$)(?=.*"type"\\s*:\\s*"user").*';
+var stringContent = (content) => {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((item) => typeof item === "string" ? item : item?.text ?? "").join("\n");
+};
+var sessionUserText = (record) => {
+  if (record?.type === "response_item" && record?.payload?.role === "user") {
+    return stringContent(record.payload.content);
+  }
+  if (record?.type === "user") return stringContent(record.content ?? record.message?.content);
+  return "";
+};
+var isCorrectionCandidate = (text) => {
+  const normalized2 = String(text ?? "").normalize("NFC").trim();
+  return normalized2.length > 0 && normalized2.length <= 500 && !normalized2.startsWith("<") && (LANGUAGE_SIGNAL.test(normalized2) && CORRECTION_SIGNAL.test(normalized2) || ARROW_REPLACEMENT.test(normalized2) || !NON_LANGUAGE_SIGNAL.test(normalized2) && EXPLICIT_REPLACEMENT.test(normalized2));
+};
+var addRecord = (records, group, file, record) => {
+  const text = sessionUserText(record).normalize("NFC").trim();
+  if (!isCorrectionCandidate(text)) return;
+  const sessionId = path3.basename(file, ".jsonl");
+  const fingerprint = createHash3("sha256").update(text).digest("hex").slice(0, 16);
+  const sessionKey = `${group.source}:${sessionId}`;
+  const evidence = { source: group.source, session_id: sessionId, timestamp: record.timestamp ?? null };
+  const existing = records.get(fingerprint);
+  if (existing) {
+    if (existing._session_keys.has(sessionKey)) return;
+    existing._session_keys.add(sessionKey);
+    existing.occurrences += 1;
+    if (existing.evidence.length < 20) existing.evidence.push(evidence);
+    if (String(record.timestamp ?? "") > String(existing.timestamp ?? "")) {
+      existing.source = group.source;
+      existing.session_id = sessionId;
+      existing.timestamp = record.timestamp ?? null;
+    }
+    return;
+  }
+  records.set(fingerprint, {
+    fingerprint,
+    source: group.source,
+    session_id: sessionId,
+    timestamp: record.timestamp ?? null,
+    text,
+    occurrences: 1,
+    evidence: [evidence],
+    _session_keys: /* @__PURE__ */ new Set([sessionKey])
+  });
+};
+async function* jsonlFiles(root) {
+  let directory;
+  try {
+    directory = await opendir(root);
+  } catch {
+    return;
+  }
+  for await (const entry of directory) {
+    const file = path3.join(root, entry.name);
+    if (entry.isDirectory()) yield* jsonlFiles(file);
+    else if (entry.isFile() && entry.name.endsWith(".jsonl")) yield file;
+  }
+}
+var scanWithoutRipgrep = async (records, group, roots) => {
+  for (const root of roots) {
+    for await (const file of jsonlFiles(root)) {
+      const lines = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
+      try {
+        for await (const raw of lines) {
+          if (raw.length > 2048 || !SEARCH_SIGNAL_JS.test(raw)) continue;
+          let record;
+          try {
+            record = JSON.parse(raw);
+          } catch {
+            continue;
+          }
+          addRecord(records, group, file, record);
+        }
+      } catch {
+      }
+    }
+  }
+};
+var scanSessionHistory = async (requested = "all") => {
+  if (!["all", "claude", "codex"].includes(requested)) throw new Error("--history must be all, claude, or codex");
+  const claudeHome = process.env.CLAUDE_CONFIG_DIR || path3.join(homedir3(), ".claude");
+  const codexHome = process.env.CODEX_HOME || path3.join(homedir3(), ".codex");
+  const sourceRoots = [];
+  if (requested !== "codex") {
+    sourceRoots.push({ source: "claude", roots: [path3.join(claudeHome, "transcripts"), path3.join(claudeHome, "projects")] });
+  }
+  if (requested !== "claude") sourceRoots.push({ source: "codex", roots: [path3.join(codexHome, "sessions")] });
+  const available = sourceRoots.flatMap((group) => group.roots).filter(existsSync3);
+  if (!available.length) return { scanned: [], count: 0, candidates: [] };
+  const unique = /* @__PURE__ */ new Map();
+  for (const group of sourceRoots) {
+    const roots = group.roots.filter(existsSync3);
+    if (!roots.length) continue;
+    const prefix = historyRecordPrefix(group.source);
+    const result = spawnSync2("rg", [
+      "--json",
+      "--pcre2",
+      "-g",
+      "*.jsonl",
+      `${prefix}${SEARCH_SIGNAL}`,
+      ...roots
+    ], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+    if (result.error?.code === "ENOENT") {
+      await scanWithoutRipgrep(unique, group, roots);
+      continue;
+    }
+    if (result.error) throw new Error(`history_scan_unavailable: ${result.error.message}`);
+    if (result.status !== 0 && result.status !== 1) throw new Error(`history_scan_failed: ${result.stderr.trim()}`);
+    for (const line of result.stdout.split("\n")) {
+      if (!line) continue;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (event.type !== "match") continue;
+      const file = event.data?.path?.text;
+      const raw = event.data?.lines?.text;
+      if (!file || !raw) continue;
+      let record;
+      try {
+        record = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      addRecord(unique, group, file, record);
+    }
+  }
+  const candidates = [...unique.values()].sort((a, b) => String(b.timestamp ?? "").localeCompare(String(a.timestamp ?? ""))).slice(0, 200).map(({ _session_keys, ...candidate }) => candidate);
+  return { scanned: available, count: candidates.length, truncated: unique.size > candidates.length, candidates };
+};
+
 // ../../scripts/review-store.mjs
 import { randomUUID } from "node:crypto";
 import {
-  chmodSync,
-  existsSync as existsSync2,
-  mkdirSync,
+  chmodSync as chmodSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
   readdirSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   renameSync,
-  rmSync,
+  rmSync as rmSync2,
   statSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { hostname, homedir as homedir2 } from "node:os";
-import path2 from "node:path";
+import { hostname as hostname2, homedir as homedir4 } from "node:os";
+import path4 from "node:path";
 
 // ../feedback-core/dist/index.js
 var createSelectionValidator = (text) => {
@@ -6111,29 +7165,29 @@ var StoreProblem = class extends Error {
   }
 };
 var problem = (status, code, message, nextAction) => new StoreProblem(status, code, message, nextAction);
-var storeHome = () => path2.resolve(process.env.GYOJEONG_HOME || path2.join(homedir2(), ".local", "share", "gyojeong"));
-var runsDir = (home) => path2.join(home, "runs");
+var storeHome = () => path4.resolve(process.env.GYOJEONG_HOME || path4.join(homedir4(), ".local", "share", "gyojeong"));
+var runsDir = (home) => path4.join(home, "runs");
 var runDir = (home, id) => {
   if (typeof id !== "string" || !REVIEW_ID.test(id)) {
     throw problem(400, "invalid_request", "\uAC80\uC218 ID \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.", "\uD604\uC7AC \uAC80\uC218 \uB9C1\uD06C\uB97C \uB2E4\uC2DC \uC5F4\uC5B4 \uC8FC\uC138\uC694.");
   }
-  return path2.join(runsDir(home), id);
+  return path4.join(runsDir(home), id);
 };
 var ensurePrivateDir = (dir) => {
-  mkdirSync(dir, { recursive: true, mode: 448 });
-  chmodSync(dir, 448);
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  chmodSync2(dir, 448);
 };
 var writeAtomic = (file, text) => {
   const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-  writeFileSync(temp, text, { mode: 384 });
+  writeFileSync2(temp, text, { mode: 384 });
   renameSync(temp, file);
 };
 var readJson = (file, fallback) => {
-  if (!existsSync2(file)) return fallback;
+  if (!existsSync4(file)) return fallback;
   try {
-    return JSON.parse(readFileSync2(file, "utf8"));
+    return JSON.parse(readFileSync3(file, "utf8"));
   } catch {
-    throw problem(409, "storage_integrity", `${path2.basename(file)} \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.`, "\uAC80\uC218 \uAE30\uB85D \uD30C\uC77C\uC744 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+    throw problem(409, "storage_integrity", `${path4.basename(file)} \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.`, "\uAC80\uC218 \uAE30\uB85D \uD30C\uC77C\uC744 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
   }
 };
 var sleepSync = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -6147,19 +7201,19 @@ var processAlive = (pid) => {
 };
 var acquireLock = (lock) => {
   const token = randomUUID();
-  const owner = { pid: process.pid, host: hostname(), token, at: (/* @__PURE__ */ new Date()).toISOString() };
+  const owner = { pid: process.pid, host: hostname2(), token, at: (/* @__PURE__ */ new Date()).toISOString() };
   const deadline = Date.now() + LOCK_WAIT_MS;
   const readOwner = () => {
     try {
-      return JSON.parse(readFileSync2(path2.join(lock, "owner.json"), "utf8"));
+      return JSON.parse(readFileSync3(path4.join(lock, "owner.json"), "utf8"));
     } catch {
       return null;
     }
   };
   for (; ; ) {
     try {
-      mkdirSync(lock);
-      writeFileSync(path2.join(lock, "owner.json"), JSON.stringify(owner), { mode: 384 });
+      mkdirSync2(lock);
+      writeFileSync2(path4.join(lock, "owner.json"), JSON.stringify(owner), { mode: 384 });
       break;
     } catch (error2) {
       if (error2?.code === "ENOENT") {
@@ -6173,12 +7227,12 @@ var acquireLock = (lock) => {
       } catch {
         continue;
       }
-      const dead = held?.host === hostname() && Number.isInteger(held.pid) && !processAlive(held.pid);
+      const dead = held?.host === hostname2() && Number.isInteger(held.pid) && !processAlive(held.pid);
       if (dead || age > LOCK_STALE_MS) {
         try {
           const broken = `${lock}.${token}.broken`;
           renameSync(lock, broken);
-          rmSync(broken, { recursive: true, force: true });
+          rmSync2(broken, { recursive: true, force: true });
           continue;
         } catch {
         }
@@ -6190,7 +7244,7 @@ var acquireLock = (lock) => {
     }
   }
   return () => {
-    if (readOwner()?.token === token) rmSync(lock, { recursive: true, force: true });
+    if (readOwner()?.token === token) rmSync2(lock, { recursive: true, force: true });
   };
 };
 var withLock = (lock, task) => {
@@ -6201,9 +7255,9 @@ var withLock = (lock, task) => {
     release();
   }
 };
-var withRunLock = (dir, task) => withLock(path2.join(dir, ".lock"), task);
+var withRunLock = (dir, task) => withLock(path4.join(dir, ".lock"), task);
 var assertRunExists = (dir) => {
-  if (!existsSync2(path2.join(dir, "content.json"))) {
+  if (!existsSync4(path4.join(dir, "content.json"))) {
     throw problem(404, "wrong_run", "\uAC80\uC218 \uAE30\uB85D\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uAC80\uC218\uAC00 \uC774\uBBF8 \uC885\uB8CC\uB410\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
   }
 };
@@ -6211,7 +7265,7 @@ var createRun = (home, input, { mode, check: check2 } = {}) => {
   const id = input.run_id;
   const dir = runDir(home, id);
   ensurePrivateDir(runsDir(home));
-  if (existsSync2(dir)) {
+  if (existsSync4(dir)) {
     throw problem(409, "duplicate_run", "\uAC19\uC740 ID\uC758 \uAC80\uC218\uAC00 \uC774\uBBF8 \uC788\uC2B5\uB2C8\uB2E4.", "\uC0C8 ID\uB85C \uB2E4\uC2DC \uAC8C\uC2DC\uD574 \uC8FC\uC138\uC694.");
   }
   const job = input.jobs[0];
@@ -6243,15 +7297,15 @@ var createRun = (home, input, { mode, check: check2 } = {}) => {
   ensurePrivateDir(staging);
   try {
     (input.attachments ?? []).forEach((attachment, index) => {
-      writeFileSync(path2.join(staging, `attachment-${index}.b64`), attachment.content_base64, { mode: 384 });
+      writeFileSync2(path4.join(staging, `attachment-${index}.b64`), attachment.content_base64, { mode: 384 });
     });
-    writeFileSync(path2.join(staging, "content.json"), serializeReviewContent(content), { mode: 384 });
-    writeFileSync(path2.join(staging, "feedback.json"), "[]", { mode: 384 });
-    writeFileSync(path2.join(staging, "state.json"), JSON.stringify({ processed_feedback_ids: [] }), { mode: 384 });
-    writeFileSync(path2.join(staging, "meta.json"), JSON.stringify({ created_at: createdAt }), { mode: 384 });
+    writeFileSync2(path4.join(staging, "content.json"), serializeReviewContent(content), { mode: 384 });
+    writeFileSync2(path4.join(staging, "feedback.json"), "[]", { mode: 384 });
+    writeFileSync2(path4.join(staging, "state.json"), JSON.stringify({ processed_feedback_ids: [] }), { mode: 384 });
+    writeFileSync2(path4.join(staging, "meta.json"), JSON.stringify({ created_at: createdAt }), { mode: 384 });
     renameSync(staging, dir);
   } catch (error2) {
-    rmSync(staging, { recursive: true, force: true });
+    rmSync2(staging, { recursive: true, force: true });
     throw error2;
   }
   return { id, job_id: content.job.id, created_at: createdAt };
@@ -6259,14 +7313,14 @@ var createRun = (home, input, { mode, check: check2 } = {}) => {
 var readContent = (home, id) => {
   const dir = runDir(home, id);
   assertRunExists(dir);
-  return readJson(path2.join(dir, "content.json"), null);
+  return readJson(path4.join(dir, "content.json"), null);
 };
 var readRun = (home, id) => {
   const dir = runDir(home, id);
   assertRunExists(dir);
-  const content = readJson(path2.join(dir, "content.json"), null);
-  const feedback2 = readJson(path2.join(dir, "feedback.json"), []);
-  const state = readJson(path2.join(dir, "state.json"), { processed_feedback_ids: [] });
+  const content = readJson(path4.join(dir, "content.json"), null);
+  const feedback2 = readJson(path4.join(dir, "feedback.json"), []);
+  const state = readJson(path4.join(dir, "state.json"), { processed_feedback_ids: [] });
   const processed2 = new Set(state.processed_feedback_ids ?? []);
   return {
     content,
@@ -6318,30 +7372,30 @@ var pendingFeedbackByDraft = (home, id, run) => {
 };
 var readDraftVersion = (home, id, version2, content = readContent(home, id)) => {
   if (version2 === (content.draft_version ?? 0)) return content.draft_text;
-  const file = path2.join(runDir(home, id), `draft-${version2}.txt`);
-  if (!Number.isInteger(version2) || version2 < 0 || !existsSync2(file)) {
+  const file = path4.join(runDir(home, id), `draft-${version2}.txt`);
+  if (!Number.isInteger(version2) || version2 < 0 || !existsSync4(file)) {
     throw problem(409, "storage_integrity", "\uD53C\uB4DC\uBC31\uC744 \uB0A8\uAE34 \uCD08\uC548\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uAC80\uC218 \uAE30\uB85D\uC744 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
   }
-  return readFileSync2(file, "utf8");
+  return readFileSync3(file, "utf8");
 };
 var markProcessed = (home, id, feedbackIds) => {
   const dir = runDir(home, id);
   assertRunExists(dir);
   return withRunLock(dir, () => {
-    const feedback2 = readJson(path2.join(dir, "feedback.json"), []);
+    const feedback2 = readJson(path4.join(dir, "feedback.json"), []);
     const known = new Set(feedback2.map((item) => item.id));
     const unknown2 = feedbackIds.filter((fid) => !known.has(fid));
     if (unknown2.length) {
       throw problem(400, "unknown_feedback", `\uC774 \uAC80\uC218\uC5D0 \uC5C6\uB294 \uD53C\uB4DC\uBC31 ID\uC785\uB2C8\uB2E4: ${unknown2.join(", ")}`, "\uD53C\uB4DC\uBC31 \uBAA9\uB85D\uC744 \uB2E4\uC2DC \uC77D\uC5B4 \uC8FC\uC138\uC694.");
     }
-    const state = readJson(path2.join(dir, "state.json"), { processed_feedback_ids: [] });
+    const state = readJson(path4.join(dir, "state.json"), { processed_feedback_ids: [] });
     const processed2 = [.../* @__PURE__ */ new Set([...state.processed_feedback_ids ?? [], ...feedbackIds])];
-    writeAtomic(path2.join(dir, "state.json"), JSON.stringify({ ...state, processed_feedback_ids: processed2 }));
+    writeAtomic(path4.join(dir, "state.json"), JSON.stringify({ ...state, processed_feedback_ids: processed2 }));
     const done = new Set(processed2);
     const needed = new Set(feedback2.filter((item) => !done.has(item.id)).map((item) => item.draft_version));
     for (const file of readdirSync(dir)) {
       const match = /^draft-(\d+)\.txt$/u.exec(file);
-      if (match && !needed.has(Number(match[1]))) rmSync(path2.join(dir, file), { force: true });
+      if (match && !needed.has(Number(match[1]))) rmSync2(path4.join(dir, file), { force: true });
     }
     return { processed: processed2.length, pending: feedback2.filter((item) => !done.has(item.id)).length };
   });
@@ -6350,7 +7404,7 @@ var reviseDraft = (home, id, draftText, { check: check2 } = {}) => {
   const dir = runDir(home, id);
   assertRunExists(dir);
   return withRunLock(dir, () => {
-    const content = readJson(path2.join(dir, "content.json"), null);
+    const content = readJson(path4.join(dir, "content.json"), null);
     if (content.draft_text === draftText) {
       throw problem(409, "unchanged_draft", "\uC218\uC815\uBCF8\uC774 \uAE30\uC874 \uCD08\uC548\uACFC \uAC19\uC2B5\uB2C8\uB2E4.", "\uC218\uC815\uD55C \uD30C\uC77C\uC744 \uC9C0\uC815\uD588\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
     }
@@ -6367,18 +7421,18 @@ var reviseDraft = (home, id, draftText, { check: check2 } = {}) => {
       revised_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     const serialized = serializeReviewContent(next);
-    const feedback2 = readJson(path2.join(dir, "feedback.json"), []);
+    const feedback2 = readJson(path4.join(dir, "feedback.json"), []);
     const unversioned = feedback2.filter((item) => item.draft_version === void 0);
     if (unversioned.length) {
       const fitsCurrent = selectionChecker(content.draft_text);
       for (const item of unversioned) item.draft_version = feedbackDraftVersion(item, content, fitsCurrent);
-      writeAtomic(path2.join(dir, "feedback.json"), JSON.stringify(feedback2, null, 2));
+      writeAtomic(path4.join(dir, "feedback.json"), JSON.stringify(feedback2, null, 2));
     }
-    const processed2 = new Set(readJson(path2.join(dir, "state.json"), { processed_feedback_ids: [] }).processed_feedback_ids ?? []);
+    const processed2 = new Set(readJson(path4.join(dir, "state.json"), { processed_feedback_ids: [] }).processed_feedback_ids ?? []);
     if (feedback2.some((item) => !processed2.has(item.id) && item.draft_version === version2)) {
-      writeAtomic(path2.join(dir, `draft-${version2}.txt`), content.draft_text);
+      writeAtomic(path4.join(dir, `draft-${version2}.txt`), content.draft_text);
     }
-    writeAtomic(path2.join(dir, "content.json"), serialized);
+    writeAtomic(path4.join(dir, "content.json"), serialized);
     return { id, revised_at: next.revised_at };
   });
 };
@@ -6386,32 +7440,32 @@ var finishRun = (home, id, force = false) => {
   const dir = runDir(home, id);
   assertRunExists(dir);
   return withRunLock(dir, () => {
-    const feedback2 = readJson(path2.join(dir, "feedback.json"), []);
-    const state = readJson(path2.join(dir, "state.json"), { processed_feedback_ids: [] });
+    const feedback2 = readJson(path4.join(dir, "feedback.json"), []);
+    const state = readJson(path4.join(dir, "state.json"), { processed_feedback_ids: [] });
     const processed2 = new Set(state.processed_feedback_ids ?? []);
     const pending = feedback2.filter((item) => !processed2.has(item.id)).length;
     if (pending > 0 && force !== true) return { finished: false, pending };
     const trash = `${dir}.${process.pid}.deleting`;
     renameSync(dir, trash);
-    rmSync(trash, { recursive: true, force: true });
+    rmSync2(trash, { recursive: true, force: true });
     return { finished: true, pending };
   });
 };
 var discardRun = (home, id) => finishRun(home, id, true);
 var listRuns = (home, now = Date.now()) => {
-  if (!existsSync2(runsDir(home))) return [];
+  if (!existsSync4(runsDir(home))) return [];
   return readdirSync(runsDir(home)).filter((name) => REVIEW_ID.test(name)).flatMap((id) => {
     try {
       const dir = runDir(home, id);
       let meta2 = null;
       try {
-        meta2 = readJson(path2.join(dir, "meta.json"), null);
+        meta2 = readJson(path4.join(dir, "meta.json"), null);
       } catch {
         meta2 = null;
       }
-      const createdAt = (meta2?.created_at ? meta2 : readJson(path2.join(dir, "content.json"), null)).created_at;
-      const feedback2 = readJson(path2.join(dir, "feedback.json"), []);
-      const processed2 = new Set(readJson(path2.join(dir, "state.json"), { processed_feedback_ids: [] }).processed_feedback_ids ?? []);
+      const createdAt = (meta2?.created_at ? meta2 : readJson(path4.join(dir, "content.json"), null)).created_at;
+      const feedback2 = readJson(path4.join(dir, "feedback.json"), []);
+      const processed2 = new Set(readJson(path4.join(dir, "state.json"), { processed_feedback_ids: [] }).processed_feedback_ids ?? []);
       return [
         {
           review_id: id,
@@ -6428,8 +7482,8 @@ var listRuns = (home, now = Date.now()) => {
 };
 
 // ../../scripts/review-cli.mjs
-var SCRIPT_DIR = path3.dirname(fileURLToPath(import.meta.url));
-var SERVER_SCRIPT = path3.join(SCRIPT_DIR, "review-server.mjs");
+var SCRIPT_DIR = path5.dirname(fileURLToPath(import.meta.url));
+var SERVER_SCRIPT = path5.join(SCRIPT_DIR, "review-server.mjs");
 var MAX_TEXT_BYTES = 2 * 1024 * 1024;
 var STALE_DAYS = 14;
 var MEDIA_TYPES = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp" };
@@ -6452,15 +7506,15 @@ var readRaw = (file, maxBytes = MAX_TEXT_BYTES) => {
   const stat = statSync2(file, { throwIfNoEntry: false });
   if (!stat?.isFile()) throw new UsageError(`not a file: ${file}`);
   if (stat.size > maxBytes) throw new UsageError(`file larger than ${maxBytes / 1024 / 1024} MiB: ${file}`);
-  return readFileSync3(file, "utf8");
+  return readFileSync4(file, "utf8");
 };
 var readText = (file) => readRaw(file).normalize("NFC");
 var requireOptions = (options, ...keys) => {
   for (const key of keys) if (!options[key]) throw new UsageError(`--${key} is required`);
 };
 var loadStandards = () => {
-  const file = path3.join(".gyojeong", "standards");
-  return existsSync3(file) ? parseStandards(readFileSync3(file, "utf8")) : { terms: [] };
+  const file = path5.join(".gyojeong", "standards");
+  return existsSync5(file) ? parseStandards(readFileSync4(file, "utf8")) : { terms: [] };
 };
 var processAlive2 = (pid) => {
   try {
@@ -6485,7 +7539,7 @@ var health = async (port, home) => {
 var runningServer = async (home) => {
   let info;
   try {
-    info = JSON.parse(readFileSync3(serverInfoPath(home), "utf8"));
+    info = JSON.parse(readFileSync4(serverInfoPath(home), "utf8"));
   } catch {
     return null;
   }
@@ -6493,7 +7547,7 @@ var runningServer = async (home) => {
   return await health(info.port, home) ? info : null;
 };
 var spawnServer = async (home) => {
-  const log = openSync(path3.join(home, "server.log"), "a", 384);
+  const log = openSync(path5.join(home, "server.log"), "a", 384);
   const child = spawn(process.execPath, [SERVER_SCRIPT], {
     detached: true,
     stdio: ["ignore", log, log],
@@ -6507,13 +7561,13 @@ var spawnServer = async (home) => {
     if (info) return { port: info.port, started: true };
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  throw new Error(`review server did not start; see ${path3.join(home, "server.log")}`);
+  throw new Error(`review server did not start; see ${path5.join(home, "server.log")}`);
 };
 var ensureServer = async (home) => {
   const existing = await runningServer(home);
   if (existing) return { port: existing.port, started: false };
-  mkdirSync2(home, { recursive: true, mode: 448 });
-  const release = acquireLock(path3.join(home, "server.lock"));
+  mkdirSync3(home, { recursive: true, mode: 448 });
+  const release = acquireLock(path5.join(home, "server.lock"));
   try {
     const started = await runningServer(home);
     return started ? { port: started.port, started: false } : await spawnServer(home);
@@ -6532,9 +7586,9 @@ var reviewUrls = (port, id, content, { publicOrigin } = loadIdleConfig()) => {
   };
 };
 var attachmentInput = (file) => {
-  const mediaType = MEDIA_TYPES[path3.extname(file).toLowerCase()];
+  const mediaType = MEDIA_TYPES[path5.extname(file).toLowerCase()];
   if (!mediaType) throw new UsageError(`unsupported attachment type: ${file} (png, jpeg, webp)`);
-  return { filename: path3.basename(file), media_type: mediaType, content_base64: readFileSync3(file).toString("base64") };
+  return { filename: path5.basename(file), media_type: mediaType, content_base64: readFileSync4(file).toString("base64") };
 };
 var publish = async (home, options) => {
   requireOptions(options, "source", "draft");
@@ -6678,7 +7732,16 @@ var verifyFeedback = (home, options) => {
 var processed = (home, options) => {
   requireOptions(options, "review", "ids");
   const ids = options.ids.split(",").map((id) => id.trim()).filter(Boolean);
-  return { review_id: options.review, ...markProcessed(home, options.review, ids) };
+  const run = readRun(home, options.review);
+  const selected = run.feedback.filter((item) => ids.includes(item.id));
+  const unknown2 = ids.filter((id) => !selected.some((item) => item.id === id));
+  if (unknown2.length) throw new UsageError(`unknown feedback ids: ${unknown2.join(",")}`);
+  const durable = ruleCurationPreview(options.review, selected);
+  return {
+    review_id: options.review,
+    ...markProcessed(home, options.review, ids),
+    rules: { pending_curation: durable.length }
+  };
 };
 var url2 = async (home, options) => {
   requireOptions(options, "review");
@@ -6695,7 +7758,55 @@ var discard = (home, options) => {
   discardRun(home, options.review);
   return { review_id: options.review, discarded: true };
 };
-var COMMANDS = { publish, revise, feedback, "verify-feedback": verifyFeedback, processed, url: url2, list, discard };
+var rules = async (home, options) => {
+  if (options.compact === "true" && (options.attach.length > 0 || Object.keys(options).some((key) => key !== "compact" && key !== "attach"))) {
+    throw new UsageError("compact rules cannot be combined with other options");
+  }
+  if (options.compact === "true") return readGistRules();
+  if (options.history) {
+    const history = await scanSessionHistory(options.history);
+    if (!options.export) return history;
+    const target = path5.resolve(options.export);
+    if (existsSync5(target)) throw new UsageError(`history export already exists: ${target}`);
+    const payload = {
+      schema_version: 1,
+      exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+      count: history.count,
+      truncated: history.truncated,
+      candidates: history.candidates
+    };
+    writeFileSync3(target, `${JSON.stringify(payload, null, 2)}
+`, { flag: "wx", mode: 384 });
+    chmodSync3(target, 384);
+    return { exported: target, count: history.count, truncated: history.truncated };
+  }
+  if (options["history-import"]) {
+    const payload = JSON.parse(readRaw(options["history-import"]));
+    if (payload?.schema_version !== 1 || !Array.isArray(payload?.candidates) || payload.candidates.length > 200 || payload.candidates.some((item) => typeof item?.text !== "string" || item.text.length > 500)) {
+      throw new UsageError("invalid history export");
+    }
+    return { count: payload.candidates.length, truncated: payload.truncated === true, candidates: payload.candidates };
+  }
+  const run = options.review ? readRun(home, options.review) : null;
+  const promoteIds = options.ids ? options.ids.split(",").map((id) => id.trim()).filter(Boolean) : [];
+  const candidateIds = options["candidate-ids"] ? options["candidate-ids"].split(",").map((id) => id.trim()).filter(Boolean) : [];
+  const sessionCorrections = options.session ? JSON.parse(readRaw(options.session)) : [];
+  const curations = options.curate ? JSON.parse(readRaw(options.curate)) : [];
+  const processedFeedback = run?.feedback.filter((item) => run.processed_feedback_ids.includes(item.id)) ?? [];
+  if (run && !options.curate) return { review_id: options.review, candidates: ruleCurationPreview(options.review, processedFeedback) };
+  const result = updateGistRules({
+    ...run ? { reviewId: options.review, feedback: processedFeedback } : {},
+    promoteIds,
+    candidateIds,
+    sessionCorrections: Array.isArray(sessionCorrections) ? sessionCorrections : [sessionCorrections],
+    curations: Array.isArray(curations) ? curations : [curations],
+    completeOnboarding: options["complete-onboarding"] === "true",
+    includeCandidates: options.candidates === "true",
+    distill: options.distill === "true"
+  });
+  return result;
+};
+var COMMANDS = { publish, revise, feedback, "verify-feedback": verifyFeedback, processed, url: url2, list, discard, rules };
 var main = async (argv = process.argv.slice(2)) => {
   const [command, ...rest] = argv;
   const run = COMMANDS[command];
@@ -6705,8 +7816,9 @@ var main = async (argv = process.argv.slice(2)) => {
     return 64;
   }
   try {
-    const result = await run(storeHome(), parseArgs(rest));
-    process.stdout.write(`${JSON.stringify(result, null, 2)}
+    const options = parseArgs(rest);
+    const result = await run(storeHome(), options);
+    process.stdout.write(`${JSON.stringify(result, null, command === "rules" && options.compact === "true" ? 0 : 2)}
 `);
     return 0;
   } catch (error2) {
@@ -6721,7 +7833,7 @@ var main = async (argv = process.argv.slice(2)) => {
     return 1;
   }
 };
-if (process.argv[1] && path3.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+if (process.argv[1] && path5.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   process.exitCode = await main();
 }
 export {