genetics-mcp 2.24.0 → 2.26.0

package/genetics.mjs

@@ -28,6 +28,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { pipeline as streamPipeline } from 'node:stream/promises';
 import { fileURLToPath } from 'node:url';
+import { codexSessionId, codexRollouts, codexMetadata, codexHumanRoot, findCodexRollout,
+  prepareCodexProjection, cachedCodexProjection, CODEX_CODEC } from './codex-session.mjs';
 
 /**
  * 판을 **package.json 에서 읽는다.** 전에는 serverInfo 에 '1.0.0' 이 상수로 박혀 있어서
@@ -122,6 +124,10 @@ try {
 Object.assign(cfg, Object.fromEntries(
   Object.entries(process.env).filter(([k]) => k.startsWith('GENETICS_'))
 ));
+const SESSION_WATCH_UUID = String(cfg.GENETICS_SESSION_WATCH_UUID || '').toLowerCase();
+if (SESSION_WATCH_UUID && !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(SESSION_WATCH_UUID)) throw new Error('Invalid session watch UUID');
+function sessionScope(uuid) { return !SESSION_WATCH_UUID || String(uuid).toLowerCase() === SESSION_WATCH_UUID; }
+function sessionToolMode() { return cfg.GENETICS_SESSION_ONLY === '1' || !!SESSION_WATCH_UUID; }
 
 // **기본 주소를 두지 않는다.** 값을 박아 두면 출하물이 "그 서버를 아는 클라이언트" 가 되고,
 // 공개 배포 시 운영 엔드포인트가 그대로 공개된다. 주소는 쓰는 쪽이 정한다.
@@ -1377,6 +1383,13 @@ const REPORT_DATA = {
       description: '요약면 현황 줄 {state, text} — state 는 critical|info|success. '
                  + '**상태에 따라 바뀌는 유일한 줄**이다. 떠 있는 알림 배너를 따로 두지 마라.',
     },
+    summary_position: {
+      type: 'string', enum: ['front'],
+      description: '선택해서 `front` 를 주면 최상위 `summary[]` 를 문서 앞 요약면에도 싣는다. '
+        + '생략하면 기존 요약면(현황·수치)과 kind:"summary" 절의 배치를 유지한다. '
+        + '앞 요약만 필요하면 kind:"summary" 절을 따로 두지 마라 — 두 곳에 같은 요지가 실린다. '
+        + '요약의 refs 는 실제 사례나 presentation:"prose" 절의 문단을 가리켜야 한다.',
+    },
     bar: { type: 'array', description: '요약면 상태 막대 [{value, label, tone}] · tone 은 done|wait' },
     bar_note: { type: 'string', description: '막대가 뜻하는 바의 한정 조건 (※ 각주)' },
     bar_alt: { type: 'string', description: '막대의 대체 텍스트 (보조기기용)' },
@@ -1478,7 +1491,29 @@ const REPORT_DATA = {
                  + '· `tone`: 장 색을 뜻으로 고른다 — you(독자 몫)·deep(요지)·neutral(허브)·'
                  + 'done(끝난 것)·wait(대기)·hold(유보). 생략하면 kind 가 정한다.\n'
                  + '· kind:status 전용 — `board_title`(대조표 제목) · `board_hint`(표 아래 안내).\n'
-                 + '· kind:note 전용 — `paragraphs`(강조 박스의 항목) · `limit_label`(그 박스 제목).',
+                 + '· kind:note 전용 — `paragraphs`(문자열 목록) · `limit_label`(기본 강조 박스 제목). '
+                 + 'presentation:"prose" 를 선택하면 paragraphs 를 항목 상자 대신 실제 산문 문단으로 싣는다. '
+                 + '문단 번호는 절 배열 순번·문단 배열 순번이며 §1.2 는 1번째 절의 2번째 문단 앵커를 가리킨다. '
+                 + 'paragraph_kinds 는 paragraphs 와 같은 길이·순서의 역할 목록이다(아래 items 계약).',
+      items: {
+        type: 'object',
+        properties: {
+          presentation: {
+            type: 'string', enum: ['prose'],
+            description: 'kind:"note" 에서만 선택하는 산문 표시. paragraphs 를 실제 <p> 문단으로 '
+              + '싣고 요약 refs 가 가리키는 case-<두 자리 절 순번>-<문단 순번> 앵커를 유지한다. '
+              + '생략하면 기존 강조 박스·limit_label 을 쓴다. 다른 kind 의 본문 장치는 바뀌지 않는다.',
+          },
+          paragraph_kinds: {
+            type: 'array', maxItems: 120,
+            items: { type: 'string', enum: ['fact', 'context', 'analysis', 'proposal', 'unknown'] },
+            description: 'presentation:"prose" 문단 역할. paragraphs 와 같은 길이·순서로 둔다. '
+              + 'fact(확인 사실)·context(맥락)는 별도 표식 없이 읽히고, analysis·proposal·unknown 은 '
+              + '각각 「해석」·「제안」·「추가 확인 필요」로 표시된다. 생략하면 역할 표식이 없다. '
+              + '역할은 글의 구분이며 사실 검증이나 접근 권한을 대신하지 않는다.',
+          },
+        },
+      },
     },
     chapters: {
       type: 'array',
@@ -1523,9 +1558,10 @@ const REPORT_DATA = {
     },
     summary: {
       type: 'array',
-      description: 'summary 절 내용 [{lead, body, refs?}] — 각 문단은 근거로 삼은 **사례 번호**를 '
-        + '최소 하나 밝혀야 한다(예: 본문에 "§3.1" 이라 쓰거나 refs:["3.1"]). 절 번호가 아니라 '
-        + '사례 번호다. 근거가 없으면 서버가 발행을 거절한다.',
+      description: '요지 [{lead, body, refs?}] — kind:"summary" 절, summary_position:"front" 이면 앞 요약면에도 선다. '
+        + '각 문단은 근거로 삼은 실제 사례 또는 kind:"note", presentation:"prose" 의 문단 번호를 '
+        + '최소 하나 밝혀야 한다(예: 본문에 "§3.1" 이라 쓰거나 refs:["3.1"]). '
+        + '산문이면 3번째 절의 1번째 문단이다. 없는 번호나 근거 표기 누락은 서버가 거절한다.',
     },
     open_items: {
       type: 'array',
@@ -2002,12 +2038,14 @@ function transcriptDir(dir) {
 
 /** uuid 로 이 기계의 트랜스크립트를 찾는다. 지금 프로젝트를 먼저 보고, 없으면 전체를 훑는다. */
 function findTranscript(uuid) {
+  const native = findCodexRollout(uuid);
+  if (native) return cachedCodexProjection(native, codexProjectionRoot()) || null;
   const here = path.join(transcriptDir(process.cwd()), `${uuid}.jsonl`);
   if (fs.existsSync(here)) return here;
   const root = path.join(os.homedir(), '.claude', 'projects');
   // Claude Code 가 없는 기계(Cursor 만 깔린 곳)에는 이 디렉터리 자체가 없다 —
   // 「전사 없음」이지 오류가 아니다. 던지면 mail 등 도구가 통째로 죽는다(smoke 실측).
-  if (!fs.existsSync(root)) return null;
+  if (!fs.existsSync(root)) return cursorTranscriptOf(uuid);
   for (const d of fs.readdirSync(root, { withFileTypes: true })) {
     if (!d.isDirectory()) continue;
     const f = path.join(root, d.name, `${uuid}.jsonl`);
@@ -2190,9 +2228,9 @@ function cursorWorkspaceFolder() {
   return cursorSeen.folder;
 }
 
-/** 「지금 이 세션」 — Claude Code env 가 정본, 없으면 Cursor 활성 대화. */
+/** Harness identity precedes UI discovery. Native Codex THREAD_ID identifies the current child. */
 function mySessionId() {
-  return process.env.CLAUDE_CODE_SESSION_ID || cursorActiveComposer();
+  return process.env.CLAUDE_CODE_SESSION_ID || codexSessionId() || cursorActiveComposer();
 }
 
 /**
@@ -2217,12 +2255,12 @@ function hookLane() {
   return hookLaneMemo.v;
 }
 
-function gitHere() {
+function gitHere(dir = process.cwd()) {
   try {
-    const r = spawnSync('git', ['-C', process.cwd(), 'rev-parse', '--abbrev-ref', 'HEAD'],
+    const r = spawnSync('git', ['-C', dir, 'rev-parse', '--abbrev-ref', 'HEAD'],
                         { encoding: 'utf8' });
     const b = (r.stdout || '').trim();
-    const c = spawnSync('git', ['-C', process.cwd(), 'rev-parse', '--short', 'HEAD'],
+    const c = spawnSync('git', ['-C', dir, 'rev-parse', '--short', 'HEAD'],
                         { encoding: 'utf8' });
     return [b, (c.stdout || '').trim()].filter(Boolean).join('@');
   } catch { return ''; }
@@ -3037,12 +3075,28 @@ async function pushAppend(a) {
  * 이 대화를 **무엇이** 만들었는가. 판번호만으로는 세션끼리 구별이 안 되므로 클라이언트를 함께 싣는다.
  * 값이 없으면 키를 안 만든다 — 없는 것을 「알 수 없음」으로 적으면 그 값이 다시 상수가 된다.
  */
-function toolsStamp() {
+function toolsStamp(native = null) {
   const t = { mcp: VERSION };
-  if (CLIENT?.name) t.client = CLIENT.version ? `${CLIENT.name}/${CLIENT.version}` : String(CLIENT.name);
+  if (native) { t.client = `codex/${native.cli_version}`; t.source_format = 'codex-rollout'; t.codec = CODEX_CODEC; }
+  else if (CLIENT?.name) t.client = CLIENT.version ? `${CLIENT.name}/${CLIENT.version}` : String(CLIENT.name);
   return t;
 }
 
+function codexProjectionRoot() { return path.join(path.dirname(CRED_FILE), 'codex-projections'); }
+function isNativeProjection(file) { return typeof file === 'string' && path.dirname(file) === codexProjectionRoot(); }
+function nativeSessionTools(tools) {
+  if (typeof tools === 'string') { try { tools = JSON.parse(tools); } catch { return false; } }
+  return tools?.source_format === 'codex-rollout' || /^codex\//.test(String(tools?.client || ''));
+}
+
+async function prepareNativeSession(uuid) {
+  const native = findCodexRollout(uuid);
+  if (!native) return null;
+  const prepared = await prepareCodexProjection(native, { cacheRoot: codexProjectionRoot(), scrub: scrubTranscript, scrubRevision: SCRUB_REV });
+  pathCache.set(uuid, { file: prepared.projection, at: Date.now() });
+  return prepared;
+}
+
 /** 개행 없는 끝 줄이 **다 쓴 줄**인가 — 온전한 JSON 객체로 읽히면 그렇다(반쪽 줄은 객체로 안 읽힌다). 공백뿐이면 아니다. */
 function cursorTailDone(tail) {
   const s = tail.toString('utf8');
@@ -3058,16 +3112,23 @@ function cursorTailDone(tail) {
  *   `auto` 와 달리 머리·folder 를 안 싣는다) · `progress` 는 요청 하나(조각 하나)가 끝날 때마다 — 임대의 묵음 시계를 민다(§3.2).
  */
 async function pushSession(tenant, uuid, title, dryRun, bind = 'skip', auto = null, hooks = null, tenantIdHint = 0) {
-  const f = findTranscript(uuid);
+  const native = await prepareNativeSession(uuid);
+  const f = native?.projection || findTranscript(uuid);
   if (!f) throw new Error(`이 기계에 그 세션이 없습니다: ${uuid}`);
   // 한 fd 로 stat 과 읽기를 한다 — 대응표의 ino·dev 가 읽은 그 파일의 것이어야 한다(§2.11).
   // ★ **덧붙임은 이 fd 를 자리 읽기로만 쓴다**(C8) — 전사를 통째로 안 읽는 것이 이 커밋의 요지다.
   const fd = fs.openSync(f, 'r');
-  try { return await pushSessionFd(fd, f, tenant, uuid, title, dryRun, bind, auto, hooks, tenantIdHint); }
+  try {
+    const result = await pushSessionFd(fd, f, tenant, uuid, title, dryRun, bind, auto, hooks, tenantIdHint, native);
+    return native ? { ...result, before: native.source_bytes, source_client: 'codex', source: {
+      codec: native.codec, raw_bytes: native.source_bytes, complete_bytes: native.raw_off,
+      records: native.records, kept: native.kept, deferred_bytes: native.deferred_bytes, projection_bytes: native.projection_bytes,
+      omitted_images: native.omitted_images, omitted_large: native.omitted_large } } : result;
+  }
   finally { fs.closeSync(fd); }
 }
 
-async function pushSessionFd(fd, f, tenant, uuid, title, dryRun, bind, auto, hooks, tenantIdHint) {
+async function pushSessionFd(fd, f, tenant, uuid, title, dryRun, bind, auto, hooks, tenantIdHint, native = null) {
   const st = fs.fstatSync(fd, { bigint: true });
   const size = Number(st.size);
   const isCursorBody = f.includes(`${path.sep}.cursor${path.sep}projects${path.sep}`);
@@ -3153,7 +3214,7 @@ async function pushSessionFd(fd, f, tenant, uuid, title, dryRun, bind, auto, hoo
   const body = {
     tenant, uuid,
     origin_cwd: sc.cwd || (isCursorBody ? relHome(cursorWorkspaceFolder() || '') : relHome(process.cwd())),
-    origin_git: gitHere(), tools: toolsStamp(),
+    origin_git: gitHere(native ? (sc.cwd_raw || native.cwd) : process.cwd()), tools: toolsStamp(native),
     jsonl: sc.jsonl,
   };
   if (typeof title === 'string' && title.trim() !== '') body.title = title.trim();
@@ -3556,12 +3617,12 @@ function indexTenant(uuid, t) {
   try { return indexWrite(uuid, t, {}, ''); } catch { return false; }
 }
 
-/** 옛 부름 자리의 껍데기 — 소속 칸(서버 응답)과 나머지를 갈라 **한 번의 잠금으로** 적는다. */
+/** 옛 부름 자리의 껍데기 — 소속 칸과 나머지를 한 번에 적고, 쓰기 수락 여부를 돌려준다. */
 function indexNote(uuid, entry, flow = '') {
-  if (!uuid || !entry?.tenant_id) return;
+  if (!uuid || !entry?.tenant_id) return false;
   const { tenant_id, tenant_slug, tenant, src, resolved_at, ...rest } = entry;
-  try { indexWrite(uuid, { tenant_id, tenant_slug, tenant, src }, rest, flow); }
-  catch { /* 색인은 있으면 좋은 것이지 도구가 실패할 이유가 아니다 */ }
+  try { return indexWrite(uuid, { tenant_id, tenant_slug, tenant, src }, rest, flow); }
+  catch { return false; /* 색인은 있으면 좋은 것이지 도구가 실패할 이유가 아니다 */ }
 }
 
 /**
@@ -4162,6 +4223,7 @@ function beatTargets(extra = []) {
   const now = Date.now();
   const out = [];
   for (const [uuid, e] of Object.entries(idx)) {
+    if (!sessionScope(uuid)) continue;
     if (!e?.tenant_id) continue;
     const f = transcriptOf(uuid);
     if (!f) continue;                       // 이 기계에 사본이 없으면 「쥐고 있다」가 아니다
@@ -4742,6 +4804,40 @@ function autoFolderOf(real, now = Date.now()) {
 let autoScan = { at: 0, rows: [] };   // 되찾기 훑기의 마지막 결과 — [{ uuid, file, mtime }]
 const autoSettled = new Map();        // uuid → 'size:mtime' — 서버가 SAME·BEHIND 라 한 사본(파일이 바뀌면 다시 본다)
 const autoTenantWait = new Map();     // tenant_id → epoch ms — 429 auto_rate 의 retry_after(그 상한은 소속처 단위다)
+let nativeInventory = { at: 0, rows: [] };
+const nativeAutoRows = new Map();
+
+/** Native date directories carry no tenant. Only validated source cwd and an effective confirmed binding do. */
+async function refreshCodexSessions(now = Date.now()) {
+  const byDir = autoFolderMap(resolveCacheRead(), now), idx = indexRead(), mine = mySessionId();
+  if (now - nativeInventory.at >= AUTO_SCAN_EVERY_MS) {
+    nativeInventory = { at: now, rows: codexRollouts().filter(r => sessionScope(r.uuid)).map(r => codexMetadata(r.file, r.uuid)).filter(Boolean)
+      .sort((a, b) => b.mtime - a.mtime) };
+  }
+  const perFolder = new Map();
+  nativeAutoRows.clear();
+  for (const meta of nativeInventory.rows) {
+    // Background child transcripts are separate conversations, never implicit root-session backfill.
+    if (!codexHumanRoot(meta)) continue;
+    const known = autoRowOnServer(idx[meta.uuid]);
+    let real;
+    try { real = fs.realpathSync(meta.cwd); } catch { continue; }
+    const hit = byDir.get(transcriptDir(real));
+    const permitted = autoPushOn() && hit?.entry.state === 'bound' && hit.entry.auto_upload === true && !hit.entry.stale;
+    if (!known && !permitted) continue;
+    if (!known && meta.uuid !== mine && (now - meta.mtime > AUTO_SCAN_MAX_AGE_MS || meta.mtime < autoFloorMs(hit.entry))) continue;
+    const count = perFolder.get(real) || 0;
+    if (!known && meta.uuid !== mine && count >= AUTO_SCAN_PER_FOLDER) continue;
+    perFolder.set(real, count + 1);
+    try {
+      const fresh = codexMetadata(meta.file, meta.uuid);
+      if (!fresh) continue;
+      const prepared = await prepareCodexProjection(fresh, { cacheRoot: codexProjectionRoot(), scrub: scrubTranscript, scrubRevision: SCRUB_REV });
+      pathCache.set(meta.uuid, { file: prepared.projection, at: now });
+      if (hit) nativeAutoRows.set(meta.uuid, { ...prepared, hit });
+    } catch (e) { warnOnce(`codex-projection-${meta.uuid}`, `native Codex 세션 ${meta.uuid.slice(0, 8)}을 준비하지 못했다: ${e.message}`); }
+  }
+}
 
 /** 전사 자리(transcriptDir) → 그 자리를 물었던 폴더의 답. resolve 캐시의 `by_path` 가 유일한 재료다. */
 function autoFolderMap(cache = resolveCacheRead(), now = Date.now()) {
@@ -4765,8 +4861,8 @@ function autoCandidates(now = Date.now()) {
   const mine = mySessionId();
   const seen = new Map();
   const add = (uuid, file) => {
-    if (!file || seen.has(uuid) || isCursorTranscript(file)) return;
-    const hit = byDir.get(path.dirname(file));
+    if (!sessionScope(uuid) || !file || seen.has(uuid) || isCursorTranscript(file)) return;
+    const hit = nativeAutoRows.get(uuid)?.hit || byDir.get(path.dirname(file));
     if (!hit) return;
     let st;
     try { st = fs.statSync(file); } catch { return; }
@@ -4801,6 +4897,7 @@ function autoCandidates(now = Date.now()) {
     autoScan = { at: now, rows };
   }
   for (const r of autoScan.rows) if (!idx[r.uuid]) add(r.uuid, r.file);
+  for (const [uuid, native] of nativeAutoRows) add(uuid, native.projection);
   const out = [...seen.values()];
   for (const c of out) {
     if (c.entry.state !== 'bound' || c.entry.auto_upload !== true) continue;
@@ -5162,6 +5259,8 @@ function autoPolicyOf(t, ctx) {
    *   ⚠ 자동이 **꺼졌거나·낡았거나·ambiguous** 인 폴더는 아래 null ① 그대로다(privacy B5) — 오너가 끈 동의를 옛 길이 안 거스른다.
    */
   const boundOn = st === 'bound' && e.auto_upload === true && !e.stale;
+  // Native support starts with explicit effective binding consent; it has no historical legacy-upload lane.
+  if (t.native && !(boundOn && t.c)) return no('not_bound_auto');
   // ── bound ──
   if (boundOn && t.c) {
     if (ctx.client_old) return no('client_old');                            // ① 만 끈다(서버가 426 으로 막을 자리)
@@ -5421,18 +5520,19 @@ async function autoSyncRound(reply, recs, cands, ctx0 = null) {
   const seen = new Set();
   for (const c of autoOrder(cands)) {
     seen.add(c.uuid);
-    list.push({ uuid: c.uuid, c, file: c.file, size: c.size, mtime: c.mtime, entry: c.entry, row: c.row, rec: recOf.get(c.uuid) || null });
+    list.push({ uuid: c.uuid, c, file: c.file, native: isNativeProjection(c.file), size: c.size, mtime: c.mtime, entry: c.entry, row: c.row, rec: recOf.get(c.uuid) || null });
   }
   for (const v of reply) {
+    if (!sessionScope(v.uuid)) continue;
     if (seen.has(v.uuid) || v.verdict !== BEAT_VERDICT.AHEAD) continue;
     seen.add(v.uuid);
     const file = transcriptOf(v.uuid);
     if (!file) continue;
     let st;
     try { st = fs.statSync(file); } catch { continue; }
-    const hit = isCursorTranscript(file) ? null : byDir.get(path.dirname(file));
+    const hit = isCursorTranscript(file) ? null : (nativeAutoRows.get(v.uuid)?.hit || byDir.get(path.dirname(file)));
     const row = ctx.idx?.[v.uuid] && typeof ctx.idx[v.uuid] === 'object' ? ctx.idx[v.uuid] : null;
-    list.push({ uuid: v.uuid, c: null, file, size: st.size, mtime: st.mtimeMs, entry: hit ? hit.entry : null, row, rec: recOf.get(v.uuid) || null });
+    list.push({ uuid: v.uuid, c: null, file, native: isNativeProjection(file), size: st.size, mtime: st.mtimeMs, entry: hit ? hit.entry : null, row, rec: recOf.get(v.uuid) || null });
   }
   for (const t of list) {
     t.v = verdict.get(t.uuid) || null;
@@ -5453,7 +5553,7 @@ function autoHoldTenants(uuid) {
   const hits = [];
   const f = transcriptOf(uuid);
   if (f && !isCursorTranscript(f)) {
-    const hit = autoFolderMap(cache).get(path.dirname(f));
+    const hit = nativeAutoRows.get(uuid)?.hit || autoFolderMap(cache).get(path.dirname(f));
     if (hit) hits.push(hit.entry);
   }
   if (uuid === mySessionId()) {
@@ -5485,6 +5585,7 @@ async function beatTick() {
   try {
     // 폴더 소속은 서버가 정한다 — 때가 되면 resolve 캐시를 갱신한다(§5.3). 조기 반환보다 **앞**이다.
     try { await resolveTick(); } catch { /* 소속 확인 실패가 심박을 멈추면 안 된다 */ }
+    try { await refreshCodexSessions(); } catch (e) { warnOnce('codex-discovery', `native Codex 후보를 확인하지 못했다: ${e.message}`); }
     minClientTick();                          // 판 비교 — 30분에 한 번(§5.8). 조기 반환보다 **앞**이다
     // 확정·자동 폴더의 후보(§5.5) — 서버 소속을 이 기계가 모르는 사본도 판정을 받게 심박에 싣는다.
     let cands = [];
@@ -5961,9 +6062,11 @@ const TOOLS = [
       '**노출 상태는 안 바꾼다**(2026-09-14) — 초안(release 전)을 고치면 초안 그대로고, 열린 문서를 고치면 열린 그대로다. ' +
       '초안을 여는 동사는 release_report 하나다. get_report 로 되읽은 데이터에 섞여 오는 publish·published_at 은 이 도구가 떼고 보낸다 — 그 값으로는 안 열린다. ' +
       '사람이 편집기로 고친 문서도 교체할 수 있다(2026-08-25) — 대신 무엇을 덮게 되는지 목록이 먼저 말하고, 덮은 뒤 되돌릴 판이 응답에 온다. ' +
-      '**그림 계약**: `assets` 를 **빼고** 보내면 서버가 저장된 그림을 그대로 유지한다. 전부 지우려면 `assets: []` 를 명시하고 ' +
+      '**그림 계약**: `assets` 를 **빼고** 보내면 서버가 저장된 그림을 그대로 유지한다 — 캡션·출처 줄·alt 같은 도판 글 칸도 저장값 그대로라, 글 칸을 고쳤으면 `assets` 를 get_report 표식째 목록으로 보낸다. 전부 지우려면 `assets: []` 를 명시하고 ' +
       '`sections[].plates`·`chapters[].asset` 에서도 그 id 를 빼야 한다 — 가리키는 곳이 없는 id 는 422 로 거절된다. ' +
-      '한 장만 바꾸려면 그 id 에 새 `source`/`file` 을 주고 나머지는 get_report 가 준 표식 그대로 두면 된다.\n' +
+      '한 장만 바꾸려면 그 id 에 새 `source`/`file` 을 주고 나머지는 get_report 가 준 표식 그대로 두면 된다. ' +
+      '**받은 판 잠금**(2026-09-30): get_report 머리줄의 body_rev 를 `body_rev` 로 실으면, 받은 뒤 본문 판이 바뀌었을 때 서버가 409 로 멈추고 아무것도 안 쓴다. ' +
+      'dry_run 에도 같이 실으면 같은 409 를 덮기 전에 받는다. 서버가 이 잠금을 모르는 옛 판이면 출력이 「판을 견주지 않았다」고 알린다.\n' +
       '**문체는 주어와 자리가 정한다** — 요청 자리 밖에는 우리·사물·화면이 주어인 문장만 개조식(~함/~했음/~임)으로 쓴다. 독자가 할 일은 요청 자리(open_items·cta·PART I 간지(요청·결정 PART 일 때)·판권지 회신 안내·요청 절 항을 부탁하는 읽는 법 한 줄)에만 두고 사실 문장까지 하십시오체로 맺는다(「회신 부탁드립니다」. 제목은 검수·보고면 「~ 요청」+기한 괄호, 결정 문서의 판단 항목은 물음). 그 밖의 칸에는 사실만 적는다(「기준 수치는 미정」). dry_run 은 일부만 센다.\n',
     inputSchema: {
       type: 'object',
@@ -5975,6 +6078,11 @@ const TOOLS = [
           description: '참이면 아무것도 바꾸지 않고 렌더 결과와 경고만 돌려준다. '
             + '이 문서는 이미 고객에게 나간 링크를 갖고 있으니 덮기 전에 한 번 볼 수 있다.',
         },
+        body_rev: {
+          type: 'integer', minimum: 0,
+          description: 'get_report **머리줄**의 body_rev=N(받은 판) — 시험 실행이 알려 주는 「지금 판」이 아니다. 주면 받은 뒤 본문 판이 바뀌었을 때(다른 교체·편집기 발행·그림이 앉아 다시 구운 것) '
+            + '서버가 409 로 멈추고 아무것도 안 쓴다. 안 주면 지금처럼 덮는다. 교체 응답이 새 판을 알려 주니 연속 교체에는 그 값을 싣는다.',
+        },
         data: REPORT_DATA,
       },
       required: ['tenant', 'id', 'data'],
@@ -6323,8 +6431,8 @@ const TOOLS = [
   {
     name: 'push_session',
     description:
-      '이 기계의 대화 하나를 **검열해서** 서버에 올린다. 다른 기계가 pull_session 으로 받아 ' +
-      '`claude --resume <uuid>` 로 이어 갈 수 있다.\n' +
+      '이 기계의 대화 하나를 **검열해서** 서버에 올린다. Native Codex 원본도 지원하며 source client를 보존한다. ' +
+      '다른 기계는 resume_session으로 작업 맥락을 읽는다. Claude 원본은 pull_session 뒤 claude --resume으로 열 수 있다.\n' +
       '올라가지 않는 것: 도구 실행 결과·첨부·파일 이력·집 경로·비밀 모양(토큰·비밀번호·개인키). ' +
       '**도구 호출의 짝과 인자는 남는다** — 그게 없으면 대화가 안 열린다.\n' +
       '긴 대화는 **알아서 조각으로** 나눠 보내고 서버가 잇는다 — 크기 때문에 사람이 할 일은 없다.\n' +
@@ -6762,7 +6870,9 @@ function tenantNoticeText(v) {
       const who = v.confirmed_by ? `${v.confirmed_by}${josaIGa(v.confirmed_by)} ` : '';
       return `genetics: 이 세션은 ${T} 소속으로 확정된 폴더(${v.path} · ${who}${String(v.confirmed_at || '').slice(0, 10)} 확정, 자동 올리기 켬)에서 `
         + '돌고 있어, 이 대화가 서버에 자동으로 올라간다. 도구 실행 결과·첨부·파일 이력은 빠지고 비밀 모양은 가려지지만, '
-        + `**주고받은 글과 생각(thinking), 도구 호출 인자는 그대로** ${T} 운영진에게 보인다. `
+        + (v.source_client === 'codex'
+          ? `**주고받은 글과 도구 호출 인자**는 ${T} 운영진에게 보인다. 내부 추론은 제외한다. `
+          : `**주고받은 글과 생각(thinking), 도구 호출 인자는 그대로** ${T} 운영진에게 보인다. `)
         + '끄는 길 — 포털 「폴더」에서 자동 올리기 끄기(서버가 강제), 이 폴더의 .genetics-private 파일 또는 '
         + 'GENETICS_NO_AUTO_PUSH=1(이 기계의 클라이언트 약속), 이 대화만 빼려면 no_auto_push. '
         + '이미 올라간 것은 꺼도 안 사라진다 — 포털 「폴더」에서 지운다.';
@@ -6836,7 +6946,8 @@ function tenantNoticeView() {
   const e = v.entry || {};
   const row = indexRead()[mine];
   const says = resolveSessionSays(it.session);     // 그 uuid 에 대한 서버의 사실(N10) — bound 갈래가 읽는다
-  const base = { state: it.state, tenant: e.tenant, path: v.fo.path, confirmed_by: e.confirmed_by,
+  const base = { state: it.state, tenant: e.tenant, path: v.fo.path,
+                 source_client: mine && mine === codexSessionId() ? 'codex' : '', confirmed_by: e.confirmed_by,
                  confirmed_at: e.confirmed_at, auto_upload: e.auto_upload };
   switch (it.state) {
     case 'bound':
@@ -7016,6 +7127,7 @@ function notifyToolsChanged(sendFn) {
 }
 
 function toolsNow() {
+  if (sessionToolMode()) return TOOLS.filter(t => ['whoami', 'list_sessions', 'push_session'].includes(t.name));
   const facts = worldFacts(3);
   if (!facts || !facts.length) return TOOLS;           // 조용한 구간은 조용하다
   const head = `\n\n지금 이 저장소:\n${facts.map((f) => `  · ${f}`).join('\n')}`;
@@ -7208,7 +7320,7 @@ async function mailRegister(tenant, mine, force = false) {
     session: mine,
     name: name || '',
     // 신원이 어디서 왔는지 그대로 말한다 — Cursor 대화에 claude-code 이름표를 달지 않는다.
-    client: mine === cursorActiveComposer() ? 'cursor' : 'claude-code',
+    client: mine === codexSessionId() ? 'codex' : (mine === cursorActiveComposer() ? 'cursor' : 'claude-code'),
     cwd: relHome(process.cwd()),
   });
 }
@@ -7227,8 +7339,8 @@ async function mailPull() {
   if (Date.now() - mailAt < MAIL_POLL_MS) return;
   mailAt = Date.now();
 
-  for (const [tenant] of tenants) {
-    try { await mailPullOne(tenant, mine, tenant === indexTenant ? indexEntry : null); }
+  for (const [tenant, tenantId] of tenants) {
+    try { await mailPullOne(tenant, mine, tenant === indexTenant ? indexEntry : null, tenantId); }
     catch { /* 한 소속처가 막혀도 나머지는 돈다 — 다음 바퀴에 다시 */ }
   }
 
@@ -7255,8 +7367,175 @@ async function mailPull() {
   }
 }
 
+/* Native Codex shares this exact journal/lease with cell/src/codex_mail.rs.
+ * No live writer is stolen by age. Interrupted reaper/malformed owner fails closed.
+ * Claude/Cursor retain their existing mailbox contract below. */
+const CODEX_MAIL_STATE_MAX = 524288;
+const CODEX_MAIL_SAYS_MAX = 65536;
+function codexMailPrivate(file, directory = false) {
+  try {
+    const st = fs.lstatSync(file);
+    return !st.isSymbolicLink() && (directory ? st.isDirectory() : st.isFile())
+      && (st.mode & 0o077) === 0 && (!process.getuid || st.uid === process.getuid());
+  } catch { return false; }
+}
+function codexMailExists(file) {
+  try { fs.lstatSync(file); return true; } catch (e) { if (e.code === 'ENOENT') return false; throw e; }
+}
+function codexMailRead(file, max = CODEX_MAIL_STATE_MAX) {
+  if (!codexMailPrivate(file)) throw new Error('mail_state');
+  const fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+  try {
+    const st = fs.fstatSync(fd);
+    if (!st.isFile() || (st.mode & 0o077) || (process.getuid && st.uid !== process.getuid()) || st.size > max) throw new Error('mail_state_bound');
+    const raw = Buffer.alloc(max + 1); let offset = 0;
+    for (let chunks = 0; chunks <= max + 1; chunks++) {
+      const n = fs.readSync(fd, raw, offset, raw.length - offset, null);
+      if (!n) return new TextDecoder('utf-8', {fatal:true}).decode(raw.subarray(0,offset));
+      offset += n;
+      if (offset > max) throw new Error('mail_state_bound');
+    }
+    throw new Error('mail_state_bound');
+  } finally { fs.closeSync(fd); }
+}
+function codexMailKeys(v, keys) {
+  return v && typeof v === 'object' && !Array.isArray(v)
+    && Object.keys(v).length === keys.length && keys.every(k => Object.hasOwn(v, k));
+}
+function codexMailPending(v) {
+  return v === null || (codexMailKeys(v, ['ids','says']) && Array.isArray(v.ids)
+    && v.ids.length > 0 && v.ids.length <= 20 && new Set(v.ids).size === v.ids.length
+    && v.ids.every(n => Number.isSafeInteger(n) && n > 0)
+    && typeof v.says === 'string' && v.says.length > 0 && Buffer.byteLength(v.says) <= CODEX_MAIL_SAYS_MAX);
+}
+function codexMailAtomic(file, text) {
+  const raw = Buffer.from(text), temp = `${file}.tmp-${process.pid}-${crypto.randomBytes(16).toString('hex')}`;
+  if (raw.length > CODEX_MAIL_STATE_MAX) throw new Error('mail_state_bound');
+  let fd = null;
+  try {
+    fd = fs.openSync(temp,'wx',0o600); fs.fchmodSync(fd,0o600);
+    let offset = 0;
+    for (let writes = 0; offset < raw.length; writes++) {
+      if (writes >= raw.length) throw new Error('mail_write_bound');
+      const n = fs.writeSync(fd,raw,offset,raw.length-offset,null);
+      if (!Number.isInteger(n) || n < 1 || n > raw.length-offset) throw new Error('mail_write');
+      offset += n;
+    }
+    fs.fsyncSync(fd); fs.closeSync(fd); fd = null; fs.renameSync(temp,file);
+  } finally {
+    if (fd !== null) fs.closeSync(fd);
+    try { fs.unlinkSync(temp); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+  }
+}
+function codexMailStore(file, value) {
+  const unlock = codexMailLease(path.join(path.dirname(file), '.inventory'));
+  if (!unlock) throw new Error('mail_inventory_busy');
+  try {
+  const raw = JSON.stringify(value);
+  codexMailInventory(path.dirname(file), Buffer.byteLength(raw), file);
+  if (Buffer.byteLength(raw) > CODEX_MAIL_STATE_MAX || (codexMailExists(file) && !codexMailPrivate(file))) throw new Error('mail_state');
+  codexMailAtomic(file, raw);
+  const fd = fs.openSync(path.dirname(file), 'r');
+  try { fs.fsyncSync(fd); } finally { fs.closeSync(fd); }
+  } finally { unlock(); }
+}
+function codexMailInventory(dir, incoming, target) {
+  const scan = fs.opendirSync(dir); let entries = 0, journals = 0, bytes = 0;
+  try {
+    for (;;) {
+      const next = scan.readSync(); if (!next) break;
+      if (++entries >= 510) throw new Error('mail_inventory_bound');
+      const file = path.join(dir,next.name);
+      if (!codexMailPrivate(file)) throw new Error('mail_inventory');
+      bytes += fs.lstatSync(file).size;
+      if (bytes > 16777216) throw new Error('mail_inventory_bound');
+      if (next.name.startsWith('v1-') && next.name.endsWith('.json')) journals++;
+    }
+    if (journals > 128 || (!codexMailExists(target) && journals >= 128) || bytes + incoming > 16777216) throw new Error('mail_inventory_bound');
+  } finally { scan.closeSync(); }
+}
+function codexMailLease(file) {
+  const lock = file + '.lock', reap = lock + '.reap';
+  const token = JSON.stringify({version:1,pid:process.pid,host:os.hostname(),nonce:crypto.randomBytes(16).toString('hex')});
+  const create = name => { const fd = fs.openSync(name, 'wx', 0o600); try { fs.fchmodSync(fd, 0o600); fs.writeFileSync(fd, token); fs.fsyncSync(fd); } finally { fs.closeSync(fd); } };
+  try { create(lock); } catch (e) {
+    if (e.code !== 'EEXIST') return null;
+    try { create(reap); } catch { return null; }
+    try {
+      const owner = JSON.parse(codexMailRead(lock, 1024));
+      if (!codexMailKeys(owner, ['version','pid','host','nonce']) || owner.version !== 1
+        || owner.host !== os.hostname() || typeof owner.nonce !== 'string' || !owner.nonce || Buffer.byteLength(owner.nonce) > 128 || !Number.isSafeInteger(owner.pid) || owner.pid < 1 || owner.pid > 2147483647) return null;
+      try { process.kill(owner.pid, 0); return null; } catch (dead) { if (dead.code !== 'ESRCH') return null; }
+      fs.unlinkSync(lock); create(lock);
+    } catch { return null; } finally { try { fs.unlinkSync(reap); } catch {} }
+  }
+  return () => { try { if (codexMailRead(lock, 1024) === token) fs.unlinkSync(lock); } catch {} };
+}
+async function codexMailApi(method, pathname, body, cred, deadline) {
+  const remaining = Math.ceil(deadline - performance.now());
+  if (remaining <= 0 || !hostAllowed(BASE)) throw new Error('mail_deadline');
+  const response = await fetch(BASE.replace(/\/+$/, '') + pathname, {method, headers:{Authorization:`Bearer ${cred.token}`,'Content-Type':'application/json'},
+    body:body === undefined ? undefined : JSON.stringify(body), signal:AbortSignal.timeout(remaining)});
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error('mail_response');
+  const raw = Buffer.alloc(262144); let bytes = 0, chunks = 0;
+  try {
+    for (;;) {
+      if (++chunks > 8192 || performance.now() >= deadline) throw new Error('mail_response_bound');
+      const {value,done} = await reader.read(); if (done) break;
+      if (bytes + value.byteLength > raw.length) throw new Error('mail_response_bound');
+      raw.set(value,bytes); bytes += value.byteLength;
+    }
+  } finally { await reader.cancel().catch(() => {}); }
+  if (performance.now() > deadline) throw new Error('mail_deadline');
+  const result = JSON.parse(new TextDecoder('utf-8', {fatal:true}).decode(raw.subarray(0,bytes)));
+  if (!response.ok || result?.ok !== true) throw new Error('mail_refused');
+  return result;
+}
+async function codexMailPullOne(tenant, mine, tenantId) {
+  if (!Number.isSafeInteger(tenantId) || tenantId < 1 || tenantId > 4294967295) return;
+  const cred = credential(); if (!cred || cred.kind !== 'user') return;
+  const dir = path.join(path.dirname(CRED_FILE), 'mail-receive');
+  try { fs.mkdirSync(dir, {mode:0o700}); } catch (e) { if (e.code !== 'EEXIST') throw e; }
+  if (!codexMailPrivate(dir,true)) throw new Error('mail_directory');
+  const tokenHash = crypto.createHash('sha256').update(cred.token).digest('hex');
+  const key = crypto.createHash('sha256').update(`${BASE.replace(/\/+$/, '')}\0${tenantId}\0${mine}\0${tokenHash}`).digest('hex');
+  const file = path.join(dir, `v1-${key}.json`);
+  const admission = codexMailLease(path.join(dir, '.inventory')); if (!admission) return;
+  let unlock;
+  try { codexMailInventory(dir, 0, file); unlock = codexMailLease(file); } finally { admission(); }
+  if (!unlock) return;
+  try {
+    let state = {version:1,last_checked_ms:0,pending:null};
+    if (codexMailExists(file)) state = JSON.parse(codexMailRead(file));
+    if (!codexMailKeys(state,['version','last_checked_ms','pending']) || state.version !== 1
+      || !Number.isSafeInteger(state.last_checked_ms) || state.last_checked_ms < 0 || state.last_checked_ms > Date.now()
+      || !codexMailPending(state.pending)) throw new Error('mail_state');
+    if (!state.pending && Date.now() - state.last_checked_ms < 8000) return;
+    const deadline = performance.now() + 3000;
+    // Successful server registration is required; no caller-provided sender label.
+    const registered = await codexMailApi('POST','/api/mail/register',{tenant,session:mine,name:'',client:'codex',cwd:relHome(process.cwd())},cred,deadline);
+    if (registered.tenant_id !== tenantId || registered.session !== mine) throw new Error('mail_registration_changed');
+    if (!state.pending) {
+      const r = await codexMailApi('GET','/api/mail?tenant='+encodeURIComponent(tenant)+'&session='+encodeURIComponent(mine)+'&limit=20',undefined,cred,deadline);
+      if (!Array.isArray(r.mail)) throw new Error('mail_response');
+      const batch = r.mail.length ? {ids:r.mail.map(m => m.id),says:r.says} : null;
+      if (!codexMailPending(batch)) throw new Error('mail_response');
+      mailCollectReturned(r);
+      state.last_checked_ms = Date.now(); state.pending = batch; codexMailStore(file,state);
+    }
+    if (!state.pending) return;
+    const ack = await codexMailApi('POST','/api/mail/ack',{tenant,ids:state.pending.ids},cred,deadline);
+    if (ack.asked !== state.pending.ids.length || !Number.isSafeInteger(ack.stamped) || ack.stamped < 0 || ack.stamped > ack.asked) throw new Error('mail_ack');
+    const says = state.pending.says;
+    state.pending = null; codexMailStore(file,state);
+    mailQueue.push(says); // Never fabricate provenance; preserve server-rendered wording.
+  } finally { unlock(); }
+}
+
 /** 한 소속처의 내 편지함을 긷고 **받았다고 도장을 찍는다**(도장은 큐에 넣기 **전에** — 재점화 방지). */
-async function mailPullOne(tenant, mine, indexEntry) {
+async function mailPullOne(tenant, mine, indexEntry, tenantId = 0) {
+  if (process.platform !== 'win32' && !process.env.CLAUDE_CODE_SESSION_ID && mine === codexSessionId()) return await codexMailPullOne(tenant, mine, tenantId || Number(indexEntry?.tenant_id));
   try { await mailRegister(tenant, mine); } catch { /* 등록 실패가 받기를 막지 않는다 */ }
 
   if (!mailCursors.has(tenant)) mailCursors.set(tenant, Number(indexEntry?.mail_cursor || 0));
@@ -7295,6 +7574,10 @@ async function mailPullOne(tenant, mine, indexEntry) {
     if (typeof r?.says === 'string' && r.says) mailQueue.push(r.says);
   }
 
+  mailCollectReturned(r);
+}
+
+function mailCollectReturned(r) {
   for (const b of (Array.isArray(r?.returned) ? r.returned : [])) {
     const id = Number(b?.id) || 0;
     if (!id || mailBackSeen.has(id)) continue;   // 서버가 1시간 동안 되풀이해 준다 — 접는 것은 우리 몫
@@ -7818,7 +8101,7 @@ async function callTool(name, args = {}) {
         const owner = r.body_owner === 'html' ? '발행물(HTML)' : 'JSON';
         head.push(`[정본 ${owner} · 본문 판 body_rev=${r.body_rev ?? '?'}`
           + (r.sha256 ? ` · 지금 발행물 ${r.bytes}B sha256:${String(r.sha256).slice(0, 12)}…` : '')
-          + `] — 고칠 때는 update_report 에 body_rev 를 함께 실으면, 그 사이 누가 고쳤을 때 409 로 멈춘다.`);
+          + `] — 고칠 때는 update_report 에 이 body_rev 를 함께 실으면, 받은 뒤 본문 판이 바뀌었을 때(다른 교체·편집기 발행·그림이 앉아 다시 구운 것) 409 로 멈춘다.`);
         // 열린 검토 회신 — 고치기 전에 읽어야 한다(판단 항목의 답이 거기 있다). 첫 줄 가까이에 둔다.
         if (Number.isInteger(r.open_replies) && r.open_replies > 0) {
           head.push(`검토 회신 ${r.open_replies}건이 열려 있다 — 고치기 전에 list_notes(id: ${Number(args.id)}) 로 본문을 읽는다.`);
@@ -7827,12 +8110,19 @@ async function callTool(name, args = {}) {
           const kept = Array.isArray(r.data?.assets)
             ? r.data.assets.filter((a) => typeof a?.data === 'string' && a.data.startsWith('(생략')).length : 0;
           if (kept > 0) {
-            head.push(`그림 ${kept}장은 서버가 보관 중 — update_report 에 assets 를 **빼고** 보내면 그대로 유지, `
+            head.push(`그림 ${kept}장은 서버가 보관 중 — update_report 에 assets 를 **빼고** 보내면 그대로 유지(캡션·출처 줄·alt 도 저장값 — 글 칸을 고쳤으면 표식째 목록으로), `
               + '전부 지우려면 `assets: []`(sections[].plates·chapters[].asset 에서도 빼야 한다), 바꿀 장만 새 source/file 로.');
           }
         // 데이터가 없으면 서버가 outline 을 함께 준다 — 그것이 지금 고객이 보는 것의 유일한 요약이다.
         if (r.data === null && r.outline) head.push(outlineText(r.outline));
-        return `${head.join('\n')}\n${JSON.stringify(r.data, null, 2)}`;
+        // 원고에 남은 판 메아리는 떼고 준다 — 옛 클라이언트가 몸통에 실어 보낸 `body_rev` 가 저장본에 남은 문서가 있다(실측 #31: 머리줄 74 ·
+        // 원고 안 67). 그 칸을 「받은 판」으로 읽으면 아무도 안 고쳤는데 409 가 되풀이된다. 받은 판은 위 머리줄의 값 하나다(2026-09-30 검토).
+        let data = r.data;
+        if (data && typeof data === 'object' && !Array.isArray(data) && 'body_rev' in data) {
+          data = { ...data };
+          delete data.body_rev;
+        }
+        return `${head.join('\n')}\n${JSON.stringify(data, null, 2)}`;
       }
       // 구조만 본다 — 데이터는 이미 다른 호출로 받을 수 있고, 둘을 같이 실으면
       // 문맥이 두 배가 된다. (같은 말을 데이터 없는 문서에도 쓰므로 함수로 뺐다.)
@@ -7926,6 +8216,7 @@ async function callTool(name, args = {}) {
       // 여기서 뒤집는다 — 확인 전에 고객이 먼저 보는 일을 막는 것은 도구의 몫이다.
       const publish = args.publish === true;
       const body = { ...data, tenant: args.tenant, slug: args.slug, publish };
+      delete body.body_rev;   // 본문 판은 서버가 센다 — 다른 문서를 되읽은 원고로 새로 발행할 때 섞여 온 값이 새 문서의 원고에 메아리로 남지 않게(update_report 와 같다)
       if (args.published_at) body.published_at = args.published_at;
       if (args.dry_run) body.dry_run = true;
       const r = await api('POST', '/api/reports', body, PUBLISH);
@@ -7967,6 +8258,12 @@ async function callTool(name, args = {}) {
       return `${r.note}\n${lines.join('\n')}`;
     }
     case 'update_report': {
+      // (2026-09-30) 받은 판 잠금 — 판은 몸통이 아니라 질의(?body_rev=)로 보낸다: 몸통은 통째로 원고(source_json)가 되어
+      // 판이 메아리로 저장되고, 그 원고를 되받아 보내는 쪽이 거짓 409 를 맞는다(서버 api.php PUT 머리말). 값은 그림을 올리기 전에 잰다.
+      const baseRev = args.body_rev;
+      if (baseRev !== undefined && baseRev !== null && !(Number.isInteger(baseRev) && baseRev >= 0)) {
+        throw new Error('body_rev 는 get_report 머리줄의 body_rev=N 값(0 이상의 정수)이어야 합니다.');
+      }
       const data = await materializeAssets(args.data, args.tenant);
       const payload = { ...data, tenant: args.tenant };
       // 노출 손잡이는 떼고 보낸다(2026-09-14). get_report 가 돌려주는 data 에는 발행 때 보낸 몸통이
@@ -7974,6 +8271,7 @@ async function callTool(name, args = {}) {
       // 서버의 `publish: true` 손잡이를 당기면 초안이 열린다. 여는 동사는 release_report 하나다.
       delete payload.publish;
       delete payload.published_at;
+      delete payload.body_rev;   // 몸통의 판은 서버가 안 읽는다 — 섞여 오면 떼고 보낸다(원고에 메아리로 남지 않게)
       if (args.dry_run) payload.dry_run = true;
       /*
        * (판 9 · 개인정보 ①) 서버는 읽고 굽는 사이 사람이 공개 상태를 바꿨으면 **아무것도 안 쓰고** 409 를 낸다
@@ -7983,7 +8281,8 @@ async function callTool(name, args = {}) {
        */
       let r;
       try {
-        r = await api('PUT', `/api/reports/${Number(args.id)}`, payload, RELEASE);
+        const q = baseRev !== undefined && baseRev !== null ? `?body_rev=${baseRev}` : '';
+        r = await api('PUT', `/api/reports/${Number(args.id)}${q}`, payload, RELEASE);
       } catch (e) {
         if (Number(e?.status) === 409 && String(e?.code || '') === 'report_publish_changed') {
           // ⚠ **상태 확인까지만 잇는다**(판 9 · 오너가 고른 규약) — 재전송을 권하지 않는다. 지금 몸통은 이미 낡았고,
@@ -7992,18 +8291,32 @@ async function callTool(name, args = {}) {
           //   서버가 모르는 것(어느 id 로 부르나)만 보탠다. 행이 사라진 409(`report_gone`)에는 안 붙인다 — 볼 문서가 없다.
           throw new Error(`${e.message}\n→ get_report(id: ${Number(args.id)})`);
         }
+        // (2026-09-30) 받은 판 잠금 409 — 같은 규약으로 상태 확인 동사만 잇는다. 새로 받은 판에 편집을 다시 얹는 것은 스킬 절차 몫이다.
+        if (Number(e?.status) === 409 && String(e?.code || '') === 'report_body_changed') {
+          throw new Error(`${e.message}\n→ get_report(id: ${Number(args.id)})`);
+        }
         throw e;
       }
       // 고친 직후가 「무엇을 아직 안 고쳤나」를 볼 가장 좋은 순간이다.
       if (!r.dry_run) { notesSeen(Number(args.id), r.open_notes); repliesSeen(Number(args.id), r.open_replies); }
+      // 받은 판을 실었는데 응답에 판이 없으면 그 서버는 잠금을 모른다(잠금을 아는 서버는 교체·시험 실행 응답에 늘 판을 싣는다) —
+      // 판을 견주지 않고 받은 것이다. 「409 로 멈춘다」는 약속이 조용히 빠지지 않게 그 사실을 말한다(2026-09-30 검토).
+      const sentRev = baseRev !== undefined && baseRev !== null;
+      const blind = sentRev && !Number.isInteger(r.body_rev);
       if (r.dry_run) {
-        return `시험 실행 — 아무것도 바꾸지 않았습니다.\n${r.tenant} · 건 ${r.cases}` + pinsText(r) + warnText(r);
+        const now = Number.isInteger(r.body_rev) ? ` · 지금 본문 판 body_rev=${r.body_rev}` : '';
+        return `시험 실행 — 아무것도 바꾸지 않았습니다.\n${r.tenant} · 건 ${r.cases}${now}`
+          + (blind ? '\n⚠ 이 서버는 받은 판 잠금(?body_rev=)을 모릅니다 — 교체해도 판을 견주지 않고 덮습니다.' : '')
+          + pinsText(r) + warnText(r);
       }
       // 상태를 함께 알린다 — 이 문서를 다음에도 API 로 고칠 수 있는지가 여기서 갈린다.
       const st = r.state ? ` [${r.state}]` : '';
       // 서버가 초안이라고 답하면 이 도구의 동사로 다음 할 일을 잇는다(서버 note 는 HTTP 경로로 말한다).
       const open = r.published === false ? ` 이 도구에서는 release_report(id: ${Number(args.id)}) 가 그 일입니다.` : '';
-      return `교체 완료 — ${r.tenant} · 건 ${r.cases}${st}\n열람 주소: ${r.url}\n${r.note || ''}${open}`
+      // 새 판 — 연속 교체의 다음 호출에 body_rev 로 되싣는다(안 알리면 두 번째 교체가 늘 409).
+      const rev = Number.isInteger(r.body_rev) ? ` · 본문 판 body_rev=${r.body_rev}` : '';
+      return `교체 완료 — ${r.tenant} · 건 ${r.cases}${st}${rev}\n열람 주소: ${r.url}\n${r.note || ''}${open}`
+        + (blind ? '\n⚠ 이 서버는 받은 판 잠금(?body_rev=)을 모릅니다 — 받은 뒤 본문이 바뀌었는지 견주지 않고 덮었습니다.' : '')
         + pendingText(r) + pinsText(r) + warnText(r);
     }
     case 'world': {
@@ -8452,7 +8765,7 @@ async function callTool(name, args = {}) {
       }
       return `${r.tenant} — ${count}\n${rows.join('\n')}\n\n`
            + '이어받으려면 `resume_session` — 지금 이 창이 그 대화를 읽고 이어서 일합니다.\n'
-           + '원본 그대로 열려면 `pull_session` 으로 받은 뒤 그 폴더에서 `claude --resume <uuid>`.'
+           + 'Claude 원본 복원은 `pull_session` 뒤 `claude --resume <uuid>`. Native Codex는 업무 맥락만 읽습니다.'
            + (follow.length ? `\n\n${follow.join('\n')}` : '');
     }
     case 'push_session': {
@@ -8492,6 +8805,9 @@ async function callTool(name, args = {}) {
         throw e;
       } finally { fileUnlock(lease); }
       const { r, before, parts, plan, appended } = pushed;
+      const sourceNote = pushed.source ? `\nCodex 원본 ${pushed.source.records}레코드 → ${pushed.source.kept}발화·도구 레코드; `
+        + `이미지 값 ${pushed.source.omitted_images || 0}개·큰 내부/도구 레코드 ${pushed.source.omitted_large || 0}개 생략; `
+        + `미완료 끝줄 ${pushed.source.deferred_bytes}B는 다음 갱신으로 넘겼습니다.` : '';
       // 표시를 **덧붙임 X B / 전체 Y B** 로(§3.4) — 통째로 갔으면 전처럼 「전 → 후」다.
       const cut = plan?.mode === 'APPEND' || plan?.mode === 'ASK'
         ? `덧붙임 ${Number(appended || 0).toLocaleString()}B / 전체 ${r.bytes.toLocaleString()}B`
@@ -8502,7 +8818,7 @@ async function callTool(name, args = {}) {
       const how = parts > 1 ? ` · ${parts}조각으로` : '';
       if (r.dry_run) {
         return `시험 실행 — 아무것도 저장하지 않았습니다.\n`
-             + `${r.tenant} · ${r.lines}줄 · 뺀 레코드 ${r.dropped} · 가린 자리 ${r.redacted} · ${cut}${how}`;
+             + `${r.tenant} · ${r.lines}줄 · 뺀 레코드 ${r.dropped} · 가린 자리 ${r.redacted} · ${cut}${how}` + sourceNote;
       }
       /*
        * ★ **두뇌 큐에 들어갔는지 말한다.** 서버는 `wiki`(queued|not-queued)와 `note` 를
@@ -8517,7 +8833,8 @@ async function callTool(name, args = {}) {
            + `${r.lines}줄 · 뺀 레코드 ${r.dropped}(첨부·파일이력) · 가린 자리 ${r.redacted} · ${cut}${how}\n`
            + (queued ? queued + '\n' : '')
            + bindNote
-           + '다른 기계에서: pull_session 으로 받은 뒤 그 폴더에서 `claude --resume ' + args.uuid + '`';
+           + (pushed.source_client === 'codex' ? '다른 기계에서: resume_session 으로 이 작업 맥락을 읽을 수 있습니다. Codex 원본 복원은 하지 않습니다.'
+             : '다른 기계에서: pull_session 으로 받은 뒤 그 폴더에서 `claude --resume ' + args.uuid + '`') + sourceNote;
     }
     case 'resume_session': {
       /*
@@ -8543,6 +8860,7 @@ async function callTool(name, args = {}) {
       const q = `?tenant=${encodeURIComponent(args.tenant)}`;
       const r = await api('GET',
         `/api/sessions/${encodeURIComponent(args.uuid)}${q}&no_body=1&digest=1&digest_chars=${chars}`);
+      const native = nativeSessionTools(r.tools);
       indexNote(args.uuid, { src: 'resume', tenant: r.tenant || args.tenant, tenant_id: r.tenant_id, head_id: r.head_id, head_ms: r.head_ms, ...(r.tenant_slug ? { tenant_slug: r.tenant_slug } : {}) }, 'rx');
 
       // 원본도 제자리에 놓는다 — **덮지 않는다**(pull_session 과 같은 이유).
@@ -8550,7 +8868,9 @@ async function callTool(name, args = {}) {
       const dir = transcriptDir(into);
       const target = path.join(dir, `${args.uuid}.jsonl`);
       let placed = target;
-      if (fs.existsSync(target)) {
+      if (native) {
+        placed = 'Codex 업무 맥락만 읽었습니다 — 원본 전사 파일을 만들지 않았습니다';
+      } else if (fs.existsSync(target)) {
         placed = `${target} (이미 있어 그대로 두었습니다 — 덮으면 이 기계에서 하던 대화가 사라집니다)`;
       } else {
         await apiToFile(`/api/sessions/${encodeURIComponent(args.uuid)}${q}&raw=1`, target);
@@ -8563,7 +8883,7 @@ async function callTool(name, args = {}) {
        * 최대 20초 동안 다른 사람 화면에는 이 기계가 안 보인다 — 이어받은 직후가 바로
        * 「누가 잡았나」를 알아야 하는 순간이라 여기서 한 번 즉시 뛴다.
        */
-      beatTick().catch(() => {});
+      if (!native) beatTick().catch(() => {});
 
       // **받기 전에 알아야 할 것을 먼저 쓴다.** 요지 뒤에 붙이면 긴 글에 묻힌다.
       const others = (r.devices || []).filter((d) => d.device !== deviceId());
@@ -8582,7 +8902,7 @@ async function callTool(name, args = {}) {
 
       return `이어받았습니다 — ${r.tenant} · ${args.uuid.slice(0, 8)} · ${r.turns || 0}턴 · ${trimmed}\n`
            + `원본을 놓은 자리: ${placed}\n`
-           + `원본 그대로 열려면: cd ${into} && claude --resume ${args.uuid}\n`
+           + (native ? 'Native Codex 원본 복원은 지원하지 않습니다. 아래 맥락으로 이어서 작업합니다.\n' : `원본 그대로 열려면: cd ${into} && claude --resume ${args.uuid}\n`)
            + (r.redacted ? `※ 가린 자리 ${r.redacted}곳 — 도구 실행 결과는 안 실려 옵니다. 필요하면 다시 실행하세요.\n` : '')
            + warn
            + '\n다음에 할 일: 아래 대화를 읽고, 사용자에게 「어디까지 되어 있고 다음이 무엇인지」를 '
@@ -8601,6 +8921,8 @@ async function callTool(name, args = {}) {
       if (fs.existsSync(target)) {
         throw new Error(`이미 있습니다: ${target}\n덮지 않았습니다 — 이 기계에서 하던 대화가 사라집니다.`);
       }
+      const meta = await api('GET', `/api/sessions/${encodeURIComponent(args.uuid)}?tenant=${encodeURIComponent(args.tenant)}&no_body=1`);
+      if (nativeSessionTools(meta.tools)) throw new Error('Native Codex는 portal 업무 맥락 투영입니다. resume_session으로 읽으세요 — Claude/native 원본 파일은 만들지 않습니다.');
       // 봉투를 안 만든다 — 메타는 헤더로 온다(apiToFile 주석).
       const { headers, bytes } = await apiToFile(
         `/api/sessions/${encodeURIComponent(args.uuid)}?tenant=${encodeURIComponent(args.tenant)}&raw=1`,
@@ -8618,14 +8940,16 @@ async function callTool(name, args = {}) {
       const mine = mySessionId();
       if (!mine) {
         return '이 세션의 번호를 모른다 — 주소를 댈 수 없어 보낼 수 없다'
-             + '(CLAUDE_CODE_SESSION_ID 도, Cursor 활성 대화도 없는 환경이다).';
+             + '(Claude 세션 번호·유효한 Codex 세션 UUID·Cursor 활성 대화가 없는 환경이다).';
       }
       /*
-       * 주소가 없으면 먼저 댄다. **이름이 없으면 서버가 409 로 거절**하므로,
-       * 그 경우를 여기서 미리 사람 말로 바꿔 준다 — 서버 오류문만 보면 무엇을 해야
-       * 하는지 알 수 없다.
+       * Native Codex에는 Claude ListAgents 자기소개가 없다. strict harness UUID로
+       * 주소를 등록하고 서버가 등록된 UUID로 발신 표시를 정한다(mail_store_sender_session).
+       * 이름을 지어내거나 요청 인자의 발신자를 쓰지 않는다. Claude·미지 클라이언트의
+       * 기존 이름 가드는 유지하고, 등록 거절은 아래에서 전송 전에 멈춘다.
        */
-      if (!myAgentName()) {
+      const nativeCodex = !process.env.CLAUDE_CODE_SESSION_ID && mine === codexSessionId();
+      if (!nativeCodex && !myAgentName()) {
         return '이 세션에는 아직 말 걸 수 있는 이름이 없어 **보낼 수가 없다**'
              + '(받는 쪽이 누가 말하는지 못 보면 그것은 메시지가 아니라 주입이다).\n'
              + '이름은 `ListAgents` 를 한 번 부르면 생긴다 — 하네스가 「This session is …」를 '
@@ -8832,12 +9156,22 @@ async function handle(line) {
         result = { tools: toolsNow() };
       } else if (req.method === 'tools/call') {
         lastToolAt = Date.now();                         // 유휴 조절기의 시계(자기 일정 표)
+        const sessionOnly = sessionToolMode();
+        if (sessionOnly && !['whoami', 'list_sessions', 'push_session'].includes(req.params?.name))
+          throw new Error('Session-only client permits whoami, list_sessions, and explicit push_session only');
+        if (SESSION_WATCH_UUID && req.params?.name === 'push_session' && !sessionScope(req.params?.arguments?.uuid))
+          throw new Error('Session watch permits writes to its explicitly selected UUID only');
         // 도구응답 레인의 긷기 — **기다리지 않는다**(도구 지연은 그대로). 60초 상한은 mailPull 안의 mailAt 검사.
         // 도구가 망을 도는 동안 도착한 통은 이번 응답 꼬리에, 아니면 다음 응답에 실린다.
-        if (hookLane() && mailPollReady()) mailPull().catch(() => {});
+        if (!sessionOnly && hookLane() && mailPollReady()) mailPull().catch(() => {});
         const text = await callTool(req.params?.name, req.params?.arguments || {});
         result = { content: [{ type: 'text', text }] };
-        worldAppend(result);
+        if (!sessionOnly) worldAppend(result);
+        else if (SESSION_WATCH_UUID) {
+          // Publishing still requires the existing visible folder consent notice.
+          const notice = tenantNotice();
+          if (notice) result.content.push({ type: 'text', text: notice });
+        }
       } else if (isNotification) {
         return;
       } else {
@@ -8851,7 +9185,7 @@ async function handle(line) {
       // 그래야 에이전트가 메시지를 읽고 고쳐서 다시 시도한다.
       if (req.method === 'tools/call') {
         const failed = { content: [{ type: 'text', text: `실패: ${e.message}` }], isError: true };
-        worldAppend(failed);   // 실패한 턴에도 세계는 움직인다.
+        if (!sessionToolMode()) worldAppend(failed);   // 실패한 턴에도 세계는 움직인다.
         send({ jsonrpc: '2.0', id: req.id, result: failed });
       } else {
         send({ jsonrpc: '2.0', id: req.id, error: { code: -32603, message: String(e.message || e) } });
@@ -9369,6 +9703,7 @@ const SCHEDULE = [
 function startSchedule() {
   if (cfg.GENETICS_NO_BEAT) return;          // 심박을 끄는 사람은 나머지도 안 원한다
   for (const row of SCHEDULE) {
+    if (SESSION_WATCH_UUID && row.name !== 'beat') continue;
     if (row.start) { row.start(); continue; }
     if (row.ready && !row.ready()) continue;
     const run = () => {
@@ -9385,17 +9720,19 @@ function startSchedule() {
 }
 
 if (IS_MAIN) {
-  ensureCellOnBoot();   // 세포가 먼저다 — 스킬보다 이쪽이 「무엇을 못 하는가」를 정한다
-  ensureSkillOnBoot();
+  if (!sessionToolMode()) {
+    ensureCellOnBoot();   // 세포가 먼저다 — 스킬보다 이쪽이 「무엇을 못 하는가」를 정한다
+    ensureSkillOnBoot();
+  }
   /*
    * **뜰 때 심박을 시작한다.** 이 프로세스가 사는 동안이 곧 「이 기계가 이 창을 열고 있는
    * 동안」이라, 시작·끝을 따로 알릴 필요가 없다. 자격이나 주소가 없으면 조용히 안 뛴다 —
    * 꺼진 것이지 고장이 아니다(그림 자격이 없을 때와 같은 태도).
    */
-  startSchedule();
+  if (cfg.GENETICS_SESSION_ONLY !== '1') startSchedule();
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', (chunk) => { buf += chunk; pump(); });
-  process.stdin.on('end', () => { pump(true); stopBeat().catch(() => {}); });
+  process.stdin.on('end', () => { pump(true); if (cfg.GENETICS_SESSION_ONLY !== '1') stopBeat().catch(() => {}); });
   // 창을 닫으면 목록에서 **즉시** 빠진다. 못 알려도 90초 뒤 서버가 스스로 지운다.
   /*
    * ★ **SIGHUP 이 빠져 있었다.** 사람이 「대화창을 닫는다」고 할 때 실제로 오는 신호가 그것인데
@@ -9406,7 +9743,7 @@ if (IS_MAIN) {
    * 「창 닫기」만은 이 한 줄로 잡힌다.
    */
   for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
-    process.on(sig, () => { stopBeat().finally(() => process.exit(0)); });
+    process.on(sig, () => { if (cfg.GENETICS_SESSION_ONLY === '1') process.exit(0); else stopBeat().finally(() => process.exit(0)); });
   }
 }
 
@@ -9432,6 +9769,7 @@ export { videoThumbs, taskReadTools, taskReadRequest, taskReadResult,
          autoRowOnServer,
          // 2026-09-18 Windows — 남의 규칙(Claude Code 슬러그)·플랫폼 갈래는 시험이 표로 걷는다
          transcriptSlug, transcriptDir, cursorUserRoot, sqliteBin, npxCacheResetHint, cellPlatformSupported,
+         mySessionId, refreshCodexSessions, autoCandidates, autoSyncRound, callTool,
          HOLDS_FILE, UPDATE_BUDGET_MS,
          // DESIGN-session-delta-sync C6 — 규칙판·좌표·기계 키·대응표·머리 끊기·private 판정(시험이 걷는다)
          SCRUB_REV, CWD_HIST_MAX, PUSH_MAC_WIN, pushDir, pushKey, pushKeyId, pushMac, pushCoords,