@kaydash9999/banker-plugins 0.20.2 → 0.21.0

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 것이 양 런타임 동일(아래).
 
 ## 게이트 체인
 무장 후 임계 초과가 감지되면 순서대로:
@@ -56,8 +101,8 @@ description: "컨텍스트 사용률이 임계(기본 50%)를 넘으면 `append_
 Codex=`$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%로 무장)

package/skills/smart-compact/scripts/codex-gate.mjs

@@ -0,0 +1,384 @@
+#!/usr/bin/env node
+/**
+ * smart-compact for Codex: a UserPromptSubmit hook that tells the session when its context passes a threshold.
+ *
+ *   node codex-gate.mjs on [--threshold N]   arm: save N (default 50), copy the hook, add it to hooks.json
+ *   node codex-gate.mjs off                  disarm: take the hook out, with its copy, threshold and state
+ *   node codex-gate.mjs status               say whether it is armed and the hook is in place and current
+ *   node codex-gate.mjs usage <rollout>      print the context use the session record shows
+ *   node codex-gate.mjs hook                 the hook itself (Codex runs it; reads the hook input on stdin)
+ *
+ * Codex gives a hook no context percentage, but every hook input carries transcript_path, the session record
+ * (rollout). Its token_count events hold last_token_usage and model_context_window, so the use of the last
+ * request over the window is the context use (measured on Codex 0.144.5).
+ * Files live in <CODEX_HOME> (default ~/.codex): smart-compact.json (threshold), smart-compact-state.json
+ * (sessions told), hooks.json.smart-compact.bak (hooks.json before each change) and the hook itself, copied to
+ * hooks-custom/banker-smart-compact-gate.mjs. Codex runs a trusted hook outside the sandbox, so the hook runs from
+ * that copy, where a sandboxed session cannot write, and not from a skill folder that may sit in a workspace.
+ * Codex trusts a hook by its handler and records the trust under the group's index: the threshold lives in a file
+ * so the command never changes with it, and the group is appended after the ones there, so OMX's hooks keep
+ * their indexes. On Windows Codex runs a hook command through PowerShell (measured on Codex 0.160.1), so the
+ * command there is `& '<node>' '<script>' hook`.
+ * The hook speaks once per session while the use stays at or over the threshold, and again after the use has
+ * dropped below it (after /compact). It never blocks a prompt: any error leaves it silent with exit 0.
+ * Exit status 1 means nothing was changed; 2 means an unexpected error stopped the command.
+ */
+import {
+  chmodSync, closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, realpathSync,
+  renameSync, rmSync, statSync, writeFileSync,
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, posix, win32 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SELF = fileURLToPath(import.meta.url);
+const COPY_NAME = "banker-smart-compact-gate.mjs";
+const KEEP_SESSIONS = 50;
+const MAX_READ = 32 << 20;
+
+export function paths(env = process.env) {
+  const home = env.CODEX_HOME || join(homedir(), ".codex");
+  return {
+    home,
+    hooks: join(home, "hooks.json"),
+    config: join(home, "smart-compact.json"),
+    state: join(home, "smart-compact-state.json"),
+    backup: join(home, "hooks.json.smart-compact.bak"),
+    copyDir: join(home, "hooks-custom"),
+    copy: join(home, "hooks-custom", COPY_NAME),
+  };
+}
+
+const isObject = (v) => Boolean(v) && typeof v === "object" && !Array.isArray(v);
+
+// JSON from a regular file only: a FIFO or a device would stall the hook. null when missing, odd or unreadable.
+function readJson(file) {
+  try {
+    return lstatSync(file).isFile() ? JSON.parse(readFileSync(file, "utf8")) : null;
+  } catch {
+    return null;
+  }
+}
+
+// A new file beside the target, given the target's mode when there is one, then renamed over it. The temp name is
+// created exclusively and a link in the target's place is replaced, not followed. The temp file goes on failure.
+function writeAtomic(file, data) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tmp, data, { flag: "wx" });
+    const mode = modeOf(file);
+    if (mode !== null) chmodSync(tmp, mode);
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+function modeOf(file) {
+  try {
+    const st = lstatSync(file);
+    return st.isFile() ? st.mode & 0o7777 : null;
+  } catch {
+    return null;
+  }
+}
+
+const writeJson = (file, value) => writeAtomic(file, `${JSON.stringify(value, null, 2)}\n`);
+
+// The last token_count with usage in a rollout, read from the end in growing spans, so a long session costs one
+// tail read in the usual case; null past `max` bytes, for a file that is not regular (checked before opening, since
+// opening a FIFO waits for a writer), or when none has usage yet (info is null on the first events of a session).
+export function lastUsage(file, max = MAX_READ) {
+  if (!statSync(file).isFile()) return null;
+  const fd = openSync(file, "r");
+  try {
+    const size = fstatSync(fd).size;
+    for (let span = 1 << 18; ; span *= 4) {
+      const start = Math.max(0, size - Math.min(span, max));
+      const buf = Buffer.alloc(size - start);
+      readSync(fd, buf, 0, buf.length, start);
+      const found = scanUsage(buf.toString("utf8"), start > 0);
+      if (found || start === 0 || span >= max) return found;
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function scanUsage(text, cutFirst) {
+  const lines = text.split("\n");
+  if (cutFirst) lines.shift();
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const found = lines[i].includes('"token_count"') ? usageOf(lines[i]) : null;
+    if (found) return found;
+  }
+  return null;
+}
+
+function usageOf(line) {
+  let rec;
+  try {
+    rec = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const info = rec && rec.payload && rec.payload.type === "token_count" ? rec.payload.info : null;
+  return info ? usageIn(info) : null;
+}
+
+function usageIn(info) {
+  const used = info.last_token_usage ? info.last_token_usage.total_tokens : NaN;
+  const win = info.model_context_window;
+  return Number.isFinite(used) && Number.isFinite(win) && win > 0 ? { used, window: win } : null;
+}
+
+export const percent = (u) => Math.round((u.used * 100) / u.window);
+
+export function nudge(pct, threshold) {
+  return `smart-compact: 컨텍스트 사용률 ${pct}% (임계 ${threshold}%). 이번 응답에서 위생 체인을 실행한다: `
+    + "$banker-append_wiki, 그다음 한 줄 안내(다음 메시지가 resume 프롬프트이고 그 뒤 /copy, /compact, 붙여 넣기 순서), "
+    + "마지막으로 $banker-ready-compact. /copy, /compact, 붙여 넣기는 사용자가 한다.";
+}
+
+const text = (o, key) => (o && typeof o[key] === "string" ? o[key] : "");
+
+// The hook's decision for one prompt: the text to inject, or "" for none. Mutates and returns the state.
+export function decide(input, config, state) {
+  const sid = text(input, "session_id");
+  const file = text(input, "transcript_path");
+  const usage = config && sid && file ? lastUsage(file) : null;
+  if (!usage) return { text: "", state };
+  const pct = percent(usage);
+  if (pct < config.threshold) {
+    delete state[sid];
+    return { text: "", state };
+  }
+  if (state[sid]) return { text: "", state };
+  state[sid] = Date.now();
+  prune(state);
+  return { text: nudge(pct, config.threshold), state };
+}
+
+function prune(state) {
+  const ids = Object.keys(state).sort((a, b) => state[a] - state[b]);
+  for (const old of ids.slice(0, Math.max(0, ids.length - KEEP_SESSIONS))) delete state[old];
+}
+
+function validConfig(c) {
+  return isObject(c) && Number.isInteger(c.threshold) && c.threshold >= 1 && c.threshold <= 95 ? c : null;
+}
+
+async function runHook(p) {
+  try {
+    process.stdin.setEncoding("utf8");
+    let raw = "";
+    for await (const chunk of process.stdin) raw += chunk;
+    const read = readJson(p.state);
+    const before = isObject(read) ? read : {};
+    const was = JSON.stringify(before);
+    const { text: say, state } = decide(JSON.parse(raw), validConfig(readJson(p.config)), before);
+    if (JSON.stringify(state) !== was) writeJson(p.state, state);
+    if (say) {
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: say },
+      }));
+    }
+  } catch {
+    /* a hook never blocks the prompt */
+  }
+  return 0;
+}
+
+// The command text, or null for a path the platform shell would still read into. POSIX: both paths in double
+// quotes, refusing $, `, " and backslashes. Windows: PowerShell's call operator with single-quoted paths, every
+// character PowerShell takes for a single quote (' and U+2018-U+201B) doubled.
+export function formatCommand(node, script, win = process.platform === "win32") {
+  if (/[\r\n\0]/.test(node + script)) return null;
+  if (win) {
+    const q = (s) => s.replace(/['\u2018-\u201B]/g, "$&$&");
+    return `& '${q(node)}' '${q(script)}' hook`;
+  }
+  return /["$`\\]/.test(node + script) ? null : `"${node}" "${script}" hook`;
+}
+
+// The command `on` writes, or null when a location makes it unsafe. Codex runs a trusted hook outside the sandbox,
+// so a node in the temp folder is refused, and when `on` itself runs inside Codex (CODEX_THREAD_ID), a node or a
+// source script inside the workspace is refused too: the sandboxed session could change it first. Paths are judged
+// by the target platform's rules.
+export function hookCommand(node, script, opts = {}) {
+  const { win = process.platform === "win32", cwd = process.cwd(), codex = Boolean(process.env.CODEX_THREAD_ID) } = opts;
+  const P = win ? win32 : posix;
+  const under = (f, dir) => {
+    const r = P.relative(dir, f);
+    return r === "" || (!r.startsWith("..") && !P.isAbsolute(r));
+  };
+  if (under(node, tmpdir()) || (codex && [node, SELF].some((f) => under(f, cwd)))) return null;
+  return formatCommand(node, script, win);
+}
+
+const COPY_RE = new RegExp(`[/\\\\]${COPY_NAME.replace(/\./g, "\\.")}["']? hook$`);
+const isOurs = (h) => isObject(h) && typeof h.command === "string" && COPY_RE.test(h.command);
+
+// hooks.json as an object, or why it cannot be changed. A missing file reads as empty; a link, a file that is not
+// JSON, or an error other than "not found" is refused, so OMX's hooks are never overwritten by mistake.
+function loadHooks(file) {
+  const kind = fileKind(file);
+  if (kind === "missing") return { doc: { hooks: {} }, groups: [] };
+  if (kind) return { why: kind };
+  const doc = readJson(file);
+  if (!isObject(doc)) return { why: `${file} 이 JSON 객체가 아님` };
+  if (doc.hooks === undefined) doc.hooks = {};
+  if (!isObject(doc.hooks)) return { why: `${file} 의 hooks 가 객체가 아님` };
+  const ups = doc.hooks.UserPromptSubmit;
+  if (ups !== undefined && !Array.isArray(ups)) return { why: `${file} 의 UserPromptSubmit 이 배열이 아님` };
+  return { doc, groups: ups || [] };
+}
+
+// "" for a regular file, "missing", or why the file cannot be used.
+function fileKind(file) {
+  try {
+    const st = lstatSync(file);
+    return st.isSymbolicLink() || !st.isFile() ? `${file} 이 일반 파일이 아님(링크나 폴더)` : "";
+  } catch (e) {
+    return e && e.code === "ENOENT" ? "missing" : `${file} 을 확인하지 못함(${e && e.code})`;
+  }
+}
+
+// Where our handler sits: [group index, handler index], or null.
+function findOurs(groups) {
+  for (let g = 0; g < groups.length; g++) {
+    const hs = isObject(groups[g]) && Array.isArray(groups[g].hooks) ? groups[g].hooks : [];
+    const h = hs.findIndex(isOurs);
+    if (h >= 0) return [g, h];
+  }
+  return null;
+}
+
+function saveHooks(p, doc) {
+  if (existsSync(p.hooks)) writeAtomic(p.backup, readFileSync(p.hooks));
+  writeJson(p.hooks, doc);
+}
+
+// The hook copy in <CODEX_HOME>/hooks-custom, refreshed when this version differs. A folder or copy that is a
+// link is refused.
+function installCopy(p) {
+  mkdirSync(p.copyDir, { recursive: true });
+  if (lstatSync(p.copyDir).isSymbolicLink()) return `${p.copyDir} 이 링크임`;
+  if (existsSync(p.copy) && !lstatSync(p.copy).isFile()) return `${p.copy} 이 일반 파일이 아님`;
+  const mine = readFileSync(SELF);
+  if (!existsSync(p.copy) || !readFileSync(p.copy).equals(mine)) writeAtomic(p.copy, mine);
+  return "";
+}
+
+const TRUST = "Codex 를 다시 열면 뜨는 Hooks need review 창이나 /hooks 에서 이 훅을 신뢰하십시오. 신뢰 전에는 돌지 않습니다";
+
+function placeHook(p, doc, groups, command) {
+  const at = findOurs(groups);
+  if (at && groups[at[0]].hooks[at[1]].command === command) return "훅은 이미 있음";
+  if (at) groups[at[0]].hooks[at[1]] = { ...groups[at[0]].hooks[at[1]], command, timeout: 5 };
+  else groups.push({ hooks: [{ type: "command", command, timeout: 5 }] });
+  doc.hooks.UserPromptSubmit = groups;
+  saveHooks(p, doc);
+  return at ? `훅 명령을 고쳤습니다. ${TRUST}` : `훅을 더했습니다. ${TRUST}`;
+}
+
+export function turnOn(p, threshold, node = process.execPath) {
+  if (!Number.isInteger(threshold) || threshold < 1 || threshold > 95) return { code: 1, msg: "임계값은 1~95 정수" };
+  const { doc, groups, why } = loadHooks(p.hooks);
+  if (why) return { code: 1, msg: `바꾸지 않음: ${why}` };
+  const command = hookCommand(node, p.copy);
+  if (!command) return { code: 1, msg: "바꾸지 않음: node 나 훅 경로가 안전하지 않음(셸이 읽는 글자, 임시 폴더의 node, Codex 작업 폴더 안의 node 나 스크립트). Codex 밖 터미널에서 실행하십시오" };
+  const bad = installCopy(p);
+  if (bad) return { code: 1, msg: `바꾸지 않음: ${bad}` };
+  const done = placeHook(p, doc, groups, command);
+  writeJson(p.config, { threshold });
+  return { code: 0, msg: `켰습니다(임계 ${threshold}%). ${done}` };
+}
+
+// Only our handler goes; a group it leaves empty goes too. Groups after a removed one move up an index, and
+// Codex then asks to trust their hooks again, so the message says so.
+export function turnOff(p) {
+  const { doc, groups, why } = loadHooks(p.hooks);
+  if (why) return { code: 1, msg: `바꾸지 않음: ${why}` };
+  const at = findOurs(groups);
+  let note = "켜져 있지 않았습니다(훅 없음). 설정만 지웠습니다";
+  if (at) {
+    const hs = groups[at[0]].hooks.filter((h) => !isOurs(h));
+    const shifts = hs.length === 0 && at[0] < groups.length - 1;
+    if (hs.length) groups[at[0]].hooks = hs;
+    else groups.splice(at[0], 1);
+    if (groups.length) doc.hooks.UserPromptSubmit = groups;
+    else delete doc.hooks.UserPromptSubmit;
+    saveHooks(p, doc);
+    note = shifts ? "껐습니다. 뒤에 있던 UserPromptSubmit 훅은 /hooks 에서 다시 신뢰해야 할 수 있습니다" : "껐습니다";
+  }
+  for (const f of [p.config, p.state, p.copy]) rmSync(f, { force: true });
+  return { code: 0, msg: note };
+}
+
+function staleness(p, groups, node) {
+  const at = findOurs(groups);
+  if (!at) return "no-hook";
+  if (groups[at[0]].hooks[at[1]].command !== formatCommand(node, p.copy)) return "stale";
+  try {
+    return readFileSync(p.copy).equals(readFileSync(SELF)) ? "" : "stale";
+  } catch {
+    return "stale";
+  }
+}
+
+export function status(p, node = process.execPath) {
+  const config = validConfig(readJson(p.config));
+  const { groups, why } = loadHooks(p.hooks);
+  if (why) return { code: 0, msg: `${config ? "켜짐 표시는 있으나 " : ""}hooks.json 을 읽지 못함: ${why}` };
+  const state = staleness(p, groups, node);
+  if (!config) return { code: 0, msg: state === "no-hook" ? "꺼짐" : "꺼짐(설정 없음, 훅만 남음). off 로 정리" };
+  if (state === "no-hook") return { code: 0, msg: "켜짐 표시는 있으나 훅이 없음(다른 도구나 손 편집이 지웠을 수 있음). on 을 다시 실행" };
+  if (state === "stale") return { code: 0, msg: "켜짐. 다만 훅 명령이나 사본이 이 판과 다름(node 경로가 바뀌었거나 banker 를 갱신함). on 을 다시 실행" };
+  return { code: 0, msg: `켜짐(임계 ${config.threshold}%). 알림이 없으면 /hooks 에서 이 훅을 신뢰했는지 확인` };
+}
+
+// on's arguments: --threshold N or --threshold=N, nothing else.
+function parseOn(args) {
+  if (args.length === 0) return 50;
+  const one = args.length === 1 && /^--threshold=(\d+)$/.exec(args[0]);
+  if (one) return Number(one[1]);
+  return args.length === 2 && args[0] === "--threshold" && /^\d+$/.test(args[1]) ? Number(args[1]) : NaN;
+}
+
+function usageLine(file) {
+  const u = file ? lastUsage(file) : null;
+  return u ? { code: 0, msg: `${percent(u)}% (${u.used} / ${u.window} 토큰)` } : { code: 1, msg: "token_count 기록 없음" };
+}
+
+const COMMANDS = {
+  on: (p, rest) => turnOn(p, parseOn(rest)),
+  off: (p, rest) => (rest.length ? null : turnOff(p)),
+  status: (p, rest) => (rest.length ? null : status(p)),
+  usage: (p, rest) => (rest.length === 1 ? usageLine(rest[0]) : null),
+};
+
+async function main(argv) {
+  const [cmd = "status", ...rest] = argv;
+  const p = paths();
+  if (cmd === "hook") return runHook(p);
+  const run = Object.prototype.hasOwnProperty.call(COMMANDS, cmd) ? COMMANDS[cmd] : null;
+  const out = (run && run(p, rest)) || { code: 1, msg: "사용법: codex-gate.mjs on [--threshold N] | off | status | usage <rollout>" };
+  (out.code ? process.stderr : process.stdout).write(`smart-compact: ${out.msg}\n`);
+  return out.code;
+}
+
+const invoked = (() => {
+  try {
+    return Boolean(process.argv[1]) && realpathSync(process.argv[1]) === realpathSync(SELF);
+  } catch {
+    return false;
+  }
+})();
+if (invoked) {
+  main(process.argv.slice(2)).then((c) => { process.exitCode = c; }, (e) => {
+    process.stderr.write(`smart-compact: 예기치 못한 오류: ${e && e.message}\n`);
+    process.exitCode = 2;
+  });
+}

package/skills/tone-compact/SKILL.md

@@ -207,7 +207,8 @@ argument-hint: "on | off | status"
 | 끊어진 링크라 그대로 두었습니다 | AGENTS.md 가 가리키는 파일이 없음. 링크를 지우거나 바꾸지 않음. 링크와 대상을 보이고 어떻게 할지 물은 뒤 다시 실행 |
 | AGENTS.md 가 끊어진 링크라 on 이 블록을 옮기지 못함 | AGENTS.override.md 에 블록만 남았고 AGENTS.md 가 가리키는 파일이 없음. 링크를 지우거나 바꾸지 않음. 링크와 대상을 보이고 어떻게 할지 물은 뒤 `on` 실행 |
 | 쓰는 사이에 같은 이름이 생겨 그대로 두었습니다 | 다른 프로그램이 그 사이에 같은 이름을 만들었음(링크일 수 있음). 지우거나 바꾸지 않음. 무엇인지 보이고(링크면 `ls -l` 로 링크와 대상 경로만 보이고 대상 내용은 열지 않음) 어떻게 할지 물은 뒤 다시 실행 |
-| 일반 파일이 아님 | 지침 파일 자리(AGENTS.md, AGENTS.override.md)의 폴더나 특수 파일은 지우지 않음. 무엇인지 사용자에게 보이고, 옮기거나 이름을 바꿀지 물은 뒤 다시 실행 |
+| 일반 파일이 아님 | 지침 파일 자리(AGENTS.md, AGENTS.override.md)의 폴더나 특수 파일, 그 백업 자리(`<파일>.tone-compact.bak`)의 폴더는 지우지 않음. 무엇인지 사용자에게 보이고, 옮기거나 이름을 바꿀지 물은 뒤 다시 실행 |
+| 32MiB 보다 큰 파일 | 지침 파일(AGENTS.md, AGENTS.override.md)이 32MiB 를 넘음. 읽지도 바꾸지도 않음. 그 파일이 무엇인지 보이고, 줄일지 옮길지 물은 뒤 다시 실행 |
 | 다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다 | 다른 banker 스킬의 `on`, `off` 가 도는 중. 잠시 뒤 다시 실행. 끝나지 않은 작업이 남긴 잠금은 1분 뒤 저절로 넘어감. 1분이 지나도 같거나 잠금 자리가 폴더면 잠금 경로를 보이고 어떻게 할지 물은 뒤 다시 실행. 잠금을 임의로 지우지 않음 |
 | 네트워크 공유가 잠금 자리에 계속 ESTALE(오래된 파일 핸들)을 돌려줘 그대로 두었습니다 | Codex 폴더가 NFS 같은 네트워크 공유에 있고 공유가 파일 핸들을 잃음. 잠시 뒤 다시 실행. 계속되면 공유 연결 상태를 확인하도록 알림. 잠금을 임의로 지우지 않음 |
 | 쓸 권한이 없음 | 해당 파일과 폴더 권한 확인 |