@kaydash9999/banker-plugins 0.18.0 → 0.19.0

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

@@ -33,17 +33,28 @@
  * 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.
+ * would lose its bytes. A folder or FIFO at a file's name is never read: a
+ * FIFO would make the read wait forever. Nor is a socket or a link loop; and an
+ * AGENTS.md that is a link to nothing is refused by turnOn, which would
+ * otherwise create the file the link points at.
+ *
+ * Codex's files are read and written under a lock file (.banker-agents.lock in
+ * the Codex folder), so both skills turned on at once keep both blocks; a lock
+ * older than a minute is taken over.
  *
  * Results are { ok, message }; ok false means refused with nothing changed.
  * Anything else that goes wrong throws.
  */
 import {
   accessSync,
+  closeSync,
   constants,
+  fstatSync,
   lstatSync,
+  openSync,
   mkdirSync,
   readFileSync,
+  realpathSync,
   renameSync,
   rmSync,
   statSync,
@@ -60,8 +71,12 @@ 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");
+/** The text without the byte order mark an editor may put in front of it. */
+export const noBom = (text) => (text.startsWith(BOM) ? text.slice(BOM.length) : text);
+/** The text with CRLF line ends turned into LF. */
+export const lf = (text) => text.replace(/\r\n/g, "\n");
+/** How many times needle occurs in text. */
+export const count = (text, needle) => text.split(needle).length - 1;
 const eolOf = (text) => (text.includes("\r\n") ? "\r\n" : "\n");
 const isDir = (path) => {
   try {
@@ -80,27 +95,61 @@ const isLink = (path) => {
 
 const UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 
+// What sits at a name that is not a regular file: a folder, a FIFO or a device.
+// It is never read; reading a FIFO waits for a writer.
+const SPECIAL = Object.freeze({ bytes: null, text: null, special: true });
+// What sits at a name that is a link to nothing: Codex finds no file there, and writing would follow the link.
+const DANGLING = Object.freeze({ bytes: null, text: null, dangling: true });
+// What opening a name fails with when no regular file can be there: links that loop (ELOOP) or a socket (ENXIO,
+// EOPNOTSUPP). macOS answers a socket with errno 102, which Node 22 does not name ("Unknown system error -102"), so
+// the kind of what is there decides too.
+const NOT_A_FILE = new Set(["ELOOP", "ENXIO", "EOPNOTSUPP"]);
+// Whether path leads to something that is there and is no regular file: a folder, a socket, a FIFO or a device.
+const notAFile = (path) => {
+  try {
+    return !statSync(path).isFile();
+  } catch {
+    return false;
+  }
+};
+
+// What a failed open of path means: null for nothing there, DANGLING for a link to nothing, SPECIAL for a folder,
+// a socket or a link loop. Any other failure (permissions) is not "missing" and propagates.
+function openFailure(path, e) {
+  if (e.code === "ENOENT" || e.code === "ENOTDIR") return isLink(path) ? DANGLING : null;
+  if (e.code === "EISDIR" || NOT_A_FILE.has(e.code) || notAFile(path)) return SPECIAL;
+  throw e;
+}
+
 // 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.
+// them with U+FFFD for good. A folder, a socket, a link loop or anything but a
+// regular file is SPECIAL, and a link to nothing is DANGLING: the name is
+// opened without blocking and not read.
 function readFile(path) {
-  let bytes;
+  let fd;
   try {
-    bytes = readFileSync(path);
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
   } catch (e) {
-    if (e.code === "ENOENT" || e.code === "ENOTDIR") return null;
-    throw e;
+    return openFailure(path, e);
   }
   try {
-    return { bytes, text: UTF8.decode(bytes) };
-  } catch {
-    return { bytes, text: null };
+    if (!fstatSync(fd).isFile()) return SPECIAL;
+    const bytes = readFileSync(fd);
+    try {
+      return { bytes, text: UTF8.decode(bytes) };
+    } catch {
+      return { bytes, text: null };
+    }
+  } finally {
+    closeSync(fd);
   }
 }
 
-const done = (message) => ({ ok: true, message });
-const refuse = (message) => ({ ok: false, message });
+/** A result that did, or found already done, what was asked. */
+export const done = (message) => ({ ok: true, message });
+/** A result that refused and changed nothing. */
+export 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) {
@@ -144,9 +193,14 @@ export const denied = (e) => e.code === "EACCES" || e.code === "EPERM" || e.code
  * 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.
+ * So do letters that print as nothing (default-ignorable ones such as U+3164),
+ * the braille blank and spaces other than the ASCII one, which hide text as blanks.
  */
 export const where = (value) =>
-  String(value).replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Co}\p{Cn}\p{Variation_Selector}]/gu, "?");
+  String(value).replace(
+    /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Co}\p{Cn}\p{Variation_Selector}\p{Default_Ignorable_Code_Point}\u{2800}\u{a0}\u{1680}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]/gu,
+    "?",
+  );
 
 // ---- Claude Code: one rules file that is banker's alone ----
 
@@ -156,7 +210,7 @@ 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 === null || file.dangling) return "off";
   if (file.text === null) return "foreign";
   const body = lf(noBom(file.text));
   if (!body.startsWith(t.ownerMark)) return "foreign";
@@ -317,25 +371,48 @@ const otherBlocks = (t, text) =>
     return spans !== null && spans.length > 0;
   });
 
+const special = (f) => f.special === true;
 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));
 
+/** Whether two bigint stats name one file: one device and one inode, where the file system gives inodes at all. */
+export const sameInode = (x, y) => x.ino !== 0n && x.dev === y.dev && x.ino === y.ino;
+
+// Whether two paths name one file: a link (both resolve to one real path) or a hard link (one inode). A file system
+// that gives no inode numbers (0) cannot say so for hard links, so those count as two files.
+function sameFile(a, b) {
+  try {
+    if (realpathSync(a) === realpathSync(b)) return true;
+    return sameInode(statSync(a, { bigint: true }), statSync(b, { bigint: true }));
+  } catch {
+    return false;
+  }
+}
+
 // 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.
+// An override that is a link or a hard link to AGENTS.md is one file with it.
 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: [] };
+    if (file === null || file.special || file.dangling) {
+      return { path, bytes: null, text: null, spans: [], special: file?.special === true, dangling: file?.dangling === true };
+    }
     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");
+  if (override.bytes !== null && main.bytes !== null && sameFile(override.path, main.path)) {
+    // One file under both names: Codex reads it either way, so it is AGENTS.md alone.
+    const none = { path: override.path, bytes: null, text: null, spans: [] };
+    return { target: main, other: none, all: [none, main], shadowers: [] };
+  }
   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);
@@ -357,18 +434,26 @@ function withBlock(t, text, rules) {
   return text === "" ? blockFor(t, rules, eol) : text + eol + blockFor(t, rules, eol);
 }
 
+// The state when the block is not in its place: "hidden" (only in an override with no text of its own),
+// "misplaced" (only in AGENTS.md while Codex reads the override), "dangling" (nowhere, and AGENTS.md is a link to
+// nothing that on must not write through) or "off".
+function placeState(files) {
+  if (hasBlock(files.other)) return files.other === files.all[0] ? "hidden" : "misplaced";
+  return files.target.dangling ? "dangling" : "off";
+}
+
 // "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".
+// applied but hiding AGENTS.md), "dangling" (nowhere, and AGENTS.md is a link to
+// nothing), "unpaired", "notutf8" or "notregular" (a folder, FIFO, socket or
+// link loop at a file's name). Without rules any block in its place counts as "on".
 function codexState(t, files, rules) {
+  if (files.all.some(special)) return "notregular";
   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 (!hasBlock(files.target)) return placeState(files);
   if (rules === undefined) return "on";
-  return blockCurrent(t, files.target, rules) && !inOther ? "on" : "stale";
+  return blockCurrent(t, files.target, rules) && !hasBlock(files.other) ? "on" : "stale";
 }
 
 // Why these files cannot be written, or "" when they can. The folder counts
@@ -390,15 +475,103 @@ function writeBlocked(changes) {
 // 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.
+// 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.
 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 });
+    if (after === "" && !isLink(file.path) && !hasOtherNames(file.path)) rmSync(file.path, { force: true });
     else writeFileSync(file.path, after, { mode: 0o644 });
   }
 }
 
+// Whether the file at path is also reachable under another name: a hard link.
+function hasOtherNames(path) {
+  try {
+    return lstatSync(path).nlink > 1;
+  } catch {
+    return false;
+  }
+}
+
+// The lock both banker skills take while they read and write Codex's instructions files: two on's at once would
+// each write the file back with only their own block. A lock is held for milliseconds; one older than a minute was
+// left by a run that died.
+const LOCK = ".banker-agents.lock";
+const LOCK_STALE_MS = 60_000;
+const LOCK_STEP_MS = 50;
+const SLEEP = new Int32Array(new SharedArrayBuffer(4));
+
+// Makes the lock file; false when one is there already. Anything else (permissions) throws.
+function tryLock(path, token) {
+  try {
+    writeFileSync(path, token, { flag: "wx", mode: 0o600 });
+    return true;
+  } catch (e) {
+    if (e.code === "EEXIST") return false;
+    throw e;
+  }
+}
+
+// Removes a lock a dead run left; true when there is none now, so the next try may take it. The name itself is
+// looked at, not where it leads: a link to nothing or a link loop there is a lock like any other. A lock dated more
+// than a minute away either way (a clock set back) is stale too. A folder there is none of this module's: it stays,
+// and the wait ends in a refusal.
+function dropStale(path) {
+  let st;
+  try {
+    st = lstatSync(path);
+  } catch (e) {
+    if (e.code === "ENOENT") return true; /* gone in between */
+    throw e;
+  }
+  if (st.isDirectory() || Math.abs(Date.now() - st.mtimeMs) <= LOCK_STALE_MS) return false;
+  rmSync(path, { force: true });
+  return true;
+}
+
+// Takes the lock: { path, token }, or null when another run held it for waitMs. The deadline is looked at every
+// round, so no lock spot, whatever is there, keeps the wait going past it.
+function takeLock(dir, waitMs) {
+  const path = join(dir, LOCK);
+  const token = `${process.pid} ${Date.now()} ${Math.random()}`;
+  const until = Date.now() + waitMs;
+  for (;;) {
+    if (tryLock(path, token)) return { path, token };
+    if (Date.now() >= until) return null;
+    if (!dropStale(path)) Atomics.wait(SLEEP, 0, 0, LOCK_STEP_MS);
+  }
+}
+
+// Gives the lock back while it is still this run's. The name is opened without blocking: a pipe put there is not
+// this run's lock and stays.
+function dropLock(lock) {
+  try {
+    if (readFile(lock.path)?.text === lock.token) rmSync(lock.path, { force: true });
+  } catch {
+    /* already gone */
+  }
+}
+
+// Runs fn holding the lock; a lock another run keeps past the wait is a refusal. A folder this account cannot write
+// takes no lock, and nothing in it can be written either: fn then only reads, and writeBlocked refuses any change,
+// so "already on" and "already off" answer as before.
+function locked(o, fn) {
+  let lock;
+  try {
+    lock = takeLock(o.codexDir, o.lockWaitMs ?? 5000);
+  } catch (e) {
+    if (denied(e)) return fn();
+    throw e;
+  }
+  if (!lock) return refuse(`다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다: ${where(join(o.codexDir, LOCK))}`);
+  try {
+    return fn();
+  } finally {
+    dropLock(lock);
+  }
+}
+
 const OMX_NOTE =
   "참고: omx setup 이 AGENTS.md 를 새로 만들면(--force, 덮어쓰기 확인, team 모드를 끈 상태의 omx setup) 이 블록이 사라집니다. 그 뒤에는 on 을 다시 실행하세요. --merge-agents 와 기본 omx setup 은 블록을 남깁니다.";
 
@@ -408,35 +581,64 @@ const shadowNote = (files) =>
     ? ""
     : `\n주의: AGENTS.override.md 에 다른 banker 블록(${files.shadowers.join(", ")})만 있어 Codex 가 AGENTS.md 를 읽지 않습니다. 그 스킬에서 on 을 실행해 블록을 옮기세요.`;
 
+// The file a refused state is about: the folder or FIFO, the file that is not UTF-8, or the one whose markers do
+// not pair up; null in any other state.
+function problemFile(files, state) {
+  const which = { notregular: special, notutf8: binary, unpaired }[state];
+  return which ? files.all.find(which) : null;
+}
+
 // 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;
+  const file = problemFile(files, state);
+  if (!file) return null;
+  const why = {
+    notregular: "일반 파일이 아니라 그대로 두었습니다",
+    notutf8: "UTF-8 이 아닌 파일이라 그대로 두었습니다",
+    unpaired: `${t.slug} 표시의 짝이 맞지 않아 그대로 두었습니다`,
+  }[state];
+  return refuse(`${why}: ${where(file.path)}`);
+}
+
+// What codexOn says it did. A block Codex does not read, because other banker
+// blocks alone fill the override, says so in its first words.
+function onWords(t, state, unread) {
+  if (state === "on") return unread ? "이미 AGENTS.md 에 있지만 지금은 적용되지 않습니다 (변경 없음)" : "이미 켜져 있습니다 (변경 없음)";
+  if (unread) return "AGENTS.md 에 넣었지만 지금은 적용되지 않습니다";
+  const moved = "블록을 맞는 파일로 옮겼습니다";
+  return { stale: t.updatedText, misplaced: moved, hidden: moved }[state] ?? "켰습니다. 다음 세션부터 자동 적용됩니다";
 }
 
 function codexOn(t, o, getRules) {
   if (!isDir(o.codexDir)) return refuse(`Codex 설정 폴더가 없습니다: ${where(o.codexDir)}`);
+  return locked(o, () => codexOnHeld(t, o, getRules));
+}
+
+function codexOnHeld(t, o, getRules) {
   const rules = getRules();
   const files = codexFiles(t, o);
   const state = codexState(t, files, rules);
   const refusal = codexRefusal(t, files, state);
   if (refusal) return refusal;
+  if (files.target.dangling) return refuse(`끊어진 링크라 그대로 두었습니다: ${where(files.target.path)}`);
+  const words = onWords(t, state, files.shadowers.length > 0);
   const tail = `${where(files.target.path)}${shadowNote(files)}`;
-  if (state === "on") return done(`Codex: 이미 켜져 있습니다 (변경 없음). ${tail}`);
+  if (state === "on") return done(`Codex: ${words}. ${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}`);
+  return done(`Codex: ${words}. ${tail}${note}`);
 }
 
 function codexOff(t, o) {
   if (!isDir(o.codexDir)) return done(`Codex: 설정 폴더가 없어 끌 것이 없습니다 (변경 없음). ${where(o.codexDir)}`);
+  return locked(o, () => codexOffHeld(t, o));
+}
+
+function codexOffHeld(t, o) {
   const files = codexFiles(t, o);
   const refusal = codexRefusal(t, files, codexState(t, files));
   if (refusal) return refusal;
@@ -445,7 +647,9 @@ function codexOff(t, o) {
   const why = writeBlocked(changes);
   if (why) return refuse(why);
   apply(t, changes);
-  return done(`Codex: 껐습니다. 다음 세션부터 적용되지 않습니다. ${changes.map((c) => where(c.file.path)).join(", ")}`);
+  const paths = changes.map((c) => where(c.file.path)).join(", ");
+  const baks = changes.map((c) => where(`${c.file.path}.${t.slug}.bak`)).join(", ");
+  return done(`Codex: 껐습니다. 다음 세션부터 적용되지 않습니다. ${paths}\n지우기 전 파일: ${baks}`);
 }
 
 // ---- status ----
@@ -458,7 +662,9 @@ const STATE_TEXT = {
   misplaced: "꺼짐, 단 블록이 Codex 가 읽지 않는 AGENTS.md 에 있음 (on 으로 옮김)",
   hidden: "켜짐, 단 AGENTS.override.md 에 블록만 있어 AGENTS.md 가 가려짐 (on 으로 옮김)",
   notutf8: "UTF-8 이 아닌 지침 파일이 있어 손대지 않음 (on, off 모두 거부)",
+  notregular: "일반 파일이 아닌 지침 파일이 있어 손대지 않음 (on, off 모두 거부)",
   unpaired: "표시의 짝이 맞지 않음 (on, off 모두 거부. 남은 표시 줄 정리 필요)",
+  dangling: "꺼짐, 단 AGENTS.md 가 끊어진 링크라 on 이 거부함 (링크 확인 필요)",
 };
 
 // A state as the status line says it.
@@ -486,7 +692,7 @@ function codexLook(t, o, rules) {
   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 };
+  return { state: shadowed ? "shadowed" : state, path: (problemFile(files, state) ?? files.target).path, who: files.shadowers };
 }
 
 /** One status line per runtime: "- Claude Code: ..." and "- Codex: ...". rules may be undefined. */
@@ -507,7 +713,7 @@ export function stateLines(t, o, rules) {
  */
 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)));
+  return isDir(o.codexDir) && !["off", "notutf8", "notregular", "dangling"].includes(codexState(t, codexFiles(t, o)));
 }
 
 const knownRuntime = (runtime) => {

package/skills/lineage/SKILL.md

@@ -2,7 +2,7 @@
 name: lineage
 description: "현재 세션 대화를 카카오톡 스타일의 단일 HTML 로 내보냄. Claude 답변은 한 줄 요약 아래에 원문을 접어 두고, 펼치면 마크다운으로 렌더해 보여 줌. 기본은 세션 모델이 요약을 쓰고 노이즈 턴을 걸러 내며, `--rulebase` 는 모델 없이 규칙만 씀. 여러 세션을 합칠 수 있음. 'lineage'/'대화 export'/'카톡 스타일 html' 시 사용."
 invocation: /lineage
-version: 3.0.3
+version: 3.0.5
 schema_version: 1
 ---
 

package/skills/lineage/lineage.py

@@ -20,6 +20,7 @@ import pathlib
 import re
 import sys
 import tempfile
+import unicodedata
 from html.parser import HTMLParser
 
 if sys.version_info < (3, 7):
@@ -734,14 +735,40 @@ def _page_clean_turn(t, extra, mode):
     return dict(t, text=clean(t["text"]), parts=[clean(p) for p in t.get("parts") or []])
 
 
+# Letters that print as nothing: the Hangul fillers, the braille blank, and the combining marks Unicode ignores by
+# default (the grapheme joiner, the Khmer inherent vowels, the Mongolian free variation selectors). With the control,
+# format, private-use, unassigned and separator categories, a cache made only of them holds no summary a person can
+# read (3.0.5).
+_BLANK_LETTERS = frozenset(map(chr, (0x115F, 0x1160, 0x3164, 0xFFA0, 0x2800,
+                                     0x034F, 0x17B4, 0x17B5, 0x180B, 0x180C, 0x180D, 0x180F)))
+_BLANK_CATEGORIES = frozenset(("Cc", "Cf", "Co", "Cn", "Zs", "Zl", "Zp"))
+
+
+def _blank(ch):
+    """Whether ch prints as nothing: whitespace, a blank-looking letter, or a variation selector."""
+    if ch.isspace() or ch in _BLANK_LETTERS or unicodedata.category(ch) in _BLANK_CATEGORIES:
+        return True
+    o = ord(ch)
+    return 0xFE00 <= o <= 0xFE0F or 0xE0100 <= o <= 0xE01EF
+
+
+def _has_visible(text):
+    """Whether text holds a letter a person can see."""
+    return not all(_blank(ch) for ch in text)
+
+
 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)."""
+    None when neither holds one: missing, bytes that are not UTF-8 (a DRM encrypted them), or
+    nothing a person can see (a write that stopped early, or only blank-looking letters); the
+    turn is then summarized again (3.0.4, 3.0.5)."""
     for cached in (p, p.with_name(p.stem + ".txt")):
         try:
-            return cached.read_text(encoding="utf-8").strip()
+            text = cached.read_text(encoding="utf-8").strip()
         except (OSError, UnicodeDecodeError):
             continue
+        if _has_visible(text):
+            return text
     return None
 
 

package/skills/omc-patch/SKILL.md

@@ -41,11 +41,11 @@ OMC(oh-my-claudecode)가 새 버전으로 자동 업데이트되면 로컬 훅
 - `--root` 는 폴더의 이름표가 OMC 가 아니면 `OMC 플러그인 폴더가 아님` 으로 멈춘다. `.claude-plugin/plugin.json` 의 name 이 있으면 그것으로, 없으면 `package.json` 의 name 으로 정한다. 다른 폴더를 잘못 준 실수를 막는 확인이고, 이름표가 없는 폴더는 통과한다.
 - 쓸 파일이 링크로 플러그인 폴더 밖을 가리키거나 백업 자리(`.omcbak`)가 링크면 도구는 쓰지 않고 실패로 센다. 문구는 적용 때 `쓰지 않음`, 되돌리기 때 `되돌리지 않음`, hooks.json 은 `hooks.json 을 건드리지 않음` 이다.
 - 패치 규칙은 OMC 훅 코드의 모양에 맞춰져 있다. 처음 보는 OMC 버전이면 반드시 `check` 를 먼저 실행한다.
-- `실패 N건` 이 1건 이상이면 멈추고 출력을 그대로 보고한다. 문법 오류가 난 파일은 도구가 원본으로 자동 롤백한다.
+- `실패 N건` 이 1건 이상이면 멈추고 출력을 그대로 보고한다. 문법 오류가 난 파일은 도구가 원본으로 자동 롤백한다. 고친 hooks.json 이 다시 읽어 JSON 이 아니어도 원본으로 되돌리고(`hooks.json 손상으로 롤백`) 실패로 센다.
 - 판정은 출력 문구로 한다. 종료 코드 0 만으로 완료라고 보고하지 않는다.
 - 캐시에는 정션이나 심볼릭 링크로 이어진 버전 폴더가 있을 수 있다(예: 옛 버전 폴더가 새 버전을 가리킴). 이때 한 번의 변경이 두 버전 폴더에 함께 보인다. 정상이다.
 - 도구는 `os.homedir()/.claude` 를 쓴다. `CLAUDE_CONFIG_DIR` 로 설정 폴더를 옮겼다면 이 도구는 그 폴더를 보지 않는다.
-- 출력의 origin 에 `https://사용자:토큰@...` 처럼 자격증명이 들어 있으면, 보고할 때 `//***@` 로 가린다. 출력을 그대로 보고하라는 단계에서도 이 가림은 지킨다. 그 URL 은 `PINNED` 에도 평문으로 남으니 사용자에게 알린다.
+- 출력의 origin 에 `https://사용자:토큰@...` 처럼 자격증명이 들어 있으면, 보고할 때 `//***@` 로 가린다. 출력을 그대로 보고하라는 단계에서도 이 가림은 지킨다. 옛 판의 도구가 만든 `PINNED` 에는 그 URL 이 남아 있을 수 있다. `--check` 는 그 칸을 `[!] 고정 기록(PINNED)에 옛 URL 칸이 남아 있음 (적용하면 지움)` 으로 알리고 모두 적용된 상태로 보지 않는다. 적용(`--check` 가 아닌 실행)은 그 칸을 지우고 권한을 0600 으로 맞춘다. 이 도구가 지우지 못하면(기록이 링크, JSON 이 아님, 쓰기 실패, 읽지 못함) `[!] 고정 기록(PINNED)의 옛 URL 칸을 ...` 줄로 알리고, 적용과 되돌리기는 실패로 센다(종료 1). 링크는 따라가 쓰지 않는다. 이때는 그 줄의 경로를 사용자에게 보이고 그 파일을 지울지 묻는다. `PINNED` 는 기록일 뿐이라 지워도 고정과 되돌리기에 영향이 없다. 링크면 URL 칸은 링크가 가리키는 파일에 있으니 그 파일도 보이고 함께 묻는다. 지운 뒤 다시 실행한다. 기록 파일의 내용은 읽어 보이지 않는다(인증 정보가 들 수 있음).
 
 ## 절차
 
@@ -77,6 +77,8 @@ node "<이 스킬 디렉터리 절대경로>/scripts/omc-patch.mjs" --check --no
 | `모두 적용된 상태입니다.` | 4단계 검증으로 건너뜀 |
 | `헬퍼 자리 결함 N건이 있습니다.` | 2단계 확인 뒤 3단계에서 활성 폴더부터 되돌림 |
 | `적용되지 않은 항목이 있습니다.` | 2단계 확인 뒤 3단계 적용 |
+| `hooks.json 을 확인하지 못했습니다.` | 적용하지 않고 위의 `[!]` 줄을 그대로 보고 |
+| `고정 기록(PINNED)의 옛 URL 칸은 이 도구로 지울 수 없습니다.` | 적용하지 않고, 위 `규칙` 절의 `PINNED` 처리대로 사용자에게 묻는다. 지운 뒤 1단계부터 다시 |
 
 - `참고: 비활성 버전 ...` 은 지금 쓰지 않는 버전이라 판정에 들어가지 않는다.
 - 인자가 `check` 이면 여기서 결과만 보고하고 끝낸다.
@@ -184,13 +186,17 @@ node "<이 스킬 디렉터리 절대경로>/scripts/omc-patch.mjs" --check --no
    | 그 밖의 `probe-pm:` 줄(종료 코드 2) | 명령 오류다. 경로를 다시 구해 한 번만 다시 실행한다. 같으면 출력을 보고하고 멈춘다 |
    | 판정 줄 뒤의 `probe-pm: 임시 폴더를 지우지 못함` | 판정은 그대로 쓴다. 남은 임시 폴더 경로를 보고에 적어 사용자가 지우게 한다 |
 
-5. 마켓플레이스 고정을 확인한다. `omc-pinned://` 로 시작하면 고정된 것이다.
+5. 마켓플레이스 고정을 확인한다. `omc-pinned://` 로 시작하면 고정된 것이다. 명령은 origin 의 사용자 정보를 `//***@` 로 가려서 낸다.
 
    ```bash
-   git -C "$HOME/.claude/plugins/marketplaces/omc" remote get-url origin
+   git -C "$HOME/.claude/plugins/marketplaces/omc" config --get remote.origin.url | sed -E 's#(//)[^/]*@#\1***@#'
    ```
 
-   PowerShell 에서는 `$HOME` 대신 `$env:USERPROFILE` 을 쓴다.
+   PowerShell:
+
+   ```powershell
+   (git -C "$env:USERPROFILE/.claude/plugins/marketplaces/omc" config --get remote.origin.url) -replace '(//)[^/]*@', '$1***@'
+   ```
 
 ### 5. 보고
 
@@ -209,6 +215,7 @@ node "<이 스킬 디렉터리 절대경로>/scripts/omc-patch.mjs" --revert
 - `.omcbak` 백업으로 설치된 모든 버전의 훅 스크립트와 `hooks.json` 을 되돌리고 마켓플레이스 `origin` 을 원래 URL 로 복구한다.
 - 되돌린 뒤 Claude Code 를 다시 시작해야 반영된다.
 - `되돌리기를 끝내지 못했습니다.` 가 나오면 위의 `[!]` 줄을 그대로 보고한다. 종료 코드는 1 이다. 백업이 없어 남은 파일과 hooks.json 도 이 끝 줄로 끝난다.
+- 고정 기록(`PINNED`)을 지우지 못하면(읽기 전용 폴더, 폴더인 `PINNED`) `[!] 고정 기록(PINNED)을 지우지 못함` 으로 알리고 실패로 센다. 링크인 `PINNED` 너머에 옛 URL 칸이 있으면 링크를 두고 `[!]` 로 알린다. 둘 다 origin 은 그대로 되돌린다. 위 `규칙` 절의 `PINNED` 처리대로 사용자에게 묻는다.
 - `이 도구가 만들지 않은 수정이 남아 있습니다` 가 나오면 백업이 없는 손 수정이다. 출력에 적힌 복구 명령을 그대로 보고하고, 사용자 승인 없이 실행하지 않는다.
 
 ## 함정
@@ -218,9 +225,14 @@ node "<이 스킬 디렉터리 절대경로>/scripts/omc-patch.mjs" --revert
 - 헬퍼 자리 결함이 남은 채 `revert` 없이 적용을 다시 돌려도 바뀌는 것이 없다. 이미 감싼 파일은 건너뛰기 때문이다.
 - `--root` 와 `--revert --root` 는 그 폴더만 다룬다. 고정 해제까지 하려면 인자 없는 `--revert` 를 쓴다.
 - 고정을 풀지 않고 OMC 를 올리려면 먼저 `revert` 한다. 그렇지 않으면 마켓플레이스 fetch 가 계속 실패한다.
-- 고정 기록(`PINNED`)은 `~/.claude/omc-local-patches/PINNED` 에 생긴다. 기록일 뿐이라 지워도 고정은 풀리지 않고, 이미 고정된 상태에서는 다시 만들어지지 않는다. `revert` 는 origin 값에서만 원래 URL 을 되찾고, `PINNED` 의 값으로 origin 을 쓰지 않는다. 다른 기기의 기록이면 알리기만 한다.
+- 고정 기록(`PINNED`)은 `~/.claude/omc-local-patches/PINNED` 에 생긴다. 고정한 시각, 판, 기기 이름만 담고 URL 은 담지 않는다. 옛 판의 기록에 URL 칸이 있으면 `--check` 가 알리고 다음 적용 때 지운다. 지우지 못하면 `[!]` 로 알리고 실패로 센다(링크는 따라가 쓰지 않음). 이 계정만 읽을 수 있다(0600). 기록일 뿐이라 지워도 고정은 풀리지 않고, 이미 고정된 상태에서는 다시 만들어지지 않는다. `revert` 는 origin 값에서만 원래 URL 을 되찾는다. 다른 기기의 기록이면 알리기만 한다.
 - `--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` 도 읽지 않고 준 파일만 본다.
+- 도구는 모르는 인자를 받지 않는다. `--check`, `--revert`, `--no-update`, `--root <폴더>`, `--scan <파일>...`, `--help` 밖의 인자나 `--root=<폴더>` 꼴을 주면 아무것도 하지 않고 사용법과 함께 종료 1 로 멈춘다.
+- 출력의 origin URL 에 사용자 이름과 비밀번호가 있으면 `//***@` 로 가린다. 도구는 origin 을 설정 값 그대로 읽어 고정하고 되돌린다(전역 `insteadOf` 를 펼치지 않음).
+- origin 을 바꾸지 못하면(`.git` 쓰기 권한 등) `[!] 고정 실패` 나 `[!] 고정 해제 실패` 와 종료 1 로 끝난다. 그 줄을 그대로 보고한다. 고정 해제에 실패해도 원래 URL 은 `git config --get remote.origin.url` 결과의 `omc-pinned://` 뒤에 남는다.
+- `--check` 는 쓸 수 없는 파일을 `패치 필요, 쓸 수 없음` 으로 미리 알린다. 폴더 밖 링크 때문에 되돌리지 못한 파일은 손 복구 방법을 함께 낸다. 사용자 승인 없이 그 방법을 실행하지 않는다.
+- 파일은 새 임시 파일과 rename 으로 바꾼다. 하드 링크로 이어진 폴더 밖 파일은 바뀌지 않는다. 쓰지 못한 파일은 `쓰지 못함` 으로 이름을 대고 실패로 센다.
 - 도구의 주석과 출력 문구는 한글이다.