@kaydash9999/banker-plugins 0.20.5 → 0.22.0

package/skills/smart-compact/scripts/codex-gate.mjs

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+/**
+ * smart-compact for Codex: a UserPromptSubmit hook that tells the session when its context passes a threshold.
+ *
+ *   node codex-gate.mjs on [--threshold N]   arm: save N (default 50), copy the hook, add it to hooks.json
+ *   node codex-gate.mjs off                  disarm: take the hook out, with its copy, threshold and state
+ *   node codex-gate.mjs status               say whether it is armed and the hook is in place and current
+ *   node codex-gate.mjs usage <rollout>      print the context use the session record shows
+ *   node codex-gate.mjs hook                 the hook itself (Codex runs it; reads the hook input on stdin)
+ *
+ * Codex gives a hook no context percentage, but every hook input carries transcript_path, the session record
+ * (rollout). Its token_count events hold last_token_usage and model_context_window, so the use of the last
+ * request over the window is the context use (measured on Codex 0.144.5).
+ * Files live in <CODEX_HOME> (default ~/.codex): smart-compact.json (threshold), smart-compact-state.json
+ * (sessions told), hooks.json.smart-compact.bak (hooks.json before each change) and the hook itself, copied to
+ * hooks-custom/banker-smart-compact-gate.mjs. Codex runs a trusted hook outside the sandbox, so the hook runs from
+ * that copy, where a sandboxed session cannot write, and not from a skill folder that may sit in a workspace.
+ * Codex trusts a hook by its handler and records the trust under the group's index: the threshold lives in a file
+ * so the command never changes with it, and the group is appended after the ones there, so OMX's hooks keep
+ * their indexes. On Windows Codex runs a hook command through PowerShell (measured on Codex 0.160.1), so the
+ * command there is `& '<node>' '<script>' hook`.
+ * The hook speaks once per session while the use stays at or over the threshold, and again after the use has
+ * dropped below it (after /compact). It never blocks a prompt: any error leaves it silent with exit 0.
+ * Exit status 1 means nothing was changed; 2 means an unexpected error stopped the command.
+ */
+import {
+  chmodSync, closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, realpathSync,
+  renameSync, rmSync, statSync, writeFileSync,
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, posix, win32 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SELF = fileURLToPath(import.meta.url);
+const COPY_NAME = "banker-smart-compact-gate.mjs";
+const KEEP_SESSIONS = 50;
+const MAX_READ = 32 << 20;
+
+export function paths(env = process.env) {
+  const home = env.CODEX_HOME || join(homedir(), ".codex");
+  return {
+    home,
+    hooks: join(home, "hooks.json"),
+    config: join(home, "smart-compact.json"),
+    state: join(home, "smart-compact-state.json"),
+    backup: join(home, "hooks.json.smart-compact.bak"),
+    copyDir: join(home, "hooks-custom"),
+    copy: join(home, "hooks-custom", COPY_NAME),
+  };
+}
+
+const isObject = (v) => Boolean(v) && typeof v === "object" && !Array.isArray(v);
+
+// JSON from a regular file only: a FIFO or a device would stall the hook. null when missing, odd or unreadable.
+function readJson(file) {
+  try {
+    return lstatSync(file).isFile() ? JSON.parse(readFileSync(file, "utf8")) : null;
+  } catch {
+    return null;
+  }
+}
+
+// A new file beside the target, given the target's mode when there is one, then renamed over it. The temp name is
+// created exclusively and a link in the target's place is replaced, not followed. The temp file goes on failure.
+function writeAtomic(file, data) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tmp, data, { flag: "wx" });
+    const mode = modeOf(file);
+    if (mode !== null) chmodSync(tmp, mode);
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+function modeOf(file) {
+  try {
+    const st = lstatSync(file);
+    return st.isFile() ? st.mode & 0o7777 : null;
+  } catch {
+    return null;
+  }
+}
+
+const writeJson = (file, value) => writeAtomic(file, `${JSON.stringify(value, null, 2)}\n`);
+
+// The last token_count with usage in a rollout, read from the end in growing spans, so a long session costs one
+// tail read in the usual case; null past `max` bytes, for a file that is not regular (checked before opening, since
+// opening a FIFO waits for a writer), or when none has usage yet (info is null on the first events of a session).
+export function lastUsage(file, max = MAX_READ) {
+  if (!statSync(file).isFile()) return null;
+  const fd = openSync(file, "r");
+  try {
+    const size = fstatSync(fd).size;
+    for (let span = 1 << 18; ; span *= 4) {
+      const start = Math.max(0, size - Math.min(span, max));
+      const buf = Buffer.alloc(size - start);
+      readSync(fd, buf, 0, buf.length, start);
+      const found = scanUsage(buf.toString("utf8"), start > 0);
+      if (found || start === 0 || span >= max) return found;
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function scanUsage(text, cutFirst) {
+  const lines = text.split("\n");
+  if (cutFirst) lines.shift();
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const found = lines[i].includes('"token_count"') ? usageOf(lines[i]) : null;
+    if (found) return found;
+  }
+  return null;
+}
+
+function usageOf(line) {
+  let rec;
+  try {
+    rec = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const info = rec && rec.payload && rec.payload.type === "token_count" ? rec.payload.info : null;
+  return info ? usageIn(info) : null;
+}
+
+function usageIn(info) {
+  const used = info.last_token_usage ? info.last_token_usage.total_tokens : NaN;
+  const win = info.model_context_window;
+  return Number.isFinite(used) && Number.isFinite(win) && win > 0 ? { used, window: win } : null;
+}
+
+export const percent = (u) => Math.round((u.used * 100) / u.window);
+
+export function nudge(pct, threshold) {
+  return `smart-compact: 컨텍스트 사용률 ${pct}% (임계 ${threshold}%). 이번 응답에서 위생 체인을 실행한다: `
+    + "$banker-append_wiki, 그다음 한 줄 안내(다음 메시지가 resume 프롬프트이고 그 뒤 /copy, /compact, 붙여 넣기 순서), "
+    + "마지막으로 $banker-ready-compact. banker 를 Codex 플러그인으로 설치했으면 $banker:append_wiki, $banker:ready-compact 다. "
+    + "/copy, /compact, 붙여 넣기는 사용자가 한다.";
+}
+
+const text = (o, key) => (o && typeof o[key] === "string" ? o[key] : "");
+
+// The hook's decision for one prompt: the text to inject, or "" for none. Mutates and returns the state.
+export function decide(input, config, state) {
+  const sid = text(input, "session_id");
+  const file = text(input, "transcript_path");
+  const usage = config && sid && file ? lastUsage(file) : null;
+  if (!usage) return { text: "", state };
+  const pct = percent(usage);
+  if (pct < config.threshold) {
+    delete state[sid];
+    return { text: "", state };
+  }
+  if (state[sid]) return { text: "", state };
+  state[sid] = Date.now();
+  prune(state);
+  return { text: nudge(pct, config.threshold), state };
+}
+
+function prune(state) {
+  const ids = Object.keys(state).sort((a, b) => state[a] - state[b]);
+  for (const old of ids.slice(0, Math.max(0, ids.length - KEEP_SESSIONS))) delete state[old];
+}
+
+function validConfig(c) {
+  return isObject(c) && Number.isInteger(c.threshold) && c.threshold >= 1 && c.threshold <= 95 ? c : null;
+}
+
+async function runHook(p) {
+  try {
+    process.stdin.setEncoding("utf8");
+    let raw = "";
+    for await (const chunk of process.stdin) raw += chunk;
+    const read = readJson(p.state);
+    const before = isObject(read) ? read : {};
+    const was = JSON.stringify(before);
+    const { text: say, state } = decide(JSON.parse(raw), validConfig(readJson(p.config)), before);
+    if (JSON.stringify(state) !== was) writeJson(p.state, state);
+    if (say) {
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: say },
+      }));
+    }
+  } catch {
+    /* a hook never blocks the prompt */
+  }
+  return 0;
+}
+
+// The command text, or null for a path the platform shell would still read into. POSIX: both paths in double
+// quotes, refusing $, `, " and backslashes. Windows: PowerShell's call operator with single-quoted paths, every
+// character PowerShell takes for a single quote (' and U+2018-U+201B) doubled.
+export function formatCommand(node, script, win = process.platform === "win32") {
+  if (/[\r\n\0]/.test(node + script)) return null;
+  if (win) {
+    const q = (s) => s.replace(/['\u2018-\u201B]/g, "$&$&");
+    return `& '${q(node)}' '${q(script)}' hook`;
+  }
+  return /["$`\\]/.test(node + script) ? null : `"${node}" "${script}" hook`;
+}
+
+// The command `on` writes, or null when a location makes it unsafe. Codex runs a trusted hook outside the sandbox,
+// so a node in the temp folder is refused, and when `on` itself runs inside Codex (CODEX_THREAD_ID), a node or a
+// source script inside the workspace is refused too: the sandboxed session could change it first. Paths are judged
+// by the target platform's rules.
+export function hookCommand(node, script, opts = {}) {
+  const { win = process.platform === "win32", cwd = process.cwd(), codex = Boolean(process.env.CODEX_THREAD_ID) } = opts;
+  const P = win ? win32 : posix;
+  const under = (f, dir) => {
+    const r = P.relative(dir, f);
+    return r === "" || (!r.startsWith("..") && !P.isAbsolute(r));
+  };
+  if (under(node, tmpdir()) || (codex && [node, SELF].some((f) => under(f, cwd)))) return null;
+  return formatCommand(node, script, win);
+}
+
+const COPY_RE = new RegExp(`[/\\\\]${COPY_NAME.replace(/\./g, "\\.")}["']? hook$`);
+const isOurs = (h) => isObject(h) && typeof h.command === "string" && COPY_RE.test(h.command);
+
+// hooks.json as an object, or why it cannot be changed. A missing file reads as empty; a link, a file that is not
+// JSON, or an error other than "not found" is refused, so OMX's hooks are never overwritten by mistake.
+function loadHooks(file) {
+  const kind = fileKind(file);
+  if (kind === "missing") return { doc: { hooks: {} }, groups: [] };
+  if (kind) return { why: kind };
+  const doc = readJson(file);
+  if (!isObject(doc)) return { why: `${file} 이 JSON 객체가 아님` };
+  if (doc.hooks === undefined) doc.hooks = {};
+  if (!isObject(doc.hooks)) return { why: `${file} 의 hooks 가 객체가 아님` };
+  const ups = doc.hooks.UserPromptSubmit;
+  if (ups !== undefined && !Array.isArray(ups)) return { why: `${file} 의 UserPromptSubmit 이 배열이 아님` };
+  return { doc, groups: ups || [] };
+}
+
+// "" for a regular file, "missing", or why the file cannot be used.
+function fileKind(file) {
+  try {
+    const st = lstatSync(file);
+    return st.isSymbolicLink() || !st.isFile() ? `${file} 이 일반 파일이 아님(링크나 폴더)` : "";
+  } catch (e) {
+    return e && e.code === "ENOENT" ? "missing" : `${file} 을 확인하지 못함(${e && e.code})`;
+  }
+}
+
+// Where our handler sits: [group index, handler index], or null.
+function findOurs(groups) {
+  for (let g = 0; g < groups.length; g++) {
+    const hs = isObject(groups[g]) && Array.isArray(groups[g].hooks) ? groups[g].hooks : [];
+    const h = hs.findIndex(isOurs);
+    if (h >= 0) return [g, h];
+  }
+  return null;
+}
+
+function saveHooks(p, doc) {
+  if (existsSync(p.hooks)) writeAtomic(p.backup, readFileSync(p.hooks));
+  writeJson(p.hooks, doc);
+}
+
+// The hook copy in <CODEX_HOME>/hooks-custom, refreshed when this version differs. A folder or copy that is a
+// link is refused.
+function installCopy(p) {
+  mkdirSync(p.copyDir, { recursive: true });
+  if (lstatSync(p.copyDir).isSymbolicLink()) return `${p.copyDir} 이 링크임`;
+  if (existsSync(p.copy) && !lstatSync(p.copy).isFile()) return `${p.copy} 이 일반 파일이 아님`;
+  const mine = readFileSync(SELF);
+  if (!existsSync(p.copy) || !readFileSync(p.copy).equals(mine)) writeAtomic(p.copy, mine);
+  return "";
+}
+
+const TRUST = "Codex 를 다시 열면 뜨는 Hooks need review 창이나 /hooks 에서 이 훅을 신뢰하십시오. 신뢰 전에는 돌지 않습니다";
+
+function placeHook(p, doc, groups, command) {
+  const at = findOurs(groups);
+  if (at && groups[at[0]].hooks[at[1]].command === command) return "훅은 이미 있음";
+  if (at) groups[at[0]].hooks[at[1]] = { ...groups[at[0]].hooks[at[1]], command, timeout: 5 };
+  else groups.push({ hooks: [{ type: "command", command, timeout: 5 }] });
+  doc.hooks.UserPromptSubmit = groups;
+  saveHooks(p, doc);
+  return at ? `훅 명령을 고쳤습니다. ${TRUST}` : `훅을 더했습니다. ${TRUST}`;
+}
+
+export function turnOn(p, threshold, node = process.execPath) {
+  if (!Number.isInteger(threshold) || threshold < 1 || threshold > 95) return { code: 1, msg: "임계값은 1~95 정수" };
+  const { doc, groups, why } = loadHooks(p.hooks);
+  if (why) return { code: 1, msg: `바꾸지 않음: ${why}` };
+  const command = hookCommand(node, p.copy);
+  if (!command) return { code: 1, msg: "바꾸지 않음: node 나 훅 경로가 안전하지 않음(셸이 읽는 글자, 임시 폴더의 node, Codex 작업 폴더 안의 node 나 스크립트). Codex 밖 터미널에서 실행하십시오" };
+  const bad = installCopy(p);
+  if (bad) return { code: 1, msg: `바꾸지 않음: ${bad}` };
+  const done = placeHook(p, doc, groups, command);
+  writeJson(p.config, { threshold });
+  return { code: 0, msg: `켰습니다(임계 ${threshold}%). ${done}` };
+}
+
+// Only our handler goes; a group it leaves empty goes too. Groups after a removed one move up an index, and
+// Codex then asks to trust their hooks again, so the message says so.
+export function turnOff(p) {
+  const { doc, groups, why } = loadHooks(p.hooks);
+  if (why) return { code: 1, msg: `바꾸지 않음: ${why}` };
+  const at = findOurs(groups);
+  let note = "켜져 있지 않았습니다(훅 없음). 설정만 지웠습니다";
+  if (at) {
+    const hs = groups[at[0]].hooks.filter((h) => !isOurs(h));
+    const shifts = hs.length === 0 && at[0] < groups.length - 1;
+    if (hs.length) groups[at[0]].hooks = hs;
+    else groups.splice(at[0], 1);
+    if (groups.length) doc.hooks.UserPromptSubmit = groups;
+    else delete doc.hooks.UserPromptSubmit;
+    saveHooks(p, doc);
+    note = shifts ? "껐습니다. 뒤에 있던 UserPromptSubmit 훅은 /hooks 에서 다시 신뢰해야 할 수 있습니다" : "껐습니다";
+  }
+  for (const f of [p.config, p.state, p.copy]) rmSync(f, { force: true });
+  return { code: 0, msg: note };
+}
+
+function staleness(p, groups, node) {
+  const at = findOurs(groups);
+  if (!at) return "no-hook";
+  if (groups[at[0]].hooks[at[1]].command !== formatCommand(node, p.copy)) return "stale";
+  try {
+    return readFileSync(p.copy).equals(readFileSync(SELF)) ? "" : "stale";
+  } catch {
+    return "stale";
+  }
+}
+
+export function status(p, node = process.execPath) {
+  const config = validConfig(readJson(p.config));
+  const { groups, why } = loadHooks(p.hooks);
+  if (why) return { code: 0, msg: `${config ? "켜짐 표시는 있으나 " : ""}hooks.json 을 읽지 못함: ${why}` };
+  const state = staleness(p, groups, node);
+  if (!config) return { code: 0, msg: state === "no-hook" ? "꺼짐" : "꺼짐(설정 없음, 훅만 남음). off 로 정리" };
+  if (state === "no-hook") return { code: 0, msg: "켜짐 표시는 있으나 훅이 없음(다른 도구나 손 편집이 지웠을 수 있음). on 을 다시 실행" };
+  if (state === "stale") return { code: 0, msg: "켜짐. 다만 훅 명령이나 사본이 이 판과 다름(node 경로가 바뀌었거나 banker 를 갱신함). on 을 다시 실행" };
+  return { code: 0, msg: `켜짐(임계 ${config.threshold}%). 알림이 없으면 /hooks 에서 이 훅을 신뢰했는지 확인` };
+}
+
+// on's arguments: --threshold N or --threshold=N, nothing else.
+function parseOn(args) {
+  if (args.length === 0) return 50;
+  const one = args.length === 1 && /^--threshold=(\d+)$/.exec(args[0]);
+  if (one) return Number(one[1]);
+  return args.length === 2 && args[0] === "--threshold" && /^\d+$/.test(args[1]) ? Number(args[1]) : NaN;
+}
+
+function usageLine(file) {
+  const u = file ? lastUsage(file) : null;
+  return u ? { code: 0, msg: `${percent(u)}% (${u.used} / ${u.window} 토큰)` } : { code: 1, msg: "token_count 기록 없음" };
+}
+
+const COMMANDS = {
+  on: (p, rest) => turnOn(p, parseOn(rest)),
+  off: (p, rest) => (rest.length ? null : turnOff(p)),
+  status: (p, rest) => (rest.length ? null : status(p)),
+  usage: (p, rest) => (rest.length === 1 ? usageLine(rest[0]) : null),
+};
+
+async function main(argv) {
+  const [cmd = "status", ...rest] = argv;
+  const p = paths();
+  if (cmd === "hook") return runHook(p);
+  const run = Object.prototype.hasOwnProperty.call(COMMANDS, cmd) ? COMMANDS[cmd] : null;
+  const out = (run && run(p, rest)) || { code: 1, msg: "사용법: codex-gate.mjs on [--threshold N] | off | status | usage <rollout>" };
+  (out.code ? process.stderr : process.stdout).write(`smart-compact: ${out.msg}\n`);
+  return out.code;
+}
+
+const invoked = (() => {
+  try {
+    return Boolean(process.argv[1]) && realpathSync(process.argv[1]) === realpathSync(SELF);
+  } catch {
+    return false;
+  }
+})();
+if (invoked) {
+  main(process.argv.slice(2)).then((c) => { process.exitCode = c; }, (e) => {
+    process.stderr.write(`smart-compact: 예기치 못한 오류: ${e && e.message}\n`);
+    process.exitCode = 2;
+  });
+}

package/skills/theme-selection/SKILL.md

@@ -24,7 +24,7 @@ argument-hint: "list | css | json | widget | check [--design-md PATH] [--only SL
    | 런타임 | 스킬 디렉터리 |
    |---|---|
    | Claude Code | 이 파일 맨 위에 넣어 준 "Base directory for this skill:" 줄의 경로 |
-   | Codex | `~/.codex/skills/banker-theme-selection/` 의 절대경로. 프로젝트 범위 설치면 `./.codex/skills/banker-theme-selection/` |
+   | Codex | Codex 스킬 목록이 보이는 이 SKILL.md 경로(file)의 폴더. npm 설치는 `~/.codex/skills/banker-theme-selection/`(프로젝트 범위 설치면 `./.codex/skills/banker-theme-selection/`), 플러그인 설치(`codex plugin add`)는 `~/.codex/plugins/cache/<마켓플레이스>/banker/<판>/skills/theme-selection/`. 절대경로로 씀 |
 
    - `~` 는 따옴표 안에서 펼쳐지지 않으니 절대경로를 쓴다.
 2. 프로젝트에 `DESIGN.md` 가 있으면 `--design-md` 로 함께 먹인다. 없으면 번들 74종만 쓴다.

package/skills/tone-compact/SKILL.md

@@ -24,7 +24,7 @@ argument-hint: "on | off | status"
    | 런타임 | `--runtime` | 스킬 디렉터리 |
    |---|---|---|
    | Claude Code | `claude` | 스킬 맨 위 "Base directory for this skill:" 경로 |
-   | Codex | `codex` | `~/.codex/skills/banker-tone-compact/` 의 절대경로. 프로젝트 범위 설치면 `./.codex/skills/banker-tone-compact/` |
+   | Codex | `codex` | Codex 스킬 목록이 보이는 이 SKILL.md 경로(file)의 폴더. npm 설치는 `~/.codex/skills/banker-tone-compact/`(프로젝트 범위 설치면 `./.codex/skills/banker-tone-compact/`), 플러그인 설치(`codex plugin add`)는 `~/.codex/plugins/cache/<마켓플레이스>/banker/<판>/skills/tone-compact/`. 절대경로로 씀 |
 
 3. 결과 처리
 

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

@@ -186,7 +186,7 @@ export function writeFresh(file, data, mode = 0o644) {
   const tmp = `${file}.${process.pid}.tmp`;
   rmSync(tmp, { force: true });
   try {
-    writeFileSync(tmp, data, { flag: "wx", mode });
+    writeNew(tmp, data, mode);
     renameOver(tmp, file);
   } catch (e) {
     rmSync(tmp, { force: true });
@@ -194,6 +194,48 @@ export function writeFresh(file, data, mode = 0o644) {
   }
 }
 
+// Opens a file that is not there yet, as "wx" does, and makes sure the name is the file made. macOS and Linux refuse
+// any name that is there, a link to nothing among them (EEXIST). Windows follows a link to nothing and makes the file
+// it leads to: then that file is removed again when it is still the empty one made, and the open is refused with
+// EEXIST as elsewhere. A look before the open catches such a link; this catches one planted between the look and the
+// open. A look that fails after the open leaves the file to the caller, as a plain "wx" would.
+export function openNew(path, mode) {
+  const fd = openSync(path, "wx", mode);
+  let made = null;
+  let st;
+  try {
+    made = fstatSync(fd, { bigint: true });
+    st = lstatSync(path, { bigint: true });
+  } catch {
+    return fd;
+  }
+  if (!st.isSymbolicLink() && (made.ino === 0n || sameInode(made, st))) return fd;
+  closeSync(fd);
+  if (st.isSymbolicLink()) dropFollowed(path, made);
+  throw Object.assign(new Error(`EEXIST: file already exists, open '${path}'`), { code: "EEXIST", syscall: "open", path });
+}
+
+// Removes the file a "wx" open made through the link at path, when it is still the empty file that open made.
+function dropFollowed(path, made) {
+  try {
+    const target = realpathSync(path);
+    const st = statSync(target, { bigint: true });
+    if (sameInode(made, st) && st.size === 0n) rmSync(target, { force: true });
+  } catch {
+    // gone already, or the link changed again: nothing of ours to take back
+  }
+}
+
+// Writes data to a file that is not there yet (openNew) and closes it.
+function writeNew(path, data, mode) {
+  const fd = openNew(path, mode);
+  try {
+    writeFileSync(fd, data);
+  } finally {
+    closeSync(fd);
+  }
+}
+
 // Windows does not rename a file over a link to a folder: there the link goes first, and the folder it
 // leads to stays.
 function renameOver(tmp, file) {
@@ -510,13 +552,14 @@ function writeBlocked(changes) {
 // whatever the umask allows more. A file left empty is removed, unless it is a
 // link or has other names (a hard link), whose other names would keep the old
 // text: it is emptied instead. Codex skips an empty file anyway.
-// A file that was not there when it was read is created only if it still is not ("wx"): a name that appeared in
+// A file that was not there when it was read is created only if it still is not (openNew): a name that appeared in
 // between, a link planted there among them, is not written through.
 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) && !hasOtherNames(file.path)) rmSync(file.path, { force: true });
-    else writeFileSync(file.path, after, { mode: 0o644, flag: file.bytes === null ? "wx" : "w" });
+    else if (file.bytes === null) writeNew(file.path, after, 0o644);
+    else writeFileSync(file.path, after, { mode: 0o644, flag: "w" });
   }
 }
 
@@ -568,9 +611,19 @@ const SLEEP = new Int32Array(new SharedArrayBuffer(4));
 // when it may still be there (no stats or no inode number to prove it is that file, or the share could not say).
 // Any other error (permissions, EIO) throws, after the same taking away.
 function tryLock(path, token) {
+  // A name that is there in any form is held. Windows opens "wx" through a link to nothing and makes the file it leads
+  // to; macOS and Linux answer EEXIST for it below, and openNew takes back a file Windows made through a link planted
+  // after this look. A look that fails leaves the answer to the open, as before.
+  let there = false;
+  try {
+    there = lstatSync(path, { throwIfNoEntry: false }) !== undefined;
+  } catch {
+    // ESTALE and the like: the open below answers
+  }
+  if (there) return "held";
   let fd;
   try {
-    fd = openSync(path, "wx", 0o600);
+    fd = openNew(path, 0o600);
   } catch (e) {
     if (e.code === "EEXIST") return "held";
     if (e.code === "ESTALE") return "stale";

package/skills/ultra-chain/SKILL.md

@@ -53,6 +53,7 @@ ultra-chain 이 직접 하는 일은 여섯 가지다.
 | 항목 | Claude Code (OMC) | Codex (OMX) |
 |---|---|---|
 | 1 자료 조사 | `Skill("banker:deep-research")` | `$banker-deep-research` |
+| 1 전문가 작업 방식 | `Skill("banker:lfm")` | `$banker-lfm` |
 | 2 모호성 제거 | `Skill("banker:ultra-interview")` | `$banker-ultra-interview` |
 | 3 합의 계획 | `Skill("oh-my-claudecode:ralplan")` `--deliberate`, 이어서 `Skill("banker:ralph-qa")` | `$ralplan --deliberate`, 이어서 `$banker-ralph-qa` |
 | 5 구현 | `Skill("oh-my-claudecode:ralph")` `--critic=critic` | `$ralph` 뒤 이 스킬의 critic 루프(OMX `ralph` 에는 `--critic` 이 없다) |
@@ -64,7 +65,7 @@ ultra-chain 이 직접 하는 일은 여섯 가지다.
 | 이어 하기 메모 | OMC 작업 노트에 덧붙이기(`notepad_write_working`). 우선 노트는 통째로 바뀌므로 쓰지 않음 | `.omx/notepad.md` 에 한 줄 덧붙이기 |
 | 실행 기록 기본 폴더 | `.omc/ultra-chain/` | `.omx/ultra-chain/` |
 
-- Codex 에는 Skill 도구가 없다. 위 표의 `$이름` 은 그 스킬의 `SKILL.md` 를 읽고 그대로 따른다는 뜻이다. banker 스킬은 `<S>/../banker-<이름>/SKILL.md`, OMX 스킬은 `~/.codex/skills/<이름>/SKILL.md` 다. 그 스킬이 상태 기록을 요구하면 그 지시대로 직접 기록한다. 큰 `SKILL.md`(ralph-qa 는 약 71KB)는 셸 출력 한도에서 잘리니 나눠 읽는다.
+- Codex 에는 Skill 도구가 없다. 위 표의 `$이름` 은 그 스킬의 `SKILL.md` 를 읽고 그대로 따른다는 뜻이다. banker 스킬은 npm 설치면 `<S>/../banker-<이름>/SKILL.md`, Codex 플러그인 설치(`<S>` 가 `plugins/cache/` 아래, 스킬 이름 `banker:<이름>`)면 `<S>/../<이름>/SKILL.md` 다. 표의 `$banker-<이름>` 은 플러그인 설치에서 `$banker:<이름>` 이다. OMX 스킬은 `~/.codex/skills/<이름>/SKILL.md` 다. 그 스킬이 상태 기록을 요구하면 그 지시대로 직접 기록한다. 큰 `SKILL.md`(ralph-qa 는 약 71KB)는 셸 출력 한도에서 잘리니 나눠 읽는다.
 - Codex 의 하위 에이전트(critic, 시각 판정)는 저자 대화를 넘기지 않는다. multi-agent v2 는 `fork_turns="none"` 을 주고, v1 은 `fork_context` 를 주지 않는다. 판정을 받으면 `close_agent` 로 닫는다.
 - Codex 환경 지시가 역할(`agent_type`)을 요구하면, 고정 모델이 세션 모델과 같은 역할을 쓰고 지시 앞머리에 파일 쓰기 금지를 적는다. 그런 역할이 없으면 역할 없이 띄운다. 쓴 역할과 모델, 강도를 판정 기록의 `note` 에 적는다.
 - Codex 의 오래 도는 명령은 기다리는 시간을 박스 `--timeout` 보다 길게 둔다. 기다리다 끊기면 박스 정리와 결과 JSON 이 남지 않는다.
@@ -190,16 +191,18 @@ node "<S>/references/chain-ledger.mjs" event "<run>" --stage research --status d
 
 ## 1. 자료 조사
 
-- deep-research 를 부른다. 넘기는 질문은 미리 좁히고, 인자에 "추가 질문 금지" 를 적는다. 범위 질문은 2단계가 맡는다. 질문은 공개 웹 검색어가 되므로 저장소 코드, 내부 이름, 비밀값을 넣지 않는다.
+- deep-research 를 부른다. 넘기는 질문은 미리 좁히고, 인자에 "추가 질문 금지" 와 "전문가 작업 방식은 lfm 이 맡음" 을 적는다. 범위 질문은 2단계가 맡는다. 질문은 공개 웹 검색어가 되므로 저장소 코드, 내부 이름, 비밀값을 넣지 않는다.
 - 저장소 사실(구조, 시험 명령과 시험 도구, 빌드 방법, 관련 코드 위치, CI)은 읽기 전용 탐색으로 모은다.
 - 둘을 `<run>/01-research.md` 하나로 저장한다. 조사 보고, 그다음 `## 저장소 사실` 절이다. 조사 스킬은 보고를 대화에만 내므로 연쇄가 파일로 남긴다. 수동 경로였다면 충실도 한계를 그대로 옮긴다.
+- 같은 단계에서 `lfm` 을 요청의 분야로 부른다. 인자는 `--no-questions --out <run>/01-masters.md` 다. 그 분야 최고 전문가 그룹이 이 일을 어떻게 하는지와 계획 적용 항목(`M-1` …)이 남는다. 검색어 규칙은 deep-research 와 같다(저장소 코드, 내부 이름, 비밀값을 넣지 않는다).
+- `lfm` 이 "웹 조사 불가" 로 끝나면 `01-masters.md` 에 그 사실만 적고 진행한다. 3단계는 "전문가 작업 방식 없음" 으로 계획한다.
 - 게이트: 살아남은 주장마다 출처가 있고, 폐기된 주장과 한계가 적혀 있다. 주장이 0개면 게이트를 지나지 않은 것이다.
 - deep-research 가 "웹 조사 불가" 로 끝나면(네트워크 없음) 이 단계를 `skipped` 와 이유 "네트워크 없음" 으로 기록하고, 저장소 사실만 `01-research.md` 에 남긴 채 2단계로 간다. 사용자에게는 웹 조사를 하지 못했다고 알린다.
 - `--skip=research` 면 이 단계를 `skipped` 로 기록한다. 2단계의 ultra-interview 가 자기 조사를 한다.
 
 ## 2. 모호성 제거
 
-- ultra-interview 를 부른다. `01-research.md` 를 근거로 넘기고, 거기서 답하지 못한 항목만 더 조사하게 한다.
+- ultra-interview 를 부른다. `01-research.md` 와 `01-masters.md` 를 근거로 넘기고, 거기서 답하지 못한 항목만 더 조사하게 한다. `01-masters.md` 가 있으면 `lfm` 을 다시 부르지 말라고 적는다.
 - `--auto` 면 인자에 "사람에게 묻지 않는다. P 항목은 보수적 가정으로 답하고 가정임을 표시한다" 를 넣는다. 이 지시는 ultra-interview 의 "가정을 사람이 훑기 전에는 판정하지 않는다" 규칙보다 앞선다. 사용자가 `--auto` 로 묻지 말라고 명시했기 때문이다. 그래서 이 결과는 통과가 아니라 "사람 확인 없음" 으로 기록한다. 보수적인 쪽이 없는 핵심 P(기능의 뜻 자체를 정하는 항목)가 남으면 멈추고 보고한다.
 - 결과를 `<run>/02-spec.md` 로 저장한다.
   - 번호 붙은 항목과 E, I, P 분류, 근거(URL, 파일 경로), 답, 가정
@@ -213,7 +216,8 @@ node "<S>/references/chain-ledger.mjs" event "<run>" --stage research --status d
 ralplan 은 계획 작성자 외에 Architect 와 Critic 두 검토자로 합의하고, 검토자를 늘리는 옵션이 없다. 그래서 ralplan 합의 뒤 ralph-qa 의 독립 검토자 3명 이상이 같은 계획을 다시 판정한다. Architect 와 Critic 은 이 3명에 세지 않는다.
 
 1. ralplan 을 `--deliberate` 로 부른다. `--interactive` 는 주지 않는다. 인자에 아래를 함께 넘긴다.
-   - 요청 원문, `02-spec.md` 경로와 수용 기준, `01-research.md` 경로
+   - 요청 원문, `02-spec.md` 경로와 수용 기준, `01-research.md` 와 `01-masters.md` 경로
+   - 계획에 `## 전문가 작업 방식 적용` 절을 두라는 지시. `01-masters.md` 의 `M-n` 마다 판정(적용, 조정, 제외)과 계획의 어느 단계에 넣었는지, 조정과 제외는 그 이유를 적는다. 판정을 바꾸면(예: `lfm` 이 적용인데 계획은 제외) 이유를 적는다
    - 계획 저장 경로: Claude Code 는 `.omc/plans/ultra-chain-<run id>.md`. Codex 는 OMX 규칙대로 `.omx/plans/` 에 쓴다
    - Codex: 인터뷰가 끝났으니 `$deep-interview` 를 돌리지 말라는 말
    - 계획에 넣을 것
@@ -233,7 +237,7 @@ ralplan 은 계획 작성자 외에 Architect 와 Critic 두 검토자로 합의
    - Claude Code: 1 에서 지정한 경로, 또는 ralplan 이 보고한 계획 경로다. 둘 다 없으면 이 단계가 시작된 뒤 `.omc/plans/` 에 쓰였고 `pending approval` 표지가 있는 파일을 고른다. 검토 문서(이름이 `-critic.md`, `-architect.md`, `-review.md` 로 끝남)와 `open-questions.md` 는 고르지 않는다. 원본 경로는 `summary` 에 적는다.
    - Codex: 이번에 쓰인 `.omx/plans/prd-*.md` 와 `test-spec-*.md` 를 차례로 붙이고, 원본 경로를 맨 위에 적는다.
 4. ralph-qa 를 `--lens=plan --agents=<agents> --max=<max>` 로 부른다. 외부 좌석 플래그(`--codex`, `--gemini`, `--opencode`)는 사용자가 준 것만 넘긴다.
-   - 검증 대상: `03-plan.md`(구현 전이라 `<base>` 대비 diff 가 없으니 원문으로 붙인다). 수용 기준: `02-spec.md` 의 AC 와 deliberate 필수 항목(사전 부검, 확장 시험 계획).
+   - 검증 대상: `03-plan.md`(구현 전이라 `<base>` 대비 diff 가 없으니 원문으로 붙인다). 수용 기준: `02-spec.md` 의 AC 와 deliberate 필수 항목(사전 부검, 확장 시험 계획), 그리고 `01-masters.md` 의 `M-n` 이 모두 `## 전문가 작업 방식 적용` 절에 판정과 함께 있는지(조정과 제외에 이유가 있는지).
    - 모든 좌석의 지시에 "저자의 주장이 틀렸다는 증거를 먼저 찾는 적대적 검토자로 판정한다" 를 넣는다. 렌즈 배정은 ralph-qa 그대로다. ralph-qa 의 기본 배정에서는 적대적 반증 렌즈가 한 좌석뿐이라, 이 문장이 있어야 검토자 모두가 적대적이다.
    - 출처-독립 검토자에게 줄 "사용자 원 요청" 은 `task.md` 와 `02-spec.md` 의 사용자 답변 원문이다.
    - ralph-qa 가 외부 모델을 물으면 여기서 한 번만 고르게 하고, 고른 모델을 기록한다. 6단계에는 `--gemini=<그 모델>` 처럼 값을 박아 넘긴다.
@@ -420,7 +424,7 @@ node "<S>/references/chain-report.mjs" "<run>"
 
 압축(compaction)이나 중단 뒤에는 다음 순서로 잇는다.
 
-1. 이 스킬을 다시 부른다: `--run=<실행 폴더> --from=<단계>`(Claude Code `Skill("banker:ultra-chain")`, Codex `$banker-ultra-chain`). 지시와 `<S>` 를 되찾기 위해서다. 실행 폴더는 이어 하기 메모나 압축 요약에서 찾는다.
+1. 이 스킬을 다시 부른다: `--run=<실행 폴더> --from=<단계>`(Claude Code `Skill("banker:ultra-chain")`, Codex `$banker-ultra-chain`, 플러그인 설치면 `$banker:ultra-chain`). 지시와 `<S>` 를 되찾기 위해서다. 실행 폴더는 이어 하기 메모나 압축 요약에서 찾는다.
 2. `node "<S>/references/chain-ledger.mjs" show "<run>"` 로 `current`(다시 시작할 단계), 단계별 `lastVerdict`(마지막 판정과 blocker), `maxRound` 를 본다. 멈추거나 실패한 실행은 그 단계가 `current` 다. 원래 플래그는 `task.md` 첫 줄과 `preflight` 기록에 있다.
 3. 끊길 때 돌던 작업(박스 시험, 검토 좌석, 서버)이 끝났는지 확인한다. 끝나지 않았으면 알림을 기다리거나 멈춘다. 끊기기 전 실행의 늦은 판정은 쓰지 않는다.
 4. 돌던 ralph-qa 실행은 되살리지 않는다. 좌석과 끈끈한 반대는 한 실행 안에서만 유지되기 때문이다.

package/skills/ultra-interview/SKILL.md

@@ -99,6 +99,16 @@ description: "리서치를 선행해 사람에게 묻는 질문을 최소화하
 - **공식 문서** (해당 기술·제품의 1차 출처)
 - **우수사례 / best practice**
 - **요청에 걸리는 공개 규제 정보** (규정·법령·시행세칙·규칙·기록)
+- **그 분야 최고 전문가 그룹의 작업 방식** (`lfm`)
+
+**전문가 작업 방식 (`lfm`):**
+- 요청의 분야로 `lfm` 을 부른다. 인자에 `--no-questions` 를 준다. 이 스킬처럼 질문을 늘리지 않기 위해서다.
+- 결과의 계획 적용 항목(`M-1` …)을 이 인터뷰에 쓴다.
+  - "적용" 이나 "조정" 판정의 관행이 답하는 항목은 E 로 답한다. 근거는 `lfm` 결과의 1차 출처 URL 이다. 이 작업에 맞는지는 사람이 가정을 훑으며 확인한다.
+  - 품질 기준 후보는 수용 기준 후보로 가정에 넣는다.
+  - 관행이 이 작업과 맞는지 사람의 판단이 필요하면(비용, 팀 구성, 일정) P 로 둔다.
+- 결과에 `## 전문가 작업 방식` 절을 두고, `M-n` 마다 판정과 이 인터뷰의 어느 항목에 반영했는지 적는다. 다음 단계의 계획이 이 절을 그대로 받는다.
+- `lfm` 이 "웹 조사 불가" 로 끝나면 그 사실을 이 절에 적고 진행한다.
 
 **규제 정보 접근 규칙:**
 - **엔드포인트·조회 파라미터·API 키를 하드코딩하지 마라.** 관할·기관·시점마다 다르고 이 스킬은 그것을 검증한 적이 없다. 하드코딩된 경로는 조용히 죽거나, 더 나쁘게는 엉뚱한 문서를 준다.
@@ -108,7 +118,7 @@ description: "리서치를 선행해 사람에게 묻는 질문을 최소화하
 - **규제 해석은 이 스킬의 산출물이 아니다.** 조문을 근거로 항목을 잠글 수는 있어도, 법적 판단이 필요한 자리는 P 로 두고 사람에게 넘긴다.
 
 **`deep-research` 위임:**
-- 넘길 때 **"추가 질문 금지" 를 인자에 명시한다.**
+- 넘길 때 **"추가 질문 금지" 를 인자에 명시한다.** `lfm` 을 따로 부르므로 "전문가 작업 방식은 lfm 이 맡음" 도 적는다.
 - 이유: 명시하지 않으면 사용자는 리서치 단계에서 한 번, 인터뷰 단계에서 또 한 번, 총 두 번 질문받는다. **질문을 줄이려고 부른 리서치가 질문을 늘린다.** 그러면 이 스킬은 존재 이유를 훼손당한다.
 - 넘기는 질문은 **이쪽에서 이미 좁혀서** 넘긴다. 되물을 여지를 안 남기는 것이 인자에 적는 금지보다 확실하다.
 
@@ -144,6 +154,7 @@ E 후보에 리서치를 돌린다. **질문 전이다.**
 - 항목마다 근거 URL 을 붙인다. URL 없는 답은 채택하지 않는다.
 - 검색 수단이 런타임에 없으면 **없다고 보고**하고, E 후보를 전부 P 로 내린 뒤 그 사실을 명시한다.
 - 수단이 있어도 호출이 모두 실패하면(네트워크 없음) 같다. "조사하지 못함: <오류>" 로 보고하고 E 후보를 전부 P 로 내린다.
+- 같은 단계에서 `lfm` 으로 그 분야 전문가 그룹의 작업 방식을 조사한다(위 "전문가 작업 방식" 참조).
 
 ### 2. E/I/P 판정
 전 항목을 분류한다. 애매하면 P.
@@ -230,4 +241,4 @@ E 후보에 리서치를 돌린다. **질문 전이다.**
 
 ARGUMENTS: [--threshold <퍼센트>] [--no-research] [요청/맥락] (없으면 현재 작업의 요청에 적용)
 - `--threshold`: 기본 3%. 올리면 게이트가 무르다. 내리는 것은 항목 33개 이하 구간에서 무의미하다(이미 미해결 0개가 조건이다). 바꿨으면 **바꾼 값을 보고에 적는다.**
-- `--no-research`: 리서치를 끈다. E 축이 죽어 전 항목이 P 로 떨어지고 **질문이 늘어난다.** 이 스킬의 델타 하나가 사라지므로, 켜서 부를 이유가 없으면 쓰지 마라.
+- `--no-research`: 리서치를 끈다(`lfm` 도 부르지 않는다). E 축이 죽어 전 항목이 P 로 떨어지고 **질문이 늘어난다.** 이 스킬의 델타 하나가 사라지므로, 켜서 부를 이유가 없으면 쓰지 마라.

package/skills/ultra-ui-qa/SKILL.md

@@ -11,7 +11,7 @@ description: "웹 UI 를 Playwright 로 렌더해 디자인 원본(PDF 나 스
 ## 0. 전제조건: playwright (없으면 설치부터)
 이 스킬은 playwright 브라우저가 있어야 동작한다. **진행 전 설치 여부를 먼저 확인**하고, 없으면 **설치부터 안내**한다(추정·임의 재설치 금지):
 - 확인: `ls "${PLAYWRIGHT_BROWSERS_PATH:-$HOME/.cache/ms-playwright}" 2>/dev/null | grep -qi chromium && echo ok`
-- 미설치면 먼저 `setup-playwright` 스킬로 설치(Claude Code: `/banker:setup` → setup-playwright / Codex: `banker-setup-playwright`). 설치·검증 후 이 스킬을 이어서 진행한다.
+- 미설치면 먼저 `setup-playwright` 스킬로 설치(Claude Code: `/banker:setup` → setup-playwright / Codex: `banker-setup-playwright`, 플러그인 설치면 `banker:setup-playwright`). 설치·검증 후 이 스킬을 이어서 진행한다.
 
 ## When to use
 - "ultra ui qa", "UI 대조", "디자인 PDF와 대조", "내부개념/어색한 내용 점검", "표 title·차트 크기 비교"