axmap-cli 1.3.1 → 1.3.3

package/README.ko.md

@@ -24,6 +24,18 @@ axmap setup
 MCP를 사용하려면 설정 후 AI 도구를 다시 시작한다.
 함께 작업하는 사람과 에이전트는 같은 원격 장부를 사용해야 서로의 선점을 볼 수 있다.
 
+## 1.3.3: Windows Codex 등록 오류 수정
+
+Windows에서 npm으로 설치한 Codex도 `axmap setup`으로 정상 등록한다. 셸 실행 파일 대신 패키지의 Node 진입점을 직접 실행해 경로와 인수를 그대로 전달한다.
+
+## 1.3.2: 쪽지 표시 이름과 사용자 자동 공유
+
+대화형 `setup`에서 `장효준`, `John Smith`처럼 쪽지에 표시할 이름을 입력한다. 입력 없이 설정하거나 오타를 고치려면 `axmap setup --name "장효준"`을 실행한다. 재설치할 때는 저장된 이름을 유지하며 Git 이름·이메일 설정은 바꾸지 않는다.
+
+각 repo에서 axMap을 처음 사용하면 해당 repo의 Git 이메일을 읽고 기존 `axmap/users` 고아 브랜치에 표시 이름을 자동 공유한다. 코드 커밋이나 repo별 수동 등록은 필요 없다. 다른 팀원은 사용자 정보 동기화 후 수신자로 발견한다. 원격 push 권한이 필요하며, 공유 실패는 경고하고 다음 사용 때 재시도한다. `setup`만 실행하고 사용한 적 없는 repo에는 등록하지 않는다.
+
+`axmap bus contacts`로 수신자 이름·이메일을 확인한다. 아는 이름으로 보낸 쪽지는 이메일 주소로 저장하므로 이름을 고쳐도 수신·읽음 기록이 이어진다. 동명이인은 이메일로 지정한다. 쪽지 자동 등록은 투표권이나 MR 승인 권한을 부여하지 않는다.
+
 자세한 설치·설정은 [docs/INSTALL.md](https://github.com/rl2aderjoon/axmap/blob/main/docs/INSTALL.md)를 참고한다.
 
 ## 1.3.1: 어느 폴더에서든 setup 한 번, 이후 repo 자동 연결

package/README.md

@@ -24,8 +24,18 @@ axmap setup
 Restart your AI tool after setup to use MCP.
 People and agents working together must share the same remote ledger to see each other's claims.
 
+During interactive setup, enter the name people should use for messages, such as `John Smith` or `장효준`. To set or correct it without a prompt, run `axmap setup --name "John Smith"`. Reinstallation keeps the saved name. Git's name and email settings are unchanged.
+
+On first use in a repository, axMap reads that repository's Git email and shares your display name through the existing `axmap/users` branch. No code commit or per-repository manual registration is needed. Teammates discover it when their user information synchronizes. This requires push access; an offline or rejected update is reported and retried. Setup alone does not announce you to repositories you have never used.
+
+Use `axmap bus contacts` to list known names and email addresses. Messages sent to a known name are addressed to its email, so correcting the name preserves delivery and read history. If multiple people use the same name, specify the recipient's email. Messaging registration does not grant voting or MR approval rights.
+
 See [docs/INSTALL.md](https://github.com/rl2aderjoon/axmap/blob/main/docs/INSTALL.md) for installation and configuration details (Korean).
 
+## 1.3.3: Windows Codex registration fix
+
+`axmap setup` now registers Codex correctly when Codex is installed through npm on Windows. It launches the package's Node entry directly, preserving paths and arguments without a shell.
+
 ## Global setup and automatic repositories in 1.3.1
 
 Set up axMap once, then open Codex or another AI CLI in any Git repository. axMap selects that session's repository and prepares its ledger on the first status or claim request. There is no per-repository `axmap init` step.

package/bin/axmap.mjs

@@ -47,6 +47,7 @@ import { stateDir } from '../src/repotarget.mjs'
 import { homeRegistrations } from '../src/mcpstate.mjs'
 import { compareBranchFor, formatOverlap } from '../src/overlap.mjs'
 import { withRepoLock } from '../src/repolock.mjs'
+import { readProfile, syncConfiguredProfile } from '../src/identity.mjs'
 
 /** 이 CLI 가 들어 있는 axMap 폴더. 갱신 확인과 setup 이 자기 위치를 알아야 한다. */
 const SELF_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
@@ -453,9 +454,17 @@ function unreadNotes(root, me) {
   }
   if (!found.length) return []
   let seen = ''
+  const email = (process.env.AXMAP_AGENT_EMAIL || git(['config', 'user.email'], { cwd: root }).out).trim().toLowerCase()
+  const mine = new Set([me.toLowerCase(), email].filter(Boolean))
+  try { const p = readProfile(); if (p) mine.add(p.name.toLowerCase()) } catch { /* profile sync reports it */ }
+  try {
+    const state = JSON.parse(fs.readFileSync(path.join(usersFilesDir(root), `${email}.json`), 'utf8'))
+    for (const n of [state.name, ...(state.aliases ?? [])]) if (n) mine.add(n.toLowerCase())
+    seen = state.seen ?? ''
+  } catch { /* no shared state */ }
   try {
     const raw = JSON.parse(fs.readFileSync(path.join(root, '.axmap-bus-seen.json'), 'utf8'))
-    seen = raw[me] ?? ''
+    for (const [key, id] of Object.entries(raw)) if (mine.has(key.toLowerCase()) && id > seen) seen = id
   } catch { /* 처음이면 아무것도 안 읽은 것 */ }
 
   const out = []
@@ -471,8 +480,8 @@ function unreadNotes(root, me) {
     const from = g('from')
     const to = g('to')
     // 내가 보낸 것은 뺀다 — 자기 쪽지에 자기가 놀라면 안 된다.
-    if (from === me) continue
-    if (to !== me && to !== 'all') continue
+    if (g('fromEmail') ? mine.has(g('fromEmail').toLowerCase()) : mine.has(from.toLowerCase())) continue
+    if (!to.split(',').some((v) => v.trim().toLowerCase() === 'all' || mine.has(v.trim().toLowerCase()))) continue
     out.push({ id, from, subject: g('subject') })
   }
   return out
@@ -504,6 +513,11 @@ function markBusSeen(root, me, id) {
     all[me] = id
     fs.writeFileSync(file, JSON.stringify(all, null, 2) + '\n')
   } catch { /* 조용히 */ }
+  // Use the same email-keyed receipt as MCP, while retaining the legacy file
+  // for older installations that still share this checkout.
+  spawnSync(process.execPath, [path.join(SELF_ROOT, 'tools', 'bus.mjs'), 'seen', '--mine', id], {
+    cwd: root, env: { ...process.env, AXMAP_AGENT: me }, encoding: 'utf8', windowsHide: true,
+  })
 }
 
 /**
@@ -722,18 +736,10 @@ function claimsDir(root) {
   return path.join(ledgerDir(root), 'claims')
 }
 
-/**
- * 쪽지함은 **일부러 `root` 그대로 둔다.**
- *
- * 장부와 같은 `.axmap/` 아래라 같은 문제가 있지만(링크된 worktree 에는 없다),
- * 고치려면 `tools/bus.mjs` 의 `SEEN_FILE`·쪽지함 경로까지 같이 옮겨야 한다.
- * 한쪽만 옮기면 **읽는 곳과 쓰는 곳이 갈려** 읽음 표시가 어긋난다 —
- * 쪽지가 안 보이는 것보다 나쁘다. 장부와 달리 여기서는 못 찾아도 죽지 않고
- * "새 쪽지 없음" 으로 조용히 지나가므로, 링크된 worktree 에서 쪽지가 안 보이는
- * 것은 남는 구멍으로 적어 둔다.
- */
+/** Message and user worktrees follow the same common checkout as the ledger.
+ * Git identity is still read from the caller's working repository. */
 function busDir(root) {
-  return path.join(root, BUS_REL)
+  return path.join(axmapHome(root), BUS_REL)
 }
 
 /** 쪽지 파일이 실제로 쌓이는 곳. 브랜치 루트에 흩뿌리지 않고 한 폴더 아래 모은다. */
@@ -742,7 +748,7 @@ function busMessagesDir(root) {
 }
 
 function usersDir(root) {
-  return path.join(root, USERS_REL)
+  return path.join(axmapHome(root), USERS_REL)
 }
 
 /** 사람마다의 파일이 쌓이는 곳. `.gitattributes` 와 섞이지 않게 한 폴더 아래 모은다. */
@@ -1343,9 +1349,17 @@ function ensureOrphan(root, { branch, rel, dir, what, seed }) {
   const remote = r.source === 'ambiguous' ? null : r.name
 
   let base = null
-  if (remote && git(['fetch', '--quiet', remote, branch], { cwd: root }).code === 0) {
-    base = git(['rev-parse', 'FETCH_HEAD'], { cwd: root }).out
-  } else {
+  if (r.source === 'ambiguous') return fail({ err: '원격이 모호합니다. git config axmap.remote <원격>을 지정하세요.' })
+  if (remote) {
+    const exists = git(['ls-remote', '--exit-code', remote, `refs/heads/${branch}`], { cwd: root })
+    if (exists.code !== 0 && exists.code !== 2) return fail(exists)
+    if (exists.code === 0) {
+      const fetched = git(['fetch', '--quiet', remote, branch], { cwd: root })
+      if (fetched.code !== 0) return fail(fetched)
+      base = git(['rev-parse', 'FETCH_HEAD'], { cwd: root }).out
+    }
+  }
+  if (!base) {
     // 빈 트리 -> 부모 없는 커밋 -> 브랜치. 작업 트리를 건드리지 않는 고아 브랜치.
     const tree = git(['mktree'], { cwd: root, input: '' })
     if (tree.code !== 0) return fail(tree)
@@ -1361,6 +1375,8 @@ function ensureOrphan(root, { branch, rel, dir, what, seed }) {
   const w = git(['worktree', 'add', '--quiet', dir, branch], { cwd: root })
   if (w.code !== 0) return fail(w)
 
+  excludeAxmap(root)
+
   seed(dir)
 
   // 🔴 고아 브랜치는 **자기 트리의 `.gitattributes` 만** 본다. 저장소 루트에
@@ -1386,6 +1402,16 @@ function ensureOrphan(root, { branch, rel, dir, what, seed }) {
   return 'created'
 }
 
+function excludeAxmap(root) {
+  const file = path.resolve(root, gitOrDie(['rev-parse', '--git-path', 'info/exclude'], { cwd: root }).out)
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  let text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
+  for (const entry of ['.axmap/', '.axmap-bus-seen.json']) {
+    if (!text.split(/\r?\n/).includes(entry)) text += (text && !text.endsWith('\n') ? '\n' : '') + entry + '\n'
+  }
+  fs.writeFileSync(file, text)
+}
+
 function ensureBus(root) {
   return ensureOrphan(root, {
     branch: BUS_BRANCH, rel: BUS_REL, dir: busDir(root), what: '쪽지함',
@@ -1424,7 +1450,7 @@ function cmdBusRepair() {
   const root = repoRoot()
   // .axmap 을 손으로 지웠어도 git 쪽에 worktree 등록이 남아 add 가 실패한다.
   git(['worktree', 'prune'], { cwd: root })
-  const r = ensureBus(root)
+  const r = withRepoLock(path.join(commonDir(root), 'axmap-init.lock'), () => ensureBus(root))
   if (r === 'failed') process.exit(1)
   console.log(
     r === 'ready'
@@ -1437,7 +1463,7 @@ function cmdBusRepair() {
 function cmdUsersRepair() {
   const root = repoRoot()
   git(['worktree', 'prune'], { cwd: root })
-  const r = ensureUsers(root)
+  const r = withRepoLock(path.join(commonDir(root), 'axmap-init.lock'), () => ensureUsers(root))
   if (r === 'failed') process.exit(1)
   console.log(
     r === 'ready'
@@ -2898,3 +2924,12 @@ switch (cmd) {
     console.log(HELP)
     process.exit(cmd ? 1 : 0)
 }
+
+// Setup stores a label, never a repository pin. Publish it only after an
+// actual successful collaboration command in the selected working repository.
+if (['init', 'claim', 'release', 'renew', 'status'].includes(cmd)) {
+  const warning = syncConfiguredProfile(process.cwd(), path.join(SELF_ROOT, 'tools', 'bus.mjs'), {
+    ...process.env, ...(flags.agent ? { AXMAP_AGENT: flags.agent } : {}),
+  })
+  if (warning) console.error(warning)
+}

package/mcp/server.mjs

@@ -45,6 +45,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import readline from 'node:readline'
 import { fileURLToPath } from 'node:url'
+import { syncConfiguredProfile } from '../src/identity.mjs'
 
 const HERE = path.dirname(fileURLToPath(import.meta.url))
 
@@ -311,7 +312,7 @@ function unreadBanner(tool, text) {
   //    떼는 순간 여기가 조용히 낡는다 — 목록은 언제나 코드보다 먼저 낡는다.
   if (text.includes('안 읽은 쪽지')) return ''
 
-  const r = bus(['list', '--to', AGENT, '--unread', '--no-mark',
+  const r = bus(['list', '--mine', '--unread', '--no-mark',
     '--throttle', String(BUS_POLL), '--quiet-if-empty'])
   if (r.code !== 0) return ''
   const rows = busRows(r.out)
@@ -331,7 +332,7 @@ function unreadBanner(tool, text) {
 
   // 🔴 배너를 다 만든 뒤에 찍는다. 위에서 죽으면 안 찍혀야 다음에 다시 뜬다.
   const ids = shown.map((s) => s.id).filter(Boolean)
-  if (ids.length) bus(['seen', '--to', AGENT, ...ids])
+  if (ids.length) bus(['seen', '--mine', ...ids])
   return banner
 }
 
@@ -358,7 +359,7 @@ function cli(args) {
     cwd: REPO,
     encoding: 'utf8',
     windowsHide: true,
-    env: { ...process.env, AXMAP_AGENT: AGENT, AXMAP_ACTOR: ACTOR, AXMAP_SESSION: SESSION },
+    env: { ...process.env, AXMAP_AGENT: AGENT, AXMAP_ACTOR: ACTOR, AXMAP_SESSION: SESSION, AXMAP_SKIP_PROFILE_SYNC: '1' },
   })
   const stdout = (r.stdout ?? '').trim()
   const stderr = (r.stderr ?? '').trim()
@@ -737,7 +738,7 @@ function releaseAllIn(dir) {
     cwd: dir,
     encoding: 'utf8',
     windowsHide: true,
-    env: { ...process.env, AXMAP_AGENT: AGENT, AXMAP_ACTOR: ACTOR, AXMAP_SESSION: SESSION },
+    env: { ...process.env, AXMAP_AGENT: AGENT, AXMAP_ACTOR: ACTOR, AXMAP_SESSION: SESSION, AXMAP_SKIP_PROFILE_SYNC: '1' },
   })
   return {
     code: r.status ?? 1,
@@ -859,7 +860,7 @@ function dispatch(name, args = {}) {
       //    겹치지만 `markSeen` 은 뒤로 가지 않으므로 결과가 같다.
       //
       //    전부 보려면 `all: true` 가 이미 있다 — 그쪽은 거르지도 찍지도 않는다.
-      const a = args.id ? ['read', String(args.id)] : ['list', ...(args.all ? ['--all'] : ['--to', AGENT, '--unread'])]
+      const a = args.id ? ['read', String(args.id)] : ['list', ...(args.all ? ['--all'] : ['--mine', '--unread'])]
       const r = bus(a)
 
       // 🔴 여기도 **낸 것만 찍는다.** 목록을 자르지 않으므로 낸 것 전부다.
@@ -870,7 +871,7 @@ function dispatch(name, args = {}) {
       //    id 로 찍으면 **나에게 온 안 읽은 쪽지가 화면에 뜬 적 없이 묻힌다.**
       if (r.code === 0 && !args.id && !args.all) {
         const ids = busRows(r.out).map((s) => s.id).filter(Boolean)
-        if (ids.length) bus(['seen', '--to', AGENT, ...ids])
+        if (ids.length) bus(['seen', '--mine', ...ids])
       }
       return {
         ok: r.code === 0,
@@ -1007,7 +1008,8 @@ async function handle(req) {
       do { task = rootsTask; await task } while (task !== rootsTask)
     }
     const r = callTool(params?.name, params?.arguments ?? {})
-    return { content: [{ type: 'text', text: r.text + (r.ok ? unreadBanner(params?.name, r.text) : '') }], isError: !r.ok }
+    const warning = r.ok ? syncConfiguredProfile(REPO, BUS, { ...process.env, AXMAP_AGENT: AGENT }) : ''
+    return { content: [{ type: 'text', text: r.text + (warning ? '\n' + warning : '') + (r.ok ? unreadBanner(params?.name, r.text) : '') }], isError: !r.ok }
   }
   if (method === 'ping') return {}
   return null // 알림이거나 지원하지 않는 메서드

package/package.json

@@ -1,7 +1,7 @@
 {
   "//name": "🔴 npm 의 'axmap' 은 2022년부터 남이 쓰고 있는 다른 꾸러미다(leozin_ 의 Map 라이브러리, 1.1.2). 그래서 `npx axmap` 은 우리 것이 아니고, 누구에게도 그렇게 안내하면 안 된다. 2026-08-28 에 axmap-cli 로 정했다 — 스코프(@사용자/이름)를 쓰지 않는 이유는 스코프가 npm 계정 이름에 묶여서 나중에 팀이나 조직으로 옮길 때 이름이 통째로 바뀌기 때문이다. 사람이 치는 **명령** 이름은 그대로 axmap 이다 (아래 bin) — 꾸러미 이름과 명령 이름은 달라도 된다.",
   "name": "axmap-cli",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "//private": "🔴 여기 있던 \"private\": true 를 2026-08-28 에 지웠다. 그 줄이 있는 동안 npm publish 는 거부됐다. 되돌리려면 다시 넣으면 되지만, 이미 올라간 버전은 그래도 안 사라진다 — npm 은 같은 번호를 덮어쓰지 못하고 삭제도 72시간 안에만 된다. 즉 이 줄을 되살리는 것은 '앞으로 안 올린다' 는 뜻이지 '올린 것을 없앤다' 는 뜻이 아니다.",
   "//publishConfig": "axmap-cli 는 스코프가 없어서 기본이 이미 공개다. 즉 지금은 없어도 된다. 그래도 남겨 두는 이유: 나중에 @조직/axmap 처럼 스코프를 붙이는 날 이 줄이 없으면 publish 가 '유료 플랜이 필요하다'는 엉뚱한 말로 실패한다.",
   "publishConfig": {

package/src/identity.mjs

@@ -0,0 +1,62 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { agentNameError } from './protocol.mjs'
+
+// Only the display name is global. Email is resolved from the working repo so
+// a work identity never silently becomes the address used in a personal repo.
+export const profilePath = (home = os.homedir()) => path.join(home, '.axmap', 'profile.json')
+
+export function displayNameError(name) {
+  if (typeof name !== 'string') return '표시 이름은 문자열이어야 합니다.'
+  return agentNameError(name) || (/[,;@\u007f]/.test(name)
+    ? '표시 이름에는 쉼표·세미콜론·@ 문자를 쓸 수 없습니다.'
+    : name.toLowerCase() === 'all' ? 'all은 전체 수신자를 뜻하므로 표시 이름으로 쓸 수 없습니다.' : null)
+}
+
+export function readProfile(home) {
+  const file = profilePath(home)
+  let data
+  try { data = JSON.parse(fs.readFileSync(file, 'utf8')) } catch (e) {
+    if (e.code === 'ENOENT') return null
+    throw new Error(`표시 이름 설정을 읽지 못했습니다: ${file} (${e.message})`)
+  }
+  const error = displayNameError(data?.name)
+  if (data?.version !== 1 || error || (data.updatedAt && !Number.isFinite(Date.parse(data.updatedAt)))) throw new Error(`표시 이름 설정이 올바르지 않습니다: ${file}${error ? ` (${error})` : ''}`)
+  return data
+}
+
+export function writeProfile(name, home) {
+  const error = displayNameError(name)
+  if (error) throw new Error(error)
+  const previous = readProfile(home)
+  const file = profilePath(home)
+  const data = { ...previous, version: 1, name,
+    updatedAt: previous?.name === name && previous.updatedAt ? previous.updatedAt : new Date().toISOString() }
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  const tmp = `${file}.tmp-${process.pid}`
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 })
+    fs.renameSync(tmp, file)
+  } finally { fs.rmSync(tmp, { force: true }) }
+  return data
+}
+
+export function emailError(email) {
+  // This address also becomes a filename on Windows; reject unsafe Git config
+  // values rather than rewriting two different addresses to the same file.
+  return typeof email !== 'string' || !/^[^\s@\\/:*?"<>|,;\u0000-\u001f]+@[^\s@\\/:*?"<>|,;\u0000-\u001f]+$/.test(email)
+    || /[.\s]$/.test(email) ? 'Git 이메일이 없거나 사용자 주소로 쓸 수 없습니다. git config user.email을 확인하세요.' : null
+}
+
+export function syncConfiguredProfile(repo, bus, env = process.env) {
+  if (env.AXMAP_SKIP_PROFILE_SYNC === '1') return ''
+  try {
+    if (!readProfile()) return ''
+    const r = spawnSync(process.execPath, [bus, 'profile'], {
+      cwd: repo, env, encoding: 'utf8', windowsHide: true,
+    })
+    return (r.stderr || (r.status !== 0 ? '경고: 쪽지 프로필 공유에 실패했습니다. 다음 사용 때 재시도합니다.' : '')).trim()
+  } catch (e) { return `경고: ${e.message}` }
+}

package/tools/bus.mjs

@@ -34,6 +34,10 @@ import { execFileSync, spawnSync } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { agentNameError } from '../src/protocol.mjs'
+import { readProfile, profilePath, emailError } from '../src/identity.mjs'
+import { withRepoLock } from '../src/repolock.mjs'
+import { randomUUID } from 'node:crypto'
 
 /** **이 프로그램**의 뿌리. 데이터가 아니라 코드를 찾을 때만 쓴다 (`who` 의 axmap.mjs). */
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
@@ -85,7 +89,11 @@ const REPO = (() => {
 })()
 
 /** 쪽지 worktree 의 루트. 커밋·push 는 여기서 돈다. */
-const BUS_WT = REPO ? path.join(REPO, '.axmap', 'bus') : null
+const COMMON = REPO ? path.resolve(REPO, execFileSync('git', ['rev-parse', '--git-common-dir'], {
+  cwd: REPO, encoding: 'utf8', windowsHide: true,
+}).trim()) : null
+const DATA_HOME = COMMON ? (path.basename(COMMON) === '.git' ? path.dirname(COMMON) : REPO) : null
+const BUS_WT = REPO ? path.join(DATA_HOME, '.axmap', 'bus') : null
 const BUS_BRANCH = 'axmap/bus'
 
 /** **쓰는 곳은 하나뿐이다.** */
@@ -273,14 +281,14 @@ const recipientsOf = (m) => String(m.to ?? 'all').split(',').map(norm).filter(Bo
  */
 function me() {
   const v = process.env.AXMAP_AGENT
-  if (v && /^[\w.-]{1,64}$/.test(v)) return v
+  if (v && !agentNameError(v)) return v
   try {
     const n = execFileSync('git', ['config', 'user.name'], {
       cwd: REPO ?? process.cwd(), encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
     }).trim()
     // 서버와 달리 여기서는 형식을 본다. 통과 못 하면 아래에서 죽는다 —
     // 못 읽는 이름을 그냥 쓰면 파일 이름과 필터가 조용히 어긋난다.
-    if (n && /^[\w.-]{1,64}$/.test(n)) return n
+    if (n && !agentNameError(n)) return n
   } catch { /* 아래에서 죽는다 */ }
   console.error(
     'AXMAP_AGENT 를 먼저 정하세요 (선점과 같은 값).\n' +
@@ -319,30 +327,14 @@ function roster() {
   if (rosterCache) return rosterCache
   const byEmail = new Map()
 
-  /**
-   * 🔴 **이름 하나는 사람 하나에게만 붙는다. 먼저 붙은 쪽이 이긴다.**
-   *
-   *    이 줄이 없으면 어긋난 쪽지 한 통이 두 사람을 영구히 합친다. 실제로 그랬다 —
-   *    도구 이름은 `alice` 인데 git 이메일이 `bob@x.com` 인 쪽지가 하나 있었고,
-   *    그 뒤로 `alice` 가 bob 의 이름이 됐다. 그러면 bob 은 alice 가 보낸 쪽지를
-   *    **자기가 보낸 것으로 보고 안 읽음에서 지운다.**
-   *
-   *    이름이 어긋나 쪽지가 묻히는 것이 이 판에서 고치려던 바로 그 증상인데,
-   *    신원을 합치는 방식으로 고치면 **자리만 바꿔서 되살아난다.**
-   *
-   *    순서가 곧 우선순위다: git 이력(1) → 쪽지 머리말(2) → 적어 둔 별칭(3).
-   *    git 이력이 가장 믿을 만하다 — 사람이 자기 PC 에 직접 설정한 값이다.
-   */
-  const nameOwner = new Map()
+  // Keep homonyms as separate email identities. Recipient resolution rejects
+  // an ambiguous label instead of silently assigning it to the first author.
   const add = (email, name) => {
     const e = norm(email)
     if (!e || !e.includes('@')) return
     if (!byEmail.has(e)) byEmail.set(e, { email: e, names: new Set() })
     const n = norm(name)
     if (!n) return
-    const owner = nameOwner.get(n)
-    if (owner && owner !== e) return          // 이미 남의 이름이다. 합치지 않는다
-    nameOwner.set(n, e)
     byEmail.get(e).names.add(n)
   }
 
@@ -383,6 +375,7 @@ function roster() {
       const st = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'))
       const email = f.replace(/\.json$/, '')
       add(email, st.name)
+      if (byEmail.has(norm(email))) byEmail.get(norm(email)).displayName = st.name
       for (const a of (st.aliases ?? [])) add(email, a)
     }
   } catch { /* 사람별 상태가 아직 없다. 1)·2)만으로도 명단은 선다 */ }
@@ -399,8 +392,13 @@ function roster() {
  */
 function addressesOf(who) {
   const w = norm(who)
-  const p = roster().find((x) => x.email === w || x.names.has(w))
-  return p ? new Set([p.email, ...p.names]) : new Set([w])
+  const people = roster()
+  const matches = people.filter((p) => p.email === w || p.names.has(w))
+  if (matches.length !== 1) return new Set([w])
+  const p = matches[0]
+  // A shared label must never make two mailboxes the same person. Known
+  // homonyms can still receive mail through their unambiguous email addresses.
+  return new Set([p.email, ...[...p.names].filter((n) => people.filter((x) => x.names.has(n)).length === 1)])
 }
 
 /**
@@ -466,8 +464,12 @@ function myAddresses() {
   const s = new Set()
   const e = myEmail()
   if (e) for (const a of addressesOf(e)) s.add(a)
-  s.add(norm(me()))
-  if (process.env.AXMAP_AGENT) s.add(norm(process.env.AXMAP_AGENT))
+  const ownName = (name) => {
+    if (roster().filter((p) => p.names.has(norm(name))).length < 2) s.add(norm(name))
+  }
+  ownName(me())
+  if (process.env.AXMAP_AGENT) ownName(process.env.AXMAP_AGENT)
+  try { const p = readProfile(); if (p) ownName(p.name) } catch { /* reported during profile sync */ }
   return s
 }
 
@@ -489,7 +491,7 @@ function myAddresses() {
 const SEEN_FILE = REPO ? path.join(REPO, '.axmap-bus-seen.json') : null
 
 /** 새 자리 — 고아 브랜치 `axmap/users` 의 worktree. 사람마다 파일 하나. */
-const USERS_WT = REPO ? path.join(REPO, '.axmap', 'users') : null
+const USERS_WT = REPO ? path.join(DATA_HOME, '.axmap', 'users') : null
 const USERS_BRANCH = 'axmap/users'
 const usersReady = () => USERS_WT !== null && fs.existsSync(path.join(USERS_WT, '.git'))
 
@@ -528,8 +530,9 @@ function openUsers() {
 /** 이 사람의 파일 자리. **이메일이 정본**이고, 없는 사람만 이름으로 떨어진다. */
 function userKey(who) {
   const w = norm(who)
-  const p = roster().find((x) => x.email === w || x.names.has(w))
-  return p ? p.email : w
+  if (w.includes('@')) return w
+  const matches = roster().filter((x) => x.names.has(w))
+  return matches.length === 1 ? matches[0].email : w
 }
 
 const userFile = (who) => path.join(USERS_WT, 'users', `${userKey(who)}.json`)
@@ -539,19 +542,148 @@ function readUserState(who) {
 }
 
 /** 원격의 사람별 상태를 받아온다. 자주 물을 이유가 없어 느슨하게 맞춘다. */
+function usersRemote() {
+  const configured = process.env.AXMAP_REMOTE || gitUsers(['config', '--get', 'axmap.remote'], { cwd: REPO }).out
+  if (configured) return configured
+  const names = gitUsers(['remote'], { cwd: REPO }).out.split('\n').filter(Boolean)
+  if (names.length === 1) return names[0]
+  if (names.includes('origin')) return 'origin'
+  if (names.length) throw new Error('사용자 정보를 공유할 원격이 모호합니다. git config axmap.remote <원격>을 지정하세요.')
+  return null
+}
+
+function mustUsers(args) {
+  const r = gitUsers(args)
+  if (r.code !== 0) throw new Error(r.err || r.out || `git ${args[0]} 실패`)
+  return r.out
+}
+
+function mergeState(local, incoming) {
+  const newest = (incoming.profileUpdatedAt ?? '') > (local.profileUpdatedAt ?? '') ? incoming : local
+  const aliases = [...new Set([...(local.aliases ?? []), ...(incoming.aliases ?? []), local.name, incoming.name].filter(Boolean))]
+  const seen = [local.seen ?? '', incoming.seen ?? ''].sort().at(-1)
+  return { ...incoming, ...local, ...newest, aliases: aliases.filter((a) => a !== newest.name), ...(seen ? { seen } : {}) }
+}
+
+// Never reset away unpublished profiles or read receipts. A rejected push is
+// retried on the latest branch, merging only the dedicated JSON user records.
+function syncUsers(remote) {
+  if (!remote) return
+  const exists = gitUsers(['ls-remote', '--exit-code', remote, `refs/heads/${USERS_BRANCH}`])
+  if (exists.code === 2) return
+  if (exists.code !== 0) throw new Error(exists.err || '사용자 정보 원격을 확인하지 못했습니다.')
+  mustUsers(['fetch', '--quiet', remote, USERS_BRANCH])
+  if (gitUsers(['merge', '--ff-only', '--quiet', 'FETCH_HEAD']).code === 0) return
+  const merged = gitUsers(['merge', '--no-commit', '--no-ff', '--allow-unrelated-histories', 'FETCH_HEAD'])
+  const conflicts = mustUsers(['diff', '--name-only', '--diff-filter=U']).split('\n').filter(Boolean)
+  try {
+    for (const f of conflicts) {
+      if (!/^users\/[^/]+\.json$/.test(f)) throw new Error(`사용자 정보 충돌을 자동으로 풀 수 없습니다: ${f}`)
+      const local = JSON.parse(mustUsers(['show', `:2:${f}`]))
+      const incoming = JSON.parse(mustUsers(['show', `:3:${f}`]))
+      fs.writeFileSync(path.join(USERS_WT, f), JSON.stringify(mergeState(local, incoming), null, 2) + '\n')
+      mustUsers(['add', '--', f])
+    }
+    if (merged.code !== 0 && !conflicts.length) throw new Error(merged.err || merged.out)
+    mustUsers(['commit', '--quiet', '--no-verify', '-m', 'axmap: merge user profiles'])
+  } catch (e) {
+    gitUsers(['merge', '--abort'])
+    throw e
+  }
+}
+
+function withUsers(action) {
+  if (!COMMON) return false
+  return withRepoLock(path.join(COMMON, 'axmap-users.lock'), () => {
+    if (!openUsers()) throw new Error('사용자 정보 브랜치를 준비하지 못했습니다.')
+    return action()
+  })
+}
+
 function pullUsers() {
-  if (!openUsers()) return
-  const stampFile = path.join(REPO, '.axmap', '.users-lastfetch')
-  // 🔴 60초. 쪽지함(기본 0초)보다 훨씬 느슨한 것은 **늦어도 손해가 없기 때문**이다.
-  //    늦으면 다른 PC 에서 읽은 것이 여기서 한 번 더 뜬다. 그뿐이다.
-  //    반대로 매번 물으면 도구 호출마다 통신이 한 번씩 더 붙는다 (실측 0.8초).
+  if (!REPO) return
+  const stampFile = path.join(DATA_HOME, '.axmap', '.users-lastfetch')
+  try { if (Date.now() - fs.statSync(stampFile).mtimeMs < 60_000) return } catch { /* first sync */ }
+  try {
+    withUsers(() => {
+      // A fresh local-only orphan still has its seed files unstaged.
+      if (gitUsers(['status', '--porcelain']).out) {
+        mustUsers(['add', '-A'])
+        mustUsers(['commit', '--quiet', '--no-verify', '-m', 'axmap: preserve user state'])
+      }
+      syncUsers(usersRemote())
+      fs.writeFileSync(stampFile, '')
+    })
+  } catch { /* Read receipts remain conservative when synchronization fails. */ }
+}
+
+function updateUser(email, change) {
+  if (emailError(email)) throw new Error(emailError(email))
+  return withUsers(() => {
+    const remote = usersRemote()
+    for (let attempt = 0; attempt < 5; attempt++) {
+      if (gitUsers(['status', '--porcelain']).out) {
+        mustUsers(['add', '-A'])
+        mustUsers(['commit', '--quiet', '--no-verify', '-m', 'axmap: preserve user state'])
+      }
+      syncUsers(remote)
+      const f = path.join(USERS_WT, 'users', `${email}.json`)
+      let cur = {}
+      try { cur = JSON.parse(fs.readFileSync(f, 'utf8')) } catch (e) { if (e.code !== 'ENOENT') throw e }
+      const next = change(cur)
+      if (JSON.stringify(cur) !== JSON.stringify(next)) {
+        fs.mkdirSync(path.dirname(f), { recursive: true })
+        fs.writeFileSync(f, JSON.stringify(next, null, 2) + '\n')
+        mustUsers(['add', '--', `users/${email}.json`])
+        mustUsers(['commit', '--quiet', '--no-verify', '-m', `user: ${email}`])
+      }
+      if (!remote) return 'local'
+      const pushed = gitUsers(['push', '--quiet', remote, `HEAD:refs/heads/${USERS_BRANCH}`])
+      if (pushed.code === 0) {
+        fs.writeFileSync(path.join(DATA_HOME, '.axmap', '.users-lastfetch'), '')
+        return 'shared'
+      }
+      if (attempt === 4) throw new Error(pushed.err || '사용자 정보 push 실패')
+    }
+  })
+}
+
+function publishProfile() {
+  const profile = readProfile()
+  if (!profile || !REPO) return null
+  const email = myEmail()
+  if (emailError(email)) throw new Error(emailError(email))
+  // Successful unchanged profiles need no network more than once a minute.
+  const stamp = path.join(DATA_HOME, '.axmap', '.profile-shared.json')
+  const revision = profile.updatedAt || fs.statSync(profilePath()).mtime.toISOString()
+  const key = JSON.stringify([profile.name, revision, email, me(), usersRemote()])
   try {
-    if (Date.now() - fs.statSync(stampFile).mtimeMs < 60_000) return
-  } catch { /* 처음이다. 받아온다 */ }
-  const remote = gitUsers(['config', '--get', 'axmap.remote'], { cwd: REPO }).out || 'origin'
-  if (gitUsers(['fetch', '--quiet', remote, USERS_BRANCH]).code !== 0) return
-  gitUsers(['reset', '--hard', '--quiet', 'FETCH_HEAD'])
-  try { fs.writeFileSync(stampFile, '') } catch { /* 스탬프 실패는 치명적이지 않다 */ }
+    const last = JSON.parse(fs.readFileSync(stamp, 'utf8'))
+    if (last.key === key && Date.now() - last.at < 60_000) return last.result
+  } catch { /* first use / changed identity */ }
+  const result = updateUser(email, (cur) => {
+    // An older PC must not undo a name correction made on another PC just
+    // because it became active later. Revision belongs to setup, not to use.
+    const name = (cur.profileUpdatedAt ?? '') > revision ? cur.name : profile.name
+    const aliases = [...new Set([...(cur.aliases ?? []), cur.name, profile.name, me()].filter((n) => n && n !== name))]
+    return { ...cur, name, aliases,
+      profileUpdatedAt: (cur.profileUpdatedAt ?? '') > revision ? cur.profileUpdatedAt : revision }
+  })
+  rosterCache = null
+  fs.writeFileSync(stamp, JSON.stringify({ key, at: Date.now(), result }) + '\n')
+  if (result === 'local') console.error('※ 쪽지 프로필을 로컬에만 저장했습니다 — 원격이 없어 다른 팀원에게는 아직 보이지 않습니다.')
+  return result
+}
+
+function messageName() {
+  const profile = readProfile()
+  if (!profile) return me()
+  try {
+    const state = JSON.parse(fs.readFileSync(path.join(USERS_WT, 'users', `${myEmail()}.json`), 'utf8'))
+    const revision = profile.updatedAt || fs.statSync(profilePath()).mtime.toISOString()
+    if ((state.profileUpdatedAt ?? '') > revision && state.name) return state.name
+  } catch { /* unpublished profile / custom standalone mailbox */ }
+  return profile.name
 }
 
 function readSeen(who) {
@@ -564,7 +696,12 @@ function readSeen(who) {
   //    그건 이 도구가 고치려던 바로 그 상태다.
   let legacy = ''
   if (SEEN_FILE) {
-    try { legacy = JSON.parse(fs.readFileSync(SEEN_FILE, 'utf8'))[who] ?? '' } catch { /* 없다 */ }
+    try {
+      const known = addressesOf(who)
+      for (const [name, id] of Object.entries(JSON.parse(fs.readFileSync(SEEN_FILE, 'utf8')))) {
+        if (known.has(norm(name)) && id > legacy) legacy = id
+      }
+    } catch { /* no legacy receipts */ }
   }
   return fromBranch > legacy ? fromBranch : legacy
 }
@@ -592,42 +729,15 @@ function markSeen(who, id) {
     } catch { /* 조용히 */ }
   }
 
-  if (!openUsers()) return
+  const email = myEmail() || userKey(who)
   try {
-    const f = userFile(who)
-    const cur = readUserState(who)
-    if ((cur.seen ?? '') >= id) return          // 뒤로 가지 않는다
-    fs.mkdirSync(path.dirname(f), { recursive: true })
-
-    // 🔴 **별칭은 저절로 적힌다.** 손으로 관리하게 하면 아무도 안 한다.
-    //
-    //    지금 쓰고 있는 이름이 이메일도 아니고 git 이 아는 이름도 아니면, 그것은
-    //    이 사람이 띄운 도구의 이름이다 (codex-jinmiri · jaehyeon-2 처럼). 적어
-    //    두면 다음부터 그 이름으로 온 쪽지도 이 사람 것이 된다.
-    const known = addressesOf(who)
-    const now = norm(me())
-    const aliases = [...new Set([...(cur.aliases ?? []), ...(known.has(now) ? [] : [now])])]
-
-    // 이름도 같이 남긴다 — 파일 이름이 이메일이라 사람이 열었을 때 누구인지 보이게.
-    fs.writeFileSync(f, JSON.stringify({ ...cur, name: me(), aliases, seen: id }, null, 2) + '\n')
-
-    gitUsers(['add', '--', path.relative(USERS_WT, f).replace(/\\/g, '/')])
-    // --no-verify: 연결된 worktree 는 훅을 공유한다. 이 브랜치는 사용자 코드가 아니다.
-    gitUsers(['commit', '--quiet', '--no-verify', '-m', `seen: ${userKey(who)}`])
-
-    // 🔴 push 는 **60초에 한 번**만 시도한다. 커밋은 이 PC 안이라 싸지만 push 는
-    //    통신이고, 쪽지를 볼 때마다 붙으면 모든 도구 호출이 그만큼 느려진다.
-    //    늦게 가도 손해가 없다 — 다른 PC 에서 그 쪽지가 한 번 더 뜰 뿐이다.
-    const stamp = path.join(REPO, '.axmap', '.users-lastpush')
-    let due = true
-    try { due = Date.now() - fs.statSync(stamp).mtimeMs >= 60_000 } catch { /* 처음이다 */ }
-    if (due) {
-      const remote = gitUsers(['config', '--get', 'axmap.remote'], { cwd: REPO }).out || 'origin'
-      if (gitUsers(['push', '--quiet', remote, `HEAD:${USERS_BRANCH}`]).code === 0) {
-        try { fs.writeFileSync(stamp, '') } catch { /* 스탬프 실패는 치명적이지 않다 */ }
-      }
-    }
-  } catch { /* 조용히 — 못 찍으면 다음에 한 번 더 뜰 뿐이다 */ }
+    updateUser(email, (cur) => {
+      const profile = readProfile()
+      const name = profile ? messageName() : (cur.name || me())
+      const aliases = [...new Set([...(cur.aliases ?? []), me()].filter((n) => n !== name))]
+      return { ...cur, name, aliases, seen: (cur.seen ?? '') > id ? cur.seen : id }
+    })
+  } catch { /* Failed read receipts cause a repeat, never a hidden message. */ }
 }
 
 const stamp = (d) => d.toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z')
@@ -734,7 +844,7 @@ function stdin() {
 }
 
 function post({ to, subject, body, replyTo = null }) {
-  const from = me()
+  const from = messageName()
   // 부르는 쪽이 하나를 주든 여럿을 주든 여기서는 목록 하나로 본다.
   let tos = (Array.isArray(to) ? to : (to == null ? [] : [to])).map((s) => String(s).trim()).filter(Boolean)
 
@@ -761,15 +871,17 @@ function post({ to, subject, body, replyTo = null }) {
   //    나중에 `ensureBus` 가 "정상적인 쪽지함이 아닙니다 — 지운 뒤 다시 하세요"
   //    라고 안내한다. **안 간 쪽지를 지우라고 시키는 것**이다. 여기서 멈추면
   //    사람은 init 한 번 하고 다시 보내면 된다 — 잃는 것이 없다.
-  if (!process.env.AXMAP_BUS_DIR && !busReady()) {
-    console.error(
-      '쪽지함이 아직 없습니다. 한 번만 준비하면 됩니다:\n' +
-        '  axmap init            (MCP 에서는 ax_init)\n\n' +
-        '준비 전에 쪽지를 쓰지 않습니다 — 여기 남으면 아무에게도 안 가고,\n' +
-        '나중에 쪽지함을 만들 때 지워야 할 것으로 보입니다.',
-    )
+  if (!openBus()) {
+    reportBusProblem()
     process.exit(1)
   }
+  for (const one of tos) {
+    const matches = roster().filter((p) => p.email === norm(one) || p.names.has(norm(one)))
+    if (norm(one) !== 'all' && !norm(one).includes('@') && matches.length > 1) {
+      console.error(`같은 이름의 수신자가 여러 명입니다: ${one}\n이메일로 지정하세요: ${matches.map((p) => p.email).join(', ')}`)
+      process.exit(1)
+    }
+  }
   // 🔴 **모르는 주소로는 안 보낸다.**
   //
   //    지금까지는 받는 사람 이름을 아무도 검사하지 않았다. 오타 하나면 그 쪽지는
@@ -785,7 +897,7 @@ function post({ to, subject, body, replyTo = null }) {
     if (norm(one) === 'all') continue
     const known = roster().some((p) => p.email === norm(one) || p.names.has(norm(one)))
     if (!known) {
-      const near = nearMatches(one)
+      const near = norm(one).includes('@') ? [] : nearMatches(one)
       if (near.length) {
         // 🔴 **거부하는 것은 오타뿐이다.** 아는 이름과 한 글자 차이거나 그 이름의
         //    앞부분이면 새 사람이 아니라 손이 미끄러진 것이다. 실측에서 실제로
@@ -806,9 +918,15 @@ function post({ to, subject, body, replyTo = null }) {
     }
   }
 
+  // Resolve labels now: later profile corrections cannot redirect an old note.
+  tos = [...new Set(tos.map((one) => {
+    if (norm(one) === 'all') return 'all'
+    const matches = roster().filter((p) => p.email === norm(one) || p.names.has(norm(one)))
+    return matches.length === 1 ? matches[0].email : one
+  }))]
   fs.mkdirSync(BOX, { recursive: true })
   const now = new Date()
-  const id = `${stamp(now)}-${from}-${slug(subject)}`
+  const id = `${stamp(now)}-${from}-${slug(subject)}-${randomUUID().slice(0, 8)}`
   // 🔴 `from` 은 **이름 그대로** 둔다. 파일 이름에 들어가는 값이라 바꾸면 예전
   //    쪽지와 형식이 갈린다. 대신 이메일을 한 줄 더 적는다 — 이름이 나중에
   //    바뀌어도 **누구였는지는 남는다.** 이것이 명단을 세우는 재료가 된다.
@@ -918,7 +1036,7 @@ function selfCmd() {
 function list() {
   pull()
   const all = readAll()
-  const to = has('--mine') ? me() : flag('--to')
+  const to = has('--mine') ? (myEmail() || me()) : flag('--to')
   const from = flag('--from')
 
   // 🔴 **한 사람에게는 주소가 여럿이다.** `--to yeaseung-lee` 로 물어도
@@ -958,7 +1076,7 @@ function list() {
     //    **내 안 읽은 쪽지로 다시 잡힌다.** 주소 전부와 견준다.
     const mine = has('--mine') ? myAddresses() : addressesOf(who)
     rows = rows.filter((m) => m.id > seen
-      && !mine.has(norm(m.from)) && !(m.fromEmail && mine.has(norm(m.fromEmail))))
+      && !(m.fromEmail ? mine.has(norm(m.fromEmail)) : mine.has(norm(m.from))))
   }
 
   // 🔴 **못 읽었으면 "없음" 이라고 답하지 않는다.** 이 세 줄이 이 파일에서 제일
@@ -1054,11 +1172,25 @@ function seen() {
     console.error(`찍을 쪽지 id 를 주세요.  예:  ${selfCmd()} seen <아이디> [<아이디>…]`)
     process.exit(1)
   }
-  markSeen(has('--mine') ? me() : (flag('--to') || me()),
+  markSeen(has('--mine') ? (myEmail() || me()) : (flag('--to') || me()),
     ids.reduce((hi, id) => (id > hi ? id : hi), ''))
 }
 
+let profileResult = null
+if (['profile', 'contacts', 'post', 'reply', 'list', 'read'].includes(cmd)) {
+  try { profileResult = publishProfile() } catch (e) {
+    console.error(`경고: 쪽지 프로필을 공유하지 못했습니다 — ${e.message}`)
+    if (cmd === 'profile') process.exit(1)
+  }
+}
+
 switch (cmd) {
+  case 'profile':
+    if (profileResult) console.log(`쪽지 프로필: ${profileResult}`)
+    break
+  case 'contacts':
+    for (const p of roster()) console.log(`${p.displayName || [...p.names][0] || p.email}\t${p.email}`)
+    break
   case 'post': post({ to: recipientArgs(), subject: flag('--subject'), body: stdin() }); break
   case 'reply': {
     const target = args[1]
@@ -1068,7 +1200,7 @@ switch (cmd) {
     const src = readAll().find((x) => x.id === target || x.id.includes(target))
     if (!src && busProblem) { reportBusProblem(); process.exit(1) }
     if (!src) { console.error(`없는 쪽지: ${target}`); process.exit(1) }
-    post({ to: src.from, subject: flag('--subject') ?? `Re: ${src.subject}`, body: stdin(), replyTo: src.id })
+    post({ to: src.fromEmail || src.from, subject: flag('--subject') ?? `Re: ${src.subject}`, body: stdin(), replyTo: src.id })
     break
   }
   case 'list': list(); break
@@ -1087,6 +1219,7 @@ switch (cmd) {
   ${selfCmd()} seen <아이디> [<아이디>…]   보여준 쪽지만 읽음으로 찍는다
   ${selfCmd()} reply <아이디> < 본문.md
   ${selfCmd()} who          지금 누가 무엇을 잡고 있나
+  ${selfCmd()} contacts     이 저장소의 쪽지 수신자 이름·이메일
 
 목록을 잘라서 보여주는 쪽은 --no-mark 로 읽기만 하고, 자기가 그린 아이디만
 seen 에 넘기세요. 안 그러면 화면에 뜬 적 없는 쪽지가 읽음이 되어 안 보입니다.

package/tools/mcp-register.mjs

@@ -266,8 +266,27 @@ function snippetJson() {
 // 🔴 TOML 을 직접 파싱하지 않는다. 파서를 새로 짜는 것은 이 저장소의 "의존성 없음" 과
 //    "판정을 복잡하게 만들지 않는다" 에 둘 다 어긋나고, 어설픈 파서가 남의 config.toml 을
 //    깨뜨리는 것이 이 작업에서 나올 수 있는 최악의 결과다. 쓰는 일은 codex 자신에게 맡긴다.
+// Windows npm installs expose a shell script and .cmd shim, neither of which
+// spawnSync can execute directly. Launch the package's declared Node entry
+// without a shell so paths and environment values keep their exact contents.
+export function codexInvocation(bin, platform = process.platform) {
+  if (platform === 'win32' && !/\.exe$/i.test(bin)) {
+    const packageDir = path.join(path.dirname(bin), 'node_modules', '@openai', 'codex')
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8'))
+      const entry = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.codex
+      if (entry) {
+        const script = path.resolve(packageDir, entry)
+        if (fs.statSync(script).isFile()) return [process.execPath, script]
+      }
+    } catch { /* Non-npm installations continue to use their original binary. */ }
+  }
+  return [bin]
+}
+
 export function doCodex(bin, { run: injectedRun, dry = DRY } = {}) {
-  const run = injectedRun ?? ((args) => spawnSync(bin, args, { cwd: os.homedir(), encoding: 'utf8', windowsHide: true }))
+  const [command, ...prefix] = codexInvocation(bin)
+  const run = injectedRun ?? ((args) => spawnSync(command, [...prefix, ...args], { cwd: os.homedir(), encoding: 'utf8', windowsHide: true }))
 
   const help = run(['mcp', '--help'])
   if (help.status !== 0 || !/\badd\b/.test(`${help.stdout}${help.stderr}`)) {

package/tools/setup.mjs

@@ -11,7 +11,9 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { createInterface } from 'node:readline/promises'
 
+import { displayNameError, readProfile, writeProfile, profilePath } from '../src/identity.mjs'
 import { agentNameError } from '../src/protocol.mjs'
 
 const HERE = path.dirname(fileURLToPath(import.meta.url))
@@ -58,7 +60,7 @@ axmap setup — 어느 폴더에서든 이 PC에 axMap을 전역 설치·등록
   --repo <경로>        선택 사항: 이 저장소의 장부·커밋 훅도 명시적으로 준비한다
   --remote <이름|URL>  장부를 둘 원격. git 주소를 주면, 그 주소를 가리키는 원격이
                        없을 때 'axmap' 이라는 이름으로 하나 더한다
-  --name <이름>        내 이름 (기본: 전역 git config user.name, 명시적 repo는 로컬 값)
+  --name <이름>        쪽지 표시 이름을 저장한다 (대화형 실행에서는 직접 입력)
   --dest <경로>        프로그램을 둘 자리 (기본: ~/.axmap/app)
   --commands <곳>      슬래시 명령을 둘 자리: global(기본) · project · none
   --hook               프롬프트마다 쪽지를 받는 하네스 훅을 settings.json 에 더한다
@@ -113,12 +115,14 @@ if (projectRequested) {
 }
 
 // ── 3. 이름 ─────────────────────────────────────────────────────────────────
-//
-// [!] 모두에게 같은 기본값을 주면 안 된다. 장부에 한 명만 존재하게 되고, 겹침
-//     판정은 자기 claim 을 겹침으로 보지 않으므로 팀 전원이 서로의 영역을 아무
-//     경고 없이 덮어쓴다. 그래서 이 PC 에서 이미 사람마다 다른 값만 후보로 쓴다.
+// Display labels are independent of claim ownership. The saved label is the
+// default on upgrades; a first setup starts from this person's Git identity.
 let name = flag('--name')
 let nameFrom = '--name'
+if (has('--name') && !name) die('--name 뒤에 표시 이름을 지정하세요.')
+let saved
+try { saved = readProfile() } catch (e) { die(e.message) }
+if (!name && saved) { name = saved.name; nameFrom = '저장된 표시 이름' }
 if (!name) {
   const g = git(REPO ? ['config', 'user.name'] : ['config', '--global', 'user.name'], REPO ?? os.homedir())
   if (g.code === 0 && g.out) { name = g.out; nameFrom = REPO ? 'git config user.name' : 'git config --global user.name' }
@@ -129,10 +133,36 @@ if (!name) {
 if (!name) { name = os.hostname(); nameFrom = '호스트 이름' }
 if (!name) die('이 PC 에서 쓸 이름을 정하지 못했습니다. --name "홍길동" 으로 직접 주세요.')
 
+if (!has('--name') && !DRY && process.stdin.isTTY && process.stdout.isTTY) {
+  const input = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    for (;;) {
+      const answer = (await input.question(`쪽지에 표시할 이름 [${name}]: `)).trim().normalize('NFC')
+      const candidate = answer || name
+      const error = displayNameError(candidate)
+      if (error) { say(error); continue }
+      name = candidate
+      nameFrom = '표시 이름 입력'
+      break
+    }
+  } finally { input.close() }
+}
+
 // 검사기를 다시 짜지 않는다. 여기서 통과시킨 이름을 서버가 거부하면 설치가 거짓말이 된다.
-const nameErr = agentNameError(String(name))
-if (nameErr) die(`이 이름은 장부에서 쓸 수 없습니다: ${name}\n\n${nameErr}`)
-ok('내 이름', `${name}  (${nameFrom})`)
+const nameErr = displayNameError(name)
+if (nameErr) die(`이 표시 이름은 쓸 수 없습니다: ${name}\n\n${nameErr}`)
+if (!DRY) {
+  try { writeProfile(name) } catch (e) { die(e.message) }
+}
+ok('쪽지 이름', `${name}  (${nameFrom}${DRY ? ', 저장 예정' : ''})`)
+const email = git(REPO ? ['config', 'user.email'] : ['config', '--global', 'user.email'], REPO ?? os.homedir()).out
+if (email) ok('Git 이메일', `${email} — 실제 쪽지 주소는 작업 repo의 Git 설정을 사용합니다`)
+else hm('Git 이메일', '작업 repo의 git config user.email을 사용합니다. 이메일은 별도로 저장하지 않습니다.')
+say(`         이름 변경: axmap setup --name "새 이름"  (${profilePath()})`)
+// Changing a message label must not change ownership of existing claims.
+const agentIdentity = git(REPO ? ['config', 'user.name'] : ['config', '--global', 'user.name'], REPO ?? os.homedir()).out
+  || (() => { try { return os.userInfo().username } catch { return os.hostname() } })()
+if (agentNameError(agentIdentity)) die('Git 사용자 이름을 선점 이름으로 쓸 수 없습니다. git config user.name을 확인하세요.')
 
 // ── 4. 장부를 둘 원격 ───────────────────────────────────────────────────────
 //
@@ -211,8 +241,8 @@ function installAndRegister() {
 
   say('')
   const r = win
-    ? spawnSync('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script, '-Source', SOURCE_ROOT, '-Dest', DEST, '-Name', name], { cwd: os.homedir(), stdio: 'inherit', windowsHide: true })
-    : spawnSync('bash', [script, '--source', SOURCE_ROOT, '--dest', DEST, '--name', name], { cwd: os.homedir(), stdio: 'inherit' })
+    ? spawnSync('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script, '-Source', SOURCE_ROOT, '-Dest', DEST, '-Name', agentIdentity], { cwd: os.homedir(), stdio: 'inherit', windowsHide: true })
+    : spawnSync('bash', [script, '--source', SOURCE_ROOT, '--dest', DEST, '--name', agentIdentity], { cwd: os.homedir(), stdio: 'inherit' })
   say('')
 
   if (r.status === 0) ok('설치·등록', DEST)
@@ -241,7 +271,7 @@ function ledgerAndHook() {
     stdio: 'inherit',
     // 이름을 넘겨서 판정을 한 번으로 못 박는다. 여기서 통과한 이름과 나중에 CLI 가
     // 스스로 고르는 이름이 다르면, 자기가 잡은 것을 자기가 반납하지 못한다.
-    env: { ...process.env, AXMAP_AGENT: name },
+    env: { ...process.env, AXMAP_AGENT: agentIdentity },
     windowsHide: true,
   })