genetics-mcp 2.25.0 → 2.27.0

package/genetics.mjs

@@ -21,13 +21,15 @@
  * 의존성 0 — MCP 는 stdio 위의 JSON-RPC 2.0 이라 표준 라이브러리로 충분하다.
  */
 
-import { spawn, spawnSync } from 'node:child_process';
+import { execFile, spawn, spawnSync } from 'node:child_process';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 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; }
 
 // **기본 주소를 두지 않는다.** 값을 박아 두면 출하물이 "그 서버를 아는 클라이언트" 가 되고,
 // 공개 배포 시 운영 엔드포인트가 그대로 공개된다. 주소는 쓰는 쪽이 정한다.
@@ -1053,7 +1059,8 @@ async function apiOpen(method, pathname, body) {
   }
   const res = await fetch(BASE + pathname, {
     method,
-    headers: { 'Content-Type': 'application/json' },
+    // 판 머리 — api() 와 같은 규율(모든 요청 · 하위 업무 번호 3단계 잣대 ②).
+    headers: { 'X-Genetics-Client': `genetics-mcp/${VERSION}`, 'Content-Type': 'application/json' },
     body: body === undefined ? undefined : JSON.stringify(body),
   });
   const text = await res.text();
@@ -1159,7 +1166,9 @@ async function api(method, pathname, body, opts = {}) {
       res = await fetch(BASE + pathname, {
         method,
         // opts.headers 는 자동 올리기의 머리 셋(§4.3)이 쓴다 — 자격·형식 머리는 덮지 못한다.
-        headers: { ...(opts.headers || {}), Authorization: `Bearer ${c.token}`, 'Content-Type': 'application/json' },
+        // ★ 판 머리(X-Genetics-Client)는 **모든 요청**에 싣는다(하위 업무 번호 DESIGN-item-codes.md · R16 ③) — 서버가 「경로만 아는 판」의
+        //   요청을 판별로 센다(3단계로 넘어가는 잣대 ②). 전에는 자동 올리기 길에만 있었다. 자동 올리기의 같은 값은 그대로 덮어 쓴다.
+        headers: { 'X-Genetics-Client': `genetics-mcp/${VERSION}`, ...(opts.headers || {}), Authorization: `Bearer ${c.token}`, 'Content-Type': 'application/json' },
         body: body === undefined ? undefined : JSON.stringify(body),
         signal,
       });
@@ -1253,7 +1262,8 @@ async function apiToFile(pathname, target, opts = {}) {
       + '주소를 바꾸라는 안내를 받았다면 의심할 것.');
   }
   const res = await fetch(BASE + pathname, {
-    headers: { Authorization: `Bearer ${cred.token}`, Accept: 'application/x-ndjson' },
+    // 판 머리 — api() 와 같은 규율(모든 요청 · 하위 업무 번호 3단계 잣대 ②).
+    headers: { 'X-Genetics-Client': `genetics-mcp/${VERSION}`, Authorization: `Bearer ${cred.token}`, Accept: 'application/x-ndjson' },
   });
   if (!res.ok) {
     // 실패는 작다 — 그때는 봉투를 읽어 서버가 준 말을 그대로 옮긴다.
@@ -1288,22 +1298,357 @@ function limMeta(h) {
 }
 
 // ── 도구 ────────────────────────────────────────────────────────────
-// 이 도구가 발행하는 것은 **"수정 내역 보고" 서식 하나**다(서버의 build.py 가 그것만 안다).
-// 포털 자체는 문서 종류를 가리지 않지만, 데이터로 발행하는 길은 아직 이 서식뿐이다.
+// 데이터로 발행하는 서식은 **하나**다(서버 report_publish.php 의 REPORT_TEMPLATES — 관보 v3 2026-10-07 ⑨) — lim-report(관보).
+// 고객이 고를 결정이 있는 문서는 같은 서식에 결정 블록(`decision_brief.decisions`)을 적는다 — 결정 블록이 있으면 결정 모드, 없으면
+// 보고 모드다(모드는 서버 report_mode · 렌더러 build.py report_mode 가 원고 내용으로 고른다). 옛 이름 lim-decision 은 서버가 lim-report 로 맞춘다.
 //
 // 필수 칸을 세우지 않는 이유: 전에는 표지 4칸과 건마다 6칸이 다 차 있어야 발행이 됐고,
 // 그래서 **초안을 올려 두고 다듬는 일이 아예 불가능했다.** 비어 있는 것은 사람이 정할 일이다.
 // 서버가 여전히 막는 것은 **조용히 사라지는 것**뿐이다 — 모르는 kind 의 절, 없는 그룹의 건.
+// (결정 모드는 하나 더 막는다 — 이대로 그리면 비대칭·헛고리·거짓이 되는 원고. 필수는 결정의 뼈대뿐이다 — 아래 정의가 말한다.)
+
+// ── 원고 칸 정의 시작 — tools/contract-drift.py 가 여기서부터 REPORT_DATA 끝까지 읽는다 ──
+/*
+ * 결정 블록 원고 칸(관보 버전2 2026-10-06 → v3 2026-10-07: 서식 하나 · 결정 블록이 있으면 결정 모드) — 전부 `data.decision_brief`
+ * 하나에 묶는다. 결정 블록을 안 쓰는 세션이
+ * 읽을 몫을 줄이려는 것이다(설계안 7.1·A-10). 칸 설명은 칸마다 「뜻 한 줄 + 빈 값을 쓰는 때」만 둔다 —
+ * 스킬에서 걷어 낸 규칙 글을 여기로 옮겨 오면 도구를 부를 때마다 읽는 글이 그만큼 는다.
+ * 다시 쓰는 꼴은 아래 다섯의 상수로 끼워 넣는다. `$ref`·`$defs` 는 쓰지 않는다 — 도구 스키마는 평평한 JSON 으로
+ * 나가고, 클라이언트마다 다른 `$ref` 해석에 기대지 않는다. 그래서 끼워 넣는 꼴은 **설명 없이 뼈대만** 둔다 —
+ * 빈 값 객체 넷은 한 꼴(`empty` 열거)로 접고, 빈 값의 부속 칸과 주체 꼴의 뜻은 DECISION_BRIEF 설명에 한 번만 적는다.
+ * 끼워 넣는 서른여 자리마다 되풀이되면 도구 목록(발행·교체 두 도구가 같은 객체를 품는다)이 그만큼 커진다.
+ * 부속 칸의 짝(na+why …)은 서버가 잰다(V-EMPTY).
+ */
+const DEC_SENTENCE = {
+  oneOf: [
+    { type: 'string', minLength: 1 },
+    { type: 'object', properties: { empty: { type: 'string', enum: ['na', 'undecided', 'elsewhere', 'unverified'] } }, required: ['empty'] },
+  ],
+};
+const DEC_WHO = {
+  oneOf: [
+    { type: 'string', pattern: '^(customer|fcg|party:[a-z0-9-]{1,32})$' },
+    DEC_SENTENCE.oneOf[1],
+  ],
+};
+/*
+ * 문장 또는 블록 목록(2026-10-08) — now · options[].what · facts_lead · opinion 넷만 쓴다. 문장 칸(글자 · 빈 값)에 더해 블록 1~12개의
+ * 목록을 받는다 — 쓰는 사람이 글 벽 대신 지식의 구조(견주기 · 차례 · 이름→풀이)를 찾아 적게 하려는 것이다. 블록은 키 하나:
+ * p · note(문장 칸) · table{caption?, head[2~5], rows[[칸 × head 수] 1~12]} · steps[{text, who?} 2~12] · items[{k ≤40자, v} 1~12].
+ * 칸의 글은 문장 칸 · who 는 주체 꼴이다. 행의 칸 수 · 그 밖의 키 · 맨 「없음」은 서버가 잰다(report_publish.php report_decision_prose).
+ * description 은 네 칸이 제 뜻 한 줄 뒤에 붙이는 한 문장이다(이 상수만 따로 나가는 자리는 없다 — 고칠 곳은 여기 한 곳).
+ */
+const DEC_PROSE = {
+  description: '구조부터 — 견주기는 table · 차례는 steps · 이름→풀이는 items · 한 줄은 p · 한계는 note(블록 목록 — 블록마다 키 하나).',
+  oneOf: [
+    DEC_SENTENCE.oneOf[0],
+    DEC_SENTENCE.oneOf[1],
+    {
+      type: 'array', minItems: 1, maxItems: 12,
+      items: {
+        type: 'object', minProperties: 1, maxProperties: 1,
+        properties: {
+          p: DEC_SENTENCE,
+          note: DEC_SENTENCE,
+          table: {
+            type: 'object',
+            properties: {
+              caption: { type: 'string', minLength: 1, maxLength: 80 },
+              head: { type: 'array', minItems: 2, maxItems: 5, items: { type: 'string', minLength: 1 } },
+              rows: { type: 'array', minItems: 1, maxItems: 12, items: { type: 'array', minItems: 2, maxItems: 5, items: DEC_SENTENCE } },
+            },
+            required: ['head', 'rows'],
+          },
+          steps: {
+            type: 'array', minItems: 2, maxItems: 12,
+            items: { type: 'object', properties: { text: DEC_SENTENCE, who: DEC_WHO }, required: ['text'] },
+          },
+          items: {
+            type: 'array', minItems: 1, maxItems: 12,
+            items: { type: 'object', properties: { k: { type: 'string', minLength: 1, maxLength: 40 }, v: DEC_SENTENCE }, required: ['k', 'v'] },
+          },
+        },
+      },
+    },
+  ],
+};
+const DEC_DUE = {
+  description: '기한 — date(YYYY-MM-DD) 또는 days_after_release(공개일부터 1~365일) 가운데 꼭 하나와 why(그 까닭 — 선택). '
+    + '기한이 아직 없으면 이 칸을 빈 값으로.',
+  oneOf: [
+    { type: 'object', properties: { date: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$' }, why: DEC_SENTENCE }, required: ['date'] },
+    { type: 'object', properties: { days_after_release: { type: 'integer', minimum: 1, maximum: 365 }, why: DEC_SENTENCE },
+      required: ['days_after_release'] },
+    DEC_SENTENCE.oneOf[1],
+  ],
+};
+const DEC_TEXT_WHO = {
+  oneOf: [
+    { type: 'object', properties: { who: DEC_WHO, text: DEC_SENTENCE }, required: ['who', 'text'] },
+    DEC_SENTENCE.oneOf[1],
+  ],
+};
+const DECISION_BRIEF = {
+  type: 'object',
+  description: '결정 블록 — decisions(정할 것)가 하나 이상이면 문서가 결정 모드로 선다(서식은 lim-report 하나 · template 은 안 적어도 된다). '
+    + '결정이 없으면 이 칸을 빼고 보고로 낸다(decisions 가 빈 decision_brief 는 거절). '
+    + '필수(거절)는 뼈대뿐 — decisions[].name · question · options(둘 이상)[].name · line, 공개 때 reply_to.who. '
+    + '권함(없어도 거절 아님 — 렌더러가 ⚠): due · now · 결정에 닿는 facts · no_reply. 선택(쓰면 서고 안 쓰면 그리지 않음): options[].rows 전부 · cost · '
+    + 'opinion · confirms · risks · unknowns · names 와 그 밖의 칸. 대칭 — 한 선택지에 쓴 행·돈은 모든 선택지가 쓴다. '
+    + '문장 칸은 글자, 또는 비우는 까닭을 밝히는 빈 값 {empty, …}: na+why(해당 없음) · undecided+until(아직 안 정해짐 — 정해지는 때) · '
+    + 'elsewhere+who+when(이 문서에 없음 — 누가 언제 정하나) · unverified+fill(확인하지 못함 — 채울 수단). 「없음」「-」 같은 맨 글자는 거절된다. '
+    + '누가 칸(by·who·payer·to)은 customer(받는 쪽, 화면에는 client) · fcg(보내는 쪽, 화면 말은 labels.dc_who_fcg) · party:<names 의 id>(그 밖의 쪽), 또는 빈 값. '
+    + 'id 는 영소문자·숫자·하이픈 1~32자, 문서 전체가 한 이름 공간이다. 글 안에서 {{결정:id}}·{{선택:id}}·{{사실:id}}·{{확인:id}}·{{위험:id}}·{{이름:id}} 로 다른 물건을 부른다.',
+  properties: {
+    scope: { type: 'string', description: '점검 범위 한 문장 — 무엇을, 어느 계정·환경에서, 언제(선택).' },
+    reply_to: {
+      type: 'object',
+      description: '회신 받는 사람. who 가 비면 공개되지 않는다(초안·dry_run 은 알림만).',
+      properties: { who: { type: 'string' }, contact: { type: 'string' } },
+    },
+    decisions: {
+      type: 'array', minItems: 1,
+      description: '지금 정하실 결정 — 결정마다 한 장으로, 기한 순으로 선다. 하나 이상이면 결정 모드.',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', pattern: '^[a-z0-9-]{1,32}$' },
+          uid: { type: 'string', pattern: '^[a-z0-9]{6}$', description: '서버가 발급하는 불변 이름. get_report 가 준 값은 그대로 되돌려 보낸다.' },
+          name: { type: 'string', description: '짧은 이름 — 첫 화면·장 머리·회신에 같은 글자로 선다.' },
+          question: { ...DEC_SENTENCE, description: '물음 하나(25자 안팎). 원고에 물음이 없으면 빈 값.' },
+          due: { ...DEC_DUE, description: '결정 기한(권함 — 없으면 거절 대신 렌더러가 ⚠). ' + DEC_DUE.description },
+          now: { ...DEC_PROSE, description: '지금 상태 — 대상과 문제를 쉬운 말로(권함). ' + DEC_PROSE.description },
+          figures: {
+            type: 'array',
+            description: '그림 칸 — 「지금 상태」 바로 아래에 서는 이 결정의 그림(선택). 항목마다 diagram(설계 데이터 — Archify IR 객체, '
+              + 'sections[].diagrams[].ir 와 같은 꼴) · chart(차트 한 벌 — sections[].charts[] 와 같은 꼴: 막대 rows 또는 kind:"series"+points, ref·form 포함) · '
+              + 'plate(도판 assets[].id — role figure·video) 가운데 꼭 하나와 caption · source(출처 한 줄). 그 밖의 키는 거절. '
+              + '그림 번호는 문서 전체 한 셈이라 적지 않는다(같은 그림은 같은 번호).',
+            items: {
+              type: 'object',
+              properties: {
+                diagram: { type: 'object', description: '설계 데이터(Archify IR) — 서버가 관보 그림으로 굽는다.' },
+                chart: { type: 'object', description: '차트 한 벌 — 그릴 행(rows)이나 점(points)이 있어야 한다.' },
+                plate: { type: 'string', description: '도판 id(assets[].id).' },
+                caption: { type: 'string', description: '그림 캡션 — 번호 없이.' },
+                source: { type: 'string', description: '출처 한 줄.' },
+              },
+              minProperties: 1,
+            },
+          },
+          settled: {
+            type: 'array',
+            description: '고객이 이미 정하신 것 — 정하신 기록(record, 화면에 안 찍힘)이 있는 것만.',
+            items: { type: 'object', properties: { text: { type: 'string' }, by: DEC_WHO, record: { type: 'string' } }, required: ['text', 'by', 'record'] },
+          },
+          options: {
+            type: 'array', minItems: 2,
+            description: '선택지 — 그대로 두는 길을 포함해 둘 이상(이름과 한 줄 뜻이 필수 · 나머지는 선택).',
+            items: {
+              type: 'object',
+              properties: {
+                id: { type: 'string', pattern: '^[a-z0-9-]{1,32}$' },
+                name: { type: 'string', description: '선택지 이름 — 표 열 머리·첫 화면·회신 말에 같은 글자로.' },
+                line: { ...DEC_SENTENCE, description: '고르면 무엇이 달라지나 한 줄(35자 안팎). 없으면 빈 값.' },
+                what: { ...DEC_PROSE, description: '실제로 하는 일 — 끝나거나 풀리는 조건까지(선택). ' + DEC_PROSE.description },
+                is_current: { type: 'boolean', description: '지금 상태를 지키는 선택지 — 결정마다 많아야 하나, 늘 첫째로 선다.' },
+                rows: {
+                  type: 'object',
+                  description: '대칭 표의 값(선택 — 쓰면 행이 서고 안 쓰면 그 행이 없다). 한 선택지에 쓴 행은 모든 선택지가 문장이나 빈 값으로 채운다. 이 밖의 키는 거절.',
+                  properties: {
+                    for_users: { ...DEC_SENTENCE, description: '이용자가 겪는 일.' },
+                    client_does: { ...DEC_TEXT_WHO, description: '고객 쪽이 하실 일 — 요청 자리, text 는 하십시오체 요청.' },
+                    fcg_does: { ...DEC_SENTENCE, description: '보내는 쪽이 할 일 — 화면 행 이름은 원고 issuer 첫 이름으로 「{발행처} 가 할 일」(labels.dc_row_fcg_does 로 덮음).' },
+                    risk_left: { ...DEC_SENTENCE, description: '남는 위험.' },
+                    settles_today: { ...DEC_SENTENCE, description: '그날 정해지는 것.' },
+                    others_do: { ...DEC_TEXT_WHO, description: '그 밖의 쪽이 할 일.' },
+                  },
+                },
+                cost: {
+                  type: 'object',
+                  description: '돈(선택 — 한 선택지에 쓰면 모든 선택지가) — 금액은 적지 않는다. 쓰면 state: yes(듦)·no(안 듦)·unknown(모름)는 필수, '
+                    + 'known_when(언제 아나)·payer(누가 내나)는 아는 것만.',
+                  properties: {
+                    state: { type: 'string', enum: ['yes', 'no', 'unknown'] },
+                    known_when: DEC_SENTENCE,
+                    payer: DEC_WHO,
+                  },
+                  required: ['state'],
+                },
+                then: {
+                  type: 'array', description: '회신 뒤 일.',
+                  items: { type: 'object', properties: { what: { type: 'string' }, who: DEC_WHO, when: { type: 'string' } }, required: ['what', 'who', 'when'] },
+                },
+                extra_rows: {
+                  type: 'array',
+                  description: '대장 「선택지 전체 비교」에만 서는 잣대 — 한 결정의 모든 선택지가 같은 label 을 갖는다.',
+                  items: { type: 'object', properties: { label: { type: 'string' }, text: DEC_SENTENCE }, required: ['label', 'text'] },
+                },
+              },
+              required: ['id', 'name', 'line'],
+            },
+          },
+          no_current_why: { ...DEC_SENTENCE, description: '그대로 두는 길(is_current)이 선택지에 없을 때 그 까닭.' },
+          no_reply: { ...DEC_SENTENCE, description: '기한까지 회신이 없으면 무엇이 그대로이고 누가 무엇을 하나(권함).' },
+          facts_lead: { ...DEC_PROSE, description: '이 결정에 닿는 사실이 둘 이상이면 — 사실들이 선택지를 어떻게 가르는지 잇는 글. ' + DEC_PROSE.description },
+          reply: {
+            type: 'object',
+            description: '회신에 덧붙일 값 — attach(함께 적어 주실 것) · conditions(조건 안내, 기본 참). {} 도 받는다.',
+            properties: { attach: { type: 'array', items: { type: 'string' } }, conditions: { type: 'boolean' } },
+          },
+          opinion: { ...DEC_PROSE, description: '보내는 쪽 의견 — 판단은 이 칸에만 둔다(선택 — 의견이 없으면 칸을 뺀다). ' + DEC_PROSE.description },
+        },
+        required: ['id', 'name', 'question', 'options'],
+      },
+    },
+    confirms: {
+      type: 'array',
+      description: '확인 요청 — 결정을 바꿀 수 있거나 결정 뒤에 할 확인.',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', pattern: '^[a-z0-9-]{1,32}$' },
+          uid: { type: 'string', pattern: '^[a-z0-9]{6}$', description: '서버가 발급하는 불변 이름. get_report 가 준 값은 그대로 되돌려 보낸다.' },
+          name: { type: 'string', description: '무엇을 확인하나 — 물음 꼴(「…가 되는가」).' },
+          to: { ...DEC_WHO, description: '누구에게 묻나·누가 하나.' },
+          due: DEC_DUE,
+          relation: { type: 'string', enum: ['sways', 'after'], description: 'sways(결과가 결정을 바꿀 수 있음) · after(결정 뒤 이행).' },
+          decisions: { type: 'array', minItems: 1, items: { type: 'string' }, description: '닿는 결정의 id.' },
+          ask: { type: 'string', description: '물으실 말 — 요청 자리, 하십시오체. ask·steps 가운데 하나 이상.' },
+          steps: { type: 'array', minItems: 1, items: { type: 'string' }, description: '하실 일 목록 — 요청 자리, 하십시오체.' },
+          why: { ...DEC_SENTENCE, description: '이 확인이 결정에 무엇을 바꾸나.' },
+        },
+        required: ['id', 'name', 'to', 'due', 'relation', 'decisions'],
+      },
+    },
+    facts: {
+      type: 'array',
+      description: '확인한 사실 — 사실 줄 하나에 근거 하나 이상.',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', pattern: '^[a-z0-9-]{1,32}$' },
+          text: { type: 'string', description: '사실 한 문장 — 방법 서술이 아니다.' },
+          basis: {
+            type: 'string', enum: ['seen', 'counted', 'tested', 'read', 'computed'],
+            description: '근거 종류 — seen(직접 봄) · counted(운영 기록에서 셈) · tested(시험에서 잼) · read(설정·코드를 읽음) · computed(계산).',
+          },
+          where: {
+            type: 'string', enum: ['production', 'replica', 'simulated'],
+            description: 'basis 가 tested 일 때만 — simulated 면 「운영과 같은 조건 아님」이 붙는다.',
+          },
+          source: {
+            type: 'array', minItems: 1,
+            description: '근거 — 항목마다 키 하나: case(건 uid) · plate(도판 id) · quote(원문 한 줄) · url · ledger(대장 「절.문단」) · fact(계산에 쓴 사실 id). '
+              + 'seen 은 plate·url·case, read 는 quote, computed 는 fact 가 하나 이상.',
+            items: {
+              type: 'object', minProperties: 1, maxProperties: 1,
+              properties: {
+                case: { type: 'string' }, plate: { type: 'string' }, quote: { type: 'string' },
+                url: { type: 'string' }, ledger: { type: 'string' }, fact: { type: 'string' },
+              },
+            },
+          },
+          bears_on: {
+            type: 'array', minItems: 1,
+            description: '사실이 서는 자리 — 항목마다 decision(+ 그 결정의 option) · risk · unknown 가운데 하나.',
+            items: {
+              type: 'object',
+              properties: { decision: { type: 'string' }, option: { type: 'string' }, risk: { type: 'string' }, unknown: { type: 'string' } },
+            },
+          },
+        },
+        required: ['id', 'text', 'basis', 'source', 'bears_on'],
+      },
+    },
+    risks: {
+      type: 'array',
+      description: '어느 선택지를 고르든 지금 열려 있는 위험.',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', pattern: '^[a-z0-9-]{1,32}$' },
+          what: { type: 'string' },
+          size: {
+            type: 'object', description: '크기 — text 와 basis(measured 잼 · estimated 가늠).',
+            properties: { text: { type: 'string' }, basis: { type: 'string', enum: ['measured', 'estimated'] } },
+            required: ['text', 'basis'],
+          },
+          blocked_by: {
+            type: 'object',
+            description: '이 위험을 막는 것 — decision(결정 id) · schedule(일정 글) · none:true + note(막을 결정·일정이 없는 까닭) 가운데 꼭 하나.',
+            properties: { decision: { type: 'string' }, schedule: { type: 'string' }, none: { type: 'boolean' }, note: { type: 'string' } },
+          },
+        },
+        required: ['id', 'what', 'blocked_by'],
+      },
+    },
+    unknowns: {
+      type: 'array',
+      description: '확인하지 못한 것.',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', pattern: '^[a-z0-9-]{1,32}$' },
+          what: { type: 'string' },
+          sways: { type: 'array', items: { type: 'string' }, description: '이것이 바꿀 수 있는 결정의 id.' },
+          size: {
+            type: 'object', description: 'risks[].size 와 같은 꼴.',
+            properties: { text: { type: 'string' }, basis: { type: 'string', enum: ['measured', 'estimated'] } },
+            required: ['text', 'basis'],
+          },
+          fill: {
+            description: '채울 수단 — 없으면 {none: true}.',
+            oneOf: [
+              { type: 'string', minLength: 1 },
+              { type: 'object', properties: { none: { type: 'boolean', enum: [true] } }, required: ['none'] },
+            ],
+          },
+        },
+        required: ['id', 'what', 'fill'],
+      },
+    },
+    names: {
+      type: 'array',
+      description: '이 문서에 나오는 낯선 말과 숫자 — 결정 장마다 처음 나오는 자리에 풀이가 선다. 선택지 이름은 두지 않는다.',
+      items: {
+        type: 'object',
+        properties: { id: { type: 'string', pattern: '^[a-z0-9-]{1,32}$' }, name: { type: 'string' }, plain: { type: 'string', description: '쉬운 말 풀이.' } },
+        required: ['id', 'name', 'plain'],
+      },
+    },
+    later: {
+      type: 'array',
+      description: '나중에 정해도 되는 것 — 회신·핀을 받지 않는다.',
+      items: {
+        type: 'object',
+        properties: { question: { type: 'string' }, options: { type: 'array', minItems: 1, items: { type: 'string' } }, revisit: { type: 'string', description: '다시 볼 때.' } },
+        required: ['question', 'options', 'revisit'],
+      },
+    },
+  },
+  required: ['decisions'],
+};
 const REPORT_DATA = {
   type: 'object',
   description: '보고서 내용. 짝인 스킬의 report.json + cases 를 하나로 합친 형태.',
   properties: {
     /*
-     * 서식·팔레트 인자는 **여기 없다.** 서버가 정한다(report_publish.php 의
-     * REPORT_TEMPLATE_DEFAULT, 그리고 서식이 팔레트를 강제하는 결합).
-     * 값이 하나뿐이고 서버가 덮어쓰는 것을 도구 표면에 올려 두면, 부르는 쪽은 고를 수 있다고
-     * 믿는데 실제로는 무시된다 — 거짓말하는 인자다. 고를 것이 생기면 그때 연다.
+     * 서식 칸(2026-10-06 관보 버전2 에 열었다) — 관보 v3(2026-10-07 ⑨)부터 서식은 lim-report 하나이고 모드는 원고 내용
+     * (decision_brief.decisions)이 정한다. 옛 이름 lim-decision 은 그 이름으로 쓴 원고 · 옛 판 도구가 보내도 받히게 enum 에 남긴다 —
+     * 서버가 lim-report 로 맞춘다(REPORT_TEMPLATE_ALIASES). 이름의 정본은 서버 REPORT_TEMPLATES 다.
+     * 팔레트는 여전히 **여기 없다** — 서식이 강제하고 서버가 박는다(report_publish.php 의 REPORT_TEMPLATE_PALETTE).
      */
+    template: {
+      type: 'string', enum: ['lim-report', 'lim-decision'],
+      description: '서식 — lim-report 하나(안 적어도 된다). 결정 블록(decision_brief.decisions)이 있으면 결정 모드, 없으면 보고 모드로 선다. '
+        + 'lim-decision 은 옛 이름 — 서버가 lim-report 로 맞추고, 그 이름으로 왔는데 결정이 없으면 거절한다.',
+    },
+    decision_brief: DECISION_BRIEF,
+    released_on: {
+      type: 'string',
+      description: '서버가 적는 공개일(YYYY-MM-DD, 결정 모드) — 「받으신 날부터 N일」을 날짜로 푸는 값. 보내도 서버가 공개일로 덮는다.',
+    },
     title_tag: { type: 'string', description: '브라우저 탭 제목' },
     title: { type: 'string', description: '표지 대제목 **첫 행** (굵게)' },
     title_sub: {
@@ -1331,7 +1676,7 @@ const REPORT_DATA = {
     cta: {
       type: 'array', items: { type: 'string' },
       description: '`kind:"asks"` 절 머리의 강조문(문자열 목록). 요청 항목들 **위**에 서서 '
-        + '「먼저 볼 것」을 한두 줄로 말한다. 없으면 강조문 없이 항목만 늘어선다.',
+        + '「먼저 볼 것」을 한두 줄로 말한다. 없으면 강조문 없이 항목만 늘어선다. 결정 모드에서는 받지 않는다(거절).',
     },
     description: { type: 'string' },
     doc_no: { type: 'string', description: '문서번호. 표지 머리 왼쪽 박스 (예: "LIM-2026-0824-01")' },
@@ -1351,7 +1696,7 @@ const REPORT_DATA = {
       description: '요약면 수치 칸 [{value, unit, label, accent?, href?, go?}] · accent:true 는 '
                  + '**독자 몫**인 첫 칸. `href` 를 주면 그 칸이 단추가 되고, `go` 는 그 단추의 '
                  + '글자다(생략하면 「해당 절로」). 어디로 가는지를 `go` 에 적어 두면 '
-                 + '독자가 누르기 전에 안다 — 예: "02절로".',
+                 + '독자가 누르기 전에 안다 — 예: "02절로". 결정 모드에서는 받지 않는다(거절).',
     },
     history: {
       type: 'array',
@@ -1361,7 +1706,7 @@ const REPORT_DATA = {
       type: 'array',
       description: '이 문서 읽는 법 [{q, a: [문장, ...]}] — **독자가 실제로 던질 질문**만. '
                  + '「시간이 없다면 어디를 봐야 하는가?」 「어디까지 확인한 것인가?」 처럼. '
-                 + '채우려고 넣으면 안 넣느니만 못하다.',
+                 + '채우려고 넣으면 안 넣느니만 못하다. 결정 모드에서는 받지 않는다(거절).',
     },
     parts: {
       type: 'array',
@@ -1370,12 +1715,19 @@ const REPORT_DATA = {
                  + 'tone 은 you(독자 몫)·neutral(기록)·wait(대기)·hold(유보) 중 하나. '
                  + 'questions 는 「이 PART 가 답하는 질문」. '
                  + '`roman` 은 간지·차례·머리띠에 서는 로마 숫자 — 생략하면 자리 순서대로 '
-                 + 'Ⅰ·Ⅱ·Ⅲ 이 매겨지므로 **보통 적지 않는다**(적으면 순서와 어긋날 수 있다).',
+                 + 'Ⅰ·Ⅱ·Ⅲ 이 매겨지므로 **보통 적지 않는다**(적으면 순서와 어긋날 수 있다). 결정 모드에서는 받지 않는다(거절).',
     },
     notice: {
       type: 'object',
       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: '막대가 뜻하는 바의 한정 조건 (※ 각주)' },
@@ -1409,13 +1761,16 @@ const REPORT_DATA = {
         + '덮을 수 있는 키: apx · as_of · ask · bar_alt · basis · client · col_grade · col_state · '
         + 'col_title · cta · doc_no · go · guide · hist · hist_date · hist_no · hist_note · marg · '
         + 'nograde · open · pt_ask · refs · remain · remain_unit · source · source_row · sum · toc · urgent.\n'
-        + '없는 키를 주면 조용히 무시된다 — 오타가 안 걸리니 위 목록에서 골라 써라.',
+        + '없는 키를 주면 조용히 무시된다 — 오타가 안 걸리니 위 목록에서 골라 써라.\n'
+        + '결정 모드의 고정 문구 키(dc_…)는 skills/genetics-report/references/decision-format.md 의 「바꿀 수 있는 글자」 표.',
     },
     grades: { type: 'object', description: '확인 등급 정의 {이름: [클래스, 설명]}' },
     groups: { type: 'array', description: '건 묶음 [{key, no}]' },
     sections: {
       type: 'array',
-      description: '절 구성 [{no, id, name, kind, group?, chapter?, principles?, logic?}] · kind 는 summary|status|cases|asks|note '
+      description: '절 구성 [{no, id, name, kind, group?, chapter?, principles?, logic?}] — 보고 모드는 절 구성이 본체다. '
+                 + '결정 모드는 대장(근거 자료) 절(kind note·cases)만, 없어도 된다.\n'
+                 + 'kind 는 summary|status|cases|asks|note '
                  + '중 하나여야 한다 — 그 밖의 값은 렌더러가 절을 통째로 빠뜨리므로 서버가 거절한다. '
                  + 'chapter 에 아래 chapters 의 id 를 적으면 그 절 앞에 챕터 오프닝이 펼쳐진다. '
                  + 'name 은 목차에 쓰는 **짧은 이름**이고, 본문의 큰 제목은 챕터의 title_lines 가 낸다.\n'
@@ -1433,7 +1788,13 @@ const REPORT_DATA = {
                  + 'rows[].no 가 `4.1`·`04-1` 모양이면 그 사례로 링크가 된다. '
                  + '그림 번호(`그림 5-1`)는 적지 않는다 — 자리가 매기고 `plates` 와 한 셈을 쓴다.\n'
                  + '· `plates`: [assets[].id, …] — 절 본문 도판.\n'
-                 + '· 시각 우선(dry_run 이 ⚠ 로 센다 — 서식 문서 §10-1): 절마다 표·흐름도·차트·도판 중 하나, 문단 220자 안, 산문의 참조 번호 3개 이하, 판단 요청 6항 이상이면 한눈표+관문 흐름도, 3,000자 넘는 문서엔 핵심 굵게. 집필 공식(독자 한 명·예시 한 명·한 장 이야기·용어 잠금·그림 먼저)은 스킬 references/visual-first.md.\n'
+                 // ── 장치 목록에서 굽는 글 «tool-devices» — 손으로 고치지 않는다: python3 tools/contract-devices.py --write ──
+                 + '· 시각 장치(정본 private/builder/devices.py — 둘 수 있는 칸 · 한도 · 만드는 법은 스킬 references/visual-first.md §4 표): 구조 → 구성도·도판(개념도) · 흐름 → 흐름도·절차도·데이터 흐름도 · 순서 → 순서도 · 상태 → 상태 변화도 · 변화 → 두 판 비교·도판(두 컷 비교) · 분포 → 막대 차트 · 시간에 따른 값 → 시계열 · 견주기 → 표·점 차트 · 원문 → 원문 인용·도판 · 화면 → 도판·화면 녹화. '
+                 + '구성도·절차도·순서도·데이터 흐름도·상태 변화도·두 판 비교는 도해 굽기가 켜진 서버에서만 새로 굽는다(포털 private/archify.on — 로컬 render.py 는 켜고 부른다) — 꺼진 서버는 굽혀 둔 그림만 싣고 새 그림은 같은 번호의 대기 상자로 둔다(「서버에서 실패한 그림이 N장」 — 원고를 고칠 일이 아니다). '
+                 + '화면 녹화는 영상 저장 연동(r2)이 켜진 서버에서만 — 꺼진 환경은 발행을 거절한다. '
+                 + '시각 우선(dry_run 이 ⚠ 로 센다 — 서식 문서 §10-1): 산문 400자 넘는 절에 표·흐름도·차트·원문 인용·도해·도판 가운데 하나도 없으면 ⚠, 문단 220자 안, 산문의 참조 번호 3개 이하, 판단 요청 6항 이상이면 한눈표+관문 흐름도, 3,000자 넘는 문서엔 핵심 굵게. '
+                 + '집필 공식(독자 한 명·예시 한 명·한 장 이야기·용어 잠금·그림 먼저)은 스킬 references/visual-first.md.\n'
+                 // ── /장치 목록 «tool-devices» ──
                  + '· 인라인 표기(본문 문자열 어디서나 — 문단·도입문·여백 주석·표 셀·흐름도 칸·주석·부록 행): `**굵게**` → 핵심 구절, `==강조==` → 놓치면 안 되는 한 구절(노란 밑면), `{{ok|보통}}` → 상태 칩(톤 ok·wait·bad·info·muted 다섯뿐, 글자 40자 안), `[글자](https://…)` → 새 창으로 여는 하이퍼링크, 맨 `https://…` 주소도 그대로 링크가 됨(http(s) 만, 꼬리 문장부호는 링크 밖). 표기가 없으면 한 글자도 안 바뀐다. 핵심 한두 구절에만 — 문단 절반이 굵으면 굵기가 위계를 못 나른다. 출처는 부록 글자에만 두지 말고 건의 `source_url` 에도 실어라(「출처 원문」 행이 된다).\n'
                  + '· `tables`: [{caption, cols[], rows[[]], align?, hint?, note?}] — **관보의 자료표.** '
                  + '여러 항목을 축으로 견주는 자리다. 불릿 목록에 수를 눌러 담고 있으면 그건 표여야 한다. '
@@ -1444,22 +1805,26 @@ const REPORT_DATA = {
                  + '표 번호(`표 5-1`)는 적지 않는다 — 자리가 매긴다. '
                  + '⚠ caption 은 **라벨이지 산문이 아니다** — 20자 안쪽으로 두고 설명은 note 로 내려라 '
                  + '(길면 캡션 바가 글줄 상한을 넘어 두 줄로 접힌다).\n'
-                 + '· `charts`: [{caption, unit?, rows:[{label, value|a+b, note?}], toggle?{a,b}, note?}] — '
-                 + '**분포 막대.** 수를 눈으로 견주게 한다. 열람 CSP 가 `script-src` 를 안 열어 캔버스를 쓸 수 없으므로 '
-                 + 'HTML 막대와 CSS 로 짓는다. 값은 **본문 글자로 남고** 막대는 그 옆에 서므로 막대가 안 보이는 '
-                 + '곳에서도 문서가 성립한다. value 는 **표기 그대로 적는다**(`"118,716"`) — 콤마는 셈에서 걷어내므로 '
-                 + '같은 문서의 표와 표기가 갈리지 않게 하려면 데이터가 표기를 정해야 한다. '
+                 + '· `charts`: [{caption, unit?, rows:[{label, value|a+b, note?, tone?, partial?}], toggle?{a,b}, form?, ref?, note?}] — '
+                 + '**차트(막대 · 점).** 렌더러가 정지 SVG 로 그린다(스크립트 0 — 열람 CSP 가 script-src 를 안 연다). 값 · 이름 · 설명은 원고 글자 그대로 '
+                 + '그림에 서고 화면 낭독 목록으로도 한 번 실린다. value 는 **표기 그대로 적는다**(`"118,716"`) — 같은 문서의 표와 표기가 갈리지 않게 데이터가 표기를 정한다. '
                  + 'rows[].tone(ok·wait·bad·info·muted) 을 주면 그 행의 막대와 값에 뜻 색이 붙는다 — 예: 처리 완료 행은 muted, 위험 행은 bad. '
-                 + 'toggle{a,b} 를 주면 rows 는 value 대신 a·b 를 갖고 두 축을 `:checked` 로 갈아 낀다 '
-                 + '(체크박스는 스크립트가 아니라 상태다). 그림 번호는 `flow`·`plates` 와 **한 셈**을 쓴다.\n'
-                 + '데이터가 있을 때만 그려진다 — 없는 문구를 지어내지 말 것.\n'
-                 + '· `charts[].kind:"series"`: {kind:"series", caption, unit?, points:[{x,y}], marks?:[{x,label}], summary?:[{label,value,note?}], note?} — '
-                 + '**시계열.** 하루·달 단위 값이 언제 계단을 만드는지 인라인 SVG 선으로 보이고, 달마다 평균·최대를 글자 행으로 남긴다(그림이 안 보여도 문서가 선다). '
+                 + 'toggle{a,b} 를 주면 rows 는 value 대신 a·b 를 갖고 두 축을 `:checked` 로 갈아 낀다(두 축이 한 축척 · 체크박스는 스크립트가 아니라 상태다). '
+                 + '그림 번호는 `flow`·`plates` 와 **한 셈**을 쓴다. 데이터가 있을 때만 그려진다 — 없는 문구를 지어내지 말 것.\n'
+                 + '· `charts[].ref`: [{value, label}] — **기준선**(점선). value 는 수(쉼표 표기 글자도 받음), label 은 원고 글자(「3초」「60초 한도」). 막대·시계열 모두. '
+                 + '`charts[].rows[].partial`: 참이면 그 행은 일부만 잰 값이라 막대 속을 비운다(행 이름 글자로 짐작하지 않는다). '
+                 + '`charts[].form`: length(길이 — 0 기준선에서 뻗는 공통 축척 막대) · position(위치 — 같은 축 위의 점) — 없으면 막대는 length · 시계열은 position. '
+                 + '셋 다 꼴이 틀리면 서버가 거절한다.\n'
+                 + '· `charts[].kind:"series"`: {kind:"series", caption, unit?, points:[{x,y}], marks?:[{x,label}], summary?:[{label,value,note?}], form?, ref?, note?} — '
+                 + '**시계열.** 하루·달 단위 값이 언제 계단을 만드는지 정지 SVG 로 보이고(기본은 점과 선 · form length 면 날마다 막대), 달마다 평균·최대를 글자 행으로 남긴다(그림이 안 보여도 문서가 선다). '
                  + 'x 는 YYYY-MM-DD 가 기본. marks[].x 는 어느 points[].x 와 같은 값이어야 선다(사건 세로선, 아니면 ⚠).\n'
                  + '· `quotes`: [{text, lang?, source_text, source_url?, verdict?, translation?}] — **원문 인용.** 공식 문서·회신 문구를 원문 그대로 싣는다(표기 안 품, 줄바꿈 유지). '
                  + 'source_text·source_url 둘 중 하나는 있어야 한다(없으면 ⚠). verdict 는 도판과 같은 축(직접 확인·조사 보고·미확인). 절 본문 맨 앞에 선다.\n'
-                 + '· `diagrams`: [{id?, caption, ir?, svg?, alt?, source_text?, verdict?, note?, wide?, origin?}] — **도해.** 기본은 `ir`: Archify 가 검증한 **workflow IR 그대로**(lanes·phases·nodes·edges·mainPath)를 넣으면 관보가 자기 활자(15px)·장 색으로 그린다. 다른 종류는 `svg`: 스킬 `assets/diagram.mjs` 로 굳힌 SVG 문자열 '
-                 + '(서버가 스크립트·스타일·외부 참조를 다시 걷는다). ir 에서 읽는 칸: diagram_type(workflow) · lanes[].id·label · phases[].label·fromCol·toCol · nodes[].id·lane·col·type·label·sublabel·variant · edges[].from·to·label·variant · mainPath. 그림 번호는 차트·흐름도·도판과 한 셈. 글자가 표시 15px 미만이면 ⚠ — 넓은 도해는 wide:true(전폭 1030px). 상한 250,000B. 절차는 스킬 references/diagrams.md.\n'
+                 + '· `diagrams`: [{id?, caption, ir? | compare?, alt?, source_text?, verdict?, note?, wide?, origin?}] — **도해.** 설계 데이터를 넣으면 서버가 '
+                 + '고정 판 Archify 로 정지 SVG 를 굽는다(관보 글자 기준 15px). `ir` 은 Archify 설계 데이터 하나 — diagram_type architecture·workflow(schema_version 2)·sequence·dataflow·lifecycle, '
+                 + '`compare` 는 {base, head} — 두 판 다 구성도 설계 데이터(두 판 비교: 겹친 그림 + 바뀐 항목 표). 미리 구운 `svg` 칸은 받지 않는다(⚠ · 번호도 안 잡는다). '
+                 + '어느 서버에서 새로 굽는지 · 종류별 한도는 위 시각 장치 줄. 못 구우면 같은 번호의 대기 상자와 ⚠ 사유(고칠 값). 우리가 그린 도해에는 verdict · 출처 줄을 비운다. '
+                 + '그림 번호는 차트·흐름도·도판과 한 셈. 쓰는 법은 스킬 references/diagrams.md.\n'
                  + '· `flow.mode:"cause"`: 원인 사슬 — 첫 칸의 「해야 할 것」 강조 면을 걷어 「사실 → 우리 상태 → 결과」가 같은 무게로 선다.\n'
                  + '\n'
                  + '관보 문법이 절마다 요구하는 칸:\n'
@@ -1478,7 +1843,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 +1910,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',
@@ -1533,7 +1921,7 @@ const REPORT_DATA = {
                  + '상대의 판단이 필요한 것만. `priority: "must"` 인 항목은 「가장 시급한 요청」으로 '
                  + '따로 서고 나머지와 괘선으로 갈린다 — **먼저 정해져야 하는 것에만** 붙여라. '
                  + '전부에 붙이면 갈림이 사라져 안 붙인 것과 같아진다. '
-                 + '`refs` 는 근거 사례 번호이고 **첫 하나만** 「근거」 단추가 된다.',
+                 + '`refs` 는 근거 사례 번호이고 **첫 하나만** 「근거」 단추가 된다. 결정 모드에서는 받지 않는다(거절).',
     },
     footer: { type: 'array' },
     assets: {
@@ -1618,11 +2006,11 @@ const REPORT_DATA = {
           },
           alt: { type: 'string', description: '설명적 대체 텍스트 — 접근성 계약. 그림과 함께 다닌다' },
           origin: { type: 'string', description: '생성 job 식별자·.mmd 원본 경로·제공자 이름' },
-          caption: { type: 'string', description: '도판 캡션. 그림 번호는 자리가 매기므로 적지 않는다' },
-          source_text: { type: 'string', description: '캡션 아래 「출처」 줄 — 이 그림이 어디서 왔는지' },
+          caption: { type: 'string', description: '도판 캡션. 그림 번호는 자리가 매기므로 적지 않는다. 캡처·영상은 끝에 증거 범위 한 구절(찍은 환경·날짜·옮겨 적은 부분, 예 「… · 운영 관리자 웹 · 8. 23. 촬영」)' },
+          source_text: { type: 'string', description: '캡션 아래 「출처」 줄 — 이 그림이 어디서 왔는지. 캡처는 「화면 이름 · 날짜」를 위치로 적는다(예 「주문 목록 화면 · 8. 23.」)' },
           verdict: {
             type: 'string', enum: ['직접 확인', '조사 보고', '미확인'],
-            description: '이 근거를 **얼마나 믿어도 되는지**. 캡션 끝에 칩으로 선다.\n'
+            description: '이 근거를 **얼마나 믿어도 되는지**. 캡션 끝에 칩으로 선다. 우리가 그린 도해·도판에는 붙이지 않는다.\n'
               + '· 직접 확인 — 원문을 직접 열어 그 수치를 확인함\n'
               + '· 조사 보고 — 2차 출처를 경유해 확인함. 원문 대조는 안 함\n'
               + '· 미확인 — 널리 쓰이나 1차 출처를 특정하지 못함\n'
@@ -1636,7 +2024,7 @@ const REPORT_DATA = {
             description: '**전폭 도판.** 두 단 그리드 밖, 절 끝에 문서 폭(약 1030px)으로 선다. '
               + '나란히 둔 화면 둘처럼 본문 단(760px)에서 절반으로 줄면 글자가 안 읽히는 그림에 켠다. '
               + '켜면 그 절의 그림 번호는 마지막이 된다. 켜든 말든 모든 도판은 눌러서 크게 보기(원본 '
-              + '긴 변 1400px)가 열린다. 집필 때 figure.mjs --display 로 표시 글자 크기를 먼저 재라(하한 14px).',
+              + '긴 변 1400px)가 열린다. 집필 때 figure.mjs --display 로 표시 글자 크기를 먼저 잰다(하한 15px — 스킬 references/readability.md R1).',
           },
           brief: {
             type: 'string',
@@ -1683,8 +2071,8 @@ const REPORT_DATA = {
           symptom: { type: 'string' },
           cause: { type: 'string' },
           fix: { type: 'string' },
-          how_to_check: { type: 'string', description: '고객이 화면에서 볼 수 있는 결과 — 어디를 열면 무엇이 보이는지(주어는 화면·값, 독자에게 시키는 문장 아님)' },
-          remaining: { type: 'string', description: '아직 닫히지 않은 것 — 미확인·미결인 사실과 운영에 아직 안 나간 우리 작업. 독자에게 부탁할 것은 open_items 로(선택)' },
+          how_to_check: { type: 'string', description: '독자가 그 결과를 **볼 자리** + **우리가 그것을 본 때·환경**. 볼 자리는 이 문서의 그림·영상·원문 인용(`{{그림:id}}`·quotes) 또는 독자 자기 화면(어디를 열면) — 자기 화면만 볼 자리로 쓴 확인 방법도 되지만 렌더러 경고 「화면을 말했는데 독자가 볼 증거가 없는 곳」은 남고 그 수가 공개·교체 승인 물음에 실린다(「…에서 봄」 꼬리는 증거로 치지 않는다). 우리가 안 본 결과는 여기 쓰지 않고 remaining 에만 둔다 — 동사는 우리가 본 수준까지(예 「주문서를 작성해 저장하면 새로고침 없이 그 주문이 목록 첫 줄에 나타남({{그림:order-saved}}), 8. 23. 운영 관리자 웹에서 봄」). 주어는 화면·값·우리(독자에게 시키는 문장 아님)' },
+          remaining: { type: 'string', description: '아직 닫히지 않은 것 — 미확인·미결인 사실과 운영에 아직 안 나간 우리 작업. 우리가 안 본 결과는 여기에만 적는다. 독자에게 부탁할 것은 open_items 로(선택)' },
           source_url: { type: 'string', description: 'http(s) 제보 원본 링크(선택)' },
           quotes: {
             type: 'array',
@@ -1719,7 +2107,9 @@ const REPORT_DATA = {
     },
   },
   // 문서가 서려면 있어야 하는 것만. 나머지는 비어 있어도 발행된다.
-  required: ['title_tag', 'sections'],
+  // `sections` 는 필수에서 뺐다(2026-10-06) — 결정 모드는 대장 절이 없어도 선다. 서버는 없으면 빈 목록으로 다룬다.
+  // 모드별 규칙(결정 블록의 뼈대 · 결정 모드가 안 받는 칸)은 스키마 if/then 으로 쓰지 않고 서버가 거절한다(K1~K4 · V-*).
+  required: ['title_tag'],
 };
 
 /* ── 세션 이식 ───────────────────────────────────────────────────────
@@ -2002,12 +2392,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 +2582,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 +2609,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 +3429,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 +3466,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 +3568,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();
@@ -3914,7 +4329,8 @@ async function resolveFetch(cred, body) {
   try {
     const res = await fetch(`${BASE}/api/folders/resolve`, {
       method: 'POST',
-      headers: { Authorization: `Bearer ${cred.token}`, 'Content-Type': 'application/json' },
+      // 판 머리 — api() 와 같은 규율(모든 요청 · 하위 업무 번호 3단계 잣대 ②).
+      headers: { 'X-Genetics-Client': `genetics-mcp/${VERSION}`, Authorization: `Bearer ${cred.token}`, 'Content-Type': 'application/json' },
       body: JSON.stringify(body),
       signal: ac.signal,
     });
@@ -4162,6 +4578,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;                       // 이 기계에 사본이 없으면 「쥐고 있다」가 아니다
@@ -4233,6 +4650,7 @@ async function beatOnce(recs, { closing = false } = {}) {
     const res = await fetch(`${BASE}/api/sessions/beat`, {
       method: 'POST',
       headers: {
+        'X-Genetics-Client': `genetics-mcp/${VERSION}`,   // 판 머리 — api() 와 같은 규율(모든 요청 · 하위 업무 번호 3단계 잣대 ②)
         Authorization: `Bearer ${cred.token}`,
         'Content-Type': 'application/x-lim-beat',
         /*
@@ -4742,6 +5160,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 +5217,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 +5253,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 +5615,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 +5876,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 +5909,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 +5941,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 = [];
@@ -5649,7 +6106,8 @@ function taskReadResult(name, args, body) {
     const tasks = rows.map(row => {
       if (!row || typeof row.uid !== 'string' || !/^[a-z0-9]{8}$/.test(row.uid)
           || ['title', 'state', 'state_word', 'done_when'].some(key => typeof row[key] !== 'string')) throw new Error('할 일의 내용을 확인하지 못했습니다.');
-      return pick(row, ['uid', 'title', 'state', 'state_word', 'done_when']);
+      // 하위 업무 번호 — 사람이 부르는 이름(승인 설계 4-1). 할 일이 번호를 들 때만 서버가 싣는다(0단계 소속처는 칸이 없다 — 결과 그대로).
+      return Object.assign(pick(row, ['uid', 'title', 'state', 'state_word', 'done_when']), taskCodeOf(row) ? { origin_code: row.origin_code } : {});
     });
     result = { tenant: args.tenant, tasks, total: body.open, page: pick(page, ['limit', 'offset', 'returned', 'truncated', 'next_offset']) };
   }
@@ -5657,6 +6115,13 @@ function taskReadResult(name, args, body) {
   return result;
 }
 
+/** 할 일의 하위 업무 번호(서버 응답의 origin_code — 서버가 정한 정본 모양일 때만). 없거나 정본이 아니면 '' — 지어내지 않는다. 정본은 서버 work_item_code_ok 와
+ *  같은 자다(일련은 두 자리 채움 · 그 밖 앞 0 없음 · 자식은 1 부터 앞 0 없음 — W-004 · W-01#04 는 아니다): 원격(mcp_task_results.php)과 stdio 가 같은 답. */
+function taskCodeOf(task) {
+  const code = task && typeof task.origin_code === 'string' ? task.origin_code : '';
+  return /^[A-Z]{1,4}-(?:0[0-9]|[1-9][0-9]{1,3})(?:#[1-9][0-9]{0,2})?$/.test(code) ? code : '';
+}
+
 /**
  * 할 일에 **완료 보고**를 올리는 문(M1 · 2026-09-26) — 사람이 화면에서 쓰는 것과 **같은 서버 함수**(`work_task_do_report`)다.
  *
@@ -5717,7 +6182,8 @@ function taskWriteResult(uid, r) {
   const counts = t.evidence_counts || {};
   const n = Number(counts.total) || (Array.isArray(c.evidence) ? c.evidence.length : 0);
   const v = Number(counts.usable) || 0;
-  const head = `«${uid}» — ${c.kind_word || '완료 보고'} #${c.id ?? '?'} 올림 · 근거 ${n}(검증 ${v})`;
+  const code = taskCodeOf(t);   // 하위 업무 번호가 있으면 사람이 부르는 이름으로 앞에(승인 설계 4-1) — 없으면 예전 그대로
+  const head = `«${code ? code + ' · ' + uid : uid}» — ${c.kind_word || '완료 보고'} #${c.id ?? '?'} 올림 · 근거 ${n}(검증 ${v})`;
   const state = t.state_word ? ` · 상태: ${t.state_word}` : '';
   return head + state + '.' + (r?.says ? ' ' + r.says : '');
 }
@@ -5849,7 +6315,9 @@ const TOOLS = [
       '메모에 **답글로** 회신한다. 이견이 있거나 물을 것이 있으면 대화창이 아니라 여기에 쓴다 — '
       + '저자는 자기가 메모를 단 그 자리에서 답을 본다.\n'
       + '고칠 수 없는 이유, 다르게 본 근거, 되묻는 것이 여기 온다. '
-      + '고쳤으면 답글이 아니라 resolve_note 다.\n'
+      + '단 **접근·권한 요청**(계정·기기·창·메일함·자동 조작 허락)은 답글이 아니라 대화창에서 사용자에게 청한다 — '
+      + '증빙(화면·영상·근거)을 요구한 메모를 못 찍었으면 「못 함」 답글 전에 그 접근부터 청한다.\n'
+      + '고쳤으면 답글이 아니라 resolve_note 다 — 증빙을 요구한 메모는 실물(캡처·영상·원문)이 실린 판에서만 닫는다(도해·설명을 더한 것으로 닫지 않는다).\n'
       + '★ **검토 회신에는 이 도구로 답하지 않는다** — 그쪽은 고객에게 보이는 글이라 사람이 포털에서 쓴다. 할 말은 작성자에게 대화로 전한다.',
     inputSchema: {
       type: 'object',
@@ -5868,6 +6336,7 @@ const TOOLS = [
       + '「무엇에 반영됐는지」를 나중에도 안다.\n'
       + '★ 고치기 **전에** 부르지 말 것 — 이 표시가 곧 「이 메모는 끝났다」이고, '
       + '표시하는 순간 미반영 목록에서 빠져 다시 눈에 안 띈다.\n'
+      + '증빙(화면·영상·근거)을 요구한 메모는 실물이 실린 판의 rev 로만 닫는다 — 도해·설명을 더한 판으로 닫지 않는다.\n'
       + '검토 회신은 `note` 대신 `reply` 로 가리킨다 — 표시해도 회신은 고객에게 그대로 보이고, 그 회신이 집은 문장이 바뀐 것을 update_report 가 더는 경고하지 않는다. '
       + '문서에 반영할 것이 없는 회신(인사·이미 답한 물음)도 읽었으면 표시한다.',
     inputSchema: {
@@ -5889,7 +6358,8 @@ const TOOLS = [
       'HTML 을 만들지 말 것 — 내용만 주면 서버가 렌더한다.\n' +
       '**기본은 초안이다** — 만들어도 고객에게는 보이지 않는다. 눈으로 확인한 뒤 ' +
       'release_report 로 열어 준다. 바로 열려면 publish: true 를 명시할 것.\n' +
-      '**문체는 주어와 자리가 정한다** — 요청 자리 밖에는 우리·사물·화면이 주어인 문장만 개조식(~함/~했음/~임)으로 쓴다. 독자가 할 일은 요청 자리(open_items·cta·PART I 간지(요청·결정 PART 일 때)·판권지 회신 안내·요청 절 항을 부탁하는 읽는 법 한 줄)에만 두고 사실 문장까지 하십시오체로 맺는다(「회신 부탁드립니다」. 제목은 검수·보고면 「~ 요청」+기한 괄호, 결정 문서의 판단 항목은 물음). 그 밖의 칸에는 사실만 적는다(「기준 수치는 미정」). dry_run 은 일부만 센다.\n' +
+      '**공개 승인**(publish: true · release_report)을 사용자에게 물을 때는 그 물음과 답에 이 판에서 건너뛴 단계(0단계 사용자 확인·독자 검토·열람 확인 등)와 증거 없는 관찰 주장 수(렌더러 경고 「화면을 말했는데 독자가 볼 증거가 없는 곳」 — 포털 dry_run 에 이 경고가 아직 없으면 스킬의 로컬 render.py 로 잰 곳 수)를 싣는다 — 「간단히」는 분량 지시이지 단계 면제가 아니다.\n' +
+      '**문체는 주어와 자리가 정한다** — 요청 자리 밖에는 우리·사물·화면이 주어인 문장만 개조식(~함/~했음/~임)으로 쓴다. 독자가 할 일은 요청 자리(open_items·cta·PART I 간지(요청·결정 PART 일 때)·판권지 회신 안내·요청 절 항을 부탁하는 읽는 법 한 줄)에만 두고 사실 문장까지 하십시오체로 맺는다(「회신 부탁드립니다」. 제목은 검수·보고면 「~ 요청」+기한 괄호, 고객이 정할 것은 data.decision_brief.decisions 에 — 서식은 lim-report 하나이고 결정 블록이 있으면 결정 모드로 선다(lim-decision 은 옛 이름)). 그 밖의 칸에는 사실만 적는다(「기준 수치는 미정」). dry_run 은 일부만 센다.\n' +
       '쓰기 전에 결과만 보고 싶으면 dry_run: true — 렌더까지 돌려 경고를 주고 아무것도 저장하지 않는다.',
     inputSchema: {
       type: 'object',
@@ -5915,7 +6385,8 @@ const TOOLS = [
     description:
       '초안을 고객에게 연다. 이 순간부터 고객 목록과 열람에 뜬다. ' +
       '이미 열려 있으면 아무 일도 하지 않고 그렇다고 답한다(다시 불러도 안전하다).\n' +
-      '사람 자격으로 공개해야 보고서의 열린 항목이 일감으로 선다.',
+      '사람 자격으로 공개해야 보고서의 열린 항목이 일감으로 선다.\n' +
+      '**공개 승인**을 사용자에게 물을 때는 그 물음과 답에 이 판에서 건너뛴 단계(0단계 사용자 확인·독자 검토·열람 확인 등)와 증거 없는 관찰 주장 수(렌더러 경고 「화면을 말했는데 독자가 볼 증거가 없는 곳」 — 포털 dry_run 에 이 경고가 아직 없으면 스킬의 로컬 render.py 로 잰 곳 수)를 싣는다 — 「간단히」는 분량 지시이지 단계 면제가 아니다.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -5966,7 +6437,8 @@ const TOOLS = [
       '한 장만 바꾸려면 그 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',
+      '**교체 승인**을 사용자에게 물을 때는 그 물음과 답에 이 판에서 건너뛴 단계(0단계 사용자 확인·독자 검토·열람 확인 등)와 증거 없는 관찰 주장 수(렌더러 경고 「화면을 말했는데 독자가 볼 증거가 없는 곳」 — 포털 dry_run 에 이 경고가 아직 없으면 스킬의 로컬 render.py 로 잰 곳 수)를 싣는다 — 「간단히」는 분량 지시이지 단계 면제가 아니다.\n' +
+      '**문체는 주어와 자리가 정한다** — 요청 자리 밖에는 우리·사물·화면이 주어인 문장만 개조식(~함/~했음/~임)으로 쓴다. 독자가 할 일은 요청 자리(open_items·cta·PART I 간지(요청·결정 PART 일 때)·판권지 회신 안내·요청 절 항을 부탁하는 읽는 법 한 줄)에만 두고 사실 문장까지 하십시오체로 맺는다(「회신 부탁드립니다」. 제목은 검수·보고면 「~ 요청」+기한 괄호, 고객이 정할 것은 data.decision_brief.decisions 에 — 서식은 lim-report 하나이고 결정 블록이 있으면 결정 모드로 선다(lim-decision 은 옛 이름)). 그 밖의 칸에는 사실만 적는다(「기준 수치는 미정」). dry_run 은 일부만 센다.\n',
     inputSchema: {
       type: 'object',
       properties: {
@@ -6055,12 +6527,20 @@ const TOOLS = [
       + '무엇을 적는가: **왜**가 이 장의 값이다(그때의 근거·수치·관찰). 그리고 **무슨 조건이면 다시 여나** — '
       + '이것을 비우면 그 결정은 「아직 열린 것」으로 읽힌다(닫혔는지 아무도 모르므로). '
       + '끝난 결정이면 "조건 없음(종결)"이라고 적을 것.\n'
-      + '모르는 칸은 **비운다** — 지어내면 「적히지 않음」보다 나쁘다.',
+      + '모르는 칸은 **비운다** — 지어내면 「적히지 않음」보다 나쁘다.\n'
+      + '★ **하위 업무 번호를 쓰는 소속처**(works 가 항목마다 W-04 같은 번호를 보여 주는 곳)에서는 번호를 서버가 매긴다 — '
+      + '그곳에서는 제목에 [W-02] · W-02 같은 번호를 쓰지 말 것(응답이 번호를 알려 준다). '
+      + '있는 하위 업무를 고쳐 적으면 item 에 그 번호, 하위로 나누면 parent 에 부모 번호를 준다. '
+      + '아직 번호를 안 쓰는 소속처는 item · parent 를 422 로 돌려준다 — 그곳의 장은 get_case 로 읽은 revision 을 expected_revision 으로 대 고쳐 적는다.',
     inputSchema: {
       type: 'object',
       properties: {
         tenant: { type: 'string', description: '대상 소속처 slug(이름도 받는다 — list_my_tenants 참조).' },
-        title: { type: 'string', description: '한 줄 제목. 다른 결정은 제목을 달리한다. 기존 결정은 expected_revision을 전달해야 수정된다.' },
+        title: { type: 'string', description: '한 줄 제목. 다른 결정은 제목을 달리한다. 기존 결정은 expected_revision을 전달해야 수정된다. 하위 업무 번호를 쓰는 소속처에서는 번호를 제목에 적지 않는다(서버가 매긴다).' },
+        item: { type: 'string', description: '고쳐 적을 **하위 업무 번호**(예 W-04 — works 목록의 번호 그대로). 그 장에 새 판으로 선다(제목이 바뀌어도 번호 · 경로 그대로). 번호를 쓰는 소속처만 받는다(아직 안 쓰는 곳은 422).' },
+        parent: { type: 'string', description: '하위로 나누기 — 부모 하위 업무 번호(예 R-01). 새 번호는 그 아래 자식(R-01#5)으로 선다. 깊이는 한 겹. 번호를 쓰는 소속처만 받는다(아직 안 쓰는 곳은 422).' },
+        branch: { type: 'string', description: '갈래를 가진 업무(hnl-wrm 등)의 갈래 머리글자(W · R · M). 비우면 tags 의 갈래 태그(예 「대기 개선(W)」)로 고른다.' },
+        prefix: { type: 'string', description: '새 업무를 여는 결정이면 그 업무의 머리글자(대문자 1~4). 비우면 서버가 제안한 것으로 선다 — 한 번 서면 못 바꾼다.' },
         expected_revision: { type: 'string', pattern: '^[a-f0-9]{64}$', description: '기존 결정 수정 시 get_case에서 읽은 revision. 신규 생성은 생략. 충돌하면 원문을 다시 읽고 변경을 재검토한다.' },
         commit_id: { type: 'string', pattern: '^[a-zA-Z0-9][a-zA-Z0-9-]{15,79}$', description: '이 저장 작업의 고유 UUID. 첫 호출 전에 생성하고 응답 유실·재시도에는 같은 값과 같은 본문을 유지한다. 별도 수정은 새 값을 쓴다.' },
         what: { type: 'string', description: '무엇을 정했나 — 한 문장.' },
@@ -6126,7 +6606,7 @@ const TOOLS = [
       type: 'object',
       properties: {
         tenant: { type: 'string', description: '대상 소속처 slug(이름도 받는다 — list_my_tenants 참조).' },
-        path: { type: 'string', description: 'search_cases·remember_decision 이 준 path 그대로(decisions/….md). 제목을 줘도 저장과 같은 자로 찾는다.' },
+        path: { type: 'string', description: 'search_cases·remember_decision 이 준 path 그대로(decisions/….md). 제목을 줘도 저장과 같은 자로 찾는다. 번호를 쓰는 소속처는 하위 업무 번호(W-04)도 받는다.' },
         expected_revision: { type: 'string', pattern: '^[a-f0-9]{64}$', description: 'get_case로 읽은 삭제 대상의 revision.' },
       },
       required: ['tenant', 'path', 'expected_revision'],
@@ -6200,7 +6680,7 @@ const TOOLS = [
       properties: {
         tenant: { type: 'string', description: '대상 소속처 slug(이름도 받는다 — list_my_tenants 참조).' },
         claim: { type: 'string', description: '이 일(slug)에 붙겠다고 선언한다 — 잠정이며, 다른 일을 선언하면 앞 선언은 대체된다. 비우면 목록만 읽는다.' },
-        item: { type: 'string', description: 'claim 과 함께 쓰면 착수 선언(잠정). work 와 함께 쓰면 완료 확인/표시/해제 대상 — 이 일 안의 결정 항목(item_key, 예: decisions/foo.md).' },
+        item: { type: 'string', description: 'claim 과 함께 쓰면 착수 선언(잠정). work 와 함께 쓰면 완료 확인/표시/해제 대상 — 이 일 안의 결정 항목(item_key, 예: decisions/foo.md). 번호를 쓰는 소속처는 하위 업무 번호(예 W-04 — 목록의 번호 그대로)도 받는다 — 그 일의 번호가 아니면 서버가 거절한다.' },
         work: { type: 'string', description: '이 일(slug). **혼자 주면 그 일의 항목 목록**(번호·제목·계획 기간·상태·item_key)을 읽는다(부작용 없음). item 과 함께 주면 그 항목의 완료 확인·표시·해제 — claim 과 별개(착수 선언 없이도 완료를 다룰 수 있다).' },
         done_when: { type: 'string', description: '이 항목의 완료 조건 — 무엇이 되면 끝인가. done_evidence 와 반드시 함께 채운다(work+item과 함께).' },
         done_evidence: { type: 'string', description: 'done_when 과 함께 쓴다 — 그 조건이 실제로 충족됐다는 구체적 관측(파일·시험 결과·커밋 등). 비우면 완료로 못 간다 — 지어내지 말 것, 스스로 확인한 것만.' },
@@ -6330,8 +6810,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' +
@@ -6404,12 +6884,18 @@ const TOOLS = [
       + '다른 기계·두뇌에 닿는다 — 서버를 지나기 때문이다.\n'
       + '`SendMessage` 는 **이 기계의 Claude Code 끼리만** 가는 지름길이다. `ListAgents` 에 없다고 '
       + '해서 세션이 없는 것이 아니다 — 발견은 `gcell agents`, 주소는 여기 `to` 다.\n'
+      + '★ 받는 쪽 주소는 **세션 uuid(36자)가 정본**이다 — `gcell agents` 가 주소 칸에 내는 그 값을 쓴다. '
+      + '세션 이름(예: report-portal-37)은 프로세스가 다시 뜰 때마다 새로 뽑히는 **그 순간의 별칭**이라, 적어 둔 이름은 '
+      + '죽거나 같은 이름을 새로 받은 다른 세션에게 간다. 이름으로 부쳤으면 결과의 「받는 세션」 uuid 로 이어 간다.\n'
+      + '한 대화를 창 둘 이상이 함께 띄우면(`gcell agents` 의 「창 N곳」) 그 uuid 앞 통은 어느 창이 받을지 정해지지 않는다 — '
+      + '한 창에 닿으려면 `SendMessage` 에 그 창의 지금 이름을 쓴다.\n'
+      + '이 세션에 이름이 없어도 보낸다 — 그때 받는 쪽에는 이 세션 uuid 앞 8자가 발신자로 찍힌다.\n'
       + '무엇을 해 달라고 **부탁해도 된다** — 이 창구는 받는 쪽 눈앞에 「누가 보냈는지」를 서버가 '
       + '반드시 붙여 주므로, 세계 장부와 달리 지시형이 막히지 않는다.\n'
-      + '받는 것은 부를 필요가 없다 — 온 것은 다른 도구를 부를 때 응답 꼬리에 저절로 실린다.\n'
+      + '받는 것은 부를 필요가 없다 — 온 것은 다른 도구를 부를 때 응답 꼬리에 저절로 실린다(답할 주소 uuid 가 함께 온다).\n'
       + '**사람에게는 이메일로** 보낸다(그 소속처 담당만) — 포털 벨이 울린다.\n'
-      + '⚠ 상대 이름은 **지어내지 말 것.** `world` 나 `gcell agents` 가 아는 이름, 세션 uuid, '
-      + '담당의 이메일, 또는 `brain` 중 하나다. 못 찾으면 사용자에게 묻는다.\n'
+      + '⚠ 상대 주소는 **지어내지 말 것.** 세션 uuid, 방금 확인한 세션 이름, 담당의 이메일, 또는 `brain` 중 하나다. '
+      + '못 찾으면 사용자에게 묻는다.\n'
       + '⚠ 한 실(thread)에는 상한이 있다 — **왕복**(한 쪽이 보내고 상대가 답하면 1왕복)은 사람이 낀 실 5회·기계끼리 3회, '
       + '답 없이 같은 쪽이 연달아 부치는 것은 3통. 넘으면 409 로 거절된다. '
       + '**사람에게 저절로 알리는 기능은 아직 없다** — 사람의 판단이 필요하면 이 세션의 사용자에게 말하거나 '
@@ -6418,7 +6904,7 @@ const TOOLS = [
       type: 'object',
       properties: {
         tenant:    { type: 'string', description: '소속처 slug(이름도 받는다). 모르면 list_my_tenants 로 먼저 확인한다' },
-        to:        { type: 'string', description: '받는 쪽 — 세포 이름 · 세션 uuid · 담당의 이메일(사람에게) · 또는 brain' },
+        to:        { type: 'string', description: '받는 쪽 — **세션 uuid(36자 · 정본 — `gcell agents` 의 주소 칸)** · 방금 확인한 세션 이름(그 순간의 별칭 — 바뀌면 남에게 간다) · 담당의 이메일(사람에게) · 또는 brain' },
         body:      { type: 'string', description: '할 말' },
         subject:   { type: 'string', description: '한 줄 제목(선택)' },
         artifact:  { type: 'string', description: '무엇에 대한 이야기인가 — 파일·문서 경로(선택)' },
@@ -6497,9 +6983,26 @@ function pinsText(r) {
 }
 function warnText(r) {
   const w = [...(r?.warnings ?? []), ...ASSET_HINTS];
-  return w.length
-    ? `\n\n경고 ${w.length}건:\n· ${w.join('\n· ')}`
-    : '';
+  if (!w.length) return '';
+  /*
+   * 결정 모드(원고에 결정 블록 — 관보 버전2 → v3 ⑨)는 **개수를 안 찍는다**(설계안 8.3) — 「경고 N건」 합계는 고친 횟수를 목표로
+   * 돌게 하는 손잡이였다(lim 위키 사례 #212). 렌더러가 결정에 속한 알림을 「결정 「X」 — 」 로 시작하게 내므로(계약 3.4),
+   * 그 줄은 결정 이름 아래로 모아 들여 찍는다. 처음 나온 차례를 지키고, 결정에 안 속한 줄은 제자리에 그대로 둔다.
+   * 모드는 응답의 `mode` 로 가른다(관보 v3 서버가 dry_run·발행·교체 응답에 싣는다 — 서식은 하나라 template 은 늘 lim-report).
+   * 옛 서버(관보 버전2)는 mode 없이 template:'lim-decision' 을 보낸다 — 그것도 결정 모드로 읽는다. 없거나 report 면 지금 그대로.
+   */
+  if (r?.mode === 'decision' || r?.template === 'lim-decision') {
+    const out = [], groups = new Map();
+    for (const line of w) {
+      const m = /^결정 「([^」]*)」 — ([\s\S]*)$/.exec(String(line));
+      if (!m) { out.push(`· ${line}`); continue; }
+      if (!groups.has(m[1])) { const g = []; groups.set(m[1], g); out.push([m[1], g]); }
+      groups.get(m[1]).push(m[2]);
+    }
+    const text = out.map((x) => (typeof x === 'string' ? x : `결정 「${x[0]}」\n${x[1].map((t) => `  · ${t}`).join('\n')}`));
+    return `\n\n알림 — 결정 장 이름 아래 자리 글:\n${text.join('\n')}`;
+  }
+  return `\n\n경고 ${w.length}건:\n· ${w.join('\n· ')}`;
 }
 
 /* 발행물의 **구조**를 사람이 읽는 줄로 옮긴다.
@@ -6769,7 +7272,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. '
         + '이미 올라간 것은 꺼도 안 사라진다 — 포털 「폴더」에서 지운다.';
@@ -6843,7 +7348,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':
@@ -7023,6 +7529,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')}`;
@@ -7072,19 +7579,30 @@ const mailQueue = [];          // 아직 안 말한 통(서버가 렌더한 글
 const mailBack  = [];          // 내가 부쳤다 만료된 것
 const mailBackSeen = new Set();
 
-/**
- * 이 세션의 **말 걸 수 있는 이름.** 전사에서 마지막 자기소개를 캔다.
- *
- * ★ 왜 전사인가: `ListAgents` 를 부르면 하네스가 「This session is <이름> [<id>]」를
- *   **전사에 적는다.** 그것은 모델이 지어낸 값이 아니라 하네스가 쓴 사실이고,
- *   전사 파일 이름이 곧 세션 uuid 라 두 체계가 거기서 만난다.
- *   세포의 `agent_name_in`(`cell/src/world.rs:443`)과 **같은 규칙**을 쓴다 —
- *   두 자로 재면 같은 세션을 다르게 부르게 된다.
- *
- * ⚠ **마지막 것**을 쓴다. 이름은 세션 도중에 바뀌고, 옛 이름은 죽은 주소다.
- * ⚠ **늘어난 부분만 다시 읽는다.** 전사가 7MB 까지 가므로(실측) 매번 통독하면
- *   그 자체가 부하다. 이름은 앞으로만 생기니 뒤만 보면 된다.
- * ⚠ 못 찾으면 `null` — **지어내지 않는다.** 이름 없는 주소는 받을 수는 있어도 못 보낸다.
+/*
+ * ══ 이 세션의 주소 — **세션 uuid 가 정본, 이름은 보내기 직전에 푼다** (주소 계약 2 · 2026-10-07) ══════════════════════════
+ *
+ * 오래 들고 있을 주소는 세션 uuid(36자)다. 하네스 이름(예: report-portal-37)은 프로세스가 뜰 때마다 00~ff 로 다시 뽑히는
+ * 표시값이라 적어 두면 죽거나 남에게 간다 — 469cd2a5 의 이름은 5일 사이 eb → 26 → 37 이었고, 7afd1d02 의 옛 이름 hnl-73 은
+ * 지금 산 세션 110cd958 의 이름이다(검증 워크플로 2026-10-07 실측). 그래서 이 MCP 는
+ *   ① **이름이 없어도 보낸다.** 서버는 2026-08-25 부터 이름 없는 발신을 uuid 앞 8자로 받는다(8ec9b061:www/portal/lib/mail_store.php:96-105 —
+ *      mail_store_sender_session). 전에는
+ *      여기 문지기(「이름 없으면 못 보냄」)가 서버보다 엄해서, 등록부를 못 읽은 세션이 전체 uuid 앞으로 보낸 통까지 거절됐다
+ *      (2026-10-06T15:49:24Z, to=469cd2a5-…-f8751b9dcd18 → 15:49:25Z 거절).
+ *   ② 서버 주소록에 대는 이름은 **대기 직전에** 푼다 — 세포(`gcell agents --self --json`)에 먼저 묻고(`cellSelf`), 세포가 없거나
+ *      못 알아들으면 아래 JS 사본(`selfAddressJs`)으로. 같은 규칙을 두 자로 재면 같은 세션을 다르게 부른다 — 9aedc967 에서 등록부
+ *      pid 가 문자열이면 세포는 그 줄을 버리고 MCP 는 받았다(9aedc967:cell/src/world.rs:684 대 mcp/genetics.mjs:7570). 그래서 JS 사본은 세포와 같은 계약을 진다.
+ *   ③ 대는 이름은 **지금 이 프로세스의 이름이라고 확인된 것**뿐이다(`myAgentName`). 확인 못 한 이름(다시 뜨기 전의 자기소개)을 대면
+ *      서버가 그 이름을 이 세션으로 풀어(052 의 최신-승) 그 이름의 지금 임자에게 갈 통이 여기로 온다.
+ */
+/*
+ * ── 전사의 자기소개 ─────────────────────────────────────────────────────────────────────────────
+ * `ListAgents` 를 부르면 하네스가 「This session is <이름> [<id>]」를 **전사에 적는다.** 모델이 지어낸 값이 아니라 하네스가 쓴
+ * 사실이지만, 그 이름은 **그때의** 이름이다 — 다시 뜬 뒤에는 옛 이름이다. 그래서 등록부 다음 차례이고, 그마저 이 MCP 가 뜬 뒤에
+ * 적힌 것만 지금 이름으로 친다(`myAgentName`).
+ * ⚠ **마지막 것**을 쓴다 — 끝에서 거슬러 읽는다(`lastIntroInRange`).
+ * ⚠ **늘어난 부분만 다시 읽는다.** 그림이 base64 로 실려 전사가 253MB 까지 간다(2026-10-07 실측 — 옛 주석의 「7MB」는 틀렸다).
+ * ⚠ 못 찾으면 `null` — **지어내지 않는다.**
  */
 /*
  * ⚠⚠ **줄 안의 글자가 아니라 레코드의 모양으로 읽는다** (2026-08-25 실측).
@@ -7103,7 +7621,37 @@ const mailBackSeen = new Set();
  */
 const INTRO_HEAD = 'This session is ';
 const INTRO_TAIL = 'the name other sessions use';
-const AGENT_NAME_RE = /^This session is ([A-Za-z0-9._-]{1,60}) \[([0-9a-fA-F]+)\]/;
+/**
+ * 자기소개 글 한 덩이 → `{ name, id }`(세포 `agent_name_in` 과 한 벌). 못 읽으면 null.
+ * ⚠ 이름 글자는 **등록부와 같은 꼴**(`harnessNameClean` — 제어문자만 걷고 65자까지)이다(2026-10-07). 전에는 [A-Za-z0-9._-]{1,60} 만
+ *   받았는데, 실제 ListAgents 목록에 「atflee Graph」·「홈 변화 그래프 — 최신 기록이 …」(47자) 같은 이름이 선다(469cd2a5 전사 실측 —
+ *   세포 쪽 조사). 그래서 식별자는 꼬리(INTRO_TAIL) 앞의 **마지막** 「 [<16진>]」이고 — 이름 안에 「 — 」나 「 [」가 있어도 안 갈린다 —
+ *   본문의 첫 줄만 본다(그 아래 「Peer sessions」 목록의 이름들은 이 세션의 이름이 아니다).
+ */
+function introNameIn(text) {
+  const t = String(text ?? '');
+  const i = t.indexOf(INTRO_HEAD);
+  if (i < 0) return null;
+  const rest = t.slice(i + INTRO_HEAD.length).split('\n')[0];
+  const tail = rest.indexOf(INTRO_TAIL);
+  const head = tail >= 0 ? rest.slice(0, tail) : rest;
+  const open = head.lastIndexOf(' [');
+  if (open < 0) return null;
+  const name = harnessNameClean(head.slice(0, open));
+  if (!name) return null;
+  const after = head.slice(open + 2);
+  const close = after.indexOf(']');
+  if (close < 0) return null;
+  const id = after.slice(0, close);
+  return /^[0-9A-Fa-f]+$/.test(id) ? { name, id } : null;
+}
+/**
+ * 전사의 레코드(JSONL 한 줄) → 그 자기소개의 이름(세포 `agent_name_in_record` 와 한 벌). 아니면 null.
+ * ★ 레코드에 하네스의 짝 표식 `toolUseResult.listing`(ListAgents 결과의 구조화 칸 — 본문과 같은 글)이 있어야 한다(2026-10-07 검증 SEC-6).
+ *   Bash 결과는 `{stdout, stderr, …}` 라, `echo "This session is <남의 이름> [ab12] — the name other sessions use"` 한 줄이 전에는 이름으로
+ *   읽혀 아래 myAgentName ②(뜬 뒤 자기소개)로 서버에 이 세션의 주소로 섰다 — 웹 문서에 숨은 지시 하나로. 실측: 전사 154개의 자기소개 211건이
+ *   하네스 2.1.239~2.1.290 내내 이 칸을 가졌고 본문과 같았다.
+ */
 function introNameOf(line) {
   if (!line.includes(INTRO_HEAD)) return null;          // 값싼 검사로 먼저 거른다
   let d;
@@ -7113,63 +7661,765 @@ function introNameOf(line) {
   const first = Array.isArray(c) ? c[0] : null;
   if (!first || first.type !== 'tool_result') return null;
   let body = first.content;
-  if (Array.isArray(body)) body = body.map((x) => (x && x.type === 'text' ? String(x.text || '') : '')).join('');
+  if (Array.isArray(body)) body = body.map((x) => (x && x.type === 'text' && typeof x.text === 'string' ? x.text : '')).join('');
   if (typeof body !== 'string' || !body.startsWith(INTRO_HEAD) || !body.includes(INTRO_TAIL)) return null;
-  const m = AGENT_NAME_RE.exec(body);
-  return m ? m[1] : null;
+  const listing = d?.toolUseResult?.listing;
+  if (typeof listing !== 'string') return null;         // ★ 하네스 ListAgents 의 짝 표식이 없다 — Bash·MCP 가 찍은 같은 글
+  const a = introNameIn(body);
+  const b = introNameIn(listing);
+  return a && b && a.name === b.name && a.id === b.id ? a.name : null;
 }
-let nameCache = null;          // { file, size, name }
-function myAgentName() {
-  const uuid = mySessionId();
-  if (!/^[0-9a-f-]{36}$/i.test(uuid)) return null;
-  const f = transcriptOf(uuid);
-  if (!f) {
+/*
+ * ── 하네스 등록부 — JS 사본(계약 1 의 의미 그대로 · 세포가 없거나 못 알아들을 때만 쓴다) ─────────────────────────────────
+ * 하네스는 이름을 **프로세스가 뜰 때마다 새로 짓고** `<설정 폴더>/sessions/<pid>.json` 의 `name` 에 적는다 — ListAgents·SendMessage 가
+ * 쓰는 바로 그 이름이다(`nameSource:"derived"` · `nameSince` = 프로세스 시작). 실측(2026-10-07): 469cd2a5 는 등록부 「report-portal-37」,
+ * 전사 「report-portal-26」.
+ *
+ * ★ 세포(`cell/src/world.rs` 「주소는 세션 uuid 다」 머리말 · registry_rows_in·row_live·self_row·whereabouts_of)와 **한 벌**이다.
+ *   두 자를 맞대는 정본은 둘이다 — 칸 규칙표 `cell/tests/fixtures/registry/cases.json`(smoke 3-2)과, 경우 통째(등록부 줄·전사·env·
+ *   프로세스 표 → 계약 1 의 답)를 맞대는 **이름 관문** `cell/tests/fixtures/agent-names/`(smoke 3-4 · 세포는 cargo 시험 둘이 같은 경우를 문다).
+ *   관문이 처음 돌 때(2026-10-07) 이 사본이 세 자리에서 세포와 달랐다 — 산 줄이면 옛 이름을 안 읽음 · 옛 이름을 설정 폴더가 아니라
+ *   findTranscript(~/.claude/projects 고정)로 찾음 · 1MiB 넘는 줄을 자기소개로 읽음. 셋 다 세포 쪽으로 맞췄다.
+ *   9aedc967 에서 둘이 갈렸다 — pid 가 문자열 "32054" 면 세포는 그 줄을 버리고 MCP 는 받아, 같은 세션을 세포는 옛 자기소개로 ·
+ *   MCP 는 등록부 이름으로 불렀다(검증 조사 픽스처 A). 그래서 아래 규칙은 글자 하나까지 세포를 따른다:
+ *   · 파일은 `<숫자>.json` 만(세션 사이 인증 열쇠 `.key` 는 안 읽는다) · 64KiB 를 넘으면 안 읽는다.
+ *   · 숫자 칸(pid·updatedAt)은 JSON 수(정수 — 소수부 0 인 실수 포함) 또는 **ASCII 숫자 1~16자** 문자열(`harnessInt`).
+ *     `Number()` 를 그대로 쓰지 않는다 — `Number(" 7")`·`Number("0x7")` 도 7 이라 두 자가 갈린다.
+ *   · 이름은 제어문자(Cc)만 걷고 앞뒤 공백을 다듬어 1~65자(코드 포인트, `harnessNameClean`). 넘으면 자르지 않고 버린다(줄은 남는다 —
+ *     이름 없이 떠 있는 세션). 하네스는 `/rename` 이름을 제어문자만 걷고 받고, 안정 주소 스위치가 켜지면 이름이 65자까지 간다 —
+ *     옛 [A-Za-z0-9._-]{1,60} 은 「atflee Graph」·47자 한글 이름의 줄을 말없이 버렸다.
+ *   · 떠 있나(`harnessRowLife`)는 셋 중 하나 — 'live' · 'gone'(재서 아니라고 나왔다) · 못 잰 까닭('platform'·'domain'·'start').
+ *     떠 있다 = pidDomain 이 이 판과 같고(하네스와 같은 꼴로 짓는다 — `harnessPidDomain`, F1) · pid 가 있고(kill 0 · EPERM 도 있는 것) ·
+ *     procStart 가 있으면 그 pid 의 실제 시작 시각과 2초 안. procStart 를 못 대조하면(꼴을 못 읽음 · 시작 시각을 못 잼) **산 것으로 안
+ *     친다** — 끝난 세션의 옛 이름을 「지금 이름」으로 대면 남의 통이 여기로 온다. 이름 없이 uuid 로 닿는 쪽이 안전하다. 그러나 「끝났다」고도
+ *     안 한다(F5 — 계약 칸 measured 거짓). procStart 칸이 없는 옛 하네스 줄은 kill 0 만.
+ *   · 같은 조건의 산 줄이 둘이면 procStart 가 늦은 줄(가장 나중에 뜬 프로세스), 같으면 pid 가 큰 줄(readdir 차례에 안 기댄다). updatedAt 은
+ *     안 쓴다 — 상태가 바뀔 때마다 움직여 창 둘이 띄운 대화는 물을 때마다 다른 이름이 나왔다(L1). 산 줄 수는 live_rows 로 낸다(SEC-1).
+ *   · 자기 줄은 **프로세스 열쇠** 차례로 찾는다: env `CLAUDE_CODE_MESSAGING_SOCKET` == `messagingSocketPath` → `CLAUDE_PID` == `pid` →
+ *     `CLAUDE_CODE_SESSION_ID` == `sessionId`. 세션 id 만으로 찾으면 /clear 뒤에는 MCP env 의 옛 id 로 줄을 못 찾는다(MCP 는 뜰 때
+ *     env 를 한 번 받는다 — 2.1.290 @217810326 · /clear 는 등록부 줄의 sessionId 만 바꾼다). MCP 의 process.ppid 는 claude 가 아니라
+ *     volta 심이라 열쇠가 못 된다(ps 실측 MCP 18936 → 심 18901 → claude 18159). MCP env 에는 CLAUDE_PID 가 없다(Bash·훅의 것).
+ */
+/**
+ * 하네스의 집 — 세포 `crate::home_dir()` 와 같은 차례(유닉스: HOME → USERPROFILE · Windows: 거꾸로), 둘 다 없으면 os.homedir().
+ * ⚠ `env` 에서 읽는다(전에는 os.homedir() 고정) — 이름 관문이 경우마다 임시 집을 주고, 세포도 그 env 의 HOME 을 읽는다.
+ */
+function harnessHome(env = process.env) {
+  for (const k of process.platform === 'win32' ? ['USERPROFILE', 'HOME'] : ['HOME', 'USERPROFILE']) {
+    const v = env?.[k];
+    if (typeof v === 'string' && v !== '') return v;
+  }
+  return os.homedir();
+}
+/** 하네스 설정 폴더 — CLAUDE_CONFIG_DIR(비어 있지 않을 때) 아니면 <집>/.claude(세포 `harness_config_dir`). NFC 는 하네스가 하는 대로. */
+function harnessConfigDir(env = process.env) {
+  return String(env?.CLAUDE_CONFIG_DIR || path.join(harnessHome(env), '.claude')).normalize('NFC');
+}
+function harnessSessionsDir(env = process.env) {
+  return path.join(harnessConfigDir(env), 'sessions');
+}
+/**
+ * Claude Code 전사를 찾는 뿌리 — <설정 폴더>/projects, 그다음 <집>/.claude/projects(설정 폴더가 그것이 아닐 때만) · 세포 `claude_project_bases`.
+ * ⚠ 옛 이름(자기소개)은 이 규칙으로만 찾는다. 전에는 `introOf`(findTranscript — Codex 먼저 · cwd 폴더 · ~/.claude/projects 고정 · Cursor)를 써서
+ *   CLAUDE_CONFIG_DIR 로 뜬 세션의 옛 이름을 세포와 다르게 냈다(이름 관문 2026-10-07 — 픽스처 10-config-dir 가 미끼를 냈다).
+ */
+function claudeProjectBases(env = process.env) {
+  const bases = [path.join(harnessConfigDir(env), 'projects')];
+  const home = path.join(path.join(harnessHome(env), '.claude').normalize('NFC'), 'projects');
+  if (!bases.includes(home)) bases.push(home);
+  return bases;
+}
+/**
+ * `bases` 의 프로젝트 폴더들에서 `<uuid>.jsonl`(본 전사)을 — 뿌리 차례, 그 안에서는 폴더 이름의 바이트 차례(libuv 가 strcmp 로 늘어놓는다 ·
+ * 세포도 같은 차례로 맞췄다)로 처음 것. 하위 에이전트 전사(`<uuid>/subagents/…/agent-*.jsonl`)는 이 꼴이 아니라 안 잡힌다(세포 `claude_transcript_in`).
+ */
+function claudeTranscriptIn(bases, sid) {
+  const s = String(sid ?? '');
+  if (!AUTO_UUID_RE.test(s)) return null;
+  for (const base of bases) {
+    let names;
+    try { names = fs.readdirSync(base); } catch { continue; }
+    for (const n of names) {
+      const f = path.join(base, n, `${s}.jsonl`);
+      try { if (fs.statSync(f).isFile()) return f; } catch { /* 이 폴더엔 없다 */ }
+    }
+  }
+  return null;
+}
+/** 그 pid 의 프로세스가 지금 있나 — 신호 0 은 보내지 않고 묻기만 한다. 남의 프로세스(EPERM)도 있는 것이다. */
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (e) { return e?.code === 'EPERM'; }
+}
+/** 등록부 숫자 칸 → 정수(세포 `reg_int`): JSON 수는 안전 정수만, 문자열은 ASCII 숫자 1~16자만. 그 밖(부호·공백·소수점·16진·지수·불·null)은 null. */
+function harnessInt(v) {
+  if (typeof v === 'number') return Number.isSafeInteger(v) ? v : null;
+  if (typeof v === 'string' && /^[0-9]{1,16}$/.test(v)) return Number(v);
+  return null;
+}
+const HARNESS_NAME_MAX = 65;
+// 유니코드 White_Space 중 제어문자(Cc)가 아닌 것 — 세포 name_clean 의 trim() 과 같은 자리를 다듬는다(JS 의 \s 는 U+FEFF 도 걷어 다르다).
+const HARNESS_TRIM = /^[\u0020\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+|[\u0020\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+$/g;
+/** 이름 꼴(세포 `name_clean`) — 제어문자(Cc)만 걷고 앞뒤 공백을 다듬은 뒤 1~65자(코드 포인트)면 그 글, 아니면 null(자르지 않는다). */
+function harnessNameClean(s) {
+  if (typeof s !== 'string') return null;
+  const t = s.replace(/[\u0000-\u001F\u007F-\u009F]/g, '').replace(HARNESS_TRIM, '');
+  const n = [...t].length;
+  return n >= 1 && n <= HARNESS_NAME_MAX ? t : null;
+}
+/** 이미 깨끗한 이름인가 — 세포가 낸 이름(이미 name_clean 을 지났다)을 받을 때 모양을 다시 잰다. */
+function harnessNameOk(s) {
+  return typeof s === 'string' && harnessNameClean(s) === s;
+}
+const PROC_MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/** `ps -o lstart` 꼴(「Www Mmm d HH:MM:SS YYYY」, UTC 로 읽는다) → 유닉스 초. 아니면 null(세포 `lstart_epoch`). */
+function lstartEpoch(s) {
+  const p = String(s).split(/\s+/).filter(Boolean);
+  if (p.length !== 5 || Buffer.byteLength(p[0]) !== 3) return null;
+  const mo = PROC_MONTHS.indexOf(p[1]);
+  if (mo < 0) return null;
+  const num = (x, lo, hi) => {
+    if (!/^[0-9]{1,4}$/.test(x)) return null;
+    const v = Number(x);
+    return v >= lo && v <= hi ? v : null;
+  };
+  const d = num(p[2], 1, 31);
+  const hms = p[3].split(':');
+  if (d === null || hms.length !== 3) return null;
+  const h = num(hms[0], 0, 23), mi = num(hms[1], 0, 59), se = num(hms[2], 0, 60), y = num(p[4], 1970, 9999);
+  if (h === null || mi === null || se === null || y === null) return null;
+  return Date.UTC(y, mo, d, h, mi, se) / 1000;
+}
+/** ISO 꼴(세포 `transcript::iso_epoch` 와 같은 너그러움 — 앞 19자만 본다). 못 읽으면 0. */
+function isoEpochLoose(s) {
+  if (s.length < 19 || s[4] !== '-' || s[7] !== '-' || (s[10] !== 'T' && s[10] !== ' ')) return 0;
+  const n = (a, z) => { const v = s.slice(a, z); return /^[+-]?[0-9]+$/.test(v) ? parseInt(v, 10) : 0; };
+  const y = n(0, 4), mo = n(5, 7);
+  if (y < 1970 || mo < 1 || mo > 12) return 0;
+  return Date.UTC(y, mo - 1, n(8, 10), n(11, 13), n(14, 16), n(17, 19)) / 1000;
+}
+/**
+ * 등록부 `procStart` → 유닉스 초(세포 `proc_start_epoch`). 하네스 2.1.290 은 `TZ=UTC ps -o lstart` 꼴로 적는다 — 「Tue Oct  6 04:41:55
+ * 2026」(2026-10-07 실측 13/13 이 그 pid 의 `TZ=UTC ps -o lstart=` 와 같은 글자). 꼴이 바뀌어도 흔한 둘(epoch 수 — 1e11 을 넘으면 ms,
+ * ISO-8601 `…Z`)은 받는다. 그 밖은 null — 로캘을 탄 ps 꼴(「2026년 10월  6일 화요일 …」)도 못 읽는 것으로 친다(세포와 같게).
+ */
+function procStartEpoch(v) {
+  if (typeof v === 'string') {
+    const l = lstartEpoch(v);
+    if (l !== null) return l;
+    const t = v.trim();
+    if (!/^[\x00-\x7F]*$/.test(t) || !t.endsWith('Z')) return null;
+    const e = isoEpochLoose(t);
+    return e > 0 ? e : null;
+  }
+  if (typeof v === 'number') {
+    const n = harnessInt(v);
+    if (n === null || n <= 0) return null;
+    return n > 100_000_000_000 ? Math.trunc(n / 1000) : n;
+  }
+  return null;
+}
+/** 등록부 JSON 한 개 → 줄(세포 `reg_row`). pid(1..2^31-1)·sessionId(uuid)가 없으면 null. procStart 는 absent · at · unreadable. */
+function harnessRowOf(d) {
+  if (!d || typeof d !== 'object' || Array.isArray(d)) return null;
+  const pid = harnessInt(d.pid);
+  if (pid === null || pid <= 0 || pid > 2147483647) return null;
+  if (typeof d.sessionId !== 'string' || !AUTO_UUID_RE.test(d.sessionId)) return null;
+  const text = (k) => (typeof d[k] === 'string' && d[k] !== '' ? d[k] : null);
+  const ps = d.procStart === undefined || d.procStart === null ? { kind: 'absent' }
+    : (() => { const t = procStartEpoch(d.procStart); return t === null ? { kind: 'unreadable' } : { kind: 'at', t }; })();
+  return { pid, session: d.sessionId.toLowerCase(), name: harnessNameClean(d.name), updatedAt: harnessInt(d.updatedAt) ?? 0,
+           procStart: ps, socket: text('messagingSocketPath'), domain: text('pidDomain') };
+}
+const HARNESS_FILE_MAX = 64 * 1024;
+/** 등록부 폴더의 줄들(살았든 죽었든 — 판정은 `harnessRowLive`). 폴더가 없으면 빈 목록. 차례는 (pid, updatedAt, session). */
+function harnessRowsIn(dir) {
+  let names;
+  try { names = fs.readdirSync(dir); } catch { return []; }
+  const rows = [];
+  for (const n of names) {
+    if (!/^[0-9]+\.json$/.test(n)) continue;             // `<pid>.json` 만
+    let d;
+    try {
+      const p = path.join(dir, n);
+      const st = fs.statSync(p);
+      if (!st.isFile() || st.size > HARNESS_FILE_MAX) continue;
+      const raw = fs.readFileSync(p);
+      if (raw.length > HARNESS_FILE_MAX) continue;         // 잰 뒤 읽기 전에 자랐다
+      d = JSON.parse(raw.toString('utf8'));
+    } catch { continue; }
+    const r = harnessRowOf(d);
+    if (r) rows.push(r);
+  }
+  return rows.sort((a, b) => (a.pid - b.pid) || (a.updatedAt - b.updatedAt) || (a.session < b.session ? -1 : a.session > b.session ? 1 : 0));
+}
+/** procStart 와 실제 시작 시각의 허용 차(초) — lstart 는 초에서 자르고 Linux 의 btime 도 초 단위라 1초가 흔들릴 수 있다(세포와 같은 값). */
+const PROC_START_SLACK_SECS = 2;
+/**
+ * 그 줄의 세션이 **지금 떠 있나**(위 머리말 · 세포 `row_life`) — 'live' · 'gone' · 못 잰 까닭('platform'·'domain'·'start').
+ * `probe` = { alive(pid), started(pid) → 초|null, domain, measurable }. measurable 이 거짓(Windows — 세포가 pid 를 못 잰다)이면 모든 줄이 'platform'.
+ * 칸이 없는 옛 probe(시험)는 잴 수 있는 것으로 친다.
+ */
+function harnessRowLife(r, probe) {
+  if (probe.measurable === false) return 'platform';
+  if (r.domain && r.domain !== probe.domain) return 'domain';   // 다른 pid 공간의 pid 는 이 기계의 프로세스 표 값이 아니다 — 못 잰다
+  if (!probe.alive(r.pid)) return 'gone';                       // 하네스가 끝내며 못 지운 줄 — 그 이름은 아무도 안 받는다
+  if (r.procStart.kind === 'absent') return 'live';             // 옛 하네스 줄 — 견줄 칸이 없다(kill 0 만)
+  if (r.procStart.kind !== 'at') return 'start';                // 꼴을 못 읽었다 — 대조를 못 하니 산 것으로 안 친다(끝난 것도 아니다)
+  const s = probe.started(r.pid);
+  if (s === null || s === undefined) return 'start';            // 시작 시각을 못 쟀다(ps 실패 · 시간 초과)
+  return Math.abs(s - r.procStart.t) <= PROC_START_SLACK_SECS ? 'live' : 'gone';
+}
+/** 떠 있다고 **재서** 나왔나(세포 `row_live`). */
+function harnessRowLive(r, probe) { return harnessRowLife(r, probe) === 'live'; }
+/** 고르는 열쇠 — procStart(가장 나중에 뜬 프로세스), 같으면 pid(세포 `pick_key` · 칸이 없는 옛 줄은 가장 이르다). a ≥ b 면 참. */
+function harnessPickGe(a, b) {
+  const ta = a.procStart.kind === 'at' ? a.procStart.t : -Infinity;
+  const tb = b.procStart.kind === 'at' ? b.procStart.t : -Infinity;
+  return ta > tb || (ta === tb && a.pid >= b.pid);
+}
+/**
+ * 조건에 맞는 줄들을 잰다(세포 `lookup`) — `{ row, lives, blind }`: 산 줄 중 고른 것 · 산 줄 전부 · 못 잰 줄 중 고른 것과 까닭(`{ why, row }`).
+ * 같은 열쇠면 나중 줄 — Rust 는 `>=` 로 같은 최댓값 중 마지막을 고르고, 두 자 모두 (pid, updatedAt, session) 차례로 걷는다.
+ */
+function harnessLookup(rows, probe, pred) {
+  const out = { row: null, lives: [], blind: null };
+  for (const r of rows) {
+    if (!pred(r)) continue;
+    const life = harnessRowLife(r, probe);
+    if (life === 'live') {
+      out.lives.push(r);
+      if (!out.row || harnessPickGe(r, out.row)) out.row = r;
+    } else if (life !== 'gone') {
+      if (!out.blind || harnessPickGe(r, out.blind.row)) out.blind = { why: life, row: r };
+    }
+  }
+  return out;
+}
+/** 조건에 맞는 **산** 줄 중 고른 것(`harnessLookup` 의 row). 없으면 null. */
+function harnessLiveRow(rows, probe, pred) {
+  return harnessLookup(rows, probe, pred).row;
+}
+/** 나를 찾는 프로세스 열쇠(세포 `SelfKeys::from_vars`) — 빈 값은 없는 것. 소켓은 글자 그대로, CLAUDE_PID 는 다듬어 숫자 규칙, 세션 id 는 uuid 꼴만(소문자). */
+function harnessSelfKeys(env) {
+  const get = (k) => { const v = env?.[k]; return typeof v === 'string' && v.trim() !== '' ? v : null; };
+  const p = get('CLAUDE_PID');
+  const pid = p === null ? null : harnessInt(p.trim());
+  const sid = get('CLAUDE_CODE_SESSION_ID');
+  const session = sid === null ? null : sid.trim().toLowerCase();
+  return { socket: get('CLAUDE_CODE_MESSAGING_SOCKET'),
+           pid: pid !== null && pid > 0 && pid <= 2147483647 ? pid : null,
+           session: session && AUTO_UUID_RE.test(session) ? session : null };
+}
+/**
+ * 등록부의 **내 줄**을 찾는다(세포 `self_lookup`) — 열쇠 차례: 소켓 → CLAUDE_PID → 세션 id. 앞 열쇠가 **산 줄이나 못 잰 줄**을 찾으면 뒤 열쇠는
+ * 안 본다(못 잰 줄이 내 줄일 수 있는데 세션 id 로 넘어가면 같은 대화를 띄운 **다른 창**을 나로 고른다 — SEC-1). 끝난 줄만 찾았으면 다음 열쇠로.
+ * `{ by: 'socket'|'pid'|'session', lk }` 또는 null.
+ */
+function harnessSelfLookup(rows, keys, probe) {
+  const tries = [['socket', keys.socket, (r) => r.socket === keys.socket], ['pid', keys.pid, (r) => r.pid === keys.pid],
+                 ['session', keys.session, (r) => r.session === keys.session]];
+  for (const [by, key, pred] of tries) {
+    if (key === null || key === undefined) continue;
+    const lk = harnessLookup(rows, probe, pred);
+    if (lk.row || lk.blind) return { by, lk };
+  }
+  return null;
+}
+/** 등록부의 **내 산 줄**(세포 `self_row` — `harnessSelfLookup` 이 산 줄을 찾았을 때만). */
+function harnessSelfRow(rows, keys, probe) {
+  return harnessSelfLookup(rows, keys, probe)?.lk.row ?? null;
+}
+const procStartSeen = new Map();   // pid → { at, v } — 같은 pid 를 1분 안에 다시 안 잰다(ps 한 번이 수 ms)
+/**
+ * 그 pid 프로세스가 **시작한 때**(유닉스 초 · 세포 `proc_started_at` 과 같은 값). 못 재면 null.
+ * · macOS: `ps -o lstart=` 를 UTC·C 로캘로 — 세포가 sysctl 로 읽는 p_starttime 과 같은 초다(2026-10-07 실측: pid 32054 →
+ *   1791261715 = 「Tue Oct  6 04:41:55 2026」). 로캘을 물려받으면 macOS ps 는 날짜를 한국어로 써서(LANG=ko_KR.UTF-8 실측) 못 읽는다.
+ * · Linux: `/proc/<pid>/stat` 의 22번째 칸(부팅 뒤 틱) ÷ 100 + `/proc/stat` 의 btime — 못 읽으면 ps. ⚠ USER_HZ 를 100 으로 둔다
+ *   (Linux 의 사용자 공간 틱은 아키텍처와 상관없이 100 이다 — 세포는 sysconf 로 묻는다). 이 기계에서는 못 돌렸다.
+ * · 그 밖(Windows): null — procStart 가 있는 줄은 산 것으로 안 친다(세포도 같다).
+ */
+function procStartOf(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  const c = procStartSeen.get(pid);
+  if (c && Date.now() - c.at < 60_000) return c.v;
+  let v = null;
+  try {
+    if (process.platform === 'linux') {
+      const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+      const ticks = Number(stat.slice(stat.lastIndexOf(')') + 1).trim().split(/\s+/)[19]);
+      const btime = Number((/^btime (\d+)$/m.exec(fs.readFileSync('/proc/stat', 'utf8')) || [])[1]);
+      if (Number.isFinite(ticks) && Number.isFinite(btime) && btime > 0) v = btime + Math.floor(ticks / 100);
+    }
+  } catch { /* 아래 ps 로 */ }
+  if (v === null && (process.platform === 'darwin' || process.platform === 'linux')) {
+    try {
+      const r = spawnSync(fs.existsSync('/bin/ps') ? '/bin/ps' : 'ps', ['-o', 'lstart=', '-p', String(pid)],
+        { encoding: 'utf8', timeout: 1000, env: { ...process.env, TZ: 'UTC', LC_ALL: 'C', LANG: 'C' } });
+      if (!r.error && r.status === 0) v = lstartEpoch(r.stdout.trim());
+    } catch { /* 못 잰다 */ }
+  }
+  // ⚠ 못 잰 답(null)은 기억하지 않는다(2026-10-07 검증 SEC-5). 부하에 ps 가 1초를 넘기면 null 이 60초 동안 남아, 그동안 이 프로세스의 줄이
+  //   「산 줄 없음」이 되고 서버 이름이 비워졌다(남이 그 이름을 가져갈 틈). 잰 값은 pid 가 살아 있는 동안 바뀌지 않으니 기억해도 된다.
+  if (v !== null) procStartSeen.set(pid, { at: Date.now(), v });
+  return v;
+}
+/**
+ * pidDomain 짓기(세포 `pid_domain_of` 와 한 벌 — 공동 표 cell/tests/fixtures/registry/cases.json 의 pid_domain). 하네스 2.1.291 `oas` 의 꼴:
+ * macOS `darwin` · Linux·WSL `linux:<machine-id 다듬음>:<readlink /proc/self/ns/pid>`(못 읽으면 빈 글) · Windows `win32:<호스트 이름 소문자>`.
+ * `platform` 은 Node `process.platform` 낱말.
+ */
+function pidDomainOf(platform, machineId, pidNs, host) {
+  if (platform === 'linux') return `linux:${typeof machineId === 'string' ? machineId.trim() : ''}:${typeof pidNs === 'string' ? pidNs : ''}`;
+  if (platform === 'win32') return `win32:${String(host ?? '').toLowerCase()}`;
+  return String(platform);
+}
+let pidDomainMemo = null;
+/**
+ * 이 판의 pidDomain — **하네스가 등록부에 적는 값과 같은 꼴**(한 번 재고 기억한다 · 세포 `pid_domain`).
+ * ⚠ 전에는 `process.platform`(맨 'linux')과 견줘, Linux·WSL 에서는 등록부의 모든 줄이 「떠 있지 않음」이었다 — MCP 는 그 판에서 등록부 이름을
+ *   영영 못 댔고, 이름이 서는 길은 「뜬 뒤 ListAgents」 하나뿐이었다(검증 F1 — 이 맥의 줄은 다 'darwin' 이라 못 봤다). Windows 의 호스트 이름은
+ *   하네스와 같은 `os.hostname()` 이다(세포는 env COMPUTERNAME 으로 어림 — 그 판은 어차피 못 잰다).
+ */
+function harnessPidDomain() {
+  if (pidDomainMemo === null) {
+    const p = process.platform;
+    let mid = null, ns = null, host = null;
+    if (p === 'linux') {
+      try { mid = fs.readFileSync('/etc/machine-id', 'utf8'); } catch { mid = null; }
+      try { ns = fs.readlinkSync('/proc/self/ns/pid'); } catch { ns = null; }
+    }
+    if (p === 'win32') { try { host = os.hostname(); } catch { host = null; } }
+    pidDomainMemo = pidDomainOf(p, mid, ns, host);
+  }
+  return pidDomainMemo;
+}
+/**
+ * 이 기계의 프로세스 표 — 시험은 픽스처의 probe 를 대신 준다. pidDomain 은 하네스와 같은 꼴(`harnessPidDomain`).
+ * ⚠ Windows 에서는 **못 잰다**(measurable 거짓) — 세포의 pid_alive 가 unix 밖에서는 없어서(world.rs) 같은 줄을 두 자가 다르게 부르지 않게
+ *   맞춘다(그 판에는 procStart 를 잴 ps 도 없다). 「끝났다」가 아니라 「못 잰다」다(F5). 이름이 없으면 uuid 로 닿는다.
+ */
+function harnessProbe() {
+  return { alive: pidAlive, started: procStartOf, domain: harnessPidDomain(), measurable: process.platform !== 'win32' };
+}
+/** epoch 초 → `2026-10-07T03:12:45Z`(세포 `iso_utc` 와 같은 꼴 — 밀리초 없음). */
+function isoUtc(secs) {
+  return new Date(secs * 1000).toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+/**
+ * 계약 1 의 JSON 한 줄과 같은 꼴(세포 `whereabouts_of`) — `{ session, name, live, pid, source, stale_name, checked_at, matched_by, live_rows,
+ *   measured }`(칸 차례도 같다 — 뒤 셋은 2026-10-07 덧붙인 칸이고 기본값은 「열쇠 모름 · 산 줄이면 1줄 · 재서 나온 답」, `harnessWithRows` 가 채운다).
+ *   산 줄이 있으면 source 'registry' · name 은 등록부 이름(꼴 밖이면 null — 그래도 떠 있다) · stale_name 은 전사의 마지막 자기소개가
+ *   지금 이름과 **다를 때만**(다시 뜨며 바뀐 옛 이름).
+ *   없으면 name·pid 는 null 이고, 전사의 마지막 자기소개가 있으면 source 'transcript' · stale_name 에 그 이름(지금 이름이 아니다).
+ * `introName` 은 이름 꼴(`harnessNameClean`)을 다시 지난다 — 시험이 주는 글도 세포의 이름 꼴로만 받는다.
+ */
+function harnessWhereaboutsOf(session, row, introName, now) {
+  const checked_at = isoUtc(now);
+  const stale = harnessNameClean(introName);
+  if (row) {
+    return { session, name: row.name, live: true, pid: row.pid, source: 'registry',
+             stale_name: stale !== null && stale !== row.name ? stale : null, checked_at, matched_by: null, live_rows: 1, measured: true };
+  }
+  return { session, name: null, live: false, pid: null, source: stale !== null ? 'transcript' : 'none', stale_name: stale, checked_at,
+           matched_by: null, live_rows: 0, measured: true };
+}
+/**
+ * 답에 덧붙인 칸 셋을 채운다(세포 `with_rows`) — 찾은 열쇠(matched_by) · 그 세션의 산 줄 수(live_rows — `same` 은 같은 세션 uuid 로 잰 판정) ·
+ * 재서 나온 답인가(measured — `blind` 는 못 잰 까닭, 떠 있으면 무시).
+ */
+function harnessWithRows(w, same, blind, by) {
+  w.matched_by = by ?? null;
+  w.live_rows = w.live ? Math.max(1, same.lives.length) : 0;
+  w.measured = w.live ? true : !blind;
+  // 창 여럿이 한 전사에 함께 쓰면 마지막 자기소개가 다른 창의 **지금** 이름일 수 있다 — 옛 이름이 아니다(세포 `with_rows` 와 같다).
+  if (w.live && w.stale_name !== null && same.lives.some((r) => r.name === w.stale_name)) w.stale_name = null;
+  return w;
+}
+/**
+ * `gcell agents --session <uuid>` 의 사본(세포 `session_whereabouts`) — 그 세션의 산 줄 중 고른 것 · 옛 이름은 그 세션 본 전사에서.
+ * MCP 는 /clear 앞 대화의 uuid 가 다른 창에 떠 있는지 볼 때 이 판정(harnessLookup)을 쓴다. 이름 관문이 세포 `--session` 과 같은 픽스처에
+ * 대 본다 — 몸은 `--self` 와 같은 블록이다. `intro` = 세션 uuid → 마지막 자기소개 이름(없으면 null).
+ */
+function harnessWhereabouts(sid, rows, probe, intro, now) {
+  const s = String(sid ?? '').toLowerCase();
+  const lk = harnessLookup(rows, probe, (r) => r.session === s);
+  return harnessWithRows(harnessWhereaboutsOf(s, lk.row, intro(s), now), lk, lk.blind ? lk.blind.why : null, null);
+}
+/**
+ * `gcell agents --self` 의 사본(세포 `self_whereabouts`) — 프로세스 열쇠로 내 줄을 찾고, 옛 이름은 **그 줄의 세션** 본 전사에서
+ * (/clear 뒤에는 env 의 세션 id 가 아니라 등록부 줄의 세션이 나다). 열쇠가 못 잰 줄만 찾았으면 이름 칸은 비고 measured 거짓 — 세션은
+ * 그 줄의 세션(이 프로세스의 열쇠로 찾은 줄이다). 아무것도 못 찾았으면 env 의 세션 id 로 옛 이름만 — 이름 칸은 빈다.
+ */
+function harnessSelfWhereabouts(rows, keys, probe, intro, now) {
+  const f = harnessSelfLookup(rows, keys, probe);
+  if (f?.lk.row) {
+    const r = f.lk.row;
+    const same = harnessLookup(rows, probe, (x) => x.session === r.session);
+    return harnessWithRows(harnessWhereaboutsOf(r.session, r, intro(r.session), now), same, null, f.by);
+  }
+  if (f?.lk.blind) {
+    const s = f.lk.blind.row.session;
+    return harnessWithRows(harnessWhereaboutsOf(s, null, intro(s), now), f.lk, f.lk.blind.why, f.by);
+  }
+  return harnessWhereaboutsOf(keys.session, null, keys.session ? intro(keys.session) : null, now);
+}
+/**
+ * 이 프로세스의 지금 주소 — JS 사본(세포가 없거나 못 알아들을 때 `selfAddress` 가 쓴다). 세포 `gcell agents --self --json` 과 **같은 답**이다:
+ * 이름 관문(cell/tests/fixtures/agent-names/ · smoke 3-4)이 두 자에 같은 경우를 먹여 맞댄다.
+ * ⚠ 전에는 산 줄이 있으면 전사를 안 읽어 stale_name 이 늘 null 이었다(「참고 칸이라 253MB 를 거슬러 읽는 값을 안 낸다」). 같은 입력에 세포와
+ *   다른 답이라 관문이 그 자리에서 빨갰다(픽스처 02-restarted). 이제 읽는다 — 값: 자기소개가 끝 가까이 있으면 조각 하나, 없으면 한 번 끝까지
+ *   (실측 세포 101MB 0.10초), 그 뒤로는 `introOfFile` 의 한 칸 캐시가 늘어난 부분만 읽는다(등록은 60초에 한 번 · 세포가 있으면 이 길을 안 탄다).
+ */
+function selfAddressJs(env = process.env, probe = harnessProbe(), intro = (sid) => claudeIntroName(sid, env), now = Math.floor(Date.now() / 1000)) {
+  return harnessSelfWhereabouts(harnessRowsIn(harnessSessionsDir(env)), harnessSelfKeys(env), probe, intro, now);
+}
+
+/*
+ * ── 세포에게 묻는다 — `gcell agents --self --json` (계약 1·2) ───────────────────────────────────────────────────
+ * 세포 경로는 기존 규칙(`cellCheck` — GENETICS_CELL_BIN · 꾸러미 지문 · 설치본) 그대로다. 1초 안에 계약 꼴의 JSON 한 줄이 아니면 JS 사본으로.
+ * ⚠ **기다리되 막지 않는다** — execFile 이라 그 1초 동안에도 다른 요청이 돈다(spawnSync 였으면 도구 응답이 통째로 선다).
+ * ⚠ 옛 세포(--self 를 모르는 판 — 설치본 f0b68dc)는 모르는 깃발을 무시하고 `agents` 를 통째로 돈다. 임시 폴더에서도 전사를 다 걸어
+ *   15.2초가 걸렸다(2026-10-07 실측 — 저장소를 못 찾으면 전사 폴더 전부를 걷는다, world.rs transcript_dirs_for). 그래서 `--since 0` 을
+ *   함께 준다: 옛 세포는 0분 창으로 곧바로 「최근 0분 안에 … 없다」 한 줄을 내고(0.18초 실측), 그 글은 계약 꼴이 아니니 「못 알아듣는다」로
+ *   적힌다. 새 세포는 `--self` 를 `--since` 보다 먼저 가르고 돌아가 그 깃발을 안 본다(cmd_agents). cwd 는 임시 폴더 — `--self` 는 저장소가
+ *   아니라 프로세스 열쇠로 찾는다.
+ * ⚠ 못 알아들은 세포는 그 바이너리(경로·크기·mtime)가 바뀌기 전엔 다시 안 묻는다 — 판올림(ensureCellOnBoot)이 갈아 끼우면 다시 묻는다.
+ *   시간 초과는 「느리다」일 수 있어 5분만 쉰다.
+ */
+const CELL_SELF_TIMEOUT_MS = 1000;
+let cellSelfDeaf = '';          // --self 를 못 알아들은 세포의 지문
+let cellSelfRestUntil = 0;      // 시간 초과 뒤 쉬는 끝
+function cellPrint(bin) {
+  try { const st = fs.statSync(bin); return `${bin}\0${st.size}\0${st.mtimeMs}`; } catch { return ''; }
+}
+/**
+ * 세포가 낸 글 → 계약 1 의 꼴, 아니면 null. **모양을 제한한다** — 지문 검사가 뚫려도 문맥에 이상한 글자가 안 들어가게(cellClean 과 같은 방어).
+ * 숫자 칸(pid)은 등록부와 같이 숫자 문자열도 받는다.
+ */
+function cellSelfParse(stdout) {
+  const t = String(stdout ?? '').trim();
+  if (!t.startsWith('{') || t.includes('\n') || t.length > 4096) return null;
+  let d;
+  try { d = JSON.parse(t); } catch { return null; }
+  if (!d || typeof d !== 'object' || Array.isArray(d)) return null;
+  if (!['registry', 'transcript', 'none'].includes(d.source) || typeof d.live !== 'boolean') return null;
+  if (d.name !== null && d.name !== undefined && !harnessNameOk(d.name)) return null;
+  const pid = d.pid === null || d.pid === undefined ? null : harnessInt(d.pid);
+  // 덧붙인 칸(2026-10-07) — 모르는 값이면 「모른다」 쪽으로: 열쇠 null(이름을 제 것으로 안 댄다) · 산 줄 수는 산가에서 · measured 는 칸이 있을 때만 거짓.
+  const rows = harnessInt(d.live_rows);
+  return {
+    session: typeof d.session === 'string' && AUTO_UUID_RE.test(d.session) ? d.session.toLowerCase() : null,
+    name: d.name ?? null,
+    live: d.live,
+    pid: pid !== null && pid > 0 ? pid : null,
+    source: d.source,
+    stale_name: harnessNameOk(d.stale_name) ? d.stale_name : null,
+    checked_at: typeof d.checked_at === 'string' ? cellClean(d.checked_at).slice(0, 40) : '',
+    matched_by: ['socket', 'pid', 'session'].includes(d.matched_by) ? d.matched_by : null,
+    live_rows: rows !== null && rows >= 0 && rows < 1000 ? rows : (d.live ? 1 : 0),
+    measured: d.measured !== false,
+  };
+}
+/** 세포의 답 — `{ ok: true, v }` 또는 `{ ok: false, why }`(why: none·deaf·rest·timeout·bad·spawn). */
+function cellSelf() {
+  const { bin } = cellCheck();
+  if (!bin) return Promise.resolve({ ok: false, why: 'none' });
+  const print = cellPrint(bin);
+  if (print && print === cellSelfDeaf) return Promise.resolve({ ok: false, why: 'deaf' });
+  if (Date.now() < cellSelfRestUntil) return Promise.resolve({ ok: false, why: 'rest' });
+  return new Promise((resolve) => {
+    let done = false;
+    let timer = null;
+    const finish = (v) => { if (done) return; done = true; if (timer) clearTimeout(timer); resolve(v); };
+    let child;
+    try {
+      child = execFile(bin, ['agents', '--self', '--json', '--since', '0'],
+        { encoding: 'utf8', maxBuffer: 64 * 1024, cwd: os.tmpdir(), windowsHide: true },
+        (err, stdout) => {
+          /*
+           * ⚠ 실행 자체가 안 된 것(EAGAIN·ENOMEM·EACCES·ENOENT … — err.code 가 글)은 「못 알아들었다」가 아니다(2026-10-07 검증 SEC-5).
+           *   전에는 이것도 deaf 로 적어, fork 한 번 실패에 그 세포를 판올림 전까지 다시 안 물었다. 잠깐(30초) 쉬고 다시 묻는다.
+           */
+          if (err && typeof err.code === 'string' && err.code !== 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+            if (!done) cellSelfRestUntil = Date.now() + 30_000;
+            finish({ ok: false, why: 'spawn' });
+            return;
+          }
+          // 끝난 코드가 0 이 아니어도 계약 꼴의 한 줄이면 받는다 — 판정은 글이 한다(못 알아들은 판은 글이 계약 꼴이 아니다).
+          const v = err?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' ? null : cellSelfParse(stdout);
+          if (!v) { if (!done) cellSelfDeaf = print; finish({ ok: false, why: 'bad' }); return; }
+          finish({ ok: true, v });
+        });
+    } catch { cellSelfRestUntil = Date.now() + 30_000; finish({ ok: false, why: 'spawn' }); return; }
     /*
-     * Cursor 활성 대화 — 전사도 ListAgents 도 없다. 이름은 별칭일 뿐 열쇠는 uuid 이므로
-     * (mail 레일 계약), 출처가 읽히는 결정적 별칭을 낸다: cursor-<uuid 앞 2자>.
+     * 1초는 **자리를 비우는 시각**이다 — execFile 의 timeout 은 죽인 뒤에도 그 자식이 물려준 stdout 이 닫혀야 답을 준다(손자 프로세스가
+     * 파이프를 쥐면 그만큼 늦는다). 그래서 따로 잰다: 넘으면 죽이고 곧바로 JS 사본으로 간다.
      */
-    if (uuid === cursorActiveComposer() || process.env.CURSOR_CONVERSATION_ID === uuid) {
-      return cursorAliasOf(uuid);
+    timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch { /* 이미 끝났다 */ }
+      cellSelfRestUntil = Date.now() + 5 * 60_000;
+      finish({ ok: false, why: 'timeout' });
+    }, CELL_SELF_TIMEOUT_MS);
+    timer.unref?.();
+  });
+}
+/** 이 프로세스의 지금 주소(계약 1 의 꼴 + `via`) — 세포가 먼저, 못 하면 JS 사본. **부를 때마다 새로 푼다**(이름은 보내기 직전에). */
+async function selfAddress() {
+  const c = await cellSelf();
+  if (c.ok) return { ...c.v, via: 'cell' };
+  return { ...selfAddressJs(), via: 'js', cell: c.why };
+}
+
+/**
+ * 전사의 `[from, size)` 에서 **마지막** 자기소개를 끝에서부터 거슬러 찾는다. `{ name, end, at }` — `end` 는 마지막 개행 바로 뒤
+ * (쓰는 중인 반쪽 줄은 다음 차례에 그 자리부터 다시 읽는다), `at` 은 그 레코드의 timestamp(ms · 없거나 못 읽으면 0).
+ * `at` 은 「그 자기소개를 지금 프로세스가 냈나」를 가르는 데 쓴다(`myAgentName` ②) — 0 이면 가를 수 없으니 지금 것으로 안 친다.
+ * ⚠ 전에는 읽을 양이 64MB 이상이면 **통째로 건너뛰었다**(전사 최대 7MB 가정). 그런데 그림이 base64 로 실려 전사가 253MB
+ *   까지 간다(2026-10-07 실측 — 이 MCP 를 띄운 세션). 첫 읽기가 늘 건너뛰어져 이름이 영영 「없음」이 됐고, mail 이 「이 세션에는
+ *   말 걸 수 있는 이름이 없다」로 거절했다 — ListAgents 를 이미 부른 뒤였는데도. 마지막 것만 필요하니 끝에서 거스르면 된다.
+ * ⚠ 줄 고르기는 세포 `last_intro_in` 과 **글자 하나까지** 같다(이름 관문 2026-10-07 — 픽스처 11-giant-line): 1MiB 를 넘는 줄은 자기소개로
+ *   안 치고 이어 붙이지도 않는다. 전에는 그 줄을 읽어(세포는 건너뛰어) 같은 전사에 두 자가 다른 옛 이름을 냈고, 큰 줄을 조각마다 다시
+ *   이어 붙여 복사가 제곱으로 늘었다. 조각은 쌓아 두었다가 줄이 온전해질 때 한 번 잇는다. 맨 끝의 반쪽 줄은 안 쌓는다(어차피 안 읽는다).
+ */
+function lastIntroInRange(fd, from, size, chunk = 8 * 1024 * 1024) {
+  chunk = Math.max(1, chunk);
+  let pos = size;
+  let end = -1;
+  let carry = [];          // 뒤에서 이어지는 줄의 조각들(파일에서 뒤쪽 조각이 앞에) — 그 줄의 머리는 아직 안 읽은 앞쪽에 있다
+  let carryLen = 0;
+  let skipping = true;     // 지금 거슬러 가는 줄을 버리는 중인가 — 처음엔 맨 끝의 쓰는 중인 반쪽 줄, 그 뒤엔 상한을 넘은 큰 줄
+  const found = (h) => ({ name: h.name, end, at: h.at });
+  while (pos > from) {
+    const start = Math.max(from, pos - chunk);
+    const buf = Buffer.allocUnsafe(pos - start);
+    fs.readSync(fd, buf, 0, buf.length, start);
+    pos = start;
+    const lastNl = buf.lastIndexOf(0x0a);
+    if (lastNl < 0) {                                   // 조각 전체가 한 줄의 가운데
+      if (!skipping) {
+        carry.push(buf);
+        carryLen += buf.length;
+        if (carryLen > INTRO_LINE_MAX) { carry = []; carryLen = 0; skipping = true; }
+      }
+      continue;
     }
-    return null;
+    if (end < 0) end = start + lastNl + 1;              // 마지막 개행 바로 뒤 — 다음 이어 읽기의 자리
+    // ① 마지막 개행 뒤 + 뒤에서 이어지던 조각들 = 이제 머리까지 다 읽은 한 줄
+    if (!skipping && buf.length - (lastNl + 1) + carryLen <= INTRO_LINE_MAX) {
+      const h = introOfLine(Buffer.concat([buf.subarray(lastNl + 1), ...carry.reverse()]));
+      if (h) return found(h);
+    }
+    carry = [];
+    carryLen = 0;
+    skipping = false;
+    // ② 이 조각 안의 온전한 줄들 — 끝에서부터
+    const firstNl = buf.indexOf(0x0a);
+    const h2 = introInLines(buf.subarray(firstNl + 1, lastNl + 1));
+    if (h2) return found(h2);
+    // ③ 맨 앞 줄(첫 개행까지) — 출발점(파일 맨 앞 · 이어 읽기의 자리)이면 온전하고, 아니면 머리가 더 앞 조각에 있다
+    const head = buf.subarray(0, firstNl + 1);
+    if (start === from) {
+      const h3 = introInLines(head);
+      if (h3) return found(h3);
+    } else if (head.length > INTRO_LINE_MAX) {
+      skipping = true;
+    } else {
+      carry.push(head);
+      carryLen = head.length;
+    }
+  }
+  // 출발점의 첫 줄이 조각보다 길었다 — 그 머리가 출발점이다
+  if (!skipping && carry.length) {
+    const h = introOfLine(Buffer.concat(carry.reverse()));
+    if (h) return found(h);
+  }
+  return { name: null, end: end < 0 ? from : end, at: 0 };
+}
+/** 자기소개 레코드 한 줄의 상한(세포 `INTRO_LINE_MAX`) — 실제 자기소개 줄은 2.7~4.5KB(2026-10-07 실측 35건). 더 긴 줄(그림 base64)은 자기소개가 아니다. */
+const INTRO_LINE_MAX = 1 << 20;
+/** 한 줄(바이트)이 하네스가 낸 자기소개 레코드면 `{ name, at }`(세포 `intro_of_line` — 상한 · 머리 글자 · 레코드 모양 차례 그대로). */
+function introOfLine(line) {
+  if (!line.length || line.length > INTRO_LINE_MAX || !line.includes(INTRO_HEAD)) return null;
+  const s = line.toString('utf8');                     // 깨진 바이트는 U+FFFD — 세포의 from_utf8_lossy 와 같다
+  const name = introNameOf(s);
+  if (!name) return null;
+  let at = 0;
+  try { at = Date.parse(JSON.parse(s).timestamp) || 0; } catch { /* 시각이 없으면 0 */ }
+  return { name, at };
+}
+/** 개행으로 끝나는 줄 묶음에서 **끝에서부터** 자기소개를 찾는다(세포 `intro_in_lines`). 줄은 바이트로 자른다 — 상한도 바이트다. */
+function introInLines(body) {
+  if (!body.includes(INTRO_HEAD)) return null;          // 값싼 검사로 먼저 거른다
+  let e = body.length;
+  if (e > 0 && body[e - 1] === 0x0a) e--;
+  for (;;) {
+    const s = e > 0 ? body.lastIndexOf(0x0a, e - 1) + 1 : 0;
+    const h = introOfLine(body.subarray(s, e));
+    if (h) return h;
+    if (s === 0) return null;
+    e = s - 1;
   }
+}
+
+let nameCache = null;          // { file, size, name, at }
+/** 세션 uuid 의 전사(findTranscript — Codex·Cursor 포함)의 마지막 자기소개. 전사가 없으면 null. `myAgentName` 이 쓴다(Cursor 판정에 file 이 든다). */
+function introOf(uuid) {
+  const f = transcriptOf(uuid);
+  return f ? introOfFile(f) : null;
+}
+/**
+ * 세션 uuid → 그 세션 **본 전사**(세포의 규칙 — 설정 폴더 먼저 · `claudeTranscriptIn`)의 마지막 자기소개 이름. 없으면 null.
+ * 세포 `claude_transcript_of` + `agent_name_of` 의 사본 — `selfAddressJs` 의 옛 이름 칸이 이것을 쓴다(이름 관문).
+ */
+function claudeIntroName(sid, env = process.env) {
+  const f = claudeTranscriptIn(claudeProjectBases(env), sid);
+  return f ? (introOfFile(f)?.name ?? null) : null;
+}
+/** 전사 파일 하나의 마지막 자기소개 `{ name, at, file }`(name 없으면 null · at = 그 레코드의 timestamp ms). 못 읽으면 null. 늘어난 부분만 다시 읽는다(한 칸 캐시). */
+function introOfFile(f) {
   let st;
   try { st = fs.statSync(f); } catch { return null; }
-  if (nameCache?.file === f && nameCache.size === st.size) return nameCache.name;
+  if (nameCache?.file === f && nameCache.size === st.size) return { name: nameCache.name, at: nameCache.at, file: f };
   const from = (nameCache?.file === f && st.size > nameCache.size) ? nameCache.size : 0;
-  let found = (from > 0 ? nameCache.name : null);
+  let found = from > 0 ? nameCache.name : null;
+  let at = from > 0 ? nameCache.at : 0;
+  let end = from;
   try {
     const fd = fs.openSync(f, 'r');
     try {
-      const len = st.size - from;
-      if (len > 0 && len < 64 * 1024 * 1024) {
-        const buf = Buffer.allocUnsafe(len);
-        fs.readSync(fd, buf, 0, len, from);
-        const txt = buf.toString('utf8');
-        // 줄 단위 — 마지막 것이 이긴다(옛 이름은 죽은 주소다).
-        // ⚠ 쓰는 중인 마지막 줄(개행 없음)은 이번에 안 읽고 다음에 그 자리부터 다시 읽는다 —
-        //   캐시 크기를 마지막 개행까지만 전진시킨다. 안 그러면 잘린 줄이 영영 사라진다.
-        const cut = txt.lastIndexOf('\n');
-        const whole = cut >= 0 ? txt.slice(0, cut + 1) : '';
-        for (const line of whole.split('\n')) {
-          const n = introNameOf(line);
-          if (n) found = n;
-        }
-        if (!found && (isCursorTranscript(f) || uuid === cursorActiveComposer()
-            || process.env.CURSOR_CONVERSATION_ID === uuid)) {
-          found = cursorAliasOf(uuid);
-        }
-        nameCache = { file: f, size: from + Buffer.byteLength(whole, 'utf8'), name: found };
-        return found;
-      }
+      // 마지막 것이 이긴다(옛 이름은 죽은 주소다) — 그래서 끝에서 거슬러 첫 자기소개에서 멈춘다(크기 상한 없음).
+      // ⚠ 쓰는 중인 마지막 줄(개행 없음)은 이번에 안 읽고 다음에 그 자리부터 다시 읽는다(`end` 가 마지막 개행 바로 뒤).
+      const r = lastIntroInRange(fd, from, st.size);
+      if (r.name) { found = r.name; at = r.at || 0; }
+      end = r.end;
     } finally { fs.closeSync(fd); }
   } catch { /* 못 읽으면 이름이 없는 것이지 고장이 아니다 */ }
-  if (!found && (isCursorTranscript(f) || uuid === cursorActiveComposer()
-      || process.env.CURSOR_CONVERSATION_ID === uuid)) {
-    found = cursorAliasOf(uuid);
+  nameCache = { file: f, size: end, name: found, at };
+  return { name: found, at, file: f };
+}
+
+/** 이 MCP 프로세스가 뜬 때(ms) — 하네스가 띄우므로 그 claude 프로세스보다 늦다. 그 뒤에 적힌 자기소개는 지금 프로세스가 낸 것이다. */
+const BOOT_MS = Math.floor(performance.timeOrigin);
+
+/**
+ * 서버 메일 주소록이 받는 이름인가 — 서버 `mail_name_ok`(www/portal/lib/mail.php)와 같은 규칙: 1~60자 · 공백류·제어문자·[ ] → < > 없음 ·
+ * **이름 없는 세션의 발신 표시 꼴(uuid 앞 8자 — 16진 8자)과 uuid 꼴이 아니다**(2026-10-07 검증 SEC-3: 남이 그 꼴을 이름으로 대면 이름 없는
+ * 세션과 머리 줄이 같아져 사칭이 되고, 그 표시로 한 답장이 사칭한 쪽으로 풀렸다).
+ */
+function mailNameOk(s) {
+  return typeof s === 'string' && s !== '' && [...s].length <= 60
+    && !/[\s\u0000-\u001F\u007F-\u009F\u2028\u2029[\]→<>]/u.test(s)
+    && !/^[0-9a-f]{8}$/i.test(s) && !/^[0-9a-f-]{36}$/i.test(s);
+}
+
+/** ①로 확인한 이 프로세스의 마지막 이름(이 MCP 프로세스 안에서만) — ④가 쓴다. */
+const mailNameSeen = { session: '', name: '' };
+
+/**
+ * 서버 주소록에 댈 이름과 이 프로세스의 지금 메일 주소 — `{ name, why, addr, cur }`. name '' 은 「이름 없이 댄다」(받기는 된다 · 보낼 때
+ * 발신 표시는 uuid 앞 8자).
+ *   cur — 이 프로세스의 지금 세션 uuid. 세포(또는 JS 사본)가 **소켓 열쇠로** 찾은 산 줄의 세션이다 — 하네스가 이 MCP 에게만 준 소켓이니 그
+ *         줄이 이 프로세스다. `/clear` 뒤에는 env 의 세션 id(mine — 뜰 때 값)와 다르다: 하네스는 /clear 에 등록부 줄의 sessionId 만 바꾼다
+ *         (검증 F2·SEC-7). 소켓으로 못 찾았으면 mine.
+ * 대는 이름은 **지금 이 프로세스의 이름이라고 확인된 것**뿐이다:
+ *   ① 등록부의 산 줄 — 그 줄을 **이 프로세스의 열쇠**로 찾았을 때만: 소켓이거나, 그 줄의 세션이 mine 이다. CLAUDE_PID 로만 찾은 남의 세션
+ *      줄은 아니다 — 하네스는 MCP 에 CLAUDE_PID 를 안 주니(Bash·훅에만 준다) MCP env 의 그 값은 조상 claude 의 Bash 에서 물려받은 것이다
+ *      (SEC-2: Bash 에서 띄운 `claude -p` 의 MCP 가 부모의 이름을 제 uuid 에 댈 뻔했다).
+ *      그 세션 uuid 의 산 줄이 **둘 이상**이면(한 대화를 창 여럿이 띄움) 이름 없이 댄다 — 창마다 이름이 달라 두 MCP 가 같은 서버 줄에 번갈아
+ *      이름을 대고(L1), 그 uuid 앞 통은 한 편지함이라 어느 창이 받을지 정해지지 않는다(SEC-1). 두 MCP 가 같은 판정을 내니 이름이 안 뒤집힌다.
+ *   ② 전사의 자기소개 — **이 MCP 가 뜬 뒤에** 적힌 하네스 ListAgents 결과만(`introNameOf` 가 짝 표식 toolUseResult.listing 을 본다 — SEC-6).
+ *      MCP 는 claude 프로세스가 띄우므로 그 뒤에 적힌 자기소개는 지금 프로세스가 낸 것이다. 그 전 것은 다시 뜨기 전 이름일 수 있고, 그
+ *      이름은 지금 남의 것일 수 있다(7afd1d02 의 hnl-73 = 지금 110cd958 — 검증 2026-10-07). 등록부가 없는 옛 하네스·잴 수 없는 판
+ *      (Windows)에서 ListAgents 를 부르면 이름이 서는 길이다.
+ *   ③ Cursor 대화의 별칭 cursor-<uuid 앞 2자> — uuid 에서 나오는 값이라 낡지 않는다. 전사도 ListAgents 도 없는 자리다.
+ *   ④ 이번에 **못 쟀으면**(measured 거짓 — 세포 시간 초과 뒤 JS 사본의 ps 가 실패 · 시작 시각을 못 잼) 이 MCP 가 ①로 마지막에 확인한 이름을
+ *      다시 댄다(SEC-5 — 일시 실패가 서버의 이름 비움 → 같은 이름을 대는 남이 가져감 → 다음 등록은 held 로 번지지 않게). 이름은 프로세스마다
+ *      정해지니 같은 MCP 프로세스(= 같은 claude 프로세스) 안의 확인은 유효하다. 확인한 적이 없으면 이름 없이.
+ * 그리고 서버가 받는 꼴(`mailNameOk`)이어야 한다 — 아니면 이름 없이 댄다(꼴 때문에 등록이 400 이면 보내기까지 막힌다).
+ * Native Codex 는 늘 이름 없이 댄다 — 서버가 등록된 uuid 로 발신 표시를 정한다(이름을 지어내지 않는다).
+ */
+async function myAgentName(mine = mySessionId()) {
+  if (!AUTO_UUID_RE.test(String(mine || ''))) return { name: '', why: '이 세션의 번호를 모른다', addr: null, cur: mine };
+  if (!process.env.CLAUDE_CODE_SESSION_ID && mine === codexSessionId()) {
+    return { name: '', why: 'Codex 세션은 이름 없이 댄다', addr: null, cur: mine };
+  }
+  const addr = await selfAddress();
+  const rowSession = typeof addr.session === 'string' && AUTO_UUID_RE.test(addr.session) ? addr.session.toLowerCase() : '';
+  const liveRow = addr.source === 'registry' && addr.live && !!rowSession;
+  const own = liveRow && (addr.matched_by === 'socket' || rowSession === mine);
+  // 소켓은 하네스가 이 MCP 에게만 준 열쇠다 — 그 줄이 이 프로세스다. 떠 있는지 이번에 못 쟀어도(우리는 떠 있다) 지금 세션은 그 줄의 것이다.
+  const cur = addr.matched_by === 'socket' && rowSession ? rowSession : mine;
+  let name = '';
+  let why = '';
+  if (own) {
+    const windows = Number(addr.live_rows) || 1;
+    if (windows >= 2) {
+      why = `이 세션 uuid 를 지금 창 ${windows}곳이 함께 띄우고 있다 — 서버 주소록은 uuid 하나에 이름 하나라 창마다 다른 이름이 번갈아 서고, `
+        + '그 uuid 앞 통은 한 편지함이라 어느 창이 받을지 정해지지 않는다(한 창에 닿으려면 SendMessage 에 그 창의 이름)';
+    } else if (addr.name) {
+      name = addr.name;
+      mailNameSeen.session = cur;
+      mailNameSeen.name = name;
+    } else {
+      why = '하네스 등록부에 이 프로세스의 산 줄은 있는데 이름이 비었거나 꼴 밖이다(제어문자만 걷고 65자까지)';
+    }
+  } else {
+    const intro = introOf(mine);
+    if (intro?.name && intro.at >= BOOT_MS) {
+      name = intro.name;
+    } else if (isCursorTranscript(intro?.file) || mine === cursorActiveComposer() || process.env.CURSOR_CONVERSATION_ID === mine) {
+      name = cursorAliasOf(mine);
+    } else if (addr.measured === false && mailNameSeen.session === cur && mailNameSeen.name) {
+      name = mailNameSeen.name;                       // ④ — 이번엔 못 쟀을 뿐이다(조용히)
+    } else if (liveRow) {
+      why = `등록부에서 찾은 산 줄(세션 ${rowSession.slice(0, 8)})은 이 MCP 의 세션이 아니고 CLAUDE_PID 로만 찾았다 — 그 값은 하네스가 MCP 에 `
+        + '주지 않는 값(조상 프로세스의 것)이라 그 줄의 이름을 이 세션의 이름으로 대지 않는다';
+    } else if (addr.measured === false) {
+      why = `하네스 등록부에서 이 프로세스의 줄이 떠 있는지 이번에 못 쟀다(${process.platform === 'win32' ? '이 판은 pid 를 못 잰다' : '시작 시각을 못 맞췄다'})`;
+    } else if (intro?.name) {
+      why = `전사의 마지막 자기소개 «${cellClean(intro.name)}» 는 이 프로세스가 뜨기 전 것이라 지금 이름이라고 못 한다(다시 뜨면 이름이 바뀐다)`;
+    } else {
+      why = `하네스 등록부(${harnessSessionsDir()})에 이 프로세스의 산 줄이 없고 전사에도 자기소개가 없다`;
+    }
+  }
+  if (name && !mailNameOk(name)) {
+    why = `지금 이름 «${cellClean(name)}» 은 메일 주소록이 받는 꼴이 아니다(60자까지 · 공백·[ ] → < > 없음 · 16진 8자·uuid 꼴 아님)`;
+    name = '';
   }
-  nameCache = { file: f, size: st.size, name: found };
-  return found;
+  return { name, why, addr, cur };
+}
+
+/**
+ * 이 프로세스의 메일 주소 한 벌을 **한 번** 푼다(주소 계약 2 · 2026-10-07 검증 F2·SEC-7) — `{ pick, cur, old }`.
+ *   pick — `myAgentName(mine)` 의 답(이름·까닭·세포 답). cur — 지금 세션(위 cur — /clear 를 따라간다). 보내기(session)·주소 대기·받기의 주인이다.
+ *   old  — /clear 앞의 env 세션(mine — cur 과 같으면 null). 이미 나간 답장 주소(from_session)·받는 세션 줄(to_session)이 그 uuid 라, 이름 없이
+ *          주소를 유지하고 긷는다 — 단 **다른 창이 그 대화를 이어 열었으면**(등록부에 old 의 산 줄이 있다) 그 창의 MCP 가 주인이라 손을 뗀다
+ *          (두 프로세스가 한 편지함을 긷지 않게 — SEC-1). 하네스가 env 를 안 바꾸니 이 MCP 가 아는 것은 이 둘뿐이다.
+ */
+async function mailSelf(mine = mySessionId()) {
+  const pick = await myAgentName(mine);
+  const cur = AUTO_UUID_RE.test(String(pick.cur || '')) ? String(pick.cur).toLowerCase() : mine;
+  const old = cur !== mine && AUTO_UUID_RE.test(String(mine || '')) && !mailOldHeldElsewhere(mine) ? mine : null;
+  const v = { pick, cur, old };
+  mailSelfMemo = { at: Date.now(), mine, v };
+  return v;
+}
+/**
+ * 받기 바퀴(mailPull)가 쓰는 주소 — 30초 안에 푼 것이 있으면 그대로 쓴다. 주소 대기(mailRegister)는 소속처마다 60초에 한 번이라 받기 바퀴마다
+ * 세포를 새로 부를 까닭이 없다(세포의 --self 는 그 세션 전사의 끝을 거슬러 읽는다 — 자기소개가 없는 큰 전사는 끝까지 간다). 보내기(mail 도구)는
+ * 늘 새로 푼다(mailSelf). /clear 를 알아채는 것은 길어야 30초 늦다.
+ */
+let mailSelfMemo = { at: 0, mine: '', v: null };
+async function mailSelfRecent(mine = mySessionId()) {
+  if (mailSelfMemo.v && mailSelfMemo.mine === mine && Date.now() - mailSelfMemo.at < 30_000) return mailSelfMemo.v;
+  return mailSelf(mine);
+}
+/** 그 세션 uuid 를 지금 **다른 프로세스**가 띄우고 있나 — 등록부의 산 줄(JS 사본으로 잰다 · 못 재면 「아니다」). */
+function mailOldHeldElsewhere(sid) {
+  try {
+    return !!harnessLiveRow(harnessRowsIn(harnessSessionsDir()), harnessProbe(), (r) => r.session === sid);
+  } catch { return false; }
 }
 
 /** 이 세션이 메일을 다룰 조건을 갖췄나. 못 갖췄으면 `null` — 조용히 안 한다. */
@@ -7204,20 +8454,132 @@ function mailReady() {
 /**
  * 주소를 **스스로 댄다.** 관측 추정이 아니다(052 머리말의 세 실측).
  *
- * 이름이 없어도 등록한다 — 받을 수는 있어야 하기 때문이다. 이름이 생기면 다시 댄다.
- */
-async function mailRegister(tenant, mine, force = false) {
+ * 이름이 없어도 등록한다 — 받을 수는 있어야 하고, 이제 보낼 수도 있다(발신 표시는 서버가 uuid 앞 8자로 세운다).
+ * 이름은 **대기 직전에** 푼다(`mailSelf` → `myAgentName` — 세포 먼저, 못 하면 JS 사본). 돌려주는 것은 서버 응답에 `sentName`(실제로 댄 이름,
+ * 없으면 '')·`nameWhy`(이름 없이 댄 까닭)·`cur`(댄 세션)·`old`(/clear 앞 세션 — 이름 없이 함께 댄 것)를 얹은 것이다 — 보낸 결과의 안내가
+ * 그 사실대로 말한다(`mailAddrNote`).
+ * ★ 대는 세션은 **지금 세션(cur)** 이다 — /clear 뒤에는 env 의 세션 id(mine)가 아니다(F2: 세포·세션 시작 안내가 남에게 주는 uuid 가 cur 인데
+ *   주소록에는 mine 만 있어 그 uuid 앞 통이 404 였다). /clear 앞 세션(old)은 **먼저** 이름 없이 댄다 — 그 줄에 이 프로세스의 이름이 남아
+ *   있으면 cur 의 같은 이름이 「살아 있는 다른 세션이 쥐었다」(held)로 막힌다(같은 사람의 두 줄도 서버는 다른 세션으로 본다).
+ * ⚠ 이름 때문에 거절되면(400) **이름 없이 한 번 더** 댄다 — 등록이 막히면 보내기도 막힌다(서버 이름 규칙이 바뀌어도 벙어리가 안 되게).
+ * `ident` 는 부르는 쪽이 이미 푼 `mailSelf()` 답(한 바퀴에 세포를 한 번만 부르려고) — 없으면 여기서 푼다.
+ */
+async function mailRegister(tenant, mine, force = false, ident = null) {
   if (!force && Date.now() - (mailAddrAt.get(tenant) || 0) < MAIL_POLL_MS) return null;
   mailAddrAt.set(tenant, Date.now());
-  const name = myAgentName();
-  return await api('POST', '/api/mail/register', {
+  const id = ident || await mailSelf(mine);
+  const body = (session, name) => ({
     tenant,
-    session: mine,
-    name: name || '',
+    session,
+    name,
     // 신원이 어디서 왔는지 그대로 말한다 — Cursor 대화에 claude-code 이름표를 달지 않는다.
-    client: mine === cursorActiveComposer() ? 'cursor' : 'claude-code',
+    client: mine === codexSessionId() ? 'codex' : (mine === cursorActiveComposer() ? 'cursor' : 'claude-code'),
     cwd: relHome(process.cwd()),
   });
+  if (id.old) {
+    try { await api('POST', '/api/mail/register', body(id.old, '')); } catch { /* 옛 대화의 주소가 막혀도 지금 세션은 댄다 */ }
+  }
+  let sent = id.pick.name;
+  let why = id.pick.why;
+  let r;
+  try {
+    r = await api('POST', '/api/mail/register', body(id.cur, sent));
+  } catch (e) {
+    if (!(sent && e?.status === 400)) throw e;
+    why = `지금 이름 «${cellClean(sent)}» 을 서버가 받지 않았다(${cellClean(e.message).slice(0, 120)})`;
+    sent = '';
+    r = await api('POST', '/api/mail/register', body(id.cur, ''));
+  }
+  return { ...(r && typeof r === 'object' ? r : {}), sentName: sent, nameWhy: why, cur: id.cur, old: id.old };
+}
+
+/**
+ * 뜰 때 **아는 소속처에 주소를 한 번 댄다**(계약 2 · 2026-10-07). 전에는 genetics 도구를 불러야만 댔다(tools/call 의 mailPull →
+ * mailRegister) — 다시 뜬 세션은 첫 호출 전까지 서버 주소록에 옛 이름으로 남아, 새 이름 앞 통은 404 였고 옛 이름 앞 통은 이 세션으로
+ * 왔다(검증 2026-10-07 remaining_failures — 9592 · 4163). 아는 소속처 = `mailReady()` 의 것(뜰 때는 색인의 소속처뿐이다).
+ * Native Codex 는 뺀다 — 자기 일정 표의 'mail' 행(codexMailPullOne)이 뜰 때 이미 이름 없이 댄다. 주소(이름)는 한 번만 푼다.
+ */
+async function mailRegisterBoot() {
+  const r0 = mailReady();
+  if (!r0) return 0;
+  if (!process.env.CLAUDE_CODE_SESSION_ID && r0.mine === codexSessionId()) return 0;
+  const ident = await mailSelf(r0.mine);
+  let n = 0;
+  for (const [tenant] of r0.tenants) {
+    try { await mailRegister(tenant, r0.mine, true, ident); n += 1; }
+    catch { /* 한 소속처가 막혀도 나머지는 댄다 — 도구를 부르면 다시 댄다 */ }
+  }
+  return n;
+}
+
+// 서버 lib/mail.php 의 MAIL_NAME_STATES 와 같은 낱말 — 늘리면 세 구현을 같이 고친다(그쪽 머리말).
+const MAIL_NAME_STATES = ['set', 'kept', 'held', 'cleared'];
+/**
+ * 주소 등록이 **실제로 어떻게 됐나**를 한 줄로(할 말이 없으면 '') — 서버 응답의 사실대로.
+ *   새 서버: `name_state`('set'|'kept'|'held'|'cleared') · `name`(그 줄에 실제로 남은 이름 — 서버가 표에서 다시 읽은 값) · `prev_name`.
+ *   옛 서버: `held_by` 만 — 그때 서버 줄에는 예전 이름이 남을 수 있어(api.php 의 `IF(VALUES(name) IS NULL, name, …)`) 단정하지 않는다.
+ * ⚠ 전에는 held 면 「이 통은 «uuid 앞 8자» 이름으로 나간다」고 단정했는데, 옛 서버는 그 줄의 옛 이름을 지켜 실제 발신 표시는 옛 이름이었다
+ *   (검증 2026-10-07 — 8ec9b061:www/portal/api.php:4163·4183·4208 · 서버는 이제 mail_store_register 에서 비운다). 발신 표시의 정본은 보낸 결과의 미리보기 첫 줄이다 — 서버가 받는 쪽에 그릴 그대로다.
+ */
+function mailAddrNote(reg, mine) {
+  if (!reg || typeof reg !== 'object') return '';
+  // 남이 닿을 주소 — 이 프로세스의 지금 세션(cur · /clear 를 따라간다). 옛 등록 응답(cur 칸 없음)이면 부르는 쪽의 mine.
+  const me = typeof reg.cur === 'string' && AUTO_UUID_RE.test(reg.cur) ? reg.cur : mine;
+  const old = typeof reg.old === 'string' && AUTO_UUID_RE.test(reg.old) ? reg.old : '';
+  // /clear 로 대화가 바뀐 창 — 그 사실과 두 uuid 를 한 번 말한다(F2: 옛 uuid 로 부친 답장도 다른 창이 그 대화를 이어 열기 전까지 이 창이 긷는다).
+  const moved = old ? `(이 창은 /clear 로 대화가 바뀌었다 — 이제 이 세션의 주소는 uuid ${me} 이다. 옛 uuid ${old} 앞 통도 다른 창이 그 대화를 `
+    + '이어 열기 전까지는 이 창이 긷는다.)\n' : '';
+  const sent = typeof reg.sentName === 'string' ? reg.sentName : '';
+  const why = typeof reg.nameWhy === 'string' ? reg.nameWhy : '';
+  const state = MAIL_NAME_STATES.includes(reg.name_state) ? reg.name_state : '';
+  const stored = state ? (typeof reg.name === 'string' ? cellClean(reg.name) : '') : null;   // null = 모른다(옛 서버)
+  const prev = state && typeof reg.prev_name === 'string' && reg.prev_name ? cellClean(reg.prev_name) : '';
+  const held = state ? state === 'held' : !!reg.held_by;
+  const holder = reg.held_by ? cellClean(String(reg.held_by)).slice(0, 8) : '';
+  const book = (stored === null ? '서버 주소록에는 이 세션의 예전 이름이 남았을 수 있다(이 서버는 남은 이름을 안 알려 준다)'
+    : (stored ? `서버 주소록에 남은 이 세션의 이름은 «${stored}» 이다` : '서버 주소록에는 이름 없이 섰다'))
+    + (prev ? ` · 옛 이름 «${prev}» 은 이제 이 세션으로 안 풀린다` : '');
+  const show = '발신 표시는 아래 미리보기 첫 줄 그대로다';
+  if (held) {
+    return moved + `(이 세션이 댄 이름 «${cellClean(sent)}» 은 살아 있는 다른 세션${holder ? ` ${holder}` : ''} 이 쥐고 있어 못 댔다 — ${book}. `
+      + `${show}. 남이 이 세션에 닿으려면 uuid ${me}.)\n`;
+  }
+  if (!sent) {
+    return moved + `(이 세션은 말 걸 수 있는 이름 없이 주소를 댔다${why ? ` — ${cellClean(why)}` : ''}. ${book}. ${show}. `
+      + `남이 이 세션에 닿으려면 uuid ${me}.)\n`;
+  }
+  if (stored !== null && stored !== sent) {
+    return moved + `(이 세션이 댄 이름은 «${cellClean(sent)}» 인데 ${book}(name_state ${state}). ${show}.)\n`;
+  }
+  if (prev) return moved + `(이 세션의 이름은 이제 «${cellClean(sent)}» 이다 — 옛 이름 «${prev}» 은 이 세션으로 안 풀린다.)\n`;
+  return moved;
+}
+
+/** 보낸 결과의 **실제 받는 세션 uuid**(서버의 `to_session` — 같은 소속처 안의 값만 온다). 없거나 꼴이 아니면 ''(옛 서버). */
+function mailToSession(r) {
+  const s = typeof r?.to_session === 'string' ? r.to_session.trim() : '';
+  return AUTO_UUID_RE.test(s) ? s.toLowerCase() : '';
+}
+
+/**
+ * 받은 통의 **답장 주소**(보낸 세션 uuid) — 서버가 GET /api/mail 항목에 `from_session` 을 실어 주면 한 줄씩 덧붙인다(계약 3).
+ * 발신 표시(uuid 앞 8자·그때의 이름)는 mail 의 to 로 안 풀리거나 남에게 간다 — 36자 uuid 만 그 세션으로 확실히 풀린다(mail_store_recipient — 8ec9b061:www/portal/lib/mail_store.php:171-172).
+ * ⚠ 서버가 쓴 글자(`says`)는 손대지 않고 **뒤에** 붙인다 — 발신 표시를 짓는 자리는 서버의 mail_render() 하나뿐이다(아래 mailPullOne 머리말).
+ *   이미 says 에 그 uuid 가 있으면 안 붙인다. 옛 서버(칸 없음)면 ''.
+ */
+function mailReplyHints(rows, says = '') {
+  const seen = new Set();
+  const low = String(says || '').toLowerCase();
+  const out = [];
+  for (const m of Array.isArray(rows) ? rows : []) {
+    const sid = typeof m?.from_session === 'string' ? m.from_session.trim().toLowerCase() : '';
+    if (!AUTO_UUID_RE.test(sid) || seen.has(sid) || low.includes(sid)) continue;
+    seen.add(sid);
+    const who = cellClean(m.from_name || '').slice(0, 60) || sid.slice(0, 8);
+    out.push(`  ↩ «${who}» 에게 답할 주소(보낸 세션 uuid — 이름은 다시 뜨면 바뀐다): ${sid}`);
+    if (out.length >= 5) break;
+  }
+  return out.length ? `\n${out.join('\n')}` : '';
 }
 
 /**
@@ -7234,8 +8596,10 @@ 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); }
+  // 주소(지금 세션 cur · /clear 앞 세션 old · 댈 이름)는 한 바퀴에 한 번 푼다 — 세포를 소속처마다 부르지 않게.
+  const ident = await mailSelfRecent(mine).catch(() => null);
+  for (const [tenant, tenantId] of tenants) {
+    try { await mailPullOne(tenant, mine, tenant === indexTenant ? indexEntry : null, tenantId, ident); }
     catch { /* 한 소속처가 막혀도 나머지는 돈다 — 다음 바퀴에 다시 */ }
   }
 
@@ -7262,46 +8626,234 @@ async function mailPull() {
   }
 }
 
-/** 한 소속처의 내 편지함을 긷고 **받았다고 도장을 찍는다**(도장은 큐에 넣기 **전에** — 재점화 방지). */
-async function mailPullOne(tenant, mine, indexEntry) {
-  try { await mailRegister(tenant, mine); } catch { /* 등록 실패가 받기를 막지 않는다 */ }
-
-  if (!mailCursors.has(tenant)) mailCursors.set(tenant, Number(indexEntry?.mail_cursor || 0));
-  let cursor = mailCursors.get(tenant);
-  /*
-   * ⚠ **자리(`cwd`)를 안 보낸다.** 창구가 그것으로 거르던 동안 주소 있는 메일이 조용히
-   *   사라졌다(실측 2026-08-25: cwd 없이 1통 · cwd 있게 0통). 메일은 폴더가 아니라
-   *   세션에 부친 것이라 **주소가 이미 필터**다.
-   */
-  const q = '?tenant=' + encodeURIComponent(tenant)
-    + '&since=' + cursor
-    + '&session=' + encodeURIComponent(mine)
-    + '&limit=' + MAIL_PAGE;
-  const r = await api('GET', '/api/mail' + q);
-
-  const rows = Array.isArray(r?.mail) ? r.mail : [];
-  if (typeof r?.cursor === 'number' && r.cursor > cursor) { cursor = r.cursor; mailCursors.set(tenant, cursor); }
-  // 색인에는 색인의 소속처 것만 적는다(다른 곳의 커서는 프로세스 안에서만 — 잃어도 ack 가 중복을 막는다).
-  // 빈 폴링은 수신이 아니다 — 위 백신 커서와 같은 규율.
-  if (indexEntry?.tenant_id) {
-    indexPatch(mine, { mail_cursor: cursor }, rows.length ? 'rx' : '');   // 소속 칸은 안 건드린다(§5.1 P1-a)
-  }
-
-  if (rows.length) {
-    const ids = rows.map((m) => Number(m.id)).filter((n) => n > 0);
-    if (ids.length) {
-      try { await api('POST', '/api/mail/ack', { tenant, ids }); }
-      catch { /* 도장을 못 찍어도 말은 한다 — 못 찍은 것은 다음 바퀴에 또 온다 */ }
+/* 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');
+      // Reply address (sender session UUID) comes from the server's from_session field and is appended after its wording.
+      const told = typeof r.says === 'string' && r.says ? r.says + mailReplyHints(r.mail, r.says) : r.says;
+      const batch = r.mail.length ? {ids:r.mail.map(m => m.id),says:told} : 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(); }
+}
+
+/**
+ * 한 소속처의 내 편지함을 긷고 **받았다고 도장을 찍는다**(도장은 큐에 넣기 **전에** — 재점화 방지).
+ * ★ 긷는 편지함은 **지금 세션(cur)** 과, /clear 뒤면 그 앞 세션(old — 다른 창이 그 대화를 이어 열지 않았을 때만)이다(F2·SEC-7 — `mailSelf`).
+ *   커서는 (소속처, 세션)마다 따로 — 한 커서로 두 세션을 긷으면 앞 세션이 커서를 밀어 뒤 세션의 통을 건너뛴다(그 통은 open 으로 남다 만료된다).
+ *   색인의 mail_cursor 는 env 세션(mine)의 것이라 그 세션을 긷을 때만 적는다.
+ */
+async function mailPullOne(tenant, mine, indexEntry, tenantId = 0, ident = null) {
+  if (process.platform !== 'win32' && !process.env.CLAUDE_CODE_SESSION_ID && mine === codexSessionId()) return await codexMailPullOne(tenant, mine, tenantId || Number(indexEntry?.tenant_id));
+  const id = ident || await mailSelf(mine);
+  try { await mailRegister(tenant, mine, false, id); } catch { /* 등록 실패가 받기를 막지 않는다 */ }
+
+  for (const sess of [id.cur, id.old]) {
+    if (!sess) continue;
+    const key = sess === mine ? tenant : `${tenant}\0${sess}`;
+    if (!mailCursors.has(key)) mailCursors.set(key, sess === mine ? Number(indexEntry?.mail_cursor || 0) : 0);
+    let cursor = mailCursors.get(key);
     /*
-     * ★ **서버가 쓴 글자를 그대로 싣는다.** 발신자 표시(`[누구 → 너]`)를 붙이는 자리는
-     *   서버의 `mail_render()` 하나뿐이고, 여기서 다시 지으면 두 자가 갈린다.
-     *   그리고 갈리는 순간 「누가 말하는지」가 보증이 아니라 장식이 된다 —
-     *   이 레일이 명령형을 허용하는 근거가 바로 그 보증이다.
+     * ⚠ **자리(`cwd`)를 안 보낸다.** 창구가 그것으로 거르던 동안 주소 있는 메일이 조용히
+     *   사라졌다(실측 2026-08-25: cwd 없이 1통 · cwd 있게 0통). 메일은 폴더가 아니라
+     *   세션에 부친 것이라 **주소가 이미 필터**다.
      */
-    if (typeof r?.says === 'string' && r.says) mailQueue.push(r.says);
+    const q = '?tenant=' + encodeURIComponent(tenant)
+      + '&since=' + cursor
+      + '&session=' + encodeURIComponent(sess)
+      + '&limit=' + MAIL_PAGE;
+    const r = await api('GET', '/api/mail' + q);
+
+    const rows = Array.isArray(r?.mail) ? r.mail : [];
+    if (typeof r?.cursor === 'number' && r.cursor > cursor) { cursor = r.cursor; mailCursors.set(key, cursor); }
+    // 색인에는 색인의 소속처 · env 세션의 것만 적는다(다른 곳의 커서는 프로세스 안에서만 — 잃어도 ack 가 중복을 막는다).
+    // 빈 폴링은 수신이 아니다 — 위 백신 커서와 같은 규율.
+    if (sess === mine && indexEntry?.tenant_id) {
+      indexPatch(mine, { mail_cursor: cursor }, rows.length ? 'rx' : '');   // 소속 칸은 안 건드린다(§5.1 P1-a)
+    }
+
+    if (rows.length) {
+      const ids = rows.map((m) => Number(m.id)).filter((n) => n > 0);
+      if (ids.length) {
+        try { await api('POST', '/api/mail/ack', { tenant, ids }); }
+        catch { /* 도장을 못 찍어도 말은 한다 — 못 찍은 것은 다음 바퀴에 또 온다 */ }
+      }
+      /*
+       * ★ **서버가 쓴 글자를 그대로 싣는다.** 발신자 표시(`[누구 → 너]`)를 붙이는 자리는
+       *   서버의 `mail_render()` 하나뿐이고, 여기서 다시 지으면 두 자가 갈린다.
+       *   그리고 갈리는 순간 「누가 말하는지」가 보증이 아니라 장식이 된다 —
+       *   이 레일이 명령형을 허용하는 근거가 바로 그 보증이다.
+       * 답장 주소(보낸 세션 uuid)는 서버가 준 칸(`from_session`)으로 그 **뒤에** 붙인다 — 표시 줄은 안 건드린다(`mailReplyHints`).
+       * /clear 앞 대화 앞으로 온 통이면 그 사실을 한 줄 앞에 둔다 — 받는 쪽(이 창의 새 대화)은 그 실의 맥락이 없다.
+       */
+      if (typeof r?.says === 'string' && r.says) {
+        const lead = sess === id.cur ? '' : `(아래는 /clear 앞 대화(uuid ${sess}) 앞으로 온 통이다 — 이 창의 지금 대화는 그 실의 맥락이 없다.)\n`;
+        mailQueue.push(lead + r.says + mailReplyHints(rows, 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시간 동안 되풀이해 준다 — 접는 것은 우리 몫
@@ -7480,6 +9032,13 @@ function requireArgs(name, args) {
     + `받는 이름은 이것뿐입니다 — ${all}`);
 }
 
+/** 창구가 돌려준 항목 짚개 한 줄 — 번호가 있으면(하위 업무 번호 2단계) 「W-04 · decisions/…」, 없으면 예전처럼 경로 하나(옛 서버 · 0단계). */
+function worksItemRef(item) {
+  const key = String(item?.key ?? '');
+  const code = typeof item?.code === 'string' ? item.code : '';
+  return code ? `${code} · ${key}` : key;
+}
+
 /**
  * ── `works(tenant, work)` — 그 일의 항목 한 줄씩(GET /api/work/items, 2026-09-27) ─────────────
  *
@@ -7487,16 +9046,26 @@ function requireArgs(name, args) {
  * 결정 장을 한 장씩 열었다(같은 날 hnl 세션: 배정안 + 항목 장 일곱). 서버가 간트와 같은 자로 낸 줄을
  * 그대로 옮긴다 — 번호(code)는 제목 머리의 [ … ] 이고, 없으면 제목만 쓴다(지어내지 않는다).
  * ⚠ **서버가 준 칸만 쓴다** — 계획·상태 칸이 없거나 비면 그 토막을 안 그린다(옛 서버·빈 관측).
+ * ★ 하위 업무 번호(DESIGN-item-codes.md · 설계 4-1 MCP works 줄): 번호를 쓰는 소속처(2단계)의 서버는 줄마다 role · parent 를 더 준다 —
+ *   (짚개 한 줄은 worksItemRef — 창구가 번호를 돌려주면 「W-04 · decisions/…」, 아니면 예전처럼 경로 하나.)
+ *   머리 장(role head — `WRM-00`)은 하위 업무 줄 · 수에서 빼 일 머리 줄에 싣고, 자식(parent 가 이 목록에 있는 줄)은 부모 밑에 들여 쓴다.
+ *   번호 글자를 쪼개 부모를 읽지 않는다(서버 parent 칸만). 그 칸이 없는 서버(0단계 · 옛 서버)의 출력은 예전과 한 글자도 같다.
  */
 function worksItemsList(r) {
   const works = Array.isArray(r?.works) ? r.works : [];
   if (!works.length) return `${r?.tenant || ''} — 열린 일이 없다. 0건은 0건이다.`;
   const md = (d) => String(d || '').slice(5);   // 2026-09-14 → 09-14
+  const str = (v) => (typeof v === 'string' ? v : '');
   const out = [];
+  let coded = false;
   for (const w of works) {
-    const items = Array.isArray(w?.items) ? w.items : [];
-    out.push(`«${w.name || w.slug}» (${w.slug}) — 항목 ${items.length}개`);
-    for (const it of items) {
+    const all = Array.isArray(w?.items) ? w.items : [];
+    if (all.some((it) => it && typeof it.role === 'string')) coded = true;
+    const headRow = all.find((it) => it && it.role === 'head') || null;
+    const items = headRow ? all.filter((it) => it !== headRow) : all;
+    out.push(`«${w.name || w.slug}» (${w.slug}) — 항목 ${items.length}개`
+      + (headRow ? ` · 머리 ${str(headRow.code)} — ${headRow.key}` : ''));
+    const line = (it, depth) => {
       const code = typeof it.code === 'string' && it.code !== '' ? it.code : '';
       const title = code ? String(it.title || '').replace(/^\[[^\]]*\]\s*/, '') : String(it.title || '');
       // 계획 끝 말(plan_word)·고유 번호(uid)도 서버가 준 것만 — 할 일 화면과 같은 자(work_task_due_word) · 할 일 표의 uid.
@@ -7504,11 +9073,26 @@ function worksItemsList(r) {
       const plan = it.plan && it.plan.from ? ` · 계획 ${md(it.plan.from)}~${md(it.plan.to)}${due}` : '';
       const state = it.state_word ? ` · ${it.state_word}` : '';
       const uid = typeof it.uid === 'string' && it.uid !== '' ? ` · uid ${it.uid}` : '';
-      out.push(`  · ${code ? code + ' ' : ''}${title}${plan}${state} — ${it.key}${uid}`);
+      return `${'  '.repeat(depth + 1)}· ${code ? code + ' ' : ''}${title}${plan}${state} — ${it.key}${uid}`;
+    };
+    // 자식 — 서버 parent 가 이 목록의 번호일 때만 들여 쓴다(부모가 목록에 없으면 제자리 한 줄 — 지어내지 않는다).
+    const codes = new Set(items.map((it) => str(it.code)).filter(Boolean));
+    const parentOf = (it) => { const p = str(it.parent); return p !== '' && p !== str(it.code) && codes.has(p) ? p : ''; };
+    const kids = new Map();
+    for (const it of items) {
+      const p = parentOf(it);
+      if (p) { if (!kids.has(p)) kids.set(p, []); kids.get(p).push(it); }
+    }
+    for (const it of items) {
+      if (parentOf(it)) continue;
+      out.push(line(it, 0));
+      for (const k of kids.get(str(it.code)) || []) out.push(line(k, 1));
     }
     if (Number(w.dropped) > 0) out.push(`  (지시형 제목이라 뺀 결정 ${Number(w.dropped)}건)`);
   }
-  out.push('항목을 건드리기 전에는 works(tenant, work, item) 로 이미 끝났는지 먼저 확인한다 — 전문은 get_case(tenant, item_key).');
+  out.push(coded
+    ? '항목을 건드리기 전에는 works(tenant, work, item) 로 이미 끝났는지 먼저 확인한다 — item 은 번호(예 W-04)나 item_key 그대로. 전문은 get_case(tenant, item_key).'
+    : '항목을 건드리기 전에는 works(tenant, work, item) 로 이미 끝났는지 먼저 확인한다 — 전문은 get_case(tenant, item_key).');
   return out.join('\n');
 }
 
@@ -7995,6 +9579,8 @@ async function callTool(name, args = {}) {
       // 서버의 `publish: true` 손잡이를 당기면 초안이 열린다. 여는 동사는 release_report 하나다.
       delete payload.publish;
       delete payload.published_at;
+      // 결정 모드 문서의 공개일은 서버가 원고에 적는다(released_on) — 되읽은 판에 섞여 오는 값은 서버가 어차피 덮지만 메아리를 줄인다.
+      delete payload.released_on;
       delete payload.body_rev;   // 몸통의 판은 서버가 안 읽는다 — 섞여 오면 떼고 보낸다(원고에 메아리로 남지 않게)
       if (args.dry_run) payload.dry_run = true;
       /*
@@ -8098,7 +9684,7 @@ async function callTool(name, args = {}) {
         }
         if (args.undone) {
           const r = await api('POST', '/api/work/done', { tenant: args.tenant, work: wSlug, item, undone: true });
-          return `${r.item.key} — 완료 표시를 되돌렸다(사후 정정, 원장에 남는다). 지금 상태: ${r.word}.`;
+          return `${worksItemRef(r.item)} — 완료 표시를 되돌렸다(사후 정정, 원장에 남는다). 지금 상태: ${r.word}.`;
         }
         if (args.done_when || args.done_evidence) {
           if (!args.done_when || !args.done_evidence) {
@@ -8110,7 +9696,7 @@ async function callTool(name, args = {}) {
             done_when: String(args.done_when), done_evidence: String(args.done_evidence),
             session: mine || '',
           });
-          return `${r.item.key} — ${r.word}(으)로 표시했다.\n  조건: ${args.done_when}\n  근거: ${args.done_evidence}`;
+          return `${worksItemRef(r.item)} — ${r.word}(으)로 표시했다.\n  조건: ${args.done_when}\n  근거: ${args.done_evidence}`;
         }
         // 아무 표시 인자도 없으면 조회 전용(부작용 없음) — 건드리기 전에 먼저 확인하는 자리.
         const r = await api('GET', '/api/work/done?tenant=' + encodeURIComponent(args.tenant)
@@ -8118,7 +9704,7 @@ async function callTool(name, args = {}) {
         const doneLine = r.state === 'done'
           ? `이미 끝난 항목이다 — 근거: ${r.done_evidence || '(비어 있음)'}. 다시 진행하지 말 것.`
           : '아직 완료가 아니다.';
-        return `${r.item.key} — ${r.word}\n${doneLine}`;
+        return `${worksItemRef(r.item)} — ${r.word}\n${doneLine}`;
       }
       if (args.claim) {
         // 착수 선언(088) — 세션 이름은 이 자리(로컬)가 안다. mail 도구의 그 관용구다.
@@ -8129,7 +9715,7 @@ async function callTool(name, args = {}) {
         };
         if (args.item) body.item = String(args.item);
         const r = await api('POST', '/api/work/claim', body);
-        const target = r.item?.key ? `${r.item.key} @ «${r.work?.name || r.work?.slug}»` : `«${r.work?.name || r.work?.slug}» (${r.work?.slug})`;
+        const target = r.item?.key ? `${worksItemRef(r.item)} @ «${r.work?.name || r.work?.slug}»` : `«${r.work?.name || r.work?.slug}» (${r.work?.slug})`;
         return `${target} — ${r.says}`;
       }
       const r = await api('GET', '/api/work/list?tenant=' + encodeURIComponent(args.tenant));
@@ -8201,6 +9787,9 @@ async function callTool(name, args = {}) {
         rejected_names: Array.isArray(args.rejected_names) ? args.rejected_names : [],
         // 옛 결정 뒤집기(2026-09-21) — 댈 때만 싣는다(안 대면 요청이 예전과 같다).
         ...(args.overturns ? { overturns: args.overturns, overturns_revision: args.overturns_revision || '' } : {}),
+        // 하위 업무 번호 네 칸(DESIGN-item-codes.md · 설계 4-1) — 댄 칸만 싣는다(안 대면 요청이 예전과 같다). 판정 · 발급은 창구 한 자리.
+        ...Object.fromEntries(['item', 'parent', 'branch', 'prefix']
+          .filter((k) => typeof args[k] === 'string' && args[k].trim() !== '').map((k) => [k, args[k].trim()])),
         // ★ 출처는 우리가 채운다 — 모델에게 안 묻는다(remember_case 와 같은 규율). 표지가
         //   열린 일과 만나 항목으로 설 때 「누가 심었나」(간트의 세션 자국)가 이것이다.
         ...myCitation(),
@@ -8251,6 +9840,11 @@ async function callTool(name, args = {}) {
       } else if (args.work && !r.effects_pending) {
         lines.push('표지(work)를 적었지만 이 서버는 아직 그 칸을 모른다 — 판이 낡았다.');
       }
+      // 하위 업무 번호 — 문장의 정본은 서버(work_items_code_note → work_note)다. 그 문장에 번호가 없을 때만(서버 문장이 빠진 판)
+      // 칸 값 그대로 한 줄 — 프로즈를 짓지 않는다. 번호가 없는 저장(0단계 · 표지 없는 결정)의 출력은 예전과 같다.
+      if (typeof r.code === 'string' && r.code !== '' && !String(r.work_note || '').includes(r.code)) {
+        lines.push(`code: ${r.code}${typeof r.parent === 'string' && r.parent !== '' ? `\nparent: ${r.parent}` : ''}`);
+      }
       return lines.join('\n');
     }
     case 'list_rejected_names': {
@@ -8489,7 +10083,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': {
@@ -8529,6 +10123,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`
@@ -8539,7 +10136,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` 를
@@ -8554,7 +10151,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': {
       /*
@@ -8580,6 +10178,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 과 같은 이유).
@@ -8587,7 +10186,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);
@@ -8600,7 +10201,7 @@ async function callTool(name, args = {}) {
        * 최대 20초 동안 다른 사람 화면에는 이 기계가 안 보인다 — 이어받은 직후가 바로
        * 「누가 잡았나」를 알아야 하는 순간이라 여기서 한 번 즉시 뛴다.
        */
-      beatTick().catch(() => {});
+      if (!native) beatTick().catch(() => {});
 
       // **받기 전에 알아야 할 것을 먼저 쓴다.** 요지 뒤에 붙이면 긴 글에 묻힌다.
       const others = (r.devices || []).filter((d) => d.device !== deviceId());
@@ -8619,7 +10220,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다음에 할 일: 아래 대화를 읽고, 사용자에게 「어디까지 되어 있고 다음이 무엇인지」를 '
@@ -8638,6 +10239,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`,
@@ -8655,31 +10258,33 @@ async function callTool(name, args = {}) {
       const mine = mySessionId();
       if (!mine) {
         return '이 세션의 번호를 모른다 — 주소를 댈 수 없어 보낼 수 없다'
-             + '(CLAUDE_CODE_SESSION_ID 도, Cursor 활성 대화도 없는 환경이다).';
+             + '(Claude 세션 번호·유효한 Codex 세션 UUID·Cursor 활성 대화가 없는 환경이다).';
       }
       /*
-       * 주소가 없으면 먼저 댄다. **이름이 없으면 서버가 409 로 거절**하므로,
-       * 그 경우를 여기서 미리 사람 말로 바꿔 준다 — 서버 오류문만 보면 무엇을 해야
-       * 하는지 알 수 없다.
+       * ★ **이름이 없어도 보낸다**(2026-10-07 — 「이름 없으면 못 보냄」 문지기를 걷었다). 가드의 보증(「받는 쪽이 누가 말하는지
+       *   본다」)은 이름이 아니라 **서버가 등록된 세션에서 발신자를 박는다**는 사실에서 온다 — 서버는 2026-08-25 부터 이름 없는 발신을
+       *   uuid 앞 8자로 받는다(mail_store_sender_session — 8ec9b061:www/portal/lib/mail_store.php:96-105). 그런데 이 문지기가 서버보다 엄해서 등록부를 못 읽은
+       *   세션은 전체 uuid 앞으로 보낸 통까지 거절됐고, 문지기가 등록보다 앞이라 주소도 안 생겼다(2026-10-06T15:49:24Z 실측).
+       * ★ **대고 나서 보낸다** — 등록(mailRegister)이 보내기 앞이다. 서버는 등록된 주소에서만 발신을 받는다(403).
+       *   이름은 대기 직전에 푼다(myAgentName — 세포 먼저, 못 하면 JS 사본). Native Codex 는 늘 이름 없이 댄다 — 이름을 지어내거나
+       *   요청 인자의 발신자를 쓰지 않는다. 등록 거절은 아래에서 전송 전에 멈춘다.
+       */
+      const nativeCodex = !process.env.CLAUDE_CODE_SESSION_ID && mine === codexSessionId();
+      /*
+       * ★ 보내는 세션은 **지금 세션(cur)** 이다 — /clear 뒤에는 env 의 세션 id(mine)가 아니다(F2·SEC-7). 받는 쪽의 답장 주소(from_session)가
+       *   그 uuid 가 되고, 이 창은 그 편지함을 긷는다(mailPullOne). /clear 앞 세션은 이름 없이 주소만 유지한다(mailRegister).
        */
-      if (!myAgentName()) {
-        return '이 세션에는 아직 말 걸 수 있는 이름이 없어 **보낼 수가 없다**'
-             + '(받는 쪽이 누가 말하는지 못 보면 그것은 메시지가 아니라 주입이다).\n'
-             + '이름은 `ListAgents` 를 한 번 부르면 생긴다 — 하네스가 「This session is …」를 '
-             + '전사에 적고, 이 도구가 그것을 읽는다. 부른 뒤 다시 보내면 된다.';
-      }
       let reg;
-      try { reg = await mailRegister(args.tenant, mine, true); }
+      let ident;
+      try { ident = await mailSelf(mine); reg = await mailRegister(args.tenant, mine, true, ident); }
       catch (e) { return `주소를 대지 못했다 — ${e.message}`; }
+      const sender = ident?.cur || mine;
       /*
-       * ⚠ 이름을 **남이 쥐고 있으면** 보내기가 409(이름 없음)로 막힌다 — 서버 오류문만 보면
-       *   무엇을 해야 하는지 모른다. 창구가 준 사실(held_by)을 여기서 사람 말로 앞세운다.
-       *   (하네스가 짧은 이름을 재사용한다 — 2026-08-25 운영 실측, app-4a 둘.)
+       * 이름을 남이 쥐고 있어도(held)·이름이 없어도 **보낸다**(침묵 금지). 무엇이 됐는지는 서버 응답의 사실대로 말한다 —
+       * 발신 표시를 단정하지 않는다(mailAddrNote 머리말: 옛 서버는 held 일 때 그 줄의 옛 이름을 지켰다).
+       * (하네스가 짧은 이름을 재사용한다 — 2026-08-25 운영 실측, app-4a 둘.) Native Codex 는 늘 이름이 없어 말할 것이 없다.
        */
-      // 이름을 남이 쥐고 있어도 **보낸다** — 발신자 표시는 서버가 uuid 앞 8자로 세운다(침묵 금지).
-      const heldNote = reg?.held_by
-        ? `(이 세션의 이름은 살아 있는 다른 세션 ${String(reg.held_by).slice(0, 8)} 이 쥐고 있어 이 통은 «${mine.slice(0, 8)}» 이름으로 나간다 — 남이 이 세션에 닿으려면 uuid ${mine} 로.)\n`
-        : '';
+      const addrNote = nativeCodex ? '' : mailAddrNote(reg, mine);
 
       const r = await api('POST', '/api/mail', {
         tenant:    args.tenant,
@@ -8691,14 +10296,17 @@ async function callTool(name, args = {}) {
         cwd:       relHome(process.cwd()),
         ...(args.thread ? { thread: args.thread } : {}),
         // ★ **출처는 우리가 채운다 — 모델에게 안 묻는다**(remember_case 의 myCitation 과 같은 규율).
-        session: mine,
+        session: sender,
       });
       // ★ 받을 곳을 기억한다 — 색인 밖 세션도 이 소속처에서 받는다(mailReady 힌트 + 색인).
       // ⚠ 서버가 tenant_id 를 아직 안 주는 판(재배포 전)이어도 **받기는 이름만으로 된다** —
       //   GET /api/mail 은 tenant 이름으로 묻는다. 색인(indexNote)만 id 가 있어야 적힌다.
       mailTenants.set(args.tenant, r?.tenant_id || 0);   // 이 소속처에서도 받는다 — 합집합, 폴백 아님
       if (r?.tenant_id && !indexRead()[mine]?.tenant) indexNote(mine, { src: 'mail', tenant: args.tenant, tenant_id: r.tenant_id, ...(r.tenant_slug ? { tenant_slug: r.tenant_slug } : {}) });
-      return heldNote + `«${r.to}» 앞으로 보냈다 — 실 ${r.thread} · 이 실의 ${r.turn}번째 통.\n`
+      // 실제로 받은 세션(서버가 푼 uuid) — 이름으로 부쳤으면 그 이름이 그 순간 누구였는지가 여기 남는다(오배달을 알아챌 자리).
+      const toSession = mailToSession(r);
+      return addrNote + `«${r.to}» 앞으로 보냈다 — 실 ${r.thread} · 이 실의 ${r.turn}번째 통.\n`
+        + (toSession ? `받는 세션: ${toSession} — 이 실을 이어 가거나 다시 부칠 때 이 uuid 가 주소다(이름은 다시 뜨면 바뀐다).\n` : '')
         + `받는 쪽이 보게 될 글자는 이것이다:\n${r.preview}\n`
         + (r.says ? `${r.says}\n` : '')
         + '답이 오면 다른 도구를 부를 때 응답 꼬리에 저절로 실린다 — 따로 확인할 필요 없다.';
@@ -8869,12 +10477,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 {
@@ -8888,7 +10506,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) } });
@@ -9386,6 +11004,7 @@ function ensureSkillOnBoot() {
  *   lane  'all'      = 모든 클라이언트 · 'hookless' = 훅 레인이 없는 클라이언트만(`hookLane()` 이 거짓 — Codex)
  *   idle  'never'    = 늘 같은 주기(심박 — 살아 있음이 신호다, 서버는 90초 침묵을 죽음으로 본다)
  *         'slow'     = 마지막 도구 호출 뒤 IDLE_AFTER_MS 가 지나면 IDLE_EVERY_MS 에 한 번만. 도구를 부르면 곧 복귀
+ *   once  true       = 타이머 없이 뜰 때 한 번만 돈다(주소 등록 — 2026-10-07). 그 뒤는 도구 호출·메일 폴이 맡는다
  *
  * 타이머가 아닌 것(심박 바퀴 안에서 사건·시각으로 도는 것): resolve(10분 TTL·사건 기반) · 판 비교(30분) ·
  * 되찾기 훑기(5분) · 자동 올리기(90초 하한, 동의 관문). 메일은 훅 레인이 있으면 도구 호출 때 긷는다(60초 상한).
@@ -9401,13 +11020,18 @@ const SCHEDULE = [
   { name: 'mail',    every: MAIL_POLL_MS,     lane: 'hookless', idle: 'slow',  tick: () => { mailPull().catch(() => {}); },
     ready: mailPollReady,
     why: '훅 레인이 없는 세션의 편지함 — 훅 레인이 있으면 도구 호출 때 긷는다' },
+  { name: 'address', every: 0,                lane: 'all',      idle: 'never', once: true, tick: () => { mailRegisterBoot().catch(() => {}); },
+    ready: mailPollReady,
+    why: '뜰 때 아는 소속처에 주소를 한 번 댄다 — 도구를 불러야만 대면 다시 뜬 세션이 첫 호출까지 서버에 옛 이름으로 남는다(계약 2)' },
 ];
 
 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;
+    if (row.once) { row.lastRun = Date.now(); row.tick(); continue; }   // 타이머를 안 건다 — 뜰 때 한 번
     const run = () => {
       if (row.lane === 'hookless' && hookLane()) return;
       const now = Date.now();
@@ -9422,17 +11046,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 이 빠져 있었다.** 사람이 「대화창을 닫는다」고 할 때 실제로 오는 신호가 그것인데
@@ -9443,12 +11069,12 @@ 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)); });
   }
 }
 
 // 시험용 — 서버 동작에는 쓰이지 않는다. materializeAssets 만 네트워크를 쓴다.
-export { videoThumbs, taskReadTools, taskReadRequest, taskReadResult,
+export { videoThumbs, taskReadTools, taskReadRequest, taskReadResult, taskWriteResult, taskCodeOf,
          encodeAsset, imageDims, imageHostAllowed, materializeAssets, warnText, IMAGE_HOST_ALLOW, HOST_ALLOW,
          scrubTranscript, splitAtLines, PUSH_PART_MAX,
          // DESIGN-genetics-ssot.md §3·§5 — 색인·잠금·폴더 identity·알림 문구의 순수/파일 함수(시험이 걷는다)
@@ -9469,6 +11095,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,
@@ -9481,4 +11108,14 @@ export { videoThumbs, taskReadTools, taskReadRequest, taskReadResult,
          planPush, pushSession, pushAppend, capsNote, capsAppend, capsScrubRev, capsFile, capsAppendGone, CAPS_FALSE_TTL_MS,
          readAt, lastNewlineAt, countLines, appendScan, splitSeg, foldHist, scrubDelta, hashRange, pushTenantId,
          APPEND_ENV_MAX, APPEND_RAW_STEP, APPEND_ROUND_MAX,
-         autoFullBudgetOf, autoFullCounts, autoDupOf, PUSH_FULL_BUDGET, PUSH_FULL_WINDOW_MS, PUSH_FULL_REBASE, PUSH_FULL_LOG_MAX };
+         autoFullBudgetOf, autoFullCounts, autoDupOf, PUSH_FULL_BUDGET, PUSH_FULL_WINDOW_MS, PUSH_FULL_REBASE, PUSH_FULL_LOG_MAX,
+         // 주소 계약 2(2026-10-07) — 등록부 JS 사본(세포와 같은 계약)·세포 답의 모양·서버 이름 꼴·보낸 결과 안내·답장 주소(시험이 표로 걷는다)
+         harnessSessionsDir, harnessInt, harnessNameClean, harnessNameOk, procStartEpoch, harnessRowOf, harnessRowsIn, harnessRowLive,
+         harnessLiveRow, harnessSelfKeys, harnessSelfRow, harnessProbe, procStartOf, selfAddressJs, introNameIn, introNameOf,
+         lastIntroInRange, cellSelfParse, mailNameOk, mailAddrNote, mailToSession, mailReplyHints,
+         // 이름 관문(2026-10-07) — 세포 `self_whereabouts`·`session_whereabouts`·`claude_transcript_in` 의 사본과 세포에 묻는 길(smoke 3-4 가 같은 픽스처에 댄다)
+         harnessHome, harnessConfigDir, claudeProjectBases, claudeTranscriptIn, claudeIntroName, introOfFile, INTRO_LINE_MAX,
+         harnessWhereaboutsOf, harnessWhereabouts, harnessSelfWhereabouts, isoUtc, selfAddress,
+         // 검증 반영(2026-10-07) — pidDomain(F1) · 세 갈래 산가(F5) · 고르기·산 줄 수(L1·SEC-1) · 찾은 열쇠(SEC-2) · /clear 따라가기(F2) · 이름 확인(SEC-5)
+         pidDomainOf, harnessPidDomain, harnessRowLife, harnessLookup, harnessSelfLookup, harnessWithRows,
+         myAgentName, mailSelf, mailRegister, mailNameSeen };