@kaydash9999/banker-plugins 0.22.0 → 0.23.2

package/codex/transform-matrix.md

@@ -1,7 +1,7 @@
 # Transform matrix: Claude Code surfaces → Codex CLI
 
 Source of truth: this repo's `skills/<name>/` + `commands/<name>.md`. `codex/manifest.json` tags each surface.
-The generator (`banker setup --codex`) applies the rules below for `target: both` and `codex-only` surfaces (`claude-only` surfaces are never written to Codex — currently there are none). A `codex-only` surface has its source in `codex/skills/<name>/` and is never part of the Claude plugin (currently `graceful-pause` and `progress`).
+The generator (`banker setup --codex`) applies the rules below for `target: both` and `codex-only` surfaces (`claude-only` surfaces are never written to Codex — currently there are none). A `codex-only` surface has its source in `codex/skills/<name>/` and is never part of the Claude plugin (currently `graceful-pause`, `progress` and `teamwork`).
 
 | Source (Claude) | Codex destination | Transform |
 |---|---|---|
@@ -19,8 +19,8 @@ The generator (`banker setup --codex`) applies the rules below for `target: both
 - `--scope user` (default) → `~/.codex/…`. `--scope project` → `./.codex/…`.
 
 ## Runtime-aware surfaces (both) — Codex uses OMX / Codex equivalents
-현재 `claude-only` 표면은 **없다**(Claude 플러그인의 표면은 전부 `both`, Codex 에만 있는 `codex-only` 는 `graceful-pause`, `progress`). OMC/Claude 에 결합됐던 표면은 본문이 런타임 인식으로 작성돼 Codex에서도 동작한다 — Codex에선 OMC 대신 oh-my-codex(OMX)의 동명 스킬을 쓴다:
-- 오케스트레이터 `all-in-one`·`ultra-init`·커맨드 `front-qa` → OMX `ralplan`/`ralph`/`ultraqa`. `ultra-init` 은 0.14.0 부터 ultragoal 원장을 쓰지 않는다(OMC 5.6.1 checkpoint 가 `/goal` 스냅샷을 요구해 ralph 와 Stop 훅 루프가 겹친다). Claude 쪽은 OMC 5 기준: `ultraqa` 가 5.0.0 에서 삭제돼 QA 게이트를 `verify` 순환(독립 verifier → architect 진단 → executor 수정, 최대 5회)으로 직접 돌리고, `ralph` 가 부르는 `omc ralph verify` 때문에 전역 `omc` CLI 가 플러그인과 같은 5.x 여야 한다(사전 점검은 종료 코드가 아니라 출력 문구로).
+`claude-only` 표면은 `ultraqa` 하나다(Codex 는 OMX 의 `$ultraqa` 를 쓰므로 npm 설치와 Codex 플러그인 스킬 목록에서 빠진다). 그 밖의 Claude 플러그인 표면은 `both`, Codex 에만 있는 `codex-only` 는 `graceful-pause`, `progress`, `teamwork`. Codex 이름이나 설명이 다른 `both` 스킬은 manifest 의 `codexName`, `codexDescription` 으로 정한다(`setup-omc` 는 `setup-omx`, `omc-reference` 는 `omx-reference`, `setup-omc-hud` 는 `setup-omx-hud`, 설명만 다른 것은 `append_wiki`, `compact-wiki`, `setup-tmux`, 커맨드 `setup`). 플러그인 길은 `codex/renamed-skills/` 의 생성 사본, npm 길은 설치 때 바꿔 쓴다. OMC/Claude 에 결합됐던 표면은 본문이 런타임 인식으로 작성돼 Codex에서도 동작한다 — Codex에선 OMC 대신 oh-my-codex(OMX)의 동명 스킬을 쓴다:
+- 오케스트레이터 `all-in-one`·`ultra-init`·커맨드 `front-qa` → OMX `ralplan`/`ralph`. 마지막 QA 단계는 두 런타임 모두 banker `ralph-qa` 하나다(`--qa` 목표를 `--gates` 로 넘김, OMX `ultraqa` 에 기대지 않음). `ultra-init` 은 0.14.0 부터 ultragoal 원장을 쓰지 않는다(OMC 5.6.1 checkpoint 가 `/goal` 스냅샷을 요구해 ralph 와 Stop 훅 루프가 겹친다). Claude 쪽은 `ralph` 가 부르는 `omc ralph verify` 때문에 전역 `omc` CLI 가 플러그인과 같은 5.x 여야 한다(사전 점검은 종료 코드가 아니라 출력 문구로).
 - `setup-omc` → `omx setup`(본문에 이미 존재). `setup-omc-hud` → Codex 자신의 상태표시줄이면 `[tui] status_line` 을 OMX 프리셋으로 켜고 끔(`assets/codex-status-line.mjs`, 없을 때만 넣고 banker 가 넣은 줄만 뺌), 같은 머신의 Claude Code 상태표시줄이면 그대로 설치(대상을 말하지 않으면 먼저 묻는다). `setup-stitch` → `codex mcp add`. `setup-bypass-permissions` → 대상 `codex` 면 `config.toml` 최상위 `approval_policy = "never"`, `sandbox_mode = "danger-full-access"`(`scripts/codex-bypass.mjs`, 켜기 전 값 기록과 `off` 원복, 조직 정책 확인), 대상 `claude` 면 같은 머신의 Claude Code 설정.
 - `compact-copy` → Codex 내장 `/copy`(경로는 Codex 규약). `omc-reference` → Codex는 OMX 카탈로그 기준. `setup` 커맨드 → Codex는 프롬프트 선택 UX.
 `setup-insane-search` 도 `both`: Codex에선 `codex plugin add insane-research-codex@gptaku-codex`.
@@ -50,8 +50,10 @@ The generator (`banker setup --codex`) applies the rules below for `target: both
 - `remains` — the same procedure in both runtimes; box runs go through `scripts/boxes.mjs` (Codex: `~/.codex/skills/banker-remains/scripts/boxes.mjs`), which needs `ssh`, `scp` and `git` on the machine and key-only logins to the boxes in `~/.config/banker/test-boxes.json`. It reads and runs tests only: no fix, no commit, no push.
 - `ultra-chain` — the same nine stages in both runtimes. Claude=OMC 5 (`ralplan --deliberate`, `ralph --critic=critic`); Codex=OMX (`$ralplan --deliberate`, then `$ralph` with the skill's own critic loop through `spawn_agent`, because OMX `ralph` has no `--critic`). Both add a `ralph-qa` plan quorum after ralplan (two reviewers, no option to add more), run OS tests through the sibling `remains/scripts/boxes.mjs` (Codex: `banker-remains`), judge screenshots with a fresh agent (OMX 0.20.2's `visual-verdict` is a deprecated stub), and render the process report from the skill's own ledger (`lineage` reads Claude Code sessions only). Box runs need `ssh`, `scp` and `git`; screenshots need Playwright with Chromium; under Codex's `workspace-write` sandbox the ssh calls and the review seats' home writes may ask for approval.
 - `theme-selection` — the same procedure in both runtimes; the engine is `scripts/themes.mjs` (Codex: `~/.codex/skills/banker-theme-selection/scripts/themes.mjs`), which reads `assets/palettes.json` beside it. Pure Node with no network; it writes only the file `--out` names (refused when that file itself is a symbolic link), and the skill asks before it overwrites one that exists.
+- `progress-mon` — the same procedure in both runtimes; the engine is `scripts/progress-mon.mjs` (Codex npm install: `~/.codex/skills/banker-progress-mon/scripts/progress-mon.mjs`; plugin install: `~/.codex/plugins/cache/<marketplace>/banker/<version>/skills/progress-mon/scripts/progress-mon.mjs`), every command with `--runtime claude|codex`. The data folder is `.omc/progress-mon/` for Claude Code and `.omx/progress-mon/` for Codex. Pure Node with no network; the server binds 127.0.0.1 by default (`--host` takes a private IPv4 only). On Codex `start`, `stop`, `status` and `init` each ask for `sandbox_permissions: "require_escalated"` (`init` writes the git exclude list), and since closing the session may stop the server, a long-lived screen runs from the user's terminal (`serve`). `init --memory agents-md` writes its rule to `AGENTS.override.md` when that file has content of its own, as Codex then reads it instead of `AGENTS.md`. Not the same as `/progress` (the session's own task panel).
 - `/graceful-pause` — in Claude Code a function-hooks command (`hooks/register.mjs`, 2.1.289+, not a manifest surface) registered `immediate`, so it runs mid-turn; it appends one hidden user row the running turn reads at its next model request. In Codex the `codex-only` skill `graceful-pause` (`$banker-graceful-pause`): a message sent with Enter while a turn runs is held as "Messages to be submitted after next tool call" and put into the same turn when the running tool call ends, so the session stops after the current step (Codex 0.144.5: verified with `sleep 40` in a real TUI).
 - `/progress` — in Claude Code a mod panel (`hooks/progress.mjs`). In Codex the `codex-only` skill `progress` (`$banker-progress`, `codex/skills/progress/scripts/progress.mjs`): it reads this session's rollout, found by `CODEX_THREAD_ID` (the id at the end of the rollout file name), and prints the last plan file the session wrote or read (tool-call commands and `apply_patch` file heads; `.omx/plans/` counts like `.omc/plans/`) as a tree with the same engine (`progress-plan.mjs`, a byte-identical copy kept by `scripts/sync-adapter.js`), then the last `update_plan` steps (or the typed requests) with the recent tool calls under the step in progress. Not a live panel: `--pane` opens a tmux side pane that redraws every 2 s.
+- `teamwork` — `codex-only` (`$banker-teamwork`, plugin `$banker:teamwork`, `codex/skills/teamwork/scripts/teamwork.mjs`): peer work between the Codex sessions of one Codex home. `on` copies the engine to `$CODEX_HOME/teamwork/bin/` beside an sh wrapper, adds a `SessionStart` and a `UserPromptSubmit` hook last under each event (taking the same `hooks.json.lock` as `bin/lib/codex-hooks.mjs`, `timeout: 5`, fixed in place; the command ends with `--rev <hash of engine and wrapper>`, so a newer engine asks for trust once more) and writes `$CODEX_HOME/rules/teamwork.rules`, a `prefix_rule` that lets only the wrapper's `peers`, `role`, `send`, `reply`, `status` and `version` run outside the sandbox (`on`, `off`, `uninstall` ask for approval; a same-named file without the `# teamwork` first line is left alone). The wrapper and the hooks run outside the sandbox, so `node`, `codex`, `ps` and `sh` are recorded as absolute paths at `on` and nothing is looked up on PATH afterwards; programs, and a Codex home, under a temp folder, the session folder or its git top, or a `writable_roots` entry are refused (exit 6). Requests and results travel by `codex queue --thread <UUID>` (Codex 0.149.0 or later). Windows ends `on` with exit 6 and the reason: on Codex 0.160.1 for Windows, `codex execpolicy check` matches the rule only for the wrapper called directly, not for the PowerShell call form (`& '<wrapper>' send ...`), so every call would ask for approval. `banker uninstall --codex` removes it only when no other way of banker into that Codex home is left.
 - Update notice and usage counting — Claude Code uses the plugin's own hooks (`SessionStart`, `PostToolUse` Skill, `UserPromptExpansion`). Codex gets `SessionStart` (`update-notify.mjs --codex`, shown as a warning line in the TUI) and `Stop` (`telemetry-count-codex.mjs`, once per turn rather than per tool call). Codex shows a skill in two ways and the Stop hook counts both from this turn of the rollout: a model-picked skill is read by a tool call (`cat .../skills/banker-<name>/SKILL.md`), and a skill the user names with `$banker-<name>` is injected without a tool call as a user-role message starting `<skill>\n<name>..</name>\n<path>..</path>`, of which only the `<path>` head is read. Codex runs trusted hooks outside the sandbox, so the update query and check-in reach the network as in Claude Code.
 - Rollout shape — `lineage`, `progress` and the Stop hook read Codex's session record, whose shape Codex does not promise (0.144 and 0.160 already differ: event `user_message`/`agent_message` vs `item_completed` items, `exec_command` calls vs `exec` code). A shape banker cannot read is never an empty result: lineage stops with exit 2 naming the Codex version when a rollout gives no user turn, progress prints a warning line, and the Stop hook, finding no `task_started` for the turn in the whole record, notes the version in `codex-shape-miss.json` so the next SessionStart (`update-notify.mjs --codex`) shows one warning. `banker doctor` checks the newest rollout (turn start, user text, tool calls) after a Codex update.
 

package/hooks/obsidize-hook.mjs

@@ -56,35 +56,46 @@ const CODEX = process.argv.includes('--codex');
 // JSON names, regular single-name pages, a canonicalizer pinned to the checked omx_wiki/ of the session folder).
 const OMX_WIKI_WRITE_RE = /^\s*(?:&\s*)?['"]?omx(?:\.cmd|\.ps1)?['"]?\s+wiki\s+(?:wiki_)?(?:ingest|add)\b/;
 
-// A command's statements, split at `;`, `&&`, `||` and line ends outside quotes. A backslash keeps the next character
-// outside quotes and inside double quotes; a backtick does so only inside double quotes (PowerShell's escape there; in
-// sh a backtick starts a command substitution, so outside quotes it is an ordinary character here). Inside single
-// quotes nothing is special.
-function statements(command) {
-  const out = [];
-  let cur = '';
-  let quote = '';
-  for (let i = 0; i < command.length; i++) {
-    const c = command[i];
-    const two = command.slice(i, i + 2);
-    if ((c === '\\' && quote !== "'") || (c === '`' && quote === '"')) {
-      cur += command.slice(i, i + 2);
-      i++;
-    } else if (quote) {
-      if (c === quote) quote = '';
-      cur += c;
-    } else if (c === '"' || c === "'") {
-      quote = c;
-      cur += c;
-    } else if (c === ';' || c === '\n' || c === '\r' || two === '&&' || two === '||') {
-      out.push(cur);
-      cur = '';
-      if (two === '&&' || two === '||') i++;
-    } else cur += c;
+// A command's statements, split at `;`, `&&`, `||` and line ends outside quotes, by the rules of the shell Codex runs
+// it in: PowerShell on Windows, sh elsewhere (shell defaults by process.platform).
+// - sh: a backslash keeps the next character, outside quotes and inside double quotes. A backtick outside quotes opens
+//   a command substitution that the next backtick closes; its inside is part of the statement around it.
+// - PowerShell: a backslash is an ordinary character (`cd C:\work\; omx wiki add` is two statements). A backtick keeps
+//   the next character, outside quotes and inside double quotes.
+// Inside single quotes nothing is special. A quote or backtick left open (an apostrophe in a here-string or a comment)
+// leaves the scan inside it to the end; then the plain split is taken too, so such a command is not missed.
+const SHELL_RULES = {
+  sh: { escape: (c, quote) => c === '\\' && quote !== "'", opens: `"'\``, },
+  powershell: { escape: (c, quote) => c === '`' && quote !== "'", opens: `"'` },
+};
+const PAIRS = new Set(['&&', '||']);
+const isBreak = (c, two) => c === ';' || c === '\n' || c === '\r' || PAIRS.has(two);
+export function statements(command, shell = process.platform === 'win32' ? 'powershell' : 'sh') {
+  const rule = SHELL_RULES[shell] ?? SHELL_RULES.sh;
+  const st = { out: [], cur: '', quote: '' };
+  for (let i = 0; i < command.length; i++) i += scan(st, rule, command[i], command.slice(i, i + 2));
+  return st.quote ? [...st.out, st.cur, ...command.split(/;|&&|\|\||\r?\n/)] : [...st.out, st.cur];
+}
+
+// One character of statements(): it joins the statement or ends one. Returns how many more characters it took (0, 1).
+function scan(st, rule, c, two) {
+  if (rule.escape(c, st.quote)) {
+    st.cur += two;
+    return 1;
+  }
+  if (st.quote || rule.opens.includes(c)) {
+    if (!st.quote) st.quote = c;
+    else if (c === st.quote) st.quote = '';
+    st.cur += c;
+    return 0;
+  }
+  if (!isBreak(c, two)) {
+    st.cur += c;
+    return 0;
   }
-  // A lone quote (an apostrophe in a here-string or a comment) leaves the scan inside quotes to the end; then the plain
-  // split is taken too, so such a command is not missed.
-  return quote ? [...out, cur, ...command.split(/;|&&|\|\||\r?\n/)] : [...out, cur];
+  st.out.push(st.cur);
+  st.cur = '';
+  return PAIRS.has(two) ? 1 : 0;
 }
 const PAGE_NAME_RE = /^[\w.-]+\.md$/;
 
@@ -270,9 +281,29 @@ function codexWikiWrite(payload) {
   return typeof command === 'string' && statements(command).some((part) => OMX_WIKI_WRITE_RE.test(part));
 }
 
+// Codex: when where this hook runs (the script, its plugin or copy folder, node) is under a config.toml writable_roots
+// entry, it does nothing and says why on stderr (the session start hook says it as a systemMessage). Unreadable: runs.
+// Loaded only on Codex, so the Claude Code hook needs nothing beside it.
+async function codexUnsafe(payload) {
+  let why = '';
+  try {
+    const r = await import('../bin/lib/codex-routes.mjs');
+    why = r.writableRootsNote(r.codexHomeOf(payload?.transcript_path), r.hookPlaces(import.meta.url));
+  } catch { /* as before */ }
+  if (why) process.stderr.write(`${why}\n`);
+  return Boolean(why);
+}
+
+// Codex: only an `omx wiki` write goes on (an unreadable payload goes on to be logged), and only from outside the
+// writable roots.
+async function codexSkip(payload, error) {
+  if (!error && !codexWikiWrite(payload)) return true;
+  return codexUnsafe(payload);
+}
+
 async function main() {
   const { payload, error } = await readPayload();
-  if (CODEX && !error && !codexWikiWrite(payload)) return;
+  if (CODEX && await codexSkip(payload, error)) return;
   const wikiDir = findArmedWikiDir(writeRoot(payload));
   if (!wikiDir) return; // Not armed: change nothing, log nothing.
 
@@ -286,6 +317,18 @@ async function main() {
   }
 }
 
-main()
-  .catch(() => {}) // An un-canonicalized page is not-yet-formatted; the next bare run repairs it.
-  .finally(() => process.exit(0));
+// Run as the hook only (node, run.cjs, or the npm hook command's import); a test imports statements() alone. Both
+// paths go through realpath: Node resolves links for import.meta.url but not for process.argv[1].
+function invokedDirectly() {
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+if (invokedDirectly()) {
+  main()
+    .catch(() => {}) // An un-canonicalized page is not-yet-formatted; the next bare run repairs it.
+    .finally(() => process.exit(0));
+}

package/hooks/telemetry-count-codex.mjs

@@ -8,11 +8,14 @@
  *  - 사용자가 $banker-<name> 으로 부른 스킬: Codex 가 도구 호출 없이 `<skill>\n<name>..</name>\n<path>..</path>` 로
  *    시작하는 사용자 역할 메시지로 본문을 넣는다. 이때는 머리의 <path> 줄만 보고 본문은 보지 않는다.
  * Codex 플러그인으로 설치한 banker(codex plugin add, $banker:<name>)는 SKILL.md 가
- * `<CODEX_HOME>/plugins/cache/<마켓플레이스>/banker/<판>/{skills,codex/skills,codex/command-skills}/<name>/` 에 있다.
- * 두 길의 경로를 모두 센다.
+ * `<CODEX_HOME>/plugins/cache/<마켓플레이스>/banker/<판>/{skills,codex/skills,codex/command-skills,codex/renamed-skills}/<name>/`
+ * 에 있다. 두 길의 경로를 모두 센다. Codex 가 다른 이름으로 부르는 스킬(setup-omc 는 Codex 에서 setup-omx)은 Codex 이름으로
+ * 설치를 확인한 뒤 Claude 이름으로 센다(bin/lib/codex-names.mjs, codex/manifest.json 의 codexName 에서 생성). 개인화 알림의
+ * 바뀐 스킬 목록(skill-changes.json)도 Claude 이름이라 두 런타임의 셈이 한 이름으로 맞는다.
  * 도구 호출마다 도는 PreToolUse 대신 턴마다 한 번 도는 Stop 에서, 훅 입력의 transcript_path(rollout) 중
  * 이번 턴(task_started 의 turn_id 뒤)의 두 기록에 `skills/banker-<name>/SKILL.md` 가 있으면 센다. 나눠 읽어도 한 번이고, Stop 이 한 턴에 두 번 와도
- * 최근 턴 키(configDir 의 codex-count-turns)로 한 번만 센다. 기록은 끝에서부터 32 MB 까지만 읽는다.
+ * (턴, 이름)마다 configDir 의 codex-count-turns.d 에 표지 파일을 만든 훅만 센다(옛 판과는 codex-count-turns 를 함께 봄).
+ * 기록은 끝에서부터 32 MB 를 줄로 읽고, 턴 시작이 그 밖이면 256 MB 까지 바이트로 찾는다.
  *
  * fail-closed 규약은 Claude 쪽과 같다(telemetry-count-codex.test.mjs 가 검증):
  *  - countingActive() 가 아니면 로컬 쓰기조차 하지 않는다.
@@ -22,9 +25,11 @@
  *  - 어떤 오류도 삼키고 항상 exit 0. 도구 호출을 절대 막지 않는다. 표준 출력은 비운다.
  */
 import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { join } from 'node:path';
 
-import { codexHomeOf, pluginRoutes } from '../bin/lib/codex-routes.mjs';
+import { CLAUDE_NAMES } from '../bin/lib/codex-names.mjs';
+import { codexHomeOf, hookPlaces, pluginRoutes, writableRootsNote } from '../bin/lib/codex-routes.mjs';
 import { appendUsageLog, CODEX_SHAPE_MISS_PATH, configDir, countingActive, randomHex, readRegular, recordUsedSkill, SKILL_NAME_RE, writeByRename } from '../bin/lib/telemetry-config.mjs';
 
 export { codexHomeOf };
@@ -32,9 +37,13 @@ export { codexHomeOf };
 const SKILL_PATH_RE = /skills[\\/]+banker-([a-z0-9_-]{1,64})[\\/]+SKILL\.md/g;
 // 플러그인 길: plugins/cache/<마켓플레이스>/banker/<판>/<스킬 폴더>/<name>/SKILL.md. 1 마켓플레이스, 2 판, 3 스킬 폴더, 4 이름.
 // 대소문자를 가리지 않는 파일 시스템에서 `FRONT-QA` 같은 변형이 다른 이름으로 세어지지 않게 i 를 두지 않는다.
-const PLUGIN_PATH_RE = /plugins[\\/]+cache[\\/]+([A-Za-z0-9._-]{1,80})[\\/]+banker[\\/]+([A-Za-z0-9._-]{1,80})[\\/]+(skills|codex[\\/]+skills|codex[\\/]+command-skills)[\\/]+([a-z0-9_-]{1,64})[\\/]+SKILL\.md/g;
+const PLUGIN_PATH_RE = /plugins[\\/]+cache[\\/]+([A-Za-z0-9._-]{1,80})[\\/]+banker[\\/]+([A-Za-z0-9._-]{1,80})[\\/]+(skills|codex[\\/]+skills|codex[\\/]+command-skills|codex[\\/]+renamed-skills)[\\/]+([a-z0-9_-]{1,64})[\\/]+SKILL\.md/g;
 const KEEP_TURNS = 100;
 export const TURNS_FILE = () => join(configDir(), 'codex-count-turns');
+// 센 (턴, 이름)마다 하나씩 만드는 표지 파일의 폴더, 기록 끝 256 MB 안에서도 턴 시작을 못 찾은 일을 적는 한 줄 파일.
+export const MARKS_DIR = () => join(configDir(), 'codex-count-turns.d');
+export const FAR_NOTE_FILE = () => join(configDir(), 'codex-count-note');
+const requireBuiltin = createRequire(import.meta.url);
 
 function readStdin() {
   return new Promise((resolvePromise, rejectPromise) => {
@@ -85,24 +94,98 @@ const isCall = (rec) => rec?.type === 'response_item' && /_call$/.test(String(re
 const SKILL_HEAD_RE = /^<skill>\n<name>[^\n<]{1,80}<\/name>\n<path>([^\n<]{1,4096})<\/path>\n/;
 
 // $banker-<name> 으로 부른 스킬을 Codex 가 넣은 메시지의 <path>. 그 밖의 기록은 ''.
+const isUserMessage = (rec) => rec?.type === 'response_item' && rec.payload?.type === 'message' && rec.payload.role === 'user';
+
 function injectedPath(rec) {
-  const p = rec?.payload;
-  if (rec?.type !== 'response_item' || p?.type !== 'message' || p.role !== 'user' || !Array.isArray(p.content)) return '';
-  const text = p.content[0]?.text;
+  if (!isUserMessage(rec) || !Array.isArray(rec.payload.content)) return '';
+  const text = rec.payload.content[0]?.text;
   return typeof text === 'string' ? (SKILL_HEAD_RE.exec(text)?.[1] ?? '') : '';
 }
 
 // 이번 턴(turn_id 의 task_started 뒤)의 도구 호출과 넣은 스킬 머리에서 읽은 banker 스킬 이름. 사용자 글과 모델 답은 세지 않는다.
 // 턴 시작은 대개 기록 끝 가까이에 있으므로 끝 1 MB 부터 읽고, 못 찾으면 두 배씩 max 까지 넓힌다.
+// 그래도 없으면 farSkills 가 그 앞을 바이트로 찾는다(한 턴이 32 MB 를 넘게 쓴 경우).
 // 기록 전체를 읽고도 task_started 가 하나도 없으면 null: Codex 는 턴마다 task_started 를 쓰므로 기록 형식이 바뀐 것이다.
 // 이 턴의 것만 없을 때(시작이 기록되지 않는 턴)는 형식 변경으로 보지 않는다.
-export function turnSkills(file, turnId, max = MAX_READ) {
+export function turnSkills(file, turnId, max = MAX_READ, far = {}) {
   for (let size = Math.min(FIRST_READ, max); ; size = Math.min(size * 2, max)) {
     const { lines, whole } = tailLines(file, size);
     const start = turnStart(lines, turnId);
     if (start >= 0) return skillsAfter(lines, start);
     if (whole) return lines.some((l) => l.trim()) && !lines.some((l) => l.includes('"task_started"')) ? null : [];
-    if (size >= max) return [];
+    if (size >= max) return farSkills(file, turnId, max, far);
+  }
+}
+
+// 기록 끝 max 바이트 앞에서 이 턴의 시작을 찾는다. 끝에서 앞으로 chunk 씩 읽어 Buffer.lastIndexOf 로 턴 id 를 찾고
+// (문자열로 바꾸지 않음, 조각 경계는 4 KB 겹쳐 읽음), 그 줄에 task_started 가 있으면 거기서부터 chunk 씩 앞으로 읽으며
+// 이름만 모은다. 기록 끝에서 cap 바이트까지, ms 밀리초까지만(훅 시간 제한 5초). 못 찾으면 빈 목록에 far 표시를 단다.
+const FAR_READ = 256 << 20;
+const FAR_CHUNK = 32 << 20;
+const FAR_MS = 2000;
+const OVERLAP = 4 << 10;
+const NL = 0x0a;
+export function farSkills(file, turnId, max, { cap = FAR_READ, chunk = FAR_CHUNK, ms = FAR_MS } = {}) {
+  const fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+  try {
+    const size = fstatSync(fd).size;
+    const deadline = Date.now() + ms;
+    const at = findStart(fd, { size, needle: Buffer.from(`"${turnId}"`), from: size - max, floor: Math.max(0, size - cap), chunk, deadline });
+    if (at < 0) return Object.assign([], { far: true });
+    return [...namesFrom(fd, at, size, chunk, deadline)];
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function readAt(fd, start, len) {
+  const buf = Buffer.alloc(len);
+  return buf.subarray(0, readSync(fd, buf, 0, len, start));
+}
+
+// task_started 와 이 턴 id 가 한 줄에 있는 마지막 자리(파일 위치). 없으면 -1.
+function findStart(fd, { size, needle, from, floor, chunk, deadline }) {
+  const mark = Buffer.from('"task_started"');
+  for (let end = from; end > floor && Date.now() <= deadline; end -= chunk) {
+    const lo = Math.max(floor, end - chunk);
+    const buf = readAt(fd, lo, Math.min(end + OVERLAP, size) - lo);
+    for (let i = buf.lastIndexOf(needle); i >= 0; i = i > 0 ? buf.lastIndexOf(needle, i - 1) : -1) {
+      const ls = buf.lastIndexOf(NL, i) + 1;
+      const le = buf.indexOf(NL, i);
+      const at = buf.subarray(ls, le < 0 ? buf.length : le).indexOf(mark);
+      if (at >= 0) return lo + ls + at;
+    }
+  }
+  return -1;
+}
+
+// at(턴 시작 줄) 뒤로 기록 끝까지 chunk 씩 읽으며 SKILL.md 가 든 줄만 문자열로 바꿔 이름을 모은다.
+function namesFrom(fd, at, size, chunk, deadline) {
+  const names = new Set();
+  let carry = Buffer.alloc(0);
+  let skip = true; // 턴 시작 줄의 남은 부분
+  for (let pos = at; pos < size && Date.now() <= deadline; pos += chunk) {
+    let buf = Buffer.concat([carry, readAt(fd, pos, Math.min(chunk, size - pos))]);
+    carry = Buffer.alloc(0);
+    if (skip) {
+      const nl = buf.indexOf(NL);
+      if (nl < 0) continue;
+      [buf, skip] = [buf.subarray(nl + 1), false];
+    }
+    const cut = pos + chunk >= size ? buf.length : buf.lastIndexOf(NL) + 1;
+    linesWithSkill(buf.subarray(0, cut), names);
+    carry = buf.subarray(cut);
+  }
+  return names;
+}
+
+const SKILL_BYTES = Buffer.from('SKILL.md');
+function linesWithSkill(buf, names) {
+  for (let hit = buf.indexOf(SKILL_BYTES); hit >= 0;) {
+    const le = buf.indexOf(NL, hit);
+    const end = le < 0 ? buf.length : le;
+    lineNames(buf.toString('utf8', buf.lastIndexOf(NL, hit) + 1, end), names);
+    hit = buf.indexOf(SKILL_BYTES, end);
   }
 }
 
@@ -141,16 +224,18 @@ function turnStart(lines, turnId) {
 
 function skillsAfter(lines, start) {
   const names = new Set();
-  for (const line of lines.slice(start + 1)) {
-    if (!line.includes('SKILL.md')) continue;
-    let rec;
-    try { rec = JSON.parse(line); } catch { continue; }
-    if (isCall(rec)) namesIn(JSON.stringify(rec.payload), names);
-    else namesIn(injectedPath(rec), names);
-  }
+  for (const line of lines.slice(start + 1)) lineNames(line, names);
   return [...names];
 }
 
+function lineNames(line, names) {
+  if (!line.includes('SKILL.md')) return;
+  let rec;
+  try { rec = JSON.parse(line); } catch { return; }
+  if (isCall(rec)) namesIn(JSON.stringify(rec.payload), names);
+  else namesIn(injectedPath(rec), names);
+}
+
 const ID_RE = /^[A-Za-z0-9._-]{1,80}$/;
 
 // 이 턴의 키. session_id 와 turn_id 가 모양이 맞을 때만(파일 한 줄 형식을 깨지 않게).
@@ -193,38 +278,115 @@ export function installed(entry, home, routes = pluginRoutes(home)) {
   return existsSync(join(home, 'skills', `banker-${name.slice('banker:'.length)}`, 'SKILL.md'));
 }
 
-// 이 턴에 아직 세지 않은 이름만 센다.
-export function countOnce(payload) {
+// 'banker:<Codex 이름>' 을 'banker:<Claude 이름>' 으로. 이름이 같은 스킬은 그대로.
+export function claudeName(entry) {
+  const name = entry.slice('banker:'.length);
+  return Object.hasOwn(CLAUDE_NAMES, name) ? `banker:${CLAUDE_NAMES[name]}` : entry;
+}
+
+// 이 턴에 아직 세지 않은 이름만 센다. far 는 기록 읽기 한도(시험이 낮춤): max 줄로 읽는 끝 부분, 그 밖은 farSkills 의 것.
+export function countOnce(payload, far = {}) {
   const key = turnKey(payload);
   const file = typeof payload?.transcript_path === 'string' ? payload.transcript_path : '';
   const home = codexHomeOf(file);
-  const got = key && file ? turnSkills(file, payload.turn_id) : [];
+  const got = readTurn(key, file, payload, far);
   if (got === null) {
     noteShapeMiss(file);
     return [];
   }
+  if (got.far) noteFar(key);
   const routes = got.some((n) => n.includes('\t')) ? pluginRoutes(home) : []; // config.toml 은 한 번만 읽는다
-  const names = [...new Set(got.filter((n) => installed(n, home, routes)).map((n) => n.split('\t')[0]))];
+  const names = [...new Set(got.filter((n) => installed(n, home, routes)).map((n) => claudeName(n.split('\t')[0])))];
   if (!names.length) return [];
-  return withTurnsLock(() => {
-    const seen = readTurns();
-    const fresh = names.filter((n) => !seen.includes(`${key}\t${n}`));
-    if (!fresh.length) return [];
-    for (const n of fresh) {
-      appendUsageLog(n);
-      recordUsedSkill(n);
+  return withTurnsLock(() => countFresh(key, names));
+}
+
+function readTurn(key, file, payload, far) {
+  return key && file ? turnSkills(file, payload.turn_id, far.max ?? MAX_READ, far) : [];
+}
+
+// 옛 판(0.22.0 까지)은 codex-count-turns 만 보고, 이 판은 (턴, 이름)마다 표지 파일을 wx 로 만든 훅만 센다.
+// 옛 파일에 이미 있는 것은 표지만 만들고 세지 않는다. 센 것은 옛 판이 다시 세지 않게 옛 파일에도 적는다.
+function countFresh(key, names) {
+  const seen = readTurns();
+  const fresh = names.filter((n) => markTurn(key, n) && !seen.includes(`${key}\t${n}`));
+  for (const n of fresh) {
+    appendUsageLog(n);
+    recordUsedSkill(n);
+  }
+  if (fresh.length) writeTurns([...seen, ...fresh.map((n) => `${key}\t${n}`)]);
+  dropOldMarks();
+  return fresh;
+}
+
+// (턴, 이름)의 표지를 이 훅이 만들었는지. 만들기는 wx(이미 있으면 실패, 링크도 따라가지 않음)라 함께 도는 훅 가운데
+// 하나만 성공한다. 표지 폴더가 링크이거나 남의 폴더이면, 또 Windows 의 wx 가 끊어진 링크를 따라가 만든 것이면 세지 않는다.
+// Windows 의 wx 는 끊어진 링크를 따라가 그 대상을 만들므로, 그 자리에 무엇이든(끊어진 링크 포함) 있으면 열지 않는다.
+function markTurn(key, name) {
+  const dir = MARKS_DIR();
+  const file = join(dir, markName(`${key}\t${name}`));
+  try {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const st = lstatSync(dir);
+    if (!st.isDirectory() || (typeof process.getuid === 'function' && st.uid !== process.getuid())) return false;
+    if (taken(file)) return false;
+    closeSync(openSync(file, 'wx', 0o600));
+    return lstatSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function taken(file) {
+  try {
+    lstatSync(file);
+    return true;
+  } catch (e) {
+    return e.code !== 'ENOENT';
+  }
+}
+
+// 표지 이름: sha256 앞 32자. node:crypto 는 셀 것이 있을 때만 불러오고, crypto 없이 빌드한 Node 에서는 FNV-1a 넷.
+function markName(text) {
+  try {
+    return requireBuiltin('node:crypto').createHash('sha256').update(text).digest('hex').slice(0, 32);
+  } catch {
+    let out = '';
+    for (let seed = 0; seed < 4; seed++) {
+      let h = (0x811c9dc5 ^ seed) >>> 0;
+      for (const c of Buffer.from(text)) h = Math.imul(h ^ c, 0x01000193) >>> 0;
+      out += h.toString(16).padStart(8, '0');
     }
-    writeTurns([...seen, ...fresh.map((n) => `${key}\t${n}`)]);
-    return fresh;
-  });
+    return out;
+  }
 }
 
-// npm 길과 플러그인 길의 Stop 훅이 같은 턴에 함께 돌면 둘 다 턴 키를 읽고 셀 수 있다. 턴 키를 읽고 쓰는 동안
-// codex-count-turns.lock 폴더를 잡는다(mkdir 은 이미 있으면 실패하고 링크를 따라가지 않아 둘 중 하나만 잡음).
-// 2초 안에 못 잡으면 잡은 쪽이 이 턴을 세므로 세지 않는다. 잠금은 몇 ms 만 잡으므로 훅 시간 제한(5초)보다 조금 긴
-// 6초가 지난 잠금은 죽은 훅의 것이다: 고유 이름으로 옮겨(rename 은 하나만 성공) 지운 뒤 다시 잡는다. 옮긴 것이
-// 새것이면(그사이 다른 훅이 넘겨받아 잡은 것) 그 훅에 이 턴을 맡기고 물러난다.
-// configDir 을 만들 수 없거나 잠금 폴더를 만들 수 없는 다른 오류면 잠금 없이 전처럼 센다.
+// 이틀 지난 표지를 지운다. Codex 는 끝난 턴에 Stop 을 다시 보내지 않는다.
+const MARK_KEEP_MS = 2 * 24 * 60 * 60 * 1000;
+function dropOldMarks() {
+  const dir = MARKS_DIR();
+  try {
+    for (const name of readdirSync(dir)) {
+      try {
+        if (Date.now() - lstatSync(join(dir, name)).mtimeMs > MARK_KEEP_MS) rmSync(join(dir, name), { force: true });
+      } catch { /* 다른 훅이 먼저 지움 */ }
+    }
+  } catch { /* 다음에 */ }
+}
+
+// 턴 시작이 기록 끝 256 MB 밖이라 세지 않은 일을 한 줄로 남긴다(마지막 한 번만).
+function noteFar(key) {
+  try {
+    writeByRename(FAR_NOTE_FILE(), `${new Date().toISOString()}\t${key}\t턴 시작이 기록 끝 256 MB 밖, 이 턴은 세지 않음\n`);
+  } catch { /* 기록만 못 함 */ }
+}
+
+// npm 길과 플러그인 길의 Stop 훅이 같은 턴에 함께 돌면 둘 다 턴 키를 읽고 셀 수 있다. 셀지는 표지 파일(markTurn)이
+// 정하고, 잠금은 codex-count-turns 를 읽고 고쳐 쓰는 동안 잡는다(mkdir 은 이미 있으면 실패하고 링크를 따라가지 않음).
+// 2초 안에 못 잡으면 잠금 없이 표지로 정한다. 잠금은 몇 ms 만 잡으므로 훅 시간 제한(5초)보다 조금 긴 6초가 지난
+// 잠금은 죽은 훅의 것이다: 고유 이름으로 옮겨(rename 은 하나만 성공) 지운 뒤 다시 잡는다. 옮긴 것이 새것이면(그사이
+// 다른 훅이 넘겨받아 잡은 것) 그 훅에 이 턴을 맡기고 세지 않고 물러난다.
+// configDir 을 만들 수 없거나 잠금 폴더를 만들 수 없는 다른 오류면 잠금 없이 표지로 정한다.
 const LOCK_WAIT_MS = 2000;
 const LOCK_STALE_MS = 6000;
 export function withTurnsLock(fn, { wait = LOCK_WAIT_MS } = {}) {
@@ -237,26 +399,13 @@ export function withTurnsLock(fn, { wait = LOCK_WAIT_MS } = {}) {
   const end = Date.now() + wait;
   const token = `${process.pid}-${randomHex()}`;
   for (;;) {
-    try {
-      mkdirSync(lock);
-      try { writeFileSync(join(lock, 'owner'), token, { flag: 'wx' }); } catch { /* 표시 없이도 잠금은 잡았다 */ }
-      break;
-    } catch (e) {
-      if (e?.code !== 'EEXIST') return fn();
-    }
-    try {
-      if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) {
-        const old = `${lock}.stale-${process.pid}-${randomHex()}`;
-        renameSync(lock, old);
-        // 본 것과 옮긴 것 사이에 다른 훅이 낡은 잠금을 치우고 새로 잡았을 수 있다. 옮긴 것이 새것이면 그 훅이 이
-        // 턴을 세는 중이므로 세지 않고 물러난다. 돌려놓지 않는다(그사이 세 번째 훅이 잡은 잠금을 덮을 수 있다).
-        // 옮긴 폴더는 다음에 잠금을 잡은 훅이 치운다.
-        if (Date.now() - statSync(old).mtimeMs <= LOCK_STALE_MS) return [];
-        rmSync(old, { recursive: true, force: true });
-        continue;
-      }
-    } catch { /* 방금 풀렸거나 다른 훅이 먼저 치움: 다시 잡아 본다 */ }
-    if (Date.now() >= end) return [];
+    const got = takeLock(lock, token);
+    if (got === 'error') return fn();
+    if (got === 'held') break;
+    const old = takeOverStale(lock);
+    if (old === 'backoff') return [];
+    if (old === 'retry') continue;
+    if (Date.now() >= end) return fn();
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
   }
   try {
@@ -267,6 +416,34 @@ export function withTurnsLock(fn, { wait = LOCK_WAIT_MS } = {}) {
   }
 }
 
+// 'held' 잡음, 'busy' 다른 훅이 잡고 있음, 'error' 잠금 폴더를 만들 수 없음.
+function takeLock(lock, token) {
+  try {
+    mkdirSync(lock);
+  } catch (e) {
+    return e?.code === 'EEXIST' ? 'busy' : 'error';
+  }
+  try { writeFileSync(join(lock, 'owner'), token, { flag: 'wx' }); } catch { /* 표시 없이도 잠금은 잡았다 */ }
+  return 'held';
+}
+
+// 낡은 잠금을 넘겨받는다. 'retry' 치웠으니 다시 잡기, 'backoff' 물러남, 'live' 살아 있는 잠금(또는 방금 풀림).
+function takeOverStale(lock) {
+  try {
+    if (Date.now() - statSync(lock).mtimeMs <= LOCK_STALE_MS) return 'live';
+    const old = `${lock}.stale-${process.pid}-${randomHex()}`;
+    renameSync(lock, old);
+    // 본 것과 옮긴 것 사이에 다른 훅이 낡은 잠금을 치우고 새로 잡았을 수 있다. 옮긴 것이 새것이면 그 훅이 이
+    // 턴을 세는 중이므로 세지 않고 물러난다. 돌려놓지 않는다(그사이 세 번째 훅이 잡은 잠금을 덮을 수 있다).
+    // 옮긴 폴더는 다음에 잠금을 잡은 훅이 치운다.
+    if (Date.now() - statSync(old).mtimeMs <= LOCK_STALE_MS) return 'backoff';
+    rmSync(old, { recursive: true, force: true });
+    return 'retry';
+  } catch {
+    return 'live'; // 방금 풀렸거나 다른 훅이 먼저 치움: 다시 잡아 본다
+  }
+}
+
 // 잠금 폴더 안의 주인 표시(owner)가 이 훅의 것일 때만 놓는다. 넘겨받던 훅이 이 잠금을 옮기고 다른 훅이 그 이름을
 // 새로 잡았으면, 그 훅의 잠금은 지우지 않는다.
 function releaseLock(lock, token) {
@@ -299,6 +476,10 @@ async function main() {
     return;
   }
   if (!countingActive()) return;
+  // 이 훅이 도는 곳이 config.toml 의 writable_roots 아래면 세지 않고 까닭만 stderr 로(세션 시작 훅은 systemMessage 로 알림).
+  let unsafe = '';
+  try { unsafe = writableRootsNote(codexHomeOf(payload?.transcript_path), hookPlaces(import.meta.url)); } catch { /* 읽지 못하면 전처럼 */ }
+  if (unsafe) { process.stderr.write(`${unsafe}\n`); return; }
   countOnce(payload);
 }
 

package/hooks/update-fetch.mjs

@@ -22,7 +22,7 @@ import http from 'node:http';
 import https from 'node:https';
 
 import {
-  UPDATE_CHECK_PATH, NPM_LATEST_URL, writeUpdateCache, collectBody, netDeadlineMs, readRegular, updateCheckDue,
+  UPDATE_CHECK_PATH, NPM_LATEST_URL, writeUpdateCache, collectBody, netDeadlineMs, readRegular, updateCheckDue, noUpdateCheck,
 } from '../bin/lib/telemetry-config.mjs';
 
 const NET_TIMEOUT_MS = 10_000;
@@ -97,6 +97,7 @@ function fetchLatestVersion(url) {
 }
 
 async function main() {
+  if (noUpdateCheck()) return; // 업데이트 확인을 껐으면 직접 실행돼도 조회하지 않는다(update-notify 는 이때 이 파일을 띄우지 않음).
   const cache = readCache();
   if (!updateCheckDue(cache)) return; // 성공이나 실패한 시도에서 하루가 지나지 않음 - no-op.