therookie 0.4.38 → 0.4.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "therookie",
-  "version": "0.4.38",
+  "version": "0.4.40",
   "description": "Persistent memory for Claude Code and Codex CLI — teach your AI once and it remembers across sessions, tools, and machines. The AI new hire that remembers what you teach it.",
   "license": "MIT",
   "keywords": [

package/src/cli.js

@@ -18,9 +18,9 @@ import { runOrphanExtract } from './commands/orphan-extract.js'
 const HELP = `rookie — the Rookie Skill/Hook 설치 관리자
 
 사용:
-  rookie init [--local] [--force] [--yes] [--deep-scan] [--claude-md | --no-claude-md]
-  rookie login [--local] [--claude-md | --no-claude-md]
-  rookie update [--force] [--claude-md | --no-claude-md]
+  rookie init [--local] [--force] [--yes] [--deep-scan] [--claude-md | --no-claude-md] [--codex-md | --no-codex-md]
+  rookie login [--local] [--claude-md | --no-claude-md] [--codex-md | --no-codex-md]
+  rookie update [--force] [--claude-md | --no-claude-md] [--codex-md | --no-codex-md]
   rookie link [--local]
   rookie save [--file <body.json>] [--json]   # 또는 stdin. --json = 서버 raw 응답 출력
   rookie status
@@ -28,7 +28,7 @@ const HELP = `rookie — the Rookie Skill/Hook 설치 관리자
   rookie unlink [--local | --global]
   rookie token list | revoke <id> | rotate
   rookie sweep-recovery [--force]
-  rookie codex-setup [--yes]
+  rookie codex-setup [--yes] [--codex-md | --no-codex-md]
   rookie done-scan [--force]
   rookie context-diet [--json] [--force]
   rookie orphan-extract [--batch=5]
@@ -40,6 +40,8 @@ const HELP = `rookie — the Rookie Skill/Hook 설치 관리자
   --deep-scan   홈 디렉토리에서 로컬 Skill 전수 스캔
   --claude-md   글로벌 ~/.claude/CLAUDE.md 에 더루키 관리 블록을 넣는다(심링크·이미 같은 규칙이 있어도, update 에서도)
   --no-claude-md  글로벌 CLAUDE.md 를 건드리지 않는다 (환경 변수 ROOKIE_NO_CLAUDE_MD=1 과 같다)
+  --codex-md    Codex 전역 지시 파일(AGENTS.override.md 가 있으면 그것, 없으면 AGENTS.md)에 더루키 관리 블록을 넣는다
+  --no-codex-md   Codex 전역 지시 파일을 건드리지 않는다 (환경 변수 ROOKIE_NO_CODEX_MD=1 과 같다)
 
 명령:
   init             첫 설치. 비밀번호 입력 받아 PAT 발급 + Skill/Hook 배포.

package/src/commands/codex-setup.js

@@ -4,6 +4,8 @@ import { existsSync } from 'node:fs'
 import { confirm } from '../prompt.js'
 import { loadConfig } from '../config.js'
 import { applyCodexSetup } from '../lib/deploy-artifacts.js'
+import { runCodexMdStep } from '../lib/claude-md-block.js'
+import { codexHomeDir } from '../lib/codex-home.js'
 
 // Codex config.toml 에 더루키 SessionStart hook 을 동의 기반으로 등록한다(managed 블록만).
 // 명시적 Codex-only 재설정 진입점 — 내부 write 는 applyCodexSetup(3층 adapter) 공유(spec §4 item 6).
@@ -18,7 +20,7 @@ export async function runCodexSetup(flags) {
     console.error(`✗ hook 스크립트가 없습니다(${hookScript}). \`rookie login\` 또는 \`rookie update\` 를 먼저 실행하세요.`)
     process.exit(1)
   }
-  const configPath = join(homedir(), '.codex', 'config.toml')
+  const configPath = join(codexHomeDir(), 'config.toml')
 
   console.log('\nCodex 설정 파일에 더루키 SessionStart hook 을 등록합니다:')
   console.log(`  ${configPath}`)
@@ -33,4 +35,13 @@ export async function runCodexSetup(flags) {
     process.exit(1)
   }
   console.log('✓ 등록 완료. 새 Codex 세션부터 자동 적용됩니다.')
+
+  // spec 2026-09-29 codex-agents-md — Codex 전역 지시 파일에 "더루키 먼저" 관리 블록(동의 기반).
+  const { lines } = await runCodexMdStep({
+    mode: 'connect',
+    flags,
+    interactive: !!process.stdin.isTTY && !flags.yes,
+    confirmFn: confirm,
+  })
+  for (const line of lines) console.log(line)
 }

package/src/commands/doctor.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
-import { claudeMdStatusLine } from '../lib/claude-md-block.js'
+import { claudeMdStatusLine, codexMdStatusLine } from '../lib/claude-md-block.js'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { execSync } from 'node:child_process'
@@ -45,6 +45,8 @@ export async function runDoctor(flags) {
   console.log(hasRookieHook(lSettings) ? '✓ 로컬 hook 등록됨' : '  로컬 hook 없음')
   const claudeMdLine = claudeMdStatusLine()
   if (claudeMdLine) console.log(claudeMdLine)
+  const codexMdLine = codexMdStatusLine()
+  if (codexMdLine) console.log(codexMdLine)
 
   if (g && l && g.version !== l.version) {
     console.log(`⚠ 버전 불일치: 글로벌 v${g.version} vs 로컬 v${l.version}`)

package/src/commands/init.js

@@ -12,7 +12,7 @@ import { apiGet, apiPostNoAuth } from '../api.js'
 import { applyToolSetup, pendingToolSetup } from '../lib/apply-tool-setup.js'
 import { renderDetected, renderConnectOutcome, toolName } from '../lib/connect-ui.js'
 import { resolveEndpoint } from '../lib/resolve-endpoint.js'
-import { runClaudeMdStep } from '../lib/claude-md-block.js'
+import { runClaudeMdStep, runCodexMdStep } from '../lib/claude-md-block.js'
 
 async function pickChoice(prompt, options, autoValue) {
   console.log(prompt)
@@ -179,4 +179,9 @@ export async function runInit(flags) {
     const { lines } = await runClaudeMdStep({ mode: 'connect', flags, interactive, confirmFn: confirm })
     for (const line of lines) console.log(line)
   }
+  // 2026-09-29 두목 결정 — Codex 전역 지시 파일도 첫 연결에서 기본 적용(끄기 ROOKIE_NO_CODEX_MD=1).
+  if (scope === 'global' && report.applied.some((a) => a.id === 'codex')) {
+    const { lines } = await runCodexMdStep({ mode: 'connect', flags, interactive, confirmFn: confirm })
+    for (const line of lines) console.log(line)
+  }
 }

package/src/commands/login.js

@@ -10,7 +10,7 @@ import { renderDetected, renderConnectOutcome, toolName } from '../lib/connect-u
 import { confirm } from '../prompt.js'
 import { resolveEndpoint } from '../lib/resolve-endpoint.js'
 import { accountLine, accountWarning } from '../lib/account-ui.js'
-import { runClaudeMdStep } from '../lib/claude-md-block.js'
+import { runClaudeMdStep, runCodexMdStep } from '../lib/claude-md-block.js'
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
@@ -170,4 +170,14 @@ export async function runLogin(flags) {
     })
     for (const line of lines) console.log(line)
   }
+  // 2026-09-29 두목 결정 — Codex 전역 지시 파일도 첫 연결에서 기본 적용(끄기 ROOKIE_NO_CODEX_MD=1).
+  if (scope === 'global' && report.applied.some((a) => a.id === 'codex')) {
+    const { lines } = await runCodexMdStep({
+      mode: 'connect',
+      flags,
+      interactive: !!process.stdin.isTTY && !flags.yes,
+      confirmFn: confirm,
+    })
+    for (const line of lines) console.log(line)
+  }
 }

package/src/commands/update.js

@@ -13,7 +13,7 @@ import { semverGt, fetchReleaseManifest, selfUpdateAndRerun, isNpmManagedInstall
 import { installSkill } from '../lib/skill-installer.js'
 import { claudeHookCommand, escapeJsonStringValue } from '../lib/hook-command.js'
 import { mergeHooks } from '../lib/merge-hooks.js'
-import { runClaudeMdStep } from '../lib/claude-md-block.js'
+import { runClaudeMdStep, runCodexMdStep } from '../lib/claude-md-block.js'
 import { confirm } from '../prompt.js'
 
 const __filename = fileURLToPath(import.meta.url)
@@ -58,13 +58,11 @@ export async function runUpdate(flags) {
   //  manifest "최신" 조기 종료·서버 실패보다 앞에 둔다. 표식이 있으면 갱신, 없으면 대화형 확인 또는
   //  --claude-md 일 때만 붙인다 — update 는 모델이 비대화로 돌리는 경로가 있다.
   {
-    const { lines } = await runClaudeMdStep({
-      mode: 'update',
-      flags,
-      interactive: !!process.stdin.isTTY && !flags.yes,
-      confirmFn: confirm,
-    })
-    for (const line of lines) console.log(line)
+    const interactive = !!process.stdin.isTTY && !flags.yes
+    for (const step of [runClaudeMdStep, runCodexMdStep]) {
+      const { lines } = await step({ mode: 'update', flags, interactive, confirmFn: confirm })
+      for (const line of lines) console.log(line)
+    }
   }
 
   let serverManifest

package/src/detect.js

@@ -1,6 +1,7 @@
 import { readFileSync, existsSync, readdirSync, accessSync, constants } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
+import { codexHomeDir } from './lib/codex-home.js'
 
 // 통일 연결 흐름(spec 2026-06-29-unified-connect-flow §3 D1): 이 컴퓨터에 깔린 AI 도구를 감지한다.
 //  registry 형 — Cursor/Gemini 등은 entry 추가만으로 확장. boolean 반환 금지.
@@ -44,7 +45,7 @@ function defaultHasCli(name, env = process.env, platform = process.platform) {
 export function detectInstalledTools({ home = homedir(), env = process.env, hasCli = defaultHasCli } = {}) {
   return TOOL_REGISTRY.map((t) => {
     const cli = t.cliNames.some((n) => hasCli(n, env))
-    const dir = existsSync(join(home, t.homeDir))
+    const dir = existsSync(t.id === 'codex' ? codexHomeDir({ home, env }) : join(home, t.homeDir))
     const present = cli || dir
     const signal = cli ? 'strong' : dir ? 'weak' : 'none'
     const reason = cli ? `${t.id} CLI 발견` : dir ? `~/${t.homeDir} 존재` : '없음'

package/src/lib/apply-tool-setup.js

@@ -3,13 +3,14 @@ import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { installSharedHookRuntime, applyClaudeSetup, applyCodexSetup } from './deploy-artifacts.js'
 import { ROOKIE_BEGIN } from './codex-config.js'
+import { codexHomeDir } from './codex-home.js'
 
 // 도구가 이미 rookie 로 설정됐는지. init 의 도구-추가 모드(early-return 우회) 판정용.
-export function isToolConfigured(id, { scope, home = homedir(), cwd = process.cwd() } = {}) {
+export function isToolConfigured(id, { scope, home = homedir(), cwd = process.cwd(), env = process.env } = {}) {
   const base = scope === 'global' ? home : cwd
   if (id === 'claude') return existsSync(join(base, '.claude', 'skills', 'rookie', 'SKILL.md'))
   if (id === 'codex') {
-    const cfg = join(home, '.codex', 'config.toml')
+    const cfg = join(codexHomeDir({ home, env }), 'config.toml')
     return existsSync(cfg) && readFileSync(cfg, 'utf8').includes(ROOKIE_BEGIN)
   }
   return false

package/src/lib/claude-md-block.js

@@ -18,9 +18,11 @@ import {
 import { homedir } from 'node:os'
 import { join, dirname, basename } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { codexHomeDir } from './codex-home.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 export const DEFAULT_TEMPLATE_PATH = join(__dirname, '..', '..', 'templates', 'claude-md', 'rookie-block.md')
+export const CODEX_TEMPLATE_PATH = join(__dirname, '..', '..', 'templates', 'codex-md', 'rookie-block.md')
 
 const BEGIN_RE = /<!-- rookie:begin v(\d+) -->/g
 const END_MARK = '<!-- rookie:end -->'
@@ -58,28 +60,61 @@ export function upsertRookieBlock(content, blockText) {
   return content + sep + blockText + '\n'
 }
 
-// 무엇을 할지 정한다(쓰지 않는다). force = --claude-md.
+// 대상 서술자 — 어느 폴더의 어느 파일을 관리하는가(spec 2026-09-29 codex-agents-md §3).
+//  candidates: 앞에서부터 먼저 존재하는 파일이 Codex/Claude 가 실제로 읽는 파일이다.
+export function claudeTarget({ home = homedir() } = {}) {
+  return {
+    dir: join(home, '.claude'),
+    candidates: ['CLAUDE.md'],
+    createName: 'CLAUDE.md',
+    needles: [SAME_INTENT_NEEDLE],
+    noDirAction: 'no_claude_dir',
+    templatePath: DEFAULT_TEMPLATE_PATH,
+  }
+}
+
+// Codex 는 $CODEX_HOME(없으면 ~/.codex)의 AGENTS.override.md 가 있으면 그것만 읽고 AGENTS.md 는 무시한다
+// (2026-09-29 codex 0.153.4 바이너리 strings + codex exec 실측).
+export function codexTarget({ home = homedir(), env = process.env } = {}) {
+  return {
+    dir: codexHomeDir({ home, env }),
+    candidates: ['AGENTS.override.md', 'AGENTS.md'],
+    createName: 'AGENTS.md',
+    needles: [SAME_INTENT_NEEDLE, 'rookie_recall'],
+    noDirAction: 'no_codex_dir',
+    templatePath: CODEX_TEMPLATE_PATH,
+  }
+}
+
+function pickTargetFile(dir, candidates) {
+  for (const name of candidates) {
+    const p = join(dir, name)
+    try { return { path: p, lst: lstatSync(p) } } catch { /* 다음 후보 */ }
+  }
+  return null
+}
+
+// 무엇을 할지 정한다(쓰지 않는다). force = --claude-md / --codex-md.
 //  action: create | append | replace | noop | noop_edited | skip_same_intent |
-//          skip_symlink_unmanaged | skip_broken_symlink | skip_newer | malformed | no_claude_dir
-export function planClaudeMd({ home = homedir(), force = false, template } = {}) {
-  const tpl = template ?? readTemplateBlock()
-  const claudeDir = join(home, '.claude')
-  const path = join(claudeDir, 'CLAUDE.md')
-  const base = { path, target: path, isSymlink: false, template: tpl }
-  if (!existsSync(claudeDir)) return { ...base, action: 'no_claude_dir' }
-
-  let lst = null
-  try { lst = lstatSync(path) } catch { lst = null }
-  if (!lst) return { ...base, action: 'create' }
-
-  let target = path
-  const isSymlink = lst.isSymbolicLink()
+//          skip_symlink_unmanaged | skip_broken_symlink | skip_newer | malformed | no_claude_dir | no_codex_dir
+export function planManagedMd({ target, force = false, template } = {}) {
+  const tpl = template ?? readTemplateBlock(target.templatePath)
+  const createPath = join(target.dir, target.createName)
+  const base = { path: createPath, target: createPath, isSymlink: false, template: tpl, needles: target.needles }
+  if (!existsSync(target.dir)) return { ...base, action: target.noDirAction }
+
+  const found = pickTargetFile(target.dir, target.candidates)
+  if (!found) return { ...base, action: 'create' }
+
+  const path = found.path
+  let real = path
+  const isSymlink = found.lst.isSymbolicLink()
   if (isSymlink) {
-    try { target = realpathSync(path) } catch { return { ...base, isSymlink, action: 'skip_broken_symlink' } }
+    try { real = realpathSync(path) } catch { return { ...base, path, target: path, isSymlink, action: 'skip_broken_symlink' } }
   }
-  const content = readFileSync(target, 'utf8')
+  const content = readFileSync(real, 'utf8')
   const p = parseRookieBlock(content)
-  const ctx = { ...base, target, isSymlink, content, existing: p }
+  const ctx = { ...base, path, target: real, isSymlink, content, existing: p }
 
   if (p.state === 'malformed') return { ...ctx, action: 'malformed' }
   if (p.state === 'ok') {
@@ -90,10 +125,18 @@ export function planClaudeMd({ home = homedir(), force = false, template } = {})
   }
   // 표식 없음
   if (isSymlink && !force) return { ...ctx, action: 'skip_symlink_unmanaged' }
-  if (content.includes(SAME_INTENT_NEEDLE) && !force) return { ...ctx, action: 'skip_same_intent' }
+  if (target.needles.some((n) => content.includes(n)) && !force) return { ...ctx, action: 'skip_same_intent' }
   return { ...ctx, action: 'append' }
 }
 
+export function planClaudeMd({ home = homedir(), force = false, template } = {}) {
+  return planManagedMd({ target: claudeTarget({ home }), force, template })
+}
+
+export function planCodexMd({ home = homedir(), env = process.env, force = false, template } = {}) {
+  return planManagedMd({ target: codexTarget({ home, env }), force, template })
+}
+
 export const WRITING_ACTIONS = new Set(['create', 'append', 'replace'])
 
 // plan 대로 쓴다. 대상 파일 폴더에 임시 파일을 만들고 rename — 심링크 경로 자체는 건드리지 않는다.
@@ -121,9 +164,29 @@ export function applyClaudeMd(plan) {
   return { written: true, action: plan.action, target, backup: mode !== null ? `${target}.rookie-bak` : null }
 }
 
-// 명령(init·login·update)이 공유하는 한 단계. 출력 줄 목록을 돌려준다(테스트 가능하게).
-//  mode 'connect'(login·init): 기본 적용. 'update': 표식이 있을 때만 갱신, 없으면 대화형 확인 또는 --claude-md.
-export async function runClaudeMdStep({
+// 대상별 문구·플래그. CLAUDE.md 문구는 0.4.38 과 글자 그대로다(테스트가 고정한다).
+export const KINDS = {
+  claude: {
+    label: () => '글로벌 CLAUDE.md',
+    forceFlag: 'claude-md',
+    optOutFlag: 'no-claude-md',
+    optOutEnv: 'ROOKIE_NO_CLAUDE_MD',
+    plan: ({ home, force, template }) => planClaudeMd({ home, force, template }),
+  },
+  codex: {
+    // Codex 는 override 가 있으면 그 파일을 읽으므로 실제 파일 이름을 그대로 보인다.
+    label: (plan) => `Codex ${plan ? basename(plan.path) : 'AGENTS.md'}`,
+    forceFlag: 'codex-md',
+    optOutFlag: 'no-codex-md',
+    optOutEnv: 'ROOKIE_NO_CODEX_MD',
+    plan: ({ home, env, force, template }) => planCodexMd({ home, env, force, template }),
+  },
+}
+
+// 명령(init·login·update·codex-setup)이 공유하는 한 단계. 출력 줄 목록을 돌려준다(테스트 가능하게).
+//  mode 'connect'(login·init·codex-setup): 기본 적용. 'update': 표식이 있을 때만 갱신, 없으면 대화형 확인 또는 강제 플래그.
+export async function runManagedMdStep({
+  kind = 'claude',
   mode,
   flags = {},
   env = process.env,
@@ -132,40 +195,44 @@ export async function runClaudeMdStep({
   home = homedir(),
   template,
 } = {}) {
+  const K = KINDS[kind]
   const lines = []
-  if (flags['no-claude-md'] || env.ROOKIE_NO_CLAUDE_MD === '1') return { lines, result: { written: false, action: 'opted_out' } }
+  if (flags[K.optOutFlag] || env[K.optOutEnv] === '1') return { lines, result: { written: false, action: 'opted_out' } }
 
-  const force = !!flags['claude-md']
+  const force = !!flags[K.forceFlag]
+  const hintCmd = `rookie update --${K.forceFlag}`
   let plan
   try {
-    plan = planClaudeMd({ home, force, template })
+    plan = K.plan({ home, env, force, template })
   } catch (e) {
-    lines.push(`⚠ 글로벌 CLAUDE.md 점검 실패: ${e.message}`)
+    lines.push(`⚠ ${K.label()} 점검 실패: ${e.message}`)
     return { lines, result: { written: false, action: 'error' } }
   }
+  const label = K.label(plan)
   const where = plan.isSymlink ? `${plan.path} → ${plan.target}` : plan.path
 
   switch (plan.action) {
     case 'no_claude_dir':
+    case 'no_codex_dir':
     case 'noop':
       return { lines, result: { written: false, action: plan.action } }
     case 'noop_edited':
-      lines.push(`  글로벌 CLAUDE.md 의 더루키 블록이 수정돼 있어 그대로 둡니다 — 템플릿으로 되돌리려면 rookie update --claude-md`)
+      lines.push(`  ${label} 의 더루키 블록이 수정돼 있어 그대로 둡니다 — 템플릿으로 되돌리려면 ${hintCmd}`)
       return { lines, result: { written: false, action: plan.action } }
     case 'skip_same_intent':
-      lines.push(`  글로벌 CLAUDE.md 에 더루키 회상 규칙이 이미 있어 블록을 넣지 않았습니다 — 관리 블록으로 두려면 --claude-md`)
+      lines.push(`  ${label} 에 더루키 회상 규칙이 이미 있어 블록을 넣지 않았습니다 — 관리 블록으로 두려면 --${K.forceFlag}`)
       return { lines, result: { written: false, action: plan.action } }
     case 'skip_symlink_unmanaged':
-      lines.push(`  글로벌 CLAUDE.md 가 심링크라 블록을 넣지 않았습니다(${where}) — 넣으려면 --claude-md`)
+      lines.push(`  ${label} 가 심링크라 블록을 넣지 않았습니다(${where}) — 넣으려면 --${K.forceFlag}`)
       return { lines, result: { written: false, action: plan.action } }
     case 'skip_broken_symlink':
-      lines.push(`⚠ 글로벌 CLAUDE.md 심링크의 대상이 없습니다(${plan.path}) — 건드리지 않았습니다`)
+      lines.push(`⚠ ${label} 심링크의 대상이 없습니다(${plan.path}) — 건드리지 않았습니다`)
       return { lines, result: { written: false, action: plan.action } }
     case 'skip_newer':
-      lines.push(`  글로벌 CLAUDE.md 의 더루키 블록(v${plan.existing.version})이 이 CLI(v${plan.template.version})보다 새 버전이라 그대로 둡니다`)
+      lines.push(`  ${label} 의 더루키 블록(v${plan.existing.version})이 이 CLI(v${plan.template.version})보다 새 버전이라 그대로 둡니다`)
       return { lines, result: { written: false, action: plan.action } }
     case 'malformed':
-      lines.push(`⚠ 글로벌 CLAUDE.md 의 더루키 블록 표식이 손상돼 건드리지 않았습니다 — 수동 점검: ${plan.target}`)
+      lines.push(`⚠ ${label} 의 더루키 블록 표식이 손상돼 건드리지 않았습니다 — 수동 점검: ${plan.target}`)
       return { lines, result: { written: false, action: plan.action } }
     default:
       break
@@ -175,18 +242,18 @@ export async function runClaudeMdStep({
   const isNewBlock = plan.action === 'create' || plan.action === 'append'
   if (mode === 'update' && isNewBlock && !force) {
     if (!interactive) {
-      lines.push(`  글로벌 CLAUDE.md 에 더루키 블록이 없습니다 — 넣으려면 rookie update --claude-md (rookie doctor 로 확인)`)
+      lines.push(`  ${label} 에 더루키 블록이 없습니다 — 넣으려면 ${hintCmd} (rookie doctor 로 확인)`)
       return { lines, result: { written: false, action: 'needs_consent' } }
     }
-    console.log(describePlan(plan))
-    if (!(await confirmFn('글로벌 CLAUDE.md 에 이 블록을 넣을까요?', { defaultYes: false }))) {
-      lines.push('  글로벌 CLAUDE.md 블록 추가를 건너뛰었습니다')
+    console.log(describePlan(plan, label))
+    if (!(await confirmFn(`${label} 에 이 블록을 넣을까요?`, { defaultYes: false }))) {
+      lines.push(`  ${label} 블록 추가를 건너뛰었습니다`)
       return { lines, result: { written: false, action: 'declined' } }
     }
   } else if (mode === 'connect' && isNewBlock && interactive) {
-    console.log(describePlan(plan))
-    if (!(await confirmFn('글로벌 CLAUDE.md 에 이 블록을 넣을까요?', { defaultYes: true }))) {
-      lines.push('  글로벌 CLAUDE.md 블록 추가를 건너뛰었습니다 (나중에: rookie update --claude-md)')
+    console.log(describePlan(plan, label))
+    if (!(await confirmFn(`${label} 에 이 블록을 넣을까요?`, { defaultYes: true }))) {
+      lines.push(`  ${label} 블록 추가를 건너뛰었습니다 (나중에: ${hintCmd})`)
       return { lines, result: { written: false, action: 'declined' } }
     }
   }
@@ -195,49 +262,69 @@ export async function runClaudeMdStep({
   try {
     result = applyClaudeMd(plan)
   } catch (e) {
-    lines.push(`⚠ 글로벌 CLAUDE.md 쓰기 실패(원본 보존): ${e.message}`)
+    lines.push(`⚠ ${label} 쓰기 실패(원본 보존): ${e.message}`)
     return { lines, result: { written: false, action: 'error' } }
   }
   if (result.written) {
     const verb = plan.action === 'replace' ? `갱신(v${plan.existing.version} → v${plan.template.version})` : `추가(v${plan.template.version})`
-    lines.push(`✓ 글로벌 CLAUDE.md 더루키 블록 ${verb}: ${where}`)
+    lines.push(`✓ ${label} 더루키 블록 ${verb}: ${where}`)
     if (result.backup) lines.push(`  · 이전 본문 backup → ${result.backup}`)
-    if (mode === 'connect' && !interactive && isNewBlock) lines.push('  (넣지 않으려면 표식 사이를 지우고 ROOKIE_NO_CLAUDE_MD=1 로 두세요)')
+    if (mode === 'connect' && !interactive && isNewBlock) lines.push(`  (넣지 않으려면 표식 사이를 지우고 ${K.optOutEnv}=1 로 두세요)`)
   }
   return { lines, result }
 }
 
+export async function runClaudeMdStep(opts = {}) {
+  return runManagedMdStep({ ...opts, kind: 'claude' })
+}
+
+export async function runCodexMdStep(opts = {}) {
+  return runManagedMdStep({ ...opts, kind: 'codex' })
+}
+
 // 쓰기 전에 보여 줄 설명.
-export function describePlan(plan) {
+export function describePlan(plan, label = '글로벌 CLAUDE.md') {
   const where = plan.isSymlink ? `${plan.path} → ${plan.target}` : plan.path
   const what = plan.action === 'create' ? '새 파일로 만들고' : plan.action === 'append' ? '파일 끝에' : '기존 블록을 바꿔'
   return [
-    `\n글로벌 CLAUDE.md 에 더루키 관리 블록을 둡니다 — ${where}`,
+    `\n${label} 에 더루키 관리 블록을 둡니다 — ${where}`,
     `  ${what} 아래 블록을 넣습니다(표식 밖의 글은 건드리지 않습니다):`,
     ...plan.template.text.split('\n').map((l) => `  | ${l}`),
   ].join('\n')
 }
 
 // doctor 용 한 줄(읽기만).
-export function claudeMdStatusLine({ home = homedir(), template } = {}) {
+export function managedMdStatusLine({ kind = 'claude', home = homedir(), env = process.env, template } = {}) {
+  const K = KINDS[kind]
+  const hintCmd = `rookie update --${K.forceFlag}`
   let plan
-  try { plan = planClaudeMd({ home, force: false, template }) } catch (e) { return `⚠ 글로벌 CLAUDE.md 점검 실패: ${e.message}` }
+  try { plan = K.plan({ home, env, force: false, template }) } catch (e) { return `⚠ ${K.label()} 점검 실패: ${e.message}` }
+  const label = K.label(plan)
   const v = plan.template.version
   switch (plan.action) {
-    case 'no_claude_dir': return null
-    case 'noop': return `✓ 글로벌 CLAUDE.md 더루키 블록 v${v}`
-    case 'replace': return `⚠ 글로벌 CLAUDE.md 더루키 블록 v${plan.existing.version} → v${v} — rookie update`
-    case 'noop_edited': return '⚠ 글로벌 CLAUDE.md 더루키 블록이 수정됨 — 되돌리려면 rookie update --claude-md'
-    case 'skip_newer': return `✓ 글로벌 CLAUDE.md 더루키 블록 v${plan.existing.version} (이 CLI 보다 새 버전)`
-    case 'skip_same_intent': return '✓ 글로벌 CLAUDE.md 에 더루키 회상 규칙 있음(관리 블록 아님)'
+    case 'no_claude_dir':
+    case 'no_codex_dir': return null
+    case 'noop': return `✓ ${label} 더루키 블록 v${v}`
+    case 'replace': return `⚠ ${label} 더루키 블록 v${plan.existing.version} → v${v} — rookie update`
+    case 'noop_edited': return `⚠ ${label} 더루키 블록이 수정됨 — 되돌리려면 ${hintCmd}`
+    case 'skip_newer': return `✓ ${label} 더루키 블록 v${plan.existing.version} (이 CLI 보다 새 버전)`
+    case 'skip_same_intent': return `✓ ${label} 에 더루키 회상 규칙 있음(관리 블록 아님)`
     case 'skip_symlink_unmanaged':
-      return plan.content.includes(SAME_INTENT_NEEDLE)
-        ? '✓ 글로벌 CLAUDE.md(심링크)에 더루키 회상 규칙 있음(관리 블록 아님)'
-        : '⚠ 글로벌 CLAUDE.md(심링크)에 더루키 블록 없음 — rookie update --claude-md'
-    case 'skip_broken_symlink': return `⚠ 글로벌 CLAUDE.md 심링크 대상 없음 — ${plan.path}`
-    case 'malformed': return `✗ 글로벌 CLAUDE.md 더루키 블록 손상(begin/end 불일치) — 수동 점검: ${plan.target}`
-    case 'create': return '⚠ 글로벌 CLAUDE.md 없음 — rookie update --claude-md'
-    case 'append': return '⚠ 글로벌 CLAUDE.md 에 더루키 블록 없음 — rookie update --claude-md'
+      return plan.needles.some((n) => plan.content.includes(n))
+        ? `✓ ${label}(심링크)에 더루키 회상 규칙 있음(관리 블록 아님)`
+        : `⚠ ${label}(심링크)에 더루키 블록 없음 — ${hintCmd}`
+    case 'skip_broken_symlink': return `⚠ ${label} 심링크 대상 없음 — ${plan.path}`
+    case 'malformed': return `✗ ${label} 더루키 블록 손상(begin/end 불일치) — 수동 점검: ${plan.target}`
+    case 'create': return `⚠ ${label} 없음 — ${hintCmd}`
+    case 'append': return `⚠ ${label} 에 더루키 블록 없음 — ${hintCmd}`
     default: return null
   }
 }
+
+export function claudeMdStatusLine({ home = homedir(), template } = {}) {
+  return managedMdStatusLine({ kind: 'claude', home, template })
+}
+
+export function codexMdStatusLine({ home = homedir(), env = process.env, template } = {}) {
+  return managedMdStatusLine({ kind: 'codex', home, env, template })
+}

package/src/lib/codex-home.js

@@ -0,0 +1,8 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+// Codex 설정 폴더. Codex 는 $CODEX_HOME 이 있으면 그 폴더를 쓴다(2026-09-29 바이너리 strings 실측).
+// config.toml·AGENTS.md·감지가 모두 이 한 곳을 보게 한다 — 갈리면 hook 과 지시 블록이 서로 다른 폴더에 들어간다.
+export function codexHomeDir({ home = homedir(), env = process.env } = {}) {
+  return env.CODEX_HOME ? env.CODEX_HOME : join(home, '.codex')
+}

package/src/lib/deploy-artifacts.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, cpSync } from 'node:fs'
 import { homedir } from 'node:os'
+import { codexHomeDir } from './codex-home.js'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { apiGet } from '../api.js'
@@ -163,8 +164,8 @@ export async function applyClaudeSetup({ scope, cfg, home, cwd } = {}) {
 
 // ── 3층: Codex adapter — ~/.codex/config.toml 의 managed 블록(upsertCodexHookBlock).
 //    scope=global 전제(D3): Codex config 는 항상 전역이고 전역 hook 을 문다. 호출 게이트는 오케스트레이터 책임.
-export function applyCodexSetup({ home = homedir() } = {}) {
-  const codexDir = join(home, '.codex')
+export function applyCodexSetup({ home = homedir(), env = process.env } = {}) {
+  const codexDir = codexHomeDir({ home, env })
   const configPath = join(codexDir, 'config.toml')
   const hookScript = join(home, '.rookie', 'bin', 'session-start.sh')
   const existing = existsSync(configPath) ? readFileSync(configPath, 'utf8') : ''

package/templates/codex-md/rookie-block.md

@@ -0,0 +1,7 @@
+<!-- rookie:begin v1 -->
+## 더루키(the Rookie) 기억 — 로컬보다 먼저
+- 전에 한 일·결정·맥락이 필요하면(어제·전에·이어서 같은 말이 없어도) 로컬 메모·Codex 자체 기억을 뒤지기 **전에** 더루키 회상을 먼저 부른다 — rookie MCP 도구 `rookie_recall` 이 있으면 그것을, 없으면 셸에서 `GET /api/rookie/recall`(rookie CLI 설정의 endpoint·토큰). 로컬 기억은 보조다.
+- 새로 기억할 것(운영 사실·결정·규칙·취향)은 **더루키에 먼저** 저장한다 — `rookie_save` 도구 또는 셸의 `rookie save`. 로컬 메모는 필요할 때만 보조로 남긴다.
+- 예외: 작업 폴더에 `.rookie-ignore` 가 있거나, `ROOKIE_DISABLED=1` 이거나, `~/.rookie/config.json` 이 없으면 위 두 줄을 따르지 않는다.
+- 세부 절차는 세션 시작 주입(더루키 hook)이 정본이다 — 여기에 옮겨 적지 않는다.
+<!-- rookie:end -->

package/version.json

@@ -1,4 +1,4 @@
 {
-  "cli_version": "0.4.38",
+  "cli_version": "0.4.40",
   "skill_version": "1.40.1"
 }