@kaydash9999/banker-plugins 0.13.0 → 0.15.0

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

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+/**
+ * payload-mon: turns the statusline payload segment on or off.
+ *
+ *   node payload-mon.mjs on       add the payload-mon block to the OMC HUD wrapper
+ *   node payload-mon.mjs off      take it out again, with the module copy and the cache
+ *   node payload-mon.mjs status   say whether it is on, with this session's estimate
+ *
+ * The wrapper (<config>/hud/omc-hud-custom.mjs, where <config> is
+ * $CLAUDE_CONFIG_DIR or ~/.claude; $PAYLOAD_MON_HUD_FILE overrides the path)
+ * gets one marker-delimited block right after the line that adds ctx, which
+ * works out the segment and places it there. Blocks other tools add to the same
+ * wrapper with their own markers are left alone.
+ *
+ * Two wrapper layouts take the block. The older one reads stdin into `let input`
+ * and runs the OMC HUD through spawnSync; the current omc_hud one reads it into
+ * `const input`, runs the HUD in-process and keeps spawnSync for a fallback
+ * branch. A block anchored on spawnSync would land in that branch, so the ctx
+ * line is the only anchor. Earlier versions that also put a block before
+ * spawnSync are converted on the next `on`.
+ *
+ * The block imports a copy of payload-size.mjs kept beside the wrapper
+ * (<hud>/payload-mon/payload-size.mjs), not the module in this folder: a plugin
+ * install lives under a versioned path that the next update retires, and an
+ * import pointing there would go dark without a word. `on` writes the copy and
+ * refreshes it when this version's module differs; `status` says when it does.
+ *
+ * `on` converges on the current block and is a no-op when it is in place. It
+ * writes only into the OMC custom HUD (signature-gated); `off` removes only
+ * payload-mon's own marker blocks. Both refuse markers that do not pair up, keep
+ * the text from before each change in <wrapper>.payload-mon.bak, and write
+ * nothing that fails `node --check`.
+ * Exit status 1 means nothing was changed; 2 means an unexpected error stopped
+ * the command partway, so check `status`.
+ */
+import { spawnSync } from "node:child_process";
+import {
+  accessSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { CACHE_DIR, clearCache, estimatePayloadBytes, REQUEST_LIMIT_BYTES, SHOW_FROM_BYTES } from "./payload-size.mjs";
+
+const OPEN = "// >>> payload-mon >>>";
+const CLOSE = "// <<< payload-mon <<<";
+const BLOCKS = /^[ \t]*\/\/ >>> payload-mon >>>[\s\S]*?\/\/ <<< payload-mon <<<[ \t]*\r?\n/gm;
+// The block goes right after the line that adds ctx.
+const CTX_LINE = /^ {2}if \(f\.ctx\) colored\.push\(colorCtx\(f\.ctx\)\);\r?\n/m;
+// The statusline JSON the block reads, in either layout.
+const INPUT_DECL = /^(?:let|const) input\b/m;
+const MB = 1024 * 1024;
+
+const CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+
+const DEFAULTS = {
+  hudFile: process.env.PAYLOAD_MON_HUD_FILE || join(CONFIG_DIR, "hud", "omc-hud-custom.mjs"),
+  moduleSource: fileURLToPath(new URL("./payload-size.mjs", import.meta.url)),
+  cacheDir: CACHE_DIR,
+  settingsFile: join(CONFIG_DIR, "settings.json"),
+  projectsDir: join(CONFIG_DIR, "projects"),
+  sessionId: process.env.CLAUDE_CODE_SESSION_ID,
+};
+
+// Where the block's module lives: beside the wrapper, outside any versioned path.
+const moduleCopy = (hudFile) => join(dirname(hudFile), "payload-mon", "payload-size.mjs");
+const moduleUrl = (hudFile) => pathToFileURL(moduleCopy(hudFile)).href;
+
+// Right after ctx, colored like the 5h/wk rates: % on the ctx scale, MB in cyan.
+// Its names are block-scoped, so none can clash with the wrapper's own.
+const placeBlock = (url) =>
+  [
+    "  " + OPEN,
+    "  // 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 import(${JSON.stringify(url)});`,
+    "      const segment = payloadSegment(estimatePayloadBytes(transcript));",
+    "      if (segment) colored.push(colorRate(segment));",
+    "    }",
+    "  } catch {",
+    "    /* no stdin JSON, unreadable transcript or module error */",
+    "  }",
+    "  " + CLOSE,
+    "",
+  ].join("\n");
+
+const insertBlock = (base, url) => base.replace(CTX_LINE, (line) => line + placeBlock(url));
+
+const count = (text, needle) => text.split(needle).length - 1;
+
+// The wrapper's text, null when there is no such file. Any other read failure
+// (permissions, say) is not "missing" and propagates.
+const readText = (file) => {
+  try {
+    return readFileSync(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") return null;
+    throw e;
+  }
+};
+
+const readBytes = (file) => {
+  try {
+    return readFileSync(file);
+  } catch {
+    return null;
+  }
+};
+
+const refusal = (why, hudFile) => ({ ok: false, message: `${why}. 래퍼를 그대로 두었습니다: ${hudFile}` });
+
+// The block exactly as `on` writes it for this URL, once, right after the ctx line.
+function inPlace(src, url) {
+  if (count(src, OPEN) !== 1 || count(src, CLOSE) !== 1) return false;
+  const ctx = CTX_LINE.exec(src);
+  return ctx !== null && src.startsWith(placeBlock(url), ctx.index + ctx[0].length);
+}
+
+// Why the block cannot go into this wrapper, or "" when it can. Markers that do
+// not pair up would let the block pattern swallow the code between them.
+function misfit(src) {
+  if (count(src, OPEN) !== count(src, CLOSE)) return "payload-mon 표시(>>> / <<<)의 짝이 맞지 않습니다";
+  const base = src.replace(BLOCKS, "");
+  if (!base.includes("omc-hud.mjs") || !base.includes("const colorRate")) return "OMC 커스텀 HUD 래퍼가 아닙니다";
+  if (!INPUT_DECL.test(base)) return "삽입 위치를 찾지 못했습니다(statusline 입력을 담는 input 변수가 없음)";
+  if (!CTX_LINE.test(base)) return "삽입 위치를 찾지 못했습니다(ctx를 넣는 줄이 없음)";
+  return "";
+}
+
+// "current", "stale" (differs from this version's module) or "missing".
+function copyState(o) {
+  const copy = readBytes(moduleCopy(o.hudFile));
+  if (copy === null) return "missing";
+  const source = readBytes(o.moduleSource);
+  return source !== null && copy.equals(source) ? "current" : "stale";
+}
+
+// Replaces file through a fresh temp file ("wx") and a rename: a link planted at
+// either name is replaced rather than written through, and a write that fails
+// leaves the old file as it was.
+function writeFresh(file, data, mode) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  rmSync(tmp, { force: true });
+  try {
+    writeFileSync(tmp, data, { flag: "wx", mode });
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+// Brings the copy up to this version's module; true when it had to write. The
+// statusline imports it on every refresh, so no other account may change it
+// (reading it is harmless). When the write fails, a folder made here is taken
+// away again: mkdirSync names a folder only when it created it, and rmdir
+// leaves one that something else has meanwhile put a file in.
+function syncModule(o) {
+  if (copyState(o) === "current") return false;
+  const copy = moduleCopy(o.hudFile);
+  const made = mkdirSync(dirname(copy), { recursive: true, mode: 0o755 }) !== undefined;
+  try {
+    writeFresh(copy, readFileSync(o.moduleSource), 0o644);
+  } catch (e) {
+    if (made) {
+      try {
+        rmdirSync(dirname(copy));
+      } catch {
+        /* no longer empty, so not only ours */
+      }
+    }
+    throw e;
+  }
+  return true;
+}
+
+// The first lines of node's complaint about `text` as an ES module, "" if it parses.
+function syntaxError(text) {
+  const dir = mkdtempSync(join(tmpdir(), "payload-mon-"));
+  try {
+    const file = join(dir, "check.mjs");
+    writeFileSync(file, text);
+    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 {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// Writes `after` over the wrapper if it parses, keeping `before` in the .bak.
+// `prepare` runs once the text is known to parse and the wrapper to be writable,
+// before the wrapper is touched, so a failure there leaves the wrapper as it was.
+function commit(hudFile, before, after, done, prepare = () => {}) {
+  const err = syntaxError(after);
+  if (err) return { ok: false, message: `node --check 실패로 래퍼를 그대로 두었습니다: ${err}` };
+  try {
+    accessSync(hudFile, constants.W_OK);
+  } catch (e) {
+    return refusal(`래퍼에 쓸 권한이 없습니다(${e.code || e.message})`, hudFile);
+  }
+  try {
+    prepare();
+  } catch (e) {
+    return refusal(`모듈 사본을 쓰지 못했습니다(${e.code || e.message})`, hudFile);
+  }
+  writeFresh(`${hudFile}.payload-mon.bak`, before);
+  writeFileSync(hudFile, after);
+  return { ok: true, message: done };
+}
+
+// Whether settings.json runs this wrapper as the statusline.
+function statusLineUses(settingsFile, hudFile) {
+  try {
+    const command = JSON.parse(readFileSync(settingsFile, "utf8"))?.statusLine?.command;
+    return typeof command === "string" && command.includes(basename(hudFile));
+  } catch {
+    return false;
+  }
+}
+
+const notShownNote = (o) =>
+  statusLineUses(o.settingsFile, o.hudFile)
+    ? ""
+    : `\n주의: statusLine 명령에 ${basename(o.hudFile)}가 보이지 않습니다. ` +
+      "다른 래퍼(smart-compact 등)가 HUD를 감싸 호출하면 정상 표시되고, 아니면 화면에 나타나지 않습니다.";
+
+export function turnOn(opts = {}) {
+  const o = { ...DEFAULTS, ...opts };
+  const src = readText(o.hudFile);
+  if (src === null) return { ok: false, message: `HUD 래퍼가 없습니다: ${o.hudFile}` };
+  if (inPlace(src, moduleUrl(o.hudFile))) {
+    try {
+      const refreshed = syncModule(o);
+      return { ok: true, message: (refreshed ? "모듈 사본을 이 버전으로 맞췄습니다." : "이미 켜져 있습니다 (변경 없음).") + notShownNote(o) };
+    } catch (e) {
+      return { ok: false, message: `모듈 사본을 쓰지 못했습니다(${e.code || e.message}): ${moduleCopy(o.hudFile)}` };
+    }
+  }
+  const why = misfit(src);
+  if (why) return refusal(why, o.hudFile);
+  const done = "켰습니다. 다음 statusline 갱신부터 8MB 이상이면 ctx 옆에 payload가 표시됩니다.";
+  const after = insertBlock(src.replace(BLOCKS, ""), moduleUrl(o.hudFile));
+  return commit(o.hudFile, src, after, done + notShownNote(o), () => syncModule(o));
+}
+
+function removeBlocks(o, src) {
+  if (src === null) return { ok: true, message: `HUD 래퍼가 없어 끌 것이 없습니다: ${o.hudFile}` };
+  if (count(src, OPEN) !== count(src, CLOSE)) return refusal("payload-mon 표시(>>> / <<<)의 짝이 맞지 않습니다", o.hudFile);
+  const out = src.replace(BLOCKS, "");
+  if (out === src) return { ok: true, message: "이미 꺼져 있습니다 (래퍼 변경 없음)." };
+  return commit(o.hudFile, src, out, "껐습니다. 다음 statusline 갱신부터 payload가 표시되지 않습니다.");
+}
+
+// What off leaves behind otherwise: the cache (when this account controls its
+// folder), and the module copy with its folder (only when nothing else is in
+// it). Neither failing undoes off.
+function removeLeftovers(o) {
+  const copy = moduleCopy(o.hudFile);
+  for (const remove of [() => clearCache(o.cacheDir), () => rmSync(copy, { force: true })]) {
+    try {
+      remove();
+    } catch {
+      /* stale numbers or an unused copy; off stands */
+    }
+  }
+  try {
+    rmdirSync(dirname(copy));
+  } catch {
+    /* absent, or holds something that is not ours */
+  }
+}
+
+export function turnOff(opts = {}) {
+  const o = { ...DEFAULTS, ...opts };
+  const res = removeBlocks(o, readText(o.hudFile));
+  if (res.ok) removeLeftovers(o);
+  return res;
+}
+
+// "현재 세션: 0.8MB / 32MB (2%), 8MB부터 표시" for the session that runs this, "" if unknown.
+function sessionEstimate(o) {
+  if (!o.sessionId || !existsSync(o.projectsDir)) return "";
+  const file = `${o.sessionId}.jsonl`;
+  const project = readdirSync(o.projectsDir).find((d) => existsSync(join(o.projectsDir, d, file)));
+  if (!project) return "";
+  try {
+    const bytes = estimatePayloadBytes(join(o.projectsDir, project, file), o.cacheDir);
+    const pct = Math.floor((bytes / REQUEST_LIMIT_BYTES) * 100);
+    return `현재 세션: ${(bytes / MB).toFixed(1)}MB / 32MB (${pct}%), ${SHOW_FROM_BYTES / MB}MB부터 표시`;
+  } catch {
+    return "";
+  }
+}
+
+const COPY_NOTE = {
+  current: "",
+  stale: ", 단 모듈 사본이 이 버전과 다름 (on 으로 갱신)",
+  missing: ", 단 모듈 사본이 없어 표시되지 않음 (on 으로 복구)",
+};
+
+function stateOf(src, o) {
+  if (src === null) return "HUD 래퍼 없음";
+  if (count(src, OPEN) + count(src, CLOSE) === 0) return "꺼짐";
+  // on and off both refuse this, so pointing at on would be a dead end.
+  if (count(src, OPEN) !== count(src, CLOSE)) return "표시(>>> / <<<)의 짝이 맞지 않습니다 (on·off 모두 거부: HUD 재설치 또는 남은 표시 줄 정리)";
+  if (!inPlace(src, moduleUrl(o.hudFile))) return "켜짐이 불완전하거나 오래됨 (on 으로 복구)";
+  return "켜짐" + COPY_NOTE[copyState(o)];
+}
+
+// What status says about the wrapper. A wrapper it cannot read is reported, not
+// thrown: status is where an exit 2 sends the user to look.
+function describe(o) {
+  try {
+    return stateOf(readText(o.hudFile), o);
+  } catch (e) {
+    return `HUD 래퍼를 읽을 수 없음 (${e.code || e.message})`;
+  }
+}
+
+export function status(opts = {}) {
+  const o = { ...DEFAULTS, ...opts };
+  const lines = [`payload-mon: ${describe(o)} (${o.hudFile})`];
+  const note = notShownNote(o);
+  if (note) lines.push(note.trim());
+  const estimate = sessionEstimate(o);
+  if (estimate) lines.push(estimate);
+  return { ok: true, message: lines.join("\n") };
+}
+
+const COMMANDS = new Map([
+  ["on", turnOn],
+  ["off", turnOff],
+  ["status", status],
+]);
+
+function main(arg) {
+  const run = COMMANDS.get(arg);
+  if (!run) {
+    process.stdout.write("사용법: payload-mon on | off | status\n");
+    return 1;
+  }
+  try {
+    const { ok, message } = run();
+    process.stdout.write(message + "\n");
+    return ok ? 0 : 1;
+  } catch (e) {
+    process.stdout.write(`예기치 못한 오류로 중단했습니다: ${e.message}\nstatus 로 상태를 확인하세요.\n`);
+    return 2;
+  }
+}
+
+// Run as a command, also when reached through a symlinked path: Node resolves
+// symlinks for import.meta.url but not for process.argv[1].
+const invokedDirectly = () => {
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+};
+
+if (invokedDirectly()) process.exitCode = main((process.argv[2] || "status").toLowerCase());

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

@@ -0,0 +1,238 @@
+/**
+ * Estimated API request payload of a Claude Code session, for the HUD.
+ *
+ * Claude Code refuses a request over the API's 32MB limit ("Request too large
+ * (max 32MB)") and measures it as the JSON size of the messages it sends
+ * ("request_body_over_limit: body=…B (messages only)"). This applies the same
+ * measure to the session transcript: everything Claude Code would send since the
+ * last compact boundary (images and tool results included), picked with the same
+ * filter it uses to build a request (see sentPart).
+ *
+ * Known gaps, all small next to the 8MB threshold in the sessions measured:
+ * - the system prompt and tool schemas are not in the transcript, so the real
+ *   request is a few hundred KB larger;
+ * - after a rewind (Esc Esc) the abandoned branch stays counted until the next
+ *   compaction;
+ * - the few messages a compaction keeps verbatim before its boundary are not
+ *   added back (13KB or less in each of the 53 compactions measured);
+ * - tool results Claude Code clears at request time (microcompact, not seen in
+ *   these transcripts) stay counted.
+ *
+ * The transcript only grows, so the scanned offset and running total are cached
+ * per transcript under $TMPDIR/omc-hud-payload-<uid>/ and each render reads only
+ * what was appended since the last one. A first render (or a rewritten
+ * transcript) skims for the last compact boundary and parses only what follows it.
+ *
+ * On Linux $TMPDIR is usually the shared /tmp, where any account can create a
+ * folder first. The uid in the folder name keeps accounts apart, and the cache is
+ * used only while that folder is a real directory this account owns and no other
+ * account can write to; otherwise every render rescans. macOS and Windows already
+ * give each account its own temp folder.
+ *
+ * When a Claude Code update changes the transcript format or the request filter,
+ * fix sentPart and bump CACHE_VERSION, so totals cached under the old rules are
+ * rebuilt.
+ */
+import { createHash } from "node:crypto";
+import {
+  closeSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const REQUEST_LIMIT_BYTES = 32 * 1024 * 1024;
+// Shown from 25% of the limit (8MB) on, as an early warning like ctx.
+export const SHOW_FROM_BYTES = REQUEST_LIMIT_BYTES / 4;
+
+const MB = 1024 * 1024;
+// The transcript is read in pieces of this size (exported for the tests).
+export const CHUNK_BYTES = 8 * MB;
+const NL = 0x0a;
+const BOUNDARY_MARK = Buffer.from('"compact_boundary"');
+// This account's uid, or null where there is none (Windows).
+const UID = typeof process.getuid === "function" ? process.getuid() : null;
+// Per-transcript estimate cache, one folder per account; payload-mon off deletes it
+// when this account controls the folder (clearCache).
+export const CACHE_DIR = join(tmpdir(), UID === null ? "omc-hud-payload" : `omc-hud-payload-${UID}`);
+// Bump whenever sentPart changes, so cached totals from older rules are rebuilt.
+const CACHE_VERSION = 2;
+// The model Claude Code stamps on the API-error rows it shows but never sends.
+const SYNTHETIC_MODEL = "<synthetic>";
+
+const parseLine = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null; // torn or foreign line: nothing to count
+  }
+};
+
+const isBoundary = (e) => e?.type === "system" && e.subtype === "compact_boundary";
+
+// Rows Claude Code drops from a request: virtual rows and API-error stand-ins.
+const isDropped = (e) => e.isVirtual === true || (e.isApiErrorMessage === true && e.message?.model === SYNTHETIC_MODEL);
+
+// An attachment sends its rendered text (system reminders, CLAUDE.md, file
+// mentions). An image @-mention is stored without one, since Claude Code renders
+// it again for each request, so its base64 stands in. A PDF mention sends only a
+// short note, and hook results and snapshots send nothing.
+function attachmentPart(e) {
+  if (e.rendered !== undefined) return e.rendered;
+  const { type, content } = e.attachment ?? {};
+  return type === "file" && content?.type === "image" ? content.file?.base64 : undefined;
+}
+
+// The part of an entry that goes into the request, mirroring Claude Code's own
+// filter: user/assistant content (the compact summary included), local command
+// output and attachments. Sidechains are subagents' own loops.
+function sentPart(e) {
+  if (!e || e.isSidechain) return undefined;
+  if (e.type === "user" || e.type === "assistant") return isDropped(e) ? undefined : e.message?.content;
+  if (e.type === "system") return e.subtype === "local_command" ? e.content : undefined;
+  return e.type === "attachment" ? attachmentPart(e) : undefined;
+}
+
+const entryBytes = (e) => {
+  const sent = sentPart(e);
+  return sent == null ? 0 : Buffer.byteLength(JSON.stringify(sent));
+};
+
+// Reads [from, size) in chunks and hands each run of complete lines to
+// onLines(buf, base): buf ends in "\n" and starts at file offset base. A last
+// line still being written is left for the next render. Returns the offset just
+// past the last complete line.
+function readCompleteLines(fd, from, size, onLines) {
+  let pos = from;
+  let base = from;
+  let carry = Buffer.alloc(0);
+  while (pos < size) {
+    const chunk = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, size - pos));
+    const n = readSync(fd, chunk, 0, chunk.length, pos);
+    if (n === 0) break;
+    pos += n;
+    const data = carry.length ? Buffer.concat([carry, chunk.subarray(0, n)]) : chunk.subarray(0, n);
+    const end = data.lastIndexOf(NL) + 1;
+    if (end > 0) onLines(data.subarray(0, end), base);
+    base += end;
+    carry = data.subarray(end);
+  }
+  return base;
+}
+
+// Offset just past the last real compact boundary, 0 when there is none. Only
+// lines holding the marker are parsed, so a 70MB transcript is skimmed in ~0.2s.
+// Exported so the tests can pin where the count starts.
+export function lastBoundaryEnd(fd, size) {
+  let found = 0;
+  readCompleteLines(fd, 0, size, (buf, base) => {
+    for (let k = buf.indexOf(BOUNDARY_MARK); k !== -1; ) {
+      const end = buf.indexOf(NL, k);
+      if (isBoundary(parseLine(buf.toString("utf8", buf.lastIndexOf(NL, k) + 1, end)))) found = base + end + 1;
+      k = buf.indexOf(BOUNDARY_MARK, end);
+    }
+  });
+  return found;
+}
+
+// Running total over the complete lines in [from, size). A compact boundary
+// starts it over: compaction replaces everything sent before it.
+function sumEntries(fd, from, size, bytes) {
+  let total = bytes;
+  const offset = readCompleteLines(fd, from, size, (buf) => {
+    for (let start = 0, end; (end = buf.indexOf(NL, start)) !== -1; start = end + 1) {
+      const e = parseLine(buf.toString("utf8", start, end));
+      total = isBoundary(e) ? 0 : total + entryBytes(e);
+    }
+  });
+  return { offset, bytes: total };
+}
+
+const cacheFile = (dir, transcriptPath) =>
+  join(dir, createHash("sha1").update(transcriptPath).digest("hex").slice(0, 16) + ".json");
+
+// Whether dir is a real folder (not a link) that this account owns and no other
+// account can write to. Windows has no uid and gives each account its own temp.
+function ownedDir(dir) {
+  try {
+    const st = lstatSync(dir);
+    return st.isDirectory() && (UID === null || (st.uid === UID && (st.mode & 0o022) === 0));
+  } catch {
+    return false;
+  }
+}
+
+const loadCache = (file) => {
+  if (!ownedDir(dirname(file))) return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+};
+
+// Write then rename, so a render running at the same time never reads half a
+// file. The temp file is created fresh ("wx"), never written through whatever
+// already sits at its name.
+function saveCache(file, state) {
+  try {
+    const dir = dirname(file);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (!ownedDir(dir)) return; // a folder this account does not control: no cache
+    const tmp = `${file}.${process.pid}.tmp`;
+    rmSync(tmp, { force: true });
+    writeFileSync(tmp, JSON.stringify(state), { flag: "wx", mode: 0o600 });
+    renameSync(tmp, file);
+  } catch {
+    /* the cache only saves time; the estimate stands without it */
+  }
+}
+
+/**
+ * Deletes the estimate cache at dir, but only a folder this account controls:
+ * one another account created first is left alone, as it was never used.
+ */
+export function clearCache(dir = CACHE_DIR) {
+  if (ownedDir(dir)) rmSync(dir, { recursive: true, force: true });
+}
+
+/**
+ * Estimated request payload, in bytes, of the session whose transcript is at
+ * transcriptPath. Throws when the transcript cannot be read.
+ */
+export function estimatePayloadBytes(transcriptPath, cacheDir = CACHE_DIR) {
+  const fd = openSync(transcriptPath, "r");
+  try {
+    const { size, ino } = fstatSync(fd);
+    const file = cacheFile(cacheDir, transcriptPath);
+    const c = loadCache(file);
+    // Resume only a cache of these rules, for this file, which has not shrunk since.
+    const resume = c?.v === CACHE_VERSION && c.path === transcriptPath && c.ino === ino && c.offset <= size;
+    const state = resume
+      ? c
+      : { v: CACHE_VERSION, path: transcriptPath, ino, offset: lastBoundaryEnd(fd, size), bytes: 0 };
+    const next = { ...state, ...sumEntries(fd, state.offset, size, state.bytes) };
+    if (!resume || next.offset !== state.offset) saveCache(file, next);
+    return next.bytes;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+/**
+ * The HUD segment, "payload:28%/9.0MB" (share of the 32MB limit / size), in the
+ * 5h/wk layout the wrapper colors like ctx; "" below 8MB.
+ */
+export function payloadSegment(bytes) {
+  if (!(bytes >= SHOW_FROM_BYTES)) return "";
+  const pct = Math.floor((bytes / REQUEST_LIMIT_BYTES) * 100);
+  return `payload:${pct}%/${(bytes / MB).toFixed(1)}MB`;
+}

package/skills/pdf-vision-extract/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: pdf-vision-extract
-description: "(banker) 비주얼 위주 PDF를 고해상도 per-page PNG로 변환해 레이아웃 손실 없이 비전 입력으로 읽기. 'pdf-vision-extract'/'PDF를 이미지로'/'디자인 PDF 추출' 시 사용."
+description: "그림 위주의 PDF 를 쪽마다 고해상도 PNG 로 바꿔 레이아웃 손실 없이 비전 입력으로 읽음. 'pdf-vision-extract'/'PDF를 이미지로'/'디자인 PDF 추출' 시 사용."
 ---
 
 # pdf-vision-extract

package/skills/play-qa/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: play-qa
-description: "(banker) Godot HTML5 웹게임을 실제 브라우저에서 직접 플레이하며 렌더·입력·시작 결함을 QA(playwright). 'play-qa'/'게임 직접 qa'/'네가 직접 플레이해봐'/'in-browser 플레이테스트' 시 사용."
+description: "Godot 로 만든 HTML5 웹 게임을 실제 브라우저에서 Playwright 로 직접 플레이하며 렌더, 입력, 시작 결함을 찾음. 'play-qa'/'게임 직접 qa'/'네가 직접 플레이해봐'/'in-browser 플레이테스트' 시 사용."
 ---
 
 # play-qa: 에이전트가 직접 브라우저에서 게임을 플레이·QA