@kaydash9999/banker-plugins 0.17.0 → 0.18.0

package/skills/anti-drm/scripts/instruction-toggle.mjs

@@ -0,0 +1,527 @@
+/**
+ * instruction-toggle: puts one set of agent instructions where Claude Code and
+ * Codex load them at every session start, and takes it out again.
+ *
+ * banker's tone-compact and anti-drm share this module. Each skill folder holds
+ * a byte-identical copy, since Codex installs every skill folder on its own and
+ * one skill cannot import from another. tone-compact's copy is the source:
+ * `node scripts/sync-adapter.js` mirrors it, and the smoke test and anti-drm's
+ * tests compare the two.
+ *
+ * Claude Code loads every rules file under <config>/rules/ (<config> is
+ * $CLAUDE_CONFIG_DIR or ~/.claude) at session start and again after compaction.
+ * turnOn writes banker-<slug>.md there and turnOff deletes it. A file at that
+ * name that does not start with banker's mark belongs to someone else and is
+ * left alone.
+ *
+ * Codex reads $CODEX_HOME/AGENTS.override.md when it holds any non-whitespace
+ * text and $CODEX_HOME/AGENTS.md otherwise (CODEX_HOME defaults to ~/.codex).
+ * turnOn adds one marked block at the end of AGENTS.md, or of the override when
+ * the override has text of its own. No banker block counts as the override's
+ * own text: banker's blocks alone there would hide AGENTS.md. When other
+ * banker blocks alone fill the override, Codex reads only them; turnOn and the
+ * status line say so, and those skills' turnOn moves them out. turnOff takes
+ * the block out and gives back the bytes from before.
+ *
+ * The block sits inside OMX's USER:OMX:POLICY markers, the only part of a
+ * generated AGENTS.md that `omx setup --merge-agents` carries over; a plain
+ * `omx setup` with team mode on only refreshes the model table. `omx setup
+ * --force`, confirming its overwrite prompt, or a plain `omx setup` with team
+ * mode off replaces the file block and all; turnOn then has to run again. Text
+ * other tools keep in these files is left alone, and the bytes from before each
+ * change are kept in <file>.<slug>.bak. Markers count only as whole lines that
+ * open and close in turn; a marker quoted inside a sentence, or an end before a
+ * start, makes turnOn and turnOff refuse rather than guess where the block ends.
+ * So does a file that is not UTF-8 (CP949, UTF-16): written back as text it
+ * would lose its bytes.
+ *
+ * Results are { ok, message }; ok false means refused with nothing changed.
+ * Anything else that goes wrong throws.
+ */
+import {
+  accessSync,
+  constants,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+/** The banker skills that keep a block in Codex's instructions files. */
+export const BANKER_SLUGS = ["tone-compact", "anti-drm"];
+export const RUNTIMES = ["claude", "codex"];
+// OMX keeps only these regions when `omx setup` rewrites a generated AGENTS.md.
+export const KEEP_OPEN = "<!-- USER:OMX:POLICY:START -->";
+export const KEEP_CLOSE = "<!-- USER:OMX:POLICY:END -->";
+
+// The byte order mark an editor may put in front of a file.
+const BOM = String.fromCharCode(0xfeff);
+const noBom = (text) => (text.startsWith(BOM) ? text.slice(BOM.length) : text);
+const lf = (text) => text.replace(/\r\n/g, "\n");
+const eolOf = (text) => (text.includes("\r\n") ? "\r\n" : "\n");
+const isDir = (path) => {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+const isLink = (path) => {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+};
+
+const UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+
+// A file's bytes and text, null when there is no such file. text is null when
+// the bytes are not UTF-8, which callers refuse: decoding them would replace
+// them with U+FFFD for good. Any other read failure (permissions, a folder at
+// that name) is not "missing" and propagates.
+function readFile(path) {
+  let bytes;
+  try {
+    bytes = readFileSync(path);
+  } catch (e) {
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") return null;
+    throw e;
+  }
+  try {
+    return { bytes, text: UTF8.decode(bytes) };
+  } catch {
+    return { bytes, text: null };
+  }
+}
+
+const done = (message) => ({ ok: true, message });
+const refuse = (message) => ({ ok: false, message });
+
+/** A skill's marks: the first line of its rules file, and the lines around its Codex block. */
+export function markersOf(slug) {
+  return { ownerMark: `<!-- banker ${slug}`, open: `<!-- banker:${slug}:start -->`, close: `<!-- banker:${slug}:end -->` };
+}
+
+/**
+ * What one skill's toggle needs: its slug and marks, the first line of its
+ * rules file, and two texts it words its own way: the status of rules that
+ * differ from the ones given (staleText), and what turnOn says when it replaced
+ * them (updatedText).
+ */
+export function toggleSpec({ slug, staleText, updatedText }) {
+  const marks = markersOf(slug);
+  const header = `${marks.ownerMark}: banker 가 관리하는 파일입니다. 끄려면 ${slug} 에 off 를 실행하세요. -->`;
+  return { slug, ...marks, header, staleText, updatedText };
+}
+
+/**
+ * Replaces file through a fresh temp file ("wx") and a rename: a link planted
+ * at either name is replaced rather than written through, and a write that
+ * fails leaves the old file as it was.
+ */
+export function writeFresh(file, data, mode = 0o644) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  rmSync(tmp, { force: true });
+  try {
+    writeFileSync(tmp, data, { flag: "wx", mode });
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+/** Whether an error is about permissions or a read-only file system. */
+export const denied = (e) => e.code === "EACCES" || e.code === "EPERM" || e.code === "EROFS";
+
+/**
+ * A path or an error text as a message shows it. Control, format, line and
+ * paragraph separator, private-use, unassigned and variation selector
+ * characters become "?": a path from the environment cannot start a line of
+ * its own, reorder the text around it, or hide text after a visible letter.
+ */
+export const where = (value) =>
+  String(value).replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Co}\p{Cn}\p{Variation_Selector}]/gu, "?");
+
+// ---- Claude Code: one rules file that is banker's alone ----
+
+const claudeFile = (t, o) => join(o.claudeDir, "rules", `banker-${t.slug}.md`);
+const claudeText = (t, rules) => `${t.header}\n${rules}\n`;
+
+// "off", "foreign" (not banker's file), or, when rules are given, "on" or
+// "stale" (other rules); without rules a banker file is "ours".
+function claudeState(t, file, rules) {
+  if (file === null) return "off";
+  if (file.text === null) return "foreign";
+  const body = lf(noBom(file.text));
+  if (!body.startsWith(t.ownerMark)) return "foreign";
+  if (rules === undefined) return "ours";
+  return body === claudeText(t, rules) ? "on" : "stale";
+}
+
+function claudeOn(t, o, getRules) {
+  const file = claudeFile(t, o);
+  const shown = where(file);
+  if (!isDir(o.claudeDir)) return refuse(`Claude Code 설정 폴더가 없습니다: ${where(o.claudeDir)}`);
+  const rules = getRules();
+  const state = claudeState(t, readFile(file), rules);
+  if (state === "foreign") return refuse(`같은 이름의 다른 파일이 있어 그대로 두었습니다: ${shown}`);
+  if (state === "on") return done(`Claude Code: 이미 켜져 있습니다 (변경 없음). ${shown}`);
+  try {
+    mkdirSync(dirname(file), { recursive: true, mode: 0o755 });
+    writeFresh(file, claudeText(t, rules));
+  } catch (e) {
+    if (denied(e)) return refuse(`쓸 권한이 없어 켜지 못했습니다 (${e.code}): ${shown}`);
+    throw e;
+  }
+  return done(
+    state === "stale"
+      ? `Claude Code: ${t.updatedText}. ${shown}`
+      : `Claude Code: 켰습니다. 다음 세션부터 자동 적용됩니다. ${shown}`,
+  );
+}
+
+function claudeOff(t, o) {
+  const file = claudeFile(t, o);
+  const state = claudeState(t, readFile(file));
+  if (state === "off") return done("Claude Code: 이미 꺼져 있습니다 (변경 없음).");
+  if (state === "foreign") return refuse(`같은 이름의 다른 파일이 있어 그대로 두었습니다: ${where(file)}`);
+  try {
+    rmSync(file);
+  } catch (e) {
+    if (denied(e)) return refuse(`지울 권한이 없어 끄지 못했습니다 (${e.code}): ${where(file)}`);
+    throw e;
+  }
+  return done(`Claude Code: 껐습니다. 다음 세션부터 적용되지 않습니다. ${where(file)}`);
+}
+
+// ---- Codex: one block in the global instructions file Codex reads ----
+
+const lineBare = (line) => line.replace(/\r?\n$/, "");
+// A line without its line break, and the first one without the byte order mark
+// an editor may put in front of it.
+const bareAt = (lines, i) => (i === 0 ? noBom(lineBare(lines[i])) : lineBare(lines[i]));
+
+// One block's place in the text: [from, to) runs from its first line (the keep
+// marker when one wraps it directly) through the end of its last line; cut is
+// from minus the line break `on` puts before the block, and blankBefore says
+// whether that break makes a blank line of its own.
+function spanOf(lines, offsets, first, last) {
+  const wrapped =
+    first > 0 &&
+    last + 1 < lines.length &&
+    bareAt(lines, first - 1) === KEEP_OPEN &&
+    bareAt(lines, last + 1) === KEEP_CLOSE;
+  const top = wrapped ? first - 1 : first;
+  const bottom = wrapped ? last + 1 : last;
+  const before = top > 0 ? lines[top - 1] : "";
+  const joint = before.endsWith("\r\n") ? 2 : before.endsWith("\n") ? 1 : 0;
+  const blankBefore = before !== "" && lineBare(before) === "";
+  return { cut: offsets[top] - joint, from: offsets[top], to: offsets[bottom] + lines[bottom].length, blankBefore };
+}
+
+// Where each line starts in the text.
+function lineOffsets(lines) {
+  const offsets = [];
+  let at = 0;
+  for (const line of lines) {
+    offsets.push(at);
+    at += line.length;
+  }
+  return offsets;
+}
+
+// Any management marker, a banker block's or OMX's, anywhere on a line.
+const ANY_MARKER = /<!-- (?:banker:[a-z0-9-]+:(?:start|end)|USER:OMX:POLICY:(?:START|END)) -->/;
+
+/**
+ * Whether text quotes any management marker. Rules must not: a block holding
+ * one would be refused as soon as it is written, and could never come out.
+ */
+export const hasMarker = (text) => ANY_MARKER.test(text);
+// Whether a marker sits between a block's first and last line: then its end was
+// moved, by hand or by an editor, and cutting to it would take other text along.
+const markerInside = (lines, first, last) => lines.slice(first + 1, last).some((line) => ANY_MARKER.test(line));
+
+/**
+ * Where the blocks between whole lines `open` and `close` sit in text, or null
+ * when those markers are not whole lines that open and close in turn, or when
+ * another management marker sits inside a block. turnOn and turnOff refuse
+ * null, so a marker quoted inside a sentence, or an end put back by hand around
+ * other text, can never make them cut the user's own text.
+ */
+export function blockSpansOf(text, open, close) {
+  const lines = text.split(/(?<=\n)/);
+  const offsets = lineOffsets(lines);
+  const spans = [];
+  let first = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const bare = bareAt(lines, i);
+    if (bare === open && first === -1) first = i;
+    else if (bare === close && first !== -1) {
+      if (markerInside(lines, first, i)) return null;
+      spans.push(spanOf(lines, offsets, first, i));
+      first = -1;
+    } else if (lines[i].includes(open) || lines[i].includes(close)) return null;
+  }
+  return first === -1 ? spans : null;
+}
+
+// A block, banker's or any USER:OMX:POLICY one, right after a line break.
+const BLOCK_NEXT = /^\r?\n(?:<!-- USER:OMX:POLICY:START -->|<!-- banker:)/;
+
+// The text without its blocks: exactly what it was before `on` added them. The
+// line break `on` put in front goes with the block when the block ends the file
+// or has a blank line of its own in front; with other text after it, the break
+// stays, so the lines on either side never run together. When another block
+// follows, its own leading break keeps the lines apart, so this one goes too:
+// two blocks taken out in the order they went in then leave a text that had no
+// final line break as it was.
+function strip(text, spans) {
+  let out = "";
+  let at = 0;
+  for (const s of spans) {
+    const keepBreak = s.to < text.length && !s.blankBefore && !BLOCK_NEXT.test(text.slice(s.to));
+    out += text.slice(at, keepBreak ? s.from : s.cut);
+    at = s.to;
+  }
+  return out + text.slice(at);
+}
+
+// Whether text holds anything but whitespace, the way Codex judges a file empty:
+// Rust's trim, which strips the Unicode White_Space set and, unlike
+// JavaScript's trim, keeps a byte order mark.
+const hasContent = (text) => /\P{White_Space}/u.test(text);
+
+// The text without any banker skill's blocks. A skill whose markers do not pair
+// up keeps its text, which then counts as content: nothing is cut on a guess.
+function withoutBankerBlocks(text) {
+  return BANKER_SLUGS.reduce((out, slug) => {
+    const { open, close } = markersOf(slug);
+    const spans = blockSpansOf(out, open, close);
+    return spans === null ? out : strip(out, spans);
+  }, text);
+}
+
+// The banker skills other than t with a block in text.
+const otherBlocks = (t, text) =>
+  BANKER_SLUGS.filter((slug) => {
+    if (slug === t.slug) return false;
+    const { open, close } = markersOf(slug);
+    const spans = blockSpansOf(text, open, close);
+    return spans !== null && spans.length > 0;
+  });
+
+const binary = (f) => f.bytes !== null && f.text === null;
+const unpaired = (f) => f.spans === null;
+const hasBlock = (f) => f.spans !== null && f.spans.length > 0;
+const stripped = (f) => (f.text === null ? "" : strip(f.text, f.spans));
+
+// Both global instruction files with their bytes and text (null when absent;
+// text null when not UTF-8) and blocks (null when the markers do not pair up).
+// The block's place (target) is the override when the override has text of its
+// own, AGENTS.md otherwise. shadowers names the other banker skills whose
+// blocks alone fill the override: Codex then reads the override, not AGENTS.md.
+function codexFiles(t, o) {
+  const read = (name) => {
+    const path = join(o.codexDir, name);
+    const file = readFile(path);
+    if (file === null) return { path, bytes: null, text: null, spans: [] };
+    return { path, ...file, spans: file.text === null ? null : blockSpansOf(file.text, t.open, t.close) };
+  };
+  const override = read("AGENTS.override.md");
+  const main = read("AGENTS.md");
+  const ownContent = binary(override) || (override.text !== null && hasContent(withoutBankerBlocks(override.text)));
+  const target = ownContent ? override : main;
+  const shadowers = ownContent || override.text === null ? [] : otherBlocks(t, override.text);
+  return { target, other: target === override ? main : override, all: [override, main], shadowers };
+}
+
+const blockFor = (t, rules, eol) => [KEEP_OPEN, t.open, ...rules.split("\n"), t.close, KEEP_CLOSE, ""].join(eol);
+// A block's text compared without line-break style, a leading byte order mark
+// or the final line break, which editors add and drop.
+const normBlock = (text) => noBom(lf(text)).replace(/\n$/, "");
+// The block exactly as `on` writes it, and only once.
+const blockCurrent = (t, f, rules) =>
+  f.spans.length === 1 && normBlock(f.text.slice(f.spans[0].from, f.spans[0].to)) === normBlock(blockFor(t, rules, "\n"));
+
+// The text with the block at the end, one line break between them; an empty
+// file gets the block alone. strip() undoes exactly this.
+function withBlock(t, text, rules) {
+  const eol = eolOf(text);
+  return text === "" ? blockFor(t, rules, eol) : text + eol + blockFor(t, rules, eol);
+}
+
+// "off", "on", "stale", "misplaced" (only in AGENTS.md while Codex reads the
+// override, so not applied), "hidden" (in the override with no text of its own,
+// applied but hiding AGENTS.md), "unpaired" or "notutf8". Without rules any
+// block in its place counts as "on".
+function codexState(t, files, rules) {
+  if (files.all.some(binary)) return "notutf8";
+  if (files.all.some(unpaired)) return "unpaired";
+  const inTarget = hasBlock(files.target);
+  const inOther = hasBlock(files.other);
+  if (!inTarget) return inOther ? (files.other === files.all[0] ? "hidden" : "misplaced") : "off";
+  if (rules === undefined) return "on";
+  return blockCurrent(t, files.target, rules) && !inOther ? "on" : "stale";
+}
+
+// Why these files cannot be written, or "" when they can. The folder counts
+// too: the .bak is written through a temp file beside the file.
+function writeBlocked(changes) {
+  for (const { file } of changes) {
+    for (const path of file.bytes === null ? [dirname(file.path)] : [file.path, dirname(file.path)]) {
+      try {
+        accessSync(path, constants.W_OK);
+      } catch (e) {
+        return `쓸 권한이 없어 그대로 두었습니다 (${where(e.code || e.message)}): ${where(path)}`;
+      }
+    }
+  }
+  return "";
+}
+
+// Writes each file in place, so a symlinked AGENTS.md stays a link and its
+// target changes, after keeping the old bytes in a .bak only this account can
+// read (the file may be a link into a private folder). A new file gets 0644
+// whatever the umask allows more. A file left empty is removed, unless it is a
+// link: Codex skips an empty file anyway.
+function apply(t, changes) {
+  for (const { file, after } of changes) {
+    if (file.bytes !== null) writeFresh(`${file.path}.${t.slug}.bak`, file.bytes, 0o600);
+    if (after === "" && !isLink(file.path)) rmSync(file.path, { force: true });
+    else writeFileSync(file.path, after, { mode: 0o644 });
+  }
+}
+
+const OMX_NOTE =
+  "참고: omx setup 이 AGENTS.md 를 새로 만들면(--force, 덮어쓰기 확인, team 모드를 끈 상태의 omx setup) 이 블록이 사라집니다. 그 뒤에는 on 을 다시 실행하세요. --merge-agents 와 기본 omx setup 은 블록을 남깁니다.";
+
+// The note for a block other banker blocks keep from being read.
+const shadowNote = (files) =>
+  files.shadowers.length === 0
+    ? ""
+    : `\n주의: AGENTS.override.md 에 다른 banker 블록(${files.shadowers.join(", ")})만 있어 Codex 가 AGENTS.md 를 읽지 않습니다. 그 스킬에서 on 을 실행해 블록을 옮기세요.`;
+
+// The refusal for files on and off must not touch, or null.
+function codexRefusal(t, files, state) {
+  if (state === "notutf8") return refuse(`UTF-8 이 아닌 파일이라 그대로 두었습니다: ${where(files.all.find(binary).path)}`);
+  if (state === "unpaired") return refuse(`${t.slug} 표시의 짝이 맞지 않아 그대로 두었습니다: ${where(files.all.find(unpaired).path)}`);
+  return null;
+}
+
+function codexOn(t, o, getRules) {
+  if (!isDir(o.codexDir)) return refuse(`Codex 설정 폴더가 없습니다: ${where(o.codexDir)}`);
+  const rules = getRules();
+  const files = codexFiles(t, o);
+  const state = codexState(t, files, rules);
+  const refusal = codexRefusal(t, files, state);
+  if (refusal) return refusal;
+  const tail = `${where(files.target.path)}${shadowNote(files)}`;
+  if (state === "on") return done(`Codex: 이미 켜져 있습니다 (변경 없음). ${tail}`);
+  const changes = [{ file: files.target, after: withBlock(t, stripped(files.target), rules) }];
+  if (hasBlock(files.other)) changes.push({ file: files.other, after: stripped(files.other) });
+  const why = writeBlocked(changes);
+  if (why) return refuse(why);
+  apply(t, changes);
+  const moved = "블록을 맞는 파일로 옮겼습니다";
+  const what = { stale: t.updatedText, misplaced: moved, hidden: moved }[state];
+  const note = files.target === files.all[1] ? `\n${OMX_NOTE}` : "";
+  return done(`Codex: ${what ?? "켰습니다. 다음 세션부터 자동 적용됩니다"}. ${tail}${note}`);
+}
+
+function codexOff(t, o) {
+  if (!isDir(o.codexDir)) return done(`Codex: 설정 폴더가 없어 끌 것이 없습니다 (변경 없음). ${where(o.codexDir)}`);
+  const files = codexFiles(t, o);
+  const refusal = codexRefusal(t, files, codexState(t, files));
+  if (refusal) return refusal;
+  const changes = files.all.filter(hasBlock).map((f) => ({ file: f, after: stripped(f) }));
+  if (changes.length === 0) return done("Codex: 이미 꺼져 있습니다 (변경 없음).");
+  const why = writeBlocked(changes);
+  if (why) return refuse(why);
+  apply(t, changes);
+  return done(`Codex: 껐습니다. 다음 세션부터 적용되지 않습니다. ${changes.map((c) => where(c.file.path)).join(", ")}`);
+}
+
+// ---- status ----
+
+const STATE_TEXT = {
+  on: "켜짐",
+  ours: "켜짐 (규칙 버전 확인 불가)",
+  off: "꺼짐",
+  foreign: "꺼짐, 같은 이름의 다른 파일이 있음 (손대지 않음)",
+  misplaced: "꺼짐, 단 블록이 Codex 가 읽지 않는 AGENTS.md 에 있음 (on 으로 옮김)",
+  hidden: "켜짐, 단 AGENTS.override.md 에 블록만 있어 AGENTS.md 가 가려짐 (on 으로 옮김)",
+  notutf8: "UTF-8 이 아닌 지침 파일이 있어 손대지 않음 (on, off 모두 거부)",
+  unpaired: "표시의 짝이 맞지 않음 (on, off 모두 거부. 남은 표시 줄 정리 필요)",
+};
+
+// A state as the status line says it.
+function stateText(t, { state, who }) {
+  if (state === "stale") return t.staleText;
+  if (state === "shadowed") {
+    return `꺼짐, 단 AGENTS.override.md 에 다른 banker 블록(${who.join(", ")})만 있어 Codex 가 AGENTS.md 를 읽지 않음 (그 스킬에서 on 으로 옮김)`;
+  }
+  return STATE_TEXT[state] ?? state;
+}
+
+// One status line. Read failures are reported, not thrown: status is where an
+// exit 2 sends the user to look.
+function describe(t, name, look) {
+  try {
+    const found = look();
+    return `- ${name}: ${stateText(t, found)} (${where(found.path)})`;
+  } catch (e) {
+    return `- ${name}: 읽을 수 없음 (${where(e.code || e.message)})`;
+  }
+}
+
+function codexLook(t, o, rules) {
+  if (!isDir(o.codexDir)) return { state: "설정 폴더 없음", path: o.codexDir };
+  const files = codexFiles(t, o);
+  const state = codexState(t, files, rules);
+  const shadowed = files.shadowers.length > 0 && (state === "on" || state === "stale");
+  return { state: shadowed ? "shadowed" : state, path: files.target.path, who: files.shadowers };
+}
+
+/** One status line per runtime: "- Claude Code: ..." and "- Codex: ...". rules may be undefined. */
+export function stateLines(t, o, rules) {
+  return [
+    describe(t, "Claude Code", () => {
+      if (!isDir(o.claudeDir)) return { state: "설정 폴더 없음", path: o.claudeDir };
+      return { state: claudeState(t, readFile(claudeFile(t, o)), rules), path: claudeFile(t, o) };
+    }),
+    describe(t, "Codex", () => codexLook(t, o, rules)),
+  ];
+}
+
+/**
+ * Whether a runtime holds the skill's rules in some form (current, older, in
+ * the wrong file or with broken markers), so that changed rules should reach
+ * it. Throws when a file cannot be read.
+ */
+export function present(t, runtime, o) {
+  if (runtime === "claude") return isDir(o.claudeDir) && claudeState(t, readFile(claudeFile(t, o))) === "ours";
+  return isDir(o.codexDir) && !["off", "notutf8"].includes(codexState(t, codexFiles(t, o)));
+}
+
+const knownRuntime = (runtime) => {
+  if (!RUNTIMES.includes(runtime)) throw new Error(`알 수 없는 런타임입니다: ${runtime}`);
+};
+
+/** Puts the rules where one runtime loads them. getRules runs after the config folder check. */
+export function turnOn(t, runtime, o, getRules) {
+  knownRuntime(runtime);
+  return runtime === "claude" ? claudeOn(t, o, getRules) : codexOn(t, o, getRules);
+}
+
+/** Takes the rules out for one runtime; it never needs them. */
+export function turnOff(t, runtime, o) {
+  knownRuntime(runtime);
+  return runtime === "claude" ? claudeOff(t, o) : codexOff(t, o);
+}

package/skills/lineage/SKILL.md

@@ -2,7 +2,7 @@
 name: lineage
 description: "현재 세션 대화를 카카오톡 스타일의 단일 HTML 로 내보냄. Claude 답변은 한 줄 요약 아래에 원문을 접어 두고, 펼치면 마크다운으로 렌더해 보여 줌. 기본은 세션 모델이 요약을 쓰고 노이즈 턴을 걸러 내며, `--rulebase` 는 모델 없이 규칙만 씀. 여러 세션을 합칠 수 있음. 'lineage'/'대화 export'/'카톡 스타일 html' 시 사용."
 invocation: /lineage
-version: 3.0.2
+version: 3.0.3
 schema_version: 1
 ---
 
@@ -212,7 +212,7 @@ Schema-tolerant 파서: 미지 record type → stderr WARN + 다음 line. `v1`/`
 
 기본 흐름에서는 검토자 요약이 우선이고, 검토자가 `null` 로 둔 턴만 아래 규칙 요약을 쓴다. `--rulebase` 는 규칙 요약만 쓴다.
 
-- 캐시 hit(`~/.cache/lineage/<schema>/<sid>/<uuid>-<digest>.txt`) → 그대로. digest 는 본문+요약기버전
+- 캐시 hit(`~/.cache/lineage/<schema>/<sid>/<uuid>-<digest>.md`, 3.0.2 까지 쓴 `.txt` 도 읽음) → 그대로. digest 는 본문+요약기버전
   해시라 **요약기를 고치면 자동 무효화**된다.
 - miss → head+tail 추출(도입이 순수 의도문이면 결론절을 끝에서 읽어 승격) + 0600 캐시 쓰기.
 - 요약 저장은 항상 **redact 적용 후**(평문 secret 이 디스크에 남지 않음).
@@ -344,7 +344,7 @@ pip install 'detect-secrets>=1.5'   # (선택) 강한 redaction
 
 ~/.cache/lineage/
 ├── stdin-id.key   (stdin 턴 id 의 HMAC 키, 0600. --purge-cache 로 지우면 stdin id 가 바뀐다)
-└── <schema_version>/<session_id>/<turn_uuid>-<digest>.txt       (규칙 요약, 0700/0600)
+└── <schema_version>/<session_id>/<turn_uuid>-<digest>.md        (규칙 요약, 0700/0600)
                                   <turn_uuid>-<digest>-llm.json  (검토자 결정)
 
 work/.lineage-review.json, .lineage-review.part-K.json   (검토 중에만, 0600)

package/skills/lineage/lineage.py

@@ -189,7 +189,7 @@ def redact(text: str, extra: "str | None" = None, mode: str = "full"):
         from detect_secrets import SecretsCollection
         from detect_secrets.settings import default_settings
         import tempfile
-        with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False,
+        with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False,
                                          encoding="utf-8") as tf:
             tf.write(out)
             tmp = tf.name
@@ -734,6 +734,17 @@ def _page_clean_turn(t, extra, mode):
     return dict(t, text=clean(t["text"]), parts=[clean(p) for p in t.get("parts") or []])
 
 
+def _read_cached(p):
+    """The summary cached at p, else at the same name with .txt, which 3.0.2 and earlier wrote.
+    None when neither can be read: missing, or bytes that are not UTF-8 (a DRM encrypted them)."""
+    for cached in (p, p.with_name(p.stem + ".txt")):
+        try:
+            return cached.read_text(encoding="utf-8").strip()
+        except (OSError, UnicodeDecodeError):
+            continue
+    return None
+
+
 def read_or_summarize(turn: dict, session_id: str, rebuild: bool = False,
                       redact_extra=None, redact_mode: str = "full"):
     """Return (summary, cache_hit). Cache key includes the content hash AND the
@@ -745,15 +756,13 @@ def read_or_summarize(turn: dict, session_id: str, rebuild: bool = False,
     ).hexdigest()[:8]
     try:                                          # ids come from the transcript: keep them in the cache
         p = (cache_dir(_safe_name(turn.get("session") or session_id))
-             / f"{_safe_name(turn['uuid'])}-{digest}.txt")
+             / f"{_safe_name(turn['uuid'])}-{digest}.md")
     except OSError as e:                          # no writable cache: summarize anyway
         _warn_once("_no_cache", f"cache unavailable ({e}); summaries are not cached")
         p = None
-    if p is not None and p.exists() and not rebuild:
-        try:
-            return p.read_text(encoding="utf-8").strip(), True
-        except (OSError, UnicodeDecodeError):
-            pass
+    cached = None if p is None or rebuild else _read_cached(p)
+    if cached is not None:
+        return cached, True
     redacted = summarize_turn(_page_clean_turn(turn, redact_extra, redact_mode))
     if p is not None:
         try:

package/skills/omc-patch/SKILL.md

@@ -22,6 +22,7 @@ OMC(oh-my-claudecode)가 새 버전으로 자동 업데이트되면 로컬 훅
 - 그러면 다른 블록의 import 가 ReferenceError 로 실패하고, 훅의 `catch` 가 그 오류를 삼킨다. 예: `project-memory-session` 은 종료 코드 0 으로 끝나지만 project-memory 를 만들지 않는다.
 - banker 0.16.x 의 도구는 새로 패치할 때 맨 앞에 넣었지만, 옛 킷이 남긴 이 결함은 진단하지 못하고 `결과: 모두 적용된 상태입니다.` 를 냈다.
 - 지금 도구의 `--check` 는 이 결함을 `헬퍼 자리 결함` 으로 알린다. 이미 감싼 파일이라 다시 적용만으로는 고쳐지지 않는다. 활성 폴더를 되돌린 뒤 다시 적용한다.
+- 헬퍼 선언을 찾지 못하거나 선언이 첫 사용보다 뒤에 있는 파일도 같은 결함으로 센다. 뒤에 있으면 첫 사용이 먼저 돌아 ReferenceError 가 난다.
 
 ## 인자
 
@@ -35,8 +36,10 @@ OMC(oh-my-claudecode)가 새 버전으로 자동 업데이트되면 로컬 훅
 
 - 이 작업은 사용자 설정 폴더(`~/.claude`)의 플러그인 캐시를 고치는 설정 변경이다. 서브에이전트에 맡기지 않고 메인 세션에서 직접 실행하고 직접 검증한다.
 - 적용은 `--no-update` 로만 실행한다. 인자 없는 apply 는 쓰지 않는다. 활성 OMC 를 도구의 `TARGET_VERSION`(5.7.0)으로 바꾸고, `revert` 로도 버전이 돌아오지 않는다.
-- 도구가 출력하는 `인자 없이 다시 실행하십시오.` 문구는 따르지 않는다. 이 스킬에서는 적용과 진단에 항상 `--no-update` 를 붙인다.
-- 헬퍼 자리 결함과 함께 나오는 `--revert 로 되돌린 뒤 다시 적용하십시오.` 도 그대로 따르지 않는다. 인자 없는 `--revert` 는 설치된 모든 버전을 되돌리고 고정까지 푼다. 이 스킬은 활성 폴더만 `--revert --root` 로 되돌린다(3단계 1).
+- 진단도 늘 `--no-update` 와 함께 한다. 그것 없이 진단하면 도구가 `인자 없이 다시 실행하십시오.` 라고 안내하는데, 인자 없는 apply 를 뜻하므로 따르지 않는다.
+- 인자 없는 `--revert` 는 설치된 모든 버전을 되돌리고 고정까지 푼다. 헬퍼 자리 결함에는 도구가 안내하는 대로 활성 폴더만 `--revert --root` 로 되돌린다(3단계 1).
+- `--root` 는 폴더의 이름표가 OMC 가 아니면 `OMC 플러그인 폴더가 아님` 으로 멈춘다. `.claude-plugin/plugin.json` 의 name 이 있으면 그것으로, 없으면 `package.json` 의 name 으로 정한다. 다른 폴더를 잘못 준 실수를 막는 확인이고, 이름표가 없는 폴더는 통과한다.
+- 쓸 파일이 링크로 플러그인 폴더 밖을 가리키거나 백업 자리(`.omcbak`)가 링크면 도구는 쓰지 않고 실패로 센다. 문구는 적용 때 `쓰지 않음`, 되돌리기 때 `되돌리지 않음`, hooks.json 은 `hooks.json 을 건드리지 않음` 이다.
 - 패치 규칙은 OMC 훅 코드의 모양에 맞춰져 있다. 처음 보는 OMC 버전이면 반드시 `check` 를 먼저 실행한다.
 - `실패 N건` 이 1건 이상이면 멈추고 출력을 그대로 보고한다. 문법 오류가 난 파일은 도구가 원본으로 자동 롤백한다.
 - 판정은 출력 문구로 한다. 종료 코드 0 만으로 완료라고 보고하지 않는다.
@@ -102,7 +105,8 @@ node "<이 스킬 디렉터리 절대경로>/scripts/omc-patch.mjs" --check --no
    ```
 
    - `되돌림  <훅 이름>` 줄과 `되돌리기 완료.` 를 확인한다. 끝의 `재시작해야 반영됩니다` 는 이 중간 단계에서는 무시한다. 2 에서 바로 다시 패치한다.
-   - 결함이 있던 훅 이름이 `되돌림` 줄에 없으면 그 파일에 `.omcbak` 백업이 없는 것이다. 이 도구로는 되돌릴 원본이 없으니 멈추고 보고한다. 원본은 같은 버전의 OMC 저장소에서 다시 받아야 한다. 파이프 대신 파일을 거친다(Windows PowerShell 5.1 의 파이프는 바이너리를 텍스트로 바꿔 파일을 깨뜨린다): `git -C "<마켓플레이스 폴더>" archive -o "<임시 tar>" v<버전> scripts/<이름>.mjs` 뒤 `tar -xf "<임시 tar>" -C "<활성 폴더>"`. 이 명령은 사용자 승인 뒤에만 실행한다.
+   - `되돌리기를 끝내지 못했습니다.` 가 나오면 멈추고 위의 `[!]` 줄을 그대로 보고한다. 종료 코드는 1 이다. 끝 줄의 `실패 N건` 은 쓰기를 거부한 파일, `되돌리지 못한 것 N건` 은 백업이 없거나 수동 백업 후보를 쓸 수 없어 남은 파일이다. 끝 줄은 링크로 같은 폴더를 가리키는 판이 여럿이어도 파일마다 한 번 센다.
+   - `[!]` 줄에 `패치는 있는데 백업이 없어 되돌리지 못했습니다 — <이름>` 이 있으면 그 파일에 `.omcbak` 백업이 없는 것이다. 이 도구로는 되돌릴 원본이 없으니 멈추고 보고한다. 원본은 같은 버전의 OMC 저장소에서 다시 받아야 한다. 파이프 대신 파일을 거친다(Windows PowerShell 5.1 의 파이프는 바이너리를 텍스트로 바꿔 파일을 깨뜨린다): `git -C "<마켓플레이스 폴더>" archive -o "<임시 tar>" v<버전> scripts/<이름>.mjs` 뒤 `tar -xf "<임시 tar>" -C "<활성 폴더>"`. 이 명령은 사용자 승인 뒤에만 실행한다.
 
 2. 적용한다.
 
@@ -204,6 +208,7 @@ node "<이 스킬 디렉터리 절대경로>/scripts/omc-patch.mjs" --revert
 
 - `.omcbak` 백업으로 설치된 모든 버전의 훅 스크립트와 `hooks.json` 을 되돌리고 마켓플레이스 `origin` 을 원래 URL 로 복구한다.
 - 되돌린 뒤 Claude Code 를 다시 시작해야 반영된다.
+- `되돌리기를 끝내지 못했습니다.` 가 나오면 위의 `[!]` 줄을 그대로 보고한다. 종료 코드는 1 이다. 백업이 없어 남은 파일과 hooks.json 도 이 끝 줄로 끝난다.
 - `이 도구가 만들지 않은 수정이 남아 있습니다` 가 나오면 백업이 없는 손 수정이다. 출력에 적힌 복구 명령을 그대로 보고하고, 사용자 승인 없이 실행하지 않는다.
 
 ## 함정
@@ -213,6 +218,9 @@ node "<이 스킬 디렉터리 절대경로>/scripts/omc-patch.mjs" --revert
 - 헬퍼 자리 결함이 남은 채 `revert` 없이 적용을 다시 돌려도 바뀌는 것이 없다. 이미 감싼 파일은 건너뛰기 때문이다.
 - `--root` 와 `--revert --root` 는 그 폴더만 다룬다. 고정 해제까지 하려면 인자 없는 `--revert` 를 쓴다.
 - 고정을 풀지 않고 OMC 를 올리려면 먼저 `revert` 한다. 그렇지 않으면 마켓플레이스 fetch 가 계속 실패한다.
-- 고정 기록(`PINNED`)은 `~/.claude/omc-local-patches/PINNED` 에 생긴다. 기록일 뿐이라 지워도 고정은 풀리지 않고, 이미 고정된 상태에서는 다시 만들어지지 않는다. `revert` 는 origin 값에서 원래 URL 을 되찾는다.
+- 고정 기록(`PINNED`)은 `~/.claude/omc-local-patches/PINNED` 에 생긴다. 기록일 뿐이라 지워도 고정은 풀리지 않고, 이미 고정된 상태에서는 다시 만들어지지 않는다. `revert` 는 origin 값에서만 원래 URL 을 되찾고, `PINNED` 의 값으로 origin 을 쓰지 않는다. 다른 기기의 기록이면 알리기만 한다.
+- `--check` 와 `--revert` 를 함께 주면 도구는 아무것도 하지 않고 종료 코드 1 로 멈춘다. 진단만 하려면 `--check` 만 준다.
+- 도구는 git 을 부를 때 저장소를 고르는 변수(`GIT_DIR`, `GIT_WORK_TREE` 등 `git rev-parse --local-env-vars` 목록)를 지운다. git 훅 안에서 불러도 마켓플레이스 저장소만 다룬다.
+- 마켓플레이스의 `.git` 이 깨졌으면(중단된 clone 등) git 이 위쪽 저장소로 올라가지 못하게 막는다. 그때 `[4/4]` 는 `origin remote 없음` 으로 끝나고 고정하지 않는다.
 - `--scan` 은 읽기만 한다. 플러그인 캐시도 `installed_plugins.json` 도 읽지 않고 준 파일만 본다.
 - 도구의 주석과 출력 문구는 한글이다.