@kaydash9999/banker-plugins 0.20.5 → 0.22.0

package/skills/setup-omc-hud/assets/codex-config.mjs

@@ -0,0 +1,210 @@
+/*
+ * Codex 의 config.toml 을 줄 단위로 읽고 고치는 공통 모듈. setup-bypass-permissions 가 정본이고 setup-omc-hud 의
+ * assets/ 에 같은 사본을 둔다(scripts/sync-adapter.js 가 지킴).
+ *
+ * TOML 전체를 다시 쓰지 않는다. 바꾸는 키의 줄만 고쳐 주석, 순서, 다른 표는 그대로 둔다.
+ * - 줄을 훑으며 문자열(한 줄, 여러 줄)과 괄호 깊이를 따라가, 여러 줄 문자열이나 배열 안의 줄을 표 머리나 키로 보지 않는다.
+ * - 키 이름은 따옴표를 벗겨 비교한다(`"approval_policy"` 도 approval_policy). 값 끝의 주석은 값으로 보지 않는다.
+ * - 최상위가 표를 점 키나 인라인 표로 정했는지(definedInline) 알려, 그런 파일에 같은 표를 더하지 않게 한다.
+ * - 파일이 링크이거나 일반 파일이 아니면 고치지 않는다. 쓰기 전 원본을 백업(이 계정만 읽음)하고, 새 파일에 쓴 뒤
+ *   바꿔 넣으며 파일 모드를 지킨다.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// Codex 처럼 상대 경로 CODEX_HOME 은 지금 폴더 기준으로 푼다.
+export function codexConfigFile(env = process.env) {
+  const home = env.CODEX_HOME ? path.resolve(env.CODEX_HOME) : path.join(os.homedir(), '.codex');
+  return path.join(home, 'config.toml');
+}
+
+export class Refused extends Error {}
+
+// { text, mode, exists }. 없으면 빈 글. 링크나 일반 파일이 아니면 Refused.
+export function readToml(file) {
+  let st;
+  try {
+    st = fs.lstatSync(file);
+  } catch (e) {
+    if (e.code === 'ENOENT') return { text: '', mode: null, exists: false };
+    throw e;
+  }
+  if (!st.isFile()) throw new Refused(`${file} 이 일반 파일이 아님(링크이거나 다른 종류)`);
+  return { text: fs.readFileSync(file, 'utf8'), mode: st.mode & 0o7777, exists: true };
+}
+
+// 원본을 backup 에 복사한 뒤(원본이 있을 때) 새 파일에 써서 바꿔 넣는다.
+export function writeToml(file, text, { mode = null, backup = null } = {}) {
+  if (backup && fs.existsSync(file)) {
+    fs.copyFileSync(file, backup);
+    fs.chmodSync(backup, 0o600); // 원본에 비밀 값이 있을 수 있다
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, text, { flag: 'wx', mode: mode ?? 0o600 });
+    if (mode !== null) fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    fs.rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+const lines = (text) => text.split(/\r?\n/);
+const eol = (text) => (text.includes('\r\n') ? '\r\n' : '\n');
+// 파일이 쓰는 줄바꿈(CRLF 가 하나라도 있으면 CRLF).
+export const eolOf = eol;
+const TRIPLE = ['"""', "'''"];
+
+// 키나 표 이름을 낱말 배열로. 따옴표 안의 점은 나누지 않는다(`profiles."a.b"` 는 ['profiles', 'a.b']).
+export const nameParts = (s) => (s.match(/"[^"]*"|'[^']*'|[^.\s]+/g) ?? []).map((p) => p.replace(/^"(.*)"$|^'(.*)'$/, '$1$2'));
+// 비교용 이름. 낱말 사이를 \u0000 으로 이어, 점이 든 낱말과 점으로 나뉜 낱말을 구분한다.
+const plainName = (s) => nameParts(s).join('\u0000');
+
+// 한 줄을 문자열 밖에서 훑는다. { d: 괄호 깊이 변화, multi: 줄 끝에 열려 있는 여러 줄 문자열 구분자, cut: 주석 시작 위치 }.
+function scanLine(s, multi = '') {
+  let d = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (multi) {
+      if (s.startsWith(multi, i)) { i += 2; multi = ''; } else if (multi === TRIPLE[0] && s[i] === '\\') i++;
+      continue;
+    }
+    const c = s[i];
+    if (TRIPLE.some((t) => s.startsWith(t, i))) { multi = s.slice(i, i + 3); i += 2; }
+    else if (c === '"') { for (i++; i < s.length && s[i] !== '"'; i++) if (s[i] === '\\') i++; }
+    else if (c === "'") { const k = s.indexOf("'", i + 1); i = k < 0 ? s.length : k; }
+    else if (c === '#') return { d, multi, cut: i };
+    else if (c === '[' || c === '{') d++;
+    else if (c === ']' || c === '}') d--;
+  }
+  return { d, multi, cut: s.length };
+}
+
+// 표 머리. 이름 안의 따옴표 친 낱말에는 ] 가 들어갈 수 있다(`[projects."/a]b"]`).
+// 이름 부분은 탐욕 한 번으로 읽는다(겹치는 공백 패턴은 긴 줄에서 역추적이 폭증한다). 앞뒤 공백은 nameParts 가 지운다.
+const HEADER_RE = /^\s*\[\[?((?:"[^"]*"|'[^']*'|[^\]"'])+)\]\]?\s*(#.*)?$/;
+const KEY_RE = /^\s*((?:"[^"]*"|'[^']*'|[A-Za-z0-9_-]+)(?:\s*\.\s*(?:"[^"]*"|'[^']*'|[A-Za-z0-9_-]+))*)\s*=(.*)$/;
+
+// 줄마다 { kind: 'header'|'key'|'inside'|'other', name, end }. header 의 name 은 표 이름, key 의 name 은 키 이름이고
+// end 는 값이 끝나는 줄 다음. 여러 줄 문자열이나 배열 안의 줄은 inside.
+export function scan(text) {
+  const ls = lines(text);
+  const out = ls.map(() => ({ kind: 'other' }));
+  for (let i = 0; i < ls.length; i++) {
+    const header = HEADER_RE.exec(ls[i]);
+    if (header) { out[i] = { kind: 'header', name: plainName(header[1]) }; continue; }
+    const key = KEY_RE.exec(ls[i]);
+    if (!key) continue;
+    let { d, multi } = scanLine(key[2]);
+    let j = i + 1;
+    for (; (d > 0 || multi) && j < ls.length; j++) {
+      out[j] = { kind: 'inside' };
+      const r = scanLine(ls[j], multi);
+      d += r.d;
+      multi = r.multi;
+    }
+    out[i] = { kind: 'key', name: plainName(key[1]), end: j };
+    i = j - 1;
+  }
+  return out;
+}
+
+// 표의 줄 범위 [from, to). table '' 은 최상위. 표가 없으면 null.
+function tableRange(info, table) {
+  table = table.includes('\u0000') || !table ? table : plainName(table);
+  let from = table ? -1 : 0;
+  for (let i = 0; i < info.length; i++) {
+    if (info[i].kind !== 'header') continue;
+    if (from >= 0) return [from, i];
+    if (info[i].name === table) from = i + 1;
+  }
+  return from >= 0 ? [from, info.length] : null;
+}
+
+function keysOf(text, table) {
+  const info = scan(text);
+  const range = tableRange(info, table);
+  if (!range) return [];
+  const keys = [];
+  for (let i = range[0]; i < range[1]; i++) if (info[i].kind === 'key') keys.push({ at: i, end: info[i].end, name: info[i].name });
+  return keys;
+}
+
+// 키의 { at, end, raw }. raw 는 값 끝의 주석을 뺀 글. 없으면 null.
+export function findKey(text, table, key) {
+  const want = nameParts(key).join('\u0000');
+  const hit = keysOf(text, plainName(table)).find((k) => k.name === want);
+  if (!hit) return null;
+  const ls = lines(text).slice(hit.at, hit.end);
+  const parts = [ls[0].slice(ls[0].indexOf('=') + 1), ...ls.slice(1)];
+  let multi = '';
+  for (const part of parts.slice(0, -1)) multi = scanLine(part, multi).multi;
+  const last = parts.length - 1;
+  parts[last] = parts[last].slice(0, scanLine(parts[last], multi).cut); // 마지막 줄의 주석을 뗀다
+  const raw = parts.join('\n');
+  return { at: hit.at, end: hit.end, raw: raw.trim() };
+}
+
+// 최상위가 이 표를 점 키나 인라인 표로 정했는지(`tui.x = 1`, `tui = { ... }`). 그런 파일에 [표] 를 더하면 키가 겹쳐
+// Codex 가 설정을 읽지 못한다.
+export function definedInline(text, table) {
+  const t = plainName(table);
+  return keysOf(text, '').some((k) => k.name === t || k.name.startsWith(`${t}\u0000`));
+}
+
+// 키를 rawValue 로 둔다. 있으면 그 줄을 바꾸고, 없으면 표 끝(최상위는 첫 표 머리 앞)에 넣는다. 표가 없으면 끝에 만든다.
+// comment 가 있으면 키 바로 위에 그 주석 줄을 둔다.
+export function setKey(text, table, key, rawValue, comment = '') {
+  const ls = lines(text);
+  const nl = eol(text);
+  const line = [...(comment ? [comment] : []), `${key} = ${rawValue}`];
+  const hit = findKey(text, table, key);
+  if (hit) {
+    const above = comment && ls[hit.at - 1] === comment ? 1 : 0;
+    ls.splice(hit.at - above, hit.end - hit.at + above, ...line);
+    return ls.join(nl);
+  }
+  const range = tableRange(scan(text), table);
+  if (!range) {
+    while (ls.length && ls[ls.length - 1] === '') ls.pop();
+    return [...ls, ...(ls.length ? [''] : []), `[${table}]`, ...line, ''].join(nl);
+  }
+  // 다음 표 머리에 붙은 주석(`# MCP servers` 처럼 머리 바로 위의 주석 줄)과 그 앞 빈 줄은 건너뛰고 넣는다.
+  let at = range[1];
+  if (range[1] < ls.length) while (at > range[0] && ls[at - 1].trim().startsWith('#')) at--;
+  while (at > range[0] && ls[at - 1].trim() === '') at--;
+  ls.splice(at, 0, ...line);
+  return ls.join(nl);
+}
+
+// 키를 뺀다. comment 와 같은 주석 줄이 바로 위에 있으면 그것도 뺀다.
+export function removeKey(text, table, key, comment = '') {
+  const hit = findKey(text, table, key);
+  if (!hit) return text;
+  const ls = lines(text);
+  const above = comment && ls[hit.at - 1] === comment ? 1 : 0;
+  ls.splice(hit.at - above, hit.end - hit.at + above);
+  return ls.join(eol(text));
+}
+
+// 표에 키도 주석도 없으면 그 머리와 뒤의 빈 줄을 뺀다.
+export function dropEmptyTable(text, table) {
+  const info = scan(text);
+  const range = tableRange(info, table);
+  if (!range) return text;
+  const ls = lines(text);
+  if (ls.slice(range[0], range[1]).some((l) => l.trim())) return text;
+  ls.splice(range[0] - 1, range[1] - range[0] + 1);
+  return ls.join(eol(text));
+}
+
+// 이름이 prefix 로 시작하는 표들 중 key 를 정한 표 이름(예: profiles.* 의 approval_policy).
+export function tablesSetting(text, prefix, key) {
+  const p = plainName(prefix);
+  const names = scan(text).filter((x) => x.kind === 'header' && x.name.startsWith(`${p}\u0000`)).map((x) => x.name);
+  return [...new Set(names)].filter((n) => findKey(text, n, key)).map((n) => n.split('\u0000').join('.'));
+}
+
+// 쓰기 실패가 이 계정의 권한(샌드박스, 읽기 전용, 다른 소유자) 때문인지.
+export const denied = (e) => ['EACCES', 'EPERM', 'EROFS'].includes(e?.code);

package/skills/setup-omc-hud/assets/codex-status-line.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/*
+ * setup-omc-hud 의 Codex 대상. Codex TUI 의 상태표시줄은 `$CODEX_HOME/config.toml` 의 `[tui] status_line` 이다.
+ * OMX 는 `omx setup` 에서 이 줄을 `# omx:managed-status-line` 표시와 함께 관리한다.
+ *
+ * - on: status_line 이 없을 때만 OMX 의 프리셋 항목으로 넣고 `# banker:status-line` 표시를 붙인다. OMX 나 사용자가
+ *   이미 둔 줄은 건드리지 않는다(누가 둔 것인지 알린다).
+ * - off: banker 표시가 붙은 줄만 뺀다.
+ * - status: 지금 줄과 그 주인.
+ * 쓰기 전 원본을 config.toml.banker-hud.bak 에 둔다. 공통 모듈 codex-config.mjs 는 setup-bypass-permissions 의 같은 사본.
+ *
+ * 사용: node codex-status-line.mjs <on [--preset focused|minimal]|off|status>
+ * 종료: 0 완료 또는 이미 그 상태, 1 거부(파일은 그대로), 2 예기치 못한 오류, 3 이 계정이 쓸 수 없음(샌드박스 등)
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { codexConfigFile, definedInline, denied, dropEmptyTable, findKey, readToml, Refused, removeKey, setKey, writeToml } from './codex-config.mjs';
+
+export const MARK = '# banker:status-line';
+const OMX_MARK = '# omx:managed-status-line';
+// oh-my-codex 의 상태표시줄 프리셋(config/generator.js 의 STATUS_LINE_PRESETS)과 같은 항목.
+export const PRESETS = {
+  focused: ['model-with-reasoning', 'git-branch', 'context-remaining', 'total-input-tokens', 'total-output-tokens', 'five-hour-limit', 'weekly-limit'],
+  minimal: ['model-with-reasoning', 'git-branch'],
+};
+
+// 지금 status_line 과 그 주인: 'banker', 'omx', 'user', 없으면 null.
+export function owner(text) {
+  const hit = findKey(text, 'tui', 'status_line');
+  if (!hit) return { owner: null, raw: '' };
+  const above = text.split(/\r?\n/)[hit.at - 1];
+  return { owner: above === MARK ? 'banker' : above === OMX_MARK ? 'omx' : 'user', raw: hit.raw };
+}
+
+const presetValue = (fields) => `[${fields.map((f) => `"${f}"`).join(', ')}]`;
+const sameValue = (a, b) => a.replace(/\s+/g, '').replace(/,\]$/, ']') === b.replace(/\s+/g, '');
+
+export function turnOn({ file = codexConfigFile(), preset = 'focused' } = {}) {
+  if (!Object.prototype.hasOwnProperty.call(PRESETS, preset)) return { code: 1, msg: `프리셋은 ${Object.keys(PRESETS).join(', ')} 중 하나` };
+  const { text, mode, exists } = readToml(file);
+  // 최상위의 `tui.x = ` 나 `tui = { }` 가 있는 파일에 [tui] 를 더하면 키가 겹쳐 Codex 가 시작하지 못한다.
+  if (definedInline(text, 'tui')) return { code: 1, msg: '거부: 최상위에서 tui 를 점 키나 인라인 표로 정한 설정이라 [tui] 를 더하지 않음. status_line 을 직접 넣으십시오' };
+  const now = owner(text);
+  if (now.owner === 'omx') return { code: 0, msg: '이미 있음: OMX 가 관리하는 상태표시줄(바꾸려면 omx setup)' };
+  if (now.owner === 'user') return { code: 0, msg: '이미 있음: 사용자가 둔 상태표시줄이라 그대로 둠' };
+  if (!fs.existsSync(path.dirname(file))) return { code: 1, msg: `Codex 설정 폴더가 없음: ${path.dirname(file)}` };
+  const next = setKey(text, 'tui', 'status_line', presetValue(PRESETS[preset]), MARK);
+  if (next === text) return { code: 0, msg: '이미 켜져 있음' };
+  writeToml(file, next, { mode, backup: exists ? `${file}.banker-hud.bak` : null });
+  return { code: 0, msg: `켬: [tui] status_line(${preset}). Codex 를 다시 열면 보임` };
+}
+
+export function turnOff({ file = codexConfigFile() } = {}) {
+  const { text, mode } = readToml(file);
+  const now = owner(text);
+  if (now.owner !== 'banker') return { code: 0, msg: now.owner ? `banker 가 둔 줄이 아님(${now.owner}): 그대로 둠` : '이미 꺼져 있음' };
+  // 표시는 남았지만 값을 사용자가 고쳤으면 사용자의 줄로 본다.
+  if (!Object.values(PRESETS).some((f) => sameValue(now.raw, presetValue(f)))) return { code: 0, msg: '사용자가 값을 고친 줄이라 그대로 둠(banker 표시만 남음)' };
+  writeToml(file, dropEmptyTable(removeKey(text, 'tui', 'status_line', MARK), 'tui'), { mode });
+  return { code: 0, msg: '끔: banker 가 둔 status_line 을 뺌' };
+}
+
+export function status({ file = codexConfigFile() } = {}) {
+  const now = owner(readToml(file).text);
+  return { code: 0, msg: now.owner ? `status_line(${now.owner}): ${now.raw.replace(/\s+/g, ' ')}` : 'status_line 없음' };
+}
+
+function run(argv) {
+  const [cmd] = argv;
+  const at = argv.indexOf('--preset');
+  if (cmd === 'on') return turnOn({ preset: at >= 0 ? argv[at + 1] : 'focused' });
+  if (cmd === 'off') return turnOff();
+  return status();
+}
+
+function main(argv) {
+  let r;
+  try {
+    r = run(argv);
+  } catch (e) {
+    r = e instanceof Refused ? { code: 1, msg: `거부: ${e.message}` } : denied(e) ? { code: 3, msg: `쓸 수 없음(${e.code}): ${e.path ?? ''}${e.code === 'EPERM' && process.platform === 'win32' ? '. 다른 프로그램(Codex, 편집기)이 파일을 잡고 있을 수 있음' : ''}` } : { code: 2, msg: `오류: ${e.message}` };
+  }
+  console.log(`${r.msg}\n설정 파일: ${codexConfigFile()}`);
+  return r.code;
+}
+
+const same = (a, b) => { try { return fs.realpathSync(a) === fs.realpathSync(b); } catch { return false; } };
+if (process.argv[1] && same(fileURLToPath(import.meta.url), path.resolve(process.argv[1]))) process.exitCode = main(process.argv.slice(2));

package/skills/smart-compact/SKILL.md

@@ -10,11 +10,11 @@ description: "컨텍스트 사용률이 임계(기본 50%)를 넘으면 `append_
 → `/compact` → paste. `smart-compact` 로 무장, `smart-compact --cancel` 로 해제한다.
 `ready-compact` 는 0.14.0 부터 마지막 메시지를 resume 프롬프트만으로 내므로, 예전처럼 `compact-copy` 를 거치지 않는다.
 
-## ⚠️ 정직한 실현 한계 (Claude Code 실측)
+## ⚠️ 정직한 실현 한계 (Claude Code, Codex 실측)
 "컨텍스트 50%에서 완전 무인 자동"은 **부분만 가능**하다 — 근거:
-- **감지**: 컨텍스트 사용률은 **statusLine stdin** 의 `context_window.used_percentage` 로만 실시간
-  노출된다(hook은 이 값을 못 받음; auto-compact은 ~95%에서만, 50% 이벤트 없음). → statusLine으로
-  **정확히 50% 감지 가능**.
+- **감지**: Claude Code 는 컨텍스트 사용률을 **statusLine stdin** 의 `context_window.used_percentage` 로만 실시간
+  노출한다(hook은 이 값을 못 받음; auto-compact은 ~95%에서만, 50% 이벤트 없음). → statusLine으로
+  **정확히 50% 감지 가능**. Codex 는 훅이 받는 세션 기록에서 계산한다(아래 Codex 절).
 - **자동 실행 가능(어시스턴트)**: `append-wiki` · `ready-compact` — 스킬/도구
   작업이라 어시스턴트가 수행.
 - **자동 불가(TUI 전용)**: `/copy` · `/compact` · **paste** 는 인터랙티브 TUI 동작이라 hook·스킬이
@@ -26,7 +26,7 @@ description: "컨텍스트 사용률이 임계(기본 50%)를 넘으면 `append_
 때만·클립보드 보장 없이 취약). smart-compact은 **가장 신뢰 가능한 최대 자동화**를 택한다.
 
 ## 메커니즘 (무장 시 설치)
-런타임 인식 — Claude Code 경로가 정밀, Codex는 신호 노출이 불확실(아래 참조).
+런타임 인식 — Claude Code 는 statusLine 래퍼, Codex 는 세션 기록을 읽는 훅으로 둘 다 임계를 정확히 잰다.
 
 **Claude Code (OMC):**
 1. **statusLine 래퍼(compose-safe)**: 기존 `statusLine.command`(예: OMC HUD)를 **보존**하고, 그것을
@@ -39,9 +39,54 @@ description: "컨텍스트 사용률이 임계(기본 50%)를 넘으면 `append_
 3. **게이트 동작(어시스턴트)**: 주입을 받으면 자동파트를 실행한다. TUI 3단 안내는 `ready-compact` **전에** 한 줄로 하고, 마지막 메시지는 `ready-compact` 의 프롬프트로 끝낸다(안내를 뒤에 붙이면 `/copy` 가 안내문을 복사한다).
 
 **Codex (OMX):**
-- Codex가 statusline/hook에 컨텍스트%를 노출하는지 **미확인**(문서 부재). 노출되면 위와 동형으로 구성
-  (`~/.codex` 경로·OMX hook). 미노출이면 **휴리스틱 폴백**: 어시스턴트가 스스로 컨텍스트 압박을 감지해
-  체인을 제안하고, 유저가 트리거. 준비 스킬은 banker 것이 양 런타임 동일(아래).
+- Codex 는 훅 입력에 사용률 칸을 주지 않는다. 대신 모든 훅 입력의 `transcript_path`(세션 기록, rollout)에 요청마다
+  `token_count` 가 남는다. 마지막 `last_token_usage.total_tokens` 를 `model_context_window` 로 나눈 값이 사용률이다
+  (Codex 0.144.5 실측). Codex 화면의 `context-remaining` 과는 몇 %p 다를 수 있다.
+- 이 스킬 폴더의 `scripts/codex-gate.mjs` 가 계산과 훅을 맡는다. statusLine 래퍼는 쓰지 않는다(Codex 상태표시줄은
+  OMX 가 `config.toml` 의 `[tui]` `status_line` 으로 관리한다). 이 SKILL.md 가 있는 디렉터리의 절대경로로 실행한다.
+  ```bash
+  node "<이 스킬 디렉터리 절대경로>/scripts/codex-gate.mjs" on --threshold <N>   # 무장(N 은 1~95 정수, 기본 50)
+  node "<이 스킬 디렉터리 절대경로>/scripts/codex-gate.mjs" off                   # 해제
+  node "<이 스킬 디렉터리 절대경로>/scripts/codex-gate.mjs" status
+  node "<이 스킬 디렉터리 절대경로>/scripts/codex-gate.mjs" usage <rollout 경로>  # 수동 확인
+  ```
+  - 파일은 모두 `$CODEX_HOME`(없으면 `~/.codex`)에 둔다.
+
+    | 파일 | 내용 |
+    |---|---|
+    | `hooks-custom/banker-smart-compact-gate.mjs` | 훅 사본. 훅은 이 사본을 돌린다 |
+    | `hooks.json` | `UserPromptSubmit` 맨 뒤에 훅 묶음 하나 |
+    | `smart-compact.json` | 임계값 |
+    | `smart-compact-state.json` | 이미 알린 세션 |
+    | `hooks.json.smart-compact.bak` | `on`, `off` 가 `hooks.json` 을 바꿀 때마다 그 직전 내용 |
+
+  - 사본을 두는 까닭: Codex 는 신뢰한 훅을 샌드박스 밖에서 돌린다. 스킬 폴더가 작업 폴더 안에 있으면(프로젝트 범위 설치)
+    샌드박스 안의 세션이 그 스크립트를 고쳐 샌드박스 밖에서 돌릴 수 있다. 사본은 샌드박스가 쓸 수 없는 곳에 있다.
+  - 같은 까닭으로 `on` 은 임시 폴더의 node 를 거부하고, Codex 안에서 실행될 때는 작업 폴더 안의 node 나 스크립트도 거부한다.
+    Codex 를 홈 폴더에서 열었으면 거부된다(그 세션은 홈 전체를 쓸 수 있다). Codex 밖 터미널에서 실행한다.
+    PowerShell 명령은 작은따옴표(`'` 와 U+2018~U+201B)를 두 번 써서 인용한다.
+  - 맨 뒤에 더하는 까닭: Codex 는 훅 신뢰를 묶음 번호와 함께 기록한다. 앞에 끼우면 OMX 훅의 번호가 밀려 다시 신뢰해야 한다.
+    임계값을 명령이 아니라 파일에 두는 것도 같은 까닭이다(명령이 바뀌면 다시 신뢰해야 한다).
+  - Windows 의 Codex 는 훅 명령을 PowerShell 로 돌린다(Codex 0.160.1 실측). 그래서 명령은 `& '<node>' '<사본>' hook` 꼴이다.
+  - Codex 는 신뢰하지 않은 새 훅을 돌리지 않는다. `on` 뒤 Codex 를 다시 열면 "Hooks need review" 창이 뜬다.
+    거기서 Review hooks 나 Trust all 을 고르거나, 나중에 `/hooks` 에서 이 훅을 신뢰하라고 사용자에게 알린다.
+    "Continue without trusting" 을 고르면 무장되지 않은 것과 같다.
+  - 다시 `on` 하면 임계값만 바꾼다. node 경로가 바뀌었거나 banker 를 갱신해 훅 명령이나 사본이 낡았으면, 같은 자리에서 명령과
+    사본을 고친다. 그때는 이 훅만 다시 신뢰하면 된다. `status` 가 "이 판과 다름" 이면 `on` 을 다시 실행한다.
+  - `off` 는 이 훅 항목과 사본, 설정, 세션 상태만 지운다. 같은 묶음의 다른 훅은 남긴다. 이 묶음 뒤에 다른 묶음이 있었으면
+    그 훅들의 번호가 당겨져 다시 신뢰해야 할 수 있다고 알린다.
+  - 훅은 사용률이 임계 이상이면 세션마다 한 번 `additionalContext` 로 체인 실행을 지시한다. `/compact` 로 내려갔다가
+    다시 넘으면 또 알린다. 오류가 나도 프롬프트를 막지 않는다. 세션 상태 기록에는 잠금이 없어, 두 세션이 같은 순간에
+    프롬프트를 보내면 한 세션이 한 번 더 알림을 받을 수 있다.
+  - `on`, `off` 는 `~/.codex` 에 쓴다. Codex 의 `workspace-write` 샌드박스가 막으므로 그 명령을 샌드박스 밖 실행으로
+    승인을 요청해 돌린다. 승인을 요청할 수 없거나(승인 정책 `never`) 거부되면, 같은 명령을 Codex 입력창에서 `!` 를 붙여 사용자가 직접 실행하게 안내한다(예: `!node "<경로>" on --threshold <N>`). 사용자가 친 `!` 명령은 샌드박스 밖에서 돈다(Codex 0.144.5, `-a never` 에서 실측). `codex exec` 처럼 사람이 없는 실행이면 그 명령을 보고하고 멈춘다.
+    `--add-dir ~/.codex` 로 설정 폴더를 통째로 여는 방법은 쓰지 않는다. 그 세션이 훅과 신뢰 기록을
+    고칠 수 있게 되어 샌드박스가 무력해진다. `status`, `usage` 는 읽기만 한다.
+  - 훅 묶음이 사라졌으면(다른 도구나 손 편집) `status` 가 "훅이 없음" 으로 알린다. `on` 을 다시 실행한다.
+  - banker 나 OMX 를 지우기 전에 `off` 를 실행한다. banker 를 지워도 사본과 훅은 남아 계속 돈다. OMX 의 훅 제거는
+    뒤에 다른 묶음이 있으면 번호가 밀린다며 멈출 수 있다.
+- 훅을 쓸 수 없으면(훅 기능 꺼짐, 신뢰 거부) **휴리스틱 폴백**: 어시스턴트가 스스로 컨텍스트 압박을 감지해 체인을
+  제안하고, 유저가 트리거. 이때는 50% 정밀 트리거를 보장하지 않는다고 알린다. 준비 스킬은 banker 것이 양 런타임 동일(아래).
 
 ## 게이트 체인
 무장 후 임계 초과가 감지되면 순서대로:
@@ -53,11 +98,11 @@ description: "컨텍스트 사용률이 임계(기본 50%)를 넘으면 `append_
 
 1~3은 어시스턴트가 자동 수행. 4는 유저가 실행한다. 안내는 2에서 끝내고 3 뒤에는 아무것도 붙이지 않는다.
 (Claude=`/banker:append_wiki`·`/banker:ready-compact`,
-Codex=`$banker-append_wiki`·`$banker-ready-compact`; `/copy`·compaction은 양쪽 TUI 내장.)
+Codex=`$banker-append_wiki`·`$banker-ready-compact`, 플러그인 설치면 `$banker:append_wiki`·`$banker:ready-compact`; `/copy`·compaction은 양쪽 TUI 내장.)
 
 ## 활성화 (idempotent · compose-safe)
-`smart-compact [--threshold N]` (기본 N=50):
-1. `~/.claude/settings.json`(Codex는 `~/.codex/`)의 기존 `statusLine`·hook 설정을 **읽어 백업**
+`smart-compact [--threshold N]` (기본 N=50). 아래는 Claude Code 절차이고, Codex 는 위 Codex 절의 `codex-gate.mjs on` 으로 대신한다:
+1. `~/.claude/settings.json` 의 기존 `statusLine`·hook 설정을 **읽어 백업**
    (`~/.claude/.smart-compact-prev.json`).
 2. statusLine 래퍼 스크립트를 설치하고 `statusLine.command` 를 래퍼로 교체(래퍼가 이전 command를 위임 호출).
 3. `UserPromptSubmit` hook 항목을 **추가**(기존 hook 보존, 중복 방지 — 이미 있으면 skip).
@@ -67,7 +112,7 @@ Codex=`$banker-append_wiki`·`$banker-ready-compact`; `/copy`·compaction은 양
 않고 **감싸거나 추가만** 한다(uid는 `id -u` 로 계산, 하드코딩 금지).
 
 ## 해제
-`smart-compact --cancel`:
+`smart-compact --cancel` (Codex 는 `codex-gate.mjs off`):
 1. 백업(`~/.claude/.smart-compact-prev.json`)에서 원래 `statusLine`·hook 설정 **복원**.
 2. 래퍼 스크립트·신호 파일·백업 제거.
 3. 무장 해제를 보고. (백업이 없으면 smart-compact가 추가한 항목만 안전 제거.)
@@ -77,6 +122,7 @@ Codex=`$banker-append_wiki`·`$banker-ready-compact`; `/copy`·compaction은 양
 - **완전 자동 과대약속 금지** — `/copy`·`/compact`·paste는 TUI 전용, 유저 핸드오프임을 항상 명시.
 - **uid 하드코딩 금지** — 신호/경로는 `id -u` 로.
 - **hook은 명령을 못 부른다** — `additionalContext` 로 어시스턴트에게 지시할 뿐, 스스로 체인을 실행하지 못함.
-- **Codex 신호 미확인** — 노출 안 되면 휴리스틱 폴백으로 정직히 degrade(50% 정밀 트리거 미보장).
+- **Codex 훅은 신뢰해야 돈다** — 설치 뒤 "Hooks need review" 창이나 `/hooks` 에서 신뢰하라고 반드시 알린다.
+- **Codex 훅 묶음은 맨 뒤에** — 앞에 끼우면 OMX 훅의 신뢰가 풀린다. `hooks.json` 을 손으로 고치지 말고 `codex-gate.mjs` 를 쓴다.
 
 ARGUMENTS: [--threshold N] | --cancel   (없으면 기본 임계 50%로 무장)