@kaydash9999/banker-plugins 0.24.1 → 0.25.1

package/skills/payload-mon/scripts/payload-mon.mjs

@@ -42,6 +42,7 @@
  * Exit status 1 means nothing was changed; 2 means an unexpected error stopped
  * the command partway, so check `status`.
  */
+import { randomBytes } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
   accessSync,
@@ -215,7 +216,7 @@ function linkedFolder(file) {
 // either name is replaced rather than written through, and a write that fails
 // leaves the old file as it was.
 function writeFresh(file, data, mode) {
-  const tmp = `${file}.${process.pid}.tmp`;
+  const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   rmSync(tmp, { force: true });
   try {
     writeFileSync(tmp, data, { flag: "wx", mode });

package/skills/payload-mon/scripts/payload-size.mjs

@@ -33,7 +33,7 @@
  * fix sentPart and bump CACHE_VERSION, so totals cached under the old rules are
  * rebuilt.
  */
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import {
   closeSync,
   fstatSync,
@@ -187,7 +187,7 @@ function saveCache(file, state) {
     const dir = dirname(file);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     if (!ownedDir(dir)) return; // a folder this account does not control: no cache
-    const tmp = `${file}.${process.pid}.tmp`;
+    const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
     rmSync(tmp, { force: true });
     writeFileSync(tmp, JSON.stringify(state), { flag: "wx", mode: 0o600 });
     renameSync(tmp, file);

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

@@ -6,7 +6,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { git, noBom, readRegular, writeAtomic } from './pm-config.mjs';
+import { git, noBom, readRegular, writeAtomic, writeNew } from './pm-config.mjs';
 
 const ADR_FILE = 'adr.json';
 const ADR_CHECK_FILE = 'adr-check.json';
@@ -404,13 +404,16 @@ const stamp = (ms) => {
 };
 
 // 스키마 FAIL 이 남은 adr.json 을 같은 폴더의 adr.json.rejected-<시각>(있으면 -2, -3 ...)으로 옮긴다. 결정 기록을 잃지 않게
-// 지우지 않는다. 새 이름은 COPYFILE_EXCL 로 만들어 있는 파일을 덮지 않고, 사본을 만든 뒤에만 원본을 지운다. 돌려줌: 옮긴 경로.
+// 지우지 않는다. 새 이름은 writeNew 로 만들어 있는 것(끊어진 링크 포함)을 덮거나 따라가지 않고, 사본을 만든 뒤에만 원본을
+// 지운다. 돌려줌: 옮긴 경로.
 function reject(file, now) {
   const base = `${file}.rejected-${stamp(now)}`;
+  const bytes = fs.readFileSync(file);
+  const mode = fs.statSync(file).mode & 0o777; // as COPYFILE_EXCL kept it
   for (let i = 1; ; i++) {
     const dest = i === 1 ? base : `${base}-${i}`;
     try {
-      fs.copyFileSync(file, dest, fs.constants.COPYFILE_EXCL);
+      writeNew(dest, bytes, { mode });
     } catch (e) {
       if (e.code === 'EEXIST') continue;
       throw e;

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

@@ -1,4 +1,5 @@
 // pm-config.mjs: 프로젝트 루트와 자료 폴더 결정, 런타임 판별, config.json 읽기와 기본값, 형식 검사, 원자적 쓰기.
+import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
 import net from 'node:net';
@@ -52,13 +53,64 @@ export function readRegular(file, encoding = 'utf8', fsx = fs, max = READ_MAX) {
   return fsx.readFileSync(file, encoding);
 }
 
+// 실제 경로. native 먼저(Windows 의 8.3 짧은 이름, macOS 와 Windows 의 디스크 대소문자로 푼다). 아직 없는 꼬리는 있는
+// 조상까지 풀고 붙인다(macOS 의 /var 는 /private/var 로 가는 링크).
+export function realNative(p) {
+  try {
+    return fs.realpathSync.native(p);
+  } catch {
+    try {
+      return fs.realpathSync(p);
+    } catch {
+      const up = path.dirname(p);
+      return up === p ? p : path.join(realNative(up), path.basename(p));
+    }
+  }
+}
+
+// 두 경로가 같은 폴더인지: 장치와 inode(bigint), inode 가 없는 파일 시스템은 realNative 철자(Windows, macOS 는 접어서).
+// 문자열 비교는 대소문자, 8.3 이름, 링크인 부모 폴더처럼 철자만 다른 같은 폴더를 다른 폴더로 본다.
+export function sameFolder(a, b) {
+  try {
+    const x = fs.statSync(a, { bigint: true });
+    const y = fs.statSync(b, { bigint: true });
+    if (x.ino !== 0n && y.ino !== 0n) return x.dev === y.dev && x.ino === y.ino;
+  } catch {
+    return false;
+  }
+  const fold = (p) => (process.platform === 'win32' || process.platform === 'darwin' ? p.toLowerCase() : p);
+  return fold(realNative(a)) === fold(realNative(b));
+}
+
 // 프로젝트 안 자료 폴더의 경로 가운데 링크인 첫 폴더(.omc, progress-mon 등). 없으면 null.
-// 프로젝트 밖(--data)이면 자료 폴더 자체만 본다. 아직 없는 폴더에서 멈춘다.
+// 프로젝트 밖(--data)이면 자료 폴더 자체만 본다. 아직 없는 폴더에서 멈춘다. 안팎은 자료 폴더에서 위로 올라가며
+// 프로젝트 루트와 같은 폴더(sameFolder)를 만나는지로 본다: --data 를 다른 대소문자나 8.3 이름으로 적어도 안으로 본다.
 function linkedDir(root, dataDir) {
-  const rel = path.relative(root, dataDir);
-  const inside = rel && !rel.startsWith('..') && !path.isAbsolute(rel);
-  const parts = inside ? rel.split(path.sep) : [];
-  const dirs = inside ? parts.map((_, i) => path.join(root, ...parts.slice(0, i + 1))) : [dataDir];
+  const isLink = (d) => {
+    try {
+      return fs.lstatSync(d).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  };
+  // 위로 올라가며 루트를 찾는다. 링크가 아닌 루트를 만나면 그 아래가 안이다(.omc -> . 같은 안의 링크도 목록에 남아
+  // 거부된다). 끝까지 못 만나면 루트를 가리키는 첫 링크(루트를 링크 철자로 적은 --data)를 루트로 본다.
+  const up = [];
+  let rootAt = -1;
+  let linkRootAt = -1;
+  for (let d = dataDir; ; d = path.dirname(d)) {
+    if (sameFolder(d, root)) {
+      if (!isLink(d)) {
+        rootAt = up.length;
+        break;
+      }
+      if (linkRootAt < 0) linkRootAt = up.length;
+    }
+    up.push(d);
+    if (path.dirname(d) === d) break;
+  }
+  const cut = rootAt >= 0 ? rootAt : linkRootAt;
+  const dirs = cut > 0 ? up.slice(0, cut).reverse() : [dataDir];
   for (const d of dirs) {
     let st;
     try {
@@ -85,8 +137,11 @@ export function privateIPv4(ip) {
   return a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168);
 }
 
-// git 출력(앞뒤 공백 제거). git 이 없거나 실패하면 예외.
-export const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+// git 출력(앞뒤 공백 제거). git 이 없거나 실패하면 예외. 홈 폴더에서 git -C 로 부른다: Windows 는 일하는 폴더의
+// 프로그램을 먼저 찾으므로, 프로젝트 안의 git.exe 가 실행되지 않게.
+// 프로그램을 띄울 폴더: 홈 폴더(없으면 임시 폴더).
+export const runDir = () => (fs.existsSync(os.homedir()) ? os.homedir() : os.tmpdir());
+export const git = (cwd, args) => execFileSync('git', ['-C', path.resolve(cwd), ...args], { cwd: runDir(), encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
 
 // 프로젝트 루트: --project, 아니면 cwd 의 git 최상위, 실패면 cwd.
 export function projectRoot(cwd, project) {
@@ -123,6 +178,77 @@ function pickContext({ cwd = process.cwd(), project, runtime, data } = {}) {
 // 사용법 오류(종료 1).
 export class UsageError extends Error {}
 
+// 고정 이름(잠금, 백업, 처음 만드는 설정)에 새 파일을 만든다(wx). 그 이름에 무엇이든 있으면 끊어진 링크까지 EEXIST.
+// 까닭: Windows 의 wx 는 끊어진 링크를 따라가 그 너머에 파일을 만든다(macOS, Linux 는 EEXIST). 그래서 먼저 lstat 로
+// 보고, 연 뒤 쓰기 전에 연 파일(fstat)과 이름(lstat)을 대조한다. 이름이 없거나 링크이거나 다른 파일이면 아무것도 쓰지
+// 않고 EEXIST(링크를 따라 만든 빈 파일은 지움). 볼 수 없으면(ESTALE, EPERM 등) 보통의 wx 처럼 그대로 쓴다. 쓰기가
+// 실패하면 이름이 아직 그 파일일 때 지운다(빈 잠금이나 빈 백업이 남지 않게). 처음 lstat 의 EPERM 등(Windows 에서 지우는
+// 중인 파일)은 그대로 던진다. 부른 쪽은 wx 의 같은 코드처럼 기다린다.
+export function writeNew(file, data, opts = {}, fsx = fs) {
+  if (fsx.lstatSync(file, { throwIfNoEntry: false }) !== undefined) throw eexist(file);
+  const fd = fsx.openSync(file, 'wx', opts.mode);
+  try {
+    const made = fstatOr(fd, fsx);
+    if (namesOpened(file, made, fsx) === false) throw eexist(file);
+    try {
+      fsx.writeFileSync(fd, data);
+    } catch (e) {
+      if (namesOpened(file, made, fsx) === true) fsx.rmSync(file, { force: true });
+      throw e;
+    }
+  } finally {
+    fsx.closeSync(fd);
+  }
+}
+
+const fstatOr = (fd, fsx) => {
+  try {
+    return fsx.fstatSync(fd, { bigint: true });
+  } catch {
+    return null;
+  }
+};
+
+// 이름이 연 파일(made)을 가리키는지: 참, 거짓(없음, 링크, 다른 파일), 볼 수 없으면 null. 링크면 그 링크로 만든 빈 파일을 지움.
+function namesOpened(file, made, fsx) {
+  let st;
+  try {
+    st = fsx.lstatSync(file, { bigint: true, throwIfNoEntry: false });
+  } catch {
+    return null;
+  }
+  if (!st) return false;
+  if (st.isSymbolicLink()) {
+    if (made) dropFollowed(file, made, fsx);
+    return false;
+  }
+  if (!made || made.ino === 0n) return null;
+  return st.dev === made.dev && st.ino === made.ino;
+}
+
+// 링크를 따라 연 파일이 아직 그 빈 파일이면 지운다.
+function dropFollowed(file, made, fsx) {
+  try {
+    const target = fsx.realpathSync(file);
+    const at = fsx.statSync(target, { bigint: true });
+    if (at.dev === made.dev && at.ino === made.ino && at.size === 0n) fsx.rmSync(target, { force: true });
+  } catch {
+    // 링크가 또 바뀜: 되돌릴 것을 찾지 못함
+  }
+}
+
+const eexist = (file) => Object.assign(new Error(`EEXIST: file already exists, open '${file}'`), { code: 'EEXIST', syscall: 'open', path: file });
+
+// 그 자리에 일반 파일이 아닌 것(링크, 폴더 등)이 있는지. 없거나 볼 수 없으면 거짓.
+export function notPlainFile(file, fsx = fs) {
+  try {
+    const st = fsx.lstatSync(file, { throwIfNoEntry: false });
+    return st !== undefined && !st.isFile();
+  } catch {
+    return false;
+  }
+}
+
 const RENAME_RETRIES = 5;
 const RENAME_STEP_MS = 50;
 const RENAME_RETRY_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);

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

@@ -4,7 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { dataLabel, defaults, loadConfig, eventsPath, writeAtomic, git, noBom, readRegular, UsageError } from './pm-config.mjs';
+import { dataLabel, defaults, loadConfig, eventsPath, writeAtomic, writeNew, notPlainFile, git, noBom, readRegular, realNative, UsageError } from './pm-config.mjs';
 import { stageList } from './pm-sources.mjs';
 import { planMemory, applyMemory } from './pm-memory.mjs';
 
@@ -58,7 +58,7 @@ function readLock(file, fsx) {
 function breakStale(file, seen, fsx) {
   const brk = `${file}.break`;
   try {
-    fsx.writeFileSync(brk, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }) + '\n', { flag: 'wx' });
+    writeNew(brk, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }) + '\n', {}, fsx);
   } catch (e) {
     if (!BUSY_CODES.has(e.code)) return false;
     try {
@@ -97,6 +97,27 @@ function breakStale(file, seen, fsx) {
   return removed;
 }
 
+// 잠금을 한 번 만들어 본다. 돌려줌: 만들었으면 null, 아니면 기다릴 까닭 코드(EEXIST, Windows 의 EPERM 등).
+// 링크나 폴더가 잠금 자리에 있으면 풀릴 잠금이 아니므로 기다리지 않고 거부한다(끊어진 링크면 읽기가 없음으로 보여 헛돈다).
+function tryLockOnce(file, body, fsx, label) {
+  try {
+    writeNew(file, body, {}, fsx);
+    return null;
+  } catch (e) {
+    if (!BUSY_CODES.has(e.code)) throw new UsageError(`잠금 파일을 만들지 못함(${e.code || e.message})`);
+    if (notPlainFile(file, fsx)) throw new UsageError(`잠금 자리에 일반 파일이 아닌 것(링크나 폴더)이 있어 거부: ${label}items.json.lock`);
+    return e.code;
+  }
+}
+
+// 기다림이 끝났을 때의 오류. 잠금 파일이 끝내 없었으면 다른 쓰기가 아니라 만들지 못한 것(권한 등).
+function lockTimeout(code, seenLock, last, label) {
+  if (!seenLock && code !== 'EEXIST') return new UsageError(`잠금 파일을 만들지 못함(${code})`);
+  return new UsageError(
+    `다른 쓰기가 끝나지 않음(잠금 ${label}items.json.lock, pid ${last.pid ?? '알 수 없음'}, createdAt ${last.createdAt ?? '알 수 없음'}). 그 프로세스가 끝났는데도 남아 있으면 잠금 파일을 지운 뒤 다시 실행`,
+  );
+}
+
 // items.json.lock 을 wx 로 만든다. 있으면 50 ms 간격으로 최대 waitMs 기다린다.
 // Windows 에서 지우는 중인 파일에 wx 하면 EPERM(또는 EACCES, EBUSY)이라 EEXIST 처럼 기다린다.
 // 낡은 잠금은 breakStale 로만 정리한다.
@@ -109,27 +130,15 @@ export async function acquireLock(dataDir, { fsx = fs, waitMs = LOCK_WAIT_MS, la
   let last = {};
   let seenLock = false; // 기다리는 동안 잠금 파일이 한 번이라도 보였는지
   for (;;) {
-    let code;
-    try {
-      fsx.writeFileSync(file, body, { flag: 'wx' });
-      return { file, mine };
-    } catch (e) {
-      code = e.code;
-      if (!BUSY_CODES.has(code)) throw new UsageError(`잠금 파일을 만들지 못함(${code || e.message})`);
-    }
+    const code = tryLockOnce(file, body, fsx, label);
+    if (code === null) return { file, mine };
     const info = readLock(file, fsx);
     // 그 사이 풀림: 바로 다시. 지우는 중(EPERM 등)이면 아래에서 기다린다
     if (info === null && code === 'EEXIST' && Date.now() < until) continue;
     if (info) seenLock = true;
     if (info && info.pid !== undefined) last = info;
     if (staleLock(info, Date.now()) && breakStale(file, info, fsx)) continue;
-    if (Date.now() >= until) {
-      // 잠금 파일이 끝내 없었으면 다른 쓰기가 아니라 만들지 못한 것(권한 등)
-      if (!seenLock && code !== 'EEXIST') throw new UsageError(`잠금 파일을 만들지 못함(${code})`);
-      throw new UsageError(
-        `다른 쓰기가 끝나지 않음(잠금 ${label}items.json.lock, pid ${last.pid ?? '알 수 없음'}, createdAt ${last.createdAt ?? '알 수 없음'}). 그 프로세스가 끝났는데도 남아 있으면 잠금 파일을 지운 뒤 다시 실행`,
-      );
-    }
+    if (Date.now() >= until) throw lockTimeout(code, seenLock, last, label);
     await sleep(STEP_MS);
   }
 }
@@ -287,13 +296,6 @@ function storyChange(o, now, configIds) {
 const NEXT = ['다음 할 일', '  1. references/authoring.md 를 읽고 req-spec.json, reqs.json, flow.json, arch.json, adr.json 작성', '  2. check 로 검사. FAIL 0 까지 최대 3회', '  3. start 로 서버 시작'];
 
 const slash = (p) => p.split(path.sep).join('/');
-const realOr = (p) => {
-  try {
-    return fs.realpathSync(p);
-  } catch {
-    return p;
-  }
-};
 const inside = (rel) => rel && !rel.startsWith('..') && !path.isAbsolute(rel);
 
 // 자료 폴더를 git 제외 목록(git rev-parse --git-path info/exclude)에 한 줄 추가. 추적 파일은 바꾸지 않는다. 실패는 알림만.
@@ -306,8 +308,9 @@ function gitExclude(ctx) {
   } catch {
     return 'git 제외 목록: git 저장소 아님, 건너뜀';
   }
-  // 링크 경로(macOS /var 와 /private/var, Windows junction)로 부른 --project 도 git 최상위(실제 경로)와 맞게 푼다
-  const rel = path.relative(realOr(top), path.join(realOr(path.dirname(ctx.dataDir)), path.basename(ctx.dataDir)));
+  // 링크 경로(macOS /var 와 /private/var, Windows junction), 다른 대소문자, 8.3 이름으로 부른 --project 나 --data 도
+  // git 최상위와 같은 철자로 푼다(realNative: 디스크의 철자)
+  const rel = path.relative(realNative(top), realNative(ctx.dataDir));
   if (!inside(rel)) return 'git 제외 목록: 자료 폴더가 저장소 밖이라 건너뜀';
   const line = `/${slash(rel)}/`;
   const shown = inside(path.relative(ctx.project, excl)) ? slash(path.relative(ctx.project, excl)) : 'info/exclude';
@@ -334,10 +337,13 @@ function gitExclude(ctx) {
   return `git 제외 목록 추가: ${line} (${shown})`;
 }
 
-// 없을 때만 만든다. 돌려줌: 출력 줄.
+// 없을 때만 만든다. 돌려줌: 출력 줄. 가리키는 것이 없는 링크는 거부한다(만들면 링크 너머에 파일이 생긴다).
 function makeOnce(file, label, text) {
-  if (fs.existsSync(file)) return `그대로 둠: ${label}`;
-  fs.writeFileSync(file, text, { flag: 'wx' });
+  if (fs.lstatSync(file, { throwIfNoEntry: false }) !== undefined) {
+    if (fs.existsSync(file)) return `그대로 둠: ${label}`;
+    throw new UsageError(`${label} 자리에 가리키는 것이 없는 링크가 있어 거부`);
+  }
+  writeNew(file, text);
   return `새로 만듦: ${label}`;
 }
 

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

@@ -2,10 +2,11 @@
 // 예외: 표식이 붙은 우리 줄(앞머리로 가린 규칙 줄과 색인 줄)이 지금 판과 다르면 그 줄만 제자리에서 바꾼다(첫 원본은 .progress-mon.bak).
 // 대상 파일은 에이전트가 넘긴다(--memory, --memory-dir). 스크립트는 HOME 아래 쓰기 경로를 스스로 만들지 않는다.
 // 덧붙인 뒤 규칙 로드 한도를 재고 경고 줄을 낸다(종료 코드는 그대로). status, check 도 같은 측정을 다시 한다.
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { git, readRegular, UsageError } from './pm-config.mjs';
+import { git, readRegular, realNative, UsageError, writeNew } from './pm-config.mjs';
 
 export const MARKER = '<!-- progress-mon:rule -->';
 export const OMX_OPEN = '<!-- USER:OMX:POLICY:START -->';
@@ -159,8 +160,10 @@ const gitTop = (dir) => {
 // Codex 프로젝트 지시 합계: 저장소 루트에서 프로젝트 루트까지 각 폴더에서 Codex 가 읽는 파일 크기의 합.
 export function measureCodex(project, env = process.env) {
   const limit = codexLimit(env);
-  const proj = path.resolve(project);
-  const top = gitTop(proj);
+  // 둘 다 디스크의 철자로 푼다: 링크나 다른 대소문자로 준 --project 가 저장소 밖으로 보여 지시 파일을 빼먹지 않게
+  const proj = realNative(path.resolve(project));
+  const top0 = gitTop(proj);
+  const top = top0 && realNative(top0);
   const rel = top ? path.relative(top, proj) : '';
   const dirs = [top && !rel.startsWith('..') && !path.isAbsolute(rel) ? top : proj];
   if (dirs[0] !== proj) for (const part of rel.split(path.sep).filter(Boolean)) dirs.push(path.join(dirs[dirs.length - 1], part));
@@ -349,7 +352,8 @@ function rewrite(file, body) {
   const real = fs.realpathSync(file);
   const st = fs.statSync(real);
   if (!st.isFile() || st.nlink > 1) throw changedError(file);
-  const tmp = `${real}.${process.pid}.${Date.now().toString(36)}.tmp`;
+  // 임시 이름은 난수: Windows 의 wx 는 끊어진 링크를 따라가므로, 미리 맞힐 수 있는 이름이면 링크를 심어 둘 수 있다.
+  const tmp = `${real}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
   try {
     fs.writeFileSync(tmp, body, { flag: 'wx', mode: st.mode & 0o777 });
     fs.chmodSync(tmp, st.mode & 0o7777);
@@ -368,13 +372,16 @@ function rewrite(file, body) {
   }
 }
 
-// 첫 원본 백업. 이미 있으면 덮지 않는다. 만들지 못하면 바꾸지 않고 거부.
+// 첫 원본 백업. 이미 있으면 덮지 않는다. 만들지 못하거나 그 자리에 일반 파일이 아닌 것(링크 등)이 있으면 바꾸지 않고 거부.
 function backup(file, buf) {
   const bak = `${file}.progress-mon.bak`;
   try {
-    fs.writeFileSync(bak, buf, { flag: 'wx' });
+    writeNew(bak, buf);
   } catch (e) {
-    if (e.code !== 'EEXIST') throw new UsageError(`${path.basename(bak)} 백업을 만들지 못해 규칙 줄을 바꾸지 않음(${e.code || e.message})`);
+    // EEXIST 는 그 자리에 일반 파일(먼저 남긴 첫 원본)이 있을 때만 통과. 링크, 폴더, 그 사이 사라진 이름은 거부
+    const st = e.code === 'EEXIST' ? fs.lstatSync(bak, { throwIfNoEntry: false }) : null;
+    const why = e.code !== 'EEXIST' ? e.code || e.message : !st ? '만든 뒤 이름이 사라짐' : !st.isFile() ? '일반 파일이 아닌 것(링크나 폴더)이 있음' : null;
+    if (why) throw new UsageError(`${path.basename(bak)} 백업을 만들지 못해 규칙 줄을 바꾸지 않음(${why})`);
   }
   return bak;
 }

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

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import { privateIPv4, dataLabel, loadConfig, writeAtomic, readRegular, UsageError } from './pm-config.mjs';
+import { privateIPv4, dataLabel, loadConfig, writeAtomic, writeNew, readRegular, UsageError } from './pm-config.mjs';
 import { workflowRoots } from './pm-sources.mjs';
 import { memoryWarnings } from './pm-memory.mjs';
 
@@ -521,7 +521,7 @@ export async function saveHost(ctx, ip, io, fsx = fs) {
 
 // ---------- start 잠금 ----------
 // 동시에 부른 start 가 서버를 둘 띄우지 않게 start 전체를 server.json.lock 으로 감싼다(wx: 둘 가운데 하나만 만듦,
-// 그 자리의 링크는 따라가지 않고 EEXIST). 못 잡은 쪽은 기다렸다가 잡고, 그 안에서 떠 있는 서버를 다시 보아 재사용한다.
+// 그 자리의 링크는 따라가지 않고 EEXIST. Windows 의 wx 는 끊어진 링크를 따라가므로 writeNew 가 먼저 lstat 로 본다). 못 잡은 쪽은 기다렸다가 잡고, 그 안에서 떠 있는 서버를 다시 보아 재사용한다.
 // 낡은 잠금(쥔 프로세스가 죽음, 또는 START_LOCK_STALE_MS 넘게 남음, 링크나 일반 파일 아님)은 넘겨받기 표지
 // server.json.lock.taking 을 wx 로 잡은 쪽만, 그 안에서 다시 판정한 뒤 지우고 새로 만든다.
 const START_LOCK = 'server.json.lock';
@@ -535,7 +535,7 @@ const LOCK_BUSY = new Set(['EEXIST', 'EPERM', 'EACCES', 'EBUSY']);
 // 돌려줌: 만들었으면 null, 아니면 그 까닭 코드. 그 밖 오류는 UsageError.
 function makeLockFile(file) {
   try {
-    fs.writeFileSync(file, `${process.pid} ${iso(Date.now())}\n`, { flag: 'wx', mode: 0o600 });
+    writeNew(file, `${process.pid} ${iso(Date.now())}\n`, { mode: 0o600 });
     return null;
   } catch (e) {
     if (LOCK_BUSY.has(e.code)) return e.code;

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

@@ -186,7 +186,8 @@ export function stageStates(records) {
 // ---------- git ----------
 
 const gitCache = new Map();
-const git = (cwd, args) => execFileSync('git', ['-C', cwd, ...args], { encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 * 1024 * 1024 });
+// 홈 폴더에서 부른다(Windows 는 일하는 폴더의 git.exe 를 먼저 찾는다)
+const git = (cwd, args) => execFileSync('git', ['-C', path.resolve(cwd), ...args], { cwd: fs.existsSync(os.homedir()) ? os.homedir() : os.tmpdir(), encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 * 1024 * 1024 });
 
 const readText = (p) => {
   try {

package/skills/ralph-qa/SKILL.md

@@ -408,6 +408,7 @@ node '<R>/gate-evidence.mjs' cleanup --dir '<g>'
 
 ### 3. 판정 수신
 각 좌석에서 4값 중 하나를 받는다. 외부 좌석은 **단독 줄 `VERDICT: <값>`** 이 필수이며, 부재·중복·절단·파싱실패·거부는 `ERROR` 다.
+코드펜스(```, ~~~) 안의 `VERDICT:` 줄은 인용한 글이라 세지 않는다. 판정 줄을 코드펜스로 감싼 답은 판정 줄이 없는 답이라 `ERROR` 다. send 출력의 `answered`, `failed` 는 답한 좌석과 실패한 좌석의 수다. `ok: true` 는 send 가 돌았다는 뜻일 뿐이고, 실패한 좌석의 `facts` 에는 `verdict` 가 없다.
 
 **나눠 보낸 페이로드.** 한 좌석에 나눠 보낸 부분들은 그 좌석의 한 판정이다. 모든 부분이 `APPROVE` 일 때만 `APPROVE`, 하나라도 `ERROR` 면 `ERROR`, 그 밖은 가장 나쁜 값(`REJECT` 가 `ITERATE` 보다 나쁘다)이다. 부분끼리는 서로의 내용을 모르므로 좌석 줄에 `분할 N` 을 적는다.
 

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

@@ -601,11 +601,24 @@ const readText = (file) => {
   }
 };
 
+// The standalone verdict lines of an answer. A line inside a code fence (``` or ~~~) is quoted text, not the seat's verdict.
+export function verdictLines(out) {
+  let fence = null;
+  const found = [];
+  for (const line of out.split(/\r?\n/)) {
+    const mark = /^\s{0,3}(`{3,}|~{3,})/.exec(line);
+    if (mark && (!fence || (mark[1][0] === fence[0] && mark[1].length >= fence.length))) { fence = fence ? null : mark[1]; continue; }
+    const m = !fence && VERDICT_LINE.exec(line);
+    if (m) found.push(m[1]);
+  }
+  return found;
+}
+
 // What a seat's answer and errors say.
 function factsOf(cli, plan) {
   const out = readText(plan.answer);
   const err = readText(plan.stderr);
-  const facts = { verdicts: out.split(/\r?\n/).map((l) => VERDICT_LINE.exec(l)).filter(Boolean).map((m) => m[1]), empty: !out.trim() };
+  const facts = { verdicts: verdictLines(out), empty: !out.trim() };
   if (cli === "codex") facts.ranModel = (/^model: (\S+)/m.exec(err.split("\n").slice(0, 40).join("\n")) || [])[1] || null;
   if (cli === "gemini") Object.assign(facts, { policyError: err.includes("Policy file error"), apiError: err.includes("Full report") });
   if (cli === "opencode") facts.fallback = err.includes("Falling back to default agent");
@@ -665,10 +678,12 @@ async function runParts(ctx, run, seat, g, parts, base) {
   }
   const last = done[done.length - 1];
   const secs = Math.round(done.reduce((t, x) => t + (x.r.secs || 0), 0) * 10) / 10;
+  // a failed seat has no verdict to count, so its facts carry none (a reader that skips `status` would count it)
+  const shownFacts = (x) => { const f = factsShown(x.f); if (x.why) delete f.verdict; return f; };
   const result = { ...base, status: last.why ? "failed" : "answered", why: last.why, exit: last.r.exit, signal: last.r.signal, secs,
-    answer: last.plan.answer, errors: last.plan.stderr, facts: factsShown(last.f) };
+    answer: last.plan.answer, errors: last.plan.stderr, facts: shownFacts(last) };
   if (!last.why && parts.length > 1) result.facts.verdict = gathered(done.map((x) => x.f.verdicts[0]));
-  if (parts.length > 1) result.parts = done.map((x) => ({ answer: x.plan.answer, errors: x.plan.stderr, why: x.why, facts: factsShown(x.f) }));
+  if (parts.length > 1) result.parts = done.map((x) => ({ answer: x.plan.answer, errors: x.plan.stderr, why: x.why, facts: shownFacts(x) }));
   return result;
 }
 
@@ -838,7 +853,9 @@ async function send(o, ctx) {
     if (thrown) throw thrown.reason;
     const seats = settled.map((x) => x.value);
     if (!a.dryRun) appendFileSync(join(d, "run.md"), seats.filter((x) => x.cliVersion).map((x) => `cli-${x.seat} ${x.cliVersion}\n`).join(""), { mode: 0o600 });
-    const result = { ok: true, ...(a.dryRun ? { dryRun: true } : {}), dir: d, out, bytes: payload.length, scan: 0, unsent: unsentCount(d), seats, declared: declared(run, payload.length, seats, d) };
+    // ok says the send ran; whether seats answered is in `answered`, `failed` and each seat's status
+    const answered = seats.filter((x) => x.status === "answered").length;
+    const result = { ok: true, ...(a.dryRun ? { dryRun: true } : {}), dir: d, out, bytes: payload.length, scan: 0, unsent: unsentCount(d), answered, failed: seats.filter((x) => x.status === "failed").length, seats, declared: declared(run, payload.length, seats, d) };
     if (!a.dryRun) writeResult(d, "send", resultJson("send", result));
     return [result, signals.code(), a.dryRun ? null : d];
   } finally {