@kaydash9999/banker-plugins 0.24.1 → 0.25.0

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);

package/skills/tune-tmux/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.
  */
@@ -220,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).
@@ -234,13 +250,17 @@ 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);
+  // 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}`;
@@ -264,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. */
@@ -306,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/tune-tmux/scripts/tmux-config.mjs

@@ -6,9 +6,9 @@
  * Every function that runs a program takes `exec(cmd, args)` returning { status, stdout, stderr, error }, so the
  * tests can stand in for tmux on every OS. No network is used.
  */
-import { accessSync, constants, lstatSync, readFileSync, rmSync, statSync } from "node:fs";
+import { accessSync, constants, lstatSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
 import { devNull, homedir } from "node:os";
-import { basename, delimiter, join, resolve } from "node:path";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
 
 /** The tool and version in `tmux -V` output. psmux says "tmux 3.3.8" on line 1 and "psmux" on line 2. */
 export function parseVersion(text) {
@@ -76,13 +76,45 @@ export function pickClipboard({ platform, env, has }) {
 
 const exists = (p) => lstatSync(p, { throwIfNoEntry: false }) !== undefined;
 
+// The path as the file system spells it (native first: the long name and the case on disk), a missing tail joined to
+// its nearest existing folder so spelled.
+function spelled(p) {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    try {
+      return realpathSync(p);
+    } catch {
+      const up = dirname(p);
+      return up === p ? p : join(spelled(up), basename(p));
+    }
+  }
+}
+
+/**
+ * Whether a and b name one file: device and inode (bigint) when both are there, else the spelled paths, case folded on
+ * Windows and macOS. A string compare took a --conf in another case, through a linked XDG_CONFIG_HOME or an 8.3 name
+ * for another file and warned wrongly.
+ */
+export function sameFile(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 not there (yet): the spellings decide
+  }
+  const fold = (p) => (process.platform === "win32" || process.platform === "darwin" ? p.toLowerCase() : p);
+  return fold(spelled(resolve(a))) === fold(spelled(resolve(b)));
+}
+
 /** The config files tmux reads by itself, in order. Measured: 3.6a reads every one there; 2.7 only ~/.tmux.conf. */
 export function tmuxReads(v, env, home) {
   const files = [join(home, ".tmux.conf")];
   if (v && !atLeast(v, 3, 1)) return files;
   if (env.XDG_CONFIG_HOME) files.push(join(env.XDG_CONFIG_HOME, "tmux", "tmux.conf"));
   files.push(join(home, ".config", "tmux", "tmux.conf"));
-  return [...new Set(files.map((f) => resolve(f)))];
+  return files.map((f) => resolve(f)).filter((f, i, all) => !all.slice(0, i).some((g) => sameFile(g, f)));
 }
 
 /** The tmux file for the block: --conf, else the first of tmuxReads that is there, else ~/.tmux.conf. */

package/skills/tune-tmux/scripts/tune-tmux.mjs

@@ -19,15 +19,19 @@
  * Exit status: 0 done (nothing to change included), 1 refused, write or reload failed, 2 usage error,
  * 3 environment (on or off with neither tmux nor psmux). No network is used.
  */
-import { mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { HASH, commitBlock, markers, planBlock } from "./marker-block.mjs";
 import * as tc from "./tmux-config.mjs";
 import { appRows } from "./app-notes.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 = [
   "tune-tmux: tmux, psmux 설정에 표지 블록을 넣고 빼서 마우스 드래그 복사와 PageUp/PageDown 스크롤을 맞춤",
   "사용법: node tune-tmux.mjs [status|on|off] [--target auto|tmux|psmux] [--conf <경로>] [--follow-symlink] [--force-drag] [--reload] [--socket <이름>] [--dry-run] [--json]",
@@ -68,7 +72,8 @@ const loadCaps = () => JSON.parse(readFileSync(new URL("./psmux-caps.json", impo
 
 function defaults(deps) {
   const env = deps.env ?? process.env;
-  const exec = (cmd, args) => spawnSync(cmd, args, { encoding: "utf8", env, timeout: 15000, windowsHide: true });
+  // from the home folder: Windows looks for tmux or psmux in the working folder first
+  const exec = (cmd, args) => spawnSync(cmd, args, { cwd: runDir(), encoding: "utf8", env, timeout: 15000, windowsHide: true });
   return { env, platform: process.platform, exec, caps: null, ...deps };
 }
 
@@ -109,8 +114,8 @@ function context(o, d) {
   }
   const conf = tc.chooseTmuxConf(t.tool, d.env, home, o.conf);
   const reads = tc.tmuxReads(t.tool, d.env, home);
-  if (o.conf && !reads.includes(conf)) ctx.warnings.push(`경고: tmux 가 스스로 읽지 않는 파일: ${conf}. tmux -f 나 source-file 로 불러야 적용됨`);
-  ctx.warnings.push(...tc.conflictsIn(reads.filter((f) => f !== conf)));
+  if (o.conf && !reads.some((f) => tc.sameFile(f, conf))) ctx.warnings.push(`경고: tmux 가 스스로 읽지 않는 파일: ${conf}. tmux -f 나 source-file 로 불러야 적용됨`);
+  ctx.warnings.push(...tc.conflictsIn(reads.filter((f) => !tc.sameFile(f, conf))));
   const body = t.tool ? tmuxWanted(t.tool, o, d) : { lines: [], omitted: [], clipboard: null };
   return { ...ctx, conf, ...body };
 }
@@ -155,7 +160,9 @@ function change(ctx, o, d) {
   const plan = planOf(ctx, o.cmd === "off" || none ? null : ctx.lines.join("\n"), o);
   if (!plan.ok) return fail(1, `${plan.message}. 아무것도 바꾸지 않음`);
   if (none && !plan.changed) return { code: 0, report: { ...reportOf(ctx, o.cmd, o), changed: false, ...noLines(ctx) } };
-  return reloaded(ctx, plan, o, d, none ? removedOld(written(ctx, o, plan), ctx) : written(ctx, o, plan));
+  const done = o.dryRun ? plan : commitBlock(plan, SKILL);
+  if (!done.ok) return fail(1, `${done.message}. 아무것도 바꾸지 않음`);
+  return reloaded(ctx, plan, o, d, none ? removedOld(written(ctx, o, plan, done), ctx) : written(ctx, o, plan, done));
 }
 
 // The written report, applied to a running server when --reload asks (not on a dry run).
@@ -166,9 +173,8 @@ function reloaded(ctx, plan, o, d, out) {
   return { code: 0, report: { ...out, reload } };
 }
 
-// Writes the plan unless dry-run and says what happened.
-function written(ctx, o, plan) {
-  const done = o.dryRun ? plan : commitBlock(plan, SKILL);
+// What the write (or the dry-run plan) did, as the report says it.
+function written(ctx, o, plan, done) {
   const empty = (o.cmd === "off" || ctx.lines.length === 0) && plan.changed && plan.after?.length === 0;
   const note = empty ? "블록만 있던 파일이라 빈 파일로 남김" : null;
   return { ...reportOf(ctx, o.cmd, o), changed: plan.changed, created: done.created === true, backup: done.backup ?? null, note };

package/skills/ultra-chain/references/chain-ledger.mjs

@@ -18,8 +18,13 @@ import { spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { homedir, tmpdir } from "node:os";
 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 startDir = () => (existsSync(homedir()) ? homedir() : tmpdir());
+
 export const STAGES = [
   { id: "preflight", label: "사전 점검" },
   { id: "research", label: "자료 조사" },
@@ -219,8 +224,10 @@ function checkQuorum(event, meta) {
 
 // ── run folder ───────────────────────────────────────────────────────────────
 
+// 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) {
-  const r = spawnSync("git", args, { cwd, encoding: "utf8" });
+  const r = spawnSync("git", ["-C", resolve(cwd), ...args], { cwd: startDir(), encoding: "utf8" });
   return r.status === 0 ? r.stdout.trim() : null;
 }
 

package/skills/vertical-pptx/verify_a4p.mjs

@@ -41,6 +41,7 @@
  * Usage: node verify_a4p.mjs <file.pptx> [--json] [--strict] [--font-file <path>] [--deck <deck.json>]
  */
 import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import os from 'node:os';
@@ -2101,10 +2102,16 @@ export function main(argv) {
         console.error(`verify_a4p: 재압축 산출물이 자기 무결성 검사를 통과하지 못해 쓰지 않았다:\n  ${integrity.problems.join('\n  ')}`);
         return EXIT.FAIL;
       }
-      // Stage then rename, so an interrupted --in-place cannot leave a half-written deck.
-      const tmp = `${target}.a4p-tmp`;
-      fs.writeFileSync(tmp, rep.out);
-      fs.renameSync(tmp, target);
+      // Stage then rename, so an interrupted --in-place cannot leave a half-written deck. The stage name is random
+      // and made exclusively, so a link someone left at a fixed name is never written through.
+      const tmp = `${target}.${randomBytes(6).toString('hex')}.a4p-tmp`;
+      try {
+        fs.writeFileSync(tmp, rep.out, { flag: 'wx' });
+        fs.renameSync(tmp, target);
+      } catch (e) {
+        fs.rmSync(tmp, { force: true });
+        throw e;
+      }
 
       report.write = {
         mode: opts.convert ? 'convert-a4p' : 'repair',