@kaydash9999/banker-plugins 0.19.2 → 0.19.3

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Claude Code skills + commands — QA, audit, docs, architecture, dependency setup, and wiki; the banker plugin marketplace.",
-    "version": "0.19.2"
+    "version": "0.19.3"
   },
   "plugins": [
     {

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "banker",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "description": "Claude Code plugin: QA/audit/docs/architecture skills + commands, a /banker:setup installer for OS dependencies (playwright, etc.), and wiki compaction.",
   "author": {
     "name": "smallOpenSource",

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.19.3] - 2026-10-17
+
+### Fixed
+- 업데이트 확인 체크인 훅: 보내기 전에 사용 기록의 이름을 바꿔 차지한다. 예전에는 첫 체크인이 보내는 사이 함께 시작한 세션이 같은 기록을 다시 보내 대시보드 수가 실제보다 커졌다. 보내는 동안 더해진 줄은 다음 체크인이 보낸다(예전에는 지워졌다). 기록 자리가 FIFO 면 기다리지 않는다. 기록이 링크면 링크만 옮겨 지우고 가리키던 파일은 그대로 두며, 다음 기록은 일반 파일로 새로 생긴다. `last-flush` 자리가 링크면 그 너머를 덮지 않는다. 백신 등이 기록을 잠시 쥐어 이름을 못 바꾸면 두 번 더 해 보고, 그래도 안 되면 다음 체크인에 남긴다. 죽은 체크인이 남긴 차지 파일은 차지한 지 한 시간이 지나면 지운다.
+- `tone-compact`, `anti-drm`: 잠금을 잡지 못한 회차마다 쉰다. 예전에는 잠금 자리를 볼 때는 없다고 하고 만들 때는 있다고 하는 공유(NFS 의 캐시 등)에서 기다리는 동안 쉬지 않고 돌았다. 잠금을 만들거나 죽은 실행의 잠금을 지울 때 ESTALE 이 나면 쉬고 다시 본다. 만들 때의 ESTALE 이 기다림이 끝나도 계속되면 그 원인을 밝혀 거부한다(종료 1). 예전에는 예기치 못한 오류로 종료 2 였다. 일을 마친 뒤 잠금을 돌려줄 때의 ESTALE 은 세 번까지 다시 한다. 예전에는 잠금이 1분 남아 그동안 다음 작업이 거부됐다.
+- `lineage` 3.0.8: 쪼개진 키, 비밀번호, `--redact-extra` 키워드도 통째로 가린다. 쪼개는 글자는 보이지 않는 글자(폭 없는 공백, 소프트 하이픈, 방향 제어 같은 기본 무시 글자와 그 밖의 서식 문자), 공백, 탭, 줄바꿈이 아닌 제어 문자와 특수 공백(줄바꿈 없는 공백 등), 사용자 정의 영역 글자, 점자 빈칸, U+FFFC, U+FFFD 다. 예전에는 쪼개진 조각이 가림 패턴에 걸리지 않아 페이지와 검토자 글에 남을 수 있었다. 다시 이은 결과가 보이는 글자 가운데 3.0.7 의 한 번이 가린 글자는 3.0.7 의 표식으로 다시 가리고, 어떤 종류의 값이든 3.0.7 보다 적게 가리면 3.0.7 한 번의 결과에서 이어 간다. 그래서 3.0.7 이 가리던 글자는 모두 그대로 가린다. 비밀 밖의 글은 그대로이고, 다시 이은 비밀 바로 옆의 그런 글자는 함께 빠질 수 있다.
+
 ## [0.19.2] - 2026-10-16
 
 ### Changed

package/hooks/update-checkin.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 /*
  * banker 카운팅 체크인 훅 - usage-log 를 스킬별 x 시간대(hour 0-23)별 count 로 집계해 엔드포인트로
- * 한 번 POST 하고, 응답의 latest 로 update-check 캐시를 겸해 갱신한다. 전송 시도 후(성공/실패 무관)
- * 로그를 truncate 해 24h 윈도우로 상한한다. telemetry-flush 를 대체(evolve)한다.
+ * 한 번 POST 하고, 응답의 latest 로 update-check 캐시를 겸해 갱신한다. 보내기 전에 로그 이름을 바꿔
+ * 차지하고, 시도 뒤(성공/실패 무관) 차지한 파일을 지워 24h 윈도우로 상한한다. telemetry-flush 를
+ * 대체(evolve)한다.
  *
  * fail-closed 규약(각 항목은 update-checkin.test.mjs 가 검증한다):
  *  - 미활성(countingActive) 또는 엔드포인트 없음이면 무동작(로그도 건드리지 않는다).
@@ -10,13 +11,19 @@
  *    counts=스킬별 x 시간대별 호출수).
  *  - 자체 네트워크 timeout 으로 hang 방지. 어떤 오류도 삼키고 항상 exit 0. 어떤 경로도 reject 안 함.
  *  - 비-loopback 평문 http 는 전송하지 않는다(https-only). loopback http 만 로컬 테스트 mock 에 허용.
+ *  - 함께 시작한 체크인은 같은 줄을 두 번 보내지 않는다(로그 이름 바꾸기는 하나만 성공한다).
+ *  - 로그 자리가 FIFO 면 기다리지 않고, 로그나 last-flush 자리가 링크면 링크 너머 파일을 비우거나 덮지 않는다.
  *
  * count-default-on: 이 훅은 hooks.json 에 배선되지 않는다(스탠드얼론 .mjs). update-notify 가
  * countingActive + 엔드포인트 설정 시 fetcher 로 detached spawn 한다(응답 latest 가 알림 캐시를 겸함).
  */
-import { readFileSync, writeFileSync } from 'node:fs';
+import {
+  closeSync, constants, fstatSync, lstatSync, openSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync,
+} from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import http from 'node:http';
 import https from 'node:https';
+import { dirname, join } from 'node:path';
 
 import {
   countingActive,
@@ -160,13 +167,80 @@ function fetchSkillChangesMap(url) {
 }
 
 // 보낼 본문. PII/IP/지속ID 없음: version + os(플랫폼 계열) + counts(스킬별 x 시간대)뿐.
-// 로그 없음도 유효한 체크인(설치 펄스 + 알림 fetch 겸함): 빈 counts 로 진행한다.
-function checkinBody() {
-  let raw = '';
-  try { raw = readFileSync(USAGE_LOG_PATH, 'utf8'); } catch { raw = ''; }
+// 차지한 줄이 없어도 유효한 체크인(설치 펄스 + 알림 fetch 겸함): 빈 counts 로 진행한다.
+function checkinBody(raw) {
   return JSON.stringify({ version: installedVersion() || 'unknown', os: process.platform, counts: aggregate(raw) });
 }
 
+// 차지한 로그의 이름(usage-log.sending-<pid>-<차지한 ms>-<난수>)과, 죽은 체크인이 남긴 것으로 볼 나이. 나이는
+// 이름의 시각으로 센다: 이름을 바꿔도 수정 시각은 로그를 마지막으로 쓴 때 그대로다. 난수는 PID 가 같은 다른
+// 이름공간(컨테이너)의 체크인과 이름이 겹치지 않게 한다.
+const CLAIM_RE = /^usage-log\.sending-\d+-(\d+)(?:-[0-9a-f]+)?$/;
+const CLAIM_MAX_AGE_MS = 3_600_000;
+// 백신이나 동기화 도구가 로그를 잠시 쥐어 이름을 못 바꿀 때(Windows 의 EPERM, EBUSY) 쉬었다 다시 해 볼 횟수와 쉼.
+const RENAME_TRIES = 3;
+const RENAME_REST_MS = 50;
+const SLEEP = new Int32Array(new SharedArrayBuffer(4));
+
+// 일반 파일의 글. 그 밖(FIFO, 폴더)과 오류는 ''. 막지 않고 열어 FIFO 를 기다리지 않는다.
+function readRegular(path) {
+  let fd;
+  try {
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+    return fstatSync(fd).isFile() ? readFileSync(fd, 'utf8') : '';
+  } catch {
+    return '';
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch { /* best-effort */ }
+  }
+}
+
+// 보내기 전에 로그 이름을 바꿔 차지한다. rename 은 원자적이라 함께 시작한 체크인 가운데 하나만 그 줄을 읽고,
+// 보내는 동안 더해진 줄은 새 로그로 가 다음 체크인이 보낸다. 링크면 링크 자체가 옮겨진다(대상은 그대로).
+// 로그가 없거나 폴더, FIFO 이거나 이름을 바꾸지 못하면(다른 체크인이 먼저 차지, Windows 에서 백신이 쥠)
+// 아무것도 차지하지 않고 로그는 다음 체크인에 남긴다.
+function claimLog() {
+  try {
+    const st = lstatSync(USAGE_LOG_PATH);
+    if (!st.isFile() && !st.isSymbolicLink()) return { raw: '', claim: null };
+  } catch {
+    return { raw: '', claim: null };
+  }
+  const claim = join(dirname(USAGE_LOG_PATH), `usage-log.sending-${process.pid}-${Date.now()}-${randomBytes(4).toString('hex')}`);
+  return renameAside(USAGE_LOG_PATH, claim) ? { raw: readRegular(claim), claim } : { raw: '', claim: null };
+}
+
+// 이름을 바꿨으면 true. 잠시 쥔 것(EPERM, EBUSY, EACCES)은 RENAME_TRIES 번까지 쉬었다 다시 하고, 없어졌으면
+// (다른 체크인이 먼저 차지) 곧 false.
+function renameAside(from, to) {
+  for (let tried = 1; ; tried++) {
+    try {
+      renameSync(from, to);
+      return true;
+    } catch (e) {
+      if (tried >= RENAME_TRIES || !['EPERM', 'EBUSY', 'EACCES'].includes(e.code)) return false;
+      Atomics.wait(SLEEP, 0, 0, RENAME_REST_MS);
+    }
+  }
+}
+
+// 죽은 체크인이 남긴 차지 파일(차지한 지 한 시간이 넘은 것, 시계를 되돌려 한 시간 넘게 앞선 것)을 지운다(배치
+// 유실 허용). 더 젊은 것은 아직 보내는 다른 체크인의 것이라 둔다. 이름 자체를 보고 지운다(링크면 링크만 지워진다).
+function dropOldClaims(now = Date.now()) {
+  const dir = dirname(USAGE_LOG_PATH);
+  let names;
+  try { names = readdirSync(dir); } catch { return; }
+  for (const name of names) {
+    const made = CLAIM_RE.exec(name);
+    if (!made || Math.abs(now - Number(made[1])) <= CLAIM_MAX_AGE_MS) continue;
+    const path = join(dir, name);
+    try {
+      const st = lstatSync(path);
+      if (st.isFile() || st.isSymbolicLink()) unlinkSync(path);
+    } catch { /* best-effort */ }
+  }
+}
+
 // 응답의 latest 로 공유 update-check 캐시를 갱신(알림 겸함). 없으면 캐시 미변경.
 // update-fetch 처럼 notified:null 재무장을 하지 않아도 등가다: dedupe 판정이 notified===latest
 // (update-notify)라 전진 버전에서 구 notified 는 항상 신 latest 와 달라 재고지가 정상 발화하고,
@@ -182,18 +256,27 @@ async function refreshUpdateCache(responseBody) {
   try { writeUpdateCache(patch); } catch { /* best-effort */ }
 }
 
-// 전송 시도 후(성공/실패 무관) 로그를 비워 24h 윈도우로 상한(배치 유실 허용).
-function resetLog() {
-  try { writeFileSync(USAGE_LOG_PATH, ''); } catch { /* best-effort */ }
-  try { writeFileSync(LAST_FLUSH_PATH, new Date().toISOString()); } catch { /* best-effort */ }
+// 전송 시도 후(성공/실패 무관) 차지한 파일을 지워 24h 윈도우로 상한(배치 유실 허용)하고 last-flush 를 남긴다.
+// last-flush 는 새 파일에 쓴 뒤 rename 으로 놓아, 그 이름 자리의 링크를 따라 다른 파일을 덮지 않는다.
+function finishClaim(claim) {
+  if (claim) try { unlinkSync(claim); } catch { /* best-effort */ }
+  const tmp = `${LAST_FLUSH_PATH}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, new Date().toISOString(), { flag: 'wx' });
+    renameSync(tmp, LAST_FLUSH_PATH);
+  } catch {
+    try { unlinkSync(tmp); } catch { /* best-effort */ }
+  }
 }
 
 async function main() {
   if (!countingActive()) return; // 미활성 - 무동작(로그 미변경).
   const url = endpoint();
   if (!url) return;              // 엔드포인트 없음 - 무동작(로그 미변경).
-  const responseBody = await post(url, checkinBody());
-  resetLog(); // 보낸 직후 비운다. 매니페스트를 받는 동안(최대 30초) 시작한 세션이 같은 로그를 다시 보내지 않게.
+  dropOldClaims();
+  const { raw, claim } = claimLog();
+  const responseBody = await post(url, checkinBody(raw));
+  finishClaim(claim); // 보내는 동안 더해진 줄은 새 로그에 남아 다음 체크인이 보낸다.
   await refreshUpdateCache(responseBody);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "description": "banker — Claude Code + Codex CLI plugin (QA, audit, docs, architecture, wiki skills). Install via Claude Code marketplace, or `npm i -g @kaydash9999/banker-plugins` then `banker setup`.",
   "bin": {
     "banker": "bin/banker.js"

package/skills/anti-drm/SKILL.md

@@ -258,4 +258,5 @@ argument-hint: "on | off | status | config"
 | 쓰는 사이에 같은 이름이 생겨 그대로 두었습니다 | 다른 프로그램이 그 사이에 같은 이름을 만들었음(링크일 수 있음). 지우거나 바꾸지 않음. 무엇인지 보이고(링크면 `ls -l` 로 링크와 대상 경로만 보이고 대상 내용은 열지 않음) 어떻게 할지 물은 뒤 다시 실행 |
 | 일반 파일이 아님 | 지침 파일 자리(AGENTS.md, AGENTS.override.md)의 폴더나 특수 파일은 지우지 않음. 무엇인지 사용자에게 보이고, 옮기거나 이름을 바꿀지 물은 뒤 다시 실행 |
 | 다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다 | 다른 banker 스킬의 `on`, `off` 가 도는 중. 잠시 뒤 다시 실행. 끝나지 않은 작업이 남긴 잠금은 1분 뒤 저절로 넘어감. 1분이 지나도 같거나 잠금 자리가 폴더면 잠금 경로를 보이고 어떻게 할지 물은 뒤 다시 실행. 잠금을 임의로 지우지 않음 |
+| 네트워크 공유가 잠금 자리에 계속 ESTALE(오래된 파일 핸들)을 돌려줘 그대로 두었습니다 | Codex 폴더가 NFS 같은 네트워크 공유에 있고 공유가 파일 핸들을 잃음. 잠시 뒤 다시 실행. 계속되면 공유 연결 상태를 확인하도록 알림. 잠금을 임의로 지우지 않음 |
 | 쓸 권한이 없음 | 해당 파일과 폴더 권한 확인 |

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

@@ -529,55 +529,67 @@ 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.
+// Makes the lock file: "taken", "held" when one is there already, or "stale" when a network share answered with a
+// stale file handle (ESTALE), which the next try may not. Anything else (permissions) throws.
 function tryLock(path, token) {
   try {
     writeFileSync(path, token, { flag: "wx", mode: 0o600 });
-    return true;
+    return "taken";
   } catch (e) {
-    if (e.code === "EEXIST") return false;
+    if (e.code === "EEXIST") return "held";
+    if (e.code === "ESTALE") return "stale";
     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.
+// Removes a lock a dead run left. 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. A name gone in between, or a
+// network share's stale file handle (ESTALE) at the look or the removal, is left for the next round.
 function dropStale(path) {
   let st;
   try {
     st = lstatSync(path);
   } catch (e) {
-    if (e.code === "ENOENT") return true; /* gone in between */
-    if (e.code === "ESTALE") return false; /* a network share's stale handle: rest and look again, not spin */
+    if (e.code === "ENOENT" || e.code === "ESTALE") return;
     throw e;
   }
-  if (st.isDirectory() || Math.abs(Date.now() - st.mtimeMs) <= LOCK_STALE_MS) return false;
-  rmSync(path, { force: true });
-  return true;
+  if (st.isDirectory() || Math.abs(Date.now() - st.mtimeMs) <= LOCK_STALE_MS) return;
+  try {
+    rmSync(path, { force: true });
+  } catch (e) {
+    if (e.code !== "ESTALE") throw e;
+  }
 }
 
-// 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.
+// Takes the lock: { path, token }, or { path, why } once the wait ends without it: why is "stale" when the last try
+// met a stale file handle instead of a lock, else "held". Every round that does not take the lock rests, so no answer
+// of the file system makes the wait spin; the deadline is looked at every round, so no lock spot keeps it going past.
 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);
+    const got = tryLock(path, token);
+    if (got === "taken") return { path, token };
+    if (Date.now() >= until) return { path, why: got };
+    if (got === "held") 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.
+// this run's lock and stays. A network share's stale file handle (ESTALE) is tried again after a rest, three times
+// at most; a lock still left goes stale in a minute.
 function dropLock(lock) {
-  try {
-    if (readFile(lock.path)?.text === lock.token) rmSync(lock.path, { force: true });
-  } catch {
-    /* already gone */
+  for (let tried = 1; ; tried++) {
+    try {
+      if (readFile(lock.path)?.text === lock.token) rmSync(lock.path, { force: true });
+      return;
+    } catch (e) {
+      if (e.code !== "ESTALE" || tried >= 3) return; /* already gone, or not this run's to take away */
+      Atomics.wait(SLEEP, 0, 0, LOCK_STEP_MS);
+    }
   }
 }
 
@@ -592,7 +604,11 @@ function locked(o, fn) {
     if (denied(e)) return fn();
     throw e;
   }
-  if (!lock) return refuse(`다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다: ${where(join(o.codexDir, LOCK))}`);
+  if (!lock.token) {
+    return refuse(lock.why === "stale"
+      ? `네트워크 공유가 잠금 자리에 계속 ESTALE(오래된 파일 핸들)을 돌려줘 그대로 두었습니다: ${where(lock.path)}`
+      : `다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다: ${where(lock.path)}`);
+  }
   try {
     return fn();
   } finally {

package/skills/lineage/SKILL.md

@@ -2,7 +2,7 @@
 name: lineage
 description: "현재 세션 대화를 카카오톡 스타일의 단일 HTML 로 내보냄. Claude 답변은 한 줄 요약 아래에 원문을 접어 두고, 펼치면 마크다운으로 렌더해 보여 줌. 기본은 세션 모델이 요약을 쓰고 노이즈 턴을 걸러 내며, `--rulebase` 는 모델 없이 규칙만 씀. 여러 세션을 합칠 수 있음. 'lineage'/'대화 export'/'카톡 스타일 html' 시 사용."
 invocation: /lineage
-version: 3.0.7
+version: 3.0.8
 schema_version: 1
 ---
 
@@ -225,6 +225,7 @@ Schema-tolerant 파서: 미지 record type → stderr WARN + 다음 line. `v1`/`
 1차 `detect-secrets>=1.5`(pip 설치 시), 미설치 → 내장 fallback + WARN.
 내장: AWS IAM(AKIA/ASIA)·GitHub PAT·Slack·JWT·private key·한/영 평문 password·Shannon entropy≥4.5.
 확장 `--redact-extra "k1,k2"`. 부분 마스킹 `--redact-mode mask`(페이지 패턴만. 검토자 패턴이 찾은 값은 늘 전부 가린다).
+쪼개진 값도, 쪼개는 글자를 뺀 모양을 패턴이 찾으면 그 구간에서만 글자를 빼고 통째로 가린다(3.0.8). 쪼개는 글자는 보이지 않는 글자(폭 없는 공백, 소프트 하이픈, 변형 선택자 같은 기본 무시 글자와 서식 문자), 공백, 탭, 줄바꿈이 아닌 제어 문자와 특수 공백, 사용자 정의 영역 글자, 점자 빈칸, U+FFFC, U+FFFD 다. 지금 모양 그대로 패턴이 찾는 값을 반으로 가르게 되면 잇지 않는다. 다시 이은 결과가 보이는 글자 가운데 3.0.7 의 한 번이 가린 글자는 3.0.7 의 표식으로 다시 가리고(`KEY=` 처럼 3.0.7 이 값과 한 덩어리로 가린 앞 글자는 값 표식 옆의 표식 하나가 된다), 어떤 종류의 값이든 3.0.7 보다 적게 가리면 3.0.7 한 번의 결과에서 이어 간다. 그래서 3.0.7 이 가리던 글자는 모두 그대로 가린다. 비밀 밖의 글은 바꾸지 않고, 다시 이은 비밀 바로 옆의 그런 글자는 함께 빠질 수 있다. 무엇이든 이었으면 결과가 더 바뀌지 않을 때까지 되풀이한다(최대 네 번).
 
 ### 5. Render
 
@@ -331,6 +332,7 @@ pip install 'detect-secrets>=1.5'   # (선택) 강한 redaction
 - 규칙 요약 캐시는 본문만으로 키를 잡는다. `--redact-mode` 나 `--redact-extra` 를 바꿔 다시 돌린 `--rulebase` 는 앞선 실행의 요약을 쓸 수 있다(2.x 동작 그대로). 기본 흐름의 묶음은 요약을 매번 새로 만든다. 묶음 형식은 `lineage-review/2` 라 0.15.1 이 만든 묶음은 `--emit-review` 부터 다시 한다.
 - 검토자는 긴 턴의 앞뒤만 본다(`clipped: true`). 가운데에만 있는 결론은 놓칠 수 있다.
 - 검토자 패턴은 흔한 모양만 가린다. `/` 가 든 URL 비밀번호와 키 이름이 100자를 넘는 16진 키는 가리지 못한다(값이 길고 무작위면 엔트로피 규칙이 가릴 수 있다). curl `-u` 패턴은 값 전체가 `docker -u 1000:1000` 같은 uid:gid, `rsync -u host:/path`, `date -u +%H:%M` 같은 날짜 형식(`+%` 뒤에 글자가 오면 나머지는 보지 않는다), 양쪽 모두 변수인 꼴(`$UID:$GID`, `${UID}:${GID}`, `%USER%:%PASS%`, `$(id -u):$(id -g)`), 기본값이 콜론 없는 경로(`/`, `~`, `.` 로 시작)인 변수(`mktemp -u "${TMPDIR:-/tmp}/x"`), 앞선 가림이 남긴 표식(`-u [REDACTED:JWT]`)일 때만 둔다. 이스케이프한 따옴표 안에서도 같다. 다른 명령의 `-u 이름:값`(`-u root:root`, `ps -u postgres:postgres`, `rsync -avu host:dir/`, `ls -lu a:bcd`), 기본값이 경로가 아닌 변수(`${UID:-1000}:${GID:-1000}`, `${API_KEY:-…}`)는 가린다. 숫자만으로 된 이름과 비밀번호, `/` 로 시작하는 비밀번호, `$` 로 시작해 변수처럼 보이는 비밀번호(`$USER:$ecret`), `-U` 와 `--proxy-user`, 붙여 쓴 묶음(`-suUSER:PW`), `-u=USER:PW`, 공백이 든 비밀번호의 둘째 낱말부터, 인자 목록에서 다른 종류의 따옴표가 든 비밀번호(`'-u', "USER:P'W"`), 사용자 안에서 따옴표 뒤에 `-eu`, `--user` 같은 플래그 꼴과 따옴표가 오는 꼴(`"$USER"-eu":PW"`), requests 의 `auth=(...)`, value 가 name 보다 앞에 온 HAR 은 가리지 못한다. 백틱 명령 치환(`` `id -u`:`id -g` ``)과 `\$(id -u):\$(id -g)` 는 가운데 일부가 가려진다(3.0.0 과 같다). 값이 `/`, `~`, `$` 로 시작하는 password 값(`$PWD:/workspace`, `OLDPWD=/home/...`, `password=$DB_PASSWORD`), 이미 가린 표식, 값 전체가 마스크 꼴(`abcd****wxyz`, `****`)인 값은 두고, `PGPASSWORD=`, `MYSQL_PWD=` 의 값은 가린다. `password=os.environ[...]`, `암호: AES-256-GCM` 처럼 코드나 이름인 값과 `sk-` 로 시작하는 긴 세션 이름은 지나치게 가린다. Basic 인증 패턴은 `HTTP_AUTHORIZATION` 처럼 앞에 `_` 가 붙은 이름, 구분자 없는 `Authorization Basic …`, 백틱이나 대괄호(`["Basic …"]`) 안의 값을 가리지 못한다.
+- 쪼갠 값 가운데 detect-secrets 만 찾는 값은 찾지 못한다. 키 바로 앞이 글자나 숫자이고 그 사이와 키 안에 쪼개는 글자가 있으면, 앞 글자 조건이 있는 검토자 패턴(Anthropic, OpenAI, Google 키, Bearer, Basic 인증)은 값 꼬리를 놓칠 수 있다. 태그 글자로 통째로 적거나 base64 로 감싼 값처럼 일부러 숨긴 값은 풀어 보지 않는다. ANSI 색 코드처럼 ESC 뒤에 `[01;31m` 같은 글자가 붙는 열은 ESC 만 쪼개는 글자라 다시 잇지 못한다. 3.0.7 한 번의 결과에서 이어 갈 때는 3.0.7 이 앞부분만 가린 키의 나머지가 남을 수 있다(3.0.7 과 같다). `--redact-mode mask` 의 앞뒤 4글자에는 쪼개는 글자도 한 글자로 든다. 쪼개는 글자가 있는 글은 이을 곳을 찾느라 3.0.7 의 약 3배 걸리고, 이은 곳이 있으면 가림을 몇 번 더 돌아 약 6배 걸린다(5MB 한 글에서 잼).
 - 페이지 패턴 가운데 JWT 와 개인 키 패턴은 같은 머리(`eyJ`, `-----BEGIN`)가 긴 줄에 되풀이되면 시간이 줄 길이의 제곱으로 는다(2.x 동작 그대로). 기본 흐름은 턴마다 여러 번 가리므로 그만큼 더 걸린다.
 - 마크다운의 **중첩 리스트는 평탄화**되고 각주는 미지원.
 - 사용자가 질문에 래퍼 블록(`<task-notification>…`)을 **인용**하면 문장은 남고 그 블록만 사라진다.

package/skills/lineage/lineage.py

@@ -10,7 +10,9 @@ Runtime-agnostic: works from any transcript via --session / --from-transcript.
 Auto-discovery assumes Claude Code's ~/.claude/projects/<encoded-cwd>/ layout.
 """
 import argparse
+import bisect
 import hashlib
+import heapq
 import hmac
 import html
 import json
@@ -22,6 +24,7 @@ import stat
 import sys
 import tempfile
 import unicodedata
+from array import array
 from html.parser import HTMLParser
 from typing import Any
 
@@ -170,15 +173,187 @@ def _mask(s: str) -> str:
     return (s[:4] + "****" + s[-4:]) if len(s) > 8 else "[REDACTED]"
 
 
-def redact(text: str, extra: "str | None" = None, mode: str = "full"):
-    """Multi-layer redaction. Returns (redacted_text, count_by_kind)."""
-    counts = {}
-    out = text
+class _Trail:
+    """Where each character of a text that redaction rewrites stood in the text it started as (-1 for one a marker
+    or a mask put in). A text whose split secrets were joined first is kept only if it shows no character that the
+    one pass over the text as it stands (3.0.7) hid (3.0.8)."""
+
+    def __init__(self, n):
+        self.n, self.pos = n, None  # None: each character is where it was
+
+    def carry(self, edits):
+        """Follow `edits` (start, end, replacement), sorted and apart: an empty replacement drops what it covers, a
+        mask keeps where its first and last four characters were, a marker is all new."""
+        if not edits:
+            return
+        pos = array("q", range(self.n)) if self.pos is None else self.pos
+        out, at, new = array("q"), 0, array("q", [-1])
+        for s, e, r in edits:
+            out += pos[at:s]
+            if r.startswith("[REDACTED"):
+                out += new * len(r)
+            elif r:
+                out += pos[s:s + 4] + new * (len(r) - 8) + pos[e - 4:e]
+            at = e
+        self.pos = out + pos[at:]
+
+    def sub(self, pat, repl, text):
+        """pat.sub(repl, text), the trail following what it replaced."""
+        edits = []
+
+        def noted(m):
+            r = repl(m)
+            if r != m.group(0):
+                edits.append((m.start(), m.end(), r))
+            return r
+        out = pat.sub(noted, text)
+        self.carry(edits)
+        return out
+
+    def shown(self):
+        """A byte for each character of the text it started as: 1 where the text it follows shows that character."""
+        if self.pos is None:
+            return bytearray(b"\x01") * self.n
+        seen = bytearray(self.n)
+        for p in self.pos:
+            if p >= 0:
+                seen[p] = 1
+        return seen
+
+
+def _plain_sub(pat, repl, text):
+    return pat.sub(repl, text)
+
+
+def _sub_for(trail):
+    """The substitution a redaction layer makes its replacements with: kept on `trail` when there is one."""
+    return _plain_sub if trail is None else trail.sub
+
+
+def _shows_more(trail, shown):
+    """Whether the text `trail` follows shows a character of the text it started as that `shown` (a _Trail.shown of
+    another text from the same start) has hidden."""
+    return (int.from_bytes(trail.shown(), "little") & ~int.from_bytes(shown, "little")) != 0
+
+
+# Characters that cut a value for the patterns while no person reads them as a separator: Unicode's default-ignorable
+# code points (the zero-width space and joiners, the soft hyphen, the direction controls, the variation selectors,
+# the tag characters, the Hangul fillers) and the other format characters, the controls and spaces that are no
+# space, tab or line break, private use, the braille blank, and U+FFFC and U+FFFD, which stand for something lost
+# (a lone surrogate became U+FFFD). A value cut by them is put back together where a pattern finds it once they
+# are gone (3.0.8).
+_SPLITTER_RANGES = (
+    (0x0000, 0x0008), (0x000E, 0x001B), (0x007F, 0x0084), (0x0086, 0x009F), (0x00A0, 0x00A0), (0x00AD, 0x00AD),
+    (0x034F, 0x034F), (0x0600, 0x0605), (0x061C, 0x061C), (0x06DD, 0x06DD), (0x070F, 0x070F), (0x0890, 0x0891),
+    (0x08E2, 0x08E2), (0x115F, 0x1160), (0x1680, 0x1680), (0x17B4, 0x17B5), (0x180B, 0x180F), (0x2000, 0x200F),
+    (0x202A, 0x202F), (0x205F, 0x206F), (0x2800, 0x2800), (0x3000, 0x3000), (0x3164, 0x3164), (0xE000, 0xF8FF),
+    (0xFE00, 0xFE0F), (0xFEFF, 0xFEFF), (0xFFA0, 0xFFA0), (0xFFF0, 0xFFFD), (0x110BD, 0x110BD), (0x110CD, 0x110CD),
+    (0x13430, 0x1343F), (0x1BCA0, 0x1BCA3), (0x1D173, 0x1D17A), (0xE0000, 0xE0FFF), (0xF0000, 0xFFFFD),
+    (0x100000, 0x10FFFD))
+_SPLITTERS = "".join(chr(a) if a == b else chr(a) + "-" + chr(b) for a, b in _SPLITTER_RANGES)
+_SPLITTER_RE = re.compile("[" + _SPLITTERS + "]")
+_UNSPLIT_RE = re.compile("[^" + _SPLITTERS + "]+")
+# A character a value can hold: past a splitter next to a found value, one of these means another value begins.
+_VALUE_CHAR_RE = re.compile(r"[A-Za-z0-9_+/=.\-]")
+
+
+def _unsplit_runs(text):
+    """`text` without its splitters, and where each run of other characters starts in it and in `text`."""
+    firsts, origins, parts, at = array("q"), array("q"), [], 0
+    for m in _UNSPLIT_RE.finditer(text):
+        firsts.append(at)
+        origins.append(m.start())
+        parts.append(m.group(0))
+        at += m.end() - m.start()
+    return "".join(parts), firsts, origins
+
+
+def _matches(text, patterns, entropy):
+    """The matches of `patterns` in `text`, and with `entropy` the runs the entropy rule hides."""
+    found = [m for pat in patterns for m in pat.finditer(text)]
+    if entropy:
+        found += [m for m in ENTROPY_LONG.finditer(text) if shannon_entropy(m.group(0)) >= 4.5]
+    return found
+
+
+def _cut_spans(text, joined, firsts, origins, matches):
+    """Where in `text` the values `matches` found in `joined` lie, for those splitters cut or touch. A stretch takes
+    in the splitters next to its value when the character past them is no value character (so the value's
+    neighbours are those it had in `joined`); a splitter between the value and another value stays."""
+    def at(j):  # where joined[j] is in text
+        k = bisect.bisect_right(firsts, j) - 1
+        return origins[k] + j - firsts[k]
+    spans = []
+    for m in matches:
+        s, e = at(m.start()), at(m.end() - 1) + 1
+        before = at(m.start() - 1) + 1 if m.start() else 0
+        after = at(m.end()) if m.end() < len(joined) else len(text)
+        if before == 0 or not _VALUE_CHAR_RE.match(text[before - 1]):
+            s = before
+        if after == len(text) or not _VALUE_CHAR_RE.match(text[after]):
+            e = after
+        if e - s > m.end() - m.start():
+            spans.append((s, e))
+    return spans
+
+
+def _kept(spans, plain):
+    """The stretches of `spans` to join: those no value the patterns find in the text as it stands holds already,
+    and that cut none of those values in two. Joining across such a value would glue it to its neighbour, so the
+    neighbour's own pattern (a lookbehind, a keyword the greedy class ate) no longer finds it. Both lists are swept
+    in order with a heap of the values still open, so many of them stay fast."""
+    plain, out, heap, at = sorted(plain), [], [], 0
+    for s, e in sorted(spans):
+        while at < len(plain) and plain[at][0] < e:
+            heapq.heappush(heap, (plain[at][1], plain[at][0]))
+            at += 1
+        while heap and heap[0][0] <= s:
+            heapq.heappop(heap)
+        if not any((o_s <= s and e <= o_e) or not (s <= o_s and o_e <= e) for o_e, o_s in heap):
+            out.append((s, e))
+    return out
+
+
+def _merged(spans):
+    """Sorted stretches with those that overlap or touch put together."""
+    out = []
+    for s, e in spans:
+        if out and s <= out[-1][1]:
+            out[-1][1] = max(out[-1][1], e)
+        else:
+            out.append([s, e])
+    return out
+
+
+def _rejoin_split(text, patterns, entropy=False, trail=None):
+    """`text` with the splitters taken out of each stretch where, once they are gone, one of `patterns` (and with
+    `entropy` the entropy rule) finds a value that the text as it stands does not show whole: the layers after
+    then see that value and hide it. The rest of the text is left as it is (3.0.8). `trail` follows what is taken out."""
+    if not _SPLITTER_RE.search(text):
+        return text
+    joined, firsts, origins = _unsplit_runs(text)
+    spans = _cut_spans(text, joined, firsts, origins, _matches(joined, patterns, entropy))
+    if spans:
+        spans = _kept(spans, [(m.start(), m.end()) for m in _matches(text, patterns, entropy)])
+    drops = [(m.start(), m.end(), "") for s, e in _merged(sorted(spans)) for m in _SPLITTER_RE.finditer(text, s, e)]
+    if trail is not None:
+        trail.carry(drops)
+    out, at = [], 0
+    for s, e, _ in drops:
+        out.append(text[at:s])
+        at = e
+    return "".join(out) + text[at:]
+
+
+def redact(text: str, extra: "str | None" = None, mode: str = "full", trail=None):
+    """Multi-layer redaction; page_redact and review_redact join split secrets first (3.0.8). Returns (text, counts).
+    With `trail` (a _Trail), where each character of the result came from is followed too."""
+    counts, out, sub = {}, text, _sub_for(trail)
     for name, pat in SECRET_PATTERNS:
         def repl(m, n=name):
             counts[n] = counts.get(n, 0) + 1
             return _mask(m.group(0)) if mode == "mask" else f"[REDACTED:{n}]"
-        out = pat.sub(repl, out)
+        out = sub(pat, repl, out)
 
     def ent_repl(m):
         s = m.group(0)
@@ -186,7 +361,7 @@ def redact(text: str, extra: "str | None" = None, mode: str = "full"):
             counts["entropy"] = counts.get("entropy", 0) + 1
             return _mask(s) if mode == "mask" else "[REDACTED:entropy]"
         return s
-    out = ENTROPY_LONG.sub(ent_repl, out)
+    out = sub(ENTROPY_LONG, ent_repl, out)
 
     try:
         from detect_secrets import SecretsCollection
@@ -204,7 +379,7 @@ def redact(text: str, extra: "str | None" = None, mode: str = "full"):
                 for s in col[fname]:
                     sv = s.secret_value
                     if sv and sv in out:
-                        out = out.replace(sv, "[REDACTED:ds]")
+                        out = sub(re.compile(re.escape(sv)), lambda m: "[REDACTED:ds]", out)
                         counts["ds:detect-secrets"] = counts.get(
                             "ds:detect-secrets", 0) + 1
         finally:
@@ -228,8 +403,8 @@ def redact(text: str, extra: "str | None" = None, mode: str = "full"):
             # a marker an earlier pass left stays whole: a keyword inside its name is no secret
             pat = re.compile(r"\[REDACTED(?::[^\]\s]*)?\]|" + re.escape(kw), re.IGNORECASE)
             hits = []
-            out = pat.sub(lambda m: m.group(0) if m.group(0).upper().startswith("[REDACTED")
-                          else hits.append(1) or "[REDACTED]", out)
+            out = sub(pat, lambda m: m.group(0) if m.group(0).upper().startswith("[REDACTED")
+                      else hits.append(1) or "[REDACTED]", out)
             if hits:
                 counts[f"custom:{kw}"] = len(hits)
     return out, counts
@@ -315,35 +490,177 @@ REVIEW_SECRET_PATTERNS = [
 ]
 
 
-def _reviewer_patterns(text):
+def _reviewer_patterns(text, trail=None):
     """`text` with what the reviewer patterns find replaced whole by [REDACTED:<name>], and the
-    count by name."""
-    counts = {}
+    count by name. A split secret is put back together by its callers first (3.0.8)."""
+    counts, sub = {}, _sub_for(trail)
     for name, pat in REVIEW_SECRET_PATTERNS:
-        text, k = pat.subn(f"[REDACTED:{name}]", text)
-        if k:
-            counts[name] = k
+        hits = []
+        text = sub(pat, lambda m, marker=f"[REDACTED:{name}]": hits.append(1) or marker, text)
+        if hits:
+            counts[name] = len(hits)
     return text, counts
 
 
+def _rejoin_secrets(text, extra=None, trail=None):
+    """`text` with each secret a splitter cuts put back together, for every pattern a page or a reviewer's text is
+    hidden with: the reviewer's, the page's, the entropy rule and the --redact-extra keywords (3.0.8)."""
+    keywords = [k.strip() for k in (extra or "").split(",") if k.strip()]
+    patterns = ([p for _, p in REVIEW_SECRET_PATTERNS] + [p for _, p in SECRET_PATTERNS]
+                + [re.compile(re.escape(k), re.IGNORECASE) for k in keywords])
+    return _rejoin_split(text, patterns, entropy=True, trail=trail)
+
+
+def _join_first(text, extra, one_pass):
+    """`one_pass` (text, trail -> (text, found)) over `text` with its split secrets put back together. Once anything
+    was joined, again over its output until a pass changes nothing (at most four passes): a value next to one a
+    marker replaced may be found only then. Returns (text, [found], the _Trail of the text, or None when nothing
+    was joined)."""
+    trail = _Trail(len(text)) if _SPLITTER_RE.search(text) else None
+    joined = _rejoin_secrets(text, extra, trail)
+    moved = joined != text
+    red, found = one_pass(joined, trail)
+    founds = [found]
+    for _ in range(3):
+        joined = _rejoin_secrets(red, extra, trail)
+        if joined == red and not moved:
+            break  # nothing joined: 3.0.7's one pass is final
+        moved = True
+        again, found = one_pass(joined, trail)
+        if again == red:
+            break
+        red = again
+        founds.append(found)
+    return red, founds, trail if moved else None
+
+
+# The key patterns that may find the same key: one kind when passes are compared.
+_KEY_FAMILY = {"AnthropicKey": "key", "OpenAIKey": "key", "GoogleKey": "key"}
+
+
+def _kinds(founds):
+    """How many values of each kind the passes hid, the entropy rule and detect-secrets apart: joining pieces
+    changes how many runs the entropy rule sees."""
+    kinds = {}
+    for found in founds:
+        for k, v in found.items():
+            if k != "entropy" and not k.startswith("ds:"):
+                k = _KEY_FAMILY.get(k, k)
+                kinds[k] = kinds.get(k, 0) + v
+    return kinds
+
+
+def _from_floor(red, found, extra, one_pass):
+    """Joining as _join_first does, but from the output of one pass over the text as it stands."""
+    founds = [found]
+    for _ in range(4):
+        joined = _rejoin_secrets(red, extra)
+        if joined == red:
+            break
+        again, found = one_pass(joined)
+        if again == red:
+            break
+        red = again
+        founds.append(found)
+    return red, founds
+
+
+def _hidden_by(floor, base):
+    """The stretches of the text it started as that `floor` (whose trail is `base`) hides, in order, each with what
+    stands for it in `floor`: [(start, end, marker)]."""
+    pos, out, i, n = base.pos, [], 0, len(floor)
+    while i < n:
+        if pos[i] >= 0:
+            i += 1
+            continue
+        j = i
+        while j < n and pos[j] < 0:
+            j += 1
+        out.append((pos[i - 1] + 1 if i else 0, pos[j] if j < n else base.n, floor[i:j]))
+        i = j
+    return out
+
+
+def _patched(red, trail, shown, hidden):
+    """`red` (whose trail is `trail`) with each run of characters it shows that `shown` has hidden put under what
+    stands for them in that text (`hidden`, from _hidden_by), and how many markers that took by name."""
+    pos, starts = trail.pos, [lo for lo, _, _ in hidden]
+    out, counts, at, i = [], {}, 0, 0
+    while i < len(red):
+        if pos[i] < 0 or shown[pos[i]]:
+            i += 1
+            continue
+        j = i + 1
+        while j < len(red) and pos[j] >= 0 and not shown[pos[j]]:
+            j += 1
+        marker = hidden[bisect.bisect_right(starts, pos[i]) - 1][2]
+        name = re.fullmatch(r"\[REDACTED:(\w+)\]", marker)
+        if name:
+            counts[name.group(1)] = counts.get(name.group(1), 0) + 1
+        out += [red[at:i], marker]
+        at = i = j
+    return "".join(out) + red[at:], counts
+
+
+def _with_rejoins(text, extra, one_pass):
+    """_join_first, with each character it shows that one pass over the text as it stands hid (3.0.7 did that one
+    pass) put back under that pass's marker; but if it hides fewer values of some kind, the joining starts from that
+    pass's output instead. Each pass only hides more, so no character 3.0.7 hid shows (3.0.8). Returns (text,
+    [found])."""
+    red, founds, trail = _join_first(text, extra, one_pass)
+    if trail is None:
+        return red, founds  # nothing joined: that was the one pass over the text as it stands
+    base = _Trail(len(text))
+    floor, found = one_pass(text, base)
+    joined = _kinds(founds)
+    if not all(joined.get(k, 0) >= v for k, v in _kinds([found]).items()):
+        return _from_floor(floor, found, extra, one_pass)
+    shown = base.shown()
+    if not _shows_more(trail, shown):
+        return red, founds
+    patched, put_back = _patched(red, trail, shown, _hidden_by(floor, base))
+    again, found = one_pass(patched)
+    out, more = _from_floor(again, found, extra, one_pass)
+    return out, founds + [put_back] + more
+
+
+def _review_pass(text, extra, trail=None):
+    pre, counts = _reviewer_patterns(text, trail)
+    red, found = redact(pre, extra=extra, mode="full", trail=trail)
+    for k, v in found.items():
+        counts[k] = counts.get(k, 0) + v
+    return red, counts
+
+
 def review_redact(text, extra=None):
     """Text as a reviewer model reads it: the reviewer-only patterns first, while the keys
     are whole (the entropy rule would otherwise cut a key and leave the rest), then fully
-    redacted (never masked, whatever --redact-mode says). Returns (text, count)."""
-    pre, counts = _reviewer_patterns(text)
-    red, found = redact(pre, extra=extra, mode="full")
-    return red, sum(counts.values()) + sum(found.values())
+    redacted (never masked, whatever --redact-mode says). A secret a splitter cuts is put back
+    together (3.0.8). Returns (text, count)."""
+    red, founds = _with_rejoins(text, extra, lambda t, trail=None: _review_pass(t, extra, trail))
+    return red, sum(sum(f.values()) for f in founds)
+
+
+def _page_pass(text, extra, mode, trail=None):
+    pre, counts = _reviewer_patterns(text, trail)
+    red, found = redact(pre, extra=extra, mode=mode, trail=trail)
+    for k, v in found.items():
+        counts[k] = counts.get(k, 0) + v
+    return red, counts
 
 
 def page_redact(text, extra=None, mode="full"):
     """Text as every page shows it (3.0.2): the reviewer patterns first, while keys are whole,
     each hit replaced whole whatever --redact-mode says (a mask keeps 4+4 characters, most of
-    a short password); then the page's redaction with this run's mode and keywords. Returns
-    (text, count_by_kind); a second pass over its output finds nothing."""
-    pre, counts = _reviewer_patterns(text)
-    red, found = redact(pre, extra=extra, mode=mode)
-    for k, v in found.items():
-        counts[k] = counts.get(k, 0) + v
+    a short password); then the page's redaction with this run's mode and keywords. A secret a
+    splitter cuts is put back together (3.0.8). Returns (text, count_by_kind). A second pass
+    over its output finds nothing, but for two values glued with no separator at all (a key
+    run into `Bearer`), where the second shows only once the first is a marker, as in 3.0.7."""
+    red, founds = _with_rejoins(text, extra, lambda t, trail=None: _page_pass(t, extra, mode, trail))
+    counts = {}
+    for found in founds:
+        for k, v in found.items():
+            counts[k] = counts.get(k, 0) + v
     return red, counts
 
 

package/skills/tone-compact/SKILL.md

@@ -209,4 +209,5 @@ argument-hint: "on | off | status"
 | 쓰는 사이에 같은 이름이 생겨 그대로 두었습니다 | 다른 프로그램이 그 사이에 같은 이름을 만들었음(링크일 수 있음). 지우거나 바꾸지 않음. 무엇인지 보이고(링크면 `ls -l` 로 링크와 대상 경로만 보이고 대상 내용은 열지 않음) 어떻게 할지 물은 뒤 다시 실행 |
 | 일반 파일이 아님 | 지침 파일 자리(AGENTS.md, AGENTS.override.md)의 폴더나 특수 파일은 지우지 않음. 무엇인지 사용자에게 보이고, 옮기거나 이름을 바꿀지 물은 뒤 다시 실행 |
 | 다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다 | 다른 banker 스킬의 `on`, `off` 가 도는 중. 잠시 뒤 다시 실행. 끝나지 않은 작업이 남긴 잠금은 1분 뒤 저절로 넘어감. 1분이 지나도 같거나 잠금 자리가 폴더면 잠금 경로를 보이고 어떻게 할지 물은 뒤 다시 실행. 잠금을 임의로 지우지 않음 |
+| 네트워크 공유가 잠금 자리에 계속 ESTALE(오래된 파일 핸들)을 돌려줘 그대로 두었습니다 | Codex 폴더가 NFS 같은 네트워크 공유에 있고 공유가 파일 핸들을 잃음. 잠시 뒤 다시 실행. 계속되면 공유 연결 상태를 확인하도록 알림. 잠금을 임의로 지우지 않음 |
 | 쓸 권한이 없음 | 해당 파일과 폴더 권한 확인 |

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

@@ -529,55 +529,67 @@ 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.
+// Makes the lock file: "taken", "held" when one is there already, or "stale" when a network share answered with a
+// stale file handle (ESTALE), which the next try may not. Anything else (permissions) throws.
 function tryLock(path, token) {
   try {
     writeFileSync(path, token, { flag: "wx", mode: 0o600 });
-    return true;
+    return "taken";
   } catch (e) {
-    if (e.code === "EEXIST") return false;
+    if (e.code === "EEXIST") return "held";
+    if (e.code === "ESTALE") return "stale";
     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.
+// Removes a lock a dead run left. 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. A name gone in between, or a
+// network share's stale file handle (ESTALE) at the look or the removal, is left for the next round.
 function dropStale(path) {
   let st;
   try {
     st = lstatSync(path);
   } catch (e) {
-    if (e.code === "ENOENT") return true; /* gone in between */
-    if (e.code === "ESTALE") return false; /* a network share's stale handle: rest and look again, not spin */
+    if (e.code === "ENOENT" || e.code === "ESTALE") return;
     throw e;
   }
-  if (st.isDirectory() || Math.abs(Date.now() - st.mtimeMs) <= LOCK_STALE_MS) return false;
-  rmSync(path, { force: true });
-  return true;
+  if (st.isDirectory() || Math.abs(Date.now() - st.mtimeMs) <= LOCK_STALE_MS) return;
+  try {
+    rmSync(path, { force: true });
+  } catch (e) {
+    if (e.code !== "ESTALE") throw e;
+  }
 }
 
-// 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.
+// Takes the lock: { path, token }, or { path, why } once the wait ends without it: why is "stale" when the last try
+// met a stale file handle instead of a lock, else "held". Every round that does not take the lock rests, so no answer
+// of the file system makes the wait spin; the deadline is looked at every round, so no lock spot keeps it going past.
 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);
+    const got = tryLock(path, token);
+    if (got === "taken") return { path, token };
+    if (Date.now() >= until) return { path, why: got };
+    if (got === "held") 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.
+// this run's lock and stays. A network share's stale file handle (ESTALE) is tried again after a rest, three times
+// at most; a lock still left goes stale in a minute.
 function dropLock(lock) {
-  try {
-    if (readFile(lock.path)?.text === lock.token) rmSync(lock.path, { force: true });
-  } catch {
-    /* already gone */
+  for (let tried = 1; ; tried++) {
+    try {
+      if (readFile(lock.path)?.text === lock.token) rmSync(lock.path, { force: true });
+      return;
+    } catch (e) {
+      if (e.code !== "ESTALE" || tried >= 3) return; /* already gone, or not this run's to take away */
+      Atomics.wait(SLEEP, 0, 0, LOCK_STEP_MS);
+    }
   }
 }
 
@@ -592,7 +604,11 @@ function locked(o, fn) {
     if (denied(e)) return fn();
     throw e;
   }
-  if (!lock) return refuse(`다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다: ${where(join(o.codexDir, LOCK))}`);
+  if (!lock.token) {
+    return refuse(lock.why === "stale"
+      ? `네트워크 공유가 잠금 자리에 계속 ESTALE(오래된 파일 핸들)을 돌려줘 그대로 두었습니다: ${where(lock.path)}`
+      : `다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다: ${where(lock.path)}`);
+  }
   try {
     return fn();
   } finally {