@kaydash9999/banker-plugins 0.23.0 → 0.23.2

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.23.0"
+    "version": "0.23.2"
   },
   "plugins": [
     {

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "banker",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "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,32 @@
 # Changelog
 
+## [0.23.2] - 2026-10-31
+
+### Fixed
+- `teamwork`(Codex 전용): Codex `/rename` 으로 정한 세션 이름을 알아본다. 피어 목록과 규칙에 `이름:` 으로 보이고, `send <이름>` 으로 보낸다(전송은 그대로 UUID). 공백과 `-` 를 같게 보고 대소문자를 가리지 않으며, 대상 찾는 순서는 `all`, 역할, 이름, 짧은ID 다. 역할이 없으면 요청 머리말의 보낸 세션에 이름을 쓴다. 이름을 바꾸면 다른 세션은 다음 입력 때 바뀐 목록을 받는다. 이름은 `$CODEX_HOME/session_index.jsonl` 의 그 세션 마지막 줄에서 읽고, 일반 파일이 아니면 읽지 않는다.
+
+### Notes
+- 0.23.1 은 npm 에 게시하지 않았다. npm 에서는 0.23.0 다음이 0.23.2 이고, 0.23.1 의 변경도 이 판에 들어 있다.
+- 실제 Codex CLI 0.165.0 두 세션(tmux)에서 `/rename` 이름으로 요청과 결과를 양방향으로 주고받았고, 열린 세션에서 이름을 바꾼 뒤 새 이름으로도 보냈다.
+- teamwork 엔진이 0.3.1 로 바뀌어 훅 명령의 `--rev` 가 달라진다. 스킬로 `on` 을 다시 실행한 뒤 Codex 가 teamwork 훅 신뢰를 한 번 다시 묻는다.
+
+## [0.23.1] - 2026-10-31
+
+### Fixed
+- `ralph-qa` send 가 폴더를 잡은 직후, 좌석 작업 전에 `.sent.md` 표지를 send 당 한 번 쓴다. 두 send 가 겹치거나 첫 send 가 결과를 쓰기 전에 멈춰도, 다음 send 는 같은 페이로드를 다시 보내지 않는다(외부 좌석 과금과 사본 겹침 방지). 표지를 못 쓰면 새 멈춤 `sent-mark` 로 끝나고 아무것도 보내지 않는다. `sent` 안내는 좌석의 답이 답 폴더(`ralph-qa-out.*`)에 있다고 적는다.
+- `progress-mon`
+  - start 잠금: 읽기 전용 폴더 같은 진짜 권한 오류는 15초를 기다리지 않고 1초대에 까닭과 함께 끝난다. 낡은 잠금을 넘겨받는 표지 자리도 같다.
+  - `server.log` 가 링크, 특수 파일, 하드링크면 쓰지도 비우지도 않고, 기록이 멈춘 것을 `status` 경고로 한 번 알린다. 그 밖 파일 시스템 오류도 코드와 함께 한 번 알린다.
+  - 메모리 대상(`CLAUDE.md`, `AGENTS.md`, `MEMORY.md` 등)이 하드링크면 거부한다. 검사 뒤 쓰기 전에 하드링크나 특수 파일로 바뀌면 쓰지 않고, FIFO 에서 멈추지 않는다. 거부 문구에 종류별 대안을 적는다.
+  - 커밋 해시는 4~40자 16진으로 통일한다. `check` 가 `commitRegex` 를 실제 커밋 제목으로 돌려 보고(스토리가 없으면 화면처럼 돌리지 않음), `config.json` 이 폴더나 특수 파일이면 까닭을 밝힌다.
+  - README 보안 요약을 실제 동작에 맞춘다.
+- `3d-intro-build` 결과 페이지: 소개 안 버튼이나 링크에 포커스가 있으면 좌우 키를 그 요소에 맡긴다(장면 점과 nav 는 그대로 장면 이동). 안쪽 요소의 blur 가 누르는 중 상태를 풀어 스냅이 잘못 일어나던 것을 고친다. 결과 페이지의 e2e 시험은 기준 프레임이 빈 화면이면 실패한다.
+- `remains`: `for` 반복으로 시험을 여러 번 돌릴 때 반복마다 `|| exit /b 1`(POSIX 는 `|| exit 1`)을 붙이라고 안내한다. 앞 반복의 실패가 마지막 반복의 종료 코드에 가려지지 않는다.
+- `ultraqa`: 게이트 명령(`package.json` 시험 명령 등)을 찾은 그대로 돌리고, 시간 제한 같은 플래그를 더하거나 바꾸지 않는다. 바꿔야 하면 사용자에게 묻는다.
+
+### Notes
+- 훅 코드는 바뀌지 않아 Codex 플러그인 사용자에게 `/hooks` 신뢰를 다시 묻지 않는다.
+
 ## [0.23.0] - 2026-10-30
 
 ### Added

package/README.md

@@ -100,7 +100,7 @@ Claude Code는 `/banker:<이름>`, Codex는 `$banker-<이름>`(플러그인 설
 | `/banker:front-qa` | 스펙(note) 기반 프론트엔드 구현 + parity QA |
 | `/banker:setup` | 구성요소·의존성 설치 오케스트레이터 (multi-select) |
 | `/graceful-pause` | 작업 중에도 바로 실행되는 정지 요청. 지금 단계만 끝내고 멈춘 뒤 보고하고 지시를 기다림 (Claude Code 2.1.289 이상, mod. Codex 는 작업 중에 `$banker-graceful-pause` 를 보내면 실행 중인 도구 호출이 끝난 뒤 멈춤) |
-| `$banker-teamwork` (Codex 전용 스킬) | 같은 기기의 Codex CLI 세션끼리 피어 협업을 켜고 끔(`on` 기본, `off`, `status`). 켜면 열린 세션과 새 세션이 모두 팀으로 동작하고, 역할은 각 세션에 말로 주며, 요청과 결과는 Codex 내장 `codex queue` 로 오감. 플러그인 길은 `$banker:teamwork` |
+| `$banker-teamwork` (Codex 전용 스킬) | 같은 기기의 Codex CLI 세션끼리 피어 협업을 켜고 끔(`on` 기본, `off`, `status`). 켜면 열린 세션과 새 세션이 모두 팀으로 동작하고, 역할은 각 세션에 말로 주며, 요청과 결과는 Codex 내장 `codex queue` 로 오감. 보낼 대상은 역할, `/rename` 으로 정한 세션 이름, 짧은ID 로 지정. 플러그인 길은 `$banker:teamwork` |
 | `/progress` | 진행 상황 패널을 켜고 끔(`show` 기본 토글, `on`, `off`). 맨 위는 이 세션이 쓰거나 읽은 마지막 계획 파일(`.omc/plans/*.md`, `docs/superpowers/plans/*.md`, `~/.claude/plans/*.md`, ralph `prd.json`, ultragoal `goals.json`) 전체. Notion 토글 목록처럼 제목이 그 아래 내용을, 목록 항목이 하위 항목을, 표와 코드 블록이 행과 줄을 품고, 처음에는 큰 제목만 접힌 채 보임. 체크박스는 완료와 대기, 제목은 그 아래 체크 수(`2/5`). 그 아래 단계는 할 일 목록(Claude 의 작업 목록이나 `mcp__banker__todo`), 없으면 이 세션의 요청이고, 하위 목록은 그 단계가 진행 중일 때 한 도구 호출 한 단계까지. 작업 중에도 바로 실행됨(2.1.289 이상에서 확인) (mod. Codex 는 `$banker-progress` 스킬이 지금 세션의 계획 트리, `update_plan` 단계, 최근 도구 호출을 텍스트로 보이고, tmux 안이면 `--pane` 으로 오른쪽 칸에 갱신) |
 
 Claude Code 2.1.296 은 Claude 5 모델(Opus 5.5 등)에 작업 목록 도구(TaskCreate, TodoWrite)를 주지 않습니다. 그래서 `/progress` 를 켜면 모델에게 할 일 도구 `mcp__banker__todo` 를 줍니다(다음 요청부터). 모델이 여러 단계 작업을 시작할 때 할 일 목록을 보내면 그 목록이 단계가 됩니다. 한 단계로 끝나는 일에는 쓰지 않으므로 그때는 요청이 단계입니다. 내장 작업 목록 도구가 있는 세션(옛 모델, `CLAUDE_CODE_ENABLE_TODO_TOOLS=1`)에는 이 도구를 더하지 않습니다. 도구는 `/progress off` 뒤에도 세션이 끝날 때까지 남고, 그동안 부르면 패널이 꺼져 있다고 답합니다.

package/codex/skills/teamwork/SKILL.md

@@ -79,9 +79,12 @@ argument-hint: "on | off | status"
 |---|---|
 | `<래퍼> role <역할>` | 사용자가 이 세션의 역할을 정해 줄 때 |
 | `<래퍼> peers` | 보내기 전 피어 확인 |
-| `<래퍼> send <역할\|짧은ID\|all> '<요청>'` | 다른 세션에 일을 맡길 때 |
+| `<래퍼> send <역할\|이름\|짧은ID\|all> '<요청>'` | 다른 세션에 일을 맡길 때 |
 | `<래퍼> reply <요청 번호> '<결과>'` | 받은 요청의 결과를 보낼 때. 요청 하나에 한 번만 |
 
+- 이름은 Codex `/rename` 으로 정한 세션 이름. 피어 목록의 `이름:` 값
+  - 공백과 `-` 를 같게 보고 대소문자를 가리지 않음 (`'리뷰 담당'` 과 `리뷰-담당`)
+  - 대상 찾는 순서: `all`, 역할, 이름, 짧은ID. 같은 역할이나 이름이 여럿이면 모두에게 보냄
 - 본문은 홑따옴표로 감쌈. 따옴표, `$`, 백틱, 여러 줄이 있으면 작업 폴더에 파일로 쓰고 `--file <경로>` 를 씀
   - `--file` 은 이 세션의 작업 폴더(훅이 기록한 세션 폴더)와 임시 폴더 안의 파일만 읽음. 명령을 부른 폴더는 기준이 아님
   - 링크를 따라가지 않고, 연 파일이 확인한 파일과 같은지(dev, ino) 봄
@@ -100,6 +103,8 @@ argument-hint: "on | off | status"
 - 피어 목록의 폴더는 훅이 기록한 세션 폴더만 씀. 명령(`role`, `send`, `reply`, `on`)을 부른 폴더는 기록하지 않음
   - 목록에 보일 때는 제어 문자와 줄 구분 문자를 `?` 로 바꾸고 200자로 자른 뒤 JSON 문자열로 감쌈
   - 역할 이름도 기록할 때와 보일 때 모두 공백, 제어 문자, 괄호, 따옴표를 `-` 로 바꿈
+  - 세션 이름(`/rename`)은 폴더처럼 바꾸고 64자로 잘라 JSON 문자열로 감쌈. 머리말의 보낸 세션에 쓸 때는 역할 이름처럼 바꿈
+  - `session_index.jsonl` 이 일반 파일이 아니면 읽지 않고 이름 없이 동작함. FIFO 에서 멈추지 않음. 1MiB 를 넘으면 끝부분만 읽음
 - 승인 규칙(`$CODEX_HOME/rules/teamwork.rules`)은 래퍼의 하위 명령 6개만 허용함. 첫 줄 표지(`# teamwork <판>`)가 없는 같은 이름의 사용자 파일은 덮어쓰지도 지우지도 않음
 - 래퍼와 훅은 샌드박스 밖에서 돎. 그래서
   - `node`, `codex`, `ps`, `sh` 는 `on` 때 찾은 절대 경로만 씀. PATH 로 다시 찾지 않음. 기록이 없거나 파일이 사라지면 훅은 빈 응답과 한 줄 안내, 명령은 6
@@ -131,7 +136,8 @@ argument-hint: "on | off | status"
 - Linux, macOS. Node 18 이상, Codex 0.149.0 이상 (`codex queue`). Windows 는 `on` 이 까닭을 밝히고 6. Codex 0.160.1 Windows 실측에서 승인 규칙 판정(`codex execpolicy check`)이 래퍼를 바로 부르는 꼴에만 맞고 PowerShell 로 부르는 꼴(`& '<래퍼>' send ...`)에는 맞지 않아, 쓸 때마다 승인을 물어야 하기 때문
 - 같은 `CODEX_HOME` 을 쓰는 세션끼리만 통신
 - Codex 0.165.0 은 훅과 명령을 상주 서버(app-server)에서 돌림. 그래서 세션의 pid 를 알 수 없고, 닫은 세션의 정리는 마지막 활동 뒤 24시간 기준
-- 세션 이름(`/rename`)으로 보내는 `codex queue` 는 0.165.0 에서 "No active session found" 로 실패. 그래서 UUID(`CODEX_THREAD_ID`)로 등록하고 보냄
+- 세션 이름(`/rename`)은 Codex 가 `$CODEX_HOME/session_index.jsonl` 에 덧붙이는 줄 중 그 세션의 마지막 줄에서 읽음. 이름을 바꾸면 다른 세션은 다음 입력 때 바뀐 목록을 받음
+- 전송은 이름이 아니라 UUID(`CODEX_THREAD_ID`)로 함. 이름으로 보내는 `codex queue` 는 0.165.0 에서 "No active session found" 로 실패하기 때문. `send <이름>` 은 스크립트가 UUID 로 바꿔 보냄
 - 받는 세션이 작업 중이면 그 턴이 끝난 뒤 처리. Esc 로 중단하면 큐에 남음
 - `off` 전에 보낸 요청 중 처리되지 않은 것은 받는 쪽이 처리하지 않음. 보낸 쪽은 알 수 없음
 - 훅을 신뢰하기 전에는 `codex exec` 가 응답 없이 멈출 수 있음. TUI 에서 한 번 신뢰한 뒤 사용

package/codex/skills/teamwork/scripts/teamwork.mjs

@@ -13,7 +13,7 @@ import crypto from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
-const VERSION = '0.3.0';
+const VERSION = '0.3.1';
 const MIN_CODEX = [0, 149, 0];
 const CODEX_HOME = path.resolve(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'));
 const TW = path.join(CODEX_HOME, 'teamwork');
@@ -28,6 +28,8 @@ const TURN = path.join(TW, 'turn');
 const LOG = path.join(TW, 'log.jsonl');
 const ORPHAN = path.join(TW, 'orphan-noticed');
 const HOOKS = path.join(CODEX_HOME, 'hooks.json');
+const INDEX = path.join(CODEX_HOME, 'session_index.jsonl');
+const INDEX_TAIL = 1024 * 1024;
 const RULES = path.join(CODEX_HOME, 'rules', 'teamwork.rules');
 const RULES_MARK = '# teamwork ';
 const ALLOWED = ['peers', 'role', 'send', 'reply', 'status', 'version'];
@@ -71,7 +73,7 @@ function writeText(file, text) { ensureDir(path.dirname(file)); fs.writeFileSync
 
 function shortId(id) { return String(id).replace(/-/g, '').slice(-6); }
 
-function isUuid(s) { return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s || ''); }
+function isUuid(s) { return typeof s === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s); }
 
 function state() { return readJson(STATE, { enabled: false }); }
 
@@ -283,6 +285,35 @@ function dropStale(file, p) {
   return again;
 }
 
+// ---------- 세션 이름 (/rename) ----------
+
+// Codex 는 /rename 이름을 $CODEX_HOME/session_index.jsonl 에 한 줄씩 덧붙인다. 같은 id 의 마지막 줄이 지금 이름이다.
+// 특수 파일에서 멈추지 않게 O_NONBLOCK 으로 열어 일반 파일만 읽고, 커지면 끝 1MiB 만 본다
+function readIndexTail() {
+  let fd;
+  try { fd = fs.openSync(INDEX, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK || 0)); } catch { return ''; }
+  try {
+    const st = fs.fstatSync(fd);
+    if (!st.isFile()) return '';
+    const len = Math.min(st.size, INDEX_TAIL);
+    const buf = Buffer.alloc(len);
+    const text = buf.toString('utf8', 0, fs.readSync(fd, buf, 0, len, st.size - len));
+    return len < st.size ? text.slice(text.indexOf('\n') + 1) : text;
+  } catch { return ''; } finally { fs.closeSync(fd); }
+}
+
+export function parseThreadNames(text) {
+  const names = new Map();
+  for (const line of String(text).split('\n')) {
+    let e;
+    try { e = JSON.parse(line); } catch { continue; }
+    if (e && isUuid(e.id) && typeof e.thread_name === 'string') names.set(e.id.toLowerCase(), e.thread_name.trim());
+  }
+  return names;
+}
+
+function threadNames() { return parseThreadNames(readIndexTail()); }
+
 function roster() {
   let names = [];
   try { names = fs.readdirSync(PEERS).filter((n) => n.endsWith('.json')); } catch { return []; }
@@ -295,28 +326,45 @@ function roster() {
     const keep = isStale(p, now) ? dropStale(file, p) : p;
     if (keep) list.push(keep);
   }
-  return list.sort((a, b) => String(a.startedAt).localeCompare(String(b.startedAt)));
+  const titles = list.length ? threadNames() : new Map();
+  return list.map((p) => ({ ...p, name: titles.get(p.id.toLowerCase()) || '' }))
+    .sort((a, b) => String(a.startedAt).localeCompare(String(b.startedAt)));
 }
 
+const NAME_SEP = /[\s\u0000-\u001f\u007f[\]()#:'"`$\\]+/g;
+
 // 역할 이름: 머리말과 목록의 줄을 흉내 내지 못하게 공백, 제어 문자, 괄호와 따옴표를 바꾼다. 기록할 때와 보일 때 모두 쓴다
-function roleName(s) { return String(s || '').normalize('NFKC').trim().replace(/[\s\u0000-\u001f\u007f[\]()#:'"`$\\]+/g, '-').slice(0, 32); }
+function roleName(s) { return String(s || '').normalize('NFKC').trim().replace(NAME_SEP, '-').slice(0, 32); }
+
+// 세션 이름 비교: 공백과 '-' 를 같게 보고 대소문자를 가리지 않는다 ('리뷰 담당' 과 리뷰-담당). 앞뒤에 남은 '-'(따옴표 등)는 뺀다
+function nameKey(s) { return String(s || '').normalize('NFKC').trim().toLowerCase().replace(NAME_SEP, '-').replace(/^-+|-+$/g, ''); }
 
-function label(p) { const r = roleName(p.role); return r ? `${r}(${shortId(p.id)})` : shortId(p.id); }
+// 머리말의 보낸 세션: 역할, 없으면 세션 이름
+function label(p) { const r = roleName(p.role) || roleName(p.name); return r ? `${r}(${shortId(p.id)})` : shortId(p.id); }
 
-// 폴더는 그 세션의 훅 입력(cwd)에서 온다. 줄을 나눠 지시처럼 보이지 못하게 제어 문자를 바꾸고 200자로 자른 뒤 JSON 문자열로 감싼다
-function showCwd(s) { return sanitize(JSON.stringify(String(s).replace(/[\u0000-\u001f\u007f\u2028\u2029]/g, '?').slice(0, 200))); }
+// 폴더는 그 세션의 훅 입력(cwd)에서 온다. 줄을 나눠 지시처럼 보이지 못하게 제어 문자를 바꾸고 잘라서 JSON 문자열로 감싼다. 세션 이름도 같게
+function showCwd(s, max = 200) { return sanitize(JSON.stringify(String(s).replace(/[\u0000-\u001f\u007f\u2028\u2029]/g, '?').slice(0, max))); }
+
+function peerLine(p, selfId) {
+  const name = p.name ? ` 이름:${showCwd(p.name, 64)}` : '';
+  return `- ${shortId(p.id)}${name} 역할:${roleName(p.role) || '미정'} 폴더:${p.cwd ? showCwd(p.cwd) : '?'}${p.id === selfId ? ' (이 세션)' : ''}`;
+}
 
 function rosterText(list, selfId) {
   if (!list.length) return '등록된 세션 없음';
-  return list.map((p) => `- ${shortId(p.id)} 역할:${roleName(p.role) || '미정'} 폴더:${p.cwd ? showCwd(p.cwd) : '?'}${p.id === selfId ? ' (이 세션)' : ''}`).join('\n');
+  return list.map((p) => peerLine(p, selfId)).join('\n');
 }
 
+// 대상 찾는 순서: all, 역할, 세션 이름(/rename), 짧은ID 나 UUID. 같은 역할이나 이름이 여럿이면 모두에게 보낸다
 function resolveTargets(to, selfId) {
   const list = roster().filter((p) => p.id !== selfId);
   const key = String(to).trim().toLowerCase();
   if (key === 'all') return list;
   const byRole = list.filter((p) => p.role && p.role.toLowerCase() === key);
   if (byRole.length) return byRole;
+  const nk = nameKey(to);
+  const byName = list.filter((p) => nk && p.name && nameKey(p.name) === nk);
+  if (byName.length) return byName;
   return list.filter((p) => shortId(p.id) === key.replace(/-/g, '') || p.id.toLowerCase() === key);
 }
 
@@ -324,15 +372,16 @@ function resolveTargets(to, selfId) {
 
 function protocolText(selfId, list) {
   const w = shq(WRAPPER);
-  const me = selfId ? readJson(peerFile(selfId), {}) : {};
+  const me = list.find((p) => p.id === selfId) || (selfId ? readJson(peerFile(selfId), {}) : {});
+  const name = me.name ? ` 이름:${showCwd(me.name, 64)}` : '';
   return [
     '[teamwork 켜짐] 이 기기의 Codex 세션들이 피어로 협업한다.',
-    `이 세션: ${selfId ? shortId(selfId) : '?'} 역할:${roleName(me.role) || '미정'}`,
+    `이 세션: ${selfId ? shortId(selfId) : '?'}${name} 역할:${roleName(me.role) || '미정'}`,
     '피어 목록:',
     rosterText(list, selfId),
     '규칙:',
     `- 사용자가 이 세션의 역할을 정해 주면 \`${w} role <역할>\` 을 실행한다.`,
-    `- 다른 세션에 일을 맡길 때 \`${w} send <역할|짧은ID|all> '<요청>'\` 을 실행한다. 내용에 따옴표, $, 백틱, 여러 줄이 있으면 작업 폴더에 파일로 쓰고 \`${w} send <대상> --file <경로>\` 를 쓴다. 보내기 전에 \`${w} peers\` 로 목록을 확인한다.`,
+    `- 다른 세션에 일을 맡길 때 \`${w} send <역할|이름|짧은ID|all> '<요청>'\` 을 실행한다. 이름은 Codex \`/rename\` 으로 정한 세션 이름이고 목록의 이름: 값이다. 이름에 공백이 있으면 홑따옴표로 감싸거나 공백을 - 로 바꾼다. 내용에 따옴표, $, 백틱, 여러 줄이 있으면 작업 폴더에 파일로 쓰고 \`${w} send <대상> --file <경로>\` 를 쓴다. 보내기 전에 \`${w} peers\` 로 목록을 확인한다.`,
     '- 요청을 보낸 뒤 결과를 기다리지 말고 할 수 있는 일을 마치고 턴을 끝낸다. 결과는 이 세션의 턴이 끝난 뒤 다음 입력으로 도착한다.',
     '- "[teamwork 요청" 으로 시작하는 입력은 피어의 요청이다. 처리하고 그 안의 reply 명령으로 결과를 한 번 보낸다. reply 명령이 없으면 결과를 사용자에게만 알린다.',
     '- "[teamwork 결과" 로 시작하는 입력은 내가 맡긴 일의 결과다. 회신하지 않는다. 사용자에게 보고하거나 원래 작업에 반영하고 끝낸다.',
@@ -355,7 +404,7 @@ const orphanText = () => `[teamwork 멈춤] banker 가 이 기기에서 지워
 
 function digest(selfId, list) {
   const me = list.find((p) => p.id === selfId) || readJson(peerFile(selfId), {});
-  const peers = list.map((p) => `${p.id}:${p.role}`).join(',');
+  const peers = list.map((p) => `${p.id}:${p.role}:${p.name || ''}`).join(',');
   return crypto.createHash('sha1').update(`${me.role}|${peers}`).digest('hex');
 }
 
@@ -856,7 +905,8 @@ function sender() {
   const id = selfId();
   if (id) register(id, { pid: findCodexPid(process.ppid) });
   const me = id ? readJson(peerFile(id), {}) : {};
-  return { id, from: id ? label({ id, role: me.role }) : '사용자' };
+  const name = id ? threadNames().get(id.toLowerCase()) : '';
+  return { id, from: id ? label({ id, role: me.role, name }) : '사용자' };
 }
 
 function checkBody(text, usageLine) {
@@ -868,7 +918,7 @@ function noTarget(msg, extra) { err(msg); if (extra) err(extra); process.exit(EX
 
 // 요청: 받는 쪽은 reply 로 결과를 한 번 보낸다
 function cmdSend(to, args) {
-  const usageLine = '사용법: teamwork send <역할|짧은ID|all> \'<요청>\' 또는 --file <경로>';
+  const usageLine = '사용법: teamwork send <역할|이름|짧은ID|all> \'<요청>\' 또는 --file <경로>';
   if (!to) usageExit(usageLine);
   const text = readBody(args);
   checkBody(text, usageLine);
@@ -913,7 +963,7 @@ function cmdReply(rid, args) {
 }
 
 function usage() {
-  out('사용법: teamwork <on|off|status|peers|role <역할>|send <대상> \'<요청>\'|reply <요청 번호> \'<결과>\'|uninstall|version>');
+  out('사용법: teamwork <on|off|status|peers|role <역할>|send <역할|이름|짧은ID|all> \'<요청>\'|reply <요청 번호> \'<결과>\'|uninstall|version>');
 }
 
 const COMMANDS = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "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/3d-intro-build/SKILL.md

@@ -124,7 +124,7 @@ if (creds._tracked) throw new Error(`프로젝트 키 파일을 git 이 추적
 | `CAMERA_FEEL` | CLIP_MODE 를 따름. dive 면 "장면마다 바깥에서 들어감"(장면별 MOVE, b 는 나가기 없음, c 는 있음), chain 과 holdFlight 면 잔잔한 전진 활공(fly-through, walkthrough, locked-iso 중 고름) | 카메라 움직임 |
 | `MOBILE` | no | yes 면 약 2배 비용(세로 체인 추가) |
 | `STILLS_SOURCE` | gpt-image-2 | 코히전 강화가 필요하면 FLUX 옵트인 |
-| `STEP_NAV` | yes | 장면 단위 이동(`step-nav.js`). 멈춤 자리는 장면마다 시작점(dive 첫 프레임, 나가기는 다음 장면으로 잇는 구간), 마지막 장면 끝, 본문 시작. 휠 1칸과 방향키(위아래, 좌우) 1번은 다음 멈춤 자리까지 절반, 2번이면 한 장면. PageUp/PageDown, Space, 스와이프는 한 장면, Home 은 첫 장면 시작, End 는 마지막 장면 끝으로 애니메이션 없이 바로 가고, 장면 점(클릭, 또는 점에 포커스를 두고 Enter 나 Space)도 그 장면 시작점으로 바로 간다(포스터 디코드 뒤, 문구도 바로). 포스터 디코드를 기다리는 시간이 150ms(`loadingDelayMs`)를 넘으면 화면 가운데에 작은 불러오는 중 표시(`loadingLabel`, 화면 읽기 프로그램에 알림, 포커스와 입력은 막지 않음, 움직임 줄이기에서는 돌지 않음)를 보이고 이동하면 바로 숨긴다. 애니메이션 이동의 대기(최대 300ms)에도 같은 규칙이다. 멈춤 자리나 절반 지점이 아닌 곳에 멈추면 잠시 뒤 가까운 장면 시작점으로 붙는다. 멈춘 자리에서는 그 장면 문구를 보인다. 스크롤 동작을 가로채므로 원하지 않으면 매니페스트 `"stepNav": false` 로 끈다 |
+| `STEP_NAV` | yes | 장면 단위 이동(`step-nav.js`). 멈춤 자리는 장면마다 시작점(dive 첫 프레임, 나가기는 다음 장면으로 잇는 구간), 마지막 장면 끝, 본문 시작. 휠 1칸과 방향키(위아래, 좌우) 1번은 다음 멈춤 자리까지 절반, 2번이면 한 장면. 장면 안 버튼이나 링크에 포커스가 있으면 좌우 키는 그 요소에 맡기고 장면을 옮기지 않는다(장면 점과 상단 메뉴는 예외로 좌우 키로 옮긴다). PageUp/PageDown, Space, 스와이프는 한 장면, Home 은 첫 장면 시작, End 는 마지막 장면 끝으로 애니메이션 없이 바로 가고, 장면 점(클릭, 또는 점에 포커스를 두고 Enter 나 Space)도 그 장면 시작점으로 바로 간다(포스터 디코드 뒤, 문구도 바로). 포스터 디코드를 기다리는 시간이 150ms(`loadingDelayMs`)를 넘으면 화면 가운데에 작은 불러오는 중 표시(`loadingLabel`, 화면 읽기 프로그램에 알림, 포커스와 입력은 막지 않음, 움직임 줄이기에서는 돌지 않음)를 보이고 이동하면 바로 숨긴다. 애니메이션 이동의 대기(최대 300ms)에도 같은 규칙이다. 멈춤 자리나 절반 지점이 아닌 곳에 멈추면 잠시 뒤 가까운 장면 시작점으로 붙는다. 멈춘 자리에서는 그 장면 문구를 보인다. 스크롤 동작을 가로채므로 원하지 않으면 매니페스트 `"stepNav": false` 로 끈다 |
 | `PANEL` | 없음 | `glass` 면 흐린 유리 문구 패널(`panel-glass.css`) |
 
 ---

package/skills/3d-intro-build/references/step-nav.js

@@ -254,6 +254,9 @@
   const pressable = function (t) {
     return Boolean(t) && (/^(BUTTON|A|SUMMARY)$/.test(t.tagName || '') || /^(button|link|checkbox|switch|menuitem|tab|option)$/.test(role(t)));
   };
+  // The intro's own controls (the route dots and the nav items) keep moving the scene on Left/Right after a click
+  // focuses them; another focused button or link (in scene content) leaves Left/Right to itself.
+  const ownControl = function (t) { return Boolean(t && t.closest && t.closest('.sw-nav, .sw-route')); };
   const KEYS = { ArrowDown: { steps: 1 }, ArrowRight: { steps: 1 }, ArrowUp: { steps: -1 }, ArrowLeft: { steps: -1 },
     PageDown: { scenes: 1 }, PageUp: { scenes: -1 }, Home: { to: 0, instant: true }, End: { to: 'last', instant: true } };
 
@@ -261,6 +264,7 @@
   function keyInput(e) {
     if (e.altKey || e.ctrlKey || e.metaKey || editable(e.target)) return null;
     if (e.key === ' ') return pressable(e.target) ? null : { scenes: e.shiftKey ? -1 : 1 };
+    if ((e.key === 'ArrowLeft' || e.key === 'ArrowRight') && pressable(e.target) && !ownControl(e.target)) return null;
     return KEYS[e.key] || null;
   }
 
@@ -640,7 +644,10 @@
     window.addEventListener('pointerdown', function () { ctx.pressed = true; clearTimeout(rest); }, true);
     // a press can end without a pointerup: a context menu, a release outside the window, a lost capture, the tab hidden
     const release = function () { if (!ctx.pressed) return; ctx.pressed = false; later(); };
-    ['pointerup', 'pointercancel', 'lostpointercapture', 'contextmenu', 'blur'].forEach(function (k) { window.addEventListener(k, release, true); });
+    ['pointerup', 'pointercancel', 'lostpointercapture', 'contextmenu'].forEach(function (k) { window.addEventListener(k, release, true); });
+    // Capture catches the window losing focus; a focused element inside the page losing focus (its own blur, which
+    // capture also sees) must not end a press, or a click that moves focus would clear `pressed` mid-press.
+    window.addEventListener('blur', function (e) { if (e.target === window) release(); }, true);
     document.addEventListener('visibilitychange', function () { if (document.hidden) release(); });
     window.addEventListener('scroll', function () {
       if (ctx.nav.state().moving) return;

package/skills/progress-mon/README.md

@@ -67,6 +67,8 @@
 - 자료 폴더 파일(`server.json` 포함)은 서빙하지 않는다. 오류 응답은 일반 문구만, 스택은 `server.log` 에만
 - 응답 머리: `cache-control: no-store`, `x-content-type-options: nosniff`, `referrer-policy: no-referrer`, `content-security-policy: default-src 'none'; style-src 'unsafe-inline'; img-src data:`
 - `stop` 은 상태 파일 PID 와 신원 응답 PID 가 같을 때만
+- 자료 폴더나 그 위 `.omc`, `.omx` 가 링크면 모든 명령을 거부한다(저장소가 심은 링크로 밖에 쓰거나 지우지 않게)
+- `server.log` 가 링크, 특수 파일, 하드링크면 쓰지도 비우지도 않고, 기록이 멈춘 것을 status 경고로 한 번 알린다. 자료 파일(`config.json` 등)은 링크를 따라 읽되 일반 파일만 읽는다. 메모리 대상은 프로젝트(또는 `--memory-dir`) 밖을 가리키는 링크와 하드링크를 거부한다
 
 ## Codex override 가려짐 해소
 

package/skills/progress-mon/SKILL.md

@@ -88,7 +88,7 @@ progress-mon skill body marker v1
 | `stop` | 없음 | 상태 파일 PID 가 이 서버일 때만 끔 |
 | `status` | 없음 | 실행 여부, URL, PID, 자료 폴더, 탭별 자료 유무(깨진 JSON 은 깨짐), 시작 시각, 요청 수, 마지막 오류 시각. 서버를 띄운 뒤 `config.json` 의 `port`, `portStrict`, `hosts` 가 바뀌었으면 경고(그 셋만 `stop` 뒤 `start` 해야 적용, 나머지는 다음 응답에 반영) |
 | `export` | `<file> [--now <ISO>]` | 4탭을 한 HTML 파일로. 외부 자원 없음, `file://` 에서 탭 전환. 사용자가 지시할 때만 만든다 |
-| `item` | `--key <k> --status todo\|doing\|done --text <t> [--note <t>] [--issue <t>] [--at <ISO>] [--commit <hash>]` | 기타 항목. 같은 key 는 대체하고 시작 시각 유지(시작 시각은 `doing` 으로 기록할 때만). `--at` 은 지금 대신 그 시각으로 기록(시간대 필수). `--commit` 은 7~40자 16진 해시(commit Hash 칸에 앞 7자리). 빼면 있던 해시 유지 |
+| `item` | `--key <k> --status todo\|doing\|done --text <t> [--note <t>] [--issue <t>] [--at <ISO>] [--commit <hash>]` | 기타 항목. 같은 key 는 대체하고 시작 시각 유지(시작 시각은 `doing` 으로 기록할 때만). `--at` 은 지금 대신 그 시각으로 기록(시간대 필수). `--commit` 은 4~40자 16진 해시(commit Hash 칸에 앞 7자리). 빼면 있던 해시 유지 |
 | `note` | `--key <k> [--note <t>] [--issue <t>]` | 단계(`stage:<id>`)나 스토리 행의 비고, 문제점. 빈 값은 그 칸을 지움 |
 | `stage` | `--id <id> --status started\|done\|skipped\|failed\|stopped [--label <t>]` | 단계 상태 기록. 설정에 없는 id 는 새 단계 행 |
 | `story` | `--id <id> (--status todo\|doing\|done \| --commit <hash>) [--name <t>]` | 스토리 상태나 완료 커밋 기록. 설정에 없는 id 는 새 스토리 행 |

package/skills/progress-mon/references/items.md

@@ -30,7 +30,7 @@
 
 | 명령 | 동작 |
 |---|---|
-| `item --key <k> --status <s> --text <t> [--note <t>] [--issue <t>] [--at <ISO>] [--commit <hash>]` | 같은 key 는 대체하고 시작 시각 `s` 는 유지. 새 key 는 끝에 추가. `s` 는 `doing` 으로 기록할 때만 정함(처음부터 `done`, `todo` 면 없음). `--at` 이 있으면 지금 대신 그 시각을 `t` 로(`doing` 이면 `s` 도). `--commit` 은 7~40자 16진 해시를 `hash` 에. `--commit` 이 없으면 있던 `hash` 를 유지 |
+| `item --key <k> --status <s> --text <t> [--note <t>] [--issue <t>] [--at <ISO>] [--commit <hash>]` | 같은 key 는 대체하고 시작 시각 `s` 는 유지. 새 key 는 끝에 추가. `s` 는 `doing` 으로 기록할 때만 정함(처음부터 `done`, `todo` 면 없음). `--at` 이 있으면 지금 대신 그 시각을 `t` 로(`doing` 이면 `s` 도). `--commit` 은 4~40자 16진 해시를 `hash` 에. `--commit` 이 없으면 있던 `hash` 를 유지 |
 | `note --key <k> [--note <t>] [--issue <t>]` | 그 key 의 칸만 대체. 빈 값(`--issue ""`)은 그 칸을 지움 |
 | `stage --id <id> --status <s> [--label <t>]` | `stageEvents` 에 한 줄 추가. 설정에 없는 id 는 새 단계 행(이름은 `--label` 또는 id) |
 | `story --id <id> --status <s> [--name <t>]` | `storyStates` 의 그 id 를 대체 |
@@ -46,7 +46,7 @@
 - `s` 는 항목이 `doing` 이 된 시각. 이미 있으면 바꾸지 않는다. `s` 가 없는 항목(처음부터 `done` 이나 `todo`)은 소요시간이 "-"
 - 옛 판이 쓴 자료에는 `s` 와 `t` 가 같은 `done` 항목이 있다(처음부터 `done` 으로 기록한 항목). 이 줄은 소요시간이 "0:00" 으로 보인다. "-" 로 보이게 하려면 그 항목의 `s` 를 지운다
 - `item --at <ISO>`: 날짜, 시각, 시간대(`Z` 또는 `+09:00`)가 모두 있어야 한다(예 `2026-10-20T12:34:56+09:00`, 초는 선택). 그 밖은 종료 1. 지난 커밋은 `git log --format=%cI` 의 커밋 시각을 그대로 넘긴다. 저장은 위 UTC Z 형식
-- `item --commit <hash>`: 7~40자 16진 해시. 그 밖은 종료 1. 손으로 쓴 `hash` 가 이 꼴이 아니면 `check` 가 FAIL. 지난 커밋은 `git log --format=%h` 의 해시를 함께 넘긴다(`--at <%cI> --commit <%h>`)
+- `item --commit <hash>`: 4~40자 16진 해시. 그 밖은 종료 1. 손으로 쓴 `hash` 가 이 꼴이 아니면 `check` 가 FAIL. 지난 커밋은 `git log --format=%h` 의 해시를 함께 넘긴다(`--at <%cI> --commit <%h>`)
 - Z 없는 19자 옛 형식(`YYYY-MM-DDTHH:MM:SS`)은 서버를 실행한 환경의 현지 시각으로 읽는다(옛 진척도 서버와 같음). 옛 자료에는 UTC 값을 Z 없이 쓴 줄도 섞여 있다. 그 줄도 현지로 읽어 옛 화면과 같은 시각을 낸다(시차만큼 이르게 보임)
 - Z 나 시차(`+09:00`)가 붙은 시각은 그 값 그대로 읽는다
 - 손으로 적을 때는 Z 를 붙여 UTC 로 적거나 시차를 붙인다. Z 없는 19자는 서버 시간대가 바뀌면 다른 시각이 된다

package/skills/progress-mon/scripts/pm-check.mjs

@@ -7,7 +7,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { loadConfig, noBom, readRegular, UsageError } from './pm-config.mjs';
-import { readItems, storyList, workflowRoots } from './pm-sources.mjs';
+import { gitLog, regexBatch, readItems, storyList, workflowRoots } from './pm-sources.mjs';
 import { ITEM_STATUS, STAGE_STATUS } from './pm-data.mjs';
 import { archLayout, archFlaws, flowLayout, nameFits, FLOW } from './pm-render.mjs';
 import { color, finite, textW, wrap, TABS } from './pm-html.mjs';
@@ -63,8 +63,32 @@ function checkConfig(ctx, r) {
   return config;
 }
 
+// commitRegex 를 실제 커밋 제목으로 돌려 본다(컴파일만 보던 것). 역추적이 폭발하면 화면은 매 요청 500 인데 check 는
+// 통과하던 것을 FAIL 로 잡는다. 화면처럼 스토리(ids)가 없으면 이 정규식을 쓰지 않으므로 돌리지 않는다.
+// sources.git 이 꺼졌거나 git 저장소가 아니면 돌려보지 못해 WARN.
+function checkCommitRegex(ctx, config, ids, r) {
+  if (!config.commitRegex || !ids.length) return;
+  if (!config.sources.git) return r.warn('config.json', 'commitRegex', 'sources.git 이 꺼져 있어 실제 커밋 제목으로 돌려보지 못함(화면도 이 정규식을 쓰지 않음)');
+  const lines = gitLog(ctx.project, config.sources.gitMax);
+  if (lines === null) return r.warn('config.json', 'commitRegex', 'git 저장소가 아니거나 커밋이 없어 실제 제목으로 돌려보지 못함');
+  try {
+    regexBatch(config.commitRegex, 'commitRegex', lines.map((l) => l.split('|').slice(2).join('|')));
+  } catch (e) {
+    r.fail('config.json', 'commitRegex', e.message);
+  }
+}
+
 // ---------- items.json ----------
 
+// storyCommits 의 값은 해시 문자열이나 {hash}. 둘 다 16진 4~40자(item --commit, story --commit 과 같은 규칙).
+function checkStoryCommits(commits, r) {
+  for (const [id, c] of Object.entries(obj(commits) || {})) {
+    const hash = typeof c === 'string' ? c : obj(c)?.hash;
+    if (typeof hash !== 'string') r.fail('items.json', `storyCommits.${id}`, '해시 문자열 또는 {hash} 가 아님');
+    else if (!/^[0-9a-f]{4,40}$/i.test(hash)) r.fail('items.json', `storyCommits.${id}`, `4~40자 16진 해시가 아님: ${hash}`);
+  }
+}
+
 function checkItems(dir, r) {
   const got = readJson(path.join(dir, 'items.json'));
   if (got.missing) return;
@@ -84,11 +108,9 @@ function checkItems(dir, r) {
     if (!ITEM_STATUS.includes(x.status)) r.fail(F, `${p}.status`, `todo, doing, done 가운데 하나가 아님: ${x.status}`);
     if (typeof x.text !== 'string') r.fail(F, `${p}.text`, '문자열이 아님');
     for (const f of ['key', 't', 's', 'note', 'issue', 'hash']) if (x[f] !== undefined && typeof x[f] !== 'string') r.fail(F, `${p}.${f}`, '문자열이 아님');
-    if (typeof x.hash === 'string' && !/^[0-9a-f]{7,40}$/i.test(x.hash)) r.fail(F, `${p}.hash`, `7~40자 16진 해시가 아님: ${x.hash}`);
+    if (typeof x.hash === 'string' && !/^[0-9a-f]{4,40}$/i.test(x.hash)) r.fail(F, `${p}.hash`, `4~40자 16진 해시가 아님: ${x.hash}`);
   });
-  for (const [id, c] of Object.entries(obj(v.storyCommits) || {})) {
-    if (typeof c !== 'string' && !(obj(c) && typeof c.hash === 'string')) r.fail(F, `storyCommits.${id}`, '해시 문자열 또는 {hash} 가 아님');
-  }
+  checkStoryCommits(v.storyCommits, r);
   for (const [id, s] of Object.entries(obj(v.storyStates) || {})) {
     if (!obj(s) || !ITEM_STATUS.includes(s.status)) r.fail(F, `storyStates.${id}`, '{status: todo|doing|done} 가 아님');
   }
@@ -488,6 +510,7 @@ export function runCheck(ctx, env = process.env) {
   checkItems(ctx.dataDir, r);
   const items = readItems(ctx.dataDir);
   const ids = storyList(config, items).map((s) => s.id);
+  checkCommitRegex(ctx, config, ids, r);
   const req = checkReq(ctx.dataDir, r, ids);
   const flow = checkFlow(ctx.dataDir, r);
   const arch = checkArch(ctx.dataDir, r, config.text.plannedPrefix);

package/skills/progress-mon/scripts/pm-config.mjs

@@ -47,7 +47,8 @@ export const READ_MAX = 32 * 1024 * 1024;
 export function readRegular(file, encoding = 'utf8', fsx = fs, max = READ_MAX) {
   const st = fsx.statSync(file);
   const code = !st.isFile() ? 'EINVAL' : st.size > max ? 'EFBIG' : null;
-  if (code) throw Object.assign(new Error(`${path.basename(file)}: ${code === 'EINVAL' ? '일반 파일 아님' : '크기 상한 초과'}`), { code });
+  // statSync 는 링크를 따라가므로, EINVAL 은 대상이 폴더나 특수 파일일 때(그것을 가리키는 링크 포함)다. EFBIG 는 32 MB 초과.
+  if (code) throw Object.assign(new Error(`${path.basename(file)}: ${code === 'EINVAL' ? '일반 파일 아님(폴더나 특수 파일, 또는 그것을 가리키는 링크)' : '크기 상한 초과(32 MB)'}`), { code });
   return fsx.readFileSync(file, encoding);
 }
 
@@ -285,7 +286,8 @@ export function loadConfig(ctx) {
     text = readRegular(file);
   } catch (e) {
     if (e.code === 'ENOENT') return { config: defaults(ctx.project, ctx.runtime), errors: [], found: false };
-    return { config: defaults(ctx.project, ctx.runtime), errors: [{ path: '$', msg: `읽기 실패(${e.code || 'error'})` }], found: true };
+    // e.message 는 readRegular 가 지은 구체 문구(일반 파일 아님 / 크기 상한 초과)이거나 그 밖 fs 오류다.
+    return { config: defaults(ctx.project, ctx.runtime), errors: [{ path: '$', msg: `읽기 실패: ${e.message || e.code || 'error'}` }], found: true };
   }
   let raw;
   try {

package/skills/progress-mon/scripts/pm-data.mjs

@@ -199,7 +199,7 @@ const AT_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}
 // item: 같은 key 는 대체하고 시작 시각 s 는 유지. 새 key 는 끝에 추가.
 // s 는 doing 으로 기록할 때만 정한다(이미 있으면 유지). 처음부터 done 이나 todo 면 s 없음(소요시간 "-").
 // --at 이 있으면 지금 대신 그 시각을 t 로 쓴다. 지난 커밋을 커밋 시각으로 기록할 때.
-// --commit 은 7~40자 16진 해시. hash 칸에 두고 진척도 표 commit Hash 칸에 앞 7자리로 보인다. --commit 이 없으면 있던 hash 를 유지.
+// --commit 은 4~40자 16진 해시(story --commit 과 같은 규칙). hash 칸에 두고 진척도 표 commit Hash 칸에 앞 7자리로 보인다. --commit 이 없으면 있던 hash 를 유지.
 export function itemChange(o, now) {
   const key = need(o, 'key', 'item');
   const status = need(o, 'status', 'item');
@@ -210,7 +210,7 @@ export function itemChange(o, now) {
     at = typeof o.at === 'string' && AT_RE.test(o.at) ? Date.parse(o.at) : NaN;
     if (!Number.isFinite(at)) throw new UsageError(`--at 은 시간대가 붙은 ISO 8601 시각(예 2026-10-29T12:34:56+09:00): ${o.at}`);
   }
-  if (o.commit !== undefined && !(typeof o.commit === 'string' && /^[0-9a-f]{7,40}$/i.test(o.commit))) throw new UsageError(`--commit 은 7~40자 16진 해시(받은 값 ${o.commit})`);
+  if (o.commit !== undefined && !(typeof o.commit === 'string' && /^[0-9a-f]{4,40}$/i.test(o.commit))) throw new UsageError(`--commit 은 4~40자 16진 해시(받은 값 ${o.commit})`);
   const t = isoSec(at);
   return (v) => {
     const i = v.items.findIndex((x) => obj(x) && x.key === key);

package/skills/progress-mon/scripts/pm-memory.mjs

@@ -167,6 +167,10 @@ export function measureCodex(project, env = process.env) {
 // ---------- 경고 줄 ----------
 
 const MEM_ALT = '대안: --memory claude-md 로 다시 등록(CLAUDE.md 는 한도 없음)';
+// init 의 메모리 대상이 거부될 때 안내하는 종류별 대안.
+const CLAUDE_ALT = '대안: --memory agents-md, 또는 --memory auto-memory --memory-dir <dir>';
+const AGENTS_ALT = '대안: --memory claude-md, 또는 --memory auto-memory --memory-dir <dir>';
+const AUTO_ALT = '대안: 다른 --memory-dir, 또는 --memory claude-md 나 agents-md';
 const CODEX_ALT = '대안: 프로젝트 지시 파일 정리(banker cleansing-memory)';
 export const SHADOW_WARN = '경고: AGENTS.override.md 에 블록만 있어 AGENTS.md 가 가려짐';
 
@@ -201,46 +205,67 @@ const within = (a, b) => {
   return !rel.startsWith('..') && !path.isAbsolute(rel);
 };
 
+// 링크의 대상 stat. 대상이 없거나 실제 경로가 base 밖이면 UsageError.
+function linkTarget(file, name, base, tail) {
+  let st;
+  let real;
+  try {
+    st = fs.statSync(file);
+    real = fs.realpathSync(file);
+  } catch {
+    throw new UsageError(`${name} 은 대상이 없는 링크라 거부${tail}`);
+  }
+  if (!within(fs.realpathSync(base), real)) throw new UsageError(`${name} 은 ${path.basename(base)} 밖을 가리키는 링크라 거부${tail}`);
+  return st;
+}
+
+// 파일을 UTF-8 로 읽는다(BOM 은 뗌). UTF-8 이 아니면 UsageError.
+function readUtf8(file, name, tail) {
+  const buf = fs.readFileSync(file);
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(buf);
+  } catch {
+    throw new UsageError(`${name} 이 UTF-8 이 아니라 거부${tail}`);
+  }
+}
+
 // 덧붙일 수 있는 파일인지. 일반 파일이나, 실제 경로가 base(프로젝트 루트나 --memory-dir) 안인 일반 파일을 가리키는 링크만.
 // 저장소가 심은 링크로 밖의 파일에 덧붙이지 않게 한다. CLAUDE.md -> AGENTS.md 같은 안쪽 링크는 받는다. 없으면 새로 만든다.
+// 하드링크(nlink > 1)는 거부한다. 다른 이름이 어디 있는지 알 수 없어, 밖의 파일과 같은 내용일 수 있다.
 // 돌려줌: { exists, text, eol }. 거부는 UsageError.
-function inspect(file, name, base) {
+function inspect(file, name, base, alt = '') {
+  const tail = alt ? `. ${alt}` : '';
   let lst;
   try {
     lst = fs.lstatSync(file);
   } catch (e) {
     if (e.code === 'ENOENT') return { exists: false, text: '', eol: '\n' };
-    throw new UsageError(`${name} 을 읽지 못함(${e.code || e.message})`);
-  }
-  let st = lst;
-  if (lst.isSymbolicLink()) {
-    let real;
-    try {
-      st = fs.statSync(file);
-      real = fs.realpathSync(file);
-    } catch {
-      throw new UsageError(`${name} 은 대상이 없는 링크라 거부`);
-    }
-    if (!within(fs.realpathSync(base), real)) throw new UsageError(`${name} 은 ${path.basename(base)} 밖을 가리키는 링크라 거부`);
-  }
-  if (!st.isFile()) throw new UsageError(`${name} 은 일반 파일이 아니라 거부`);
-  const buf = fs.readFileSync(file);
-  let text;
-  try {
-    text = new TextDecoder('utf-8', { fatal: true }).decode(buf);
-  } catch {
-    throw new UsageError(`${name} 이 UTF-8 이 아니라 거부`);
+    throw new UsageError(`${name} 을 읽지 못함(${e.code || e.message})${tail}`);
   }
+  const st = lst.isSymbolicLink() ? linkTarget(file, name, base, tail) : lst;
+  if (!st.isFile()) throw new UsageError(`${name} 은 일반 파일이 아니라 거부${tail}`);
+  if (st.nlink > 1) throw new UsageError(`${name} 은 하드링크(이름 ${st.nlink}개)라 거부${tail}`);
+  const text = readUtf8(file, name, tail);
   // TextDecoder 는 BOM 을 떼므로 줄 끝 판정만 쓴다. 쓰기는 원본 바이트 뒤에 덧붙인다.
   return { exists: true, text, eol: text.includes('\r\n') ? '\r\n' : '\n' };
 }
 
 // 원본 바이트를 그대로 두고 끝에 줄을 덧붙인다. 마지막 줄에 줄바꿈이 없으면 먼저 넣는다.
+// 연 fd 를 fstat 으로 다시 본다: 검사(inspect)와 쓰기 사이에 하드링크나 특수 파일로 바뀌었으면 쓰지 않는다.
 function append(file, info, lines) {
   const glue = info.text && !info.text.endsWith('\n') ? info.eol : '';
   const body = glue + lines.join(info.eol) + info.eol;
-  if (info.exists) fs.appendFileSync(file, body);
-  else fs.writeFileSync(file, body, { flag: 'wx' });
+  // O_NONBLOCK: 검사 뒤 FIFO 로 바뀐 자리에서 open 이 읽는 쪽을 기다리며 멈추지 않게 한다(Windows 에는 없어 0)
+  const { O_WRONLY, O_APPEND, O_CREAT, O_EXCL } = fs.constants;
+  const flags = O_WRONLY | (fs.constants.O_NONBLOCK || 0) | O_CREAT | (info.exists ? O_APPEND : O_EXCL);
+  const fd = fs.openSync(file, flags, 0o666);
+  try {
+    const st = fs.fstatSync(fd);
+    if (!st.isFile() || st.nlink > 1) throw new UsageError(`${path.basename(file)} 이 검사 뒤 하드링크나 특수 파일로 바뀌어 쓰지 않음`);
+    fs.writeFileSync(fd, body); // 다 쓸 때까지 반복
+  } finally {
+    fs.closeSync(fd);
+  }
 }
 
 // 등록 계획. 쓰기 전에 대상을 모두 검사한다(거부면 아무것도 바꾸지 않음).
@@ -260,8 +285,8 @@ export function planMemory({ kind, memoryDir, project, runtime }) {
       runtime,
       dir,
       steps: [
-        { file: rule, name: '자동 메모리 progress-mon.md', info: inspect(rule, 'progress-mon.md', dir), what: 'rule-file' },
-        { file: index, name: '자동 메모리 MEMORY.md', info: inspect(index, 'MEMORY.md', dir), what: 'index' },
+        { file: rule, name: '자동 메모리 progress-mon.md', info: inspect(rule, 'progress-mon.md', dir, AUTO_ALT), what: 'rule-file' },
+        { file: index, name: '자동 메모리 MEMORY.md', info: inspect(index, 'MEMORY.md', dir, AUTO_ALT), what: 'index' },
       ],
       memory: { kind, path: index },
     };
@@ -270,11 +295,11 @@ export function planMemory({ kind, memoryDir, project, runtime }) {
   const root = path.resolve(project);
   if (kind === 'claude-md') {
     const file = path.join(root, 'CLAUDE.md');
-    return { kind, runtime, steps: [{ file, name: 'CLAUDE.md', info: inspect(file, 'CLAUDE.md', root), what: 'line' }], memory: { kind, path: file } };
+    return { kind, runtime, steps: [{ file, name: 'CLAUDE.md', info: inspect(file, 'CLAUDE.md', root, CLAUDE_ALT), what: 'line' }], memory: { kind, path: file } };
   }
   const t = codexTarget(root);
   const name = path.basename(t.file);
-  return { kind, runtime, steps: [{ file: t.file, name, info: inspect(t.file, name, root), what: 'block' }], memory: { kind, path: t.file } };
+  return { kind, runtime, steps: [{ file: t.file, name, info: inspect(t.file, name, root, AGENTS_ALT), what: 'block' }], memory: { kind, path: t.file } };
 }
 
 // 계획대로 쓴다. 돌려줌: 출력 줄 목록(규칙 줄, 경고 줄).

package/skills/progress-mon/scripts/pm-server.mjs

@@ -72,24 +72,32 @@ function dropState(dataDir) {
 const NOFOLLOW = fs.constants.O_NOFOLLOW || 0; // Windows 에는 없음. 거기서는 lstat 만으로 링크를 거른다
 const NONBLOCK = fs.constants.O_NONBLOCK || 0;
 
-// server.log 가 링크나 일반 파일이 아닌 것(FIFO 등)이면 참. 없으면 거짓.
+// server.log 가 링크나 일반 파일이 아닌 것(FIFO 등)이거나 하드링크(nlink > 1)면 참. 없으면 거짓.
+// 하드링크를 거르는 까닭: rotateLog 가 옮기지 못할 때 ftruncate 로 비우는데, 하드링크면 그 대상(남의 파일)이 비워진다.
 function oddLog(file) {
   try {
-    return !fs.lstatSync(file).isFile();
+    const st = fs.lstatSync(file);
+    return !st.isFile() || st.nlink > 1;
   } catch (e) {
     return e.code !== 'ENOENT';
   }
 }
 
+// 링크, 특수 파일, 하드링크라 server.log 를 거부한 오류. fs 가 낸 오류(EINVAL 등)와 섞이지 않게 표시를 따로 둔다.
+const oddLogError = (msg) => Object.assign(new Error(msg), { oddLog: true });
+// lstat 과 open 사이에 링크(ELOOP, BSD 의 EMLINK)나 소켓(ENXIO)으로 바뀐 자리에서 open 이 내는 코드. 같은 거부로 본다.
+const ODD_OPEN = new Set(['ELOOP', 'EMLINK', 'ENXIO']);
+
 // server.log 의 fd. 기본은 덧붙이기, append 가 거짓이면 처음부터 다시 쓰기(Windows 의 덧붙이기 fd 는 자를 수 없음).
 // 링크와 일반 파일 아닌 것은 열지 않는다(POSIX 는 O_NOFOLLOW, 연 뒤 fstat 다시 확인).
 function openLog(file, append = true) {
-  if (oddLog(file)) throw Object.assign(new Error('server.log 가 일반 파일 아님'), { code: 'EINVAL' });
+  if (oddLog(file)) throw oddLogError('server.log 가 일반 파일 아님');
   const { O_WRONLY, O_RDWR, O_APPEND, O_CREAT } = fs.constants;
   const fd = fs.openSync(file, (append ? O_WRONLY | O_APPEND : O_RDWR) | O_CREAT | NOFOLLOW | NONBLOCK, 0o600);
-  if (!fs.fstatSync(fd).isFile()) {
+  const st = fs.fstatSync(fd);
+  if (!st.isFile() || st.nlink > 1) {
     fs.closeSync(fd);
-    throw Object.assign(new Error('server.log 가 일반 파일 아님'), { code: 'EINVAL' });
+    throw oddLogError('server.log 가 일반 파일 아님 또는 하드링크');
   }
   return fd;
 }
@@ -114,6 +122,12 @@ function rotateLog(file, fd, warn) {
   }
 }
 
+// server.log 를 못 쓴 까닭의 경고 문구. 링크, 특수 파일, 하드링크 거부와 fs 오류를 나눈다.
+function logFailure(e) {
+  if (e && (e.oddLog || ODD_OPEN.has(e.code))) return 'server.log 가 링크, 특수 파일이거나 하드링크라 기록하지 않음. 그 파일을 치우면 다시 기록';
+  return `server.log 에 기록하지 못함(${(e && (e.code || e.message)) || e}). 서버는 계속`;
+}
+
 // server.log 한 줄 덧붙이기. 덧붙이면 max(1 MB)를 넘을 때 먼저 server.log.1 로 옮긴다(대상을 자르지 않음).
 // 링크이거나 일반 파일이 아니면 쓰지 않는다. 옮기지 못한 일은 onWarn(서버의 status 경고)과 로그의 경고 줄로 한 번 알린다. 실패해도 서버는 계속.
 export function makeLogger(dataDir, max = LOG_MAX, onWarn = () => {}) {
@@ -139,8 +153,9 @@ export function makeLogger(dataDir, max = LOG_MAX, onWarn = () => {}) {
       if (pending) fs.writeSync(fd, pending);
       pending = '';
       fs.writeSync(fd, line);
-    } catch {
-      // 로그를 못 써도 응답은 계속
+    } catch (e) {
+      // 로그를 못 써도 응답은 계속. 기록이 멈춘 것을 까닭과 함께 한 번 알린다(status 경고)
+      warn(logFailure(e));
     } finally {
       if (fd !== null) fs.closeSync(fd);
     }
@@ -508,21 +523,26 @@ function staleLock(file, now) {
   return pid !== null && !alive(pid);
 }
 
+// 낡은 잠금을 넘겨받는다. 돌려줌: 넘겨받았으면 null, 아니면 기다릴 까닭 { code, slot }(slot 은 그 코드를 낸 파일).
+// 표지를 EEXIST 밖의 까닭(EPERM, EACCES, EBUSY)으로 못 만들면 slot 은 표지다. 그래야 표지 자리의 진짜 권한 오류가
+// 잠금 자리처럼 1초대에 끝나고, 15초 뒤 "다른 start 가 끝나지 않음" 으로 잘못 안내하지 않는다.
 function takeOverLock(file, now) {
   const taking = `${file}.taking`;
-  if (makeLockFile(taking) !== null) {
+  const code = makeLockFile(taking);
+  if (code !== null) {
     // 넘겨받던 start 가 죽어 남은 표지는 START_LOCK_STALE_MS 뒤 치운다(이번은 기다리고 다음에 넘겨받음)
     try {
       if (now - fs.lstatSync(taking).mtimeMs > START_LOCK_STALE_MS) fs.rmSync(taking, { force: true });
     } catch {
-      // 그 사이 지워짐
+      // 그 사이 지워짐, 또는 표지가 없음(EPERM 등)
     }
-    return false;
+    return { code, slot: taking };
   }
   try {
-    if (!staleLock(file, now)) return false;
+    if (!staleLock(file, now)) return { code: 'EEXIST', slot: file };
     fs.rmSync(file, { force: true });
-    return makeLockFile(file) === null;
+    const again = makeLockFile(file);
+    return again === null ? null : { code: again, slot: file };
   } finally {
     fs.rmSync(taking, { force: true });
   }
@@ -530,18 +550,44 @@ function takeOverLock(file, now) {
 
 // start 잠금을 잡을 때까지 waitMs 기다린다. 돌려줌: 잠금 경로. 시간 초과는 UsageError: 잠금 파일이 한 번이라도 보였으면
 // 다른 start, 끝내 없었으면(EPERM 등이 계속, 권한 등) 만들지 못함.
-export async function takeStartLock(dataDir, waitMs = START_LOCK_WAIT_MS) {
+// 잠금 파일이 끝내 안 보이는 동안 EPERM/EACCES/EBUSY 가 pendingMs(1초) 넘게 이어지면 바로 실패한다: Windows 의
+// delete pending 은 ms 안에 풀려 그 사이 성공하지만, 읽기 전용 폴더 같은 진짜 권한 오류는 15초를 기다리지 않고 끝낸다.
+// 잠금을 만들거나 낡은 것을 넘겨받으면 { lock }, 아니면 그 까닭 { code, slot }.
+function tryStartLock(file, now) {
+  const code = makeLockFile(file);
+  if (code === null) return { lock: file };
+  if (!staleLock(file, now)) return { code, slot: file };
+  const why = takeOverLock(file, now);
+  return why === null ? { lock: file } : why;
+}
+
+// 전체 대기가 끝났을 때 던질 오류: 잠금 파일을 한 번도 못 봤으면 만들지 못함, 봤으면 다른 start 가 끝나지 않음.
+function startWaitError(file, seen, code) {
+  if (!seen) return new UsageError(`잠금 ${START_LOCK} 을 만들지 못함(${code})`);
+  return new UsageError(`다른 start 가 끝나지 않음(잠금 ${START_LOCK}, pid ${lockPid(file) ?? '알 수 없음'}). 30초 뒤 다시 실행. 그 start 가 끝났는데도 남아 있으면 잠금 파일을 지운 뒤 다시 실행`);
+}
+
+// 잠금을 못 잡은 반복의 상태 갱신. 돌려줌: [seen, errSince]. 그 코드를 낸 파일(slot: 잠금 또는 넘겨받기 표지)이 없는
+// EPERM/EACCES/EBUSY 가 pendingMs 넘게 이어지면(진짜 권한 오류) 바로 실패시킨다. errSince 는 그런 코드가 처음 난 때.
+// seen 은 잠금 파일을 한 번이라도 본 것(표지를 못 만든 반복도 잠금 파일은 있음).
+function startWaitStep(file, { code, slot }, seen, errSince, now, pendingMs) {
+  const here = code === 'EEXIST' || fs.existsSync(slot);
+  const es = here ? null : (errSince ?? now);
+  if (es !== null && now - es >= pendingMs) throw new UsageError(`잠금 ${path.basename(slot)} 을 만들지 못함(${code})`);
+  return [seen || here || (slot !== file && fs.existsSync(file)), es];
+}
+
+export async function takeStartLock(dataDir, waitMs = START_LOCK_WAIT_MS, pendingMs = 1000) {
   const file = path.join(dataDir, START_LOCK);
   const until = Date.now() + waitMs;
   let seen = false;
+  let errSince = null;
   for (;;) {
-    const code = makeLockFile(file);
-    if (code === null || (staleLock(file, Date.now()) && takeOverLock(file, Date.now()))) return file;
-    seen = seen || code === 'EEXIST' || fs.existsSync(file);
-    if (Date.now() >= until) {
-      if (!seen) throw new UsageError(`잠금 ${START_LOCK} 을 만들지 못함(${code})`);
-      throw new UsageError(`다른 start 가 끝나지 않음(잠금 ${START_LOCK}, pid ${lockPid(file) ?? '알 수 없음'}). 30초 뒤 다시 실행. 그 start 가 끝났는데도 남아 있으면 잠금 파일을 지운 뒤 다시 실행`);
-    }
+    const now = Date.now();
+    const r = tryStartLock(file, now);
+    if (r.lock) return r.lock;
+    [seen, errSince] = startWaitStep(file, r, seen, errSince, now, pendingMs);
+    if (now >= until) throw startWaitError(file, seen, r.code);
     await sleep(100);
   }
 }

package/skills/ralph-qa/SKILL.md

@@ -117,7 +117,7 @@ node "<이 스킬 디렉터리 절대경로>/references/verifier-probe.mjs" --ru
 
 폴더, 페이로드, 비밀 검사, 좌석 명령, 시간 상한, 정리는 실행기 `references/seat-run.mjs` 가 한다. **좌석 명령과 git 사슬을 손으로 짜지 않는다.** 실행기가 멈추면 출력 JSON 의 `stop` 을 아래 멈춤 표대로 처리한다.
 `<R>` 은 `<이 스킬 디렉터리 절대경로>/references` 다(Codex 의 npm 설치본은 `~/.codex/skills/banker-ralph-qa/references`, 플러그인 설치본은 `~/.codex/plugins/cache/<마켓플레이스>/banker/<판>/skills/ralph-qa/references`. `CODEX_HOME` 이 있으면 `~/.codex` 대신 그 폴더). 호출 사이에 셸 변수가 남지 않으므로 호출마다 실제 경로를 적는다.
-명령마다 stdout 에 JSON 하나를 내고, 같은 JSON 을 `<d>/result-<명령>.md` 에도 쓴다(멈춘 send 는 `result-send-stop.md`). 종료 코드는 0 끝남, 1 비밀처럼 보이는 줄, 2 인자나 실행기 오류, 3 멈춤, 4 512 KiB 초과, 5 send 가 아직 돎이다.
+명령마다 stdout 에 JSON 하나를 내고, 같은 JSON 을 `<d>/result-<명령>.md` 에도 쓴다(멈춘 send 는 `result-send-stop.md`. 멈춘 send 도 `.sent.md` 가 있으면 좌석이 페이로드를 이미 받았을 수 있어 다시 보내지 않는다). 종료 코드는 0 끝남, 1 비밀처럼 보이는 줄, 2 인자나 실행기 오류, 3 멈춤, 4 512 KiB 초과, 5 send 가 아직 돎이다.
 페이로드 폴더는 반복마다 새로 만든다. `--gates` 의 게이트 기록 폴더 `<g>` 는 이것과 따로, 실행 내내 하나다(게이트 증거 절).
 
 1. `init` 으로 폴더 둘을 만든다. 출력의 `dir` 이 페이로드 폴더 `<d>`, `out` 이 답 폴더다.
@@ -200,7 +200,8 @@ node '<R>/seat-run.mjs' cleanup --dir '<d>'
 | `scan` | 비밀처럼 보이는 줄이 있다(종료 1) | 4단계대로 가린다 | 끝내 못 가리면 `cli-call-failed` |
 | `too-large` | 512 KiB 를 넘는다(종료 4) | 4단계대로 묻는다 | 못 물으면 `cli-call-failed`, 거절이면 `model-declined` |
 | `split` | 나눌 단위가 부분 수보다 적거나, 부분의 표지나 검사가 맞지 않다. prompt.md 의 짧은 부분이 prepare 때와 다를 때도(짧은 부분 안을 고쳐 가림. 길이가 같아도 `run.md` 의 sha256 과 견줌) | 부분 수를 줄인다. 짧은 부분 안을 가렸으면 short.md 를 고쳐 prepare 를 다시 한다 | 없음 |
-| `sent` | 이미 보낸 폴더다 | `init` 으로 새 폴더를 만든다 | 없음 |
+| `sent` | 이미 보낸 폴더다(`result-send.md` 나 `.sent.md` 가 있음). 멈춘 send 뒤(`result-send-stop.md` 가 있음)라면 좌석이 이미 페이로드를 받았을 수 있다 | 다시 보내지 않는다. 좌석의 답이 있으면 답 폴더(`ralph-qa-out.*`)에 있다. 다시 보낼지는 사용자에게 묻는다. 새 반복이면 `init` 으로 새 폴더를 만든다 | 없음 |
+| `sent-mark` | 보냈음 표지 `.sent.md` 를 쓰지 못했다(디스크 가득 참 등) | 폴더의 쓰기 상태를 본다. 좌석은 아무것도 보내지 않았다 | 없음 |
 | `not-prepared` | `prepare` 가 끝난 폴더가 아니다 | `prepare` 를 한다 | 없음 |
 | `not-a-run-folder` | `init` 이 만든 폴더가 아니다. 이름과 표지가 맞아도 알려진 기준 폴더(실제 경로로 견줌) 바로 아래가 아니거나 그 기준 폴더를 다른 계정도 쓸 수 있으면 이것이다 | `init` 이 찍은 경로를 쓴다 | 없음 |
 | `sandboxed` | Codex sandbox 가 네트워크를 막는다 | 승인을 받아 sandbox 밖에서 다시 한다 | 승인할 수 없으면 `cli-call-failed` |

package/skills/ralph-qa/references/seat-run.mjs

@@ -32,7 +32,7 @@ import { CLI_DEFAULT, probe as localProbe, safeModel } from "./verifier-probe.mj
 
 // The stops a command may end with, as `stop` in its JSON; the skill's table of what to do holds the same set.
 export const STOP_CODES = ["index-missing", "no-diff", "list", "binary-diff", "range-source", "range-link", "range-outside", "file", "markers",
-  "spec", "not-a-repo", "base-invalid", "git-failed", "git-timeout", "scan", "too-large", "sent", "sandboxed", "base-not-private",
+  "spec", "not-a-repo", "base-invalid", "git-failed", "git-timeout", "scan", "too-large", "sent", "sent-mark", "sandboxed", "base-not-private",
   "base-not-writable", "inside-repo", "busy", "not-prepared", "not-a-run-folder", "split", "cleanup-left"];
 const EXIT_OF = { scan: 1, "too-large": 4, busy: 5 };
 
@@ -44,6 +44,10 @@ const ANY_RUN = /^ralph-qa(-out)?\.[A-Za-z0-9]+$/;
 // The lock of a send that runs: one name, made with "wx", holding the pid and the time.
 const LOCK_NAME = ".running.md";
 const TAKING_NAME = ".taking.md";
+// The "sent" mark, written once under the lock before any seat work (send's markOrStop). It stands apart from
+// result-send.md (written after every seat ends): a send that holds the lock in the A2 window finds this mark and
+// does not send the payload again, even if that first send died before it wrote result-send.md.
+const SENT_NAME = ".sent.md";
 const STALE_TAKING_MS = 60 * 1000;
 
 class Usage extends Error {}
@@ -144,11 +148,39 @@ function listUntracked(o, ctx) {
   return [{ ok: true, ...untracked({ repo: o.repo, env: ctx.env, folder: o.folder || null }) }, 0, null];
 }
 
-const sent = (d) => existsSync(join(d, "result-send.md"));
+// A folder is sent once either mark is there: result-send.md (a send ran to the end) or .sent.md (a send took the
+// folder to send it, even if it then stopped or died before result-send.md).
+const sent = (d) => existsSync(join(d, "result-send.md")) || existsSync(join(d, SENT_NAME));
 const refuseSent = (d) => {
-  if (sent(d)) throw new Stop("sent", `이미 보낸 폴더다. 반복마다 init 으로 새 폴더를 만든다: ${d}`);
+  if (sent(d)) throw new Stop("sent", `이미 보낸 폴더다. 좌석의 답이 있으면 답 폴더(ralph-qa-out.*)에 있다. 다시 보내지 말고, 다시 보낼지는 사용자에게 묻는다: ${d}`);
 };
 
+// Writes .sent.md once (the memo answers again with the first result). EEXIST means another send (the A2 window)
+// already marked it; any other write error is `err`, and a mark left empty by a failed write is taken away, so the
+// next send is not refused for a folder nothing went out of.
+export function makeMarkSent(d, now) {
+  let state = null;
+  return () => {
+    if (state) return state;
+    const file = join(d, SENT_NAME);
+    try {
+      writeFileSync(file, `${process.pid} ${new Date(now()).toISOString()}\n`, { flag: "wx", mode: 0o600 });
+      state = { ok: true };
+    } catch (e) {
+      if (e.code !== "EEXIST") rmSync(file, { force: true });
+      state = e.code === "EEXIST" ? { already: true } : { err: e };
+    }
+    return state;
+  };
+}
+
+// Marks the folder sent under the lock, before any seat work, or stops the send (the lock goes back in send's finally).
+function markOrStop(d, now) {
+  const mark = makeMarkSent(d, now)();
+  if (mark.already) throw new RunStop("sent", `다른 send 가 이미 이 폴더를 보냈다: ${d}`);
+  if (mark.err) throw new RunStop("sent-mark", `보냈음 표지(.sent.md)를 쓰지 못했다(${mark.err.code || mark.err.message}). 좌석은 아무것도 보내지 않았다: ${d}`);
+}
+
 // prepare and check end with 1 when a line looks like a secret and 4 past 512 KiB; the JSON carries both.
 function verdict(result) {
   if (result.scan.count) {
@@ -797,6 +829,9 @@ async function send(o, ctx) {
   const signals = watchSignals();
   const run = { ...a, d, o: out, id, short, shortSha, signalled: () => signals.code() !== 0 };
   try {
+    // The folder is marked sent under the lock, before any seat writes into it: a send that lost the A2 window stops
+    // here, before it could overwrite the winner's prompt copies or clean the winner's seat folders.
+    if (!a.dryRun) markOrStop(d, ctx.now);
     // every seat settles before the lock goes back and the stop handlers go away
     const settled = await Promise.allSettled(a.seats.map((x) => sendSeat(ctx, run, x, payload)));
     const thrown = settled.find((x) => x.status === "rejected");
@@ -833,7 +868,9 @@ const folderOf = (o, ctx) => {
   }
 };
 
-// A send that stopped goes to result-send-stop.md: result-send.md says the folder was sent, and a stopped send sent nothing.
+// A send that stopped goes to result-send-stop.md, not result-send.md (that one says every seat ended). A stopped
+// send may still have carried the payload to some seats: .sent.md, written under the lock before any seat work, is what
+// keeps the next send from sending it again.
 const stopName = (command) => (command === "send" ? "send-stop" : command);
 
 // A stop of run-folder.mjs carries no name: this runner's goes before it.

package/skills/remains/SKILL.md

@@ -55,6 +55,7 @@ argument-hint: "[기준 커밋] [--no-boxes]"
    - 보내는 것은 추적하는 파일의 커밋된 내용 그대로다(줄 끝 변환 없음). `--ref worktree` 는 커밋하지 않은 추적 파일의 변경까지 보낸다. 추적하지 않는 새 파일은 보내지 않는다(출력의 `untracked`). 그 파일이 시험에 필요하면 미검증으로 적는다.
    - Windows 박스에서는 명령이 `.cmd` 파일 안에서 돈다. 명령이 OS 마다 달라야 하면 `--box <이름>` 으로 나눠 돌린다.
    - 그 `.cmd` 파일은 UTF-8 코드 페이지로 돌아 한글 인자도 그대로 간다. `for` 의 변수는 배치 파일 규칙대로 `%%i` 로 쓰고, `for` 나 `if` 안에서 npm 같은 배치 명령을 부르면 `call npm ...` 으로 쓴다.
+   - `for` 반복으로 시험을 여러 번 돌릴 때 종료 코드는 마지막 반복 것이라 앞 반복의 실패가 가려진다(POSIX `run.sh` 도 같다). 각 반복에 `|| exit /b 1`(POSIX `|| exit 1`)을 붙여 한 번이라도 실패하면 비정상 종료로 끝낸다.
    - 오래 걸리면 `--timeout <분>`(기본 20)을 늘린다.
 4. 출력 JSON 의 박스별 `summary`(tests, pass, fail, skipped, failures)와 `log` 파일을 근거로 쓴다. 종료 코드는 다음과 같다.
    - 0: 모든 박스가 통과

package/skills/ultraqa/SKILL.md

@@ -46,6 +46,7 @@ argument-hint: "--tests | --build | --lint | --typecheck | --custom \"<명령이
 
 - 구조화된 목표가 없으면 인자를 행동 목표로 읽고, 저장소에서 실행 가능한 e2e 방법을 찾는다.
 - 목표 명령은 저장소에서 찾는다(`package.json` 의 `scripts`, CI 시험 단계, `Makefile`, pytest 설정). 찾은 근거를 보고에 적는다.
+- 찾은 그대로 돌린다. 게이트 명령에 플래그를 더하거나 바꾸지 않는다(예: `--test-timeout`, `--test-force-exit` 는 멈춤을 통과로 가려 게이트를 거짓으로 만든다). 바꿔야 할 까닭이 있으면 멈추고 사용자에게 묻는다. 저장소의 시험 명령 자체를 고치는 것은 QA 가 아니라 구현 작업이다.
 
 ## 시나리오 행렬