@kaydash9999/banker-plugins 0.24.0 → 0.25.0

package/skills/build-testbox/scripts/proc.mjs

@@ -1,9 +1,9 @@
 // Child processes for build-testbox: PATH lookup (PATHEXT on Windows), a promise-returning runner with a time limit
 // and a set of live children, so a signal handler can stop them all. No shell: arguments go to the program as given.
 // On Windows a .cmd or .bat goes through cmd.exe with each argument quoted (Node refuses to spawn them directly).
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { accessSync, constants, statSync } from "node:fs";
-import { delimiter, extname, isAbsolute, join } from "node:path";
+import { delimiter, extname, isAbsolute, join, win32 } from "node:path";
 
 const LIVE = new Set();
 const MAX_OUT = 8 * 1024 * 1024;
@@ -51,6 +51,21 @@ function collector() {
   return { parts, add };
 }
 
+// Ends a child and everything it started: on POSIX its process group (the child leads one, spawned detached), on
+// Windows the tree through System32's taskkill /T /F (not a taskkill found in the working folder).
+function killTree(child) {
+  if (process.platform === "win32") {
+    const taskkill = win32.join(process.env.SystemRoot || "C:\\Windows", "System32", "taskkill.exe");
+    spawnSync(taskkill, ["/T", "/F", "/PID", String(child.pid)], { stdio: "ignore", windowsHide: true });
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    try { child.kill("SIGKILL"); } catch { /* already gone */ }
+  }
+}
+
 // Runs a program and resolves { code, signal, stdout, stderr, out, timedOut, error }. Never rejects: a missing
 // program is { code: null, error: "ENOENT" }. out holds stdout and stderr in arrival order.
 export function runProc(cmd, args = [], opts = {}) {
@@ -61,13 +76,19 @@ export function runProc(cmd, args = [], opts = {}) {
     let timedOut = false;
     let child;
     try {
-      child = spawn(bin, argv, { cwd: opts.cwd, env: opts.env || process.env, stdio: ["ignore", "pipe", "pipe"], ...extra });
+      const detached = process.platform !== "win32"; // its own process group, so a time-out ends what it started too
+      child = spawn(bin, argv, { cwd: opts.cwd, env: opts.env || process.env, stdio: ["ignore", "pipe", "pipe"], detached, ...extra });
     } catch (e) {
       resolveRun({ code: null, signal: null, ...parts, timedOut, error: e.code || String(e.message) });
       return;
     }
     LIVE.add(child);
-    const timer = opts.timeoutMs ? setTimeout(() => { timedOut = true; child.kill("SIGKILL"); }, opts.timeoutMs) : null;
+    const timer = opts.timeoutMs ? setTimeout(() => { timedOut = true; killTree(child); }, opts.timeoutMs) : null;
+    // After a time-out, a process that left the tree may still hold the pipes: they are closed a second after the exit,
+    // so the run ends instead of waiting for it.
+    child.on("exit", () => {
+      if (timedOut) setTimeout(() => { child.stdout.destroy(); child.stderr.destroy(); }, 1000).unref();
+    });
     child.stdout.on("data", add("stdout"));
     child.stderr.on("data", add("stderr"));
     let error = null;
@@ -80,12 +101,15 @@ export function runProc(cmd, args = [], opts = {}) {
   });
 }
 
-// Stops every child still running (used by the SIGINT and SIGTERM handlers).
+// Stops every child still running (used by the SIGINT and SIGTERM handlers, and when this process exits). On POSIX a
+// child leads its own process group, so it no longer gets the terminal's signals: an entry point that uses runProc
+// keeps signal handlers that call killAll (testbox.mjs does).
 export function killAll() {
-  for (const child of LIVE) {
-    try { child.kill("SIGKILL"); } catch { /* already gone */ }
-  }
+  for (const child of LIVE) killTree(child);
   LIVE.clear();
 }
 
 export const firstLine = (s) => String(s || "").split(/\r?\n/).map((l) => l.trim()).find(Boolean) || "";
+
+// A child group left when this process ends some other way (an uncaught error) is ended too.
+process.on("exit", killAll);

package/skills/build-testbox/scripts/testbox.mjs

@@ -2,7 +2,7 @@
 // build-testbox: a test bed each PC builds for itself. Browser matrix (Playwright Chromium and WebKit, desktop and
 // mobile emulation) and container OS (Rocky Linux; macOS only as a Tart VM on Apple Silicon) run in parallel.
 // run downloads nothing; setup downloads only after --yes. Pure Node 18+, no dependency.
-import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { UsageError, parseArgs } from "./args.mjs";
@@ -144,5 +144,13 @@ export async function main(argv) {
   }
 }
 
-const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+// Run directly, also through a linked path or another spelling: both sides as real paths.
+const realOr = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+};
+const isMain = process.argv[1] && realOr(process.argv[1]) === realOr(fileURLToPath(import.meta.url));
 if (isMain) main(process.argv.slice(2)).then((code) => { process.exitCode = code; });

package/skills/git-init/scripts/git-init.mjs

@@ -24,13 +24,17 @@
  * repository, a .git below the root, no commit identity). No network is used.
  */
 import { spawnSync } from "node:child_process";
-import { lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, parse, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { HASH, commitBlock, findBlock, markers, planBlock } from "./marker-block.mjs";
 import { scan } from "./payload-scan.mjs";
 
+// 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 USAGE = [
   "git-init: 민감 정보를 빼는 .gitignore 를 쓰고 비밀값을 스캔한 뒤 git init, git add ., git commit -m \"init\" 으로 첫 커밋을 만듦(check 는 계획만)",
   "사용법: node git-init.mjs [check|run] [--root <dir>] [--branch <이름>] [--local-identity \"<이름> <<메일>>\"] [--nested]",
@@ -120,9 +124,29 @@ function gitEnv(extra) {
   return env;
 }
 
-// Runs git; never throws. ok is false when git could not start or exited non-zero.
+// On Windows git is a wrapper (cmd\git.exe) that starts the real git: a time limit on the wrapper alone leaves the real
+// git running, which can still make the commit after the failure was reported. With a time limit, git runs under this
+// small Node supervisor instead, which ends the whole tree with System32's taskkill /T /F and exits 124.
+const TREE_SUPERVISOR = [
+  "const {spawn,spawnSync}=require('child_process');const p=require('path');",
+  "const [ms,...a]=process.argv.slice(1);",
+  "const c=spawn('git',a,{stdio:'inherit',windowsHide:true});",
+  "const t=setTimeout(()=>{spawnSync(p.win32.join(process.env.SystemRoot||'C:\\\\Windows','System32','taskkill.exe'),['/T','/F','/PID',String(c.pid)],{stdio:'ignore',windowsHide:true});process.exit(124)},Number(ms));",
+  "c.on('error',()=>process.exit(127));c.on('exit',(code)=>{clearTimeout(t);process.exit(code==null?1:code)});",
+].join("");
+
+// Runs git on the folder cwd (git -C), started from the home folder: Windows looks for a program in the working folder
+// first, so a git.exe inside the folder being initialized never runs. Never throws. ok is false when git could not
+// start or exited non-zero; a time-out is error.code ETIMEDOUT.
 function git(args, cwd, { env, timeout } = {}) {
-  const r = spawnSync("git", args, { cwd, encoding: "utf8", env: gitEnv(env), timeout, killSignal: "SIGKILL", maxBuffer: 256 * 1024 * 1024, windowsHide: true });
+  const opts = { cwd: runDir(), encoding: "utf8", env: gitEnv(env), killSignal: "SIGKILL", maxBuffer: 256 * 1024 * 1024, windowsHide: true };
+  const argv = ["-C", cwd, ...args];
+  if (timeout && process.platform === "win32") {
+    const r = spawnSync(process.execPath, ["-e", TREE_SUPERVISOR, String(timeout), ...argv], { ...opts, timeout: timeout + 30000 });
+    const error = r.status === 124 ? Object.assign(new Error("git timed out"), { code: "ETIMEDOUT" }) : r.error;
+    return { ok: !error && r.status === 0, out: r.stdout ?? "", err: (r.stderr ?? "").trim(), error };
+  }
+  const r = spawnSync("git", argv, { ...opts, timeout });
   return { ok: !r.error && r.status === 0, out: r.stdout ?? "", err: (r.stderr ?? "").trim(), error: r.error };
 }
 
@@ -136,12 +160,35 @@ const real = (p) => {
   }
 };
 
+// Whether a and b are one folder: device and inode (bigint, as NTFS file ids pass 2^53), or where the file system has
+// no inode numbers, the path as the file system spells it (realpathSync.native gives one spelling for names that differ
+// only in case, an 8.3 short name or a linked parent), case folded on Windows and macOS. A string compare of the JS
+// realpath let `--root c:\users\me` (or /users/me on macOS) pass the HOME refusal.
+function sameDir(a, b) {
+  try {
+    const x = statSync(a, { bigint: true });
+    const y = statSync(b, { bigint: true });
+    if (x.ino !== 0n && y.ino !== 0n) return x.dev === y.dev && x.ino === y.ino;
+  } catch {
+    // one is gone: the spellings below decide
+  }
+  const spell = (p) => {
+    try {
+      return realpathSync.native(p);
+    } catch {
+      return real(p);
+    }
+  };
+  const fold = (p) => (process.platform === "win32" || process.platform === "darwin" ? p.toLowerCase() : p);
+  return fold(spell(a)) === fold(spell(b));
+}
+
 // The root folder, or a failure: missing (2), HOME or a file system root (3).
 function checkRoot(rootArg) {
   const root = resolve(rootArg);
   if (!statSync(root, { throwIfNoEntry: false })?.isDirectory()) return fail(2, `루트 폴더가 없음: ${root}`);
   const r = real(root);
-  if (r === real(homedir())) return fail(3, `루트가 HOME 이라 거부: ${root}. 프로젝트 폴더에서 실행하거나 --root 로 지정`);
+  if (sameDir(root, homedir())) return fail(3, `루트가 HOME 이라 거부: ${root}. 프로젝트 폴더에서 실행하거나 --root 로 지정`);
   if (parse(r).root === r) return fail(3, `루트가 파일 시스템 루트라 거부: ${root}`);
   return { root };
 }
@@ -212,7 +259,7 @@ export function missingPatterns(text) {
 function gitignorePlan(root, follow) {
   const path = join(root, ".gitignore");
   const opts = { comment: HASH, id: ID, skill: SKILL, followSymlink: follow };
-  const probe = planBlock(path, { ...opts, body: null });
+  const probe = planBlock(path, { ...opts, body: null, readOnly: true }); // read only: never written
   if (!probe.ok) return { refuse: probe };
   const missing = missingPatterns(probe.before === null ? "" : probe.before.toString("utf8"));
   const plan = planBlock(path, { ...opts, body: missing.length > 0 ? [BLOCK_HEAD, ...missing].join("\n") : null });
@@ -325,6 +372,7 @@ function commitInit(root) {
 
 function runSteps(o, ctx) {
   const done = commitBlock(ctx.gi.plan, SKILL);
+  if (!done.ok) return fail(1, `.gitignore 거부: ${done.message}. git init 하지 않음`, { ...ctx.report, ok: false });
   const report = { ...ctx.report, gitignore: { ...ctx.report.gitignore, status: done.changed ? (done.created ? "created" : "updated") : "unchanged", backup: done.backup ?? null } };
   const list = listCandidates(ctx.tmp, ctx.root, []);
   const nested = list.filter((p) => p.endsWith("/"));

package/skills/git-init/scripts/marker-block.mjs

@@ -20,7 +20,7 @@
  *   file. Windows has no owner or permission bits to check.
  * - Writes go to a temp file in the same folder and a rename. A failed write removes the temp file.
  * - When the bytes change, the first original is kept in `<file>.<skill>.bak`; an existing backup is never
- *   overwritten.
+ *   overwritten. Something else at that name (a link, a folder) refuses the change (backup), so no original is lost.
  *
  * Results are { ok, changed, refused?, message, path, file }. Callers map refused to exit status 1.
  */
@@ -67,6 +67,13 @@ const readlinkOr = (path) => {
     return "?";
   }
 };
+const nativeReal = (path) => {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return resolve(path);
+  }
+};
 const realOrNull = (path) => {
   try {
     return realpathSync(path);
@@ -96,7 +103,8 @@ function fileProblem(st, file, uid) {
   return null;
 }
 
-// The file's stat and bytes, opened without blocking so a FIFO planted after the look never waits.
+// The file's stat and bytes, opened without blocking so a FIFO planted after the look never waits. id: the same
+// file's bigint stat for telling files apart (an NTFS file id passes 2^53, so as a Number two files can share one).
 function readChecked(file, uid) {
   const first = statSync(file);
   const problem = fileProblem(first, file, uid);
@@ -105,7 +113,7 @@ function readChecked(file, uid) {
   try {
     const st = fstatSync(fd);
     const late = fileProblem(st, file, uid);
-    return late ? { refuse: late } : { st, bytes: readFileSync(fd) };
+    return late ? { refuse: late } : { st, id: fstatSync(fd, { bigint: true }), bytes: readFileSync(fd) };
   } finally {
     closeSync(fd);
   }
@@ -212,9 +220,25 @@ const options = (opts) => ({
   wrap: opts.wrap ?? null,
   skill: opts.skill,
   follow: opts.followSymlink === true,
+  readOnly: opts.readOnly === true, // a plan only read (never committed): no backup spot to check
   uid: "uid" in opts ? opts.uid : process.getuid?.(),
 });
 
+// A file not there yet is named by its folder as the file system spells it (one key for a linked parent, an 8.3 name
+// or the folder in another case) and its own name as given. Two names differing only in case still get two keys:
+// where the file system takes them for one file, applyBlocks meets that when the second create finds the first.
+const newFileKey = (file) => `path:${join(nativeReal(dirname(resolve(file))), basename(file))}`;
+
+// The key of a file that is there now, as planBlock gives it, or null when it cannot be read.
+function keyNow(file) {
+  try {
+    const id = statSync(file, { bigint: true });
+    return id.ino === 0n ? `path:${nativeReal(file)}` : `ino:${id.dev}:${id.ino}`;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Works out what applyBlock would write, without writing: { ok, changed, refused?, message, path, file, key,
  * before, after, mode }. key names the file (device and inode, or the path of a file not there yet).
@@ -226,14 +250,20 @@ export function planBlock(path, opts) {
   if (at.refuse) return at.refuse;
   if (!at.exists) {
     const after = o.body === null ? null : Buffer.from(blockText(o.mk, o.body, o.wrap, "\n"), "utf8");
-    return { ok: true, changed: after !== null, path, file: at.file, key: `path:${resolve(at.file)}`, before: null, after, mode: NEW_FILE_MODE };
+    return { ok: true, changed: after !== null, path, file: at.file, key: newFileKey(at.file), before: null, after, mode: NEW_FILE_MODE };
   }
   const read = readChecked(at.file, o.uid);
   if (read.refuse) return read.refuse;
   const next = nextBytes(read.bytes, o, at.file);
   if (next.refuse) return next.refuse;
   const changed = !next.bytes.equals(read.bytes);
-  const key = `ino:${read.st.dev}:${read.st.ino}`;
+  // A change keeps the first original in <file>.<skill>.bak: something else there (a link, a folder) is refused now,
+  // in the plan, so a dry run, a status and a check say so before anything is written.
+  const bakWhy = changed && !o.readOnly ? backupSpotWhy(`${at.file}.${o.skill}.bak`) : null;
+  if (bakWhy) return refusal("backup", `${bakWhy}: ${at.file}.${o.skill}.bak`, path);
+  // ino 0 (a file system without file ids) tells nothing apart: then the path as the file system spells it is the
+  // key (realpathSync.native gives one spelling for names that differ only in case where case is ignored).
+  const key = read.id.ino === 0n ? `path:${nativeReal(at.file)}` : `ino:${read.id.dev}:${read.id.ino}`;
   return { ok: true, changed, path, file: at.file, key, before: read.bytes, after: next.bytes, mode: read.st.mode & 0o7777 };
 }
 
@@ -254,36 +284,111 @@ function writeAtomic(file, data, mode) {
   }
 }
 
-// Keeps the first original: writes <file>.<skill>.bak only when nothing is at that name yet.
-function backup(file, skill, bytes) {
-  const bak = `${file}.${skill}.bak`;
-  if (lstatSync(bak, { throwIfNoEntry: false })) return null;
-  const fd = openSync(bak, "wx", BACKUP_MODE);
+// Opens a file not there yet, as "wx" does, and makes sure the name is the file made. Anything at the name, a link to
+// nothing among them, is EEXIST: Windows opens "wx" through a link to nothing and makes the file it leads to (macOS
+// and Linux answer EEXIST), so the name is looked at first, and a link planted between that look and the open is
+// caught after it by comparing the opened file with the name; the empty file made through it is taken back.
+function openFresh(path, mode) {
+  if (lstatSync(path, { throwIfNoEntry: false })) throw eexist(path);
+  const fd = openSync(path, "wx", mode);
+  let made;
+  let st;
+  try {
+    made = fstatSync(fd, { bigint: true });
+    st = lstatSync(path, { bigint: true, throwIfNoEntry: false });
+  } catch {
+    return fd; // cannot look (ESTALE, EPERM): the file is the caller's, as a plain "wx" leaves it
+  }
+  if (st && !st.isSymbolicLink() && (made.ino === 0n || (st.dev === made.dev && st.ino === made.ino))) return fd;
+  closeSync(fd);
+  if (st?.isSymbolicLink()) takeBack(path, made);
+  throw eexist(path);
+}
+
+const eexist = (path) => Object.assign(new Error(`EEXIST: file already exists, open '${path}'`), { code: "EEXIST", path });
+
+// Removes the file an open made through the link at path, while it is still that empty file.
+function takeBack(path, made) {
+  try {
+    const target = realpathSync(path);
+    const st = statSync(target, { bigint: true });
+    if (st.dev === made.dev && st.ino === made.ino && st.size === 0n) rmSync(target, { force: true });
+  } catch {
+    // the link changed again: nothing of ours to find
+  }
+}
+
+// Writes bytes to a file not there yet (openFresh) and closes it. A write that fails takes the empty file away again
+// while the name is still that file, so no empty file stands for a first original later.
+function writeFresh(path, bytes, mode) {
+  const fd = openFresh(path, mode);
   try {
     writeFileSync(fd, bytes);
+  } catch (e) {
+    try {
+      const made = fstatSync(fd, { bigint: true });
+      const st = lstatSync(path, { bigint: true, throwIfNoEntry: false });
+      if (st && st.isFile() && st.dev === made.dev && st.ino === made.ino) rmSync(path, { force: true });
+    } catch {
+      // cannot tell the name is still that file: it stays, and the write's own error is what is reported
+    }
+    throw e;
   } finally {
     closeSync(fd);
   }
-  return bak;
 }
 
-/** Writes what planBlock worked out. A plan that changes nothing or was refused is returned as a result. */
+// Why the backup spot cannot take the first original, or null: something that is not a regular file there, or a look
+// that fails (EPERM on Windows for a .bak being deleted, and the like).
+function backupSpotWhy(bak) {
+  try {
+    const st = lstatSync(bak, { throwIfNoEntry: false });
+    return st && !st.isFile() ? "백업 자리에 일반 파일이 아닌 것이 있어 그대로 둠" : null;
+  } catch (e) {
+    return `백업 자리를 확인하지 못해 그대로 둠(${e.code || e.message})`;
+  }
+}
+
+// Keeps the first original: writes <file>.<skill>.bak only when nothing is at that name yet. { bak } (null when a
+// regular file there is the first original already), or { refuse } when something else is there (a link, a folder):
+// then the file is not changed, as its original would have nowhere to go.
+function backup(file, skill, bytes) {
+  const bak = `${file}.${skill}.bak`;
+  const there = (st) => (st.isFile() ? { bak: null } : { refuse: refusal("backup", `백업 자리에 일반 파일이 아닌 것이 있어 그대로 둠: ${bak}`, file) });
+  const st = lstatSync(bak, { throwIfNoEntry: false });
+  if (st) return there(st);
+  try {
+    writeFresh(bak, bytes, BACKUP_MODE);
+  } catch (e) {
+    if (e?.code !== "EEXIST") throw e;
+    const now = lstatSync(bak, { throwIfNoEntry: false }); // made since the look
+    return now ? there(now) : { refuse: refusal("backup", `백업을 만들지 못해 그대로 둠: ${bak}`, file) };
+  }
+  return { bak };
+}
+
+/**
+ * Writes what planBlock worked out. A plan that changes nothing or was refused is returned as a result. A file planned
+ * as new that is there by the write (made or linked since the plan) is not touched: the result is a refusal with
+ * raced: true, which applyBlocks answers by planning that file again.
+ */
 export function commitBlock(plan, skill) {
   if (!plan.ok) return plan;
   const result = { ok: true, changed: plan.changed, path: plan.path, file: plan.file };
   if (!plan.changed) return { ...result, message: `변경 없음: ${plan.path}` };
   if (plan.before === null && plan.after !== null) {
-    const fd = openSync(plan.file, "wx", plan.mode);
     try {
-      writeFileSync(fd, plan.after);
-    } finally {
-      closeSync(fd);
+      writeFresh(plan.file, plan.after, plan.mode);
+    } catch (e) {
+      if (e?.code !== "EEXIST") throw e;
+      return { ...refusal("raced", `계획한 뒤 그 이름에 파일이나 링크가 생겨 그대로 둠: ${plan.path}`, plan.path), raced: true };
     }
     return { ...result, created: true, message: `새로 만듦: ${plan.path}` };
   }
-  const bak = backup(plan.file, skill, plan.before);
+  const kept = backup(plan.file, skill, plan.before);
+  if (kept.refuse) return kept.refuse;
   writeAtomic(plan.file, plan.after, plan.mode);
-  return { ...result, backup: bak, message: `바꿈: ${plan.path}` };
+  return { ...result, backup: kept.bak, message: `바꿈: ${plan.path}` };
 }
 
 /** Puts in, replaces or (body null) takes out the block in one file. dryRun plans only. */
@@ -296,16 +401,33 @@ export function applyBlock(path, opts) {
 /**
  * Applies blocks to several files, each entry { path, ...opts }. Every file is planned first: one refusal and
  * none is written. Two entries naming one file (after links are followed) write it once, by the first entry.
+ * A file that changes between the plans and the writes (raced) is planned again; a refusal then comes back as
+ * { ok: false, partial: true }, the entries before it being written already.
  */
 export function applyBlocks(entries, { dryRun = false } = {}) {
   const plans = entries.map((e) => ({ entry: e, plan: planBlock(e.path, e) }));
   const refused = plans.filter((p) => !p.plan.ok).map((p) => p.plan);
   if (refused.length > 0) return { ok: false, refused, results: plans.map((p) => p.plan) };
   const seen = new Map();
-  const results = plans.map(({ entry, plan }) => {
-    if (seen.has(plan.key)) return { ok: true, changed: false, path: plan.path, file: plan.file, sameAs: seen.get(plan.key), message: `같은 파일이라 한 번만 씀: ${plan.path}` };
+  const once = (plan) => ({ ok: true, changed: false, path: plan.path, file: plan.file, sameAs: seen.get(plan.key), message: `같은 파일이라 한 번만 씀: ${plan.path}` });
+  const write = (entry, plan) => {
+    const done = dryRun ? plan : commitBlock(plan, entry.skill);
+    if (!done.ok) return done;
     seen.set(plan.key, plan.path);
-    return dryRun ? plan : commitBlock(plan, entry.skill);
+    const now = done.created ? keyNow(plan.file) : null; // a file made now is that file to later spellings too
+    if (now && !seen.has(now)) seen.set(now, plan.path);
+    return done;
+  };
+  const results = plans.map(({ entry, plan }) => {
+    if (seen.has(plan.key)) return once(plan);
+    const done = write(entry, plan);
+    if (!done.raced) return done;
+    // Made since the plan: by an earlier entry under another spelling (a case-insensitive file system), or by another
+    // program. Plan it again as what is there now.
+    const again = planBlock(entry.path, entry);
+    if (!again.ok) return again;
+    return seen.has(again.key) ? once(again) : write(entry, again);
   });
-  return { ok: true, refused: [], results };
+  const late = results.filter((r) => r.ok === false);
+  return late.length > 0 ? { ok: false, partial: true, refused: late, results } : { ok: true, refused: [], results };
 }

package/skills/init-dir/SKILL.md

@@ -111,7 +111,7 @@ argument-hint: "[apply|status] [--only=<폴더,...>] [--follow-symlink] [--dry-r
 | 로테이션 | 쓰기 전에 "현재 크기 + 쓸 양 > 100MB(104857600 바이트)" 면 돌림. `.log` 가 `.1.log` 로 밀리고 `.6.log` 는 지움. 현재 파일 포함 7개, 스트림당 최대 700MB |
 | stop | 감독에 SIGTERM. 감독이 자식의 프로세스 그룹에 넘기고 10초 뒤 SIGKILL. 감독이 없으면 자식에 직접. Windows 는 `taskkill /T`, 10초 뒤 `/F` |
 | status | 감독과 자식의 실행 여부를 따로, 로그 파일 수와 크기 |
-| 시작 잠금 | `start` 는 `logs/<이름>.start.lock` 을 O_EXCL 로 만들어 잡고 끝나면 지움. 동시에 여러 번 실행해도 감독은 하나, 나중 실행은 기다린 뒤 `이미 실행 중`. 죽은 PID, 다른 프로그램, 30초 넘은 잠금은 넘겨받음. 링크나 폴더 자리는 거부 |
+| 시작 잠금 | `start` 는 `logs/<이름>.start.lock` 을 O_EXCL 로 만들어 잡고 끝나면 지움. 동시에 여러 번 실행해도 감독은 하나, 나중 실행은 기다린 뒤 `이미 실행 중`. 죽은 PID, 다른 프로그램, 30초 넘은 잠금은 `.start.lock.break` 를 잡은 `start` 하나만 다시 읽어 확인한 뒤 지움(동시 정리에도 감독은 하나). 링크나 폴더 자리는 거부 |
 | 종료 코드 | 0 성공(status 는 둘 다 실행 중), 1 실패(시작 2초 안에 멈춤, 멈추지 못함, status 에서 실행 중 아님), 2 설정 없음(`command` 비어 있음), 3 Node 18 이상 없음(래퍼) |
 
 - 대상 프로젝트에 Node 18 이상이 필요하다. 다른 Node 는 환경 변수 `NODE` 에 경로

package/skills/init-dir/scripts/init-dir.mjs

@@ -93,12 +93,35 @@ const real = (p) => {
   }
 };
 
+// Whether a and b are one folder: device and inode (bigint, as NTFS file ids pass 2^53), or where the file system has
+// no inode numbers, the path as the file system spells it (realpathSync.native gives one spelling for names that differ
+// only in case, an 8.3 short name or a linked parent), case folded on Windows and macOS. A string compare of the JS
+// realpath let `--root c:\users\me` (or /users/me on macOS) pass the HOME refusal.
+function sameDir(a, b) {
+  try {
+    const x = statSync(a, { bigint: true });
+    const y = statSync(b, { bigint: true });
+    if (x.ino !== 0n && y.ino !== 0n) return x.dev === y.dev && x.ino === y.ino;
+  } catch {
+    // one is gone: the spellings below decide
+  }
+  const spell = (p) => {
+    try {
+      return realpathSync.native(p);
+    } catch {
+      return real(p);
+    }
+  };
+  const fold = (p) => (process.platform === "win32" || process.platform === "darwin" ? p.toLowerCase() : p);
+  return fold(spell(a)) === fold(spell(b));
+}
+
 // The root folder, or a failure: missing (2), HOME or a file system root (3).
 function checkRoot(rootArg) {
   const root = resolve(rootArg);
   if (!statSync(root, { throwIfNoEntry: false })?.isDirectory()) return fail(2, `루트 폴더가 없음: ${root}`);
   const r = real(root);
-  if (r === real(homedir())) return fail(3, `루트가 HOME 이라 거부: ${root}. 프로젝트 폴더에서 실행하거나 --root 로 지정`);
+  if (sameDir(root, homedir())) return fail(3, `루트가 HOME 이라 거부: ${root}. 프로젝트 폴더에서 실행하거나 --root 로 지정`);
   if (parse(r).root === r) return fail(3, `루트가 파일 시스템 루트라 거부: ${root}`);
   return { root };
 }
@@ -165,6 +188,7 @@ const blockEntries = (root, files, present, follow) =>
   }));
 
 function instructionStatus(r) {
+  if (r.ok === false) return `refused:${r.refused}`;
   if (r.sameAs) return "same-file";
   if (!r.changed) return "unchanged";
   return r.created || r.before === null ? "created" : "updated";
@@ -227,7 +251,10 @@ function apply(o) {
   if (p.error) return p;
   const folders = o.dryRun ? plannedFolders(p.folders) : makeFolders(p.root, p.folders);
   const done = o.dryRun ? p.plan : applyBlocks(p.entries);
-  if (!done.ok) return fail(1, `지시 파일 거부: ${done.refused.map((r) => r.message).join("; ")}. 폴더는 만들었음`);
+  if (!done.ok) {
+    const wrote = done.partial ? done.results.filter((r) => r.ok && r.changed).map((r) => r.path) : [];
+    return fail(1, `지시 파일 거부: ${done.refused.map((r) => r.message).join("; ")}. 폴더는 만들었음${wrote.length ? `. 이미 쓴 파일: ${wrote.join(", ")}` : ""}`);
+  }
   const instructions = done.results.map((r, i) => ({ file: p.entries[i].name, status: instructionStatus(r) }));
   const warnings = [...p.warnings, ...leftoverWarnings(p.root)];
   return { code: 0, report: { ok: true, command: "apply", root: p.root, runtime: o.runtime, dryRun: o.dryRun, folders, instructions, warnings, present: p.present } };