@kaydash9999/banker-plugins 0.17.1 → 0.19.0

package/skills/tone-compact/scripts/tone-compact.mjs

@@ -8,62 +8,43 @@
  *
  * The rules are the part of ../SKILL.md between the tone-compact:rules markers,
  * so the text the skill applies in the session and the text later sessions load
- * are the same.
- *
- * Claude Code loads every rules file under <config>/rules/ (<config> is
- * $CLAUDE_CONFIG_DIR or ~/.claude) at session start and again after compaction.
- * `on` writes banker-tone-compact.md there and `off` 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).
- * `on` adds one marked block at the end of AGENTS.md, or of the override when
- * the override has text of its own (a block alone there would hide AGENTS.md);
- * `off` takes it 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; `on` 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>.tone-compact.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 on
- * and off 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.
+ * are the same. Where they go, and how they come out again byte for byte, is
+ * instruction-toggle.mjs beside this file, shared with anti-drm: a rules file
+ * under Claude Code's <config>/rules/, and one marked block in the instructions
+ * file Codex reads.
  *
  * `off` never needs the rules, so it works even when SKILL.md cannot be read.
  * Exit status 0 means done or already so; 1 means refused or a usage error, with
  * nothing changed; 2 means an unexpected error stopped the command partway, so
  * check `status`.
  */
-import {
-  accessSync,
-  constants,
-  lstatSync,
-  mkdirSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  KEEP_CLOSE,
+  KEEP_OPEN,
+  RUNTIMES,
+  blockSpansOf,
+  count,
+  hasMarker,
+  lf,
+  stateLines,
+  toggleSpec,
+  turnOff as toggleOff,
+  turnOn as toggleOn,
+  where,
+} from "./instruction-toggle.mjs";
 
 const RULES_START = "<!-- tone-compact:rules:start -->";
 const RULES_END = "<!-- tone-compact:rules:end -->";
-// The Claude Code rules file starts with this mark; it is how off and on know the file is banker's.
-const OWNER_MARK = "<!-- banker tone-compact";
-const HEADER = `${OWNER_MARK}: banker 가 관리하는 파일입니다. 끄려면 tone-compact 에 off 를 실행하세요. -->`;
-const OPEN = "<!-- banker:tone-compact:start -->";
-const CLOSE = "<!-- banker:tone-compact:end -->";
-// OMX keeps only these regions when `omx setup` rewrites a generated AGENTS.md.
-const KEEP_OPEN = "<!-- USER:OMX:POLICY:START -->";
-const KEEP_CLOSE = "<!-- USER:OMX:POLICY:END -->";
-const MARKERS = [OPEN, CLOSE, KEEP_OPEN, KEEP_CLOSE, RULES_START, RULES_END];
+const TOGGLE = toggleSpec({
+  slug: "tone-compact",
+  staleText: "켜짐, 단 규칙이 이 버전과 다름 (on 으로 갱신)",
+  updatedText: "규칙을 이 버전으로 바꿨습니다",
+});
+const MARKERS = [TOGGLE.open, TOGGLE.close, KEEP_OPEN, KEEP_CLOSE, RULES_START, RULES_END];
 
 const DEFAULTS = {
   claudeDir: process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"),
@@ -71,48 +52,6 @@ const DEFAULTS = {
   skillFile: fileURLToPath(new URL("../SKILL.md", import.meta.url)),
 };
 
-const count = (text, needle) => text.split(needle).length - 1;
-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 });
-
 /** The rules: the text between the markers in SKILL.md, without the line breaks around it. */
 export function rulesOf(skillText) {
   const text = lf(skillText);
@@ -122,7 +61,7 @@ export function rulesOf(skillText) {
     throw new Error("SKILL.md 에서 규칙 구간(tone-compact:rules 표시)을 찾지 못했습니다");
   }
   const rules = text.slice(start + RULES_START.length, end).replace(/^\n+|\n+$/g, "");
-  if (rules === "" || MARKERS.some((m) => rules.includes(m))) {
+  if (rules === "" || MARKERS.some((m) => rules.includes(m)) || hasMarker(rules)) {
     throw new Error("SKILL.md 의 규칙 구간이 비었거나 관리 표시를 담고 있습니다");
   }
   return rules;
@@ -130,291 +69,8 @@ export function rulesOf(skillText) {
 
 const loadRules = (o) => rulesOf(readFileSync(o.skillFile, "utf8"));
 
-// 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.
-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;
-  }
-}
-
-const denied = (e) => e.code === "EACCES" || e.code === "EPERM" || e.code === "EROFS";
-
-// ---- Claude Code: one rules file that is banker's alone ----
-
-const claudeFile = (o) => join(o.claudeDir, "rules", "banker-tone-compact.md");
-const claudeText = (rules) => `${HEADER}\n${rules}\n`;
-
-// "off", "foreign" (not banker's file), or, when rules are given, "on" or
-// "stale" (an earlier version's rules); without rules a banker file is "ours".
-function claudeState(file, rules) {
-  if (file === null) return "off";
-  if (file.text === null) return "foreign";
-  const body = lf(file.text.replace(/^\uFEFF/, ""));
-  if (!body.startsWith(OWNER_MARK)) return "foreign";
-  if (rules === undefined) return "ours";
-  return body === claudeText(rules) ? "on" : "stale";
-}
-
-function claudeOn(o) {
-  const file = claudeFile(o);
-  if (!isDir(o.claudeDir)) return refuse(`Claude Code 설정 폴더가 없습니다: ${o.claudeDir}`);
-  const rules = loadRules(o);
-  const state = claudeState(readFile(file), rules);
-  if (state === "foreign") return refuse(`같은 이름의 다른 파일이 있어 그대로 두었습니다: ${file}`);
-  if (state === "on") return done(`Claude Code: 이미 켜져 있습니다 (변경 없음). ${file}`);
-  try {
-    mkdirSync(dirname(file), { recursive: true, mode: 0o755 });
-    writeFresh(file, claudeText(rules));
-  } catch (e) {
-    if (denied(e)) return refuse(`쓸 권한이 없어 켜지 못했습니다 (${e.code}): ${file}`);
-    throw e;
-  }
-  return done(
-    state === "stale"
-      ? `Claude Code: 규칙을 이 버전으로 바꿨습니다. ${file}`
-      : `Claude Code: 켰습니다. 다음 세션부터 자동 적용됩니다. ${file}`,
-  );
-}
-
-function claudeOff(o) {
-  const file = claudeFile(o);
-  const state = claudeState(readFile(file));
-  if (state === "off") return done("Claude Code: 이미 꺼져 있습니다 (변경 없음).");
-  if (state === "foreign") return refuse(`같은 이름의 다른 파일이 있어 그대로 두었습니다: ${file}`);
-  try {
-    rmSync(file);
-  } catch (e) {
-    if (denied(e)) return refuse(`지울 권한이 없어 끄지 못했습니다 (${e.code}): ${file}`);
-    throw e;
-  }
-  return done(`Claude Code: 껐습니다. 다음 세션부터 적용되지 않습니다. ${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 ? lineBare(lines[i]).replace(/^\uFEFF/, "") : 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 the tone-compact blocks sit in text, or null when the markers are not
- * whole lines that open and close in turn. on and off refuse null, so a marker
- * quoted inside a sentence can never make them cut the user's own text.
- */
-export function blockSpans(text) {
-  const lines = text.split(/(?<=\n)/);
-  const offsets = [];
-  let at = 0;
-  for (const line of lines) {
-    offsets.push(at);
-    at += line.length;
-  }
-  const spans = [];
-  let open = -1;
-  for (let i = 0; i < lines.length; i++) {
-    const bare = bareAt(lines, i);
-    if (bare === OPEN && open === -1) open = i;
-    else if (bare === CLOSE && open !== -1) {
-      spans.push(spanOf(lines, offsets, open, i));
-      open = -1;
-    } else if (lines[i].includes(OPEN) || lines[i].includes(CLOSE)) return null;
-  }
-  return open === -1 ? spans : null;
-}
-
-// 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.
-function strip(text, spans) {
-  let out = "";
-  let at = 0;
-  for (const s of spans) {
-    const keepBreak = s.to < text.length && !s.blankBefore;
-    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 unlike JavaScript's keeps a byte order mark).
-const hasContent = (text) => /[^\t\n\v\f\r \u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/.test(text);
-
-// 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: an override holding only the block would hide
-// AGENTS.md from Codex, which reads any override with non-whitespace text.
-function codexFiles(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 : blockSpans(file.text) };
-  };
-  const override = read("AGENTS.override.md");
-  const main = read("AGENTS.md");
-  const ownContent =
-    binary(override) ||
-    (override.text !== null && hasContent(override.spans === null ? override.text : strip(override.text, override.spans)));
-  const target = ownContent ? override : main;
-  return { target, other: target === override ? main : override, all: [override, main] };
-}
-
-const blockFor = (rules, eol) => [KEEP_OPEN, OPEN, ...rules.split("\n"), CLOSE, KEEP_CLOSE, ""].join(eol);
-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));
-// 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) => lf(text).replace(/^\uFEFF/, "").replace(/\n$/, "");
-// The block exactly as `on` writes it, and only once.
-const blockCurrent = (f, rules) =>
-  f.spans.length === 1 && normBlock(f.text.slice(f.spans[0].from, f.spans[0].to)) === normBlock(blockFor(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(text, rules) {
-  const eol = eolOf(text);
-  return text === "" ? blockFor(rules, eol) : text + eol + blockFor(rules, eol);
-}
-
-// "off", "on", "stale", "misplaced" (only in AGENTS.md while Codex reads the
-// override, so not applied), "hidden" (alone in the override, applied but hiding
-// AGENTS.md), "unpaired" or "notutf8". Without rules any block in its place
-// counts as "on".
-function codexState(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(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 `쓸 권한이 없어 그대로 두었습니다 (${e.code || e.message}): ${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(changes) {
-  for (const { file, after } of changes) {
-    if (file.bytes !== null) writeFresh(`${file.path}.tone-compact.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 은 블록을 남깁니다.";
-
-const notUtf8Refusal = (files) => refuse(`UTF-8 이 아닌 파일이라 그대로 두었습니다: ${files.all.find(binary).path}`);
-
-const unpairedRefusal = (files) =>
-  refuse(`tone-compact 표시의 짝이 맞지 않아 그대로 두었습니다: ${files.all.find(unpaired).path}`);
-
-function codexOn(o) {
-  if (!isDir(o.codexDir)) return refuse(`Codex 설정 폴더가 없습니다: ${o.codexDir}`);
-  const rules = loadRules(o);
-  const files = codexFiles(o);
-  const state = codexState(files, rules);
-  if (state === "notutf8") return notUtf8Refusal(files);
-  if (state === "unpaired") return unpairedRefusal(files);
-  if (state === "on") return done(`Codex: 이미 켜져 있습니다 (변경 없음). ${files.target.path}`);
-  const changes = [{ file: files.target, after: withBlock(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(changes);
-  const moved = "블록을 맞는 파일로 옮겼습니다";
-  const what = { stale: "규칙을 이 버전으로 바꿨습니다", misplaced: moved, hidden: moved }[state];
-  const note = files.target === files.all[1] ? `\n${OMX_NOTE}` : "";
-  return done(`Codex: ${what ?? "켰습니다. 다음 세션부터 자동 적용됩니다"}. ${files.target.path}${note}`);
-}
-
-function codexOff(o) {
-  if (!isDir(o.codexDir)) return done(`Codex: 설정 폴더가 없어 끌 것이 없습니다 (변경 없음). ${o.codexDir}`);
-  const files = codexFiles(o);
-  const state = codexState(files);
-  if (state === "notutf8") return notUtf8Refusal(files);
-  if (state === "unpaired") return unpairedRefusal(files);
-  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(changes);
-  return done(`Codex: 껐습니다. 다음 세션부터 적용되지 않습니다. ${changes.map((c) => c.file.path).join(", ")}`);
-}
-
-// ---- status ----
-
-const STATE_TEXT = {
-  on: "켜짐",
-  ours: "켜짐 (규칙 버전 확인 불가)",
-  stale: "켜짐, 단 규칙이 이 버전과 다름 (on 으로 갱신)",
-  off: "꺼짐",
-  foreign: "꺼짐, 같은 이름의 다른 파일이 있음 (손대지 않음)",
-  misplaced: "꺼짐, 단 블록이 Codex 가 읽지 않는 AGENTS.md 에 있음 (on 으로 옮김)",
-  hidden: "켜짐, 단 AGENTS.override.md 에 블록만 있어 AGENTS.md 가 가려짐 (on 으로 옮김)",
-  notutf8: "UTF-8 이 아닌 지침 파일이 있어 손대지 않음 (on, off 모두 거부)",
-  unpaired: "표시의 짝이 맞지 않음 (on, off 모두 거부. 남은 표시 줄 정리 필요)",
-};
-
-// One status line per runtime. Read failures are reported, not thrown: status
-// is where an exit 2 sends the user to look.
-function describe(name, look) {
-  try {
-    const { state, path } = look();
-    return `- ${name}: ${STATE_TEXT[state] ?? state} (${path})`;
-  } catch (e) {
-    return `- ${name}: 읽을 수 없음 (${e.code || e.message})`;
-  }
-}
+/** Where the tone-compact blocks sit in text, or null when the markers do not pair up. */
+export const blockSpans = (text) => blockSpansOf(text, TOGGLE.open, TOGGLE.close);
 
 export function status(opts = {}) {
   const o = { ...DEFAULTS, ...opts };
@@ -423,29 +79,17 @@ export function status(opts = {}) {
   try {
     rules = loadRules(o);
   } catch (e) {
-    lines.push(`- 규칙 원문을 읽지 못해 버전은 비교하지 않음 (${e.code || e.message})`);
+    lines.push(`- 규칙 원문을 읽지 못해 버전은 비교하지 않음 (${where(e.code || e.message)})`);
   }
-  lines.push(
-    describe("Claude Code", () => {
-      if (!isDir(o.claudeDir)) return { state: "설정 폴더 없음", path: o.claudeDir };
-      return { state: claudeState(readFile(claudeFile(o)), rules), path: claudeFile(o) };
-    }),
-    describe("Codex", () => {
-      if (!isDir(o.codexDir)) return { state: "설정 폴더 없음", path: o.codexDir };
-      const files = codexFiles(o);
-      return { state: codexState(files, rules), path: files.target.path };
-    }),
-  );
-  return done(lines.join("\n"));
+  lines.push(...stateLines(TOGGLE, o, rules));
+  return { ok: true, message: lines.join("\n") };
 }
 
-const ACTIONS = new Map([
-  ["claude", { on: claudeOn, off: claudeOff }],
-  ["codex", { on: codexOn, off: codexOff }],
-]);
-
-export const turnOn = (runtime, opts = {}) => ACTIONS.get(runtime).on({ ...DEFAULTS, ...opts });
-export const turnOff = (runtime, opts = {}) => ACTIONS.get(runtime).off({ ...DEFAULTS, ...opts });
+export const turnOn = (runtime, opts = {}) => {
+  const o = { ...DEFAULTS, ...opts };
+  return toggleOn(TOGGLE, runtime, o, () => loadRules(o));
+};
+export const turnOff = (runtime, opts = {}) => toggleOff(TOGGLE, runtime, { ...DEFAULTS, ...opts });
 
 // { command, runtime, extra } from the command line; --runtime takes "x" or "=x".
 export function parseArgs(argv) {
@@ -465,14 +109,21 @@ const USAGE = "사용법: tone-compact on | off | status [--runtime claude|codex
 // The runtime on and off act on: the flag, else Claude Code when it runs this.
 const runtimeOf = (flag, env) => flag ?? (env.CLAUDECODE === "1" ? "claude" : null);
 
+// Why the command line cannot run as given, or "" when it can.
+function usageError(command, flag, extra) {
+  if (extra.length > 0 || !["on", "off", "status"].includes(command)) return USAGE;
+  return flag !== null && !RUNTIMES.includes(flag) ? USAGE : "";
+}
+
 function main(argv, env = process.env) {
   const { command, runtime: flag, extra } = parseArgs(argv);
-  if (extra.length > 0 || !["on", "off", "status"].includes(command) || (flag !== null && !ACTIONS.has(flag))) {
-    process.stdout.write(`${USAGE}\n`);
+  const why = usageError(command, flag, extra);
+  if (why) {
+    process.stdout.write(`${why}\n`);
     return 1;
   }
   const runtime = runtimeOf(flag, env);
-  if (command !== "status" && !ACTIONS.has(runtime)) {
+  if (command !== "status" && !RUNTIMES.includes(runtime)) {
     process.stdout.write(`런타임을 정할 수 없습니다. --runtime claude 또는 --runtime codex 를 붙이세요.\n${USAGE}\n`);
     return 1;
   }
@@ -481,7 +132,7 @@ function main(argv, env = process.env) {
     process.stdout.write(`${message}\n`);
     return ok ? 0 : 1;
   } catch (e) {
-    process.stdout.write(`예기치 못한 오류로 중단했습니다: ${e.message}\nstatus 로 상태를 확인하세요.\n`);
+    process.stdout.write(`예기치 못한 오류로 중단했습니다: ${where(e.message)}\nstatus 로 상태를 확인하세요.\n`);
     return 2;
   }
 }

package/skills/ultra-chain/SKILL.md

@@ -283,7 +283,7 @@ ralplan 은 계획 작성자 외에 Architect 와 Critic 두 검토자로 합의
 
 ## 5. 구현
 
-1. 기준선: 바꾸기 전에 시험 명령을 한 번 돌려 이미 실패하는 항목을 `<run>/05-baseline.txt` 에 남긴다. 0단계에서 기존 변경을 두고 진행했으면 지금 트리를 기준선으로 쓴다.
+1. 기준선: 바꾸기 전에 시험 명령을 한 번 돌려 이미 실패하는 항목을 `<run>/05-baseline.md` 에 남긴다. 0단계에서 기존 변경을 두고 진행했으면 지금 트리를 기준선으로 쓴다.
    - 깨끗한 사본이 필요하면 저장소 밖 임시 폴더에 `git worktree add --detach <임시> HEAD` 로 만든다. 의존성을 링크하거나 설치한 뒤 돌리고, 명령이 실제로 돌았는지 확인한다. "명령 없음" 오류뿐인 기록은 기준선이 아니다. 끝나면 `git worktree remove --force <임시>` 로 지운다.
    - `git stash`, `git reset` 은 쓰지 않는다.
 2. Claude Code: ralph 를 `--critic=critic` 으로 부른다. 인자에 아래를 넘긴다.
@@ -322,7 +322,7 @@ ralph-qa 의 검토자는 시험을 직접 돌리지 않는다. 연쇄가 이
 1. 이번 변경의 새 파일을 스테이징한다(`git add -- <파일>...`, 커밋은 하지 않음). 박스로 보내는 트리는 추적 파일만 담는다. 스테이징할 목록을 먼저 보인다.
    - `.omc/`, `.omx/` 아래, `.env` 류, 키와 자격 증명 파일은 넣지 않는다.
    - 넣을 텍스트 파일은 `<scan>` 으로 검사한다. 걸린 파일은 넣지 않고 사용자에게 알린다. 그 파일이 필요한 시험은 박스에서 미검증이다.
-2. 이 머신에서 시험, 빌드, 린트를 돌려 원문 출력을 `<run>/qa/local-r<k>.txt` 에 남긴다. 결과를 `tests` 에 기록한다(`where: "local"`, `os`, `status`, 셀 수 있으면 `tests`, `pass`, `fail`, `skipped`, `log: "qa/local-r<k>.txt"`).
+2. 이 머신에서 시험, 빌드, 린트를 돌려 원문 출력을 `<run>/qa/local-r<k>.md` 에 남긴다. 결과를 `tests` 에 기록한다(`where: "local"`, `os`, `status`, 셀 수 있으면 `tests`, `pass`, `fail`, `skipped`, `log: "qa/local-r<k>.md"`).
 3. 박스에서 같은 시험을 돌린다. 고른 박스마다 `--box <이름>` 을 붙인다. 오래 도는 명령으로 돌리고, 끝난 뒤에 기록한다.
 
    ```bash
@@ -341,7 +341,7 @@ ralph-qa 의 검토자는 시험을 직접 돌리지 않는다. 연쇄가 이
    - 한 OS 에서만 실패하면 원인을 나눈다. 제품 결함은 고치고, 시험이 실행 환경을 잘못 가정한 것도 고친다.
    - `--boxes=none` 이면 이 3을 건너뛴다.
 4. ralph-qa 를 `--lens=both --agents=<agents> --max=<max>` 로 부른다. 외부 좌석은 3단계에서 고른 모델을 값으로 넘긴다.
-   - 입력: 요청 원문, `02-spec.md` 의 수용 기준과 사용자 답변 원문, `03-plan.md`, 승인된 목업과 기대 출력, 2의 원문 출력, 3의 박스 JSON 과 실패한 박스의 로그 발췌, `05-baseline.txt`. diff 의 기준은 `<base>` 다
+   - 입력: 요청 원문, `02-spec.md` 의 수용 기준과 사용자 답변 원문, `03-plan.md`, 승인된 목업과 기대 출력, 2의 원문 출력, 3의 박스 JSON 과 실패한 박스의 로그 발췌, `05-baseline.md`. diff 의 기준은 `<base>` 다
    - 3단계와 같이 모든 좌석의 지시에 적대적 검토 문장을 넣는다
    - 회차마다 `note` 로 기록하고, 끝나면 보고 전문을 `<run>/qa/ralph-qa-r<k>.md` 로 저장한다.
    - `ITERATE` 면 고친 뒤 1부터 3까지 다시 하고(새 `<k>`), 같은 실행에서 다시 판정받는다. 끈끈한 반대는 그 검토자의 재판정으로만 풀린다.
@@ -355,7 +355,7 @@ ralph-qa 의 검토자는 시험을 직접 돌리지 않는다. 연쇄가 이
    - 임시 데이터 폴더나 임시 HOME 에서 만든다. 사용자의 실제 데이터에 쓰지 않는다.
    - 색을 끈다(`NO_COLOR=1`). 종료 코드도 대조 대상이다.
    - `mock/expected/` 와 대조한다. JSON 은 파싱해 깊게 비교하고, 텍스트는 바이트로 비교한다(줄 끝 포함). `.ignore.json` 에 적힌 칸은 뺀다.
-   - 결과를 보기마다 `tests` 하나로 `where: "compare:<보기>"` 에 기록한다. `tests` 는 그 보기에서 대조한 파일 수, `pass` 는 같은 파일 수, `fail` 은 다른 파일 수다. `log` 는 파일마다 `same <이름>` 이나 `DIFF <이름>` 한 줄을 남긴 대조 출력(`visual/compare-r<k>.txt`, `<k>` 는 마지막 `qa` 회차)이다. 로그만 보고도 수를 다시 셀 수 있어야 한다.
+   - 결과를 보기마다 `tests` 하나로 `where: "compare:<보기>"` 에 기록한다. `tests` 는 그 보기에서 대조한 파일 수, `pass` 는 같은 파일 수, `fail` 은 다른 파일 수다. `log` 는 파일마다 `same <이름>` 이나 `DIFF <이름>` 한 줄을 남긴 대조 출력(`visual/compare-r<k>.md`, `<k>` 는 마지막 `qa` 회차)이다. 로그만 보고도 수를 다시 셀 수 있어야 한다.
 2. 캡처: 목업 보기와 실제 결과를 같은 크기로 찍는다. CLI 와 라이브러리는 실제 출력을 escape 해 목업과 같은 HTML 틀에 담아 `<run>/actual/<view>.html` 로 만든 뒤 찍는다. 앱 서버가 필요하면 시험 데이터와 임시 HOME 으로(실제 `.env`, 실제 DB 없이) 오래 도는 명령으로 띄우고, 캡처가 끝나면 그 작업을 멈춘다.
 
    ```bash
@@ -429,9 +429,10 @@ node "<S>/references/chain-report.mjs" "<run>"
 5. 회차는 `maxRound` 다음 번호로 이어 센다. 앞 회차 파일을 덮어쓰지 않는다. `--max` 는 남은 횟수만 쓴다.
 6. 판정이 없는 회차(그 번호의 시험이나 박스 기록은 있는데 같은 번호의 판정 기록이 없음)는 새 번호로, 지금 트리로 시험부터 다시 한다.
 7. 5단계에서 이을 때
-   - `05-baseline.txt` 는 다시 쓰지 않는다. 이미 바뀐 트리로 쓰면 이번 변경이 만든 실패가 기존 실패로 바뀐다.
+   - `05-baseline.md` 는 다시 쓰지 않는다. 이미 바뀐 트리로 쓰면 이번 변경이 만든 실패가 기존 실패로 바뀐다.
+   - 이 판보다 먼저 시작한 실행 폴더에는 기준선이 `05-baseline.txt` 로 있다. `05-baseline.md` 가 없으면 그 파일을 기준선으로 쓴다.
    - 같은 세션에서 ralph 가 아직 켜져 있으면 다시 부르지 않고 끝나기를 기다린다.
-   - 새 세션에서 ralph 를 다시 부르면 ralph 는 지금 트리로 기준선을 다시 기록한다. 이 사실을 `build` 의 `note` 에 적고, 새 실패의 판정은 `05-baseline.txt` 기준으로 한다.
+   - 새 세션에서 ralph 를 다시 부르면 ralph 는 지금 트리로 기준선을 다시 기록한다. 이 사실을 `build` 의 `note` 에 적고, 새 실패의 판정은 `05-baseline.md` 기준으로 한다.
 
 ## 플래그
 

package/skills/update-banker/SKILL.md

@@ -61,7 +61,7 @@ banker 는 서로 다른 메커니즘의 채널 3개로 설치되고, 그 채널
 - 반대 방향의 거짓말도 하지 마라: banker 자체는 dependencies 0 이라 컴파일이 없다. **빌드 도구·툴체인 준비를 요구하는 절차를 넣으면 그건 거짓이다.**
 
 **4. `~/.claude/plugins/cache/` 를 `rm -rf` 하지 마라.**
-- 캐시에 구버전이 공존하는 것은 **관측 대상이지 조치 대상이 아니다.** 갱신 의미론 밖이고, 자동 정리 주기에 관한 증거는 서로 어긋난다.
+- 캐시에 구버전이 공존하는 것은 **관측 대상이지 조치 대상이 아니다.** 갱신 의미론 밖이다. Claude Code 는 교체된 판 폴더에 `.orphaned_at` 을 쓰고, 14일이 지나고 그 판을 쓰는 세션이 없으면 그 폴더를 스스로 지운다(2.1.299 에서 확인). 링크로 된 판 폴더(OMC 의 옛 판 경로 등)는 표시하지도 지우지도 않는다.
 - 발견하면 보고만 한다. 손대지 않는다.
 
 ## 워크플로