@kaydash9999/banker-plugins 0.13.0 → 0.15.0

package/skills/setup-bypass-permissions/scripts/fallback/bypass-permissions.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""setup-bypass-permissions step 3 on macOS and Linux, for when node cannot run the main script.
+
+    python3 bypass-permissions.py on --yes   set permissions.defaultMode = "bypassPermissions"
+    python3 bypass-permissions.py off        remove that key (Claude Code's default start mode)
+
+The file is <config>/settings.json, <config> being $CLAUDE_CONFIG_DIR or ~/.claude. Every other
+key stays, and so does a BOM. `on` keeps the text from before in settings.json.bypass-permissions.bak,
+readable by this account alone; a second `on` finds the mode set and writes nothing. Both files are
+replaced whole through a temp file and a rename, so a stop partway leaves the old text, and a link at
+the settings name stays a link. Only the node script's `off` knows what `on` replaced; this `off`
+removes the key.
+
+`on` refuses (exit 1, nothing written) where Claude Code would not honour the mode or not start with
+it: managed policy (managed-settings.json or its managed-settings.d drop-ins) or the settings file
+itself sets permissions.disableBypassPermissionsMode, or the account is root outside a sandbox Claude
+Code recognises (IS_SANDBOX=1, or its bubblewrap one). It also refuses a file that is not a JSON object,
+a policy file or folder this account cannot read, and a machine with no Claude Code config folder.
+
+Exit status: 0 done, or nothing to do. 1 refused. 2 unexpected error. 3 this account may not write
+the file or its folder. Every result ends with the line `settings file: <path>` on stdout.
+Python 3.6 or later.
+"""
+import errno
+import json
+import os
+import sys
+import tempfile
+
+MODE = "bypassPermissions"
+BOM = b"\xef\xbb\xbf"
+POLICY_HOMES = {"darwin": "/Library/Application Support/ClaudeCode"}
+
+
+class Refused(Exception):
+    pass
+
+
+def settings_path():
+    config = os.environ.get("CLAUDE_CONFIG_DIR") or os.path.expanduser("~/.claude")
+    return os.path.join(config, "settings.json")
+
+
+def policy_home():
+    # The override exists for this skill's tests alone.
+    if os.environ.get("BANKER_BYPASS_TEST") == "1" and os.environ.get("BANKER_BYPASS_POLICY_HOME"):
+        return os.environ["BANKER_BYPASS_POLICY_HOME"]
+    return POLICY_HOMES.get(sys.platform, "/etc/claude-code")
+
+
+def forbids(data):
+    perm = data.get("permissions") if isinstance(data, dict) else None
+    value = perm.get("disableBypassPermissionsMode") if isinstance(perm, dict) else None
+    return value is True or value == "disable"
+
+
+# A policy path that is not there, or is not a file of that kind: no policy, not a failure.
+ABSENT = (errno.ENOENT, errno.ENOTDIR, errno.EISDIR)
+
+
+def unreadable_policy(path):
+    return Refused("this machine's managed policy cannot be read (" + path + "); ask the administrator whether it allows the mode")
+
+
+def policy_files():
+    """The managed settings file and its drop-ins, in the order Claude Code reads them."""
+    home = policy_home()
+    files = [os.path.join(home, "managed-settings.json")]
+    drop = os.path.join(home, "managed-settings.d")
+    try:
+        names = os.listdir(drop)
+    except OSError as e:
+        if e.errno not in ABSENT:
+            raise unreadable_policy(drop)
+        names = []
+    files += [os.path.join(drop, n) for n in sorted(n for n in names if n.endswith(".json") and not n.startswith("."))]
+    return files
+
+
+def policy_block():
+    """The policy file that forbids the mode, or ""; Refused for a policy this account cannot read."""
+    for path in policy_files():
+        try:
+            with open(path, "rb") as handle:
+                raw = handle.read()
+        except OSError as e:
+            if e.errno in ABSENT:
+                continue
+            raise unreadable_policy(path)
+        try:
+            if forbids(json.loads(raw.decode("utf-8-sig"))):
+                return path
+        except ValueError:
+            pass  # not JSON: nothing this fallback can see forbids it
+    return ""
+
+
+def load(path):
+    """(data, raw bytes or None when there is no file) for a JSON object; Refused otherwise."""
+    try:
+        with open(path, "rb") as handle:
+            raw = handle.read()
+    except FileNotFoundError:
+        return {}, None
+    try:
+        text = raw.decode("utf-8-sig")
+    except UnicodeDecodeError:
+        raise Refused("settings.json is not valid UTF-8")
+    if not text.strip():
+        return {}, raw
+    def reject(token):
+        raise ValueError("the constant " + token + " is not JSON")
+
+    try:
+        data = json.loads(text, parse_constant=reject)
+    except ValueError as e:
+        raise Refused("settings.json is not valid JSON (" + str(e) + ")")
+    if not isinstance(data, dict):
+        raise Refused("settings.json is not a JSON object")
+    if not isinstance(data.get("permissions", {}), dict):
+        raise Refused("the permissions entry of settings.json is not an object")
+    return data, raw
+
+
+def replace(path, data, mode):
+    """Write bytes to path through a temp file in the same folder and a rename."""
+    fd, tmp = tempfile.mkstemp(dir=os.path.dirname(path), prefix=".bypass-permissions.")
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(data)
+        os.chmod(tmp, mode)
+        try:
+            os.replace(tmp, path)
+        except OSError as e:
+            if e.errno not in (errno.EBUSY, errno.EXDEV):
+                raise
+            with open(path, "wb") as target:  # a bind-mounted single file refuses the rename: write in place
+                target.write(data)
+            os.remove(tmp)
+    except BaseException:
+        if os.path.exists(tmp):
+            os.remove(tmp)
+        raise
+
+
+def save(path, data, raw):
+    """Replace the real file behind path (a link stays a link), keeping its mode and BOM."""
+    real = os.path.realpath(path)
+    mode = os.stat(real).st_mode & 0o777 if os.path.exists(real) else 0o600
+    bom = BOM if raw is not None and raw.startswith(BOM) else b""
+    replace(real, bom + (json.dumps(data, indent=2, ensure_ascii=False) + "\n").encode("utf-8"), mode)
+
+
+def check_on(path, data):
+    # Claude Code lets root use the mode inside a sandbox it recognises: IS_SANDBOX exactly "1", or
+    # CLAUDE_CODE_BUBBLEWRAP set to a true value (2.1.289 reads 1, true, yes, on; 0 or false is not one).
+    bubblewrap = os.environ.get("CLAUDE_CODE_BUBBLEWRAP", "").strip().lower() in ("1", "true", "yes", "on")
+    sandboxed = os.environ.get("IS_SANDBOX") == "1" or bubblewrap
+    if hasattr(os, "geteuid") and os.geteuid() == 0 and not sandboxed:
+        raise Refused("Claude Code will not start in bypassPermissions as root; IS_SANDBOX=1 marks a real sandbox")
+    blocked = policy_block()
+    if blocked:
+        raise Refused("managed policy forbids bypassPermissions: " + blocked)
+    if forbids(data):
+        raise Refused("settings.json itself sets permissions.disableBypassPermissionsMode")
+
+
+def forget_record(path):
+    """Drop the node script's record of what `on` replaced. This fallback keeps no record, so one left by an
+    earlier node `on` is stale: the mode is no longer what it describes, and a later node `off` would restore it."""
+    try:
+        os.remove(path + ".bypass-permissions.json")
+    except FileNotFoundError:
+        pass
+
+
+def turn_on(path):
+    if not os.path.isdir(os.path.dirname(path)):
+        raise Refused("there is no Claude Code config folder at " + os.path.dirname(path))
+    data, raw = load(path)
+    check_on(path, data)
+    if data.get("permissions", {}).get("defaultMode") == MODE:
+        print("defaultMode = " + MODE + " (already, nothing changed)")
+        return 0
+    if raw is not None and not os.access(path, os.W_OK):
+        raise PermissionError(errno.EACCES, "this account may not write", path)
+    if raw is not None:
+        replace(path + ".bypass-permissions.bak", raw, 0o600)
+    forget_record(path)  # the mode is not on, so any record is stale
+    data.setdefault("permissions", {})["defaultMode"] = MODE
+    save(path, data, raw)
+    print("defaultMode = " + MODE)
+    return 0
+
+
+def turn_off(path):
+    data, raw = load(path)
+    current = data.get("permissions", {}).get("defaultMode")
+    if current != MODE:
+        print("defaultMode = " + str(current) + " (not bypassPermissions, nothing changed)")
+        return 0
+    if not os.access(path, os.W_OK):  # a read-only settings file is a lock: off honours it as on does
+        raise PermissionError(errno.EACCES, "this account may not write", path)
+    del data["permissions"]["defaultMode"]
+    save(path, data, raw)
+    forget_record(path)  # only after the write: if it failed, the record is still the way back
+    print("defaultMode removed (Claude Code's default start mode)")
+    return 0
+
+
+def outcome(argv, path):
+    actions = {("on", "--yes"): turn_on, ("off",): turn_off}
+    action = actions.get(tuple(argv[1:]))
+    if action is None:
+        print("refused: usage is `bypass-permissions.py on --yes` or `bypass-permissions.py off`", file=sys.stderr)
+        return 1
+    try:
+        return action(path)
+    except Refused as e:
+        print("refused: " + str(e) + "; settings.json left as it was", file=sys.stderr)
+        return 1
+    except OSError as e:
+        if e.errno in (errno.EACCES, errno.EPERM, errno.EROFS):
+            print("write blocked: " + str(e) + "; settings.json left as it was", file=sys.stderr)
+            return 3
+        print("unexpected error: " + str(e) + "; check settings.json", file=sys.stderr)
+        return 2
+    except Exception as e:  # anything else stopped it partway too
+        print("unexpected error: " + type(e).__name__ + ": " + str(e) + "; check settings.json", file=sys.stderr)
+        return 2
+
+
+def main(argv):
+    path = settings_path()
+    code = outcome(argv, path)
+    print("settings file: " + path)
+    return code
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/skills/{harness-factory → setup-harness-factory}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: harness-factory
-description: "(banker) revfactory/harness(팀 아키텍처 팩토리) 플러그인 설치·구성·사용안내. Claude=harness@harness-marketplace, Codex=meta-harness. 'harness-factory'/'하네스 팩토리'/'에이전트팀 생성' 또는 /banker:setup 시 사용."
+name: setup-harness-factory
+description: "도메인 한 줄로 전문 에이전트 팀을 만들어 주는 `revfactory/harness` 플러그인을 설치하고 구성한 뒤 사용법을 안내. Claude Code 는 `harness@harness-marketplace`, Codex 는 `meta-harness`. 'setup-harness-factory'/'harness-factory'/'하네스 팩토리'/'에이전트팀 생성' 또는 `/banker:setup` 시 사용."
 ---
 
-# harness-factory: revfactory/harness 팀 아키텍처 팩토리 설치·구성
+# setup-harness-factory: revfactory/harness 팀 아키텍처 팩토리 설치·구성
 
 `harness`는 도메인을 한 줄로 받아 `.claude/agents/`+`.claude/skills/`(전문 에이전트팀 + 그 에이전트가 쓸
 스킬)를 생성하는 **메타 스킬**이다. 이 플러그인의 본체는 설치물이 아니라 **방법론**이다. 따라서 이

package/skills/setup-insane-search/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-insane-search
-description: "(banker) insane-search(차단·봇방어 사이트 우회 검색·페치) 플러그인 설치(Claude=gptaku_plugins, Codex=gptaku-codex). 'setup-insane-search'/'insane-search 설치' 또는 /banker:setup 시 사용."
+description: "차단이나 봇 방어가 있는 사이트도 우회해 검색하고 가져오는 플러그인을 설치. Claude Code 는 `gptaku-plugins` 의 `insane-search`, Codex 는 `gptaku-codex` 의 `insane-research-codex`. 'setup-insane-search'/'insane-search 설치' 또는 `/banker:setup` 시 사용."
 ---
 
 # setup-insane-search: insane-search 플러그인 설치

package/skills/setup-java/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-java
-description: "(banker) JDK 21 + JAVA_HOME 설치(alternatives로 java·javac 비대칭 방지, Debian은 Adoptium 전용). jdtls 등 Java LSP 전제. 'setup-java'/'JDK 설치'/'Java 21 설치' 또는 /banker:setup 시 사용."
+description: "JDK 21 을 설치하고 `JAVA_HOME` 을 설정. `alternatives` 로 `java` 와 `javac` 의 버전 비대칭을 막고, Debian 은 Adoptium 만 씀. jdtls 같은 Java LSP 의 전제. 'setup-java'/'JDK 설치'/'Java 21 설치' 또는 `/banker:setup` 시 사용."
 ---
 
 # setup-java: JDK 21 + JAVA_HOME 설치

package/skills/setup-lsp/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-lsp
-description: "(banker) 언어별 LSP 서버(vtsls·basedpyright·bash·jdtls·spring)와 lsp-mcp 브리지 설치·연동. 'setup-lsp'/'LSP 설치'/'언어 서버' 또는 /banker:setup 시 사용."
+description: "언어별 LSP 서버(vtsls, basedpyright, bash, jdtls, spring)와 lsp-mcp 브리지를 설치하고 연동. 'setup-lsp'/'LSP 설치'/'언어 서버' 또는 `/banker:setup` 시 사용."
 ---
 
 # setup-lsp: 언어별 LSP 서버 + lsp-mcp 브리지

package/skills/setup-mcp/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-mcp
-description: "(banker) context7·sequential-thinking·filesystem·git·fetch(+선택 tavily) 범용 MCP 서버를 Claude Code(claude mcp add)·Codex(codex mcp add+config.toml)에 배선(serena·lsp_bridge 제외). 'setup-mcp'/'MCP 서버 설치'/'context7·sequential-thinking 설치' 또는 /banker:setup 시 사용."
+description: "범용 MCP 서버(context7, sequential-thinking, filesystem, git, fetch, 선택 사항인 tavily)를 Claude Code(`claude mcp add`)와 Codex(`codex mcp add`, `config.toml`)에 등록. serena 와 `lsp_bridge` 는 제외. 'setup-mcp'/'MCP 서버 설치'/'context7 설치'/'sequential-thinking 설치' 또는 `/banker:setup` 시 사용."
 ---
 
 # setup-mcp: 범용 MCP 서버 설치

package/skills/setup-node/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-node
-description: "(banker) nvm + Node 22(LTS) 런타임 설치(Windows는 winget 또는 nvm-windows). Claude Code npm 설치·Codex/OMX·npx 기반 MCP 서버 전제. 'setup-node'/'Node 설치'/'nvm 설치' 또는 /banker:setup 시 사용."
+description: "nvm 과 Node 22(LTS)를 설치(Windows 는 winget 이나 nvm-windows). Claude Code 의 npm 설치, Codex 와 OMX, npx 로 도는 MCP 서버의 전제. 'setup-node'/'Node 설치'/'nvm 설치' 또는 `/banker:setup` 시 사용."
 ---
 
 # setup-node: nvm + Node 22(LTS) 런타임 설치

package/skills/setup-omc/SKILL.md

@@ -1,26 +1,33 @@
 ---
 name: setup-omc
-description: "(banker) all-in-one·ultra-init·front-qa 가 의존하는 oh-my-claudecode(OMC) 설치/갱신(Codex는 OMX). 'setup-omc'/'OMC 설치'/'oh-my-claudecode 설치' 또는 /banker:setup 시 사용."
+description: "`all-in-one`, `ultra-init`, `front-qa` 가 의존하는 oh-my-claudecode(OMC)를 설치하거나 갱신. Codex 에서는 oh-my-codex(OMX)가 대상. 'setup-omc'/'OMC 설치'/'oh-my-claudecode 설치' 또는 `/banker:setup` 시 사용."
 ---
 
 # setup-omc: oh-my-claudecode(OMC) 설치/갱신
 
 banker의 오케스트레이터(`all-in-one`·`ultra-init`)와 `/banker:front-qa` 커맨드는 OMC의
-`ralplan`·`ralph`·`ultraqa` 등에 의존한다. 이 스킬은 OMC를 설치하거나 최신화한다(이미 있으면 갱신만; 멱등). 답변은 한글.
+`ralplan`·`ralph`·`verify` 와 `omc` CLI(`omc ralph verify`)에 의존한다. OMC 5부터 `ralph` 가 첫 반복에 `omc ralph verify` 를 직접 부르므로, 플러그인만 새것이고 전역 `omc` CLI 가 낡으면(4.x) `ralph` 가 시작하자마자 멈춘다. 이 스킬은 OMC를 설치하거나 최신화한다(이미 있으면 갱신만; 멱등). 답변은 한글.
 
 ## 0. 감지 (먼저, 추정 금지)
 ```bash
 command -v omc >/dev/null && omc --version || echo "omc: 미설치"
+omc ralph verify --help 2>&1 | grep -q 'Usage: omc ralph verify' && echo "omc CLI: ralph verify 있음" || echo "omc CLI: ralph verify 없음 (미설치 또는 4.x)"
 command -v claude >/dev/null || echo "claude: 미설치"
 ```
+- `ralph verify` 는 종료 코드가 아니라 **출력 문구로 판정**한다. 4.x CLI 는 모르는 명령에 `--help` 를 붙이면 전체 도움말을 찍고 0 으로 끝난다. `--help` 없이 부르면 Claude 실행으로 넘어가므로 점검에는 반드시 붙인다.
 
 ## Claude Code · OMC
 - **이미 설치(`omc` 존재)** 면 최신화만 한다:
   ```bash
   omc update      # 플러그인·npm 패키지·CLAUDE.md 동기화
   ```
+- `omc update` 가 중간에 실패하거나 끝난 뒤에도 `ralph verify` 가 없으면, CLI 만 직접 올린다:
+  ```bash
+  npm install -g oh-my-claude-sisyphus@latest
+  ```
+  - 네이티브 모듈(`better-sqlite3`) 빌드가 낡은 기본 컴파일러 때문에 실패하는 배포판(예: RHEL·Rocky 8)은 새 gcc 를 켠 셸에서 같은 명령을 실행한다(예: `source /opt/rh/gcc-toolset-14/enable`).
 - **미설치** 면 공식 배포처 절차를 따른다(일반적으로 npm 전역 설치 후 `omc setup`). 정확한 설치 명령이 불명확하면 추정하지 말고 사용자에게 확인한다.
-- 확인: `omc --version` + Claude 재시작·`/reload-plugins` 후 `/oh-my-claudecode:*` 노출.
+- 확인: `omc --version`, 위 `ralph verify` 점검 통과, Claude 재시작·`/reload-plugins` 후 `/oh-my-claudecode:*` 노출.
 
 ## Codex CLI · OMX (oh-my-codex)
 Codex에서의 대응 프레임워크는 OMX다.
@@ -30,7 +37,7 @@ command -v omx >/dev/null && omx setup      # 유저/프로젝트 레벨 OMX 구
 - 미설치면 OMX 배포처 안내대로 설치 후 `omx setup`.
 
 ## 검증·보고
-- OMC: `omc --version` / OMX: `omx --version`. 반영엔 재시작·`/reload-plugins`(Claude)가 필요할 수 있다.
+- OMC: `omc --version` + `ralph verify` 점검 / OMX: `omx --version`. 반영엔 재시작·`/reload-plugins`(Claude)가 필요할 수 있다.
 - 실패·불명확은 정직 보고(가짜 성공 금지).
 
 ## 함정

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

@@ -1,6 +1,7 @@
 ---
 name: setup-omc-hud
-description: "(banker) omc_hud(Claude Code 상태표시줄)를 OS별 apply 스크립트로 적용(Codex는 OMX hud). 'setup-omc-hud'/'omc_hud 설치' 또는 /banker:setup 시 사용."
+description: "Claude Code 의 상태표시줄 omc_hud 를 OS별 적용 스크립트로 설치하고, Claude Code 갱신 안내를 줄 맨 끝으로 옮김. Codex 는 OMX 의 `hud` 스킬을 씀. 'setup-omc-hud'/'omc_hud 설치'/'Claude 갱신 안내 위치' 또는 `/banker:setup` 시 사용."
+argument-hint: "[off|status]"
 ---
 
 # setup-omc-hud — omc_hud 상태표시줄 설치 (OS별)
@@ -9,10 +10,20 @@ description: "(banker) omc_hud(Claude Code 상태표시줄)를 OS별 apply 스
 
 **런타임:** omc_hud 는 Claude Code 상태표시줄(`~/.claude/settings.json` statusLine) 대상이다. **Codex 런타임에선 oh-my-codex(OMX)가 자체 `hud` 스킬/구성을 제공**하므로, Codex에선 이 스킬 대신 OMX 의 `hud` 를 사용한다.
 
+**인자가 `off` 또는 `status` 일 때:** 0~3단계를 건너뛰고 3단계의 Claude 갱신 안내 스크립트만 그 인자로 실행해 결과를 보고한다(`off` 는 안내를 래퍼가 정한 자리로 되돌림, `status` 는 상태만 확인).
+
 ## 0. 감지
 ```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"
+```
+Windows(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" }
 ```
 
 ## 1. mac / linux — apply 스크립트 적용
@@ -41,8 +52,22 @@ git 없으면 GitHub "Download ZIP" → 해제 → 동봉 적용 스크립트
 - 적용 스크립트가 `~/.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`.
 
 ## 함정
 - `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` 를 실행한다.

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

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * claude-update-last: puts OMC's Claude Code update notice at the end of the statusline.
+ *
+ *   node claude-update-last.mjs on       add the block to the OMC custom HUD wrapper
+ *   node claude-update-last.mjs off      take it out again
+ *   node claude-update-last.mjs status   say whether it is on
+ *
+ * When a newer Claude Code is out, OMC's HUD prints "[Claude#<running>] -> <latest>
+ * claude update" on its main line. The omc_hud wrapper lays that line out again in
+ * a fixed order: the older wrapper drops segments it does not know, so the notice
+ * never shows, and the current one shows them dimmed before the path, mid-line.
+ * The block runs right before the wrapper joins its segments, takes the notice out
+ * of wherever it landed and adds it, dimmed, after every other segment. OMC's own
+ * hint on the line below ("[!] claude <latest> - paste: ! claude update") is left
+ * as the wrapper shows it.
+ *
+ * The wrapper is <config>/hud/omc-hud-custom.mjs, where <config> is
+ * $CLAUDE_CONFIG_DIR or ~/.claude; $CLAUDE_UPDATE_LAST_HUD_FILE overrides the path.
+ * Blocks other tools add with their own markers (payload-mon's, say) are left alone.
+ *
+ * `on` converges on the current block and is a no-op when it is in place. Both
+ * commands refuse markers that do not pair up, keep the text from before each
+ * change in <wrapper>.claude-update-last.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, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+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 =
+  /^[ \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;
+// 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");
+
+const DEFAULTS = {
+  hudFile: process.env.CLAUDE_UPDATE_LAST_HUD_FILE || join(CONFIG_DIR, "hud", "omc-hud-custom.mjs"),
+};
+
+// OMC 5.6.1 renders the notice as `[Claude${tag}] -> ${latest} claude update`, the
+// tag being "#<running version>" or empty. The block's names are block-scoped, so
+// none can clash with the wrapper's own.
+const BLOCK = [
+  OPEN,
+  "// 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 {",
+  String.raw`  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 */",
+  "}",
+  CLOSE,
+];
+
+// The block as `on` writes it, in the line endings of the line it goes before.
+const blockText = (eol) => BLOCK.map((line) => "  " + line).join(eol) + eol;
+
+const count = (text, needle) => text.split(needle).length - 1;
+// Markers that do not pair up, in number or in order: removing the blocks leaves one behind.
+const unpaired = (src) => {
+  const rest = src.replace(BLOCKS, "");
+  return rest.includes(OPEN) || rest.includes(CLOSE);
+};
+const PAIR = "claude-update-last 표시(>>> / <<<)의 짝이 맞지 않습니다(개수나 순서)";
+
+// Every line that joins the segments, as [offset, line ending].
+const joinLines = (src) => [...src.matchAll(JOIN_LINE)].map((m) => [m.index, m[0].endsWith("\r") ? "\r\n" : "\n"]);
+
+// 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 refusal = (why, hudFile) => ({ ok: false, message: `${why}. 래퍼를 그대로 두었습니다: ${hudFile}` });
+
+// The block exactly as `on` writes it, once, right before the one joining line.
+function inPlace(src) {
+  if (count(src, OPEN) !== 1 || count(src, CLOSE) !== 1) return false;
+  const lines = joinLines(src);
+  if (lines.length !== 1) return false;
+  const [at, eol] = lines[0];
+  const block = blockText(eol);
+  return src.slice(at - block.length, at) === block;
+}
+
+// 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 (unpaired(src)) return PAIR;
+  const base = src.replace(BLOCKS, "");
+  if (!base.includes("omc-hud.mjs")) return "OMC 커스텀 HUD 래퍼가 아닙니다";
+  const places = joinLines(base).length;
+  if (places === 0) return "삽입 위치를 찾지 못했습니다(세그먼트를 합치는 colored.join(SEP) 줄이 없음)";
+  if (places > 1) return "삽입 위치가 두 곳 이상입니다(colored.join(SEP) 줄이 여러 개)";
+  if (!NAMES.every((name) => name.test(base))) return "블록이 쓰는 이름(segs, colored, stripAnsi, A)을 래퍼에서 찾지 못했습니다";
+  return "";
+}
+
+function insertBlock(base) {
+  const [[at, eol]] = joinLines(base);
+  return base.slice(0, at) + blockText(eol) + base.slice(at);
+}
+
+// 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) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  rmSync(tmp, { force: true });
+  try {
+    writeFileSync(tmp, data, { flag: "wx" });
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+// The first lines of node's complaint about `text` as an ES module, "" if it parses.
+function syntaxError(text) {
+  const dir = mkdtempSync(join(tmpdir(), "claude-update-last-"));
+  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.
+function commit(hudFile, before, after, done) {
+  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);
+  }
+  writeFresh(`${hudFile}.claude-update-last.bak`, before);
+  writeFileSync(hudFile, after);
+  return { ok: true, message: done };
+}
+
+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)) return { ok: true, message: "이미 켜져 있습니다 (변경 없음)." };
+  const why = misfit(src);
+  if (why) return refusal(why, o.hudFile);
+  const done = "켰습니다. 다음 statusline 갱신부터 Claude Code 갱신 안내가 줄 맨 끝에 표시됩니다.";
+  return commit(o.hudFile, src, insertBlock(src.replace(BLOCKS, "")), done);
+}
+
+export function turnOff(opts = {}) {
+  const o = { ...DEFAULTS, ...opts };
+  const src = readText(o.hudFile);
+  if (src === null) return { ok: true, message: `HUD 래퍼가 없어 끌 것이 없습니다: ${o.hudFile}` };
+  if (unpaired(src)) return refusal(PAIR, o.hudFile);
+  const out = src.replace(BLOCKS, "");
+  if (out === src) return { ok: true, message: "이미 꺼져 있습니다 (래퍼 변경 없음)." };
+  return commit(o.hudFile, src, out, "껐습니다. 다음 statusline 갱신부터 원래 순서로 표시됩니다.");
+}
+
+function stateOf(src) {
+  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 (unpaired(src)) return "표시(>>> / <<<)의 짝이 맞지 않습니다 (on, off 모두 거부: HUD 재설치 또는 남은 표시 줄 정리)";
+  return inPlace(src) ? "켜짐" : "켜짐이 불완전하거나 오래됨 (on 으로 복구)";
+}
+
+// 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));
+  } catch (e) {
+    return `HUD 래퍼를 읽을 수 없음 (${e.code || e.message})`;
+  }
+}
+
+export function status(opts = {}) {
+  const o = { ...DEFAULTS, ...opts };
+  return { ok: true, message: `claude-update-last: ${describe(o)} (${o.hudFile})` };
+}
+
+const COMMANDS = new Map([
+  ["on", turnOn],
+  ["off", turnOff],
+  ["status", status],
+]);
+
+function main(arg) {
+  const run = COMMANDS.get(arg);
+  if (!run) {
+    process.stdout.write("사용법: claude-update-last 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());