@kaydash9999/banker-plugins 0.20.5 → 0.21.0

package/codex/skills/progress/scripts/progress.mjs

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+/*
+ * banker progress (Codex) - 지금 Codex 세션의 진행 상황을 텍스트 트리로 보인다. Claude Code 의 /progress 패널에 해당한다.
+ *
+ * 읽는 것은 이 세션의 기록(rollout) 하나다. Codex 는 셸에 CODEX_THREAD_ID 를 주고, 그 id 가 rollout 파일 이름 끝에 있다.
+ *  - 계획: 이 세션이 도구 호출(exec_command 의 명령, apply_patch 의 파일 머리)로 다룬 마지막 계획 파일(.omx/plans/*.md,
+ *    .omc/plans/*.md, docs/superpowers/plans/*.md, ~/.claude/plans/*.md, prd.json, ultragoal/goals.json). 트리 엔진은
+ *    Claude Code 패널과 같은 progress-plan.mjs(hooks/progress-plan.mjs 의 같은 사본, scripts/sync-adapter.js 가 지킴).
+ *  - 단계: 마지막 update_plan 의 계획. 없으면 이 세션에서 사용자가 입력한 요청.
+ *  - 하위 목록: 진행 중인 단계(없으면 마지막 요청) 뒤의 최근 도구 호출.
+ * 파일은 읽기만 한다. --pane 만 tmux 칸을 열고 닫는다.
+ *
+ * 사용: node progress.mjs [--depth N] [--rollout FILE] [--follow] [--pane on|off]
+ */
+import { spawnSync } from 'node:child_process';
+import { closeSync, constants, existsSync, fstatSync, openSync, readdirSync, readSync, realpathSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { clip, fit, parsePlan, planKind } from './progress-plan.mjs';
+
+const MAX_READ = 32 << 20;
+const PLAN_READ = 1 << 20;
+const RECENT_CALLS = 5;
+const RECENT_PROMPTS = 10;
+const PANE_TITLE = 'banker-progress';
+const ID_RE = /^[0-9A-Za-z-]{8,64}$/;
+
+// 계획 파일인지: Claude Code 패널의 규칙에 OMX 의 계획 폴더(.omx/plans)를 더한다. 'plan', 'weak', null.
+export function codexPlanKind(path) {
+  const p = String(path ?? '').replaceAll('\\', '/');
+  return planKind(p.replace(/\/\.omx\/plans\//, '/.omc/plans/'));
+}
+
+export function rolloutFor(thread, env = process.env) {
+  if (!ID_RE.test(thread ?? '')) return null;
+  const root = join(env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
+  const hits = [];
+  for (const y of list(root)) for (const m of list(join(root, y))) for (const d of list(join(root, y, m))) {
+    for (const f of list(join(root, y, m, d))) if (f.startsWith('rollout-') && f.endsWith(`-${thread}.jsonl`)) hits.push(join(root, y, m, d, f));
+  }
+  return hits.sort().at(-1) ?? null;
+}
+
+function list(dir) {
+  try { return readdirSync(dir).sort(); } catch { return []; }
+}
+
+// 일반 파일만 연다: 기다리지 않게 O_NONBLOCK 으로 열고, 연 것이 일반 파일인지 fstat 으로 본다. 아니면 null.
+function openRegular(file) {
+  const fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+  if (fstatSync(fd).isFile()) return fd;
+  closeSync(fd);
+  return null;
+}
+
+// 일반 파일의 끝 max 바이트를 줄로. 앞에서 잘린 첫 줄은 버린다.
+export function tail(file, max = MAX_READ) {
+  const fd = openRegular(file);
+  if (fd === null) return [];
+  try {
+    const size = fstatSync(fd).size;
+    const start = Math.max(0, size - max);
+    const buf = Buffer.alloc(size - start);
+    readSync(fd, buf, 0, buf.length, start);
+    const lines = buf.toString('utf8').split('\n');
+    if (start > 0) lines.shift();
+    lines.cut = start > 0; // 앞쪽을 읽지 않았는지
+    return lines;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// 기록 첫 줄(session_meta)의 Codex 판. 끝만 읽은 기록에서도 판을 알기 위해 앞에서 따로 읽는다.
+function headVersion(file) {
+  const fd = openRegular(file);
+  if (fd === null) return '';
+  try {
+    const buf = Buffer.alloc(Math.min(fstatSync(fd).size, 8 << 20));
+    readSync(fd, buf, 0, buf.length, 0);
+    const rec = json(buf.toString('utf8').split('\n')[0]);
+    return rec?.type === 'session_meta' ? String(rec.payload?.cli_version ?? '?') : '';
+  } finally {
+    closeSync(fd);
+  }
+}
+
+const json = (text) => { try { return JSON.parse(text); } catch { return null; } };
+
+// rollout 줄에서 이 도구가 쓰는 기록만: 세션 머리, 사용자 요청, 도구 호출.
+export function records(lines) {
+  const out = { cwd: '', version: '', prompts: [], calls: [], plan: null, planAt: -1 };
+  for (const line of lines) {
+    if (!line.includes('"session_meta"') && !line.includes('"user_message"') && !line.includes('"UserMessage"') && !line.includes('_call"')) continue;
+    const rec = json(line);
+    const p = rec?.payload;
+    if (!p || typeof p !== 'object') continue;
+    if (rec.type === 'session_meta') [out.cwd, out.version] = [String(p.cwd ?? ''), String(p.cli_version ?? '?')];
+    else if (rec.type === 'event_msg' && p.type === 'user_message' && typeof p.message === 'string') takePrompt(out, p.message);
+    else if (rec.type === 'event_msg' && p.type === 'item_completed' && p.item?.type === 'UserMessage') takePrompt(out, itemText(p.item));
+    else if (rec.type === 'response_item' && /_call$/.test(String(p.type))) takeCall(out, p);
+  }
+  return out;
+}
+
+// Codex 0.160 은 사용자 글을 item_completed 의 UserMessage 로 쓴다. 두 형식이 함께 오면 같은 글은 한 번만.
+const itemText = (item) => (Array.isArray(item.content) ? item.content.map((c) => (typeof c?.text === 'string' ? c.text : '')).join('\n') : '');
+function takePrompt(out, text) {
+  const last = out.prompts.at(-1);
+  if (text && !(last && last.text === text && last.at === out.calls.length)) out.prompts.push({ text, at: out.calls.length });
+}
+
+function takeCall(out, p) {
+  const name = typeof p.name === 'string' && p.name ? p.name : String(p.type).slice(0, -5);
+  if (name === 'update_plan') {
+    const plan = json(p.arguments)?.plan;
+    if (Array.isArray(plan)) [out.plan, out.planAt] = [plan.filter((s) => s && typeof s.step === 'string'), out.calls.length];
+    return;
+  }
+  const args = typeof p.arguments === 'string' ? json(p.arguments) ?? {} : {};
+  const input = typeof p.input === 'string' ? p.input : '';
+  out.calls.push({ name, cmd: typeof args.cmd === 'string' ? args.cmd : '', workdir: typeof args.workdir === 'string' ? args.workdir : '', input });
+}
+
+// 한 도구 호출이 다룬 파일 경로들(명령의 낱말, apply_patch 의 파일 머리). Codex 0.160 은 도구를 코드로 부르므로
+// (`exec` 의 입력 `tools.exec_command({cmd:'...'})`) 그 입력의 낱말도 본다.
+export function pathsOf(call, cwd) {
+  // The code input is JS source, so a Windows path in it has each backslash written twice.
+  const code = call.name === 'apply_patch' ? '' : call.input.replace(/\\\\/g, '\\');
+  const words = `${call.cmd} ${code}`.match(/[^\s'"`;|&<>(){},]+\.(?:md|json)\b/g) ?? [];
+  const heads = [...call.input.matchAll(/^\*\*\* (?:Add|Update) File: (.+)$/gm)].map((m) => m[1].trim());
+  const base = call.workdir || cwd;
+  return [...words, ...heads].map((w) => (w.startsWith('~/') ? join(homedir(), w.slice(2)) : isAbsolute(w) || !base ? w : resolve(base, w)));
+}
+
+// 이 세션이 마지막으로 다룬 계획 파일. 리뷰 기록 같은 약한 계획은 다른 계획이 없을 때만.
+export function lastPlan(calls, cwd) {
+  let weak = null;
+  for (let i = calls.length - 1; i >= 0; i--) {
+    for (const path of pathsOf(calls[i], cwd).reverse()) {
+      const kind = codexPlanKind(path);
+      if (kind === 'plan' && existsSync(path)) return path;
+      if (kind === 'weak' && !weak && existsSync(path)) weak = path;
+    }
+  }
+  return weak;
+}
+
+function readPlan(path) {
+  try {
+    const fd = openRegular(path);
+    if (fd === null) return null;
+    try {
+      const buf = Buffer.alloc(Math.min(fstatSync(fd).size, PLAN_READ));
+      readSync(fd, buf, 0, buf.length, 0);
+      return parsePlan(path, buf.toString('utf8'));
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+
+const BOX = { completed: '[x]', in_progress: '[>]', pending: '[ ]' };
+const box = (status) => BOX[status] ?? '';
+const one = (text, n) => clip(String(text ?? '').replace(/\s+/g, ' ').trim(), n);
+
+function nodeText(n) {
+  const t = n.text || (Array.isArray(n.parts) ? n.parts.join(' ') : '') || n.name || n.head || '';
+  return [box(n.status), n.kind === 'item' && !n.status && n.marker ? (/\d/.test(n.marker) ? `${n.marker}.` : '-') : '', one(t, 100), n.count ? `(${n.count})` : '']
+    .filter(Boolean).join(' ');
+}
+
+export function renderTree(nodes, depth, out = [], level = 0) {
+  for (const n of nodes) {
+    out.push(`${'  '.repeat(level + 1)}${nodeText(n)}`);
+    if (n.children?.length && level + 1 < depth) renderTree(n.children, depth, out, level + 1);
+    else if (n.children?.length) out[out.length - 1] += ` (+${n.children.length})`;
+  }
+  return out;
+}
+
+// 한 도구 호출의 한 줄. 코드로 부른 도구는 그 안의 도구 이름과 cmd 를 보인다.
+function callLine(c) {
+  const inner = c.input.match(/\btools\.(\w+)\(\{\s*cmd:\s*(['"`])((?:\\.|(?!\2).){0,200})/);
+  const name = inner ? inner[1] : c.name;
+  const what = c.cmd || (inner ? inner[3].replace(/\\(.)/g, '$1') : c.input.match(/^\*\*\* \w+ File: .+$/m)?.[0] ?? '');
+  return `      - ${name}${what ? `: ${one(what, 80)}` : ''}`;
+}
+
+function stepLines(r) {
+  const out = [];
+  if (r.plan) {
+    out.push('단계 (update_plan)');
+    const current = r.plan.findIndex((s) => s.status === 'in_progress');
+    r.plan.forEach((s, i) => {
+      out.push(`  ${box(s.status) || '[ ]'} ${one(s.step, 100)}`);
+      if (i === current) out.push(...r.calls.slice(r.planAt).slice(-RECENT_CALLS).map(callLine));
+    });
+    return out;
+  }
+  const prompts = r.prompts.slice(-RECENT_PROMPTS);
+  out.push(prompts.length ? '요청 (update_plan 없음)' : '요청 없음');
+  prompts.forEach((p, i) => {
+    const last = i === prompts.length - 1;
+    out.push(`  ${last ? '[>]' : '[x]'} ${one(p.text, 100)}`);
+    if (last) out.push(...r.calls.slice(p.at).slice(-RECENT_CALLS).map(callLine));
+  });
+  return out;
+}
+
+// rollout 하나를 진행 상황 글로.
+export function render(file, depth = 2, max = MAX_READ) {
+  const lines = tail(file, max);
+  const r = records(lines);
+  if (lines.cut) r.version = headVersion(file);
+  const out = [`진행 상황 (${file.split(/[\\/]/).at(-1).slice(-42, -6)})`];
+  const planPath = lastPlan(r.calls, r.cwd);
+  const plan = planPath && readPlan(planPath);
+  if (plan) {
+    out.push(`계획: ${clip(planPath, 200)}${plan.hasStates ? `  ${plan.done}/${plan.total}` : ''}`);
+    out.push(...renderTree(plan.tree, depth));
+    if (plan.treeCut) out.push('  (계획이 길어 일부만 보임)');
+  } else out.push('계획 파일 없음');
+  out.push('', ...stepLines(r));
+  // Codex 세션은 언제나 사용자 글로 시작한다. 하나도 못 읽었으면 이 Codex 판의 기록 형식이 바뀐 것이라 빈 결과로 넘기지 않는다.
+  if (r.version && !r.prompts.length && lines.cut) out.push('', '참고: 기록이 32 MB 를 넘어 끝부분만 읽었고, 그 안에는 사용자 요청이 없음');
+  else if (r.version && !r.prompts.length) {
+    out.push('', `경고: 이 Codex ${r.version} 기록에서 사용자 요청을 하나도 읽지 못함. 기록 형식이 바뀌었을 수 있음(banker 업데이트 확인)`);
+  }
+  return out.join('\n');
+}
+
+function opt(argv, name, fallback) {
+  const i = argv.indexOf(name);
+  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : fallback;
+}
+
+function pane(mode, file, depth) {
+  if (!process.env.TMUX) return 'tmux 안이 아니라 칸을 열 수 없음. 진행 상황은 이 출력으로 봄';
+  const ids = spawnSync('tmux', ['list-panes', '-F', '#{pane_id} #{pane_title}'], { encoding: 'utf8' });
+  if (ids.status !== 0) return `tmux 에 닿지 못함(${(ids.stderr || '').trim() || ids.error?.code}). 샌드박스 밖 실행 승인이 필요할 수 있음`;
+  for (const l of ids.stdout.split('\n')) if (l.endsWith(` ${PANE_TITLE}`)) spawnSync('tmux', ['kill-pane', '-t', l.split(' ')[0]]);
+  if (mode === 'off') return 'progress 칸을 닫음';
+  const me = fileURLToPath(import.meta.url);
+  const cmd = [process.execPath, me, '--follow', '--rollout', file, '--depth', String(depth)].map((a) => `'${a.replaceAll("'", "'\\''")}'`).join(' ');
+  const r = spawnSync('tmux', ['split-window', '-h', '-d', '-l', '40%', '-P', '-F', '#{pane_id}', cmd], { encoding: 'utf8' });
+  if (r.status !== 0) return `칸을 열지 못함(${(r.stderr || '').trim()})`;
+  spawnSync('tmux', ['select-pane', '-t', r.stdout.trim(), '-T', PANE_TITLE]);
+  return 'progress 칸을 오른쪽에 엶(2초마다 갱신). 닫기: --pane off';
+}
+
+// 기록 크기, 바뀐 시각, 칸 폭이 그대로면 다시 읽지 않는다(2초마다 32 MB 를 읽지 않게).
+function follow(file, depth) {
+  let seen = '';
+  const draw = () => {
+    let key = '';
+    // 10초마다는 다시 그린다: 계획 파일만 바뀐 것은 기록 크기로 알 수 없다.
+    try { const st = statSync(file); key = `${st.size}:${st.mtimeMs}:${process.stdout.columns}:${Math.floor(Date.now() / 10000)}`; } catch { key = 'gone'; }
+    if (key === seen) return;
+    seen = key;
+    let text;
+    try { text = render(file, depth); } catch (e) { text = `읽지 못함: ${e.message}`; }
+    const width = process.stdout.columns || 80;
+    process.stdout.write(`\x1b[2J\x1b[H${text.split('\n').map((l) => fit(l, width)).join('\n')}\n`);
+  };
+  draw();
+  setInterval(draw, 2000);
+}
+
+function main(argv) {
+  const depth = Math.max(1, Math.min(9, Number.parseInt(opt(argv, '--depth', '2'), 10) || 2));
+  const file = opt(argv, '--rollout', null) ?? rolloutFor(process.env.CODEX_THREAD_ID);
+  if (!file) {
+    console.error('Codex 세션 기록을 찾지 못함: Codex 안(CODEX_THREAD_ID)에서 실행하거나 --rollout FILE 을 줌');
+    return 2;
+  }
+  if (argv.includes('--follow')) return follow(file, depth);
+  if (argv.includes('--pane')) {
+    console.log(pane(opt(argv, '--pane', 'on') === 'off' ? 'off' : 'on', file, depth));
+    return 0;
+  }
+  console.log(render(file, depth));
+  return 0;
+}
+
+// 직접 실행일 때만 main. 경로에 링크가 있어도(~/.codex 가 링크인 경우) 같은 파일로 본다.
+const same = (a, b) => { try { return realpathSync(a) === realpathSync(b); } catch { return false; } };
+if (process.argv[1] && same(fileURLToPath(import.meta.url), resolve(process.argv[1]))) {
+  const code = main(process.argv.slice(2));
+  if (typeof code === 'number') process.exitCode = code;
+}

package/codex/transform-matrix.md

@@ -1,25 +1,27 @@
 # 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` surfaces ONLY (`claude-only` surfaces are never written to Codex — currently there are none; every surface is `both`).
+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`).
 
 | Source (Claude) | Codex destination | Transform |
 |---|---|---|
 | `skills/<name>/SKILL.md` (+ subtree) | `~/.codex/skills/banker-<name>/` (whole dir) | **COPY subtree** (Windows: no symlink), then **rewrite the frontmatter `name:` to `banker-<name>`**. Codex discovers skills by directory and requires `name:` == directory name, so the prefix must be applied to both (leaving `name: <name>` while the dir is `banker-<name>` makes Codex skip the skill). `description` is left as-is. |
-| `commands/<name>.md` | `~/.codex/prompts/banker-<name>.md` | Near-identical (frontmatter `description`+`argument-hint`). Codex prompts are flat → the `banker-` prefix lives in the filename; invoked as `/banker-<name>`. |
+| `commands/<name>.md` | `~/.codex/prompts/banker-<name>.md` **and** `~/.codex/skills/banker-<name>/SKILL.md` | The prompt file is near-identical (frontmatter `description`+`argument-hint`), for Codex builds that still read custom prompts (`/banker-<name>`). Codex 0.144+ has no custom prompts (`/banker-x` is an unrecognized command), so each command is also written as a skill: frontmatter `name: banker-<name>` + the command's `description`, then one line saying `$ARGUMENTS`/`$1` mean the text after `$banker-<name>`, then the command body. Invoked as `$banker-<name>`. |
+| `codex/skills/<name>/` (`codex-only`) | `~/.codex/skills/banker-<name>/` | Same copy and `name:` rewrite as a `both` skill. |
+| `hooks/update-notify.mjs`, `hooks/telemetry-count-codex.mjs` (+ the modules they import) | `~/.codex/hooks-custom/banker/` + one group each in `~/.codex/hooks.json` | `bin/lib/codex-hooks.mjs`: copies the hook payload out of any workspace, then appends one group per hook last under its event (`SessionStart` for the update notice with `--codex`, `Stop` for usage counting). Only our handlers are ever removed (`banker uninstall --codex`, `banker hooks disable <name>`); a stale command is fixed in place; a link or a malformed `hooks.json` is refused; a Codex home inside the current folder or its git repository (the home folder and the filesystem root aside) gets no hooks, since a sandboxed session could edit the copies; the file is backed up to `hooks.json.banker.bak` before each write. Windows uses the PowerShell call form `& '<node>' '<script>'`. Codex runs a new hook only after the user trusts it (Hooks need review, `/hooks`). |
 | (none) | `~/.codex/AGENTS.md` | **NOT TOUCHED by setup.** omx regenerates it (clobber risk, `:7`/`:253`); `omx setup --merge-agents` keeps only `<!-- USER:OMX:POLICY:START -->`…`END` blocks on a rewrite; `--force`, a confirmed overwrite, and a plain `omx setup` with team mode off replace the file whole; a plain `omx setup` with team mode on only refreshes the model table. Rely on `~/.codex/skills/` auto-discovery. The runtime writers are the `tone-compact` and `anti-drm` skills, at the user's request, each inside such a block. |
 
 ## Naming
 - Codex skill dir **and** frontmatter `name:`: `banker-<name>` (avoids collision with omx/system skills; kept in sync so Codex discovers it).
-- Codex prompt file: `banker-<name>.md` → invoked `/banker-<name>`.
+- Codex prompt file: `banker-<name>.md` → invoked `/banker-<name>` where custom prompts exist; the same command as a skill is `$banker-<name>`.
 
 ## Scope
 - `--scope user` (default) → `~/.codex/…`. `--scope project` → `./.codex/…`.
 
 ## Runtime-aware surfaces (both) — Codex uses OMX / Codex equivalents
-현재 `claude-only` 표면은 **없다**(전부 `both`). OMC/Claude 에 결합됐던 표면은 본문이 런타임 인식으로 작성돼 Codex에서도 동작한다 — Codex에선 OMC 대신 oh-my-codex(OMX)의 동명 스킬을 쓴다:
+현재 `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 여야 한다(사전 점검은 종료 코드가 아니라 출력 문구로).
-- `setup-omc` → `omx setup`(본문에 이미 존재). `setup-omc-hud` → OMX `hud`. `setup-stitch` → `codex mcp add`.
+- `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`.
 
@@ -28,27 +30,30 @@ The generator (`banker setup --codex`) applies the rules below for `target: both
 - `deep-init` → 서브에이전트 Claude=OMC explore/architect/writer, Codex=OMX worker/explore(부재 시 직접 수행). 순수 fs+doc.
 - `deep-research` → Claude 번들 워크플로/`WebSearch`, Codex OMX `autoresearch`/`best-practice-research`.
 - `ralph-qa` → 백본은 세션 모델로 띄운 검토 에이전트 3개 이상이다(Claude=Agent 의 `Plan` 을 `model` 없이, Codex=`spawn_agent` 를 역할 없이, 저자 대화를 넘기지 않고). 두 런타임 모두 Bash 가 있어 읽기 전용은 지시로 선다. 외부 좌석은 `--codex`·`--gemini`·`--opencode` 를 줄 때만 앉고, 저자 계열은 앉지 않는다(Codex 런타임의 `--codex` 는 자기 자신이라 부적격). Codex 의 `workspace-write` 샌드박스는 HOME 쓰기를 막아 gemini, opencode 가 시작부터 실패하고, Linux 에서는 페이로드 기준 폴더(`$XDG_RUNTIME_DIR`, `~/.cache`)도 막는다. 그래서 외부 좌석 전송의 실행기 명령 전부(`seat-run.mjs` 의 init, untracked, prepare, check, send, cleanup, put)를 승인을 받아 샌드박스 밖에서 실행한다.
-- `lineage` → 기본 흐름의 검토자는 세션 모델이다(Claude=Agent 의 `Plan` 을 `model` 없이, Codex=`spawn_agent` 를 역할 없이, 저자 대화를 넘기지 않고). 띄울 수 없으면 세션이 파트를 직접 검토한다. Codex 검토자에게는 파일 읽기 도구가 없어 파트 파일을 읽는 셸 명령만 쓰게 한다. `workspace-write` 샌드박스에서는 `~/.cache` 에 쓸 수 없어 이번 실행의 검토 결정을 캐시에 쓰지 못한다(WARN). 앞선 실행이 남긴 결정은 읽는다. 읽는 기록은 Claude Code 형식뿐이라 Codex 에서는 Claude Code 기록을 내보낼 때만 쓴다. `--rulebase` 는 모델 호출 없이 양쪽 같다.
-- `smart-compact` → Claude statusLine `context_window.used_percentage`+hook; Codex 신호 미확인 시 휴리스틱 폴백. TUI 3단(`/copy`·`/compact`·paste)은 유저.
+- `lineage` → 기본 흐름의 검토자는 세션 모델이다(Claude=Agent 의 `Plan` 을 `model` 없이, Codex=`spawn_agent` 를 역할 없이, 저자 대화를 넘기지 않고). 띄울 수 없으면 세션이 파트를 직접 검토한다. Codex 검토자에게는 파일 읽기 도구가 없어 파트 파일을 읽는 셸 명령만 쓰게 한다. `workspace-write` 샌드박스에서는 `~/.cache` 에 쓸 수 없어 이번 실행의 검토 결정을 캐시에 쓰지 못한다(WARN). 앞선 실행이 남긴 결정은 읽는다. Codex rollout 도 읽는다: Codex 안에서는 `CODEX_THREAD_ID`(rollout 파일 이름 끝의 id)로 지금 세션을 찾고, `--all-sessions` 는 `session_meta` 의 cwd 가 지금 폴더인 rollout 을 합친다. 사용자가 입력한 글(`user_message`), 모델의 답(`agent_message`), 도구 호출 이름(`*_call`)만 읽고 모델 입력, 추론, 도구 결과는 읽지 않는다. 캐시는 4단계를 승인받아 샌드박스 밖에서 돌리거나 `--add-dir ~/.cache/lineage` 로 쓴다. `--rulebase` 는 모델 호출 없이 양쪽 같다.
+- `smart-compact` → Claude statusLine `context_window.used_percentage`+hook; Codex 는 `scripts/codex-gate.mjs` 사본(`$CODEX_HOME/hooks-custom/`)을 `UserPromptSubmit` 훅으로 `hooks.json` 맨 뒤에 더해, 훅 입력의 `transcript_path`(rollout)에서 마지막 `token_count` 의 `last_token_usage.total_tokens` / `model_context_window` 로 잰다(0.144.5 실측). 새 훅은 사용자가 신뢰해야 돈다("Hooks need review", `/hooks`). TUI 3단(`/copy`·`/compact`·paste)은 유저.
 - `curation` → 런타임 무관(외부 의존 0, 양쪽 동일).
 
 ## Caveats (documented; not blockers)
-- `append_wiki`, `compact-wiki` — use `wiki_*` MCP at runtime → copy fine, need a wiki MCP available in Codex.
+- `append_wiki`, `compact-wiki` — Claude Code uses the OMC `wiki_*` MCP over `.omc/wiki`; Codex has no wiki MCP, so both skills tell it to use the `omx wiki <tool> --input <json> --json` CLI over `omx_wiki/` (same tool names and inputs, workspace-only writes).
 - `audit-web-page`, `play-qa`, `ultra-ui-qa` — need playwright (install via `setup-playwright`).
 - `setup-playwright` — genericize the `/banker:setup` trigger phrasing for the Codex copy.
 - `visual-ralph` — needs an imagegen path (Stitch via `setup-stitch`, or `/ccg`/Gemini) + a frontend repo; static/live-URL reference works without imagegen.
 - `ralph-qa` — runs with no external dependency: the backbone of 3+ session-model reviewer agents always runs, and an external CLI seat joins only on its flag (`--codex`, `--gemini`, `--opencode`), on that CLI's best model as the probe reads it from local config and the CLI's bundled list (the probe sends no HTTP request and no prompt; opencode is started with its model-list refresh off). Its absence is a coverage fact (model axis uncovered), not a degraded mode. A same-runtime `critic` is never substituted for an external seat — on Codex that would be GPT approving GPT, i.e. self-approval.
 - `deep-research` — needs web search/fetch (Claude WebSearch/WebFetch or bundled workflow; Codex OMX autoresearch).
-- `smart-compact` — Claude statusLine exposes context%; Codex signal unconfirmed → heuristic fallback; `/copy`·`/compact`·paste stay user-driven (TUI).
-- `obsidizer` — OMC-managed trees respect the 9-field frontmatter whitelist + reserved files + no-rename + bare `[[slug]]` links only; `aliases` are written in generic vaults only; Canvas sidecars and body-inline `::` are durable in-place; no `wiki_*` write dependency, `wiki_lint` read-only for verification. `--enable` is Claude-only (plugin-declared PostToolUse hook); Codex has no MCP tool hooks → honest no-op.
-- `payload-mon` — needs the OMC custom HUD wrapper (`setup-omc-hud`). It measures Claude Code sessions only; from Codex it manages the same machine's Claude Code HUD wrapper and never measures Codex's own requests.
+- `smart-compact` — Claude statusLine exposes context%; Codex hooks get no percentage but every hook input carries `transcript_path`, whose `token_count` events give it (`scripts/codex-gate.mjs`). `on` copies the script to `$CODEX_HOME/hooks-custom/` and points the hook there (Codex runs trusted hooks outside the sandbox, so the hook must not run from a workspace); on Windows the command is PowerShell's `& '<node>' '<copy>' hook` (Codex 0.160.1). `on`/`off` write `~/.codex`, so under `workspace-write` they need approval to run outside the sandbox (not `--add-dir ~/.codex`); `/copy`·`/compact`·paste stay user-driven (TUI).
+- `obsidizer` — OMC-managed trees respect the 9-field frontmatter whitelist + reserved files + no-rename + bare `[[slug]]` links only; `aliases` are written in generic vaults only; Canvas sidecars and body-inline `::` are durable in-place; no `wiki_*` write dependency, `wiki_lint` read-only for verification. `--enable` in Claude Code arms the plugin-declared PostToolUse hook on the OMC wiki write tools. Codex has no wiki MCP (wiki writes are `omx wiki` shell calls), so there `--enable` writes `omx_wiki/.obsidizer` and installs a user-scope PostToolUse hook with matcher `Bash` (`banker hooks enable obsidize`, a copy in `$CODEX_HOME/hooks-custom/banker/` along with `skills/obsidizer/obsidize.mjs`). The hook runs `obsidize-hook.mjs --codex`: any shell call that is not `omx wiki` ingest/add ends after reading the input; for one that is, it canonicalizes the `omx_wiki/` pages named in the CLI's JSON stdout (`tool_response`) under the session cwd, with the same `omc` profile (the OMX wiki keeps the OMC schema and reserved files). Because the hook spawns node after every shell call in every project, it is installed only on `--enable`.
+- `payload-mon` — needs the OMC custom HUD wrapper (`setup-omc-hud`). It measures Claude Code sessions only; from Codex it manages the same machine's Claude Code HUD wrapper and never measures Codex's own requests. Under Codex's `workspace-write` sandbox, `on` and `off` need approval to run outside it (not `--add-dir ~/.claude`, which would let the session rewrite hooks); `status` only reads.
 - `tone-compact` — per runtime: Claude Code loads `<config>/rules/banker-tone-compact.md`; Codex reads one marked block at the end of `$CODEX_HOME/AGENTS.override.md` (when it has content of its own) or `AGENTS.md`, wrapped in `USER:OMX:POLICY` so `omx setup --merge-agents` keeps it (`--force` or team mode off replaces the file; run `on` again). Turning it on in one runtime leaves the other as it is.
 - `anti-drm` — the same places as `tone-compact` through the same shared module (`instruction-toggle.mjs`, a byte-identical copy in each skill): `<config>/rules/banker-anti-drm.md` for Claude Code, one `USER:OMX:POLICY`-wrapped block in the instructions file Codex reads. The settings (`~/.config/banker/anti-drm.json`) are shared by both runtimes; `on` and `off` act on one runtime, while `config` and `on` with settings refresh every runtime that holds the rules.
-- `omc-patch` — acts on the Claude Code OMC plugin cache (`~/.claude/plugins/`) even when run from Codex; Codex's own OMX is untouched. The skill always passes `--no-update` (a plain apply would switch the active OMC to the tool's hard-coded `TARGET_VERSION`). `--revert --root` restores only the active plugin folder when an older kit left the timeout helper inside a block, and `scripts/probe-pm.mjs` runs OMC's project-memory hook in a temp scratch project with its own home and state folder.
+- `omc-patch` — acts on the Claude Code OMC plugin cache (`~/.claude/plugins/`) even when run from Codex; Codex's own OMX is untouched. The skill always passes `--no-update` (a plain apply would switch the active OMC to the tool's hard-coded `TARGET_VERSION`). `--revert --root` restores only the active plugin folder when an older kit left the timeout helper inside a block, and `scripts/probe-pm.mjs` runs OMC's project-memory hook in a temp scratch project with its own home and state folder. Under `workspace-write`, `--check` and `probe-pm.mjs` run as they are; apply and revert need approval to run outside the sandbox (not `--add-dir ~/.claude`).
 - `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.
-- `/graceful-pause` (not a manifest surface) — a Claude Code function-hooks command (`hooks/register.mjs`, 2.1.289+) registered `immediate`, so it runs mid-turn; it appends one hidden user row the running turn reads at its next model request. Codex has no equivalent (no function hooks), and the earlier `graceful_pause` skill was removed because a typed skill waits until the turn ends.
+- `/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.
+- 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.
 
 신규 스킬(0.7.0)도 `both`·런타임 인식:
 - `ultra-interview` → 리서치 선행 질문 최소화 + 모호성 3% 이하 종료. **자체 루브릭 소유**가 설계 요점이다: OMC deep-interview 는 3차원, OMX 는 5차원으로 산식이 달라 네이티브 채점을 물려받으면 같은 임계값이 런타임마다 다른 뜻이 된다. OMC/OMX 네이티브 `deep-interview` 를 번들하거나 대체하지 않는다. 규제 조회는 엔드포인트 하드코딩이 아니라 "해당 관할의 공식 1차 출처를 찾아라"는 일반 지시다.

package/hooks/obsidize-hook.mjs

@@ -19,9 +19,16 @@
  *    stderr too, so that log is the only channel by which a permanently broken hook is
  *    discoverable rather than silently doing nothing forever. Only a regular file there is
  *    written: a link (a cloned repository can carry one) or a pipe gets no line.
+ *
+ * Codex (`--codex`): Codex has no wiki MCP, so a wiki write is a shell call to the `omx wiki` CLI, and Codex fires
+ * PostToolUse with tool_name Bash, tool_input.command and the command's stdout as tool_response (Codex 0.144.5).
+ * Only a command that runs `omx wiki` ingest or add goes on; every other shell call ends before any file is read. The
+ * vault is omx_wiki/ under the session cwd (the CLI writes under the cwd it runs in), and the page names come from the
+ * CLI's JSON (`{"created":["a.md"],...}`), which the same name pattern reads. The OMX wiki keeps the OMC page schema
+ * and reserved files, so the canonicalizer runs with the same profile.
  */
 import { spawnSync } from 'node:child_process';
-import { closeSync, constants, existsSync, fstatSync, lstatSync, openSync, readdirSync, statSync, writeSync } from 'node:fs';
+import { closeSync, constants, existsSync, fstatSync, lstatSync, openSync, readdirSync, realpathSync, statSync, writeSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -40,6 +47,46 @@ const RESERVED = new Set(['index.md', 'log.md', 'environment.md']);
 const RECENT_MS = 10_000;
 // Stay inside the `timeout: 5` declared in hooks.json.
 const CANONICALIZE_TIMEOUT_MS = 4000;
+const CODEX = process.argv.includes('--codex');
+// A statement that IS `omx wiki ingest|add` (omx its first word, PowerShell's `&` allowed before it), with or without
+// the wiki_ prefix the CLI also takes, and omx.cmd/omx.ps1 on Windows. A command may set the JSON up first
+// (`$j = '...'; omx wiki <ingest> --input $j`, as models write it for PowerShell), so each statement split at
+// `;`, `&&`, `||` and line ends outside quotes is looked at. `echo omx wiki add` and `echo "x; omx wiki add"` are
+// not one. This only spares the hook needless runs: what keeps a woken hook inside the vault is the rest (the CLI's
+// 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 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];
+}
+const PAGE_NAME_RE = /^[\w.-]+\.md$/;
 
 function readStdin() {
   return new Promise((resolvePromise, rejectPromise) => {
@@ -60,7 +107,8 @@ function log(wikiDir, tool, reason) {
     if (!NO_FOLLOW && isLink(at)) return;
     const fd = openSync(at, LOG_FLAGS, 0o600);
     try {
-      if (fstatSync(fd).isFile()) writeSync(fd, line);
+      const st = fstatSync(fd);
+      if (st.isFile() && st.nlink === 1) writeSync(fd, line); // a hard link to a file elsewhere gets no line
     } finally {
       closeSync(fd);
     }
@@ -78,6 +126,7 @@ function isDir(path) {
 }
 
 function wikiDirCandidates(root) {
+  if (CODEX) return root ? [join(root, 'omx_wiki')] : [];
   const dirs = [];
   // OMC relocates state to <OMC_STATE_DIR>/<projectId>/wiki. projectId is an OMC internal
   // we must not reimplement, so enumerate the candidates instead of deriving the name.
@@ -95,7 +144,49 @@ function wikiDirCandidates(root) {
 
 // The flag both arms the hook and identifies which vault it may touch.
 function findArmedWikiDir(root) {
-  return wikiDirCandidates(root).find((dir) => isDir(dir) && existsSync(join(dir, FLAG))) ?? null;
+  return wikiDirCandidates(root).find((dir) => isDir(dir) && existsSync(join(dir, FLAG)) && (!CODEX || ownDir(root, dir))) ?? null;
+}
+
+// Codex runs this hook outside its sandbox, so the vault must really be omx_wiki/ inside the session folder: not a
+// link (nor under one) that a sandboxed session or a cloned repository could point at another project's wiki.
+function ownDir(root, dir) {
+  try {
+    return !lstatSync(dir).isSymbolicLink() && realpathSync(dir) === join(realpathSync(root), basename(dir));
+  } catch {
+    return false;
+  }
+}
+
+// Codex: only a regular page with one name, so a link or a hard link cannot carry the rewrite out of the vault,
+// and a pipe cannot hold the hook.
+function plainPage(path) {
+  try {
+    const st = lstatSync(path);
+    return st.isFile() && st.nlink === 1;
+  } catch {
+    return false;
+  }
+}
+
+// Codex: the pages the `omx wiki` CLI's JSON says it wrote ({"created":[..],"updated":[..]}); else none. Other
+// output may come before it, so the whole output and then each line from the end is tried.
+function cliResult(stdout) {
+  const text = String(stdout ?? '');
+  for (const part of [text, ...text.split(/\r?\n/).reverse()]) {
+    try {
+      const out = JSON.parse(part);
+      if (out && typeof out === 'object' && (Array.isArray(out.created) || Array.isArray(out.updated))) return out;
+    } catch {
+      // not this one
+    }
+  }
+  return null;
+}
+
+function namesFromCli(stdout) {
+  const out = cliResult(stdout);
+  const list = [out?.created, out?.updated].filter(Array.isArray).flat();
+  return [...new Set(list.filter((n) => typeof n === 'string' && PAGE_NAME_RE.test(n)))];
 }
 
 function namesFromResponse(toolResponse) {
@@ -115,6 +206,9 @@ function namesFromScan(wikiDir) {
 }
 
 function resolvePages(wikiDir, toolResponse) {
+  if (CODEX) {
+    return namesFromCli(toolResponse).filter((name) => !RESERVED.has(name)).map((name) => join(wikiDir, name)).filter(plainPage);
+  }
   const names = namesFromResponse(toolResponse);
   return (names.length > 0 ? names : namesFromScan(wikiDir))
     .filter((name) => !RESERVED.has(name))
@@ -143,9 +237,19 @@ function runFailure(run) {
   }
 }
 
+// Codex: the canonicalizer runs in the vault folder on a bare page name, after it checks the folder is the one
+// looked at here (dev:ino), so swapping omx_wiki/ for a link after the check cannot lead it outside.
+function codexArgs(wikiDir, page) {
+  const st = lstatSync(wikiDir, { bigint: true });
+  if (!st.isDirectory()) throw new Error('omx_wiki is no folder');
+  return { args: [basename(page), '--page', `--vault=${st.dev}:${st.ino}`], cwd: wikiDir };
+}
+
 // Canonicalizes one page; a failure appends its one log line.
 function canonicalize(wikiDir, tool, page) {
-  const run = spawnSync(process.execPath, [CANONICALIZER, page, '--profile=omc', '--json'], {
+  const at = CODEX ? codexArgs(wikiDir, page) : { args: [page], cwd: undefined };
+  const run = spawnSync(process.execPath, [CANONICALIZER, ...at.args, '--profile=omc', '--json'], {
+    cwd: at.cwd,
     encoding: 'utf8',
     timeout: CANONICALIZE_TIMEOUT_MS,
     windowsHide: true,
@@ -156,11 +260,19 @@ function canonicalize(wikiDir, tool, page) {
 
 // A write can be redirected with workingDirectory; fall back to the session cwd.
 function writeRoot(payload) {
+  if (CODEX) return payload?.cwd || process.cwd();
   return payload?.tool_input?.workingDirectory || payload?.cwd || process.cwd();
 }
 
+// Codex fires this after every shell call; only an `omx wiki` write is ours.
+function codexWikiWrite(payload) {
+  const command = payload?.tool_input?.command;
+  return typeof command === 'string' && statements(command).some((part) => OMX_WIKI_WRITE_RE.test(part));
+}
+
 async function main() {
   const { payload, error } = await readPayload();
+  if (CODEX && !error && !codexWikiWrite(payload)) return;
   const wikiDir = findArmedWikiDir(writeRoot(payload));
   if (!wikiDir) return; // Not armed: change nothing, log nothing.
 

package/hooks/progress-plan.mjs

@@ -222,7 +222,7 @@ const step = (title, text, status) => ({
 
 const str = (v) => (typeof v === 'string' ? v : typeof v === 'number' ? String(v) : '');
 // A map's own entry: a key like `constructor` finds nothing.
-export const pick = (map, key) => (Object.hasOwn(map, key) ? map[key] : undefined);
+export const pick = (map, key) => (Object.prototype.hasOwnProperty.call(map, key) ? map[key] : undefined);
 const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 // ultragoal's states, and the ones like them; one it does not know shows no state.
 const GOAL_STATUS = { complete: 'completed', completed: 'completed', in_progress: 'in_progress', active: 'in_progress',