@kaydash9999/banker-plugins 0.24.1 → 0.25.1

package/skills/ralph-qa/references/verifier-probe.mjs

@@ -188,6 +188,8 @@ export const DECISION_REASONS = [
 
 export const CLI_DEFAULT = "@cli-default";
 
+// How a CLI call ended, for a note.
+const callWhy = (res) => (res?.why ? res.why : res?.status === 0 ? "exit 0 with output the probe could not use" : `exit ${res?.status ?? "?"}`);
 const firstLine = (res) => (res?.status === 0 ? String(res.stdout).trim().split("\n")[0] || null : null);
 const absent = (cli) => ({ cli, present: false, decision: "unseated", reason: "cli-absent" });
 const adopt = (seat, model, reason) => ({ ...seat, decision: "adopt", model, reason });
@@ -382,6 +384,8 @@ const rawMcpNames = (lines) => lines.filter((l) => !/^\s*#/.test(l))
 // or the line that opened what is still open), and the strings of each top-level array
 // (`arrays`). Enough for those keys; not a TOML parser.
 export function readToml(text) {
+  // a file there that could not be read (permissions, a folder): nothing it says is known, so it reads as broken
+  if (text?.unreadable) return { values: {}, roots: [], arrays: {}, mcpServers: [], mcpUnread: true, modelKeys: false, broken: true, brokenAt: 0, unreadable: text.unreadable };
   const state = tomlState();
   const lines = String(text ?? "").split(/\r?\n/);
   const isOpen = () => state.open !== null || state.depth > 0;
@@ -457,6 +461,7 @@ export function stripJsonc(text) {
 // { value } for a readable JSONC text, { unreadable: true } for a broken one, {} when absent.
 function readJsonc(text) {
   if (text == null) return {};
+  if (text.unreadable) return { unreadable: true };
   try {
     const value = JSON.parse(stripJsonc(String(text)));
     return value && typeof value === "object" && !Array.isArray(value) ? { value } : { unreadable: true };
@@ -530,7 +535,7 @@ function codexConfig(world) {
     mcpUnread: layers.some((l) => l.mcpUnread),
     modelKeys: layers.some((l) => l.modelKeys),
     broken: layers.some((l) => l.broken),
-    brokenAt: layers.map((l, k) => (l.broken ? `${files[k]} line ${l.brokenAt}` : null)).filter(Boolean),
+    brokenAt: layers.map((l, k) => (!l.broken ? null : l.unreadable ? `${files[k]} (not readable: ${l.unreadable})` : `${files[k]} line ${l.brokenAt}`)).filter(Boolean),
   };
 }
 
@@ -555,6 +560,8 @@ function mcpBlockedSeat(seat, conf, notes) {
 const SEAT_KEYS = ["notify", "otel", "mcp_servers", "web_search", "tools", "analytics", "features", "hooks",
   "sandbox_mode", "sandbox_workspace_write", "approval_policy"];
 
+const unreadAt = (read) => (read.unreadable ? `could not be read (${read.unreadable})` : `could not be read to its end (line ${read.brokenAt})`);
+
 // The unseated seat when the managed file sets one of those keys, or could not be read to its
 // end (a line read short may set one); null otherwise.
 function managedBlockedSeat(seat, world, notes) {
@@ -562,7 +569,7 @@ function managedBlockedSeat(seat, world, notes) {
   const read = readToml(world.readFile(CODEX_MANAGED));
   const keys = read.roots.filter((k) => SEAT_KEYS.includes(k));
   if (!keys.length && !read.broken) return null;
-  notes.push(`${CODEX_MANAGED} ${keys.length ? `sets ${keys.join(", ")}` : `could not be read to its end (line ${read.brokenAt})`}, which codex applies over the seat's -c flags: the seat cannot hold its guards`);
+  notes.push(`${CODEX_MANAGED} ${keys.length ? `sets ${keys.join(", ")}` : unreadAt(read)}, which codex applies over the seat's -c flags: the seat cannot hold its guards`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -583,7 +590,7 @@ function requirementsBlockedSeat(seat, world, notes) {
   const allows = (k) => SEAT_ALLOWS[k] !== undefined && (read.arrays[k] ?? []).includes(SEAT_ALLOWS[k]);
   const keys = read.roots.filter((k) => !GUARD_FREE.includes(k) && !allows(k));
   if (!keys.length && !read.broken) return null;
-  notes.push(`${CODEX_REQUIREMENTS} ${keys.length ? `sets ${keys.join(", ")}` : `could not be read to its end (line ${read.brokenAt})`}, which codex holds over the seat's -c, --disable and -s flags: the seat cannot hold its guards`);
+  notes.push(`${CODEX_REQUIREMENTS} ${keys.length ? `sets ${keys.join(", ")}` : unreadAt(read)}, which codex holds over the seat's -c, --disable and -s flags: the seat cannot hold its guards`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -653,10 +660,18 @@ function codexSeat(flag, { world, runtime, authorFamilies }) {
   const notes = [];
   const conf = codexConfig(world);
   const configured = vetConfigured(safeOnly([conf.cfg.model], "config.toml", notes)[0], authorFamilies, notes);
-  const catalog = readCatalog(world.run("codex", ["debug", "models", "--bundled"]), notes) ?? [];
+  const listed = world.run("codex", ["debug", "models", "--bundled"]);
+  const read = readCatalog(listed, notes);
+  const catalog = read ?? [];
   const sorted = sortModels([...catalog, configured], authorFamilies);
-  const version = firstLine(world.run("codex", ["--version"]));
+  const ran = world.run("codex", ["--version"]);
+  // a version line has a version number in it; an error text on stdout with exit 0 is not one
+  const version = /\d+\.\d+/.test(firstLine(ran) ?? "") ? firstLine(ran) : null;
+  if (!read) notes.push(`codex debug models --bundled gave no catalog (${callWhy(listed)})`);
+  if (!version) notes.push(`codex --version gave no version (${callWhy(ran)})`);
   const seat = { cli: "codex", present: true, version, configured, candidates: sorted.independent, unclassified: sorted.unclassified, mcpServers: conf.mcpServers };
+  // both calls failed: this codex does not run here (not logged in, broken install, killed), so it is not a seat
+  if (!read && !version) return withNotes({ ...seat, decision: "unseated", reason: "cli-call-failed" }, notes);
   const refused = legacyProfileSeat(seat, conf.cfg, notes) ?? managedBlockedSeat(seat, world, notes)
     ?? requirementsBlockedSeat(seat, world, notes) ?? mcpBlockedSeat(seat, conf, notes);
   if (refused) return withNotes(refused, notes);
@@ -710,8 +725,10 @@ function geminiPoliciesDir(world) {
 // seat's read-only tools rest on that flag: such a seat is not seated.
 function geminiPolicySeat(seat, world, notes) {
   const dir = geminiPoliciesDir(world);
-  if (!world.listDir(dir).some((f) => f.endsWith(".toml"))) return null;
-  notes.push(`gemini ignores --admin-policy while ${dir} holds policies: the seat cannot be held to its read-only tools`);
+  const list = world.listDir(dir);
+  if (list && !list.some((f) => f.endsWith(".toml"))) return null;
+  notes.push(list ? `gemini ignores --admin-policy while ${dir} holds policies: the seat cannot be held to its read-only tools`
+    : `the probe could not list ${dir}: gemini ignores --admin-policy while it holds policies, so the seat cannot be shown to keep to its read-only tools`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -835,7 +852,8 @@ const opencodeCache = (world) => join(world.env.XDG_CACHE_HOME || join(world.hom
 function catalogProviders(world) {
   const file = join(opencodeCache(world), "models.json");
   const read = readJsonc(world.readFile(file));
-  return read.value ? new Set(Object.keys(read.value)) : null;
+  // an emptied copy ({}) lists no provider: it says nothing about which ones models.dev knows
+  return read.value && Object.keys(read.value).length ? new Set(Object.keys(read.value)) : null;
 }
 
 // The models the config lists are all opencode can run only when enabled_providers names
@@ -953,18 +971,20 @@ function realWorld() {
     platform: process.platform,
     env: process.env,
     which: onPath,
+    // null when the file is not there; { unreadable } when it is but cannot be read, which is not the same as absent
     readFile: (path) => {
       try {
         return readFileSync(path, "utf8");
-      } catch {
-        return null;
+      } catch (e) {
+        return e.code === "ENOENT" || e.code === "ENOTDIR" ? null : { unreadable: e.code || "error" };
       }
     },
+    // [] when the folder is not there; null when it is but cannot be listed
     listDir: (path) => {
       try {
         return readdirSync(path);
-      } catch {
-        return [];
+      } catch (e) {
+        return e.code === "ENOENT" || e.code === "ENOTDIR" ? [] : null;
       }
     },
     run: (cmd, args, env = {}) => {
@@ -978,11 +998,13 @@ function realWorld() {
       const r = spawnSync(viaCmd ? `"${exe}"` : exe, args, {
         encoding: "utf8",
         timeout: 15000,
+        // a CLI that ignores SIGTERM would hold spawnSync past its time limit
+        killSignal: "SIGKILL",
         maxBuffer: 64 * 1024 * 1024,
         shell,
         env: { ...process.env, ...(viaCmd ? { NoDefaultCurrentDirectoryInExePath: "1" } : {}), ...env },
       });
-      return { status: r.status, stdout: r.stdout ?? "" };
+      return { status: r.status, stdout: r.stdout ?? "", why: r.error ? (r.error.code === "ETIMEDOUT" ? "timed out" : r.error.code) : r.signal ? `killed by ${r.signal}` : null };
     },
   };
 }

package/skills/remains/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: remains
-description: "남은 버그, 하자, 미검증 항목을 찾아 표로 보여 줌. 테스트박스가 등록돼 있으면 각 OS 에서 시험을 돌려 확인함. 읽기와 시험 실행만 하고 고치지 않음. 'remains'/'남은 버그'/'남은 하자'/'미검증 항목'/'뭐가 남았어' 시 사용."
+description: "남은 버그, 하자, 미검증 항목을 찾아 표로 보여 줌. 찾은 결함과 원인이 같은 자리는 저장소 전체에서 찾음. 테스트박스가 등록돼 있으면 각 OS 에서 시험을 돌려 확인함. 읽기와 시험 실행만 하고 고치지 않음. 'remains'/'남은 버그'/'남은 하자'/'미검증 항목'/'뭐가 남았어' 시 사용."
 argument-hint: "[기준 커밋] [--no-boxes]"
 ---
 
@@ -28,10 +28,34 @@ argument-hint: "[기준 커밋] [--no-boxes]"
 |---|---|
 | 이번 대화 | 미검증이나 보류로 남긴 것, 검토의 비차단 지적, 사용자가 미룬 결정, 보고했지만 확인하지 않은 주장 |
 | 저장소 기록 | 인계 문서(예: `.omc/handoffs/`), CHANGELOG `[Unreleased]` 의 `UNVALIDATED` 나 미검증 표기, 문서의 미검증 절 |
-| 코드 표시 | 범위 안에서 바뀐 파일의 `TODO`, `FIXME`, `XXX`, `HACK`, 시험의 `skip`, `only`, `todo` |
+| 코드 표시 | 범위 안에서 바뀐 파일의 `TODO`, `FIXME`, `XXX`, `HACK`, 시험의 `skip`, `only`, `todo`. 같은 종류는 2-1 에서 저장소 전체로 넓힌다 |
 | git 상태 | 커밋하지 않은 변경, push 하지 않은 커밋, 추적하지 않는 새 파일 |
 | 메모리와 노트 | 있으면 그 안의 남은 지적 |
 
+## 2-1. 같은 종류 전체 찾기 (읽기만)
+
+지적을 그 자리에만 적으면 같은 원인의 결함이 다른 파일에 남는다. 그러면 고칠 때마다 다음 검토에서 같은 종류가 또 나온다. 그래서 모은 결함 항목(버그와 하자)마다 같은 종류를 저장소 전체에서 찾는다.
+
+1. 항목마다 결함 종류를 원인으로 한 문장에 쓴다. 자리 이름으로 쓰지 않는다.
+   - 예: "Windows 의 wx 는 끊어진 링크를 따라가므로, 추측 가능한 이름에 새 파일을 만들면 링크 너머에 파일이 생긴다"
+   - 예: "경로 문자열로 같은 파일인지 판정하면 대소문자, 8.3 짧은 이름, 링크인 부모 폴더만 다른 같은 파일을 놓친다"
+2. 같은 원인을 내는 코드 꼴을 모두 적는다. API 하나만 보지 않는다.
+   - 예: `wx` 만이 아니라 `O_EXCL`, `COPYFILE_EXCL`, `wx` 없이 추측 가능한 임시 이름에 쓰는 것까지
+   - 예: `===` 비교만이 아니라 `Map`, `Set` 키, `startsWith`, `path.relative` 의 `..` 판정, `includes` 까지
+3. 범위는 바뀐 파일이 아니라 배포되는 파일 전부다.
+   - 같은 파일의 사본(다른 스킬 폴더, 런타임별 폴더)도 각각 센다.
+   - 시험과 개발 도구에서 찾은 것은 따로 표시한다.
+4. 찾은 명령과 건수를 확인 범위에 적는다.
+   - 찾기가 0건이면 패턴을 의심한다. 더 단순한 패턴이나 다른 도구(`rg`, `git grep`)로 다시 찾는다. 셸의 `grep` 이 다른 도구로 바뀌어 있을 수 있다.
+5. 찾은 자리마다 판정한다.
+   - 고칠 것: 결과(거짓 성공, 예외, 경계 우회, 밖 파일 생성 등)를 적는다.
+   - 해당 없음: 까닭(방어가 이미 있음, 닿는 길이 없음, 이름을 미리 알 수 없음 등)을 적는다.
+6. 프로젝트에 기록된, 이미 고친 결함도 종류로 삼는다.
+   - 출처: CHANGELOG 의 고친 항목, 위키와 메모리의 함정 기록
+   - 비슷한 항목은 종류 하나로 묶어 중복을 줄인다.
+   - 예전에 한 곳만 고친 종류가 다른 곳에 남았는지 1~5 와 같은 방법으로 본다.
+7. 자리가 많으면 런타임이 지원하는 읽기 전용 하위 에이전트에게 종류별로 나눠 맡겨도 된다. 맡길 때는 결함 종류, 찾을 꼴, 이미 고친 본보기를 함께 준다. 하위 에이전트도 고치지 않는다.
+
 ## 3. 이 머신에서 시험
 
 - 프로젝트의 시험 명령을 찾는다. `package.json` 의 `scripts.test`, CI 워크플로의 시험 단계, `Makefile`, pytest 설정, `*.test.mjs`(node:test) 순으로 본다. 찾은 명령과 그 근거를 확인 범위에 적는다.
@@ -68,7 +92,7 @@ argument-hint: "[기준 커밋] [--no-boxes]"
    - `noTests` 는 시험이 하나도 돌지 않았다는 뜻이라 통과가 아니라 미검증이다.
    - 한 OS 에서만 실패하면, 제품의 결함은 버그로, 시험이 실행 환경을 잘못 가정한 것은 하자로 적는다.
 
-박스에 둔 것은 `run` 이 끝날 때 지운다. 시간 초과, 연결 끊김, 중단(SIGINT, SIGTERM) 때는 박스에서 시작한 프로세스를 먼저 끝낸다. Linux, macOS 는 `mktemp -d` 로 만든 개인 폴더를 쓴다. 지우지 못하면 결과의 `cleaned` 가 `false` 이고, 그 박스를 하자로 적는다.
+박스에 둔 것은 `run` 이 끝날 때 지운다. 시간 초과, 연결 끊김, 중단(SIGINT, SIGTERM) 때는 박스에서 시작한 프로세스를 먼저 끝낸다. Linux, macOS 는 `mktemp -d` 로 만든 개인 폴더를 쓴다. 보통은 `/tmp` 아래이고, `runAs` 박스는 `/var/lib` 아래다. `runAs` 계정의 HOME 도 그 안에 있어서, 임시 폴더를 거부하는 도구(teamwork 등)의 시험도 그대로 돈다. 지우지 못하면 결과의 `cleaned` 가 `false` 이고, 그 박스를 하자로 적는다.
 알려진 한계: 이중 fork 로 프로세스 트리를 벗어난 프로세스는 끝나지 않는다. `pgrep` 이 없는 박스에서는 기록된 프로세스 하나만 끝난다.
 
 ### 등록 파일
@@ -90,7 +114,7 @@ argument-hint: "[기준 커밋] [--no-boxes]"
 | `name` | 박스 이름(영문이나 숫자로 시작, 영문, 숫자, `.`, `_`, `-`) |
 | `os` | `linux`, `darwin`, `win32` 중 하나 |
 | `ssh` | `user@host`. 암호 없이 SSH 키로 접속돼야 한다 |
-| `port`, `identity` | 선택. SSH 포트와 키 파일 경로 |
+| `port`, `identity` | 선택. SSH 포트와 키 파일 경로(상대 경로는 boxes.mjs 를 실행한 폴더 기준) |
 | `path` | 선택. Linux, macOS 박스에서 PATH 앞에 붙일 절대 경로(비대화형 SSH 의 PATH 에 node 가 없을 때) |
 | `runAs` | 선택. root 로 접속하는 Linux 박스에서 시험을 대신 돌릴 계정(예: `nobody`) |
 
@@ -123,5 +147,8 @@ argument-hint: "[기준 커밋] [--no-boxes]"
 
 - 근거는 다시 확인할 수 있게 쓴다(파일과 줄, 명령, 시험 이름, 로그 경로).
 - 심각도가 높은 것부터 놓는다.
+- 2-1 의 결함 종류는 종류마다 한 행으로 쓴다. 항목 칸에 종류를, 근거 칸에 고칠 자리 수와 해당 없음 수를 적는다.
+  - 고칠 자리가 20곳 이하면 표 아래에 `파일:줄 | 판정 | 까닭` 목록을 붙인다.
+  - 20곳을 넘으면 자리 목록을 시스템 임시 폴더의 파일에 쓰고 그 경로를 근거에 적는다. 저장소 안에는 쓰지 않는다.
 - 남은 항목이 없으면 표 대신 "남은 항목 없음" 과 확인 범위를 쓴다.
 - 마지막 줄에는 사용자가 고를 다음 행동을 쓴다(예: 고칠 항목 고르기). 고치는 일은 요청을 받은 뒤에 한다.

package/skills/remains/scripts/boxes.mjs

@@ -15,15 +15,23 @@ import { spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { copyFileSync, existsSync, linkSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// The folder programs start in: the home folder (Windows looks for a program in the working folder first, so a
+// program planted in the folder worked on never runs), or the temp folder when there is no home folder.
+const runDir = () => (existsSync(homedir()) ? homedir() : tmpdir());
+
 const OSES = new Set(["linux", "darwin", "win32"]);
 const FIELDS = new Set(["name", "os", "ssh", "port", "identity", "path", "runAs"]);
 const SECRETISH = /pass|secret|token|credential/i;
 const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const TARGET = /^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9.-]*$/;
-const REMOTE_DIR = /^\/tmp\/banker-remains\.[A-Za-z0-9]+$/;
+// Where a box's private folder goes. A runAs box gets one outside the temporary folders, so that the copy and the
+// run account's HOME inside it are not under /tmp: tools that refuse temporary folders (teamwork's Codex home check)
+// would refuse the tests' fixtures there. /var/lib is root's, so only a root login (runAs) makes one there.
+const dirBase = (b) => (b.runAs ? "/var/lib" : "/tmp");
+const remoteDir = (b) => new RegExp(`^${dirBase(b).replace(/\//g, "\\/")}\\/banker-remains\\.[A-Za-z0-9]+$`);
 // What ssh and scp print about the connection itself, as opposed to what the remote command prints.
 const SSH_ERR = /^(ssh|scp): |Connection (closed|refused|reset|timed out)|Host key verification failed|Permission denied \(|Could not resolve hostname|No route to host|Broken pipe/m;
 const UPLOAD_MS = 10 * 60 * 1000;
@@ -102,7 +110,10 @@ export function loadBoxes(file = configFile()) {
 
 // ── commands for a box ───────────────────────────────────────────────────────
 
-const extras = (b, portFlag) => [...(b.port ? [portFlag, String(b.port)] : []), ...(b.identity ? ["-i", b.identity] : [])];
+// ssh and scp start in the home folder, so a relative key path is made absolute against this run's folder first,
+// where it was meant. A path from ~ stays as it is: OpenSSH expands it itself.
+const keyPath = (p) => (/^~([\\/]|$)/.test(p) || isAbsolute(p) ? p : resolve(p));
+const extras = (b, portFlag) => [...(b.port ? [portFlag, String(b.port)] : []), ...(b.identity ? ["-i", keyPath(b.identity)] : [])];
 export const sshBase = (b) => [...BASE, ...extras(b, "-p")];
 export const scpBase = (b) => [...BASE, ...extras(b, "-P")];
 
@@ -146,8 +157,8 @@ function winSteps(b, name) {
   };
 }
 
-// Linux and macOS work in the private folder `mktemp -d` made. A root login hands the run to runAs, with a
-// HOME of its own. Ending a run takes the process tree under the recorded id first, then the folder.
+// Linux and macOS work in the private folder `mktemp -d` made (under /tmp, or /var/lib for runAs). A root login
+// hands the run to runAs, with a HOME of its own inside that folder. Ending a run takes the process tree under the recorded id first, then the folder.
 function posixSteps(b, name, dir) {
   const go = b.runAs
     ? `mkdir -p "$D/home" && chown -R ${b.runAs} "$D" && runuser -u ${b.runAs} -- env HOME="$D/home" sh "$D/run.sh"`
@@ -220,10 +231,10 @@ const sshFailed = (r) => (r.status === null && !r.timedOut) || (r.status === 255
 
 async function makeDir(b, exec) {
   if (b.os === "win32") return { dir: null };
-  const r = await exec("ssh", [...sshBase(b), b.ssh, "mktemp -d /tmp/banker-remains.XXXXXXXX"], { timeoutMs: PROBE_MS });
+  const r = await exec("ssh", [...sshBase(b), b.ssh, `mktemp -d ${dirBase(b)}/banker-remains.XXXXXXXX`], { timeoutMs: PROBE_MS });
   const dir = String(r.stdout || "").trim();
   if (r.status !== 0) return { error: lastLine(r.stderr) || "ssh 실패" };
-  return REMOTE_DIR.test(dir) ? { dir } : { error: `mktemp -d 가 예상과 다른 경로를 냈습니다: ${dir.slice(0, 80)}` };
+  return remoteDir(b).test(dir) ? { dir } : { error: `mktemp -d 가 예상과 다른 경로를 냈습니다: ${dir.slice(0, 80)}` };
 }
 
 async function attempt(b, plan, exec, files, steps) {
@@ -256,22 +267,39 @@ export async function runOnBox(b, plan, exec) {
   return { ...rest, ms: Date.now() - t0 };
 }
 
-function git(cwd, args) {
-  const r = spawnSync("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-  if (r.status !== 0) throw new Error(`git ${args.filter((a) => !a.includes("=")).join(" ")} 실패: ${lastLine(r.stderr) || r.error?.message || ""}`);
+// Started from the home folder with git -C: Windows looks for a program in the working folder first, so a git.exe
+// inside the folder worked on never runs.
+function git(cwd, args, env = process.env) {
+  const r = spawnSync("git", ["-C", resolve(cwd), ...args], { cwd: runDir(), env, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  if (r.status !== 0) throw new Error(`git ${gitWords(args)} 실패: ${lastLine(r.stderr) || r.error?.message || ""}`);
   return r.stdout;
 }
 
+// The command words for a message: global options (-c key=value, --no-optional-locks) are left out.
+export const gitWords = (args) => args.filter((a, i) => a !== "-c" && args[i - 1] !== "-c" && !a.startsWith("--no-optional-locks")).join(" ");
+
 // The commit to send. `worktree` is a commit object made from the tracked files as they are now
 // (git stash create: no stash entry, no change to the work tree). Untracked files are never sent.
-function resolveTree(repo, ref) {
-  const status = git(repo, ["status", "--porcelain", "--untracked-files=all"]).split("\n").filter(Boolean);
+// Neither step writes the repository's index: status takes no optional lock, and stash create works on a copy of
+// the index (GIT_INDEX_FILE), so two runs at once, or a git command of the user's, do not meet on index.lock.
+export function resolveTree(repo, ref) {
+  const status = git(repo, ["--no-optional-locks", "status", "--porcelain", "--untracked-files=all"]).split("\n").filter(Boolean);
   const untracked = status.filter((l) => l.startsWith("??")).length;
   if (ref !== "worktree") {
     return { sha: git(repo, ["rev-parse", "--verify", `${ref}^{commit}`]).trim(), untracked, modified: status.length - untracked };
   }
-  const made = git(repo, ["-c", "user.name=banker-remains", "-c", "user.email=banker-remains@localhost", "stash", "create"]).trim();
-  return { sha: made || git(repo, ["rev-parse", "HEAD"]).trim(), untracked, modified: 0 };
+  const tmp = join(tmpdir(), `banker-remains-index-${randomBytes(8).toString("hex")}`);
+  mkdirSync(tmp, { mode: 0o700 });
+  try {
+    const index = resolve(repo, git(repo, ["rev-parse", "--git-path", "index"]).trim());
+    const copy = join(tmp, "index");
+    if (existsSync(index)) copyFileSync(index, copy);
+    const env = { ...process.env, GIT_INDEX_FILE: copy };
+    const made = git(repo, ["-c", "user.name=banker-remains", "-c", "user.email=banker-remains@localhost", "stash", "create"], env).trim();
+    return { sha: made || git(repo, ["rev-parse", "HEAD"]).trim(), untracked, modified: 0 };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 }
 
 function testFiles(repo, sha) {
@@ -423,7 +451,8 @@ export async function main(argv, deps = {}) {
 // even if a grandchild still holds its pipes. Output past MAX_OUTPUT is dropped.
 export function spawnExec(file, args, { timeoutMs = UPLOAD_MS } = {}) {
   return new Promise((resolve) => {
-    const child = spawn(file, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    // from the home folder: Windows looks for ssh.exe and scp.exe in the working folder (the repository) first
+    const child = spawn(file, args, { cwd: runDir(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
     children.add(child);
     const buf = { stdout: "", stderr: "" };
     for (const k of ["stdout", "stderr"]) {

package/skills/setup-bypass-permissions/scripts/bypass-permissions.mjs

@@ -38,6 +38,7 @@
  * folder (a sandbox, a read-only mount, a file another account owns): the settings are unchanged.
  * Every output ends with the line `설정 파일: <path>`.
  */
+import { randomBytes } from "node:crypto";
 import { accessSync, chmodSync, constants, existsSync, lstatSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -187,7 +188,7 @@ function writeFresh(file, data, mode) {
   if (lstatSync(file, { throwIfNoEntry: false })?.isDirectory()) {
     throw Object.assign(new Error(`쓸 자리에 폴더가 있습니다: ${file}`), { code: "EISDIR" });
   }
-  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/setup-bypass-permissions/scripts/codex-config.mjs

@@ -9,6 +9,7 @@
  * - 파일이 링크이거나 일반 파일이 아니면 고치지 않는다. 쓰기 전 원본을 백업(이 계정만 읽음)하고, 새 파일에 쓴 뒤
  *   바꿔 넣으며 파일 모드를 지킨다.
  */
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -34,15 +35,19 @@ export function readToml(file) {
   return { text: fs.readFileSync(file, 'utf8'), mode: st.mode & 0o7777, exists: true };
 }
 
-// 원본을 backup 에 복사한 뒤(원본이 있을 때) 새 파일에 써서 바꿔 넣는다.
+// 원본을 backup 에 복사한 뒤(원본이 있을 때) 새 파일에 써서 바꿔 넣는다. 백업도 같은 방식이라 백업 자리의 링크는
+// 따라가지 않고 바뀐다.
 export function writeToml(file, text, { mode = null, backup = null } = {}) {
-  if (backup && fs.existsSync(file)) {
-    fs.copyFileSync(file, backup);
-    fs.chmodSync(backup, 0o600); // 원본에 비밀 값이 있을 수 있다
-  }
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  if (backup && fs.existsSync(file)) replaceFile(backup, fs.readFileSync(file), 0o600); // 원본에 비밀 값이 있을 수 있다
+  replaceFile(file, text, mode);
+}
+
+// 난수 이름의 새 파일에 쓴 뒤 file 자리로 바꿔 넣는다. 이름을 미리 맞힐 수 없어, 그 자리에 심어 둔 링크를 wx 가
+// 따라가는 일(Windows 는 끊어진 링크를 따라가 대상 파일을 만든다)이 없다. 실패하면 새 파일을 지운다.
+function replaceFile(file, data, mode) {
+  const tmp = `${file}.${crypto.randomBytes(8).toString('hex')}.tmp`;
   try {
-    fs.writeFileSync(tmp, text, { flag: 'wx', mode: mode ?? 0o600 });
+    fs.writeFileSync(tmp, data, { flag: 'wx', mode: mode ?? 0o600 });
     if (mode !== null) fs.chmodSync(tmp, mode);
     fs.renameSync(tmp, file);
   } catch (e) {

package/skills/setup-omc-hud/assets/apply-hud.mjs

@@ -34,6 +34,7 @@
  * changes the exit code. APPLY_HUD_CHECK_TIMEOUT_MS (tests) shortens its 25s limit.
  * Exit 1 means nothing changed; exit 2 means an unexpected error stopped it partway.
  */
+import { randomBytes } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
   accessSync,
@@ -405,7 +406,7 @@ function writeSettings(file, text) {
   } catch {
     if (isLink(file)) return writeFileSync(file, text);
   }
-  const tmp = `${target}.${process.pid}.tmp`;
+  const tmp = `${target}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   try {
     rmSync(tmp, { force: true });
     writeFileSync(tmp, text, { flag: "wx", mode });

package/skills/setup-omc-hud/assets/codex-config.mjs

@@ -9,6 +9,7 @@
  * - 파일이 링크이거나 일반 파일이 아니면 고치지 않는다. 쓰기 전 원본을 백업(이 계정만 읽음)하고, 새 파일에 쓴 뒤
  *   바꿔 넣으며 파일 모드를 지킨다.
  */
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -34,15 +35,19 @@ export function readToml(file) {
   return { text: fs.readFileSync(file, 'utf8'), mode: st.mode & 0o7777, exists: true };
 }
 
-// 원본을 backup 에 복사한 뒤(원본이 있을 때) 새 파일에 써서 바꿔 넣는다.
+// 원본을 backup 에 복사한 뒤(원본이 있을 때) 새 파일에 써서 바꿔 넣는다. 백업도 같은 방식이라 백업 자리의 링크는
+// 따라가지 않고 바뀐다.
 export function writeToml(file, text, { mode = null, backup = null } = {}) {
-  if (backup && fs.existsSync(file)) {
-    fs.copyFileSync(file, backup);
-    fs.chmodSync(backup, 0o600); // 원본에 비밀 값이 있을 수 있다
-  }
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  if (backup && fs.existsSync(file)) replaceFile(backup, fs.readFileSync(file), 0o600); // 원본에 비밀 값이 있을 수 있다
+  replaceFile(file, text, mode);
+}
+
+// 난수 이름의 새 파일에 쓴 뒤 file 자리로 바꿔 넣는다. 이름을 미리 맞힐 수 없어, 그 자리에 심어 둔 링크를 wx 가
+// 따라가는 일(Windows 는 끊어진 링크를 따라가 대상 파일을 만든다)이 없다. 실패하면 새 파일을 지운다.
+function replaceFile(file, data, mode) {
+  const tmp = `${file}.${crypto.randomBytes(8).toString('hex')}.tmp`;
   try {
-    fs.writeFileSync(tmp, text, { flag: 'wx', mode: mode ?? 0o600 });
+    fs.writeFileSync(tmp, data, { flag: 'wx', mode: mode ?? 0o600 });
     if (mode !== null) fs.chmodSync(tmp, mode);
     fs.renameSync(tmp, file);
   } catch (e) {

package/skills/setup-omc-hud/scripts/claude-update-last.mjs

@@ -25,6 +25,7 @@
  * `node --check`. 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, constants, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -139,7 +140,7 @@ function insertBlock(base) {
 // either name is replaced rather than written through, and a write that fails
 // leaves the old file as it was.
 function writeFresh(file, data) {
-  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" });

package/skills/smart-compact/scripts/codex-gate.mjs

@@ -27,6 +27,7 @@ import {
   chmodSync, closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, realpathSync,
   renameSync, rmSync, statSync, writeFileSync,
 } from "node:fs";
+import { randomBytes } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
 import { join, posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -60,10 +61,11 @@ function readJson(file) {
   }
 }
 
-// A new file beside the target, given the target's mode when there is one, then renamed over it. The temp name is
-// created exclusively and a link in the target's place is replaced, not followed. The temp file goes on failure.
+// A new file beside the target, given the target's mode when there is one, then renamed over it. The temp name ends
+// in random bytes, so no one can plant a link at it first (Windows opens "wx" through a link to nothing and makes the
+// file it leads to), and a link in the target's place is replaced, not followed. The temp file goes on failure.
 function writeAtomic(file, data) {
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  const tmp = `${file}.${randomBytes(8).toString("hex")}.tmp`;
   try {
     writeFileSync(tmp, data, { flag: "wx" });
     const mode = modeOf(file);
@@ -214,10 +216,29 @@ export function hookCommand(node, script, opts = {}) {
     const r = P.relative(dir, f);
     return r === "" || (!r.startsWith("..") && !P.isAbsolute(r));
   };
-  if (under(node, tmpdir()) || (codex && [node, SELF].some((f) => under(f, cwd)))) return null;
+  // Each path as given and as the file system spells it: a link, macOS /var against /private/var, a Windows 8.3 name
+  // or another case would otherwise slip a node in the temp folder past the check.
+  const both = (p) => [p, realOf(p)];
+  const temps = [tmpdir(), ...(win ? [] : ["/tmp"])].flatMap(both);
+  const inTemp = both(node).some((f) => temps.some((d) => under(f, d)));
+  const inWork = codex && [node, SELF].flatMap(both).some((f) => both(cwd).some((d) => under(f, d)));
+  if (inTemp || inWork) return null;
   return formatCommand(node, script, win);
 }
 
+// The path as the file system spells it (native first: it gives the long name and the case on disk), or as given.
+function realOf(p) {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    try {
+      return realpathSync(p);
+    } catch {
+      return p;
+    }
+  }
+}
+
 const COPY_RE = new RegExp(`[/\\\\]${COPY_NAME.replace(/\./g, "\\.")}["']? hook$`);
 const isOurs = (h) => isObject(h) && typeof h.command === "string" && COPY_RE.test(h.command);
 

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

@@ -198,7 +198,8 @@ export function writeFresh(file, data, mode = 0o644) {
 // any name that is there, a link to nothing among them (EEXIST). Windows follows a link to nothing and makes the file
 // it leads to: then that file is removed again when it is still the empty one made, and the open is refused with
 // EEXIST as elsewhere. A look before the open catches such a link; this catches one planted between the look and the
-// open. A look that fails after the open leaves the file to the caller, as a plain "wx" would.
+// open. A name gone after the open is EEXIST too. A look that cannot be made (ESTALE, EPERM) leaves the file to the
+// caller, as a plain "wx" would.
 export function openNew(path, mode) {
   const fd = openSync(path, "wx", mode);
   let made = null;
@@ -206,8 +207,10 @@ export function openNew(path, mode) {
   try {
     made = fstatSync(fd, { bigint: true });
     st = lstatSync(path, { bigint: true });
-  } catch {
-    return fd;
+  } catch (e) {
+    if (e?.code !== "ENOENT") return fd; // cannot look (ESTALE, EPERM): the file is the caller's, as a plain "wx" leaves it
+    closeSync(fd); // the name is gone: nothing is written through a name not proved
+    throw Object.assign(new Error(`EEXIST: file already exists, open '${path}'`), { code: "EEXIST", syscall: "open", path });
   }
   if (!st.isSymbolicLink() && (made.ino === 0n || sameInode(made, st))) return fd;
   closeSync(fd);