@kaydash9999/banker-plugins 0.20.2 → 0.20.5

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

@@ -19,13 +19,16 @@
  * column when Node reports one but never quoting it; one holding only white
  * space is read as {}, as Claude Code does; UTF-8 BOM accepted; CLAUDE_CONFIG_DIR trimmed, "~" expanded
  * and made absolute; formatter and HUD config backed up when they differ (the
- * blocks payload-mon and claude-update-last add do not count), settings.json only
+ * blocks payload-mon and claude-update-last add do not count unless edited by hand), settings.json only
  * when it changes; pre-releases sort below their release; no
  * folder is made when OMC is missing. Also refused before any change: a config
  * folder path the statusLine shell would act on, a file or folder it cannot
  * write, an OMC folder without both loader files, a relative OMC_PLUGIN_ROOT.
  * Backups keep the original bytes and mode; the files it writes are 0644 and new
- * folders 0755; the other statusLine fields (padding, ...) stay.
+ * folders 0755; the other statusLine fields (padding, ...) stay. settings.json goes
+ * in as a new file through a rename (a link keeps pointing at it), in place where
+ * that cannot be done or would part a hard link or change its owner or group, and
+ * is left as it was when the disk is too full for the new file.
  * At the end it runs the installed formatter once with no input and reports
  * whether OMC's HUD loads and which version draws (the render check); that never
  * changes the exit code. APPLY_HUD_CHECK_TIMEOUT_MS (tests) shortens its 25s limit.
@@ -38,9 +41,13 @@ import {
   constants,
   copyFileSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   readdirSync,
   readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
@@ -70,6 +77,27 @@ const configDst = join(OMC_DIR, "hud-config.json");
 // PowerShell on Windows) that treats backslashes as escapes.
 const cmdPath = wrapperDst.split(sep).join("/");
 const log = (m) => process.stdout.write(m + "\n");
+// Characters that could act on a terminal or pass for a line of their own are shown as "?", as
+// omc-patch.mjs (UNSAFE_CH) shows file values in output an agent reads.
+const UNSAFE = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Co}\p{Cn}\p{Variation_Selector}\p{Default_Ignorable_Code_Point}\u{2800}\u{a0}\u{1680}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]/gu;
+const shown = (s) => String(s).replace(UNSAFE, "?");
+// The old statusLine command as the report shows it: its first word (the program; a NAME=value it sets is skipped) and
+// its length. settings.json can hold tokens (see step 0) and the line goes into a report; masking the parts that look
+// like secrets missed every form no rule named (curl -u, sshpass -p, mysql -pPW), so the rest stays in the backup.
+const ASSIGN = /^[A-Za-z_][A-Za-z0-9_]*=/;
+// Shell words: runs of plain characters, quoted pieces and backslash escapes (a quote or a space after a backslash
+// stays in its word, inside double quotes too), a quote left open running to the end, so a value in quotes stays one
+// word with its name.
+const WORDS = /(?:"(?:[^"\\]|\\.)*"?|'[^']*'?|\\[\s\S]?|[^\s"'\\])+/g;
+function priorShown(command) {
+  const text = String(command).trim();
+  const words = text.match(WORDS) || [];
+  const first = words.findIndex((w) => !ASSIGN.test(w));
+  // a first word that looks like a setting or an address may hold a secret itself
+  const name = first === -1 ? "(no program)" : /[=@]|:\/\//.test(words[first]) ? "(program hidden)" : words[first];
+  const head = `${name}${first !== -1 && first < words.length - 1 ? " …" : ""}`;
+  return `${JSON.stringify(shown(head))} (${text.length} characters)`;
+}
 const stamp = new Date().toISOString().replace(/[:.]/g, "-");
 const refuse = (lines) => {
   for (const l of lines) log(l);
@@ -108,6 +136,30 @@ function readSettings(raw) {
   if (value && typeof value === "object" && !Array.isArray(value)) return { settings: value, empty: false };
   return { refusal: `[x] settings.json holds ${kindOf(value)}, not a JSON object; nothing changed. Fix it and re-run.` };
 }
+// A target that is there but no regular file (a folder, a FIFO, a device), or a folder the install writes into that
+// is there but no folder, is refused before anything is read or written: reading or writing a FIFO waits for good,
+// and the others stopped the install half-way. Links are followed, as the reads and writes follow them; a target
+// that is not there (a broken link too) is written new.
+function oddTarget() {
+  for (const p of [settingsPath, loaderDst, libDst, wrapperDst, configDst]) {
+    try {
+      if (!statSync(p).isFile()) return `${shown(p)} is not a regular file (a folder, a FIFO or a device)`;
+    } catch {
+      /* not there: written new */
+    }
+  }
+  for (const d of [CONFIG_DIR, HUD_DIR, join(HUD_DIR, "lib"), OMC_DIR]) {
+    try {
+      if (!statSync(d).isDirectory()) return `${shown(d)} is not a folder`;
+    } catch {
+      /* not there: made */
+    }
+  }
+  return "";
+}
+const odd = oddTarget();
+if (odd) refuse([`[x] ${odd}; nothing changed. Move it aside and re-run.`]);
+
 let settings = {};
 let settingsRaw = null;
 if (existsSync(settingsPath)) {
@@ -199,17 +251,82 @@ function writeOwned(file, data) {
 }
 
 // The marker blocks payload-mon and claude-update-last add to the installed formatter, matched as those
-// tools match them (payload-mon.mjs BLOCKS, claude-update-last.mjs's block pattern). Read as latin1,
-// which maps every byte to one character, so text outside the blocks compares byte for byte.
+// tools match them (payload-mon.mjs BLOCKS, claude-update-last.mjs BLOCKS). Read as latin1, which maps
+// every byte to one character, so text outside the blocks compares byte for byte.
 const TOOL_BLOCKS = [
   /^[ \t]*\/\/ >>> payload-mon >>>[\s\S]*?\/\/ <<< payload-mon <<<[ \t]*\r?\n/gm,
   /^[ \t]*\/\/ >>> claude-update-last >>>(?:(?!\/\/ >>> claude-update-last >>>)[\s\S])*?\/\/ <<< claude-update-last <<<[ \t]*(?:\r?\n|(?![\s\S]))/gm,
 ];
-const withoutToolBlocks = (text) => TOOL_BLOCKS.reduce((t, blocks) => t.replace(blocks, ""), text);
+// payload-mon's closing line (payload-mon.mjs CLOSE_LINE). No block reaches past the last one, so its
+// pattern runs only on the text before it: otherwise every stray opening line scans to the end again
+// (a 2MB file of them took 28s).
+const PM_CLOSE = /\/\/ <<< payload-mon <<<[ \t]*\r?\n/g;
+// The text without the tools' blocks, and the blocks it held.
+function splitToolBlocks(text) {
+  const blocks = [];
+  const take = (t, pattern) =>
+    t.replace(pattern, (block) => {
+      blocks.push(block);
+      return "";
+    });
+  let end = -1;
+  for (const m of text.matchAll(PM_CLOSE)) end = m.index + m[0].length;
+  const rest = end < 0 ? text : take(text.slice(0, end), TOOL_BLOCKS[0]) + text.slice(end);
+  return { body: take(rest, TOOL_BLOCKS[1]), blocks };
+}
+// The blocks as the tools write them (payload-mon.mjs placeBlock, claude-update-last.mjs blockText), with
+// LF line endings and payload-mon's import of its module copy as "<module copy>" (where the copy sits is the
+// tool's to choose; a URL to any other file is an edit). A block that differs from both was edited by hand. When a tool's block changes, the test "payload-mon 블록만 다른 래퍼와 바뀌지 않은 settings.json 은
+// 다시 설치해도 백업하지 않음" fails until this copy follows.
+const TOOL_BLOCK_TEXTS = [
+  [
+    "  // >>> payload-mon >>>",
+    "  // payload-mon: estimated API request payload against the 32MB request limit, shown",
+    "  // like ctx from 8MB (25%) on. `payload-mon off` removes this block; a missing or",
+    "  // broken module costs only this segment, never the statusline.",
+    "  try {",
+    "    const transcript = JSON.parse(input)?.transcript_path;",
+    "    if (transcript) {",
+    "      const { estimatePayloadBytes, payloadSegment } = await <module copy>;",
+    "      const segment = payloadSegment(estimatePayloadBytes(transcript));",
+    "      if (segment) colored.push(colorRate(segment));",
+    "    }",
+    "  } catch {",
+    "    /* no stdin JSON, unreadable transcript or module error */",
+    "  }",
+    "  // <<< payload-mon <<<",
+    "",
+  ].join("\n"),
+  [
+    "  // >>> claude-update-last >>>",
+    "  // claude-update-last (setup-omc-hud): OMC's Claude Code update notice",
+    "  // (\"[Claude#X] -> Y claude update\") goes after every other segment.",
+    "  // `claude-update-last off` removes this block; on any error the order stays as it was.",
+    "  try {",
+    "    const notice = /^\\[Claude(?:#[^\\]]*)?\\]\\s*->\\s*\\S+\\s+claude\\s+update\\b/;",
+    "    const plain = (s) => stripAnsi(String(s)).trim();",
+    "    const found = segs.find((s) => notice.test(plain(s)));",
+    "    if (found) {",
+    "      const moved = A(\"2\", plain(found));",
+    "      for (let i = colored.length - 1; i >= 0; i--) if (notice.test(plain(colored[i]))) colored.splice(i, 1);",
+    "      colored.push(moved);",
+    "    }",
+    "  } catch {",
+    "    /* keep the order the wrapper chose */",
+    "  }",
+    "  // <<< claude-update-last <<<",
+    "",
+  ].join("\n"),
+];
+const toolMade = (block) =>
+  TOOL_BLOCK_TEXTS.includes(block.replace(/\r\n/g, "\n").replace(/await import\("file:\/\/[^"\\]*\/payload-mon\/payload-size\.mjs"\)/, "await <module copy>"));
 const sameBytes = (a, b) => a.equals(b);
-// Those blocks alone are no reason for a backup: `payload-mon on` puts its block back, and wrapper v4
-// needs no claude-update-last block.
-const sameFormatter = (a, b) => withoutToolBlocks(a.toString("latin1")) === withoutToolBlocks(b.toString("latin1"));
+// Blocks as the tools write them are no reason for a backup: `payload-mon on` puts its block back, and
+// wrapper v4 needs no claude-update-last block. A block edited by hand is one.
+function sameFormatter(a, b) {
+  const old = splitToolBlocks(a.toString("latin1"));
+  return old.body === splitToolBlocks(b.toString("latin1")).body && old.blocks.every(toolMade);
+}
 
 // Keep a timestamped copy, with its bytes and mode, of a file that differs from what replaces it.
 function backupIfDifferent(dst, next, label, same = sameBytes) {
@@ -234,7 +351,7 @@ function installLoader() {
 
 // 3. Install the custom formatter and HUD config from the bundled templates.
 //    Files that differ from the templates (local edits) are kept as timestamped
-//    backups first; the blocks payload-mon / claude-update-last add do not count.
+//    backups first; the blocks payload-mon / claude-update-last add, as they write them, do not count.
 function installTemplates() {
   const wrapperSrc = readFileSync(join(SELF, "omc-hud-custom.mjs"));
   const configSrc = readFileSync(join(SELF, "hud-config.json"));
@@ -246,6 +363,72 @@ function installTemplates() {
   log("[ok] HUD config       -> " + configDst);
 }
 
+// settings.json goes in as a new file through a rename, so a stop midway never leaves it half written.
+// One that is a link (dotfiles) keeps its link, and the file it points at is the one replaced. A file
+// left at the temporary name (an earlier run with this pid, or a link put there) is removed first and
+// never written through. It is written in place as before where the new file cannot go in (a folder
+// this account may not write, a file another program holds open, a file system that refuses the
+// rename) or the link leads nowhere yet, and where a rename would part a hard link (its other name
+// would keep the old text) or the new file has another owner or group. Only a full disk stops it, as
+// writing in place could then cut settings.json short; the new file is written before that choice, so
+// a hard link or another owner finds a full disk first too.
+const FULL_DISK = new Set(["ENOSPC", "EDQUOT"]);
+const isLink = (p) => {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+};
+const removeTmp = (tmp) => {
+  try {
+    rmSync(tmp, { force: true });
+  } catch {
+    /* a folder at that name: left alone */
+  }
+};
+// Whether the file, as `old` was, must keep its inode: it has a second name (a hard link), or the new file
+// `tmp` got another owner or group than it had.
+function keepsInode(old, tmp) {
+  if (!old) return false;
+  const now = statSync(tmp);
+  return old.nlink > 1 || now.uid !== old.uid || now.gid !== old.gid;
+}
+function writeSettings(file, text) {
+  let target = file;
+  let old;
+  let mode;
+  try {
+    target = realpathSync(file);
+    old = statSync(target);
+    mode = old.mode & 0o777;
+  } catch {
+    if (isLink(file)) return writeFileSync(file, text);
+  }
+  const tmp = `${target}.${process.pid}.tmp`;
+  try {
+    rmSync(tmp, { force: true });
+    writeFileSync(tmp, text, { flag: "wx", mode });
+    if (mode !== undefined && process.platform !== "win32") chmodSync(tmp, mode);
+    if (!keepsInode(old, tmp)) return renameSync(tmp, target);
+  } catch (e) {
+    if (FULL_DISK.has(e.code)) throw e;
+  } finally {
+    removeTmp(tmp);
+  }
+  writeFileSync(file, text);
+}
+
+// How many other names settings.json has (a hard link, a `cp -al` snapshot, say), 0 when it cannot be read.
+// writeSettings writes such a file in place, so those names show the new text too.
+function otherNames(file) {
+  try {
+    return statSync(file).nlink - 1;
+  } catch {
+    return 0;
+  }
+}
+
 // 4. Point settings.json statusLine at the custom formatter; its other fields (padding, ...) stay.
 //    A settings.json that already says exactly this is neither backed up nor written.
 const objectOr = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
@@ -254,7 +437,7 @@ function pointStatusLine() {
   const command = `node "${cmdPath}"`;
   const prior = objectOr(settings.statusLine);
   if (typeof prior.command === "string" && prior.command && prior.command !== command) {
-    log(`[..] statusLine ran ${JSON.stringify(prior.command)}; it now runs the custom HUD (the old value is in the backup)`);
+    log(`[..] statusLine ran ${priorShown(prior.command)}; it now runs the custom HUD (the old value is in the backup)`);
   }
   settings.statusLine = { ...prior, type: "command", command };
   const next = JSON.stringify(settings, null, 2) + "\n";
@@ -267,8 +450,12 @@ function pointStatusLine() {
     copyFileSync(settingsPath, backup); // the original bytes and mode
     log("[ok] Backed up settings.json -> " + backup);
   }
-  writeFileSync(settingsPath, next);
+  const others = otherNames(settingsPath);
+  writeSettings(settingsPath, next);
   log("[ok] statusLine -> " + command);
+  if (others > 0) {
+    log(`[..] settings.json has ${others} other name${others > 1 ? "s" : ""} (a hard link); it was written in place, so they show the new text too (the old text is in the backup)`);
+  }
 }
 
 // 5. Render check: run the installed formatter once with no input, as the statusLine command does,
@@ -280,7 +467,7 @@ function pointStatusLine() {
 const CHECK_MS = Number(process.env.APPLY_HUD_CHECK_TIMEOUT_MS) || 25000;
 const BLAME =
   "    OMC's install is at fault. /oh-my-claudecode:omc-setup repairs it but points statusLine back at OMC, so run setup-omc-hud again after it.";
-const clip = (s, n = 200) => String(s).slice(0, n);
+const clip = (s, n = 200) => shown(s).slice(0, n);
 // No input, and the config folder as working folder: OMC's loader looks in the working folder's
 // node_modules and runs git from it, and Windows looks there first for a bare program name, so the
 // folder the installer was started in (a project, say) must not be it.
@@ -288,20 +475,31 @@ const RUN_OPTS = { input: "", encoding: "utf8", timeout: CHECK_MS, windowsHide:
 
 // node as the statusLine shell finds it, but only in PATH folders given as absolute paths: spawning the
 // bare name would on Windows try the working folder first, where a project's own node.exe could run.
-function findNode(pathEnv) {
-  const name = process.platform === "win32" ? "node.exe" : "node";
+// Like the shell, it passes over a file it may not run.
+function findNode(pathEnv, name = process.platform === "win32" ? "node.exe" : "node") {
   for (const entry of (pathEnv || "").split(delimiter)) {
     const dir = entry.replace(/^"(.*)"$/, "$1");
     if (!dir || !isAbsolute(dir)) continue;
+    const file = join(dir, name);
     try {
-      if (statSync(join(dir, name)).isFile()) return join(dir, name);
+      if (statSync(file).isFile()) {
+        accessSync(file, constants.X_OK);
+        return file;
+      }
     } catch {
-      /* not in this folder */
+      /* not in this folder, or not runnable */
     }
   }
   return null;
 }
 
+const NO_NODE = '[!!] Render check: no "node" on PATH; the statusLine command runs "node", so the statusline will not show.';
+// Claude Code runs statusLine with Git Bash when it finds it, else with PowerShell. Of the two only
+// PowerShell runs node.cmd for "node", and this check cannot tell which it will be, so it does not run.
+const NODE_CMD_ONLY =
+  '[..] Render check: skipped; PATH has node.cmd but no node.exe, and Git Bash, which Claude Code runs statusLine with when it finds it, does not run node.cmd as "node".';
+const noNodeLine = (pathEnv) => (process.platform === "win32" && findNode(pathEnv, "node.cmd") ? NODE_CMD_ONLY : NO_NODE);
+
 function omcVersion(root) {
   if (!root) return null;
   try {
@@ -312,41 +510,58 @@ function omcVersion(root) {
   }
 }
 
+// The first line of a Node error ("Error: ...", "TypeError [ERR_X]: ..."), "" when there is none.
+const errorLine = (text) => /^\w*Error\b.*$/m.exec(text || "")?.[0] ?? "";
+
 // Why an OMC version does not load: its HUD's own error when run directly.
 function loadReason(node, root) {
   const hud = join(root, "dist", "hud", "index.js");
   if (!existsSync(hud)) return "no dist/hud/index.js";
   const r = spawnSync(node, [hud], RUN_OPTS);
-  const line = /^\w*Error\b.*$/m.exec(r.stderr || "");
-  return line ? clip(line[0]) : "";
+  const line = errorLine(r.stderr);
+  return line ? clip(line) : "";
 }
 
+const NO_OUTPUT = "[..] Render check: OMC printed nothing with no input, so this check cannot tell whether the statusline draws.";
+
 // What the formatter printed, as report lines.
 function judgeRender(out, node) {
   const banner = /^\[OMC\] HUD v(\S+) \| preset: /m.exec(out);
   if (banner) {
     const installed = omcVersion(pluginRoot);
-    if (!installed || installed === banner[1]) return [`[ok] Render check: the statusline loads OMC ${banner[1]}.`];
+    // Both version strings come from OMC (its output, its package.json): shown through clip like its lines.
+    const [drew, want] = [clip(banner[1], 40), clip(installed, 40)];
+    if (!installed || installed === banner[1]) return [`[ok] Render check: the statusline loads OMC ${drew}.`];
     const why = loadReason(node, pluginRoot);
-    const line = `[!!] Render check: the statusline loads OMC ${banner[1]}, not the installed ${installed}; ${installed} does not load`;
-    return [`${line}${why ? ` (${why})` : ""}.`, BLAME];
+    // Without an error from the installed version, all this check saw is which version drew.
+    if (!why) return [`[..] Render check: the statusline loads OMC ${drew}, not the installed ${want}.`];
+    return [`[!!] Render check: the statusline loads OMC ${drew}, not the installed ${want}; ${want} does not load (${why}).`, BLAME];
   }
+  // The formatter says this when OMC printed nothing; with no input that alone does not say it cannot draw.
+  if (/^\[OMC HUD\] no output$/m.test(out)) return [NO_OUTPUT];
   // OMC's line ends with the reason, after a path that can be long: keep it whole within reason.
   const failed = /^\[OMC HUD\] .*$/m.exec(out);
   if (failed) return [`[!!] Render check: OMC's HUD does not load: ${clip(failed[0], 1000)}`, BLAME];
+  // A loader that cannot load prints Node's error, header lines first; its module path can be long.
+  const error = errorLine(out);
+  if (error) return [`[!!] Render check: the statusline prints an error instead of a line: ${clip(error, 1000)}`];
   return [`[..] Render check: unrecognized output: ${clip(out.split("\n")[0])}`];
 }
 
+// A statusline command that exited non-zero: its Node error line when stderr has one, else the first line.
+function failedLine(r) {
+  const stderr = (r.stderr || "").trim();
+  const err = errorLine(stderr) || stderr.split("\n")[0];
+  return `[!!] Render check: the statusline command failed (exit ${r.status ?? r.signal})${err ? `: ${clip(err)}` : ""}`;
+}
+
 function renderReport() {
   const node = findNode(process.env.PATH);
-  if (!node) return ['[!!] Render check: no "node" on PATH; the statusLine command runs "node", so the statusline will not show.'];
+  if (!node) return [noNodeLine(process.env.PATH)];
   const r = spawnSync(node, [wrapperDst], RUN_OPTS);
   if (r.error && r.error.code === "ETIMEDOUT") return [`[!!] Render check: the statusline gave no answer in ${CHECK_MS / 1000}s.`];
   if (r.error) throw r.error;
-  if (r.status !== 0) {
-    const err = (r.stderr || "").trim().split("\n")[0];
-    return [`[!!] Render check: the statusline command failed (exit ${r.status ?? r.signal})${err ? `: ${clip(err)}` : ""}`];
-  }
+  if (r.status !== 0) return [failedLine(r)];
   return judgeRender((r.stdout || "").replace(/\x1b\[[0-9;]*m/g, ""), node);
 }
 
@@ -364,7 +579,7 @@ try {
   pointStatusLine();
 } catch (e) {
   log(`[x] Stopped partway (${e.code || e.message}); some files may have changed.`);
-  log(`    Earlier versions it replaced, apart from the loader and the tool blocks, are in <file>.backup.${stamp}.`);
+  log(`    Earlier versions it replaced, apart from the loader and blocks as the tools wrote them, are in <file>.backup.${stamp}.`);
   process.exit(2);
 }
 

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

@@ -18,8 +18,10 @@
  *     segment each: 🤖1|🔧14|⚡3. A count OMC leaves out (zero) stays out.
  *   - per-model usage badge (fable:0%(1h31m)) -> Fa:0%/1h31m, after the rate windows.
  *   - PL:<MB, 1 decimal>M always shown before se. It reads payload-mon's module
- *     copy next to this file (hud/payload-mon/payload-size.mjs); without it PL
- *     is left out.
+ *     copy, payload-mon/payload-size.mjs, from the first of these folders that
+ *     holds it as a regular file: this file's (the one a statusLine link points
+ *     at), the link's, the config folder's hud/, then the folder import.meta.url
+ *     names (the link's under --preserve-symlinks); without it PL is left out.
  *   - cwd group split on "|"; branch shown without "branch:" after the account.
  *   - OMC#X.Y.Z label no longer shown, nor OMC's update hint lines
  *     ("[!] omc X - paste: ! ...", "[!] claude X - paste: ! claude update").
@@ -68,14 +70,43 @@
  *    We wait for the first complete line instead.
  */
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { Readable } from "node:stream";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const HUD = join(__dirname, "omc-hud.mjs");
+// The statusLine command names this file. When that name is a link (dotfiles, say), node runs the
+// file it points at: the installer puts omc-hud.mjs beside the link and payload-mon puts its copy
+// beside the file, so both folders are looked in. The command's name counts only when it leads to
+// this file (another script may have imported this one), and the file's own folder comes from
+// realpath: with --preserve-symlinks-main, import.meta.url names the link.
+function hereDirs() {
+  const dirs = { named: null, real: __dirname, self: __dirname };
+  try {
+    const real = realpathSync(fileURLToPath(import.meta.url));
+    dirs.real = dirname(real);
+    const named = process.argv[1] ? resolve(process.argv[1]) : "";
+    if (named && realpathSync(named) === real) dirs.named = dirname(named);
+  } catch {
+    /* keep this file's own folder */
+  }
+  return dirs;
+}
+const HERE = hereDirs();
+const isFile = (p) => {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+};
+// The first of these folders (each once, in this order) that holds the file as a regular file, "" when none
+// does: a folder at that name is no module, and opening a FIFO waits for a writer for good.
+function findSibling(dirs, ...parts) {
+  return [...new Set(dirs.filter(Boolean))].map((d) => join(d, ...parts)).find(isFile) ?? "";
+}
 
 const STDIN_TIMEOUT_MS = 2000; // Claude Code pipes the payload immediately
 const RENDER_TIMEOUT_MS = 10000; // see timer discipline note above
@@ -122,10 +153,39 @@ function emit(s) {
 // that file in $CLAUDE_CONFIG_DIR when set, otherwise in the home folder.
 function claudeJsonDir() {
   const v = (process.env.CLAUDE_CONFIG_DIR || "").trim();
-  if (!v) return homedir();
+  return v ? expandDir(v) : homedir();
+}
+// Where Claude Code was started (the statusline JSON's workspace.project_dir, else the working
+// folder). A relative CLAUDE_CONFIG_DIR is read from there: Claude Code reads it from its own working
+// folder, which is the same one until it moves (into a worktree, say).
+function startDir() {
+  try {
+    const d = JSON.parse(input)?.workspace?.project_dir;
+    if (typeof d === "string" && isAbsolute(d)) return d;
+  } catch {
+    /* no or bad stdin JSON */
+  }
+  return process.cwd();
+}
+function expandDir(v) {
   if (v === "~") return homedir();
   if (v.startsWith("~/") || v.startsWith("~\\")) return join(homedir(), v.slice(2));
-  return v;
+  return resolve(startDir(), v);
+}
+// Claude Code's config folder. Its hud/ is where the installer puts the loader: the third place
+// siblings are looked for, as when another script imported this file through a link. "" when the
+// home folder cannot be told (no HOME and no account entry) or the working folder is gone: the
+// other places still count.
+function configDir() {
+  const v = (process.env.CLAUDE_CONFIG_DIR || "").trim();
+  return v ? expandDir(v) : join(homedir(), ".claude");
+}
+function configHud() {
+  try {
+    return join(configDir(), "hud");
+  } catch {
+    return "";
+  }
 }
 function loginAccount() {
   try {
@@ -175,6 +235,7 @@ function readStdinBounded(ms) {
 }
 
 const input = await readStdinBounded(STDIN_TIMEOUT_MS);
+const HUD = findSibling([HERE.named, HERE.real, configHud(), HERE.self], "omc-hud.mjs");
 
 // Current reasoning effort level (low/medium/high/xhigh) from the statusline
 // payload (effort.level) — shown next to the model. Empty if absent.
@@ -278,13 +339,18 @@ for (const s of [process.stdout, process.stderr]) {
 }
 
 let raw = "";
-try {
-  raw = (await renderInProcess(RENDER_TIMEOUT_MS)).replace(/\r/g, "");
-} catch {
-  raw = ""; // fall through to the child-process path
+if (!HUD) {
+  // No regular file at any place looked in: nothing to run. Named where the installer puts it.
+  emit(`[OMC HUD] omc-hud.mjs not found: ${join(HERE.named || HERE.real, "omc-hud.mjs")}\n`);
+} else {
+  try {
+    raw = (await renderInProcess(RENDER_TIMEOUT_MS)).replace(/\r/g, "");
+  } catch {
+    raw = ""; // fall through to the child-process path
+  }
 }
 
-if (!raw.trim()) {
+if (HUD && !raw.trim()) {
   // In-process rendering produced nothing usable. Fall back to the original
   // out-of-process path: it costs an extra node, but a statusline that renders
   // beats one that does not — e.g. if a future OMC version stops being
@@ -481,8 +547,9 @@ try {
   // without it (payload-mon off) or without a transcript, PL is left out.
   try {
     const transcript = JSON.parse(input)?.transcript_path;
-    if (transcript) {
-      const { estimatePayloadBytes, REQUEST_LIMIT_BYTES } = await import(pathToFileURL(join(__dirname, "payload-mon", "payload-size.mjs")).href);
+    const copy = transcript ? findSibling([HERE.real, HERE.named, configHud(), HERE.self], "payload-mon", "payload-size.mjs") : "";
+    if (copy) {
+      const { estimatePayloadBytes, REQUEST_LIMIT_BYTES } = await import(pathToFileURL(copy).href);
       const bytes = estimatePayloadBytes(transcript);
       if (Number.isFinite(bytes)) {
         for (let i = colored.length - 1; i >= 0; i--) if (/^payload:/.test(stripAnsi(colored[i]))) colored.splice(i, 1);

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

@@ -35,7 +35,7 @@ const OPEN = "// >>> claude-update-last >>>";
 const CLOSE = "// <<< claude-update-last <<<";
 // A block's body never crosses another opening marker, so a stray one above a
 // block is left over (and refused) instead of taking the code between with it.
-const BLOCKS =
+export const BLOCKS =
   /^[ \t]*\/\/ >>> claude-update-last >>>(?:(?!\/\/ >>> claude-update-last >>>)[\s\S])*?\/\/ <<< claude-update-last <<<[ \t]*(?:\r?\n|(?![\s\S]))/gm;
 // The block goes right before the line that joins the segments into the statusline.
 const JOIN_LINE = /^ {2}let result = colored\.join\(SEP\);\r?$/gm;
@@ -150,12 +150,14 @@ function writeFresh(file, data) {
   }
 }
 
-// The first lines of node's complaint about `text` as an ES module, "" if it parses.
+// The first lines of node's complaint about `text` as an ES module, "" if it parses. A leading BOM
+// is left out: node runs a wrapper that starts with one, but `node --check` rejects a BOM before a
+// shebang (Node 20, 24).
 function syntaxError(text) {
   const dir = mkdtempSync(join(tmpdir(), "claude-update-last-"));
   try {
     const file = join(dir, "check.mjs");
-    writeFileSync(file, text);
+    writeFileSync(file, text.replace(/^\uFEFF/, ""));
     const r = spawnSync(process.execPath, ["--check", file], { encoding: "utf8" });
     return r.status === 0 ? "" : String(r.stderr || r.error).trim().split("\n").slice(0, 3).join(" | ");
   } finally {