@kaydash9999/banker-plugins 0.20.2 → 0.21.0

package/bin/banker.js

@@ -26,6 +26,12 @@ function version() {
 }
 function log(...a) { console.log(...a); }
 function warn(...a) { console.error(...a); }
+// 캐시에 적힌 밀리초 시각의 ISO 글, 없거나 날짜로 바꿀 수 없으면(깨진 캐시) ''.
+function isoTime(t) {
+  if (typeof t !== 'number' || !Number.isFinite(t)) return '';
+  const d = new Date(t);
+  return Number.isNaN(d.getTime()) ? '' : d.toISOString();
+}
 
 // GitHub 저장소에 별을 단다 (gh CLI 인증 사용). star 는 repo 쓰기 권한이 필요 없어 인증된 어느 계정으로도
 // 가능하다. gh 미설치/미인증/실패는 {ok:false, reason} 로 반환해 호출부가 URL 안내로 폴백하게 한다.
@@ -50,8 +56,9 @@ function starRepo(spawn = cp.spawnSync) {
 function parseArgs(argv) {
   const a = { cmd: null, sub: null, claude: false, codex: false, scope: 'user', scopeExplicit: false, dryRun: false, help: false, version: false };
   for (const t of argv) {
-    if (t === 'setup' || t === 'doctor' || t === 'uninstall' || t === 'help' || t === 'telemetry') { if (!a.cmd) a.cmd = t; }
-    else if (t === 'on' || t === 'off' || t === 'status') { if (!a.sub) a.sub = t; } // telemetry subcommand
+    if (t === 'setup' || t === 'doctor' || t === 'uninstall' || t === 'help' || t === 'telemetry' || t === 'hooks') { if (!a.cmd) a.cmd = t; }
+    else if (t === 'on' || t === 'off' || t === 'status' || t === 'enable' || t === 'disable') { if (!a.sub) a.sub = t; } // telemetry, hooks subcommand
+    else if (a.cmd === 'hooks' && /^[a-z]+$/.test(t)) (a.hookIds = a.hookIds || []).push(t);
     else if (t === '--claude') a.claude = true;
     else if (t === '--codex') a.codex = true;
     else if (t === '--dry-run' || t === '-n') a.dryRun = true;
@@ -75,11 +82,19 @@ function assertNotRoot() {
 }
 
 function readManifest() { return JSON.parse(fs.readFileSync(MANIFEST, 'utf8')); }
-function eligible(m) { return m.surfaces.filter(s => s.target === 'both'); }
+// Codex gets every 'both' surface and the 'codex-only' ones (their source lives in codex/skills/, which the Claude
+// plugin never loads: Claude Code has its own surface for them, e.g. the /graceful-pause and /progress mods).
+function eligible(m) { return m.surfaces.filter(s => s.target === 'both' || s.target === 'codex-only'); }
+function skillSource(s) { return s.target === 'codex-only' ? path.join(PKG_ROOT, 'codex', 'skills', s.name) : path.join(PKG_ROOT, 'skills', s.name); }
 
 function homeDir() { return os.homedir(); }
 function claudePluginsDir() { return path.join(homeDir(), '.claude', 'plugins'); }
-function codexBase(scope) { return scope === 'project' ? path.join(process.cwd(), '.codex') : path.join(homeDir(), '.codex'); }
+// User scope is where Codex itself reads skills and hooks: $CODEX_HOME when set, else ~/.codex.
+function codexBase(scope) {
+  if (scope === 'project') return path.join(process.cwd(), '.codex');
+  const ch = process.env.CODEX_HOME;
+  return ch ? path.resolve(ch) : path.join(homeDir(), '.codex'); // a relative one from here, as Codex reads it
+}
 
 function have(bin) {
   // PATH scan — no shell (avoids DEP0190 + injection). Cross-OS.
@@ -147,6 +162,19 @@ function setCodexSkillName(skillMd, newName, dryRun) {
   fs.writeFileSync(skillMd, src.slice(0, fm.index) + `---\n${block}\n---` + src.slice(fm.index + fm[0].length));
 }
 
+// A command as a Codex skill: the command's description becomes the skill's, under name: <name>. Codex skills get
+// no $ARGUMENTS substitution, so a note says where the arguments come from.
+function writeCommandSkill(src, destDir, name, dryRun) {
+  if (dryRun) { log(`  [dry-run] write command skill ${path.relative(PKG_ROOT, src)} -> ${destDir}`); return; }
+  const text = fs.readFileSync(src, 'utf8');
+  const fm = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const desc = fm && fm[1].match(/^description:\s*(.*)$/m);
+  const body = fm ? text.slice(fm[0].length) : text;
+  const note = '> Codex: 이 명령은 스킬로 설치됐다. 본문의 `$ARGUMENTS`, `$1` 은 사용자가 `$' + name + '` 뒤에 쓴 글이다.\n\n';
+  fs.mkdirSync(destDir, { recursive: true });
+  fs.writeFileSync(path.join(destDir, 'SKILL.md'), `---\nname: ${name}\ndescription: ${desc ? desc[1] : '""'}\n---\n\n${note}${body}`);
+}
+
 /* ---------- Claude Code target ---------- */
 function setupClaude(dryRun) {
   log('• Claude Code:');
@@ -179,21 +207,77 @@ function setupCodex(dryRun, scope) {
   for (const s of eligible(m)) {
     if (s.type === 'skill') {
       const dest = path.join(skillsDir, `banker-${s.name}`);
-      copyDir(path.join(PKG_ROOT, 'skills', s.name), dest, dryRun);
+      copyDir(skillSource(s), dest, dryRun);
       setCodexSkillName(path.join(dest, 'SKILL.md'), `banker-${s.name}`, dryRun); // dir==name (Codex discovery)
       nSkill++;
     } else if (s.type === 'command') {
-      copyFile(path.join(PKG_ROOT, 'commands', `${s.name}.md`), path.join(promptsDir, `banker-${s.name}.md`), dryRun);
+      const src = path.join(PKG_ROOT, 'commands', `${s.name}.md`);
+      copyFile(src, path.join(promptsDir, `banker-${s.name}.md`), dryRun);
+      writeCommandSkill(src, path.join(skillsDir, `banker-${s.name}`), `banker-${s.name}`, dryRun);
       nCmd++;
     }
   }
-  log(`  → ${nSkill} skills -> ${path.join(base, 'skills', 'banker-*')}, ${nCmd} prompts -> ${path.join(base, 'prompts', 'banker-*.md')}`);
+  log(`  → ${nSkill} skills -> ${path.join(base, 'skills', 'banker-*')}, ${nCmd} commands -> skills banker-* and prompts ${path.join(base, 'prompts', 'banker-*.md')}`);
+  log('  → Codex 0.144+ has no custom prompts, so each command is also a skill: invoke it as $banker-<name>.');
   log('  → skills are invoked as `banker-<name>` (frontmatter name rewritten to match the dir).');
   log('  → ~/.codex/AGENTS.md is NOT modified (omx regenerates it); skills auto-discovered from ~/.codex/skills/.');
   return true;
 }
 
 /* ---------- doctor ---------- */
+// The newest Codex session record (rollout) under <base>/sessions/YYYY/MM/DD/, or null.
+function newestRollout(base) {
+  let at = path.join(base, 'sessions');
+  for (let depth = 0; depth < 3; depth++) {
+    let names = [];
+    try { names = fs.readdirSync(at).filter(n => /^\d+$/.test(n)).sort(); } catch { return null; }
+    if (!names.length) return null;
+    at = path.join(at, names[names.length - 1]);
+  }
+  try {
+    const files = fs.readdirSync(at).filter(n => /^rollout-.*\.jsonl$/.test(n)).sort();
+    return files.length ? path.join(at, files[files.length - 1]) : null;
+  } catch { return null; }
+}
+
+// What lineage, progress and the usage-count hook look for in a rollout. Codex does not promise its record shape,
+// so after a Codex update this tells whether banker still reads it (a miss would otherwise leave empty results).
+function codexShapeReport(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK || 0));
+    const st = fs.fstatSync(fd);
+    if (!st.isFile()) return null;
+    const read = (start, len) => { const b = Buffer.alloc(len); fs.readSync(fd, b, 0, len, start); return b.toString('utf8'); };
+    const first = read(0, Math.min(st.size, 8 << 20)); // session_meta carries the instructions and can be large
+    const head = first.split('\n')[0];
+    if (!first.includes('\n') && st.size > (8 << 20)) return { version: '', tooLong: true }; // the first line is past 8 MB (bytes)
+    if (!first.slice(head.length).trim()) return { version: 'new', fresh: true };
+    const body = read(Math.max(0, st.size - (32 << 20)), Math.min(st.size, 32 << 20));
+    let version = '';
+    try { const m = JSON.parse(head); version = m.type === 'session_meta' ? String((m.payload || {}).cli_version || '?') : ''; } catch {}
+    return {
+      version,
+      turnStart: /"task_started"[^\n]*"turn_id"|"turn_id"[^\n]*"task_started"/.test(body),
+      userText: /"(user_message|UserMessage)"/.test(body),
+      toolCall: /"type":"[a-z_]+_call"/.test(body),
+    };
+  } catch { return null; } finally { if (fd !== undefined) try { fs.closeSync(fd); } catch {} }
+}
+
+function doctorCodexShape(base) {
+  const file = newestRollout(base);
+  if (!file) { log('  Codex record shape: no session record yet (run one Codex session, then doctor again)'); return; }
+  const r = codexShapeReport(file);
+  if (r && r.tooLong) { log(`  Codex record shape: ${path.basename(file)} opens with a line over 8 MB, not checked`); return; }
+  if (r && r.fresh) { log(`  Codex record shape: ${path.basename(file)} holds no turn yet (run one Codex turn, then doctor again)`); return; }
+  if (!r || !r.version) { log(`  ⚠ Codex record shape: ${path.basename(file)} does not open with session_meta - lineage, progress and usage counting cannot read it`); return; }
+  const mark = (ok) => (ok ? 'ok' : 'MISSING');
+  log(`  Codex record shape (Codex ${r.version}, ${path.basename(file)}): turn start ${mark(r.turnStart)}, user text ${mark(r.userText)}, tool calls ${mark(r.toolCall)}`);
+  if (!r.turnStart || !r.userText) log('  ⚠ banker may not read this Codex version\'s records (lineage stops, progress warns, usage counting misses); update banker');
+  else if (!r.toolCall) log('    (no tool calls: fine for a session that used no tools)');
+}
+
 function doctor() {
   log(`banker v${version()}  (pkg: ${PKG_ROOT})`);
   log(`plugin.json version: ${(() => { try { return require(PLUGIN_JSON).version; } catch { return '?'; } })()}`);
@@ -205,7 +289,8 @@ function doctor() {
   let installed = [];
   try { installed = fs.readdirSync(sdir).filter(d => d.startsWith('banker-')); } catch {}
   log(`  codex CLI: ${have('codex') ? 'found' : 'NOT found'}`);
-  log(`  installed banker skills in ~/.codex/skills: ${installed.length}`);
+  log(`  installed banker skills in ${sdir}: ${installed.length}`);
+  doctorCodexShape(base);
   // Codex only discovers a skill when its dir name equals the SKILL.md `name:` — flag any mismatch.
   const mismatched = installed
     .map(d => ({ d, name: readSkillName(path.join(sdir, d, 'SKILL.md')) }))
@@ -252,6 +337,54 @@ function uninstallCodex(dryRun, scopes) {
   }
 }
 
+/* ---------- Codex hooks ---------- */
+// bin/lib/codex-hooks.mjs is ESM; loaded lazily like telemetry-config. Hooks go into the same Codex home as the skills.
+async function loadCodexHooks() {
+  return import(require('url').pathToFileURL(path.join(__dirname, 'lib', 'codex-hooks.mjs')).href);
+}
+function codexHookPaths(ch) { return ch.codexPaths({ CODEX_HOME: codexBase('user') }); }
+
+// Update notice and usage counting on Codex, as the Claude plugin's hooks.json gives them to Claude Code. User scope
+// only: a project-scope copy would sit in a workspace, and Codex runs trusted hooks outside the sandbox.
+async function setupCodexHooks(dryRun, scope) {
+  if (scope !== 'user') { log('  → Codex hooks (update notice, usage counting) are user-scope only; skipped for scope=project.'); return; }
+  const ch = await loadCodexHooks();
+  if (dryRun) { log(`  [dry-run] Codex hooks: ${ch.DEFAULT_HOOKS.join(', ')} -> ${codexHookPaths(ch).hooks}`); return; }
+  const r = ch.enableHooks(codexHookPaths(ch), ch.DEFAULT_HOOKS, PKG_ROOT);
+  if (r.code) { warn(`  Codex hooks not changed: ${r.msg}`); return; }
+  log(`  → Codex hooks ${ch.DEFAULT_HOOKS.join(', ')} in ${codexHookPaths(ch).hooks}${r.changed.length ? ` (changed: ${r.changed.join(', ')})` : ' (already in place)'}.`);
+  if (r.changed.length) log(`  → ${ch.TRUST_NOTE}`);
+}
+
+async function uninstallCodexHooks(dryRun) {
+  const ch = await loadCodexHooks();
+  if (dryRun) { log(`  [dry-run] remove banker Codex hooks from ${codexHookPaths(ch).hooks}`); return; }
+  const r = ch.removeAll(codexHookPaths(ch));
+  if (r.code) warn(`  Codex hooks not changed: ${r.msg}`);
+  else if (r.changed.length) log(`  removed banker Codex hooks: ${r.changed.join(', ')}${r.shifted.length ? ` (later ${r.shifted.join(', ')} hooks may need trusting again in /hooks)` : ''}`);
+}
+
+// banker hooks <status|enable|disable> [ids]: status of all, or turn named hooks on or off (obsidizer --enable on Codex).
+async function hooksCmd(sub, ids) {
+  const ch = await loadCodexHooks();
+  const p = codexHookPaths(ch);
+  const all = Object.keys(ch.HOOKS);
+  const want = ids && ids.length ? ids : all;
+  const unknown = want.filter((id) => !all.includes(id));
+  if (unknown.length || (sub !== 'status' && !(ids && ids.length))) { warn(`usage: banker hooks <status|enable|disable> [${all.join('|')}]`); process.exitCode = 1; return; }
+  if (sub === 'status' || !sub) {
+    const s = ch.hookStatus(p, want, PKG_ROOT);
+    if (s.why) { warn(`banker hooks: ${s.why}`); process.exitCode = 1; return; }
+    for (const id of want) log(`${id}: ${s.status[id]}`);
+    return;
+  }
+  const r = sub === 'enable' ? ch.enableHooks(p, want, PKG_ROOT) : ch.disableHooks(p, want);
+  if (r.code) { warn(`banker hooks: not changed: ${r.msg}`); process.exitCode = 1; return; }
+  log(`banker hooks ${sub}: ${r.changed.length ? r.changed.join(', ') : 'nothing to change'}`);
+  if (sub === 'enable' && r.changed.length) log(ch.TRUST_NOTE);
+  if (r.shifted && r.shifted.length) log(`later ${r.shifted.join(', ')} hooks may need trusting again in /hooks.`);
+}
+
 /* ---------- telemetry config bridge ---------- */
 // bin/banker.js is CommonJS; telemetry-config is ESM (.mjs). Load it lazily via dynamic import
 // (pathToFileURL keeps the specifier valid on Windows). Only the interactive setup path and the
@@ -311,65 +444,105 @@ const TELEMETRY_USAGE = `Usage: banker telemetry <on|off|status>
 
 async function telemetryCmd(sub) {
   const tc = await loadTelemetry();
-  if (sub === 'on' || sub === 'off') {
-    const cfg = tc.readConfig();
-    if (sub === 'off') cfg.telemetry = false;                        // opt-out 저장
-    else delete cfg.telemetry;                                       // opt-out 해제: 기본-on 으로 복귀
-    if (!tc.writeConfig(cfg)) {
-      warn('banker: 설정을 저장하지 못했습니다 (config 쓰기 실패).');
-      process.exitCode = 1;
-      return;
-    }
-    if (sub === 'off') {
-      log('카운팅을 껐습니다 (off). config.telemetry=false 로 opt-out 을 저장했습니다.');
-    } else {
-      log('카운팅 opt-out 을 해제했습니다 (on). 기본값(켜짐)으로 복귀합니다.');
-      if (!tc.endpoint()) log('참고: 엔드포인트가 설정되어 있지 않아 지금은 아무것도 전송하지 않습니다.');
-    }
-    return;
-  }
+  if (sub === 'on' || sub === 'off') return telemetrySwitch(tc, sub);
   if (sub === 'status') {
-    const cfg = tc.readConfig();
-    const v = process.env.BANKER_NO_TELEMETRY;
-    const envOptOut = !(v === undefined || v === '' || v === '0' || v === 'false');
-    const cfgOptOut = cfg.telemetry === false;
-    log('banker 상태:');
-    log('[카운팅] 익명 사용량 카운팅 (기본값: 켜짐 · count-default-on)');
-    log(`  엔드포인트 설정: ${tc.endpoint() != null ? '설정됨' : '미설정'}`);
-    log(`  opt-out(BANKER_NO_TELEMETRY): ${envOptOut ? '적용됨' : '미적용'}`);
-    log(`  opt-out(config.telemetry=false): ${cfgOptOut ? '적용됨' : '미적용'}`);
-    log(`  실효 상태(effective): ${tc.countingActive() ? 'enabled' : 'disabled'}`);
-    log('  참고: 엔드포인트가 설정되어 있고 opt-out 이 아닐 때(env·config 둘 다 아님)만 실제로 전송됩니다.');
-
-    let cache = {};
-    try { cache = JSON.parse(tc.readRegular(tc.UPDATE_CHECK_PATH)); } catch { /* 캐시 없음/malformed/일반 파일 아님(FIFO 를 기다리지 않음) */ }
-    const installed = tc.installedVersion();
-    const cmp = (cache.latest && installed) ? tc.compareVersions(cache.latest, installed) : null;
-    log('[업데이트 체크] 새 버전 알림 (기본값: 켜짐)');
-    log(`  opt-out(BANKER_NO_UPDATE_CHECK/config.updateCheck=false): ${tc.noUpdateCheck() ? '적용됨' : '미적용'}`);
-    log(`  마지막 체크: ${cache.checkedAt ? new Date(cache.checkedAt).toISOString() : '없음'}`);
-    log(`  캐시된 최신 버전: ${cache.latest || '없음'} / 설치된 버전: ${installed || '알 수 없음'}`);
-    log(cmp === null ? '  비교 불가 (캐시 없음 또는 malformed)'
-      : cmp > 0 ? `  업데이트 있음 (${installed} → ${cache.latest})`
-      : '  최신 버전 사용 중');
+    printCountingStatus(tc);
+    printUpdateCheckStatus(tc);
     return;
   }
   log(TELEMETRY_USAGE);                                              // 알 수 없는 하위명령: 사용법 출력
 }
 
+// `telemetry on|off`: config 에 opt-out 을 저장하거나(off) 지워 기본값(켜짐)으로 돌아간다(on).
+function telemetrySwitch(tc, sub) {
+  const cfg = tc.readConfig();
+  if (sub === 'off') cfg.telemetry = false;                          // opt-out 저장
+  else delete cfg.telemetry;                                         // opt-out 해제: 기본-on 으로 복귀
+  if (!tc.writeConfig(cfg)) {
+    warn('banker: 설정을 저장하지 못했습니다 (config 쓰기 실패).');
+    process.exitCode = 1;
+    return;
+  }
+  if (sub === 'off') {
+    log('카운팅을 껐습니다 (off). config.telemetry=false 로 opt-out 을 저장했습니다.');
+    return;
+  }
+  log('카운팅 opt-out 을 해제했습니다 (on). 기본값(켜짐)으로 복귀합니다.');
+  if (!tc.endpoint()) log('참고: 엔드포인트가 설정되어 있지 않아 지금은 아무것도 전송하지 않습니다.');
+}
+
+// `telemetry status` 의 카운팅 절: 엔드포인트, 두 opt-out, 그 결과.
+function printCountingStatus(tc) {
+  const cfg = tc.readConfig();
+  const v = process.env.BANKER_NO_TELEMETRY;
+  const envOptOut = !(v === undefined || v === '' || v === '0' || v === 'false');
+  log('banker 상태:');
+  log('[카운팅] 익명 사용량 카운팅 (기본값: 켜짐 · count-default-on)');
+  log(`  엔드포인트 설정: ${tc.endpoint() != null ? '설정됨' : '미설정'}`);
+  log(`  opt-out(BANKER_NO_TELEMETRY): ${envOptOut ? '적용됨' : '미적용'}`);
+  log(`  opt-out(config.telemetry=false): ${cfg.telemetry === false ? '적용됨' : '미적용'}`);
+  log(`  실효 상태(effective): ${tc.countingActive() ? 'enabled' : 'disabled'}`);
+  log('  참고: 엔드포인트가 설정되어 있고 opt-out 이 아닐 때(env·config 둘 다 아님)만 실제로 전송됩니다.');
+}
+
+// `telemetry status` 의 업데이트 확인 절: opt-out, 마지막 확인과 실패한 시도, 캐시의 최신 버전과 설치 버전.
+function printUpdateCheckStatus(tc) {
+  const cache = readUpdateCacheFile(tc);
+  const installed = tc.installedVersion();
+  log('[업데이트 체크] 새 버전 알림 (기본값: 켜짐)');
+  log(`  opt-out(BANKER_NO_UPDATE_CHECK/config.updateCheck=false): ${tc.noUpdateCheck() ? '적용됨' : '미적용'}`);
+  printLastChecks(tc, cache);
+  log(`  캐시된 최신 버전: ${cache.latest || '없음'} / 설치된 버전: ${installed || '알 수 없음'}`);
+  log(versionVerdict(tc, cache, installed));
+}
+
+// update-check 캐시 객체. 없음, malformed, 객체가 아닌 JSON, 일반 파일 아님(FIFO 를 기다리지 않음)은 {}.
+function readUpdateCacheFile(tc) {
+  try {
+    const cache = JSON.parse(tc.readRegular(tc.UPDATE_CHECK_PATH));
+    return cache && typeof cache === 'object' && !Array.isArray(cache) ? cache : {};
+  } catch {
+    return {};
+  }
+}
+
+// 마지막 확인 시각, 그리고 그 뒤에 실패한 시도가 있으면 그 시각과 다음 시도. 다음 시도는 훅이 쓰는 updateCheckDue 로
+// 정한다: 지금보다 뒤의 시도 시각은 쉼으로 세지 않지만, 하루가 안 된 마지막 체크는 여전히 쉬게 한다.
+function printLastChecks(tc, cache) {
+  log(`  마지막 체크: ${isoTime(cache.checkedAt) || '없음'}`);
+  if (isoTime(cache.triedAt) && !(cache.triedAt <= cache.checkedAt)) log(`  마지막 시도: ${isoTime(cache.triedAt)} (실패. ${nextTry(tc, cache)})`);
+}
+
+// 실패한 시도 뒤 다음 시도가 언제인지, 훅이 쓰는 updateCheckDue 와 같은 규칙으로.
+function nextTry(tc, cache) {
+  if (!(cache.triedAt > Date.now())) return '그 뒤 24시간은 다시 시도하지 않습니다';
+  return tc.updateCheckDue(cache) ? '시각이 지금보다 뒤라 다음 세션 시작에 다시 시도합니다'
+    : '시각이 지금보다 뒤라 쉼으로 세지 않지만, 마지막 체크에서 24시간이 지나야 다시 시도합니다';
+}
+
+// 캐시의 최신 버전과 설치 버전을 견준 한 줄.
+function versionVerdict(tc, cache, installed) {
+  if (!cache.latest && Object.keys(cache).length) return '  비교 불가 (확인에 성공한 적이 없어 최신 버전 정보 없음)';
+  const cmp = (cache.latest && installed) ? tc.compareVersions(cache.latest, installed) : null;
+  if (cmp === null) return '  비교 불가 (캐시 없음 또는 malformed)';
+  return cmp > 0 ? `  업데이트 있음 (${installed} → ${cache.latest})` : '  최신 버전 사용 중';
+}
+
 const HELP = `banker v${version()} — install the banker plugin into Claude Code and/or Codex CLI
 
 Usage:
   banker setup [--claude] [--codex] [--scope user|project] [--dry-run]
   banker uninstall [--claude] [--codex] [--scope user|project] [--dry-run]
   banker telemetry <on|off|status>
+  banker hooks <status|enable|disable> [update|count|obsidize]   (Codex hooks in $CODEX_HOME/hooks.json, default ~/.codex)
   banker doctor
   banker help
 
 Notes:
   - setup/uninstall with no target flag applies to BOTH tools.
   - --claude registers the marketplace + installs banker@banker-plugins (skills as /banker:*).
-  - --codex copies codex-eligible skills -> ~/.codex/skills/banker-* and commands -> ~/.codex/prompts/banker-*.md.
+  - --codex copies codex-eligible skills -> ~/.codex/skills/banker-* and commands -> ~/.codex/prompts/banker-*.md
+    ($CODEX_HOME instead of ~/.codex when it is set).
   - telemetry on|off toggles anonymous usage counting opt-out (default-on; config only); status prints counting + update-check state. See PRIVACY.md.
   - Never runs as root. --dry-run prints planned actions without writing.`;
 
@@ -379,11 +552,12 @@ async function main() {
   if (a.help || a.cmd === 'help' || !a.cmd) { log(HELP); return; }
   if (a.cmd === 'doctor') { doctor(); return; }
   if (a.cmd === 'telemetry') { await telemetryCmd(a.sub); return; }
+  if (a.cmd === 'hooks') { assertNotRoot(); await hooksCmd(a.sub, a.hookIds); return; }
   assertNotRoot();
   if (a.cmd === 'setup') {
     log(`banker setup${a.dryRun ? ' (dry-run)' : ''}: claude=${a.claude} codex=${a.codex}`);
     if (a.claude) setupClaude(a.dryRun);
-    if (a.codex) setupCodex(a.dryRun, a.scope);
+    if (a.codex && setupCodex(a.dryRun, a.scope)) await setupCodexHooks(a.dryRun, a.scope);
     // Best-effort first-run prompts (interactive TTY only). A prompt failure must never fail setup.
     try { await maybeFirstRunPrompts(a); } catch { /* non-fatal */ }
     log('done.');
@@ -391,7 +565,10 @@ async function main() {
   }
   if (a.cmd === 'uninstall') {
     if (a.claude) uninstallClaude(a.dryRun);
-    if (a.codex) uninstallCodex(a.dryRun, a.scopeExplicit ? [a.scope] : ['user', 'project']);
+    if (a.codex) {
+      uninstallCodex(a.dryRun, a.scopeExplicit ? [a.scope] : ['user', 'project']);
+      if (!a.scopeExplicit || a.scope === 'user') await uninstallCodexHooks(a.dryRun);
+    }
     log('done.');
     return;
   }

package/bin/lib/codex-hooks.mjs

@@ -0,0 +1,249 @@
+/*
+ * banker 의 Codex 훅 설치. Claude Code 는 플러그인의 hooks/hooks.json 을 바로 읽지만 Codex 는
+ * <CODEX_HOME>/hooks.json 만 읽고, 새 훅은 사용자가 신뢰해야 돈다("Hooks need review", /hooks).
+ *
+ * - 훅 스크립트와 그 의존 파일을 <CODEX_HOME>/hooks-custom/banker/ 에 패키지와 같은 배치로 복사하고, 훅은 그 사본을
+ *   돌린다. Codex 는 신뢰한 훅을 샌드박스 밖에서 돌리므로, 작업 폴더 안의 파일을 가리키지 않게 하기 위해서다.
+ * - 묶음은 각 이벤트의 맨 뒤에 더한다. Codex 는 신뢰를 <hooks.json>:<이벤트>:<묶음 번호>:<항목 번호> 로 기록해, 앞에
+ *   끼우면 OMX 훅의 번호가 밀려 다시 신뢰해야 한다. 빼기는 우리 항목만, 낡은 명령은 같은 자리에서 고친다.
+ * - Windows 의 Codex 는 훅 명령을 PowerShell 로 돌린다(Codex 0.160.1 실측): `& '<node>' '<스크립트>' 인자`.
+ * - hooks.json 이 링크이거나 JSON 객체가 아니거나 "없음" 말고 다른 이유로 확인할 수 없으면 바꾸지 않는다. 바꿀 때마다
+ *   직전 내용을 hooks.json.banker.bak 에 둔다. smart-compact 의 codex-gate.mjs 와 같은 규칙이다.
+ */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// 훅마다 이벤트, 스크립트(패키지 기준 경로), 인자, 도구 이름 matcher(있으면 그 도구 호출 뒤에만 돈다).
+export const HOOKS = {
+  update: { event: 'SessionStart', script: 'hooks/update-notify.mjs', args: ['--codex'] },
+  count: { event: 'Stop', script: 'hooks/telemetry-count-codex.mjs', args: [] },
+  obsidize: { event: 'PostToolUse', script: 'hooks/obsidize-hook.mjs', args: ['--codex'], matcher: 'Bash' },
+};
+// 사본으로 옮길 파일(훅 스크립트와 그 의존 파일). 상대 경로를 그대로 둬 '../bin/lib/...' 가져오기가 맞는다.
+export const PAYLOAD = [
+  '.claude-plugin/plugin.json',
+  'bin/lib/telemetry-config.mjs',
+  'hooks/update-notify.mjs',
+  'hooks/update-fetch.mjs',
+  'hooks/update-checkin.mjs',
+  'hooks/telemetry-count-codex.mjs',
+  'hooks/obsidize-hook.mjs',
+  'skills/obsidizer/obsidize.mjs',
+];
+export const DEFAULT_HOOKS = ['update', 'count'];
+
+// Codex 처럼 상대 경로 CODEX_HOME 은 지금 폴더 기준으로 푼다.
+export function codexPaths(env = process.env) {
+  const home = env.CODEX_HOME ? path.resolve(env.CODEX_HOME) : path.join(os.homedir(), '.codex');
+  return { home, hooks: path.join(home, 'hooks.json'), backup: path.join(home, 'hooks.json.banker.bak'), dir: path.join(home, 'hooks-custom', 'banker') };
+}
+
+const isObject = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+
+function writeAtomic(file, data) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, data, { flag: 'wx' });
+    const mode = modeOf(file);
+    if (mode !== null) fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    fs.rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+function modeOf(file) {
+  try {
+    const st = fs.lstatSync(file);
+    return st.isFile() ? st.mode & 0o7777 : null;
+  } catch {
+    return null;
+  }
+}
+
+// 명령 글. POSIX 는 큰따옴표, 셸이 그 안에서 읽는 글자는 거부. Windows 는 PowerShell 호출 연산자와 작은따옴표.
+export function formatCommand(node, script, args, win = process.platform === 'win32') {
+  const all = [node, script, ...args].join('');
+  if (/[\r\n\0]/.test(all)) return null;
+  if (win) {
+    const q = (s) => `'${s.replace(/['‘-‛]/g, '$&$&')}'`;
+    return ['&', q(node), q(script), ...args].join(' ');
+  }
+  if (/["$`\\]/.test(all)) return null;
+  return [`"${node}"`, `"${script}"`, ...args].join(' ');
+}
+
+// 임시 폴더의 node 는 거부한다. Codex 안에서 돌 때는 작업 폴더 안의 node 도(샌드박스 안 세션이 고칠 수 있다).
+export function safeNode(node, { win = process.platform === 'win32', cwd = process.cwd(), codex = Boolean(process.env.CODEX_THREAD_ID) } = {}) {
+  const P = win ? path.win32 : path.posix;
+  const under = (f, dir) => {
+    const r = P.relative(dir, f);
+    return r === '' || (!r.startsWith('..') && !P.isAbsolute(r));
+  };
+  // A link elsewhere is judged where it leads too, so a link in a safe place cannot pin a node from the temp folder.
+  const places = [node, real(node)];
+  return !places.some((f) => under(f, os.tmpdir()) || (codex && under(f, cwd)));
+}
+
+function real(file) {
+  try {
+    return fs.realpathSync(file);
+  } catch {
+    return file;
+  }
+}
+
+const scriptOf = (p, id) => path.join(p.dir, ...HOOKS[id].script.split('/'));
+const markOf = (id) => `/hooks-custom/banker/${HOOKS[id].script}`;
+const isOurs = (h, id) => isObject(h) && typeof h.command === 'string' && h.command.replace(/\\/g, '/').includes(markOf(id));
+
+function fileKind(file) {
+  try {
+    const st = fs.lstatSync(file);
+    return st.isSymbolicLink() || !st.isFile() ? `${file} 이 일반 파일이 아님(링크나 폴더)` : '';
+  } catch (e) {
+    return e && e.code === 'ENOENT' ? 'missing' : `${file} 을 확인하지 못함(${e && e.code})`;
+  }
+}
+
+// hooks.json 을 객체로, 또는 바꿀 수 없는 까닭. 쓰는 이벤트의 값이 배열이 아니면 거부한다.
+export function loadHooks(file, events) {
+  const kind = fileKind(file);
+  if (kind === 'missing') return { doc: { hooks: {} } };
+  if (kind) return { why: kind };
+  let doc;
+  try {
+    doc = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    doc = null;
+  }
+  if (!isObject(doc)) return { why: `${file} 이 JSON 객체가 아님` };
+  if (doc.hooks === undefined) doc.hooks = {};
+  if (!isObject(doc.hooks)) return { why: `${file} 의 hooks 가 객체가 아님` };
+  const bad = events.find((e) => doc.hooks[e] !== undefined && !Array.isArray(doc.hooks[e]));
+  return bad ? { why: `${file} 의 ${bad} 가 배열이 아님` } : { doc };
+}
+
+function findOurs(groups, id) {
+  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((x) => isOurs(x, id));
+    if (h >= 0) return [g, h];
+  }
+  return null;
+}
+
+function saveHooks(p, doc) {
+  if (fs.existsSync(p.hooks)) writeAtomic(p.backup, fs.readFileSync(p.hooks));
+  writeAtomic(p.hooks, `${JSON.stringify(doc, null, 2)}\n`);
+}
+
+// 사본 폴더. 링크인 폴더는 거부하고, 파일은 내용이 다를 때만 새로 쓴다.
+export function installPayload(p, pkgRoot) {
+  fs.mkdirSync(p.dir, { recursive: true });
+  if (fs.lstatSync(p.dir).isSymbolicLink()) return `${p.dir} 이 링크임`;
+  for (const rel of PAYLOAD) {
+    const dest = path.join(p.dir, ...rel.split('/'));
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    if (fs.existsSync(dest) && !fs.lstatSync(dest).isFile()) return `${dest} 이 일반 파일이 아님`;
+    const data = fs.readFileSync(path.join(pkgRoot, ...rel.split('/')));
+    if (!fs.existsSync(dest) || !fs.readFileSync(dest).equals(data)) writeAtomic(dest, data);
+  }
+  return '';
+}
+
+// 한 훅을 제자리에 두기: 없으면 이벤트 맨 뒤 묶음으로, 명령이 낡았으면 같은 자리에서 고친다. 바뀌었으면 true.
+function place(doc, id, command) {
+  const ev = HOOKS[id].event;
+  const groups = doc.hooks[ev] || [];
+  const at = findOurs(groups, id);
+  if (at && groups[at[0]].hooks[at[1]].command === command) return false;
+  if (at) groups[at[0]].hooks[at[1]] = { ...groups[at[0]].hooks[at[1]], command, timeout: 5 };
+  else groups.push({ ...(HOOKS[id].matcher ? { matcher: HOOKS[id].matcher } : {}), hooks: [{ type: 'command', command, timeout: 5 }] });
+  doc.hooks[ev] = groups;
+  return true;
+}
+
+// Codex 홈이 지금 폴더나 그 저장소 안이면(예: 저장소의 .envrc 가 CODEX_HOME=./.codex) 훅 사본도 작업 폴더 안에 놓여,
+// 샌드박스 안의 세션이 샌드박스 밖에서 도는 훅을 고칠 수 있다. 홈 폴더와 파일 시스템 루트는 작업 폴더로 보지 않는다.
+export function homeInWorkspace(home, cwd = process.cwd()) {
+  const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', windowsHide: true });
+  const roots = [cwd, top.status === 0 ? top.stdout.trim() : ''].filter(Boolean).map(real);
+  const skip = new Set([real(os.homedir()), path.parse(real(cwd)).root]);
+  const h = real(home);
+  return roots.some((r) => !skip.has(r) && (h === r || h.startsWith(r.endsWith(path.sep) ? r : r + path.sep)));
+}
+
+// ids 를 켠다. { code, changed:[id], msg }. code 1 이면 아무것도 바꾸지 않았다.
+export function enableHooks(p, ids, pkgRoot, node = process.execPath, cwd = process.cwd()) {
+  if (!safeNode(node)) return { code: 1, changed: [], msg: `node 가 안전하지 않은 곳에 있음(${node})` };
+  if (homeInWorkspace(p.home, cwd)) return { code: 1, changed: [], msg: `Codex 홈(${p.home})이 작업 폴더 안이라 훅을 설치하지 않음. 샌드박스가 고칠 수 있는 곳임` };
+  const { doc, why } = loadHooks(p.hooks, ids.map((id) => HOOKS[id].event));
+  if (why) return { code: 1, changed: [], msg: why };
+  const cmds = ids.map((id) => [id, formatCommand(node, scriptOf(p, id), HOOKS[id].args)]);
+  if (cmds.some(([, c]) => !c)) return { code: 1, changed: [], msg: '경로에 셸이 읽는 글자가 있음' };
+  const bad = installPayload(p, pkgRoot);
+  if (bad) return { code: 1, changed: [], msg: bad };
+  const changed = cmds.filter(([id, c]) => place(doc, id, c)).map(([id]) => id);
+  if (changed.length) saveHooks(p, doc);
+  return { code: 0, changed, msg: '' };
+}
+
+// ids 를 끈다: 우리 항목만 빼고, 비는 묶음과 이벤트를 지운다. 뒤 묶음의 번호가 밀리면 shifted 에 이벤트를 적는다.
+export function disableHooks(p, ids) {
+  const { doc, why } = loadHooks(p.hooks, ids.map((id) => HOOKS[id].event));
+  if (why) return { code: 1, changed: [], shifted: [], msg: why };
+  const changed = [];
+  const shifted = [];
+  for (const id of ids) {
+    const ev = HOOKS[id].event;
+    const groups = doc.hooks[ev] || [];
+    const at = findOurs(groups, id);
+    if (!at) continue;
+    const hs = groups[at[0]].hooks.filter((h) => !isOurs(h, id));
+    if (hs.length) groups[at[0]].hooks = hs;
+    else {
+      if (at[0] < groups.length - 1) shifted.push(ev);
+      groups.splice(at[0], 1);
+    }
+    if (groups.length) doc.hooks[ev] = groups;
+    else delete doc.hooks[ev];
+    changed.push(id);
+  }
+  if (changed.length) saveHooks(p, doc);
+  return { code: 0, changed, shifted, msg: '' };
+}
+
+// 훅마다 'on' | 'off' | 'stale'(명령이 이 node 와 사본을 가리키지 않거나 사본이 이 판과 다름). 읽지 못하면 why.
+export function hookStatus(p, ids, pkgRoot, node = process.execPath) {
+  const { doc, why } = loadHooks(p.hooks, ids.map((id) => HOOKS[id].event));
+  if (why) return { why };
+  const out = {};
+  for (const id of ids) {
+    const groups = doc.hooks[HOOKS[id].event] || [];
+    const at = findOurs(groups, id);
+    if (!at) out[id] = 'off';
+    else out[id] = groups[at[0]].hooks[at[1]].command === formatCommand(node, scriptOf(p, id), HOOKS[id].args) && copyCurrent(p, pkgRoot) ? 'on' : 'stale';
+  }
+  return { status: out };
+}
+
+function copyCurrent(p, pkgRoot) {
+  try {
+    return PAYLOAD.every((rel) => fs.readFileSync(path.join(p.dir, ...rel.split('/'))).equals(fs.readFileSync(path.join(pkgRoot, ...rel.split('/')))));
+  } catch {
+    return false;
+  }
+}
+
+// 모든 banker 훅을 빼고 사본 폴더를 지운다(banker uninstall --codex).
+export function removeAll(p) {
+  const r = disableHooks(p, Object.keys(HOOKS));
+  if (r.code === 0) fs.rmSync(p.dir, { recursive: true, force: true });
+  return r;
+}
+
+export const TRUST_NOTE = 'Codex 를 다시 열면 뜨는 Hooks need review 창이나 /hooks 에서 banker 훅을 신뢰하십시오. 신뢰 전에는 돌지 않습니다.';