@kaydash9999/banker-plugins 0.26.1 → 0.27.0

package/codex/skills/ralph/scripts/run-folder.mjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+/**
+ * run-folder: the private run folders of ralph-qa, ultraqa and the Codex ralph, and the work tree snapshot their gate
+ * evidence is judged against. The source of truth is skills/ralph-qa/references/run-folder.mjs;
+ * skills/ultraqa/references and codex/skills/ralph/scripts hold byte-identical copies (scripts/sync-adapter.js).
+ *
+ *   bases(ctx)                        { base, known }: this run's base, and every base a run of any version used
+ *   sharedAbove(p)                    the nearest folder above p every account may write in, or null (POSIX)
+ *   readyBase(ctx, base)              makes the base, private (POSIX), or stops
+ *   makeRunFolder(ctx, kind)          <base>/<kind>.<six letters and digits>, private, with its marker .<kind>
+ *   runFolder(dir, ctx, kinds)        { d, kind } for such a folder right under a known private base, else a stop
+ *   removeMarked(p, marker)           the folder's contents, then its marker, then the folder
+ *   removeRunFolder(dir, ctx, kinds)  one run folder, checked as runFolder checks it; nothing outside it
+ *   snapshot(repo, env)               (async) HEAD, the status, the untracked files' content hashes, one fingerprint
+ *   requireGitTree(repo, env, flag)   the work tree's root, or the stop not-a-git-tree naming the folder it checked
+ *   spawnFiles(exe, args, opts)       spawnSync with files, not pipes, for the child's input and output
+ *   hashFile(createHash, p)           a file's sha256 read in pieces (a file past 2 GiB is no Buffer)
+ *   lstatOr, isFile, listDir, norm(ctx, p), realOr   small fs helpers seat-run.mjs shares (null, [], p on an error)
+ *
+ * ctx is { env, platform }. A base is never /tmp: another account may put files there (gemini, a ralph-qa seat, reads
+ * a .env it finds walking up from its folder). No shell and no network: git runs as a program with its arguments.
+ */
+import { spawnSync } from "node:child_process";
+import { closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
+
+// A stop: `code` names it, the message is a Korean line (the caller puts its name before it), `detail` the paths or
+// lines it concerns.
+export class Stop extends Error {
+  constructor(code, message, detail = []) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+  }
+}
+
+export const lstatOr = (p) => {
+  try {
+    return lstatSync(p);
+  } catch {
+    return null;
+  }
+};
+export const isFile = (p) => Boolean(lstatOr(p)?.isFile());
+export const listDir = (dir) => {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+};
+
+const homeOf = (ctx) => (ctx.platform === "win32" ? ctx.env.USERPROFILE : ctx.env.HOME) || homedir();
+export const norm = (ctx, p) => (ctx.platform === "win32" ? p.toLowerCase() : p);
+export const realOr = (p) => {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    return p;
+  }
+};
+
+// A folder only this account may write in (POSIX: its own, no group or other write bit).
+export function privateDir(p) {
+  try {
+    const st = statSync(p);
+    return st.isDirectory() && st.uid === process.getuid() && (st.mode & 0o022) === 0;
+  } catch {
+    return false;
+  }
+}
+const insideHome = (ctx, p) => norm(ctx, realOr(p)).startsWith(norm(ctx, realOr(homeOf(ctx))) + sep);
+
+// The base for this run's folders, and every base a run of any version may have used, for the day rule. Linux: an
+// XDG_RUNTIME_DIR, macOS: a $TMPDIR (its own per account by default), of this account's own and not below a shared
+// folder (/tmp) the home is not below, else ~/.cache; Windows: %TEMP% when it is inside the home, else ~/.cache (the
+// old Git Bash runs used ~/.cache).
+const OWN_TEMP = { linux: "XDG_RUNTIME_DIR", darwin: "TMPDIR" };
+export function bases(ctx) {
+  const cache = join(homeOf(ctx), ".cache");
+  const base = baseOn(ctx, cache);
+  const own = ctx.env[OWN_TEMP[ctx.platform]];
+  return { base, known: [...new Set([base, cache, ...(own ? [resolve(own)] : [])])] };
+}
+
+function baseOn(ctx, cache) {
+  const { env } = ctx;
+  if (ctx.platform === "win32") return env.TEMP && insideHome(ctx, env.TEMP) ? resolve(env.TEMP) : cache;
+  const own = env[OWN_TEMP[ctx.platform]];
+  return own && isAbsolute(own) && privateDir(own) && !belowSharedAlone(ctx, own) ? resolve(own) : cache;
+}
+
+const belowSharedAlone = (ctx, p) => Boolean(sharedAbove(p)) && !sharedAbove(homeOf(ctx));
+
+// The nearest folder above p, by its real path, that every account may write in (/tmp, /var/tmp, /dev/shm), or null.
+// A private folder there is still a folder whose parents another account fills: gemini reads the .env it finds
+// walking up to the root. An XDG_RUNTIME_DIR or $TMPDIR below one is refused unless the home is below one too (a test
+// box's account under /tmp): then ~/.cache is no better. POSIX only.
+export function sharedAbove(p) {
+  for (let d = dirname(realOr(resolve(p))); ; d = dirname(d)) {
+    try {
+      if ((statSync(d).mode & 0o002) !== 0) return d;
+    } catch {
+      /* not there or not readable: the next one up */
+    }
+    if (dirname(d) === d) return null;
+  }
+}
+
+export function readyBase(ctx, base) {
+  try {
+    mkdirSync(base, { recursive: true, mode: 0o700 });
+  } catch (e) {
+    throw new Stop("base-not-writable", `기준 폴더를 만들 수 없다(${e.code}): ${base}`);
+  }
+  if (ctx.platform !== "win32" && !privateDir(base)) throw new Stop("base-not-private", `기준 폴더를 다른 계정도 쓸 수 있다: ${base}`);
+}
+
+// One folder by mkdtemp under the base, with its marker.
+export function makeRunFolder(ctx, kind) {
+  const { base } = bases(ctx);
+  readyBase(ctx, base);
+  let d;
+  try {
+    d = mkdtempSync(join(base, `${kind}.`));
+    writeFileSync(join(d, `.${kind}`), "", { mode: 0o600 });
+  } catch (e) {
+    if (d) rmSync(d, { recursive: true, force: true });
+    throw new Stop("base-not-writable", `기준 폴더에 쓸 수 없다(${e.code}): ${base}`);
+  }
+  return { dir: d, base };
+}
+
+// The folder's parent, by its real path, is one of the known bases by theirs (macOS's /var is a link to /private/var:
+// either form names the same base), and only this account may write in it (POSIX).
+export function underBase(ctx, d) {
+  const parent = norm(ctx, realOr(dirname(d)));
+  const known = bases(ctx).known.some((b) => norm(ctx, realOr(b)) === parent);
+  return known && (ctx.platform === "win32" || privateDir(dirname(d)));
+}
+
+const escaped = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// A folder made as makeRunFolder makes one, of one of `kinds`: named <kind>.<letters and digits>, a folder and no link,
+// with its marker, right under a known base that only this account may write in.
+export function runFolder(dir, ctx, kinds) {
+  const d = resolve(String(dir));
+  const kind = kinds.find((k) => new RegExp(`^${escaped(k)}\\.[A-Za-z0-9]+$`).test(basename(d)));
+  if (!kind || !lstatOr(d)?.isDirectory() || !isFile(join(d, `.${kind}`))) {
+    throw new Stop("not-a-run-folder", `init 이 만든 폴더가 아니다: ${d}`);
+  }
+  if (!underBase(ctx, d)) throw new Stop("not-a-run-folder", `알려진 기준 폴더 바로 아래의 실행 폴더가 아니다: ${d}`);
+  return { d, kind };
+}
+
+// A marked folder removed, its marker last: a removal that stops part way leaves a folder the next cleanup still knows.
+// One that cannot be removed gets back its marker (if the removal reached it) and its times, so it stays a marked folder.
+export function removeMarked(p, marker) {
+  const was = lstatOr(p);
+  try {
+    for (const name of listDir(p).filter((n) => n !== marker)) rmSync(join(p, name), { recursive: true, force: true, maxRetries: 3 });
+    rmSync(p, { recursive: true, force: true, maxRetries: 3 });
+  } catch (e) {
+    keepMarked(p, marker, was);
+    throw e;
+  }
+}
+
+function keepMarked(p, marker, was) {
+  try {
+    if (!lstatOr(p)?.isDirectory()) return;
+    if (!isFile(join(p, marker))) writeFileSync(join(p, marker), "", { flag: "wx", mode: 0o600 });
+    if (was) utimesSync(p, was.atime, was.mtime);
+  } catch {
+    /* the folder takes no marker or times either */
+  }
+}
+
+// One run folder and nothing else: a path a record names outside it is the caller's to report, never to remove.
+export function removeRunFolder(dir, ctx, kinds) {
+  const { d, kind } = runFolder(dir, ctx, kinds);
+  try {
+    removeMarked(d, `.${kind}`);
+  } catch (e) {
+    throw new Stop("cleanup-left", "실행 폴더를 다 지우지 못했다. 사용자에게 경로를 알린다", [`${d} (${e.code || e.message})`]);
+  }
+  return { removed: d };
+}
+
+// ---- a program with files for its input and output
+
+// spawnSync with the child's stdin, stdout and stderr on files in a private temporary folder, read back into
+// r.stdout and r.stderr (Buffers) and removed. Node's own pipes are AF_UNIX socket pairs, and the Codex Linux sandbox
+// refuses their setsockopt: a pipe child's output can be lost and spawnSync reports EPERM though the program ran.
+// A file descriptor works there. Without a temporary folder it falls back to the pipes. With `digest` (a function
+// of the stdout file's path, or of the Buffer on the pipe fallback) r.stdout is what it gives, and the output, which
+// may pass 2 GiB, is never read whole.
+export function spawnFiles(exe, args, { input, digest, ...opts } = {}) {
+  let t;
+  try {
+    t = mkdtempSync(join(tmpdir(), "rq-io-"));
+  } catch {
+    const r = spawnSync(exe, args, { ...opts, input });
+    return digest && r.stdout ? { ...r, stdout: digest(r.stdout) } : r;
+  }
+  const fds = [];
+  const open = (name, flags) => (fds.push(openSync(join(t, name), flags, 0o600)), fds[fds.length - 1]);
+  try {
+    if (input !== undefined) writeFileSync(join(t, "in"), input, { mode: 0o600 });
+    const stdio = [input === undefined ? "ignore" : open("in", "r"), open("out", "wx"), open("err", "wx")];
+    const r = spawnSync(exe, args, { ...opts, stdio });
+    return { ...r, stdout: (digest || readFileSync)(join(t, "out")), stderr: readFileSync(join(t, "err")) };
+  } finally {
+    for (const fd of fds) closeSync(fd);
+    rmSync(t, { recursive: true, force: true });
+  }
+}
+
+// A file's sha256 in pieces of 1 MiB: readFileSync stops at 2 GiB (ERR_FS_FILE_TOO_LARGE). `createHash` comes from
+// the caller (this module loads node:crypto only inside snapshot).
+export function hashFile(createHash, p) {
+  const h = createHash("sha256");
+  const fd = openSync(p, "r");
+  try {
+    const buf = Buffer.alloc(1 << 20);
+    for (let n = readSync(fd, buf, 0, buf.length, null); n > 0; n = readSync(fd, buf, 0, buf.length, null)) h.update(buf.subarray(0, n));
+  } finally {
+    closeSync(fd);
+  }
+  return h.digest("hex");
+}
+
+// ---- the work tree snapshot
+
+// git as a program, from the home folder (Windows looks in the working folder first for a bare name; a home that is
+// not there, as in a test's env, gives the temporary folder), with no fsmonitor program and no external diff or text
+// conversion.
+function git(repo, env, args, digest) {
+  const cwd = existsSync(homedir()) ? homedir() : tmpdir();
+  const r = spawnFiles("git", ["-c", "core.fsmonitor=false", "-C", repo, ...args], { cwd, env, maxBuffer: 1 << 30, windowsHide: true, digest });
+  return { ok: r.status === 0, out: r.stdout || Buffer.alloc(0), err: String(r.stderr || r.error?.code || "") };
+}
+
+// The untracked entries of `git status --porcelain=v1 -z` (a rename or copy entry carries its old name next).
+function untrackedOf(raw) {
+  const parts = String(raw).split("\0");
+  const out = [];
+  for (let i = 0; i < parts.length; i += 1) {
+    const e = parts[i];
+    if (e.startsWith("?? ")) out.push(e.slice(3));
+    else if (/^[RC]/.test(e)) i += 1;
+  }
+  return out.sort();
+}
+
+// A gate's evidence needs a git work tree: in a folder without one the fingerprint sees no change, so no record of
+// it could ever hold (the conjunct's `unverifiable`). Stopped before anything runs, with the absolute folder it checked
+// (`checked`, also in detail) and what to do: a call from outside the repo without `flag` checked the wrong folder.
+export function requireGitTree(repo, env = process.env, flag = "--cwd") {
+  const checked = resolve(repo);
+  const top = git(checked, env, ["rev-parse", "--show-toplevel"]);
+  if (top.ok) return String(top.out).trim();
+  const e = new Stop("not-a-git-tree", `git 저장소가 아니다(검사한 폴더: ${checked}). 이 폴더가 대상 저장소가 아니면 검사할 저장소를 ${flag} 로 주십시오. 대상 저장소가 맞으면 작업 트리 지문이 변경을 보지 못해 게이트 증거를 만들 수 없다: 사용자가 git init 과 첫 커밋을 하거나, 게이트 없이 돈다`, [checked]);
+  e.checked = checked;
+  throw e;
+}
+
+// An untracked entry's content hash: a link's target, a file's bytes (in pieces), or what it is when it is neither.
+function contentHash(root, rel, hash, createHash) {
+  const p = join(root, rel);
+  const st = lstatOr(p);
+  if (st?.isSymbolicLink()) return hash(Buffer.from(`link\0${readlinkSync(p)}`));
+  if (st?.isFile()) return hashFile(createHash, p);
+  return hash(Buffer.from(st ? "other" : "gone"));
+}
+
+// What a gate's result was judged on: HEAD, the status, the diff against HEAD (the index and the work tree) and every
+// untracked file's content, hashed together; the diffs and the files are hashed in pieces, never read whole. A tree
+// with no git has one fingerprint per folder: changes go unseen (`git: false`, which the gate conjunct does not take).
+// Files git ignores are outside it: a build or a test run makes them anew every time.
+export async function snapshot(repo, env = process.env) {
+  const { createHash } = await import("node:crypto");
+  const hash = (b) => createHash("sha256").update(b).digest("hex");
+  const digest = (src) => (Buffer.isBuffer(src) ? hash(src) : hashFile(createHash, src));
+  const top = git(resolve(repo), env, ["rev-parse", "--show-toplevel"]);
+  if (!top.ok) return { git: false, head: null, untracked: [], fingerprint: hash(`no-git\0${resolve(repo)}`) };
+  const root = String(top.out).trim();
+  const head = git(root, env, ["rev-parse", "--verify", "-q", "HEAD"]);
+  const status = git(root, env, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+  const diffArgs = ["--binary", "--no-ext-diff", "--no-textconv"];
+  const diffs = (head.ok ? [["diff", "HEAD"]] : [["diff", "--cached"], ["diff"]]).map((a) => git(root, env, [...a, ...diffArgs], digest));
+  const failed = [status, ...diffs].find((r) => !r.ok);
+  if (failed) throw new Stop("git-failed", `작업 트리를 읽지 못했다: ${failed.err.split("\n")[0]}`);
+  const untracked = untrackedOf(status.out).map((path) => ({ path, sha256: contentHash(root, path, hash, createHash) }));
+  const headId = head.ok ? String(head.out).trim() : null;
+  const parts = [`head\0${headId}`, `status\0${hash(status.out)}`, ...diffs.map((r) => `diff\0${r.out}`), ...untracked.map((u) => `new\0${u.path}\0${u.sha256}`)];
+  return { git: true, root, head: headId, untracked, fingerprint: hash(parts.join("\n")) };
+}

package/codex/transform-matrix.md

@@ -19,14 +19,14 @@ The generator (`banker setup --codex`) applies the rules below for `target: both
 - `--scope user` (default) → `~/.codex/…`. `--scope project` → `./.codex/…`.
 
 ## Runtime-aware surfaces (both) — Codex uses OMX / Codex equivalents
-`claude-only` 표면은 `ultraqa` 하나다(Codex 는 OMX 의 `$ultraqa` 를 쓰므로 npm 설치와 Codex 플러그인 스킬 목록에서 빠진다). 그 밖의 Claude 플러그인 표면은 `both`, Codex 에만 있는 `codex-only` 는 `graceful-pause`, `progress`, `teamwork`. Codex 이름이나 설명이 다른 `both` 스킬은 manifest 의 `codexName`, `codexDescription` 으로 정한다(`setup-omc` 는 `setup-omx`, `omc-reference` 는 `omx-reference`, `setup-omc-hud` 는 `setup-omx-hud`, 설명만 다른 것은 `append_wiki`, `compact-wiki`, `setup-tmux`, 커맨드 `setup`). 플러그인 길은 `codex/renamed-skills/` 의 생성 사본, npm 길은 설치 때 바꿔 쓴다. OMC/Claude 에 결합됐던 표면은 본문이 런타임 인식으로 작성돼 Codex에서도 동작한다 — Codex에선 OMC 대신 oh-my-codex(OMX)의 동명 스킬을 쓴다:
-- 오케스트레이터 `all-in-one`·`ultra-init`·커맨드 `front-qa` → OMX `ralplan`/`ralph`. 마지막 QA 단계는 두 런타임 모두 banker `ralph-qa` 하나다(`--qa` 목표를 `--gates` 로 넘김, OMX `ultraqa` 에 기대지 않음). `ultra-init` 은 0.14.0 부터 ultragoal 원장을 쓰지 않는다(OMC 5.6.1 checkpoint 가 `/goal` 스냅샷을 요구해 ralph 와 Stop 훅 루프가 겹친다). Claude 쪽은 `ralph` 가 부르는 `omc ralph verify` 때문에 전역 `omc` CLI 가 플러그인과 같은 5.x 여야 한다(사전 점검은 종료 코드가 아니라 출력 문구로).
+`claude-only` 표면은 `ultraqa` 하나다(Codex 는 OMX 의 `$ultraqa` 를 쓰므로 npm 설치와 Codex 플러그인 스킬 목록에서 빠진다). 그 밖의 Claude 플러그인 표면은 `both`, Codex 에만 있는 `codex-only` 는 `graceful-pause`, `progress`, `ralph`, `teamwork`. Codex 이름이나 설명이 다른 `both` 스킬은 manifest 의 `codexName`, `codexDescription` 으로 정한다(`setup-omc` 는 `setup-omx`, `omc-reference` 는 `omx-reference`, `setup-omc-hud` 는 `setup-omx-hud`, 설명만 다른 것은 `append_wiki`, `compact-wiki`, `setup-tmux`, 커맨드 `setup`). 플러그인 길은 `codex/renamed-skills/` 의 생성 사본, npm 길은 설치 때 바꿔 쓴다. OMC/Claude 에 결합됐던 표면은 본문이 런타임 인식으로 작성돼 Codex에서도 동작한다 — Codex에선 OMC 대신 oh-my-codex(OMX)의 동명 스킬을 쓴다:
+- 오케스트레이터 `all-in-one`·`ultra-init`·커맨드 `front-qa` → 계획은 OMX `ralplan`(계획만 쓰고 멈추게 함. OMX 0.21 의 ralplan 은 끝에 `$ultragoal` 로 넘어감), 구현은 banker 의 Codex 전용 `ralph`(OMX 0.21 이 `$ralph` 를 없앰). 마지막 QA 단계는 두 런타임 모두 banker `ralph-qa` 하나다(`--qa` 목표를 `--gates` 로 넘김, OMX `ultraqa` 에 기대지 않음). `ultra-init` 은 0.14.0 부터 ultragoal 원장을 쓰지 않는다(OMC 5.6.1 checkpoint 가 `/goal` 스냅샷을 요구해 ralph 와 Stop 훅 루프가 겹친다). Claude 쪽은 `ralph` 가 부르는 `omc ralph verify` 때문에 전역 `omc` CLI 가 플러그인과 같은 5.x 여야 한다(사전 점검은 종료 코드가 아니라 출력 문구로).
 - `setup-omc` → `omx setup`(본문에 이미 존재). `setup-omc-hud` → Codex 자신의 상태표시줄이면 `[tui] status_line` 을 OMX 프리셋으로 켜고 끔(`assets/codex-status-line.mjs`, 없을 때만 넣고 banker 가 넣은 줄만 뺌), 같은 머신의 Claude Code 상태표시줄이면 그대로 설치(대상을 말하지 않으면 먼저 묻는다). `setup-stitch` → `codex mcp add`. `setup-bypass-permissions` → 대상 `codex` 면 `config.toml` 최상위 `approval_policy = "never"`, `sandbox_mode = "danger-full-access"`(`scripts/codex-bypass.mjs`, 켜기 전 값 기록과 `off` 원복, 조직 정책 확인), 대상 `claude` 면 같은 머신의 Claude Code 설정.
 - `compact-copy` → Codex 내장 `/copy`(경로는 Codex 규약). `omc-reference` → Codex는 OMX 카탈로그 기준. `setup` 커맨드 → Codex는 프롬프트 선택 UX.
 `setup-insane-search` 도 `both`: Codex에선 `codex plugin add insane-research-codex@gptaku-codex`.
 
 신규 스킬(0.4.0)도 `both`·런타임 인식:
-- `visual-ralph` → OMX `$ralph`·`$imagegen`(+`omx imagegen continuation`)·Visual Verdict; Claude은 `ralph`+`visual-verdict`+Stitch/ccg imagegen.
+- `visual-ralph` → banker `$banker-ralph`(OMX 0.21 이 `$ralph` 를 없앰)·OMX `$imagegen`(+`omx imagegen continuation`)·Visual Verdict; Claude은 `ralph`+`visual-verdict`+Stitch/ccg imagegen.
 - `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)를 승인을 받아 샌드박스 밖에서 실행한다.
@@ -48,7 +48,7 @@ The generator (`banker setup --codex`) applies the rules below for `target: both
 - `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. 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`, which has no `--critic`). After ralph both runtimes run the skill's own critic seat loop (`critic#1..N`; Claude `Agent` `Plan`, Codex `spawn_agent`; ralph's own approval is recorded as `ralph-reviewer` and is not the gate). `--agents=N` (default 3, raised to 3, over 17 refused, kept in `run.json` as `agents` and `agentsSource`) sets the stage 3 and 6 `ralph-qa` seats, the stage 5 critic seats and the stage 7 visual judges; the ledger enforces the count, the seat ids and the all-approve rule, and a seat that cannot be spawned stops the stage as `INCONCLUSIVE`. Both add a `ralph-qa` plan quorum of `--agents` reviewers after ralplan (whose Architect and Critic are two fixed reviewers with no option to add more and are not counted), run OS tests through the sibling `remains/scripts/boxes.mjs` (Codex: `banker-remains`), judge screenshots with `--agents` fresh judges whose lowest score must reach 90 (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.
+- `ultra-chain` — the same nine stages in both runtimes. Claude=OMC 5 (`ralplan --deliberate`, `ralph --critic=critic`); Codex=OMX `$ralplan --deliberate` (told to stop at the plan), then banker's Codex `ralph` (`$banker-ralph`, plugin `$banker:ralph`; OMX 0.21 removed `$ralph`), which has no `--critic`. After ralph both runtimes run the skill's own critic seat loop (`critic#1..N`; Claude `Agent` `Plan`, Codex `spawn_agent`; ralph's own approval is recorded as `ralph-reviewer` and is not the gate). `--agents=N` (default 3, raised to 3, over 17 refused, kept in `run.json` as `agents` and `agentsSource`) sets the stage 3 and 6 `ralph-qa` seats, the stage 5 critic seats and the stage 7 visual judges; the ledger enforces the count, the seat ids and the all-approve rule, and a seat that cannot be spawned stops the stage as `INCONCLUSIVE`. Both add a `ralph-qa` plan quorum of `--agents` reviewers after ralplan (whose Architect and Critic are two fixed reviewers with no option to add more and are not counted), run OS tests through the sibling `remains/scripts/boxes.mjs` (Codex: `banker-remains`), judge screenshots with `--agents` fresh judges whose lowest score must reach 90 (OMX 0.20.2's `visual-verdict` is a deprecated stub), and render the process report from the skill's own ledger (`lineage` reads Claude Code sessions only). Box runs need `ssh`, `scp` and `git`; screenshots need Playwright with Chromium; under Codex's `workspace-write` sandbox the ssh calls and the review seats' home writes may ask for approval.
 - `theme-selection` — the same procedure in both runtimes; the engine is `scripts/themes.mjs` (Codex: `~/.codex/skills/banker-theme-selection/scripts/themes.mjs`), which reads `assets/palettes.json` beside it. Pure Node with no network; it writes only the file `--out` names (refused when that file itself is a symbolic link), and the skill asks before it overwrites one that exists.
 - `progress-mon` — the same procedure in both runtimes; the engine is `scripts/progress-mon.mjs` (Codex npm install: `~/.codex/skills/banker-progress-mon/scripts/progress-mon.mjs`; plugin install: `~/.codex/plugins/cache/<marketplace>/banker/<version>/skills/progress-mon/scripts/progress-mon.mjs`), every command with `--runtime claude|codex`. The data folder is `.omc/progress-mon/` for Claude Code and `.omx/progress-mon/` for Codex. Pure Node with no network; the server binds 127.0.0.1 by default (`--host` takes a private IPv4 only). On Codex `start`, `stop`, `status` and `init` each ask for `sandbox_permissions: "require_escalated"` (`init` writes the git exclude list), and since closing the session may stop the server, a long-lived screen runs from the user's terminal (`serve`). `init --memory agents-md` writes its rule to `AGENTS.override.md` when that file has content of its own, as Codex then reads it instead of `AGENTS.md`. The fifth tab, ADR, reads `adr.json` only (the agent cites `docs/adr/` and `docs/evidence/` from it); a project set up before the ADR tab gets, on the next bare call and after one confirmation (Claude Code AskUserQuestion, Codex request_user_input), a rerun of `init` with the memory kind from `state.json` (auto-memory passes the folder of its `MEMORY.md` as `--memory-dir`) that replaces the old rule line in place with a `.progress-mon.bak` backup, then the ADR step. Not the same as `/progress` (the session's own task panel).
 - `init-dir` — the same procedure in both runtimes; the engine is `scripts/init-dir.mjs` (Codex npm install: `~/.codex/skills/banker-init-dir/scripts/init-dir.mjs`; plugin install: `~/.codex/plugins/cache/<marketplace>/banker/<version>/skills/init-dir/scripts/init-dir.mjs`), run with `--runtime claude|codex`. It writes one marked block (`<!-- banker:init-dir:start -->` to `<!-- banker:init-dir:end -->`) into whichever of `AGENTS.md` and `CLAUDE.md` exist (Codex with neither: `AGENTS.md`), the `AGENTS.md` block inside its own `USER:OMX:POLICY` pair; `AGENTS.override.md` is never written, only warned about when it has content of its own. The block editor `scripts/marker-block.mjs` is the source of truth for its future copies (`scripts/sync-adapter.js`). Pure Node with no network. On Codex a `--root` outside the workspace, or starting a generated service that must outlive the session, asks for `sandbox_permissions: "require_escalated"`.
@@ -59,6 +59,7 @@ The generator (`banker setup --codex`) applies the rules below for `target: both
 - `tune-tmux` — the same procedure in both runtimes; the engine is `scripts/tune-tmux.mjs` (Codex npm install: `~/.codex/skills/banker-tune-tmux/scripts/tune-tmux.mjs`; plugin install: `~/.codex/plugins/cache/<marketplace>/banker/<version>/skills/tune-tmux/scripts/tune-tmux.mjs`) with `status` (the default), `on` and `off`. It writes one marked block (`# banker:tune-tmux:start` to `# banker:tune-tmux:end`) through `scripts/marker-block.mjs`, a byte-identical copy of init-dir's kept by `scripts/sync-adapter.js`, into the user's tmux config (`~/.tmux.conf` or the XDG `tmux.conf`) or psmux config (`~/.psmux.conf` and the rest of psmux's order); psmux gets zero lines today, as `scripts/psmux-caps.json` verifies nothing beyond its defaults. The conditional `#{||:}` is probed on a private `tmux -L` server, never the user's. A symbolic-link config is refused unless `--follow-symlink`. No network. On Codex `on`, `off` and `--reload` ask for `sandbox_permissions: "require_escalated"`, as the config file and the tmux socket are outside the workspace; Claude Code and Codex settings are never changed, and Codex Fullscreen history cannot be scrolled by tmux copy-mode (only the user's `--no-alt-screen` or `tui.alternate_screen = "never"` changes that).
 - `/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.
+- `ralph` — `codex-only` (`$banker-ralph`, plugin `$banker:ralph`, `codex/skills/ralph/scripts/ralph-state.mjs`): the Codex build loop the five orchestrators call in place of OMX `$ralph`, which OMX 0.21 turned into a stub pointing at `$ultragoal`. Each iteration: build, slop pass recorded with `ralph-state.mjs deslop`, gates through `gate-evidence.mjs run` (a byte-identical copy of ralph-qa's, with `run-folder.mjs`, kept by `scripts/sync-adapter.js`), then a fresh reviewer (`spawn_agent` without a role or the author's context) recorded with `verdict`. `done` ends the run only when the gate conjunct, an APPROVE with no REJECT and the slop pass all match the work tree fingerprint now (`RALPH COMPLETE`); `stop` ends it otherwise (`RALPH STOPPED`). The record is `ralph.md` in the gate folder outside the repo, because an untracked file in the repo would change the fingerprint. It uses no OMX (no `omx state`, no OMX Stop hook) and needs no tmux. Like the OMC ralph in Claude Code it keeps going: banker's own Codex Stop hook (`hooks/ralph-continue-codex.mjs`, installed by `banker setup --codex` and by the plugin's `codex/hooks.json`, trusted once in `/hooks`) answers `{"decision":"block"}` while the session that started the run (`CODEX_THREAD_ID` at `start`; `adopt` moves it to another session) has it active; five stops with no change to the record or the gate evidence let the turn end, and `BANKER_NO_RALPH_CONTINUE` turns it off. Codex goal tools, when present, are completed only after `done`. Needs a git work tree; under `workspace-write` its calls may ask for approval.
 - `teamwork` — `codex-only` (`$banker-teamwork`, plugin `$banker:teamwork`, `codex/skills/teamwork/scripts/teamwork.mjs`): peer work between the Codex sessions of one Codex home. `on` copies the engine to `$CODEX_HOME/teamwork/bin/` beside an sh wrapper, adds a `SessionStart` and a `UserPromptSubmit` hook last under each event (taking the same `hooks.json.lock` as `bin/lib/codex-hooks.mjs`, `timeout: 5`, fixed in place; the command ends with `--rev <hash of engine and wrapper>`, so a newer engine asks for trust once more) and writes `$CODEX_HOME/rules/teamwork.rules`, a `prefix_rule` that lets only the wrapper's `peers`, `role`, `send`, `reply`, `status` and `version` run outside the sandbox (`on`, `off`, `uninstall` ask for approval; a same-named file without the `# teamwork` first line is left alone). The wrapper and the hooks run outside the sandbox, so `node`, `codex`, `ps` and `sh` are recorded as absolute paths at `on` and nothing is looked up on PATH afterwards; programs, and a Codex home, under a temp folder, the session folder or its git top, or a `writable_roots` entry are refused (exit 6). Requests and results travel by `codex queue --thread <UUID>` (Codex 0.149.0 or later). Windows ends `on` with exit 6 and the reason: on Codex 0.160.1 for Windows, `codex execpolicy check` matches the rule only for the wrapper called directly, not for the PowerShell call form (`& '<wrapper>' send ...`), so every call would ask for approval. `banker uninstall --codex` removes it only when no other way of banker into that Codex home is left.
 - Update notice and usage counting — Claude Code uses the plugin's own hooks (`SessionStart`, `PostToolUse` Skill, `UserPromptExpansion`). Codex gets `SessionStart` (`update-notify.mjs --codex`, shown as a warning line in the TUI) and `Stop` (`telemetry-count-codex.mjs`, once per turn rather than per tool call). Codex shows a skill in two ways and the Stop hook counts both from this turn of the rollout: a model-picked skill is read by a tool call (`cat .../skills/banker-<name>/SKILL.md`), and a skill the user names with `$banker-<name>` is injected without a tool call as a user-role message starting `<skill>\n<name>..</name>\n<path>..</path>`, of which only the `<path>` head is read. Codex runs trusted hooks outside the sandbox, so the update query and check-in reach the network as in Claude Code.
 - Rollout shape — `lineage`, `progress` and the Stop hook read Codex's session record, whose shape Codex does not promise (0.144 and 0.160 already differ: event `user_message`/`agent_message` vs `item_completed` items, `exec_command` calls vs `exec` code). A shape banker cannot read is never an empty result: lineage stops with exit 2 naming the Codex version when a rollout gives no user turn, progress prints a warning line, and the Stop hook, finding no `task_started` for the turn in the whole record, notes the version in `codex-shape-miss.json` so the next SessionStart (`update-notify.mjs --codex`) shows one warning. `banker doctor` checks the newest rollout (turn start, user text, tool calls) after a Codex update.

package/commands/front-qa.md

@@ -16,7 +16,9 @@ argument-hint: "[스펙 파일 경로. 생략하면 docs/note.md]"
   omc ralph verify --help 2>&1 | grep -q 'Usage: omc ralph verify' && echo "omc ok" || echo "omc CLI 없음 또는 낡음"
   ```
 - 실패하면 `/banker:setup` → oh-my-claudecode(또는 `setup-omc` 스킬 / `npm install -g oh-my-claude-sisyphus@latest`)로 먼저 구성한 뒤 이어서 진행. 점검을 통과하기 전에는 절차 1을 시작하지 않는다.
-- **런타임 매핑:** 아래 절차의 `/ralplan`·`/ralph`는 Claude Code에선 OMC 스킬, **Codex에선 oh-my-codex(OMX)의 동명 스킬**이다(Codex는 OMC 대신 OMX 전제). 각 런타임에서 사용 가능한 형태로 호출한다.
+- **런타임 매핑:** 아래 절차의 `/ralplan` 은 Claude Code에선 OMC 스킬, **Codex에선 oh-my-codex(OMX)의 동명 스킬**이다(Codex는 OMC 대신 OMX 전제). `/ralph` 는 Claude Code에선 OMC 스킬, **Codex에선 banker 의 Codex 전용 `ralph`** 다(npm 길 `$banker-ralph`, 플러그인 길 `$banker:ralph`. OMX 0.21 이 `$ralph` 를 없애 OMX 것은 부르지 않음). 각 런타임에서 사용 가능한 형태로 호출한다.
+- **Codex 의 2단계:** OMX 0.21 의 `$ralplan` 은 끝에 스스로 `$ultragoal` 로 넘어간다. 계획만 쓰고 멈추라고 넘긴다(`$ultragoal`, `$ralph`, `$team`, 구현으로 넘어가지 않음). 계획은 `.omx/plans/` 에 둔다.
+- **Codex 의 3~6단계:** banker `ralph` 의 `SKILL.md`(스킬로 설치된 때: npm 길 `<S>/../banker-ralph/SKILL.md`, 플러그인 길 `<S>/../../skills/ralph/SKILL.md`, `<S>` 는 이 커맨드 스킬 폴더)를 따른다. 스테이지와 스펙 항목을 수용 기준으로, typecheck 와 vitest 와 parity-gate 를 게이트(게이트마다 명령 하나)로 넘긴다. 그 ralph 가 새 맥락 검토, 슬롭 점검, 회귀 확인을 함께 하고 `RALPH COMPLETE` 줄을 낸다. critic 은 ralph 의 검토자가 맡는다.
 
 ## 절차 (CLAUDE.md: 계획 없는 즉시실행 금지)
 

package/hooks/ralph-continue-codex.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/*
+ * banker ralph 계속 훅 (Codex Stop). Claude Code 의 OMC ralph 처럼, banker 의 Codex ralph 실행이 끝나기 전에 턴이
+ * 끝나려 하면 계속하라는 이유를 돌려준다(`{"decision":"block","reason":...}`, OMX 의 Stop 훅과 같은 출력).
+ *
+ * - 막는 때: 훅 입력의 session_id 가 그 실행을 시작한 세션(start 때의 CODEX_THREAD_ID)이고, 그 실행이 이 작업 폴더의
+ *   저장소에서 active 일 때만. 검토자 같은 하위 에이전트 세션과 다른 세션은 막지 않는다.
+ * - 기록이나 게이트 증거가 바뀌지 않은 채 다섯 번 멈추려 하면 놓아준다(같은 턴의 두 번째 훅은 세지 않음).
+ *   판정은 codex/skills/ralph/scripts/ralph-state.mjs 의 continueFor() 가 한다.
+ * - BANKER_NO_RALPH_CONTINUE 가 있으면 아무것도 하지 않는다.
+ * - 어떤 오류도 삼키고 항상 exit 0. 막지 않을 때 표준 출력은 비운다.
+ */
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { continueFor } from '../codex/skills/ralph/scripts/ralph-state.mjs';
+
+const MAX_INPUT = 1 << 20;
+
+function readStdin() {
+  return new Promise((resolvePromise) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+      if (data.length > MAX_INPUT) process.stdin.destroy();
+    });
+    process.stdin.on('end', () => resolvePromise(data));
+    process.stdin.on('close', () => resolvePromise(data));
+    process.stdin.on('error', () => resolvePromise(''));
+  });
+}
+
+// The reason to keep the turn going for this hook input, or null.
+export function decide(input, env = process.env, platform = process.platform) {
+  if (env.BANKER_NO_RALPH_CONTINUE) return null;
+  if (!input || typeof input !== 'object') return null;
+  return continueFor({ cwd: input.cwd, sessionId: input.session_id, turnId: input.turn_id, transcript: input.transcript_path }, { env, platform });
+}
+
+async function main() {
+  try {
+    const input = JSON.parse(await readStdin());
+    const reason = decide(input);
+    if (reason) process.stdout.write(`${JSON.stringify({ decision: 'block', reason })}\n`);
+  } catch {
+    /* never in the way: no output, exit 0 */
+  }
+}
+
+const invokedDirectly = () => {
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+};
+
+if (invokedDirectly()) main().then(() => process.exit(0));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.26.1",
+  "version": "0.27.0",
   "description": "banker — Claude Code + Codex CLI plugin (QA, audit, docs, architecture, wiki skills). Install via Claude Code marketplace, or `npm i -g @kaydash9999/banker-plugins` then `banker setup`.",
   "bin": {
     "banker": "bin/banker.js"

package/skills/all-in-one/SKILL.md

@@ -14,8 +14,9 @@ level: 4
 This skill orchestrates OMC's `ralplan` → `ralph`, then banker's own `ralph-qa`
 as the QA gate. **Check the dependency before Stage 1**; if it is missing or
 stale, **guide installation first** rather than failing mid-pipeline. The `omc`
-check below is for Claude Code; on Codex check OMX instead (`omx --version`), whose
-`ralph` does not use the `omc` CLI.
+check below is for Claude Code. On Codex check OMX for Stage 1 (`omx --version`);
+Stage 2 there is banker's Codex `ralph` (npm `$banker-ralph`, plugin
+`$banker:ralph`), which needs neither OMX nor the `omc` CLI.
 
 - **The `omc` CLI must have `ralph verify` (Claude Code).** OMC 5's `ralph` runs
   `omc ralph verify` on its first iteration and stops when the command is
@@ -35,13 +36,14 @@ check below is for Claude Code; on Codex check OMX instead (`omx --version`), wh
   pipeline whose Stage 2 will stop.
 - **Stage 3 is banker's `ralph-qa` on both runtimes.** It ships with banker, so
   the gate needs no OMC or OMX skill; OMC and OMX serve Stages 1 and 2 only.
-- On Codex the equivalent framework is OMX (`omx setup`).
+- On Codex the planning framework is OMX (`omx setup`). OMX 0.21 removed
+  `$ralph` (a stub that points at `$ultragoal`), so Stage 2 never calls OMX's.
 
-**런타임 매핑 (Claude Code ↔ Codex).** Stage 1·2 의 `ralplan`·`ralph` 는 Claude Code에선 OMC 스킬이고 **Codex에선 oh-my-codex(OMX)가 제공하는 동명 스킬**이다. Stage 3 은 두 런타임 모두 banker `ralph-qa` 다: Claude Code `Skill("banker:ralph-qa")`, Codex npm 길 `$banker-ralph-qa`, 플러그인 길 `$banker:ralph-qa`. Codex 에는 Skill 도구가 없으니 그 `SKILL.md` 를 읽고 그대로 따른다(npm 길 `<S>/../banker-ralph-qa/SKILL.md`, 플러그인 길 `<S>/../ralph-qa/SKILL.md`, `<S>` 는 이 스킬 폴더). `<RQ>` 는 ralph-qa 의 `references` 폴더다(Claude Code 와 Codex 플러그인 길 `<S>/../ralph-qa/references`, Codex npm 길 `<S>/../banker-ralph-qa/references`). 아래 `Skill("oh-my-claudecode:<name>")` 표기는 Claude Code 기준이다.
+**런타임 매핑 (Claude Code ↔ Codex).** Stage 1 의 `ralplan` 은 Claude Code에선 OMC 스킬이고 **Codex에선 oh-my-codex(OMX)가 제공하는 동명 스킬**이다. Stage 2 의 `ralph` 는 Claude Code에선 OMC 스킬이고 **Codex에선 banker 의 Codex 전용 `ralph`** 다(npm 길 `$banker-ralph`, 플러그인 길 `$banker:ralph`). 그 `SKILL.md` 는 npm 길 `<S>/../banker-ralph/SKILL.md`, 플러그인 길 `<S>/../../codex/skills/ralph/SKILL.md` 다. OMX 의 `$ralph` 는 부르지 않는다(OMX 0.21 이 없앰). Stage 3 은 두 런타임 모두 banker `ralph-qa` 다: Claude Code `Skill("banker:ralph-qa")`, Codex npm 길 `$banker-ralph-qa`, 플러그인 길 `$banker:ralph-qa`. Codex 에는 Skill 도구가 없으니 그 `SKILL.md` 를 읽고 그대로 따른다(npm 길 `<S>/../banker-ralph-qa/SKILL.md`, 플러그인 길 `<S>/../ralph-qa/SKILL.md`, `<S>` 는 이 스킬 폴더). `<RQ>` 는 ralph-qa 의 `references` 폴더다(Claude Code 와 Codex 플러그인 길 `<S>/../ralph-qa/references`, Codex npm 길 `<S>/../banker-ralph-qa/references`). 아래 `Skill("oh-my-claudecode:<name>")` 표기는 Claude Code 기준이다.
 
-**Codex 의 tmux 밖 실행.** OMX 의 런타임 워크플로(`ralph`, `team` 등)는 OMX tmux 런타임을 요구한다. OMX 의 `AGENTS.md` 는 tmux 밖(Codex App, 일반 `codex`, `codex exec`)이면 그 사실을 알리고 가장 가까운 대체 경로로 계속하라고 정한다(oh-my-codex 0.20.2 `templates/AGENTS.md`). 그래서 tmux 밖이라는 사실만으로는 멈추지 않는다. 그 단계는 이 세션이 그 스킬의 `SKILL.md` 절차를 네이티브 하위 에이전트로 그대로 따르고, 보고에 `<단계>: tmux 밖 대체 실행(OMX 런타임 없음)` 한 줄을 적는다. 종결 낱말은 다른 멈춤 조건과 마지막 ralph-qa 판정으로만 정한다. 대체 실행도 할 수 없으면(하위 에이전트 기능이 꺼짐 등) `STOPPED(omx-runtime-unavailable)` 로 멈추고 tmux 안의 OMX 에서 다시 실행하라고 안내한다.
+**Codex 의 tmux 밖 실행.** banker `ralph` 는 tmux 가 필요 없다. OMX 의 런타임 워크플로(`team` 등)는 OMX tmux 런타임을 요구한다. OMX 의 `AGENTS.md` 는 tmux 밖(Codex App, 일반 `codex`, `codex exec`)이면 그 사실을 알리고 가장 가까운 대체 경로로 계속하라고 정한다(oh-my-codex 0.20.2 `templates/AGENTS.md`). 그래서 tmux 밖이라는 사실만으로는 멈추지 않는다. 그 단계는 이 세션이 그 스킬의 `SKILL.md` 절차를 네이티브 하위 에이전트로 그대로 따르고, 보고에 `<단계>: tmux 밖 대체 실행(OMX 런타임 없음)` 한 줄을 적는다. 종결 낱말은 다른 멈춤 조건과 마지막 ralph-qa 판정으로만 정한다. 대체 실행도 할 수 없으면(하위 에이전트 기능이 꺼짐 등) `STOPPED(omx-runtime-unavailable)` 로 멈추고 tmux 안의 OMX 에서 다시 실행하라고 안내한다.
 
-**Codex 의 계획과 상태 경로.** 이 문서의 `.omc/plans/`, `.omc/state/` 는 Claude Code(OMC) 경로다. Codex 에서는 OMX 경로를 쓴다: 계획은 `.omx/plans/`(ralplan 이 쓰는 `prd-*.md`, `test-spec-*.md`), ralph 의 진행 기록은 `.omx/state/<scope>/ralph-progress.json`. Codex 에서 `.omc/` 아래에 계획을 쓰지 않는다.
+**Codex 의 계획과 상태 경로.** 이 문서의 `.omc/plans/`, `.omc/state/` 는 Claude Code(OMC) 경로다. Codex 에서는 OMX 경로를 쓴다: 계획은 `.omx/plans/`(ralplan 이 쓰는 `prd-*.md`, `test-spec-*.md`), ralph 의 진행 기록은 저장소 밖 게이트 폴더의 `ralph.md`(banker `ralph` 의 `ralph-state.mjs`). Codex 에서 `.omc/` 아래에 계획을 쓰지 않는다.
 
 ## Purpose
 
@@ -148,6 +150,9 @@ then **stops**.
 - **If `--checkpoint`:** before proceeding, use `AskUserQuestion` to present the
   plan and offer *Approve & implement / Request changes / Stop*. Only continue
   on approval.
+- **Codex: plan only.** OMX 0.21's `$ralplan` ends by moving on to
+  `$ultragoal`. Tell it to write the plan and stop there: no `$ultragoal`,
+  `$ralph`, `$team` or implementation. Stage 2 is banker's `ralph`.
 - **If consensus is NOT reached** (ralplan hits its 5-iteration cap with no
   `APPROVE`): do not auto-proceed. Surface the best plan and ask the user how to
   proceed. Never build on an unapproved plan.
@@ -167,8 +172,8 @@ One command per gate (no `&&` or `;` chains) and a `--timeout` on each.
 record** (iteration 0 in `<g>/evidence.md`) is the gate's baseline: ralph-qa
 counts a failure with the same command and failure signature as not this
 change's (`baseline`). It covers checks that are not among ralph's feedback
-commands, and on Codex it is the only baseline there is (OMX `ralph` keeps
-none). Never use `git stash` or `git reset` to get a pre-change state for it; if
+commands. On Codex banker's `ralph` keeps a baseline of its own in its own
+gate folder; this one is still the gate's. Never use `git stash` or `git reset` to get a pre-change state for it; if
 the tree already has changes, take the record from a clean copy of HEAD
 (`git worktree add --detach <tmp> HEAD`, run with `--cwd <tmp>`, then
 `git worktree remove <tmp>`). A fresh worktree has no installed dependencies
@@ -247,6 +252,15 @@ criteria → Step-7 reviewer verification → Step-7.5 deslop → Step-7.6 regre
   `omc ralph verify` command unavailable): stop and report. Do **not** run
   Stage 3 on a broken or partial build and call it done.
 
+**Codex: banker `ralph`.** Follow its `SKILL.md` (paths above) instead of the
+OMC `ralph` above. Hand it the plan file path with its stories and acceptance
+criteria, the `--qa` goals' commands as its gates (one command per gate id),
+`--no-deslop` if passed, and "no questions: write assumptions down". `--critic`
+has no Codex counterpart: ralph's fresh reviewer takes that place. It runs its
+own gate folder, apart from `<g>`. Go on to Stage 3 only after its
+`RALPH COMPLETE` line; on `RALPH STOPPED` stop and report its reason. The
+`omc ralph verify` bullets above are Claude Code only.
+
 ### Stage 3 — QA gate: banker `ralph-qa` (both runtimes)
 
 Precondition: Stage 2's ralph has completed and self-cancelled.

package/skills/ralph-qa/references/gate-evidence.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
  * gate-evidence: a gate command run by this program, not by the model, and what it saw, as the evidence ralph-qa
- * (--gates), ultraqa, all-in-one, ultra-init and ultra-chain judge by. The source of truth is
- * skills/ralph-qa/references/gate-evidence.mjs; skills/ultraqa/references holds a byte-identical copy
- * (scripts/sync-adapter.js).
+ * (--gates), ultraqa, the Codex ralph, all-in-one, ultra-init and ultra-chain judge by. The source of truth is
+ * skills/ralph-qa/references/gate-evidence.mjs; skills/ultraqa/references and codex/skills/ralph/scripts hold
+ * byte-identical copies (scripts/sync-adapter.js).
  *
  *   node gate-evidence.mjs init [--cwd <repo>]   the gate folder <g> of one ralph-qa run (ralph-qa-gates.<letters and digits>): made
  *        once before the baseline, kept across the iterations, apart from the payload folder seat-run.mjs makes anew

package/skills/ralph-qa/references/run-folder.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /**
- * run-folder: the private run folders of ralph-qa and ultraqa, and the work tree snapshot their gate evidence is judged
- * against. The source of truth is skills/ralph-qa/references/run-folder.mjs; skills/ultraqa/references holds a
- * byte-identical copy (scripts/sync-adapter.js).
+ * run-folder: the private run folders of ralph-qa, ultraqa and the Codex ralph, and the work tree snapshot their gate
+ * evidence is judged against. The source of truth is skills/ralph-qa/references/run-folder.mjs;
+ * skills/ultraqa/references and codex/skills/ralph/scripts hold byte-identical copies (scripts/sync-adapter.js).
  *
  *   bases(ctx)                        { base, known }: this run's base, and every base a run of any version used
  *   sharedAbove(p)                    the nearest folder above p every account may write in, or null (POSIX)

package/skills/ultra-chain/SKILL.md

@@ -60,7 +60,7 @@ ultra-chain 이 직접 하는 일은 여섯 가지다.
 | 1 전문가 작업 방식 | `Skill("banker:lfm")` | `$banker-lfm` |
 | 2 모호성 제거 | `Skill("banker:ultra-interview")` | `$banker-ultra-interview` |
 | 3 합의 계획 | `Skill("oh-my-claudecode:ralplan")` `--deliberate`, 이어서 `Skill("banker:ralph-qa")` | `$ralplan --deliberate`, 이어서 `$banker-ralph-qa`(플러그인 길 `$banker:ralph-qa`) |
-| 5 구현 | `Skill("oh-my-claudecode:ralph")` `--critic=critic`, 이어서 이 스킬의 critic 좌석 `<agents>` 개 루프 | `$ralph`, 이어서 이 스킬의 critic 좌석 `<agents>` 개 루프(OMX `ralph` 에는 `--critic` 이 없다) |
+| 5 구현 | `Skill("oh-my-claudecode:ralph")` `--critic=critic`, 이어서 이 스킬의 critic 좌석 `<agents>` 개 루프 | banker `$banker-ralph`(플러그인 길 `$banker:ralph`), 이어서 이 스킬의 critic 좌석 `<agents>` 개 루프(banker `ralph` 에는 `--critic` 이 없다. OMX 0.21 이 `$ralph` 를 없앰) |
 | 5 critic 좌석 에이전트 | `Agent` 의 `Plan` 유형, `model` 없이 | `spawn_agent`, 역할 규칙은 아래 |
 | 6 합의 검증 | `Skill("banker:ralph-qa")` | `$banker-ralph-qa`(플러그인 길 `$banker:ralph-qa`) |
 | 7 시각 판정 에이전트 | 판정자 `<agents>` 명. `Plan` 유형, `model` 없이 | 판정자 `<agents>` 명. `spawn_agent`, 역할과 `model` 없이 |
@@ -70,11 +70,11 @@ ultra-chain 이 직접 하는 일은 여섯 가지다.
 | 이어 하기 메모 | OMC 작업 노트에 덧붙이기(`notepad_write_working`). 우선 노트는 통째로 바뀌므로 쓰지 않음 | `.omx/notepad.md` 에 한 줄 덧붙이기 |
 | 실행 기록 기본 폴더 | `.omc/ultra-chain/` | `.omx/ultra-chain/` |
 
-- Codex 에는 Skill 도구가 없다. 위 표의 `$이름` 은 그 스킬의 `SKILL.md` 를 읽고 그대로 따른다는 뜻이다. banker 스킬은 npm 설치면 `<S>/../banker-<이름>/SKILL.md`, Codex 플러그인 설치(`<S>` 가 `plugins/cache/` 아래, 스킬 이름 `banker:<이름>`)면 `<S>/../<이름>/SKILL.md` 다. 표의 `$banker-<이름>` 은 플러그인 설치에서 `$banker:<이름>` 이다. OMX 스킬은 `~/.codex/skills/<이름>/SKILL.md` 다. 그 스킬이 상태 기록을 요구하면 그 지시대로 직접 기록한다. 큰 `SKILL.md`(ralph-qa 는 약 71KB)는 셸 출력 한도에서 잘리니 나눠 읽는다.
+- Codex 에는 Skill 도구가 없다. 위 표의 `$이름` 은 그 스킬의 `SKILL.md` 를 읽고 그대로 따른다는 뜻이다. banker 스킬은 npm 설치면 `<S>/../banker-<이름>/SKILL.md`, Codex 플러그인 설치(`<S>` 가 `plugins/cache/` 아래, 스킬 이름 `banker:<이름>`)면 `<S>/../<이름>/SKILL.md` 다. 표의 `$banker-<이름>` 은 플러그인 설치에서 `$banker:<이름>` 이다. Codex 전용인 banker `ralph` 만 플러그인 설치에서 `<S>/../../codex/skills/ralph/SKILL.md` 다(npm 설치는 `<S>/../banker-ralph/SKILL.md`). OMX 스킬은 `~/.codex/skills/<이름>/SKILL.md` 다. 그 스킬이 상태 기록을 요구하면 그 지시대로 직접 기록한다. 큰 `SKILL.md`(ralph-qa 는 약 71KB)는 셸 출력 한도에서 잘리니 나눠 읽는다.
 - Codex 의 하위 에이전트(critic 좌석, 시각 판정자)는 저자 대화를 넘기지 않는다. multi-agent v2 는 `fork_turns="none"` 을 주고, v1 은 `fork_context` 를 주지 않는다. 판정을 받으면 `close_agent` 로 닫는다.
 - Codex 의 동시 하위 에이전트 한도보다 `<agents>` 가 크면 나눠 띄우고, 모두 받은 뒤 합친다.
 - Codex 환경 지시가 역할(`agent_type`)을 요구하면, 고정 모델이 세션 모델과 같은 역할을 쓰고 지시 앞머리에 파일 쓰기 금지를 적는다. 그런 역할이 없으면 역할 없이 띄운다. 쓴 역할과 모델, 강도를 판정 기록의 `note` 에 적는다.
-- **Codex 의 tmux 밖 실행.** OMX 의 런타임 워크플로(`ralph`, `team` 등)는 OMX tmux 런타임을 요구한다. OMX 의 `AGENTS.md` 는 tmux 밖(Codex App, 일반 `codex`, `codex exec`)이면 그 사실을 알리고 가장 가까운 대체 경로로 계속하라고 정한다(oh-my-codex 0.20.2 `templates/AGENTS.md`). 그래서 tmux 밖이라는 사실만으로는 멈추지 않는다. 그 단계는 이 세션이 그 스킬의 `SKILL.md` 절차를 네이티브 하위 에이전트로 그대로 따르고, 보고에 `<단계>: tmux 밖 대체 실행(OMX 런타임 없음)` 한 줄을 적는다. 종결 낱말은 다른 멈춤 조건과 마지막 ralph-qa 판정으로만 정한다. 대체 실행도 할 수 없으면(하위 에이전트 기능이 꺼짐 등) `STOPPED(omx-runtime-unavailable)` 로 멈추고 tmux 안의 OMX 에서 다시 실행하라고 안내한다.
+- **Codex 의 tmux 밖 실행.** banker `ralph` 는 tmux 가 필요 없다. OMX 의 런타임 워크플로(`team` 등)는 OMX tmux 런타임을 요구한다. OMX 의 `AGENTS.md` 는 tmux 밖(Codex App, 일반 `codex`, `codex exec`)이면 그 사실을 알리고 가장 가까운 대체 경로로 계속하라고 정한다(oh-my-codex 0.20.2 `templates/AGENTS.md`). 그래서 tmux 밖이라는 사실만으로는 멈추지 않는다. 그 단계는 이 세션이 그 스킬의 `SKILL.md` 절차를 네이티브 하위 에이전트로 그대로 따르고, 보고에 `<단계>: tmux 밖 대체 실행(OMX 런타임 없음)` 한 줄을 적는다. 종결 낱말은 다른 멈춤 조건과 마지막 ralph-qa 판정으로만 정한다. 대체 실행도 할 수 없으면(하위 에이전트 기능이 꺼짐 등) `STOPPED(omx-runtime-unavailable)` 로 멈추고 tmux 안의 OMX 에서 다시 실행하라고 안내한다.
 - Codex 의 오래 도는 명령은 기다리는 시간을 박스 `--timeout` 보다 길게 둔다. 기다리다 끊기면 박스 정리와 결과 JSON 이 남지 않는다.
 - Codex 세션을 닫으면 그 세션에서 띄운 서버도 끝날 수 있다. 오래 볼 미리보기는 사용자 터미널에서 띄우게 안내한다(9단계).
 
@@ -241,6 +241,7 @@ ralplan 은 계획 작성자 외에 Architect 와 Critic 두 검토자로 합의
    - 계획에 `## 전문가 작업 방식 적용` 절을 두라는 지시. `01-masters.md` 의 `M-n` 마다 판정(적용, 조정, 제외)과 계획의 어느 단계에 넣었는지, 조정과 제외는 그 이유를 적는다. 판정을 바꾸면(예: `lfm` 이 적용인데 계획은 제외) 이유를 적는다
    - 계획 저장 경로: Claude Code 는 `.omc/plans/ultra-chain-<run id>.md`. Codex 는 OMX 규칙대로 `.omx/plans/` 에 쓴다
    - Codex: 인터뷰가 끝났으니 `$deep-interview` 를 돌리지 말라는 말
+   - Codex: 계획만 쓰고 멈추라는 말. OMX 0.21 의 `$ralplan` 은 끝에 스스로 `$ultragoal` 로 넘어간다. `$ultragoal`, `$ralph`, `$team`, 구현으로 넘어가지 않게 한다
    - 계획에 넣을 것
      - 대상 OS 와 OS 별 시험 명령. 비대화형으로 돌게 한다(`CI=true`, 감시 모드 끔. Windows 는 `cmd` 기준으로 `set CI=true&&`)
      - 시험 출력 꼴. node:test 면 TAP(`--test-reporter=tap`)로 내게 한다. 박스 결과가 시험 수를 셀 수 있다
@@ -336,7 +337,13 @@ ralplan 은 계획 작성자 외에 Architect 와 Critic 두 검토자로 합의
      - `prd.json` 이 없으면 OMC 의 `PRD` 꼴(`src/hooks/ralph/prd.ts`)로 쓴다. 최상위 `project`(저장소 이름), `branchName`(지금 브랜치), `description`(작업 요약), `userStories` 는 빠지면 OMC 가 PRD 전체를 무효로 읽는다. 이야기마다 `id`, `title`, `description`, `acceptanceCriteria`(배열), `priority`(수), `passes: false` 를 넣는다. 위에서 정한 피드백 명령은 `feedbackCommands`, 품질 등급은 `repoQualityClass` 로 같은 파일에 넣는다. 빠지면 `omc ralph verify` 가 package.json 의 스크립트로 대신 돈다.
      - OMC 의 내부 모듈(`dist/` 아래)을 불러 PRD 나 상태를 만들지 않는다. 판이 다른 내부 API 를 부르게 된다. 이 확인과 고친 것을 `build` 의 `note` 에 적는다.
 3. ralph 가 끝까지 가게 둔다(검토자 승인, deslop, 회귀 확인, `/oh-my-claudecode:cancel`). ralph 의 cancel 은 구현 단계의 끝이지 연쇄의 끝이 아니다. ralph 가 아직 도는 동안 6단계를 시작하지 않는다. 끝나면 `.omc/state/sessions/<id>/prd.json`(`OMC_STATE_DIR` 이 있으면 그 아래)을 `<run>/05-prd.json` 으로 복사한다. ralph 의 반복 한도는 ralph 자신의 것이다. ralph 보고에서 실제로 승인한 검토자가 critic 인지 확인해 기록한다. Skill 경로로 켠 ralph 는 검토자 설정이 architect 로 남을 수 있다. ralph 의 승인은 `build` 에 `note` 하나로 `verdict.by: "ralph-reviewer"` 로 기록한다(좌석 수 검사 대상이 아니다). 이어서 5의 critic 좌석 루프를 돈다.
-4. Codex: `$ralph` 를 따른다. 2의 입력을 같이 넘기고, 인터뷰가 끝났으니 `$deep-interview` 를 돌리지 말라고 적는다. 연쇄 전체의 목표(goal)를 완료로 바꾸지 말라고도 적는다. ralph 의 승인은 3과 같이 `verdict.by: "ralph-reviewer"` 로 기록한다. 이어서 5의 critic 좌석 루프를 돈다.
+4. Codex: banker `$banker-ralph`(플러그인 길 `$banker:ralph`)를 따른다. OMX 의 `$ralph` 는 부르지 않는다(OMX 0.21 이 없앰).
+   - 2의 입력 가운데 계획, 목업, 기대 출력, 수용 기준을 넘긴다. `repoQualityClass`, `prd.json`, `state_read` 는 Claude Code 의 OMC 것이라 넘기지 않는다
+   - 게이트: 계획의 로컬 게이트 목록(게이트마다 명령 하나와 시간 제한)을 넘긴다. 2의 피드백 명령 꼴(`grep -Ev` 로 거른 꼴)이 아니라 종료 코드로 판정하는 보통 명령을 쓴다
+   - 인터뷰가 끝났으니 `$deep-interview` 를 돌리지 말라고 적는다. 연쇄 전체의 목표(goal)를 완료로 바꾸지 말라고도 적는다. 질문하지 말고 가정을 적으라고 적는다
+   - ralph 가 `RALPH COMPLETE` 줄을 낸 뒤에만 다음으로 간다. `RALPH STOPPED` 면 그 까닭으로 `stopped` 를 기록하고 멈춘다
+   - ralph 의 게이트 폴더는 이 연쇄의 `<g>` 와 따로다. ralph 가 끝나며 지운다. ralph 의 `RALPH COMPLETE` 줄을 `build` 의 `note` 에 적는다
+   - ralph 의 승인은 3과 같이 `verdict.by: "ralph-reviewer"` 로 기록한다. 이어서 5의 critic 좌석 루프를 돈다
 5. critic 좌석 루프(두 런타임 공통). ralph 의 critic 은 1명 고정이고 ralph 가 끝나면 다시 판정할 수 없어서, ralph 가 끝난 뒤 이 스킬의 좌석 `<agents>` 개로 다시 판정한다.
    - 좌석 `critic#1`..`critic#<agents>` 를 런타임 대응 표의 5 critic 좌석 에이전트로 띄운다. Claude Code 는 `Agent` 의 `Plan` 유형을 `model` 없이(읽기 전용 도구, 세션 모델) 쓴다. Codex 는 `spawn_agent` 이고, 역할 `critic` 의 고정 모델이 세션 모델과 같으면 그 역할을 쓰고, 아니면 런타임 대응 절의 역할 규칙을 따른다. 지시 앞머리에 파일 쓰기 금지를 적는다.
    - Agent 도구나 `Plan` 유형을 띄울 수 없으면(Codex 는 하위 에이전트 기능이 꺼짐) 한 맥락이 좌석을 연기하지 않는다. 그 회차를 `INCONCLUSIVE` 로 기록하고 멈춘다(ralph-qa 의 "띄울 수 없으면 흉내 내지 않는다" 와 같은 규칙).