@kaydash9999/banker-plugins 0.19.5 → 0.20.0

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Claude Code skills + commands — QA, audit, docs, architecture, dependency setup, and wiki; the banker plugin marketplace.",
-    "version": "0.19.5"
+    "version": "0.20.0"
   },
   "plugins": [
     {

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "banker",
-  "version": "0.19.5",
+  "version": "0.20.0",
   "description": "Claude Code plugin: QA/audit/docs/architecture skills + commands, a /banker:setup installer for OS dependencies (playwright, etc.), and wiki compaction.",
   "author": {
     "name": "smallOpenSource",

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.20.0] - 2026-10-19
+
+### Changed
+- `setup-omc-hud` 가 상태표시줄 파일을 내려받지 않고 스킬에 든 파일(`skills/setup-omc-hud/assets/`)로 설치한다. 모든 OS 에서 `node assets/apply-hud.mjs` 한 명령이고, 네트워크가 없어도 끝까지 된다. 예전에는 GitHub 의 omc_hud 저장소에서 OS 별 스크립트를 받아, 원본이 바뀌면 설치 결과도 말없이 바뀌었다.
+- 설치 스크립트는 설정 폴더 경로의 공백과 `settings.json` 앞의 BOM 을 처리하고, 손으로 고친 래퍼와 HUD 설정은 `.backup.<시각>` 으로 남긴다. 백업은 원본의 바이트와 권한을 그대로 두고, statusLine 의 다른 필드(`padding` 등)는 남긴다.
+- 설치 스크립트는 `settings.json` 이 JSON 객체가 아니거나, OMC 가 없거나, 설정 폴더 경로에 셸이 해석하는 글자(`"`, `$`, 백틱, `%`, `\`, 줄바꿈)가 있거나, 쓸 수 없는 파일이 있으면 아무 파일도 바꾸지 않고 멈춘다(종료 1). 예기치 못한 오류로 중간에 멈추면 종료 2 로 알린다.
+- 첨부 HUD 설정은 OMC 출력을 8줄까지 둔다. 3줄이면 에이전트가 하나만 돌아도 갱신 안내와 함께 상세 줄이 `... (+N lines)` 로 접혔다.
+- 상태표시줄 래퍼가 v4 로 바뀐다. 첫 줄은 `<model>/<effort>|5h:<pct>/<reset>|wk:<pct>/<reset>|<mm>:<pct>/<reset>|think|PL:<mb>M|se:<hours>h|ctx:<pct>%|🤖<agents>|🔧<tools>|⚡<skills>|<cwd>|<account>|<branch>|claude<cur>→<new>` 이고, 둘째 줄부터 에이전트 목록 같은 상세 줄이 붙는다. 화면 폭을 넘으면 칸 사이에서 접는다. OMC 와 Claude Code 의 갱신 안내 줄, OMC 판 표시는 보이지 않는다.
+- `setup-omc-hud` 는 설치할 때마다 payload-mon 을 켠다. `PL:` 칸이 payload-mon 의 크기 계산 모듈을 쓰기 때문이다. 예전에는 켜져 있던 경우만 다시 켰다.
+- `setup-omc-hud` 의 Claude 갱신 안내 블록 단계를 뺀다. 새 래퍼가 안내를 줄여 직접 맨 끝에 둔다. 인자 `off`, `status` 는 옛 래퍼에 넣은 블록을 위해 남는다.
+- 유지보수자용: 설치 스크립트, 래퍼 형식, 블록 도구 둘과 래퍼 v4 의 왕복을 시험한다. smoke 는 스킬 설명서에 내려받기 명령이 없는지와 Codex 사본의 설치 스크립트가 도는지를 본다.
+
+### Fixed
+- `payload-mon` 과 `setup-omc-hud` 의 블록 도구가 따옴표 안에서 펼쳐지지 않은 `~` 나 끝 공백이 든 `CLAUDE_CONFIG_DIR` 를 그대로 경로로 써서, 설치 스크립트가 만든 래퍼를 찾지 못하던 것. 이제 설치 스크립트와 같이 `~/x` 를 `<홈>/x` 로 읽는다.
+
 ## [0.19.5] - 2026-10-17
 
 ### Changed

package/README.md

@@ -180,7 +180,7 @@ USER_RESOURCES 가이드의 공통 요소를 OS별·런타임별(Claude Code/Cod
 | `setup-omc` | oh-my-claudecode(OMC) 설치·갱신 (Codex는 OMX) |
 | `setup-harness-factory` | revfactory/harness 팀 아키텍처 팩토리 설치·구성·사용안내 (Codex=meta-harness) |
 | `setup-playwright` | Playwright + headless 브라우저 (RHEL8/Rocky8·non-root·no-conda 폴백) |
-| `setup-omc-hud` | omc_hud 상태표시줄 (OS별). Claude 갱신 안내는 줄 맨 끝 |
+| `setup-omc-hud` | omc_hud 상태표시줄(래퍼 v4). 스킬에 든 파일로 오프라인 설치, 모든 OS 같은 명령 |
 | `setup-insane-search` | insane-search 플러그인 설치 (Claude·Codex) |
 | `setup-stitch` | Stitch 디자인 MCP 프록시 등록(RockyLinux8 proxy) |
 | `docs-setup` | arch-diagram·pdf-vision-extract 의존성(pptx·pymupdf·plantuml) 설치 |
@@ -247,7 +247,7 @@ banker uninstall        # 제거
 | `setup-mcp` | `claude mcp add` (context7·seq-thinking·filesystem·git·fetch) | `[mcp_servers.*]` |
 | `setup-lsp` | LSP MCP 등록 | `[mcp_servers.lsp_bridge]` |
 | `setup-stitch` | `claude mcp add stitch` | `codex mcp add stitch` |
-| `setup-omc-hud` | `statusLine` + `hud/omc-hud-custom.mjs` 에 Claude 갱신 안내를 줄 맨 끝으로 옮기는 블록 1개(`.claude-update-last.bak` 백업·멱등·`node --check` 검증, `off` 로 원복) | — (Codex는 OMX `hud`) |
+| `setup-omc-hud` | `statusLine`(`settings.json` 백업) + `hud/omc-hud-custom.mjs`, `hud/omc-hud.mjs`, `.omc/hud-config.json`(바뀐 파일은 `.backup.<시각>` 백업) + payload-mon 켜기. 옛 판이 넣은 갱신 안내 블록은 `off` 로 원복 | — (Codex는 OMX `hud`) |
 | `setup-pwsh` | `env.CLAUDE_CODE_GIT_BASH_PATH` (병합) | — (네이티브 셸, 배선 불필요) |
 | `setup-harness-factory` | `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` (env 영속) | — |
 | `smart-compact` | `statusLine.command` 래핑 + `UserPromptSubmit` 훅 추가 (백업·멱등) | `~/.codex/` 대응 |
@@ -301,7 +301,8 @@ Codex는 재설치할 때마다 기존 `banker-*` 를 먼저 정리하므로 옛
 > 표시 블록과 모듈 사본은 플러그인 밖(`~/.claude/hud/`)에 있어서, 플러그인을 지워도 남아 계속 표시됩니다.\
 > 이미 지웠다면 HUD를 재설치하거나, `omc-hud-custom.mjs` 에서 `// >>> payload-mon >>>` 부터 `// <<< payload-mon <<<` 까지 지우면 됩니다.
 
-> `setup-omc-hud` 가 넣은 Claude 갱신 안내 블록도 플러그인 밖(`~/.claude/hud/omc-hud-custom.mjs`)에 남습니다. 원래 순서로 되돌리려면 제거 전에 `/banker:setup-omc-hud off` 를 실행하세요.\
+> `setup-omc-hud` 가 설치한 상태표시줄 래퍼와 설정도 플러그인 밖(`~/.claude/hud/`, `~/.claude/.omc/`)에 있어서, 플러그인을 지워도 남습니다.\
+> 0.19.5 이하의 `setup-omc-hud` 가 옛 래퍼에 넣은 Claude 갱신 안내 블록은 제거 전에 `/banker:setup-omc-hud off` 로 뺄 수 있습니다.\
 > 이미 지웠다면 HUD를 재설치하거나, `// >>> claude-update-last >>>` 부터 `// <<< claude-update-last <<<` 까지 지우면 됩니다. 블록을 남겨 두어도 상태표시줄은 깨지지 않습니다.
 
 > `setup-bypass-permissions` 로 바꾼 권한 모드는 `settings.json` 에 남아, 플러그인을 지워도 모든 세션에서 확인 없이 도구가 실행됩니다. 제거 전에 `/banker:setup-bypass-permissions off` 를 실행하세요.\
@@ -366,6 +367,8 @@ banker 자체는 **MIT** ([LICENSE](LICENSE)). Owner: [smallOpenSource](https://
   패턴 목록은 Wikipedia [*Signs of AI writing*](https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing)(WikiProject AI Cleanup, **CC BY-SA**)에 기반합니다.
 - `skills/3d-intro-build/references`: [oso95/scroll-world](https://github.com/oso95/scroll-world) 의 스크럽 엔진(`scrub-engine.js`·`index-template.html`)을 그대로 벤더링, **MIT License**(© 2026 cyw).\
   원본 라이선스 고지는 `skills/3d-intro-build/references/LICENSE` 와 `NOTICE.md` 에 포함.
+- `skills/setup-omc-hud/assets`: 상태표시줄 래퍼와 설치 스크립트는 [smallOpenSource/omc_hud](https://github.com/smallOpenSource/omc_hud) d3cedd5 를 고친 것, **MIT License**(© 2026 smallOpenSource).\
+  원본 라이선스 고지는 `skills/setup-omc-hud/assets/LICENSE-omc_hud` 에 포함.
 - `skills/theme-selection/assets`: 번들 팔레트(`palettes.json`)는 [VoltAgent/awesome-design-md](https://github.com/VoltAgent/awesome-design-md) 의 DESIGN.md 에서 색 값을 읽어 만든 것, **MIT License**(© 2026 VoltAgent).\
   원본 라이선스 고지는 `skills/theme-selection/assets/LICENSE` 와 `NOTICE.md` 에 포함.\
   테마 이름의 상표는 각 소유자에게 있으며, banker 는 그 회사들과 관계가 없습니다.

package/codex/manifest.json

@@ -28,7 +28,7 @@
     { "name": "ultra-init",           "type": "skill",   "target": "both",        "reason": "orchestrates ralplan->ralph->QA gate (no ultragoal ledger: OMC 5.6.1 checkpoints need a /goal snapshot that would compete with ralph); Claude=OMC 5 (verify cycle in place of the removed ultraqa; needs the omc CLI with `omc ralph verify`), Codex=OMX (OMX ultraqa); body runtime-aware", "supportingFiles": [] },
     { "name": "omc-reference",        "type": "skill",   "target": "both",        "reason": "OMC/OMX agent/tool/skill registry reference; runtime-aware (Codex counterpart is OMX)", "supportingFiles": [] },
     { "name": "setup-omc",            "type": "skill",   "target": "both",        "reason": "installs OMC (Claude) or OMX (Codex `omx setup`); body already dual-runtime", "supportingFiles": [] },
-    { "name": "setup-omc-hud",        "type": "skill",   "target": "both",        "reason": "installs omc_hud (Claude statusLine) and moves OMC's Claude Code update notice to the end of the line; Codex uses OMX `hud`; runtime-aware", "supportingFiles": ["scripts/claude-update-last.mjs"] },
+    { "name": "setup-omc-hud",        "type": "skill",   "target": "both",        "reason": "installs the omc_hud statusline wrapper v4 (Claude statusLine) from files bundled in assets/, offline and with one node command on every OS, then turns payload-mon on for the PL segment; off/status handle the update-notice block older wrappers took; Codex uses OMX `hud`; runtime-aware", "supportingFiles": ["assets/apply-hud.mjs", "assets/omc-hud-custom.mjs", "assets/hud-config.json", "assets/LICENSE-omc_hud", "scripts/claude-update-last.mjs"] },
     { "name": "setup-stitch",         "type": "skill",   "target": "both",        "reason": "registers the Stitch MCP proxy (RockyLinux8 ~/bin/stitch-proxy.sh); Claude `claude mcp add`, Codex `codex mcp add`", "supportingFiles": [] },
 
     { "name": "docs-setup",           "type": "skill",   "target": "both",        "reason": "installs arch-diagram/pdf-vision-extract deps (python-pptx, pymupdf, plantuml); python-env detect/select; runtime-agnostic installer", "supportingFiles": [] },

package/commands/setup.md

@@ -31,7 +31,7 @@ banker 플러그인이 제공하는 설치 스킬들을 **multi-select**로 골
    - **setup-omc** — oh-my-claudecode(OMC) 설치/갱신(Codex는 OMX). `all-in-one`·`ultra-chain`·`ultra-init`·`/banker:front-qa` 의존성.
    - **setup-harness-factory** — revfactory/harness(팀 아키텍처 팩토리) 설치+구성+안내(Codex=meta-harness).
    - **setup-insane-search** — insane-search 플러그인(차단 사이트 우회, Claude/Codex 양쪽).
-   - **setup-omc-hud** — omc_hud 상태표시줄(OS별).
+   - **setup-omc-hud** — omc_hud 상태표시줄(래퍼 v4, 스킬에 든 파일로 오프라인 설치).
    - **setup-stitch** — Stitch(디자인 생성) MCP 프록시 등록(RockyLinux8 proxy-script, API key 필요).
 
    **의존성 라이브러리**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.19.5",
+  "version": "0.20.0",
   "description": "banker — Claude Code + Codex CLI plugin (QA, audit, docs, architecture, wiki skills). Install via Claude Code marketplace, or `npm i -g @kaydash9999/banker-plugins` then `banker setup`.",
   "bin": {
     "banker": "bin/banker.js"

package/skills/payload-mon/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: payload-mon
-description: "OMC HUD 상태표시줄의 `ctx` 옆에, 현재 세션이 보내는 API 요청의 페이로드 추정치를 32MB 한도 대비로 표시하는 기능을 켜고 끔. 8MB 부터 표시. 'payload-mon'/'payload 모니터 켜/꺼'/'상태표시줄 payload 표시'/'요청 크기 경고'/'32MB 한도 경고'/'payload 표시가 안 보여' 시 사용."
+description: "OMC HUD 상태표시줄에 현재 세션이 보내는 API 요청의 페이로드 추정치를 32MB 한도 대비로 표시하는 기능을 켜고 끔. 래퍼 v4 는 `PL:` 칸으로 늘 보이고, 옛 래퍼는 8MB 부터 `ctx` 옆에 보임. 'payload-mon'/'payload 모니터 켜/꺼'/'상태표시줄 payload 표시'/'요청 크기 경고'/'32MB 한도 경고'/'payload 표시가 안 보여' 시 사용."
 argument-hint: "on | off | status"
 ---
 
@@ -11,6 +11,7 @@ argument-hint: "on | off | status"
 Claude Code 는 요청 본문이 32MB 를 넘으면 "Request too large (max 32MB)" 로 거절한다.
 이 한도는 토큰이 아니라 바이트라서, ctx(컨텍스트 %)가 낮아도 이미지나 큰 도구 결과가 쌓이면 걸린다.
 이 스킬은 그 바이트를 추정해 한도의 25%(8MB)부터 ctx 옆에 `payload:28%/9.0MB` 처럼 보여 준다.
+`setup-omc-hud` 가 까는 래퍼 v4 는 이 스킬의 모듈로 크기를 늘 `se` 앞에 `PL:0.5M` 처럼 보이고, 블록이 내는 칸은 그 `PL:` 이 대신한다.
 
 ## 실행
 
@@ -41,13 +42,14 @@ node "<이 스킬 디렉터리 절대경로>/scripts/payload-mon.mjs" <on|off|st
   블록이 불러오는 추정 모듈은 래퍼 옆 `hud/payload-mon/payload-size.mjs` 에 사본으로 둔다. 플러그인 설치 경로는 버전마다 바뀌어 업데이트 뒤에 사라지기 때문이다.
   이미 켜져 있으면 래퍼를 바꾸지 않고, 모듈 사본이 이 버전과 다를 때만 사본을 맞춘다. 예전 방식(블록 2개)으로 켜져 있었다면 새 방식으로 바꾼다.
   바꾸기 전 내용은 `omc-hud-custom.mjs.payload-mon.bak` 에 남는다.
-- `off`: 그 블록만 빼서 래퍼를 켜기 전 상태로 되돌리고, 모듈 사본과 추정치 캐시를 지운다.
+- `off`: 그 블록만 빼서 래퍼를 켜기 전 상태로 되돌리고, 모듈 사본과 추정치 캐시를 지운다. 래퍼 v4 에서는 모듈 사본이 없어져 `PL:` 칸도 사라진다.
 - `status`: 켜짐·꺼짐, 모듈 사본이 이 버전과 같은지, statusLine 이 이 래퍼를 쓰는지, 현재 세션의 추정치를 보여 준다.
 - 같은 래퍼에 자기 표시 블록을 넣는 다른 도구가 있어도 서로의 블록을 건드리지 않는다.
 
 ## 무엇을 어떻게 보여 주는가
 
-- `ctx:21%|payload:28%/9.0MB|se:…`: 32MB 대비 %(ctx 와 같은 색: 70% 미만 초록, 85% 미만 노랑, 그 이상 빨강)와 크기(MB, 청록). 8MB 미만이면 숨긴다.
+- 래퍼 v4: `PL:9.0M|se:0.7h|…`. 크기(MB, 소수 1자리)를 늘 보이고, 색은 32MB 대비 %(70% 미만 초록, 85% 미만 노랑, 그 이상 분홍)다.
+- 옛 래퍼: `ctx:21%|payload:28%/9.0MB|se:…`: 32MB 대비 %(ctx 와 같은 색: 70% 미만 초록, 85% 미만 노랑, 그 이상 빨강)와 크기(MB, 청록). 8MB 미만이면 숨긴다.
 - 값은 마지막 `/compact` 이후 Claude Code 가 실제로 보내는 메시지의 바이트다. Claude Code 가 32MB 한도를 판정하는 방식과 같고, 무엇을 넣고 뺄지는 Claude Code 2.1.288 의 요청 필터를 따른다.
 - 세션 파일 크기가 아니다. 71MB 짜리 세션 파일도 실제 전송분은 0.1MB 일 수 있다. 알려진 오차는 `scripts/payload-size.mjs` 머리 주석에 있다.
 
@@ -60,7 +62,7 @@ node "<이 스킬 디렉터리 절대경로>/scripts/payload-mon.mjs" <on|off|st
 - "모듈 사본을 쓰지 못했습니다": 래퍼 옆 `hud/payload-mon/` 에 쓸 수 없다(권한, 같은 이름의 파일, 디스크 공간). 래퍼는 그대로다.
 - "표시(>>> / <<<)의 짝이 맞지 않습니다": 래퍼에 payload-mon 표시 줄이 한쪽만 남았다. `on`·`off` 모두 거부하므로, 손으로 고치지 말라는 원칙의 유일한 예외다.
   `setup-omc-hud` 로 HUD 를 재설치하거나, 래퍼에서 짝 없이 남은 `// >>> payload-mon >>>` 또는 `// <<< payload-mon <<<` 줄을 지운 뒤 다시 실행한다.
-- HUD 를 재설치한 뒤 payload 가 안 보이면 `on` 을 다시 실행한다. `setup-omc-hud` 로 재설치했다면 그 스킬이 다시 켠다.
+- HUD 를 재설치한 뒤 payload 가 안 보이면 `on` 을 다시 실행한다. `setup-omc-hud` 는 설치할 때마다 이 스킬을 늘 켠다(래퍼 v4 의 `PL:` 칸이 모듈 사본을 씀).
 - banker 업데이트 알림에 payload-mon 이 바뀌었다고 나오거나 `status` 에 "모듈 사본이 이 버전과 다름" 이 나오면, `on` 을 한 번 실행해 사본을 맞춘다.
 - `status` 에 "주의: statusLine 명령에 … 보이지 않습니다" 가 나오면 statusline 이 다른 명령이다. smart-compact 처럼 HUD 를 감싸 호출하는 래퍼라면 정상 표시된다. 이 스킬은 OMC 커스텀 HUD 래퍼에만 붙는다.
 - 추정치가 실제 "Request too large" 시점과 크게 어긋나면 Claude Code 가 세션 파일 형식이나 요청 필터를 바꿨을 수 있다. banker 이슈로 알린다.

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

@@ -49,7 +49,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { CACHE_DIR, clearCache, estimatePayloadBytes, REQUEST_LIMIT_BYTES, SHOW_FROM_BYTES } from "./payload-size.mjs";
 
@@ -62,7 +62,17 @@ const CTX_LINE = /^ {2}if \(f\.ctx\) colored\.push\(colorCtx\(f\.ctx\)\);\r?\n/m
 const INPUT_DECL = /^(?:let|const) input\b/m;
 const MB = 1024 * 1024;
 
-const CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+// The same rules as setup-omc-hud's installer (OMC's getClaudeConfigDir): trim, expand a leading "~",
+// make it absolute, drop a trailing separator. A value no shell expanded ("~/x" in quotes) still finds
+// the wrapper the installer put there.
+function configDir() {
+  const v = (process.env.CLAUDE_CONFIG_DIR || "").trim();
+  if (!v) return join(homedir(), ".claude");
+  if (v === "~") return homedir();
+  if (v.startsWith("~/") || v.startsWith("~\\")) return join(homedir(), v.slice(2));
+  return resolve(v);
+}
+const CONFIG_DIR = configDir().replace(/[\\/]+$/, "");
 
 const DEFAULTS = {
   hudFile: process.env.PAYLOAD_MON_HUD_FILE || join(CONFIG_DIR, "hud", "omc-hud-custom.mjs"),

package/skills/setup-omc-hud/SKILL.md

@@ -1,73 +1,134 @@
 ---
 name: setup-omc-hud
-description: "Claude Code 의 상태표시줄 omc_hud 를 OS별 적용 스크립트로 설치하고, Claude Code 갱신 안내를 줄 맨 끝으로 옮김. Codex 는 OMX 의 `hud` 스킬을 씀. 'setup-omc-hud'/'omc_hud 설치'/'Claude 갱신 안내 위치' 또는 `/banker:setup` 시 사용."
+description: "Claude Code 상태표시줄 omc_hud 래퍼를 스킬에 든 파일로 설치. 내려받지 않고 오프라인에서 모든 OS 같은 명령으로 동작하며, PL 칸에 쓰는 payload-mon 모듈도 켬. Codex 는 OMX 의 `hud` 스킬을 씀. 'setup-omc-hud'/'omc_hud 설치'/'상태표시줄 설치' 또는 `/banker:setup` 시 사용."
 argument-hint: "[off|status]"
 ---
 
-# setup-omc-hud — omc_hud 상태표시줄 설치 (OS별)
+# setup-omc-hud: omc_hud 상태표시줄 설치 (오프라인)
 
-`smallOpenSource/omc_hud` 의 apply 스크립트를 OS에 맞게 내려받아 적용한다. `wget` 없으면 `curl`로 폴백. 답변은 한글.
+이 스킬 폴더의 `assets/` 에 든 파일로 상태표시줄 래퍼 v4 를 설치한다. 답변은 한글.
 
-**런타임:** omc_hud 는 Claude Code 상태표시줄(`~/.claude/settings.json` statusLine) 대상이다. **Codex 런타임에선 oh-my-codex(OMX)가 자체 `hud` 스킬/구성을 제공**하므로, Codex에선 이 스킬 대신 OMX 의 `hud` 를 사용한다.
+- 내려받는 것이 없다. 네트워크가 없어도 끝까지 된다.
+- Windows, Linux, macOS 모두 `node` 명령 하나로 같은 절차를 밟는다.
+- 설치 파일: `apply-hud.mjs`(설치 스크립트), `omc-hud-custom.mjs`(래퍼 v4), `hud-config.json`(HUD 설정), `LICENSE-omc_hud`(원본 omc_hud 의 MIT 라이선스)
 
-**인자가 `off` 또는 `status` 일 때:** 0~3단계를 건너뛰고 3단계의 Claude 갱신 안내 스크립트만 그 인자로 실행해 결과를 보고한다(`off` 는 안내를 래퍼가 정한 자리로 되돌림, `status` 는 상태만 확인).
+**런타임:** Claude Code 상태표시줄(`<설정 폴더>/settings.json` 의 `statusLine`)이 대상이다. Codex 런타임에서는 oh-my-codex(OMX)가 자체 `hud` 스킬을 주므로 이 스킬 대신 OMX 의 `hud` 를 쓴다.
+
+**인자가 `off` 또는 `status` 일 때:** 0~3단계를 건너뛰고 "인자 off, status" 절만 실행한다.
+
+## 표시 형식
+
+```
+<model>/<effort>|5h:<pct>/<reset>|wk:<pct>/<reset>|<mm>:<pct>/<reset>|think|PL:<mb>M|se:<hours>h|ctx:<pct>%|🤖<agents>|🔧<tools>|⚡<skills>|<cwd>|<account>|<branch>|claude<cur>→<new>
+<에이전트 목록, 경고 같은 상세 줄>
+```
+
+| 변수 | 뜻 | 예 | 나오는 조건 |
+|---|---|---|---|
+| `<model>` | 모델 이름 앞 2글자와 버전 | `Op5.5` | 항상 |
+| `<effort>` | 추론 강도 | `high` | Claude Code 가 넘기거나 OMC 가 effort 칸을 낼 때 |
+| `<pct>`, `<reset>` | 사용률과 초기화까지 남은 시간 | `96%`, `1h5m` | 사용량 정보가 있을 때 |
+| `<mm>` | 모델별 사용량의 모델 이름 앞 2글자 | `Fa` | OMC 가 모델별 사용량을 낼 때 |
+| `think` | 확장 사고 표시 | `think` | 확장 사고가 켜져 있을 때 |
+| `<mb>` | 요청 크기 추정치(MB, 소수 1자리) | `0.5` | payload-mon 모듈이 있을 때 |
+| `<hours>` | 세션 시간(시간, 소수 1자리) | `0.7` | 항상 |
+| `ctx:<pct>%` | 대화 맥락 사용률 | `ctx:12%` | OMC 가 ctx 를 낼 때 |
+| `<agents>` | 이 세션의 에이전트 호출 수 | `1` | 1 이상일 때 |
+| `<tools>` | 도구 호출 수 | `14` | 1 이상일 때 |
+| `<skills>` | 스킬 호출 수 | `3` | 1 이상일 때 |
+| `<cwd>` | 작업 폴더 | `/home/user/project` | 항상 |
+| `<account>` | 로그인 계정 이메일의 `@` 앞부분 | `user` | `.claude.json` 에 이메일이 있을 때 |
+| `<branch>` | git 브랜치 | `main` | git 저장소 안일 때 |
+| `<cur>`, `<new>` | 지금 Claude Code 판과 새 판 | `2.1.300`, `2.1.302` | 새 판이 있을 때. 지금 판을 모르면 `claude→<new>` |
+
+- 조건이 맞지 않는 칸은 구분자 `|` 와 함께 빠진다.
+- 색
+  - `%` 는 70% 미만 초록, 85% 미만 노랑, 그 이상 분홍(256색 213)
+  - `<mb>` 는 32MB 대비 같은 기준
+- OMC 는 ctx 가 80% 를 넘으면 뒤에 `COMPRESS?`, `CRITICAL` 을 붙인다. 래퍼는 이 글자를 빼고 색으로만 보인다.
+- ralph, autopilot, `agents:<n>`(실행 중인 에이전트) 같은 OMC 상태 칸은 활성일 때만 `⚡<skills>` 와 `<cwd>` 사이에 흐리게 나온다.
+- 화면 폭을 넘으면 칸 사이에서 다음 줄로 넘어간다.
+- 둘째 줄부터는 OMC 의 상세 줄(에이전트 목록, todo, 경고)이다. OMC 와 Claude Code 의 갱신 안내 줄은 뺀다.
+- 첨부 HUD 설정은 OMC 출력을 8줄까지 둔다. 넘으면 OMC 가 상세 줄을 `... (+N lines)` 한 줄로 접는다.
 
 ## 0. 감지
+
+- `node -v` 로 Node 18 이상인지 본다. OMC 5.7.4 는 Node 20 이상을 적는다.
+- 설정 폴더는 `$CLAUDE_CONFIG_DIR`, 없으면 `~/.claude` 다.
+- OMC 가 설치돼 있어야 한다. 없으면 1단계가 멈추고 알린다.
+
+## 1. 적용
+
+모든 OS 에서 같은 명령이다.
+
+bash, zsh:
 ```bash
-case "$(uname -s)" in Darwin) OS=mac;; Linux) OS=linux;; *) OS=windows;; esac; echo "OS=$OS"
-command -v wget >/dev/null && echo "dl=wget" || { command -v curl >/dev/null && echo "dl=curl" || echo "dl=none(설치 필요)"; }
-# 적용 스크립트가 래퍼를 덮어쓰면 payload-mon 표시 블록이 빠진다. 지금 켜져 있는지 기억해 둔다(3단계에서 사용).
-HUD_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/hud/omc-hud-custom.mjs"
-grep -qF '// >>> payload-mon >>>' "$HUD_FILE" 2>/dev/null && echo "payload-mon=on" || echo "payload-mon=off"
+node "<이 스킬 디렉터리 절대경로>/assets/apply-hud.mjs"
 ```
-Windows(PowerShell)에서는 같은 확인을 이렇게 한다:
+
+PowerShell:
 ```powershell
-$cfg = if ($env:CLAUDE_CONFIG_DIR) { $env:CLAUDE_CONFIG_DIR } else { "$env:USERPROFILE\.claude" }
-if (Select-String -Quiet -SimpleMatch -LiteralPath "$cfg\hud\omc-hud-custom.mjs" -Pattern '// >>> payload-mon >>>' -ErrorAction SilentlyContinue) { "payload-mon=on" } else { "payload-mon=off" }
+node "<이 스킬 디렉터리 절대경로>\assets\apply-hud.mjs"
 ```
 
-## 1. mac / linux — apply 스크립트 적용
+- `[ok] statusLine -> node "<설정 폴더>/hud/omc-hud-custom.mjs"` 줄을 확인한다.
+- 기존 statusLine 이 다른 명령이었으면 `[..] statusLine ran ...` 줄이 나온다. 보고에 그대로 넣는다.
+- 종료 코드 1 이면 출력의 `[x]` 줄을 그대로 보고하고 멈춘다. 이때 바뀐 파일은 없다.
+  - `settings.json` 이 JSON 객체가 아니면 사용자가 고친 뒤 다시 실행한다.
+  - OMC 가 없으면 OMC 를 먼저 설치한다(`setup-omc` 스킬). 이 스킬은 OMC 를 설치하지 않는다.
+  - 설정 폴더 경로에 셸이 해석하는 글자가 있으면 그 글자가 없는 폴더를 쓰게 안내한다.
+  - 쓸 수 없는 파일이나 폴더가 있으면 권한을 고친 뒤 다시 실행한다.
+- 종료 코드 2 면 예기치 못한 오류로 중간에 멈춘 것이다. 출력을 그대로 보고하고, 바뀐 파일의 이전 판은 `<파일>.backup.<시각>` 에 있다고 알린다.
+
+## 2. payload-mon 켜기
+
+이전 상태와 상관없이 늘 실행한다.
+
 ```bash
-RAW=https://raw.githubusercontent.com/smallOpenSource/omc_hud/refs/heads/main
-mkdir -p ~/dummy && cd ~/dummy
-script=$([ "$OS" = mac ] && echo apply-hud-macos.sh || echo apply-hud-linux.sh)
-for f in "$script" apply-hud.mjs hud-config.json omc-hud-custom.mjs; do
-  if command -v wget >/dev/null; then wget -q "$RAW/$f"; else curl -fsSLO "$RAW/$f"; fi
-done
-chmod +x "$script" && "./$script"
-rm -f "$script" apply-hud.mjs hud-config.json omc-hud-custom.mjs   # 정리
-cd - >/dev/null
+node "<이 스킬 디렉터리 절대경로>/../payload-mon/scripts/payload-mon.mjs" on
 ```
 
-## 2. windows
-`wget`이 없는 경우가 많아 **프로젝트 통째로 받아 적용**한다:
-```powershell
-# git 있으면
-git clone https://github.com/smallOpenSource/omc_hud.git "$env:TEMP\omc_hud"; cd "$env:TEMP\omc_hud"
-# 저장소의 windows 적용 스크립트(apply-hud-*.ps1/.cmd) 또는 `node apply-hud.mjs` 안내를 따른다.
+- Codex 사본에서 실행할 때 경로는 `<이 스킬 디렉터리 절대경로>/../banker-payload-mon/scripts/payload-mon.mjs` 다.
+- 이유: `PL:` 칸은 payload-mon 이 래퍼 옆(`hud/payload-mon/`)에 두는 크기 계산 모듈을 쓴다. 모듈이 없으면 `PL:` 이 나오지 않는다.
+- 이 단계의 출력 "8MB 이상이면 ctx 옆에 payload가 표시됩니다" 는 옛 래퍼 기준이다. 그대로 옮기지 말고 "PL 칸에 쓰는 모듈을 설치함" 으로 보고한다.
+
+## 3. 보고
+
+- 1단계 출력의 statusLine 줄과 백업 경로
+- 2단계 결과
+- statusLine 이 바뀌었으면 Claude Code 재시작 안내
+
+## 인자 off, status
+
+옛 래퍼(v3)에 넣었던 Claude 갱신 안내 블록(`claude-update-last`)을 다룬다. v4 래퍼는 갱신 안내를 직접 줄 맨 끝에 두므로 새 설치에는 이 블록이 필요 없다.
+
+```bash
+node "<이 스킬 디렉터리 절대경로>/scripts/claude-update-last.mjs" off
 ```
-git 없으면 GitHub "Download ZIP" → 해제 → 동봉 적용 스크립트 실행.
-
-## 3. 검증·보고
-- 적용 스크립트가 `~/.claude/settings.json` 의 statusLine 등을 갱신했는지(스크립트 출력 확인).
-- HUD는 **다음 프롬프트/세션**부터 반영될 수 있음 → 안 보이면 재시작 안내.
-- `~/dummy` 임시파일 정리 확인. 이미 적용돼 있으면 재적용 불필요.
-- **payload-mon 복구**: 0단계에서 `payload-mon=on` 이었다면, 적용 스크립트가 래퍼를 덮어써 payload 표시 블록이 빠진 상태다.
-  payload-mon 스킬(Claude Code `/banker:payload-mon`, Codex `banker-payload-mon`)을 `on` 으로 실행해 다시 켜고, 그 결과를 함께 보고한다.
-  `payload-mon=off` 였다면 아무것도 하지 않는다(사용자가 켠 적 없는 기능을 켜지 않는다).
-- **Claude 갱신 안내 위치**: payload-mon 처리 뒤에 이 스킬의 스크립트를 `on` 으로 실행한다. 재적용을 건너뛴 경우에도 실행하고, Windows 도 같은 명령이다.
-  ```bash
-  node "<이 스킬 디렉터리 절대경로>/scripts/claude-update-last.mjs" on
-  ```
-  새 Claude Code 가 나오면 OMC 가 띄우는 `[Claude#2.1.288] -> 2.1.289 claude update` 를 상태표시줄 1번째 줄 맨 끝(OMC 표시 뒤)으로 옮긴다. 2번째 줄의 `[!] claude 2.1.289 - paste: ! claude update` 안내는 그대로 둔다.
-  출력을 그대로 보고한다. 종료 코드 1(거부)이면 래퍼는 바뀌지 않았으니 이유만 보고하고, 2(예기치 못한 오류로 중간에 멈춤)면 `status` 결과를 함께 보고한다.
-  되돌리기는 `off`, 상태 확인은 `status`.
+
+- `off` 는 블록을 뺀다. `status` 는 상태만 본다.
+- 출력을 그대로 보고한다. 종료 코드 1(거부)이면 래퍼는 바뀌지 않았으니 이유만 보고한다.
+- 종료 코드 2(예기치 못한 오류로 중간에 멈춤)면 `status` 결과를 함께 보고한다.
 
 ## 함정
-- `curl` 다운로드는 **대문자 `-O`**(원격 파일명 유지). 소문자 `-o`는 출력명 지정이라 다름.
-- raw URL 의 `refs/heads/main` 브랜치명이 바뀌면 404 → 저장소 확인.
-- `.mjs` 적용은 Node 필요(`node -v`).
-- `claude-update-last` 를 `off` 로 꺼 두었어도 이 스킬을 다시 실행하면 3단계에서 다시 켜진다. 래퍼가 정한 자리를 원하면 끝난 뒤 `off`.
-- 블록은 OMC 의 안내 문구(`[Claude#X] -> Y claude update`)로 안내를 찾는다. OMC 가 문구를 바꾸면 안내는 래퍼가 정한 자리에 남고, 상태표시줄은 깨지지 않는다.
-- 블록은 래퍼가 세그먼트를 합치는 줄에서 `segs`·`colored` 를 읽는다. 래퍼 구조가 바뀌어 그 줄에서 이 이름이 보이지 않으면 `on` 은 성공해도 효과가 없다(상태표시줄은 그대로). 새 Claude Code 가 나왔을 때 안내가 맨 끝에 오는지로 확인한다.
-- 이 블록은 플러그인 밖(`~/.claude/hud/`)에 남는다. 플러그인을 지우기 전에 `off` 를 실행한다.
+
+- 다시 설치하면 래퍼와 `hud-config.json` 을 첨부 파일로 덮어쓴다. 손으로 고친 내용은 `.backup.<시각>` 에만 남는다.
+- `settings.json` 의 `omcHud` 값은 `hud-config.json` 의 같은 키를 덮어쓴다. 래퍼가 기대는 아래 키를 바꾸면 칸이 달라지거나 OMC 원문이 그대로 나온다.
+  - `omcLabel`, `useBars`
+  - `maxWidth`, `maxOutputLines`
+  - `showCallCounts`, `callCountsFormat`
+  - `contextBar`, `gitBranch`
+- `payload-mon off` 를 실행하면 크기 계산 모듈이 지워져 `PL:` 칸도 사라진다. 다시 보려면 `payload-mon on`.
+- v4 에서 payload-mon 블록은 모듈을 깔기 위해서만 남는다. 갱신마다 크기 추정이 두 번 돌지만 두 번째는 캐시를 쓴다.
+- 래퍼를 손으로 고칠 때 `if (f.ctx) colored.push(colorCtx(f.ctx));` 줄을 지우지 않는다. 실행상 비어 있지만 `payload-mon on` 이 이 줄 바로 뒤에 블록을 넣는다.
+- 래퍼는 statusLine 프로세스가 받은 터미널 폭(stderr, stdout 의 `columns`, 그다음 `COLUMNS`)으로 줄을 접는다. 폭을 받지 못하면 한 줄로 나오고 Claude Code 가 끝을 자른다.
+- Claude Code 는 자기 화면이 터미널이면 그 폭과 높이를 `COLUMNS`, `LINES` 로 넘긴다(2.1.303 에서 확인). 그래서 보통은 접힌다.
+- 분홍은 256색 코드다. 256색을 못 쓰는 터미널에서는 기본 색으로 보인다.
+- statusLine 은 PATH 의 `node` 를 쓴다. GUI 로 띄운 Claude Code(macOS Dock, VS Code 확장)는 PATH 에 `/opt/homebrew/bin` 같은 폴더가 빠질 수 있다(추정). 상태표시줄이 안 나오면 PATH 를 확인한다.
+- 설정 폴더 경로에 `"`, 백틱, `$`, `%`, `\`, 줄바꿈이 있으면 설치 스크립트가 거부한다. statusLine 명령의 큰따옴표 안에서도 셸이 이 글자를 해석해, 명령이 깨지거나 경로 속 명령이 실행되기 때문이다.
+- 기존 statusLine 의 다른 필드(`padding`, `refreshInterval` 등)는 그대로 둔다. 다른 래퍼(smart-compact 등)가 감싼 명령은 이 래퍼의 명령으로 바뀐다. 이전 값은 `settings.json` 백업에 있다.
+- 갱신 안내는 OMC 의 문구 `[Claude#<cur>] -> <new> claude update` 로 찾는다. OMC 가 문구를 바꾸면 줄이지 못하고 원문이 경로 앞 칸에 남는다. 상태표시줄은 깨지지 않는다.
+- `[!] omc <ver> - paste: ` 와 `[!] claude <new> - paste: ` 로 시작하는 갱신 안내 줄은 뺀다. OMC 가 이 문구를 바꾸면 다시 보인다.
+- 설치는 네트워크를 쓰지 않는다. 다만 OMC 가 렌더할 때 네트워크로 얻는 정보(새 Claude Code 판 같은)는 오프라인에서 빠질 수 있다.
+- 래퍼, HUD 설정, 모듈 사본은 플러그인 밖(`<설정 폴더>/hud/`, `<설정 폴더>/.omc/`)에 있다. 플러그인을 지워도 상태표시줄은 남는다.
+- OMC 를 지울 때는 statusLine 도 지운다. OMC 로더는 플러그인을 못 찾으면 작업 폴더의 `node_modules` 에서 OMC HUD 를 찾아 불러오기 때문이다.

package/skills/setup-omc-hud/assets/LICENSE-omc_hud

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 smallOpenSource
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+/**
+ * apply-hud.mjs — cross-platform installer for the custom OMC HUD statusline.
+ *
+ * Installs into ${CLAUDE_CONFIG_DIR:-~/.claude}:
+ *   - hud/omc-hud.mjs        (OMC loader, copied from the installed plugin)
+ *   - hud/lib/config-dir.mjs (loader dependency)
+ *   - hud/omc-hud-custom.mjs (the custom compact/colored formatter)
+ *   - .omc/hud-config.json   (HUD preset/elements)
+ *   - settings.json          (statusLine -> the custom formatter; existing file backed up)
+ *
+ * Runs identically on Linux, macOS, and Windows (only needs node + an OMC install).
+ * Run it directly with `node apply-hud.mjs` on every OS; the templates are read
+ * from this file's folder, so nothing is downloaded.
+ *
+ * Based on smallOpenSource/omc_hud d3cedd5 (MIT, see LICENSE-omc_hud). Changes:
+ * statusLine path quoted; a settings.json that is not a JSON object is refused
+ * before any file changes (the original replaced it); UTF-8 BOM accepted;
+ * CLAUDE_CONFIG_DIR trimmed, "~" expanded and made absolute; formatter and HUD
+ * config backed up when they differ; 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.
+ * Exit 1 means nothing changed; exit 2 means an unexpected error stopped it partway.
+ */
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SELF = dirname(fileURLToPath(import.meta.url));
+// Same rules as OMC's getClaudeConfigDir: trim, expand a leading "~", then make
+// it absolute so statusLine works from any cwd.
+function configDir() {
+  const v = (process.env.CLAUDE_CONFIG_DIR || "").trim();
+  if (!v) return join(homedir(), ".claude");
+  if (v === "~") return homedir();
+  if (v.startsWith("~/") || v.startsWith("~\\")) return join(homedir(), v.slice(2));
+  return resolve(v);
+}
+const CONFIG_DIR = configDir().replace(/[\\/]+$/, "");
+const HUD_DIR = join(CONFIG_DIR, "hud");
+const OMC_DIR = join(CONFIG_DIR, ".omc");
+const settingsPath = join(CONFIG_DIR, "settings.json");
+const loaderDst = join(HUD_DIR, "omc-hud.mjs");
+const libDst = join(HUD_DIR, "lib", "config-dir.mjs");
+const wrapperDst = join(HUD_DIR, "omc-hud-custom.mjs");
+const configDst = join(OMC_DIR, "hud-config.json");
+// An absolute forward-slash path: Claude Code runs statusLine through a shell (Git Bash or
+// PowerShell on Windows) that treats backslashes as escapes.
+const cmdPath = wrapperDst.split(sep).join("/");
+const log = (m) => process.stdout.write(m + "\n");
+const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+const refuse = (lines) => {
+  for (const l of lines) log(l);
+  process.exit(1);
+};
+
+// 0. Check settings.json before touching anything, so a refusal leaves every
+//    file as it was. Refuse rather than replace: a fresh file would drop every
+//    other setting. A BOM (Windows editors) is dropped when the file is written
+//    back; the backup keeps the original bytes.
+let settings = {};
+let settingsRaw = null;
+if (existsSync(settingsPath)) {
+  settingsRaw = readFileSync(settingsPath, "utf8");
+  try {
+    settings = JSON.parse(settingsRaw.replace(/^\uFEFF/, ""));
+  } catch {
+    settings = undefined;
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+    refuse(["[x] Existing settings.json is not a JSON object; nothing changed. Fix it and re-run."]);
+  }
+}
+
+// Inside the command's double quotes these still act: a quote ends the path, $ and `
+// run what follows, %VAR% expands, a backslash escapes, a line break ends the command.
+if (/["`$%\\\r\n]/.test(cmdPath)) {
+  refuse([
+    '[x] The config folder path has a character the statusLine shell would act on (" ` $ % \\ or a line break); nothing changed.',
+    "    Use a config folder without it (CLAUDE_CONFIG_DIR).",
+  ]);
+}
+
+// 1. Resolve the installed OMC plugin root (for the canonical HUD loader template).
+function resolvePluginRoot() {
+  const lib = (r) => join(r, "scripts", "lib");
+  // The loader needs both files; a folder holding only one would leave hud/ half replaced.
+  const complete = (r) => existsSync(join(lib(r), "hud-wrapper-template.txt")) && existsSync(join(lib(r), "config-dir.mjs"));
+  const fromEnv = process.env.OMC_PLUGIN_ROOT;
+  // Only an absolute path: a relative one would be read from the project folder the command runs in.
+  if (fromEnv && isAbsolute(fromEnv) && complete(fromEnv)) return fromEnv;
+  const base = join(CONFIG_DIR, "plugins", "cache", "omc", "oh-my-claudecode");
+  if (!existsSync(base)) return null;
+  const SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([A-Za-z0-9.-]+))?$/;
+  // Newest first; a pre-release sorts below its release (5.7.4-beta < 5.7.4).
+  const newer = (a, b) => {
+    const x = a.match(SEMVER);
+    const y = b.match(SEMVER);
+    for (let i = 1; i <= 3; i++) if (+x[i] !== +y[i]) return +y[i] - +x[i];
+    if (!x[4] !== !y[4]) return x[4] ? 1 : -1;
+    return (y[4] || "").localeCompare(x[4] || "", undefined, { numeric: true });
+  };
+  const versions = readdirSync(base)
+    .filter((n) => SEMVER.test(n))
+    .sort(newer);
+  for (const v of versions) {
+    const r = join(base, v);
+    if (complete(r)) return r;
+  }
+  return null;
+}
+
+const pluginRoot = resolvePluginRoot();
+if (!pluginRoot && !existsSync(loaderDst)) {
+  refuse([
+    "[x] OMC plugin not installed and no existing hud/omc-hud.mjs found.",
+    "    Install OMC first, then re-run:",
+    "      /plugin install oh-my-claudecode   (or set OMC_PLUGIN_ROOT to an OMC version folder)",
+  ]);
+}
+
+// Every file this run writes or backs up, checked before the first write so that a
+// refusal changes nothing; a new file or backup needs its folder, or the nearest one
+// that exists, to take it.
+function unwritable() {
+  for (const p of [settingsPath, loaderDst, libDst, wrapperDst, configDst]) {
+    if (!existsSync(p)) continue;
+    try {
+      accessSync(p, constants.W_OK);
+    } catch (e) {
+      return `${p} (${e.code})`;
+    }
+  }
+  for (const dir of [CONFIG_DIR, HUD_DIR, join(HUD_DIR, "lib"), OMC_DIR]) {
+    let d = dir;
+    while (!existsSync(d) && dirname(d) !== d) d = dirname(d);
+    try {
+      accessSync(d, constants.W_OK);
+    } catch (e) {
+      return `${d} (${e.code})`;
+    }
+  }
+  return "";
+}
+const blocked = unwritable();
+if (blocked) refuse([`[x] Cannot write ${blocked}; nothing changed. Fix the permission and re-run.`]);
+
+// The statusline runs or reads these on every refresh, so no other account may change them.
+const FILE_MODE = 0o644;
+function writeOwned(file, data) {
+  writeFileSync(file, data, { mode: FILE_MODE });
+  if (process.platform !== "win32") chmodSync(file, FILE_MODE);
+}
+
+// Keep a timestamped copy, with its bytes and mode, of a file that differs from what replaces it.
+function backupIfDifferent(dst, next, label) {
+  if (!existsSync(dst)) return;
+  if (readFileSync(dst).equals(next)) return;
+  const keep = dst + ".backup." + stamp;
+  copyFileSync(dst, keep);
+  log(`[ok] Backed up ${label} -> ${keep}`);
+}
+
+// 2. Ensure target directories exist, then copy the loader.
+function installLoader() {
+  for (const d of [join(HUD_DIR, "lib"), OMC_DIR]) mkdirSync(d, { recursive: true, mode: 0o755 });
+  if (!pluginRoot) {
+    log("[..] OMC plugin root not found; keeping existing hud/omc-hud.mjs");
+    return;
+  }
+  writeOwned(loaderDst, readFileSync(join(pluginRoot, "scripts", "lib", "hud-wrapper-template.txt")));
+  writeOwned(libDst, readFileSync(join(pluginRoot, "scripts", "lib", "config-dir.mjs")));
+  log("[ok] OMC HUD loader installed from " + pluginRoot);
+}
+
+// 3. Install the custom formatter and HUD config from the bundled templates.
+//    Files that differ from the templates (local edits, blocks added by
+//    payload-mon / claude-update-last) are kept as timestamped backups first.
+function installTemplates() {
+  const wrapperSrc = readFileSync(join(SELF, "omc-hud-custom.mjs"));
+  const configSrc = readFileSync(join(SELF, "hud-config.json"));
+  backupIfDifferent(wrapperDst, wrapperSrc, "previous formatter");
+  backupIfDifferent(configDst, configSrc, "previous HUD config");
+  writeOwned(wrapperDst, wrapperSrc);
+  writeOwned(configDst, configSrc);
+  log("[ok] Custom formatter -> " + wrapperDst);
+  log("[ok] HUD config       -> " + configDst);
+}
+
+// 4. Point settings.json statusLine at the custom formatter; its other fields (padding, ...) stay.
+const objectOr = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
+function pointStatusLine() {
+  if (settingsRaw !== null) {
+    const backup = settingsPath + ".backup." + stamp;
+    copyFileSync(settingsPath, backup); // the original bytes and mode
+    log("[ok] Backed up settings.json -> " + backup);
+  }
+  // Quoted so a config dir with spaces (C:/Users/First Last/.claude) still runs.
+  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)`);
+  }
+  settings.statusLine = { ...prior, type: "command", command };
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  log("[ok] statusLine -> " + command);
+}
+
+try {
+  installLoader();
+  installTemplates();
+  pointStatusLine();
+} catch (e) {
+  log(`[x] Stopped partway (${e.code || e.message}); some files may have changed.`);
+  log(`    A replaced file's earlier version is in <file>.backup.${stamp}.`);
+  process.exit(2);
+}
+
+log("");
+log("Done. Restart Claude Code to load the new statusline.");

package/skills/setup-omc-hud/assets/hud-config.json

@@ -0,0 +1,53 @@
+{
+  "preset": "full",
+  "labels": {
+    "thinking": "think"
+  },
+  "elements": {
+    "omcLabel": true,
+    "updateNotification": true,
+    "model": true,
+    "modelFormat": "versioned",
+    "cwd": true,
+    "cwdFormat": "absolute",
+    "useHyperlinks": false,
+    "gitRepo": false,
+    "gitBranch": true,
+    "gitStatus": false,
+    "ralph": true,
+    "autopilot": true,
+    "prdStory": true,
+    "activeSkills": false,
+    "lastSkill": false,
+    "contextBar": true,
+    "agents": true,
+    "agentsFormat": "multiline",
+    "backgroundTasks": true,
+    "todos": true,
+    "thinking": true,
+    "thinkingFormat": "text",
+    "permissionStatus": false,
+    "apiKeySource": false,
+    "profile": false,
+    "promptTime": false,
+    "sessionHealth": true,
+    "showSessionDuration": true,
+    "showHealthIndicator": false,
+    "useBars": false,
+    "showCallCounts": true,
+    "callCountsFormat": "emoji",
+    "safeMode": true,
+    "maxOutputLines": 8
+  },
+  "thresholds": {
+    "contextWarning": 70,
+    "contextCompactSuggestion": 80,
+    "contextCritical": 85,
+    "ralphWarning": 7
+  },
+  "staleTaskThresholdMinutes": 30,
+  "contextLimitWarning": {
+    "threshold": 80,
+    "autoCompact": false
+  }
+}

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

@@ -0,0 +1,545 @@
+#!/usr/bin/env node
+/**
+ * OMC HUD custom formatter (wrapper) — v4
+ *
+ * Runs the canonical OMC HUD (omc-hud.mjs), then reformats its rendered line
+ * into a compact pipe-delimited layout requested by the user:
+ *
+ *   <model>/<effort>|5h:<pct>/<reset>|wk:<pct>/<reset>|<mm>:<pct>/<reset>|think|PL:<mb>M|se:<hours>h|ctx:<pct>%|🤖<agents>|🔧<tools>|⚡<skills>|<cwd>|<account>|<branch>|claude<cur>→<new>
+ *   e.g. Op5.5/high|5h:8%/1h23m|wk:96%/1h23m|Fa:0%/1h23m|think|PL:0.4M|se:0.4h|ctx:12%|🤖1|🔧14|⚡3|...
+ *
+ * Changes vs v3:
+ *   - OMC 5.x wraps at the terminal width; the width is hidden from OMC and the
+ *     wrapper wraps the compact line itself at segment boundaries (no "…").
+ *   - effort:<level> badge dropped; session -> se:<hours, 1 decimal>h.
+ *   - ctx:<pct>% comes right after se, without OMC's " COMPRESS?" / " CRITICAL"
+ *     words (the color shows the level).
+ *   - OMC's call counts ("🔧14 🤖1 ⚡3") are shown agents, tools, skills, one
+ *     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.
+ *   - 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").
+ *   - Claude Code update notice "[Claude#2.1.300] -> 2.1.302 claude update" ->
+ *     "claude2.1.300→2.1.302", shown last. A claude-update-last block has
+ *     nothing left to move.
+ *   - >=85% is pink (256-color 213) instead of red.
+ *   - Blocks added by `payload-mon on` / `claude-update-last on` are not part of
+ *     this file; those tools insert them.
+ *
+ * Why a wrapper: OMC's render.js hardcodes " | " separators, the "[...]" label
+ * brackets, the "Model: " prefix, the "percent(time)" rate layout and the
+ * "session:Nm" label. None are configurable, so we transform the final text.
+ * All data (usage %, reset times, tool counts, cwd) still comes from OMC.
+ *
+ * Defensive: on any parse failure it prints OMC's raw output unchanged, so the
+ * statusline never breaks if OMC's format changes after an update.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Changes vs v1 (formatting logic below is byte-identical to v1 on purpose):
+ *
+ *   1. The canonical HUD runs IN THIS PROCESS instead of via spawnSync, so a
+ *      statusline refresh costs one node process instead of two. Windows charges
+ *      kernel paged pool per process creation (fltmgr FMfn name-cache node), and
+ *      on this machine that accumulation is not reclaimable short of a reboot.
+ *
+ *   2. Every unbounded wait now has a time budget. v1 could block forever in two
+ *      places with no timeout: readFileSync(0) waiting for stdin EOF, and
+ *      spawnSync waiting on the child. Both are SYNCHRONOUS, so a setTimeout
+ *      watchdog cannot fire while they block — the event loop is not running.
+ *      A stalled instance never dies, and the next refresh spawns another, so
+ *      they accumulate linearly. Both are now async and bounded.
+ *
+ * Timer discipline comes from a 3-OS reproduction documented in
+ * .omc/wiki/bounding-a-hanging-dynamic-import-in-node.md:
+ *   - the budget timer stays REF'd: an unref'd timer never fires when Node bails
+ *     out of an unsettled top-level await with exit 13,
+ *   - the self-exit timer is UNREF'd: it must not hold a healthy process open,
+ *     and when something really is hung the loop is alive so it still fires,
+ *   - the budget is 10s, not 3s: a tight budget silently discards work that was
+ *     merely slow, without saving any time (the hung import holds the loop anyway).
+ *
+ * 🔴 omc-hud.mjs ends with a bare `main();` — no await. Module evaluation
+ *    therefore completes BEFORE any output is produced. Awaiting the import
+ *    alone captures nothing (that is why v2 printed "[OMC HUD] no output").
+ *    We wait for the first complete line instead.
+ */
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } 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");
+
+const STDIN_TIMEOUT_MS = 2000; // Claude Code pipes the payload immediately
+const RENDER_TIMEOUT_MS = 10000; // see timer discipline note above
+const SPAWN_TIMEOUT_MS = 8000; // fallback path only
+const EXIT_GRACE_MS = 2000;
+const HARD_EXIT_MS = 20000;
+
+// Last-resort guard: if any path leaves us alive past this, end voluntarily.
+// unref'd so a healthy render is never held open by it.
+{
+  const g = setTimeout(() => {
+    try {
+      process.stdout.write("\n");
+    } catch {
+      /* stdout already gone */
+    }
+    process.exit(0);
+  }, HARD_EXIT_MS);
+  if (g && g.unref) g.unref();
+}
+
+// Print and terminate. The canonical HUD ran in-process, so its own async work
+// may still be pending on the event loop; once our line is out there is nothing
+// left to wait for. The write callback is the flush-safe exit point, and the
+// unref'd timer covers the case where the callback never arrives.
+// Only the first call prints: the fallback path may emit and then fall through
+// to the formatter, whose passthrough catch would print a second line.
+let emitted = false;
+function emit(s) {
+  if (emitted) return;
+  emitted = true;
+  try {
+    process.stdout.write(s, () => process.exit(0));
+  } catch {
+    process.exit(0);
+  }
+  const k = setTimeout(() => process.exit(0), EXIT_GRACE_MS);
+  if (k && k.unref) k.unref();
+}
+
+// Currently logged-in Claude account: the part of the email before "@".
+// Read from <config home>/.claude.json (oauthAccount.emailAddress) via a light
+// regex so we don't JSON.parse the whole config every render. Claude Code keeps
+// 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();
+  if (v === "~") return homedir();
+  if (v.startsWith("~/") || v.startsWith("~\\")) return join(homedir(), v.slice(2));
+  return v;
+}
+function loginAccount() {
+  try {
+    const raw = readFileSync(join(claudeJsonDir(), ".claude.json"), "utf8");
+    const m = raw.match(/"emailAddress"\s*:\s*"([^"@]+)@/);
+    return m ? m[1] : "";
+  } catch {
+    return "";
+  }
+}
+
+// Read the statusline JSON Claude Code pipes on stdin, bounded.
+// A TTY means a human ran this by hand — there is no EOF coming, so skip it
+// entirely rather than hang waiting for one.
+function readStdinBounded(ms) {
+  if (process.stdin.isTTY) return Promise.resolve("");
+  return new Promise((resolve) => {
+    let data = "";
+    let done = false;
+    const onData = (c) => {
+      data += c;
+    };
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(t);
+      process.stdin.removeListener("data", onData);
+      process.stdin.removeListener("end", finish);
+      process.stdin.removeListener("error", finish);
+      try {
+        process.stdin.pause();
+      } catch {
+        /* already closed */
+      }
+      resolve(data);
+    };
+    const t = setTimeout(finish, ms); // ref'd on purpose
+    try {
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", onData);
+      process.stdin.once("end", finish);
+      process.stdin.once("error", finish);
+    } catch {
+      finish();
+    }
+  });
+}
+
+const input = await readStdinBounded(STDIN_TIMEOUT_MS);
+
+// Current reasoning effort level (low/medium/high/xhigh) from the statusline
+// payload (effort.level) — shown next to the model. Empty if absent.
+let effort = "";
+try {
+  effort = String(JSON.parse(input)?.effort?.level || "");
+} catch {
+  /* no/invalid stdin JSON */
+}
+
+// Run the canonical HUD in-process, capturing what it writes to stdout.
+// Resolves on the first complete line (see the `main();` note in the header),
+// or when the budget expires — whichever comes first.
+//
+// 🔴 The HUD DOES read stdin — dist/hud/stdin.js readStdin() async-iterates
+//    process.stdin (it is not readFileSync(0)). We already drained the real fd,
+//    so without replaying the payload the HUD sees empty input and prints its
+//    "HUD installed / statusLine configured" info screen instead of a
+//    statusline. Swapping process.stdin for a stream carrying the same bytes
+//    restores identical behaviour to the spawnSync path, which fed the child
+//    through its stdin.
+// What the HUD writes to stdout is collected instead of printed; `onLine` runs
+// once a full line is in.
+function captureStdout(onLine) {
+  const origWrite = process.stdout.write.bind(process.stdout);
+  let captured = "";
+  process.stdout.write = (chunk, enc, cb) => {
+    captured += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    const done = typeof enc === "function" ? enc : cb;
+    if (typeof done === "function") done();
+    if (captured.includes("\n")) onLine();
+    return true;
+  };
+  return {
+    text: () => captured,
+    restore: () => {
+      process.stdout.write = origWrite;
+    },
+  };
+}
+
+async function renderInProcess(ms) {
+  const origStdin = Object.getOwnPropertyDescriptor(process, "stdin");
+  let settleFirstLine;
+  const firstLine = new Promise((r) => {
+    settleFirstLine = r;
+  });
+
+  const replay = Readable.from(input ? [input] : []);
+  replay.isTTY = false; // must stay falsy or readStdin() bails out early
+  try {
+    Object.defineProperty(process, "stdin", { value: replay, configurable: true });
+  } catch {
+    /* leave the real stdin in place; the fallback path still works */
+  }
+
+  const out = captureStdout(settleFirstLine);
+  let budgetTimer;
+  const budget = new Promise((r) => {
+    budgetTimer = setTimeout(r, ms); // ref'd on purpose
+  });
+
+  try {
+    await Promise.race([
+      (async () => {
+        await import(pathToFileURL(HUD).href);
+        await firstLine;
+      })(),
+      budget,
+    ]);
+  } finally {
+    clearTimeout(budgetTimer);
+    out.restore();
+    // Restore the real stdin so the spawnSync fallback below behaves normally.
+    if (origStdin) {
+      try {
+        Object.defineProperty(process, "stdin", origStdin);
+      } catch {
+        /* not restorable; we exit right after anyway */
+      }
+    }
+  }
+  return out.text();
+}
+
+// OMC 5.x wraps its line at the terminal width (index.js: stderr/stdout
+// columns, then $COLUMNS). Wrapped tails land below the OMC# line, where this
+// wrapper passes them through raw ("session:9m | ctx:12% | 🔧12"). The wrapper
+// does its own compaction, so hide the width and let OMC emit one line.
+// The width is read first: the wrapper wraps the compact line itself at the
+// end, so Claude Code does not cut the tail off with "…".
+const TERM_COLS =
+  process.stderr.columns || process.stdout.columns || parseInt(process.env.COLUMNS ?? "0", 10) || 0;
+delete process.env.COLUMNS; // also keeps the spawnSync fallback unwrapped
+for (const s of [process.stdout, process.stderr]) {
+  try {
+    Object.defineProperty(s, "columns", { value: undefined, configurable: true });
+  } catch {
+    /* not overridable; OMC may wrap and the tail stays below */
+  }
+}
+
+let raw = "";
+try {
+  raw = (await renderInProcess(RENDER_TIMEOUT_MS)).replace(/\r/g, "");
+} catch {
+  raw = ""; // fall through to the child-process path
+}
+
+if (!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
+  // import-safe. Bounded, unlike v1.
+  const res = spawnSync(process.execPath, [HUD], {
+    input,
+    encoding: "utf8",
+    timeout: SPAWN_TIMEOUT_MS,
+    killSignal: "SIGKILL",
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  raw = (res.stdout || "").replace(/\r/g, "");
+  if (!raw.trim()) {
+    emit(((res.stderr || "").trim() || "[OMC HUD] no output") + "\n");
+  }
+}
+
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+
+// Terminal columns of a string: ANSI is free, CJK and emoji take two columns,
+// variation selectors and ZWJ take none.
+const WRAP_MARGIN = 4;
+// BMP emoji drawn two columns wide (East Asian Width W), e.g. ⚡ in OMC's call counts.
+const WIDE_BMP_EMOJI = [
+  [0x231a, 0x231b], [0x23e9, 0x23ec], [0x23f0, 0x23f0], [0x23f3, 0x23f3],
+  [0x25fd, 0x25fe], [0x2614, 0x2615], [0x2648, 0x2653], [0x267f, 0x267f],
+  [0x2693, 0x2693], [0x26a1, 0x26a1], [0x26aa, 0x26ab], [0x26bd, 0x26be],
+  [0x26c4, 0x26c5], [0x26ce, 0x26ce], [0x26d4, 0x26d4], [0x26ea, 0x26ea],
+  [0x26f2, 0x26f3], [0x26f5, 0x26f5], [0x26fa, 0x26fa], [0x26fd, 0x26fd],
+  [0x2705, 0x2705], [0x270a, 0x270b], [0x2728, 0x2728], [0x274c, 0x274c],
+  [0x274e, 0x274e], [0x2753, 0x2755], [0x2757, 0x2757], [0x2795, 0x2797],
+  [0x27b0, 0x27b0], [0x27bf, 0x27bf], [0x2b1b, 0x2b1c], [0x2b50, 0x2b50],
+  [0x2b55, 0x2b55],
+];
+// Every two-column range: Hangul Jamo, the emoji above, CJK, Hangul syllables, CJK compatibility and
+// forms, fullwidth forms, the emoji planes and the supplementary ideographs.
+const WIDE_RANGES = [
+  [0x1100, 0x115f], ...WIDE_BMP_EMOJI, [0x2e80, 0xa4cf], [0xac00, 0xd7a3], [0xf900, 0xfaff], [0xfe30, 0xfe4f],
+  [0xff00, 0xff60], [0xffe0, 0xffe6], [0x1f300, 0x1faff], [0x20000, 0x10ffff],
+];
+const isWide = (c) => WIDE_RANGES.some(([lo, hi]) => c >= lo && c <= hi);
+const visibleWidth = (s) => {
+  let w = 0;
+  for (const ch of stripAnsi(s)) {
+    const c = ch.codePointAt(0);
+    if (c === 0x200d || (c >= 0xfe00 && c <= 0xfe0f)) continue;
+    w += isWide(c) ? 2 : 1;
+  }
+  return w;
+};
+
+// Color helpers — we strip OMC's ANSI to parse, then re-apply our own so the
+// statusline is highlighted. Threshold scale (usage/context %): green<70,
+// yellow<85, pink>=85 (pink replaces red on request). Pipes and path are
+// dimmed; model name cyan, effort yellow.
+const A = (c, s) => `\x1b[${c}m${s}\x1b[0m`;
+const SEP = "\x1b[2m|\x1b[0m";
+const PINK = "38;5;213";
+const pc = (n) => (n >= 85 ? PINK : n >= 70 ? "33" : "32");
+const colorRate = (seg) => {
+  const m = seg.match(/^(\w+):(\d+)%\/(.+)$/);
+  return m ? `${m[1]}:${A(pc(+m[2]), m[2] + "%")}\x1b[2m/\x1b[0m${A("36", m[3])}` : seg;
+};
+const colorCtx = (seg) => {
+  const m = seg.match(/^ctx:(\d+)%$/);
+  return m ? `ctx:${A(pc(+m[1]), m[1] + "%")}` : seg;
+};
+const colorModel = (seg) => {
+  const m = seg.match(/^(.+?)\/(\w+)$/);
+  return m ? `${A("36", m[1])}\x1b[2m/\x1b[0m${A("33", m[2])}` : A("36", seg);
+};
+const colorSe = (seg) => {
+  const m = seg.match(/^se:(.+)$/);
+  return m ? `se:${A("33", m[1])}` : seg;
+};
+// Per-model usage badge ("fable:0%") rides along in the rate group and has no
+// dedicated field. Shorten the model name to two letters so it matches the
+// model token's own convention (Opus 4.8 -> Op4.8): fable:0% -> Fa:0%.
+// OMC appends a stale marker and/or a reset time to scoped weekly buckets
+// (renderRateLimits in dist/hud/elements/limits.js), so the pattern must not
+// anchor at "%": keep that tail intact -> fable:0%(3d3h) -> Fa:0%(3d3h).
+const shortModelPct = (seg) => {
+  const m = seg.match(/^([A-Za-z][A-Za-z0-9.-]*):(\d+%\*?(?:\([^)]*\))?)$/);
+  return m ? `${m[1][0].toUpperCase()}${m[1].slice(1, 2).toLowerCase()}:${m[2]}` : seg;
+};
+
+try {
+  const lines = raw.split("\n").map(stripAnsi).filter((l) => l.length);
+  const mainIdx = lines.findIndex((l) => l.includes("OMC#"));
+  if (mainIdx === -1) throw new Error("no OMC line");
+
+  const main = lines[mainIdx];
+  const pathLine = lines.slice(0, mainIdx).join(" ").trim(); // cwd (+git) group above
+  // Detail lines (agent tree, warnings) are kept as-is, except OMC's update
+  // hints ("[!] omc 5.7.5 - paste: ! claude plugin ...", "[!] claude 2.1.302 -
+  // paste: ! claude update"): the OMC version is not wanted here, and the Claude
+  // Code update already shows as claude<cur>→<new> on the main line.
+  const UPDATE_HINT = /^\[!\] (?:omc|claude) \S+ - paste: /;
+  const below = lines.slice(mainIdx + 1).filter((l) => !UPDATE_HINT.test(l.trim()));
+
+  // Collapse " | " -> "|", then split into segments.
+  const rawSegs = main
+    .replace(/\s*\|\s*/g, "|")
+    .split("|")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  // The 5h/wk/sn rate windows live in one space-separated segment; expand them.
+  // The per-model usage badge ("fable:0%") arrives inside that same segment, so
+  // remember which pieces came from there. Only those get abbreviated later —
+  // unrelated badges that also land in `extra` must be left alone.
+  const segs = [];
+  const rateGroup = new Set();
+  // OMC's Claude Code update notice ("[Claude#2.1.300] -> 2.1.302 claude update",
+  // render.js claudeLabel) is shortened to "claude2.1.300→2.1.302" and shown last.
+  // It is taken out of segs, so a claude-update-last block (which looks for the
+  // long form in segs) finds nothing to move.
+  const UPDATE_NOTICE = /^\[Claude(?:#([^\]]*))?\]\s*->\s*(\S+)\s+claude\s+update\b/;
+  let update = "";
+  for (const s of rawSegs) {
+    const um = s.match(UPDATE_NOTICE);
+    if (um) {
+      update = `claude${um[1] || ""}→${um[2]}`;
+    } else if (/\b(5h|wk|sn):/.test(s) && /\s/.test(s)) {
+      for (const p of s.split(/\s+/)) {
+        if (!p) continue;
+        segs.push(p);
+        if (!/^(5h|wk|sn):/.test(p)) rateGroup.add(p);
+      }
+    } else {
+      segs.push(s);
+    }
+  }
+
+  // Without effort.level on stdin, take the level from OMC's effort badge.
+  if (!effort) {
+    const badge = segs.find((s) => /^effort:\S/.test(s));
+    if (badge) effort = badge.slice("effort:".length).trim();
+  }
+
+  const f = { label: "", model: "", r5: "", rwk: "", rsn: "", think: "", ctx: "", se: "", counts: "" };
+  let ctxShown = ""; // the ctx segment shown after se; f.ctx stays empty (see the ctx line below)
+  const extra = [];
+  const modelRates = []; // per-model usage badges, shown right after the rate windows
+  const slash = (s) => s.replace(/%\(([^)]+)\)/, "%/$1"); // 6%(3h56m) -> 6%/3h56m
+
+  for (const s of segs) {
+    if (/^\[?OMC#/.test(s)) {
+      const m = s.match(/OMC#([0-9][0-9.]*)/);
+      f.label = m ? `OMC#${m[1]}` : s; // drop brackets + trailing "L"
+    } else if (/^Model:/.test(s) || /^(Opus|Sonnet|Haiku)\b/.test(s)) {
+      const m = s.match(/(?:Model:\s*)?([A-Za-z]+)\s*([0-9][0-9.]*)/);
+      // Opus 4.8 -> Op4.8/high; an unknown id (Model: claude-x-5) keeps its name.
+      const name = m ? `${m[1].slice(0, 2)}${m[2]}` : s.replace(/^Model:\s*/, "");
+      f.model = `${name}${effort ? "/" + effort : ""}`;
+    } else if (/^5h:/.test(s)) {
+      f.r5 = slash(s);
+    } else if (/^wk:/.test(s)) {
+      f.rwk = slash(s);
+    } else if (/^sn:/.test(s)) {
+      f.rsn = slash(s);
+    } else if (/^think/i.test(s)) {
+      f.think = "think";
+    } else if (/^effort:/.test(s)) {
+      // OMC 5.x effort badge; the level already rides on the model (Op5.5/high).
+    } else if (/^ctx:/.test(s)) {
+      // "ctx:82% COMPRESS?" -> "ctx:82%": the color already says how full it is.
+      const m = s.match(/^ctx:(\d+)%/);
+      ctxShown = m ? `ctx:${m[1]}%` : s;
+    } else if (/^session:/.test(s)) {
+      const m = s.match(/session:(\d+)m/);
+      f.se = m ? `se:${(parseInt(m[1], 10) / 60).toFixed(1)}h` : s.replace(/^session:/, "se:");
+    } else if (/🔧|🤖|⚡/.test(s) || /^[TAS]:\d/.test(s)) {
+      f.counts = s;
+    } else {
+      if (rateGroup.has(s)) modelRates.push(slash(shortModelPct(s))); // fable:0%(1h31m) -> Fa:0%/1h31m
+      else extra.push(s); // dynamic badges: todos, ralph, autopilot, bg, skill, etc.
+    }
+  }
+
+  const colored = [];
+  if (f.model) colored.push(colorModel(f.model));
+  if (f.r5) colored.push(colorRate(f.r5));
+  if (f.rwk) colored.push(colorRate(f.rwk));
+  if (f.rsn) colored.push(colorRate(f.rsn));
+  for (const r of modelRates) colored.push(colorRate(r));
+  if (f.think) colored.push(A("36", f.think));
+  // Keep the next line: f.ctx is always empty now (ctx is shown after se), but
+  // `payload-mon on` inserts its block right after this exact line, ahead of PL.
+  if (f.ctx) colored.push(colorCtx(f.ctx));
+  // PL: payload size always shown before se, as "PL:0.3M" (MB, one decimal),
+  // colored by its share of the 32MB limit. Replaces the payload-mon segment,
+  // which only appears from 8MB on. Reuses payload-mon's module copy and cache;
+  // 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 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);
+        const pct = Math.floor((bytes / REQUEST_LIMIT_BYTES) * 100);
+        colored.push(`PL:${A(pc(pct), (bytes / (1024 * 1024)).toFixed(1) + "M")}`);
+      }
+    }
+  } catch {
+    /* no stdin JSON, unreadable transcript or module missing */
+  }
+  if (f.se) colored.push(colorSe(f.se));
+  if (ctxShown) colored.push(colorCtx(ctxShown));
+  // OMC prints "🔧14 🤖1 ⚡3" ("T:14 A:1 S:3" in ASCII) and leaves out a zero count.
+  // Show agents, tools, skills, one segment each; anything else keeps its place after them.
+  if (f.counts) {
+    const rank = (p) => (/^(?:🤖|A:)/u.test(p) ? 0 : /^(?:🔧|T:)/u.test(p) ? 1 : /^(?:⚡|S:)/u.test(p) ? 2 : 3);
+    colored.push(...f.counts.trim().split(/\s+/).sort((a, b) => rank(a) - rank(b)));
+  }
+  for (const e of extra) colored.push(A("2", e));
+  // OMC's cwd group is "cwd | branch:x | ...": keep the cwd parts here with "|",
+  // and move the branch (without its "branch:" label) right before OMC#.
+  let branch = "";
+  const pathParts = pathLine
+    .split(/\s*\|\s*/)
+    .map((p) => p.trim())
+    .filter((p) => {
+      const m = p.match(/^branch:\s*(.+)$/);
+      if (m) branch = m[1];
+      return p && !m;
+    });
+  for (const p of pathParts) colored.push(A("36", p));
+  const acct = loginAccount();
+  if (acct) colored.push(A("92", acct));
+  if (branch) colored.push(A("36", branch));
+  // The OMC#X.Y.Z label is parsed (it marks OMC's main line) but not shown.
+  if (update) colored.push(A("2", update));
+
+  let result = colored.join(SEP);
+  // Wrap at segment boundaries instead of letting Claude Code truncate the tail.
+  // WRAP_MARGIN leaves room for the indent Claude Code puts before the line.
+  if (TERM_COLS > WRAP_MARGIN + 20) {
+    const max = TERM_COLS - WRAP_MARGIN;
+    const rows = [];
+    let row = "";
+    for (const seg of colored) {
+      if (row && visibleWidth(row) + 1 + visibleWidth(seg) > max) {
+        rows.push(row);
+        row = seg;
+      } else {
+        row = row ? row + SEP + seg : seg;
+      }
+    }
+    if (row) rows.push(row);
+    result = rows.join("\n");
+  }
+  if (below.length) result += "\n" + below.join("\n");
+  emit(result + "\n");
+} catch {
+  emit(raw.endsWith("\n") ? raw : raw + "\n"); // safe passthrough
+}

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

@@ -28,7 +28,7 @@
 import { spawnSync } from "node:child_process";
 import { accessSync, constants, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const OPEN = "// >>> claude-update-last >>>";
@@ -42,7 +42,16 @@ const JOIN_LINE = /^ {2}let result = colored\.join\(SEP\);\r?$/gm;
 // What the block reads at that line, all in the wrapper's own scope there.
 const NAMES = [/\bconst segs\b/, /\bconst colored\b/, /\bconst stripAnsi\b/, /\bconst A = /];
 
-const CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+// The same rules as ../assets/apply-hud.mjs (OMC's getClaudeConfigDir): trim, expand a leading "~",
+// make it absolute, drop a trailing separator, so this finds the wrapper the installer wrote.
+function configDir() {
+  const v = (process.env.CLAUDE_CONFIG_DIR || "").trim();
+  if (!v) return join(homedir(), ".claude");
+  if (v === "~") return homedir();
+  if (v.startsWith("~/") || v.startsWith("~\\")) return join(homedir(), v.slice(2));
+  return resolve(v);
+}
+const CONFIG_DIR = configDir().replace(/[\\/]+$/, "");
 
 const DEFAULTS = {
   hudFile: process.env.CLAUDE_UPDATE_LAST_HUD_FILE || join(CONFIG_DIR, "hud", "omc-hud-custom.mjs"),