@kaydash9999/banker-plugins 0.23.3 → 0.24.1

package/skills/tune-tmux/scripts/marker-block.mjs

@@ -0,0 +1,321 @@
+/**
+ * marker-block: puts one marked block of lines into a text file, replaces it or takes it out, and leaves every
+ * byte outside the block as it was.
+ *
+ * The canonical copy is skills/init-dir/scripts/marker-block.mjs. tune-tmux and git-init carry byte-identical
+ * copies, since Codex installs every skill folder on its own; scripts/sync-adapter.js mirrors and checks them.
+ * Edit the canonical copy only.
+ *
+ * Policy (one place for every skill that edits a user's file):
+ * - Markers are whole lines `<open> <id>:start <close>` and `<open> <id>:end <close>`, with the comment syntax
+ *   given (`#` or `<!-- -->`). A marker inside a sentence, an unpaired marker, an end before a start or a second
+ *   block is refused: nothing is cut on a guess.
+ * - Bytes outside the block stay as they were. CRLF files get CRLF blocks, a byte order mark stays in front.
+ *   A file that is not UTF-8 is refused.
+ * - A folder, FIFO, socket or device at the name is refused without being read.
+ * - A symbolic link is refused (refused: "symlink") unless followSymlink is set; then the file it leads to is
+ *   written and the link stays a link. A link to nothing is refused either way ("dangling").
+ * - A file with two or more hard links is refused ("hardlink"): the rename below would split them.
+ * - A file owned by another user is refused ("owner"). The permission bits of the file carry over to the new
+ *   file. Windows has no owner or permission bits to check.
+ * - Writes go to a temp file in the same folder and a rename. A failed write removes the temp file.
+ * - When the bytes change, the first original is kept in `<file>.<skill>.bak`; an existing backup is never
+ *   overwritten.
+ *
+ * Results are { ok, changed, refused?, message, path, file }. Callers map refused to exit status 1.
+ */
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+
+/** Comment syntaxes. */
+export const HTML = Object.freeze({ open: "<!--", close: "-->" });
+export const HASH = Object.freeze({ open: "#", close: "" });
+
+const BOM = "\u{FEFF}";
+const UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+const MAX_BYTES = 32 * 1024 * 1024;
+const NEW_FILE_MODE = 0o644;
+const BACKUP_MODE = 0o600;
+
+/** The start and end marker lines for id in a comment syntax. */
+export function markers(comment, id) {
+  const tail = comment.close ? ` ${comment.close}` : "";
+  return { start: `${comment.open} ${id}:start${tail}`, end: `${comment.open} ${id}:end${tail}` };
+}
+
+const refusal = (code, message, path) => ({ ok: false, changed: false, refused: code, message, path });
+const bare = (line) => line.replace(/\r?\n$/, "").replace(/[ \t]+$/, "");
+const eolOf = (text) => (text.includes("\r\n") ? "\r\n" : "\n");
+const readlinkOr = (path) => {
+  try {
+    return readlinkSync(path);
+  } catch {
+    return "?";
+  }
+};
+const nativeReal = (path) => {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return resolve(path);
+  }
+};
+const realOrNull = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+};
+
+// Where the bytes live: the path itself, or with followSymlink the file a link leads to.
+function locate(path, follow) {
+  const lst = lstatSync(path, { throwIfNoEntry: false });
+  if (!lst) return { file: path, exists: false };
+  if (!lst.isSymbolicLink()) return { file: path, exists: true };
+  const target = readlinkOr(path);
+  if (!follow) return { refuse: refusal("symlink", `심볼릭 링크라 그대로 둠: ${path} -> ${target}`, path) };
+  const real = realOrNull(path);
+  if (real === null) return { refuse: refusal("dangling", `끊어진 링크라 그대로 둠: ${path} -> ${target}`, path) };
+  return { file: real, exists: true, link: path };
+}
+
+// Why the file at file may not be read or replaced, or null.
+function fileProblem(st, file, uid) {
+  if (!st.isFile()) return refusal("special", `일반 파일이 아니라 그대로 둠: ${file}`, file);
+  if (st.nlink > 1) return refusal("hardlink", `하드 링크가 ${st.nlink}개라 그대로 둠: ${file}`, file);
+  if (uid !== undefined && st.uid !== uid) return refusal("owner", `다른 사용자 소유라 그대로 둠: ${file}`, file);
+  if (st.size > MAX_BYTES) return refusal("too-big", `32MiB 보다 커서 그대로 둠: ${file}`, file);
+  return null;
+}
+
+// The file's stat and bytes, opened without blocking so a FIFO planted after the look never waits. id: the same
+// file's bigint stat for telling files apart (an NTFS file id passes 2^53, so as a Number two files can share one).
+function readChecked(file, uid) {
+  const first = statSync(file);
+  const problem = fileProblem(first, file, uid);
+  if (problem) return { refuse: problem };
+  const fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+  try {
+    const st = fstatSync(fd);
+    const late = fileProblem(st, file, uid);
+    return late ? { refuse: late } : { st, id: fstatSync(fd, { bigint: true }), bytes: readFileSync(fd) };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// What one line is: "start", "end", "inline" (a marker inside other text) or null.
+function kindOf(line, mk) {
+  const b = bare(line);
+  if (b === mk.start) return "start";
+  if (b === mk.end) return "end";
+  return line.includes(mk.start) || line.includes(mk.end) ? "inline" : null;
+}
+
+// Takes line i of kind into state; returns why the markers are broken, or null.
+function step(state, kind, i) {
+  if (kind === "inline") return `문장 안에 표지가 있음(${i + 1}행)`;
+  if (kind === "start") {
+    if (state.open !== -1 || state.found) return `표지 짝이 맞지 않거나 블록이 둘 이상(${i + 1}행)`;
+    state.open = i;
+  } else if (kind === "end") {
+    if (state.open === -1) return `끝 표지가 시작 표지보다 먼저(${i + 1}행)`;
+    state.found = { first: state.open, last: i };
+    state.open = -1;
+  }
+  return null;
+}
+
+/** The block's first and last line in lines, null when there is none, or { error } when markers are broken. */
+export function findBlock(lines, mk) {
+  const state = { open: -1, found: null };
+  for (let i = 0; i < lines.length; i++) {
+    const error = step(state, kindOf(lines[i], mk), i);
+    if (error) return { error };
+  }
+  if (state.open !== -1) return { error: `짝 없는 시작 표지(${state.open + 1}행)` };
+  return state.found;
+}
+
+// Whether line i sits inside an open wrap region (more wrap opens than closes before it).
+function insideWrap(lines, i, wrap) {
+  let depth = 0;
+  for (let j = 0; j < i; j++) {
+    const b = bare(lines[j]);
+    if (b === wrap.open) depth++;
+    else if (b === wrap.close && depth > 0) depth--;
+  }
+  return depth > 0;
+}
+
+// The span [first, last] widened to wrap lines directly around it, and whether new text must bring its own wrap.
+function spanOf(lines, found, wrap) {
+  if (!wrap) return { ...found, wrapNew: false };
+  const wrapped = found.first > 0 && bare(lines[found.first - 1]) === wrap.open && bare(lines[found.last + 1] ?? "") === wrap.close;
+  if (wrapped) return { first: found.first - 1, last: found.last + 1, wrapNew: true };
+  return { ...found, wrapNew: !insideWrap(lines, found.first, wrap) };
+}
+
+const blockText = (mk, body, wrap, eol) => {
+  const inner = [mk.start, ...body.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n"), mk.end];
+  return [...(wrap ? [wrap.open, ...inner, wrap.close] : inner), ""].join(eol);
+};
+
+// The text with the block put in, replaced or (body null) taken out. Appending puts one line break between the
+// text and the block; taking a block out at the end of the file takes that break back, so add then remove gives
+// the bytes from before.
+function render(text, found, o) {
+  const lines = text.split(/(?<=\n)/);
+  const eol = eolOf(text);
+  if (!found) {
+    if (o.body === null) return text;
+    return text === "" ? blockText(o.mk, o.body, o.wrap, eol) : text + eol + blockText(o.mk, o.body, o.wrap, eol);
+  }
+  const span = spanOf(lines, found, o.wrap);
+  const before = lines.slice(0, span.first).join("");
+  const after = lines.slice(span.last + 1).join("");
+  if (o.body !== null) return before + blockText(o.mk, o.body, span.wrapNew ? o.wrap : null, eol) + after;
+  return after === "" ? before.replace(/\r?\n$/, "") : before + after;
+}
+
+function checkBody(o) {
+  if (o.body === null) return;
+  const forbidden = [o.mk.start, o.mk.end, ...(o.wrap ? [o.wrap.open, o.wrap.close] : [])];
+  if (o.body.split(/\r?\n/).some((line) => forbidden.includes(bare(line)))) throw new Error("block body holds a marker line");
+}
+
+// The new bytes for the old ones, or { refuse } when the old ones may not be edited.
+function nextBytes(bytes, o, file) {
+  let text;
+  try {
+    text = UTF8.decode(bytes);
+  } catch {
+    return { refuse: refusal("encoding", `UTF-8 이 아니라 그대로 둠: ${file}`, file) };
+  }
+  const bom = text.startsWith(BOM) ? BOM : "";
+  const plain = text.slice(bom.length);
+  const found = findBlock(plain.split(/(?<=\n)/), o.mk);
+  if (found?.error) return { refuse: refusal("markers", `표지 손상이라 그대로 둠: ${file}: ${found.error}`, file) };
+  return { bytes: Buffer.from(bom + render(plain, found, o), "utf8") };
+}
+
+const options = (opts) => ({
+  mk: markers(opts.comment, opts.id),
+  body: opts.body ?? null,
+  wrap: opts.wrap ?? null,
+  skill: opts.skill,
+  follow: opts.followSymlink === true,
+  uid: "uid" in opts ? opts.uid : process.getuid?.(),
+});
+
+/**
+ * Works out what applyBlock would write, without writing: { ok, changed, refused?, message, path, file, key,
+ * before, after, mode }. key names the file (device and inode, or the path of a file not there yet).
+ */
+export function planBlock(path, opts) {
+  const o = options(opts);
+  checkBody(o);
+  const at = locate(path, o.follow);
+  if (at.refuse) return at.refuse;
+  if (!at.exists) {
+    const after = o.body === null ? null : Buffer.from(blockText(o.mk, o.body, o.wrap, "\n"), "utf8");
+    return { ok: true, changed: after !== null, path, file: at.file, key: `path:${resolve(at.file)}`, before: null, after, mode: NEW_FILE_MODE };
+  }
+  const read = readChecked(at.file, o.uid);
+  if (read.refuse) return read.refuse;
+  const next = nextBytes(read.bytes, o, at.file);
+  if (next.refuse) return next.refuse;
+  const changed = !next.bytes.equals(read.bytes);
+  // ino 0 (a file system without file ids) tells nothing apart: then the path as the file system spells it is the
+  // key (realpathSync.native gives one spelling for names that differ only in case where case is ignored).
+  const key = read.id.ino === 0n ? `path:${nativeReal(at.file)}` : `ino:${read.id.dev}:${read.id.ino}`;
+  return { ok: true, changed, path, file: at.file, key, before: read.bytes, after: next.bytes, mode: read.st.mode & 0o7777 };
+}
+
+// Writes data to a fresh temp file beside file and renames it over file.
+function writeAtomic(file, data, mode) {
+  const tmp = join(dirname(file), `.${basename(file)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`);
+  let fd = openSync(tmp, "wx", mode);
+  try {
+    writeFileSync(fd, data);
+    closeSync(fd);
+    fd = null;
+    if (process.platform !== "win32") chmodSync(tmp, mode);
+    renameSync(tmp, file);
+  } catch (e) {
+    if (fd !== null) closeSync(fd);
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+// Keeps the first original: writes <file>.<skill>.bak only when nothing is at that name yet.
+function backup(file, skill, bytes) {
+  const bak = `${file}.${skill}.bak`;
+  if (lstatSync(bak, { throwIfNoEntry: false })) return null;
+  const fd = openSync(bak, "wx", BACKUP_MODE);
+  try {
+    writeFileSync(fd, bytes);
+  } finally {
+    closeSync(fd);
+  }
+  return bak;
+}
+
+/** Writes what planBlock worked out. A plan that changes nothing or was refused is returned as a result. */
+export function commitBlock(plan, skill) {
+  if (!plan.ok) return plan;
+  const result = { ok: true, changed: plan.changed, path: plan.path, file: plan.file };
+  if (!plan.changed) return { ...result, message: `변경 없음: ${plan.path}` };
+  if (plan.before === null && plan.after !== null) {
+    const fd = openSync(plan.file, "wx", plan.mode);
+    try {
+      writeFileSync(fd, plan.after);
+    } finally {
+      closeSync(fd);
+    }
+    return { ...result, created: true, message: `새로 만듦: ${plan.path}` };
+  }
+  const bak = backup(plan.file, skill, plan.before);
+  writeAtomic(plan.file, plan.after, plan.mode);
+  return { ...result, backup: bak, message: `바꿈: ${plan.path}` };
+}
+
+/** Puts in, replaces or (body null) takes out the block in one file. dryRun plans only. */
+export function applyBlock(path, opts) {
+  const plan = planBlock(path, opts);
+  if (opts.dryRun || !plan.ok) return plan;
+  return commitBlock(plan, opts.skill);
+}
+
+/**
+ * Applies blocks to several files, each entry { path, ...opts }. Every file is planned first: one refusal and
+ * none is written. Two entries naming one file (after links are followed) write it once, by the first entry.
+ */
+export function applyBlocks(entries, { dryRun = false } = {}) {
+  const plans = entries.map((e) => ({ entry: e, plan: planBlock(e.path, e) }));
+  const refused = plans.filter((p) => !p.plan.ok).map((p) => p.plan);
+  if (refused.length > 0) return { ok: false, refused, results: plans.map((p) => p.plan) };
+  const seen = new Map();
+  const results = plans.map(({ entry, plan }) => {
+    if (seen.has(plan.key)) return { ok: true, changed: false, path: plan.path, file: plan.file, sameAs: seen.get(plan.key), message: `같은 파일이라 한 번만 씀: ${plan.path}` };
+    seen.set(plan.key, plan.path);
+    return dryRun ? plan : commitBlock(plan, entry.skill);
+  });
+  return { ok: true, refused: [], results };
+}

package/skills/tune-tmux/scripts/psmux-caps.json

@@ -0,0 +1,71 @@
+{
+  "psmux": "3.3.8",
+  "probed": "2026-11-01, Windows 10 22H2 test box, psmux 3.3.8 (winget marlocarlo.psmux)",
+  "rule": "A line goes into the block only when verified is true and default is not true (psmux already has it).",
+  "behavior": {
+    "default": ["마우스(mouse on)", "set-clipboard on", "휠로 copy-mode 진입(scroll-enter-copy-mode on)"],
+    "unverified": [
+      "드래그한 글이 Windows 클립보드로 가는지(실제 마우스와 데스크톱이 필요해 미실측)",
+      "전체 화면 앱(Claude Code, Codex) 안의 PageUp/PageDown 을 앱이 받는지(미실측)"
+    ],
+    "broken": [
+      "앱 밖(셸) PageUp 은 prefix 뒤에만 copy-mode 진입. 루트 PageUp 바인딩은 넣지 않음",
+      "PageDown 이 바닥에서 copy-mode 를 빠지지 않음(-e 미지원, Escape 로 빠짐)",
+      "#{alternate_on} 이 늘 0 이라 전체 화면 앱을 구분하지 못함(앱 구분 바인딩 불가)"
+    ]
+  },
+  "options": [
+    {
+      "id": "mouse",
+      "line": "set -g mouse on",
+      "verified": true,
+      "default": true,
+      "note": "psmux 기본값이 on. 블록에 넣지 않음"
+    },
+    {
+      "id": "set-clipboard",
+      "line": "set -s set-clipboard on",
+      "verified": true,
+      "default": true,
+      "note": "psmux 기본값이 on. show -s 는 show -g 와 같음"
+    },
+    {
+      "id": "scroll-enter-copy-mode",
+      "line": "set -g scroll-enter-copy-mode on",
+      "verified": true,
+      "default": true,
+      "note": "psmux 기본값이 on"
+    },
+    {
+      "id": "page-up",
+      "line": "bind -n PPage if -F \"#{||:#{alternate_on},#{pane_in_mode}}\" \"send-keys PPage\" \"copy-mode -e -u\"",
+      "verified": false,
+      "note": "등록, copy-mode 진입, 스크롤은 됨. 그러나 Windows 10 에서 #{alternate_on} 이 늘 0 이라 전체 화면 앱의 PageUp 을 빼앗음. 바닥에서 빠지는 -e 미지원"
+    },
+    {
+      "id": "page-up-joined-flags",
+      "line": "bind -n PPage copy-mode -eu",
+      "verified": false,
+      "note": "붙인 짧은 플래그를 풀지 못해 -eu 가 사라짐"
+    },
+    {
+      "id": "copy-command",
+      "line": "set -s copy-command 'clip.exe'",
+      "verified": false,
+      "note": "값 저장만 확인. 드래그 복사에 쓰는지 미확인"
+    },
+    {
+      "id": "copy-pipe",
+      "line": "bind -T copy-mode MouseDragEnd1Pane send -X copy-pipe-and-cancel 'clip.exe'",
+      "verified": false,
+      "note": "경고 없이 버려짐"
+    },
+    {
+      "id": "force-drag",
+      "line": "bind -n MouseDrag1Pane if -F \"#{pane_in_mode}\" \"send-keys -M\" \"copy-mode -M\"",
+      "verified": false,
+      "forceDrag": true,
+      "note": "경고 없이 버려짐"
+    }
+  ]
+}

package/skills/tune-tmux/scripts/tmux-config.mjs

@@ -0,0 +1,251 @@
+/**
+ * tmux-config: what tune-tmux knows about tmux and psmux. Tool and version detection, the clipboard command,
+ * which config files are read, the block lines, conflicting lines in other files and the commands that take
+ * block lines back out of a running server.
+ *
+ * Every function that runs a program takes `exec(cmd, args)` returning { status, stdout, stderr, error }, so the
+ * tests can stand in for tmux on every OS. No network is used.
+ */
+import { accessSync, constants, lstatSync, readFileSync, rmSync, statSync } from "node:fs";
+import { devNull, homedir } from "node:os";
+import { basename, delimiter, join, resolve } from "node:path";
+
+/** The tool and version in `tmux -V` output. psmux says "tmux 3.3.8" on line 1 and "psmux" on line 2. */
+export function parseVersion(text) {
+  const out = String(text ?? "");
+  const first = out.split(/\r?\n/)[0].trim();
+  if (!/^(tmux|psmux)\s/i.test(first)) return null;
+  const kind = /psmux/i.test(out) ? "psmux" : "tmux";
+  const m = /(\d+)\.(\d+)/.exec(first);
+  return m ? { kind, major: Number(m[1]), minor: Number(m[2]), raw: first } : { kind, major: 99, minor: 0, raw: first };
+}
+
+/** Whether version v is at least major.minor. */
+export const atLeast = (v, major, minor) => v.major > major || (v.major === major && v.minor >= minor);
+
+/** The tool behind bin, or null when it does not run. */
+export function toolVersion(exec, bin) {
+  const r = exec(bin, ["-V"]);
+  if (r.error || r.status !== 0) return null;
+  const v = parseVersion(`${r.stdout ?? ""}\n${r.stderr ?? ""}`);
+  return v ? { ...v, bin } : null;
+}
+
+/** The home folder psmux and tmux use: USERPROFILE first on Windows, HOME elsewhere. */
+export function homeOf(env, platform) {
+  const first = platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME;
+  return first || homedir();
+}
+
+// Whether p is a file this user may run (Windows: any file).
+function runnable(p, platform) {
+  try {
+    if (!statSync(p).isFile()) return false;
+    if (platform !== "win32") accessSync(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The path of an executable name in env.PATH, or null. */
+export function which(name, env, platform = process.platform) {
+  const exts = platform === "win32" ? ["", ...String(env.PATHEXT || ".EXE;.CMD;.BAT").split(";")] : [""];
+  for (const dir of String(env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const p = join(dir, name + ext);
+      if (runnable(p, platform)) return p;
+    }
+  }
+  return null;
+}
+
+const CLIPBOARDS = [
+  { tool: "pbcopy", cmd: "pbcopy", when: (o) => o.platform === "darwin" },
+  { tool: "wl-copy", cmd: "wl-copy", when: (o) => Boolean(o.env.WAYLAND_DISPLAY) },
+  { tool: "xclip", cmd: "xclip -selection clipboard -in", when: (o) => Boolean(o.env.DISPLAY) },
+  { tool: "xsel", cmd: "xsel -ib", when: (o) => Boolean(o.env.DISPLAY) },
+  { tool: "clip.exe", cmd: "clip.exe", when: (o) => Boolean(o.env.WSL_DISTRO_NAME || o.env.WSL_INTEROP) },
+];
+
+/** The OS clipboard command: macOS pbcopy, Wayland wl-copy, X11 xclip then xsel, WSL clip.exe; or null. */
+export function pickClipboard({ platform, env, has }) {
+  const hit = CLIPBOARDS.find((c) => c.when({ platform, env }) && has(c.tool));
+  return hit ? { tool: hit.tool, cmd: hit.cmd } : null;
+}
+
+const exists = (p) => lstatSync(p, { throwIfNoEntry: false }) !== undefined;
+
+/** The config files tmux reads by itself, in order. Measured: 3.6a reads every one there; 2.7 only ~/.tmux.conf. */
+export function tmuxReads(v, env, home) {
+  const files = [join(home, ".tmux.conf")];
+  if (v && !atLeast(v, 3, 1)) return files;
+  if (env.XDG_CONFIG_HOME) files.push(join(env.XDG_CONFIG_HOME, "tmux", "tmux.conf"));
+  files.push(join(home, ".config", "tmux", "tmux.conf"));
+  return [...new Set(files.map((f) => resolve(f)))];
+}
+
+/** The tmux file for the block: --conf, else the first of tmuxReads that is there, else ~/.tmux.conf. */
+export function chooseTmuxConf(v, env, home, conf) {
+  if (conf) return resolve(conf);
+  return tmuxReads(v, env, home).find(exists) ?? resolve(join(home, ".tmux.conf"));
+}
+
+/** psmux reads one file: -f, PSMUX_CONFIG_FILE, then the first there of these four (measured on psmux 3.3.8). */
+function psmuxCandidates(home) {
+  return [join(home, ".psmux.conf"), join(home, ".psmuxrc"), join(home, ".tmux.conf"), join(home, ".config", "psmux", "psmux.conf")];
+}
+
+export function choosePsmuxConf(env, home, conf) {
+  if (conf) return resolve(conf);
+  if (env.PSMUX_CONFIG_FILE) return resolve(env.PSMUX_CONFIG_FILE);
+  return resolve(psmuxCandidates(home).find(exists) ?? join(home, ".psmux.conf"));
+}
+
+export const PAGE_UP = 'bind -n PPage if -F "#{||:#{alternate_on},#{pane_in_mode}}" "send-keys PPage" "copy-mode -eu"';
+export const FORCE_DRAG = 'bind -n MouseDrag1Pane if -F "#{pane_in_mode}" "send-keys -M" "copy-mode -M"';
+export const HEADER = "# banker tune-tmux: mouse drag copy and PageUp scroll. Remove with: tune-tmux off";
+
+// The lines that send a finished mouse selection to the OS clipboard, for this version.
+function copyLines(v, clipboard) {
+  if (!clipboard) return { lines: [], omitted: [{ what: "copy-command", reason: "외부 클립보드 도구 없음, 터미널의 OSC 52 허용 필요" }] };
+  if (atLeast(v, 3, 2)) return { lines: [`set -s copy-command '${clipboard.cmd}'`], omitted: [] };
+  if (atLeast(v, 2, 4)) {
+    const pipe = (t) => `bind -T ${t} MouseDragEnd1Pane send -X copy-pipe-and-cancel '${clipboard.cmd}'`;
+    return { lines: [pipe("copy-mode"), pipe("copy-mode-vi")], omitted: [] };
+  }
+  return { lines: [], omitted: [{ what: "copy-pipe", reason: `tmux ${v.major}.${v.minor} 는 send -X 가 없음(2.4 이상 필요)` }] };
+}
+
+/** The tmux block: { lines, omitted }. conditional is whether #{||:} works (probeConditional). */
+export function tmuxBody({ version, clipboard, conditional, forceDrag }) {
+  const copy = copyLines(version, clipboard);
+  const lines = [HEADER, "set -g mouse on", "set -s set-clipboard on", ...copy.lines];
+  const omitted = [...copy.omitted];
+  if (conditional) lines.push(PAGE_UP);
+  else omitted.push({ what: "PageUp", reason: "이 tmux 는 #{||:} 조건식을 읽지 못함. PageUp 줄을 넣으면 전체 화면 앱의 PageUp 을 빼앗으므로 넣지 않음" });
+  if (forceDrag) lines.push(FORCE_DRAG);
+  return { lines, omitted };
+}
+
+/** The psmux block from the caps table: verified lines psmux does not already have. Empty means no block. */
+export function psmuxBody(caps, forceDrag) {
+  const wanted = caps.options.filter((o) => !o.forceDrag || forceDrag);
+  const lines = wanted.filter((o) => o.verified === true && o.default !== true).map((o) => o.line);
+  const omitted = wanted
+    .filter((o) => !(o.verified === true && o.default !== true))
+    .map((o) => ({ what: o.id, reason: o.default === true ? `psmux 기본값과 같음: ${o.note}` : `psmux ${caps.psmux} 에서 확인 안 됨: ${o.note}` }));
+  return { lines: lines.length > 0 ? [HEADER, ...lines] : [], omitted, behavior: psmuxBehavior(caps) };
+}
+
+/** What psmux does with its defaults: { default, unverified, broken } lists of text (empty when caps has none). */
+function psmuxBehavior(caps) {
+  const b = caps.behavior ?? {};
+  const list = (v) => (Array.isArray(v) ? v : []);
+  return { default: list(b.default), unverified: list(b.unverified), broken: list(b.broken) };
+}
+
+// The socket file of a private server, removed after kill-server (tmux leaves it behind; measured 2.7 and 3.6a).
+function removeSocket(path, sock) {
+  if (!path || basename(path) !== sock) return;
+  if (lstatSync(path, { throwIfNoEntry: false })?.isSocket()) rmSync(path, { force: true });
+}
+
+/** Runs fn(sock) against a private server started with no config, then kills it: { value } or { error }. */
+function withPrivateServer(exec, bin, fn) {
+  const sock = `banker-tune-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  const up = exec(bin, ["-L", sock, "-f", devNull, "new-session", "-d", "-s", "probe", "-x", "80", "-y", "24"]);
+  if (up.error || up.status !== 0) return { error: `사설 서버를 띄우지 못함: ${firstLine(up)}` };
+  const path = String(exec(bin, ["-L", sock, "display-message", "-p", "-t", "probe", "#{socket_path}"]).stdout ?? "").trim();
+  try {
+    return { value: fn(sock) };
+  } finally {
+    exec(bin, ["-L", sock, "kill-server"]);
+    removeSocket(path, sock);
+  }
+}
+
+/** Whether #{||:} works, asked of a private server: { ok, reason? }. */
+export function probeConditional(exec, bin) {
+  const r = withPrivateServer(exec, bin, (sock) => exec(bin, ["-L", sock, "display-message", "-p", "-t", "probe", "#{||:0,1}#{||:0,0}"]));
+  if (r.error) return { ok: false, reason: r.error };
+  return { ok: r.value.status === 0 && String(r.value.stdout).trim() === "10" };
+}
+
+export const firstLine = (r) => String(r.error?.message || r.stderr || r.stdout || "").trim().split(/\r?\n/)[0];
+
+const CONFLICTS = [
+  { what: "mouse off", test: (t) => isSet(t, "mouse", "off") },
+  { what: "set-clipboard off", test: (t) => isSet(t, "set-clipboard", "off") },
+  { what: "루트 PPage 바인딩", test: (t) => isRootBind(t, "PPage") },
+];
+const isSet = (t, name, value) => ["set", "set-option"].includes(t[0]) && t.indexOf(name) > 0 && t[t.indexOf(name) + 1] === value;
+const isRootBind = (t, key) => ["bind", "bind-key"].includes(t[0]) && (t.includes("-n") || t[t.indexOf("-T") + 1] === "root") && t.includes(key);
+
+/** Warnings for lines in other files tmux reads that undo the block (mouse off, set-clipboard off, PPage). */
+export function conflictsIn(files) {
+  const warnings = [];
+  for (const file of files) {
+    let text;
+    try {
+      if (!statSync(file).isFile() || statSync(file).size > 1024 * 1024) continue;
+      text = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    text.split(/\r?\n/).forEach((line, i) => {
+      const t = line.trim().split(/\s+/);
+      for (const c of CONFLICTS) if (c.test(t)) warnings.push(`경고: ${file}:${i + 1} 에 ${c.what}. tmux 가 이 파일도 읽으므로 블록보다 나중에 읽히면 블록 설정을 덮음`);
+    });
+  }
+  return warnings;
+}
+
+/** The body lines of the block in text (marker lines excluded), or [] when there is none. */
+export function blockLinesOf(text, mk) {
+  const lines = String(text).replace(/^\u{FEFF}/u, "").split(/\r?\n/);
+  const first = lines.findIndex((l) => l.trimEnd() === mk.start);
+  const last = lines.findIndex((l) => l.trimEnd() === mk.end);
+  return first !== -1 && last > first ? lines.slice(first + 1, last) : [];
+}
+
+// What a block line changes: an option ({ scope, name }) or a key ({ table, key }), or null for a comment.
+function effectOf(line) {
+  const set = /^set\s+-([gs])\s+(\S+)\s/.exec(line);
+  if (set) return { id: `opt:${set[1]}:${set[2]}`, undo: `set -${set[1]}u ${set[2]}` };
+  const bind = /^bind\s+(?:-n|-T\s+(\S+))\s+(\S+)\s/.exec(line);
+  if (bind) return { id: `key:${bind[1] ?? "root"}:${bind[2]}`, table: bind[1] ?? "root", key: bind[2] };
+  return null;
+}
+
+// The list-keys lines of the keys asked, from tables of a private server.
+function readKeys(exec, bin, sock, keys) {
+  const found = new Map(keys.map((k) => [`${k.table} ${k.key}`, null]));
+  for (const table of new Set(keys.map((k) => k.table))) {
+    for (const line of String(exec(bin, ["-L", sock, "list-keys", "-T", table]).stdout ?? "").split(/\r?\n/)) {
+      const m = /^bind-key\s+(?:-r\s+)?-T\s+(\S+)\s+(\S+)\s/.exec(line);
+      if (m && found.has(`${m[1]} ${m[2]}`)) found.set(`${m[1]} ${m[2]}`, line.trim());
+    }
+  }
+  return found;
+}
+
+/** The default bindings of a fresh private server for the keys asked: Map "table key" -> list-keys line or null. */
+export function defaultKeys(exec, bin, keys) {
+  if (keys.length === 0) return new Map();
+  const r = withPrivateServer(exec, bin, (sock) => readKeys(exec, bin, sock, keys));
+  return r.value ?? new Map();
+}
+
+/**
+ * The commands that take the effect of oldLines out of a server when newLines replace them: options are unset,
+ * keys get their default binding back (from defaults) or are unbound. Lines also in newLines are left alone.
+ */
+export function undoCommands(oldLines, newLines, defaults) {
+  const kept = new Set(newLines.map(effectOf).filter(Boolean).map((e) => e.id));
+  const gone = oldLines.map(effectOf).filter((e) => e && !kept.has(e.id));
+  return gone.map((e) => e.undo ?? defaults.get(`${e.table} ${e.key}`) ?? `unbind -T ${e.table} ${e.key}`);
+}
+
+/** The keys among block lines, for defaultKeys. */
+export const keysOf = (lines) => lines.map(effectOf).filter((e) => e?.key);