axmap-cli 1.5.0 → 1.7.0

package/.claude/commands/pipeline.md

@@ -0,0 +1,9 @@
+---
+description: axMap 로컬 세션 그래프와 실제 요청·응답·토큰 상태를 표시한다
+---
+
+현재 작업 저장소에 대해 `ax_pipeline`을 호출해 MCP Apps 패널을 연다. 연결된 세션, 역할, 요청/응답 연결, 실제 사용량과 이벤트를 표시한다. 토큰/진행률을 추정하거나 모델을 호출하지 않는다.
+
+도구 또는 UI 확장이 없으면 `axmap pipeline --cwd <현재 Git 저장소 절대경로>`로 터미널 그래프를 연다. 대화 출력만 가능한 환경은 `--once` 스냅샷임을 명시한다. 다른 저장소로 임의 전환하거나 세션을 새로 만들지 않는다.
+
+명령 호출 자체는 세션 실행·재전송·승인·설정 변경을 요청하는 것이 아니다.

package/README.ko.md

@@ -19,12 +19,49 @@ axmap setup
 
 [사용법](docs/INSTALL.md) · [MCP 연결](mcp/README.md) · [개발 가이드](docs/ONBOARD-TEAM.md)
 
+세션·메시지 핵심 모듈은 strict TypeScript로 작성합니다. 단계적 전환 범위와 빌드 방법은 [TypeScript 개발 안내](docs/TYPESCRIPT.md)를 참고하세요.
+
+지원되는 MCP Apps 호스트에서는 대화 안에서 파이프라인을 확인하고, Claude Code·agy에서는 기존 상태줄에 진행을 추가할 수 있습니다. 호스트별 지원이 다르며 ChatGPT·Claude 앱의 실제 임베디드 화면은 아직 검증하지 않았습니다. [클라이언트 설정과 제한](docs/PIPELINE-CLIENTS.md). 선택적으로 별도 터미널의 `axmap monitor`도 제공합니다([사용법](docs/MONITOR.md)).
+
 ---
 
 ## 변경 기록
 
 최신 변경부터 정리합니다.
 
+### 1.7.0
+
+<sub>2026.10.27</sub>
+
+**일반 협업 알림을 작업 경계에서 모아 처리하고 기존 로컬 Codex 대화를 연결합니다.**
+
+- 일반 알림은 `ax_message` / `axmap bridge message`로 새 모델 턴 없이 저장합니다. 수신자는 작업·테스트·실험의 안전한 경계에서 `ax_mailbox`로 묶음 회수합니다.
+- 중단 요청·데이터 손상 위험·현재 작업 무효화를 명시적 긴급 사유로 구분합니다. 수신자가 작업 중이면 전달을 보류하며 실행 중 작업을 강제 중단하지 않습니다.
+- 발신자·시각·이력을 보존하고 만료, 멱등 키, 같은 발신자·주제의 대기 업데이트 최신화를 지원합니다. 전달불명 메시지는 자동 재전송하지 않습니다.
+- 로컬 제어 소켓으로 기존 Codex 대화를 연결합니다. 작업 중에는 관측만 허용하고 새 요청 전 대기 상태를 확인합니다.
+- `axmap pipeline` 그래프와 읽기 전용 loopback 웹 화면, 새 모델 턴을 시작하지 않는 Codex 문맥 안내를 추가합니다.
+
+받은 편지함은 격리 provider와 CLI/MCP 계약으로 검증했습니다. 실제 턴 절감량은 미측정이며 실행 중 강제 중단은 지원하지 않습니다. 수신 에이전트가 작업 경계에서 받은 편지함을 회수해야 합니다. 새 도구를 발견하려면 MCP를 다시 연결하세요. 실행용 기존 `ax_dispatch`는 유지합니다.
+[받은 편지함 안내 →](docs/SESSION-MAILBOX.md) · [로컬 파이프라인 →](docs/LOCAL-PIPELINE.md)
+
+---
+
+### 1.6.0
+
+<sub>2026.10.26</sub>
+
+**요청 흐름을 표시하고 기존 Windows agy 연결의 관측 비용을 줄입니다.**
+
+- Windows 콘솔 도우미를 매번 컴파일하지 않고 캐시하며 PowerShell 대체 경로를 유지합니다.
+- 제한 시간 안에서 응답을 기다리는 `wait_ms`·`--wait-ms`와 비동기 MCP 진행 알림을 추가합니다.
+- MCP Apps 파이프라인 리소스, 텍스트 대체 출력, 기존 명령을 보존하는 Claude Code·agy 상태줄을 제공합니다. 별도 터미널 표시가 필요하면 `axmap monitor`를 사용합니다.
+- 세션·파이프라인 모듈을 strict TypeScript로 작성하며 Node.js 20+용 JavaScript를 함께 배포합니다. 실행에 TypeScript 설치는 필요하지 않습니다.
+
+Windows의 실제 agy에서 전달·진행 알림·상태줄의 완료 표시를 확인했습니다. ChatGPT·Claude UI는 기능 협상과 프로토콜 테스트로 검증했으며 실제 제품의 임베디드 화면 검증은 남아 있습니다. 이 Codex 세션에는 새 파이프라인 도구가 노출되지 않았습니다. 로컬 stdio 지원만으로 ChatGPT 웹용 원격 엔드포인트가 생기지는 않습니다.
+[클라이언트 설정과 제한 →](docs/PIPELINE-CLIENTS.md)
+
+---
+
 ### 1.5.0
 
 <sub>2026.10.21</sub>

package/README.md

@@ -19,12 +19,49 @@ Each Git repository's ledger is prepared on first use. Collaborators must share
 
 [Usage](docs/INSTALL.md) · [MCP setup](mcp/README.md) · [Development](docs/ONBOARD-TEAM.md)
 
+Session and messaging modules are authored in strict TypeScript. See the [TypeScript development guide](docs/TYPESCRIPT.md) for the incremental migration and build workflow.
+
+View pipeline state inside compatible MCP Apps hosts, or add it to the existing Claude Code / agy statusline. Host support varies; actual ChatGPT and Claude embedded rendering remains unverified. See [client support and setup](docs/PIPELINE-CLIENTS.md). An optional separate terminal view is available with `axmap monitor` ([guide](docs/MONITOR.md)).
+
 ---
 
 ## Changelog
 
 Newest changes first.
 
+### 1.7.0
+
+<sub>October 27, 2026</sub>
+
+**Batch routine collaboration messages at safe work boundaries and connect existing local Codex threads.**
+
+- Use `ax_message` / `axmap bridge message` for routine updates without starting a model turn. Receivers collect messages together with `ax_mailbox` at task, test or experiment checkpoints.
+- Explicit urgent reasons distinguish stop requests, data-loss risks and changes that invalidate current work. Busy recipients defer delivery; this release does not force-interrupt active work.
+- Preserve message provenance and history while supporting expiration, idempotency keys and latest pending updates per sender/topic. Uncertain delivery is never automatically retried.
+- Connect an existing Codex thread through its local control socket, with read-only observation of active work and idle checks before submission.
+- Add the `axmap pipeline` graph, a read-only loopback web view and context-only Codex notices that do not start a new model turn.
+
+Mailbox behavior is covered by isolated provider and CLI/MCP tests. Actual turn savings and active-work interruption are not claimed. Receivers must collect their mailbox at safe checkpoints; reconnect MCP clients to discover the new tools. Existing execution-oriented `ax_dispatch` remains available.
+[Mailbox guide →](docs/SESSION-MAILBOX.md) · [Local pipeline →](docs/LOCAL-PIPELINE.md)
+
+---
+
+### 1.6.0
+
+<sub>October 26, 2026</sub>
+
+**Observe request flow and reduce the overhead of existing Windows agy connections.**
+
+- Cache the Windows console helper instead of recompiling it for every observation, with PowerShell fallback.
+- Add bounded `wait_ms` / `--wait-ms` response waiting and asynchronous MCP progress notifications.
+- Add MCP Apps pipeline resources, text fallback, and optional Claude Code / agy statuslines that preserve existing commands. An optional `axmap monitor` shows the same flow in a terminal.
+- Author session and pipeline modules in strict TypeScript while shipping generated JavaScript for Node.js 20+; TypeScript is not required at runtime.
+
+Actual agy delivery, progress and native statusline completion were verified on Windows. ChatGPT / Claude UI support is capability-based and covered by protocol tests; embedded rendering in those products remains unverified. This Codex session did not expose the new pipeline tools. Local stdio support does not provide a remote ChatGPT web endpoint.
+[Client setup and limits →](docs/PIPELINE-CLIENTS.md)
+
+---
+
 ### 1.5.0
 
 <sub>October 21, 2026</sub>

package/bin/axmap.mjs

@@ -2624,6 +2624,8 @@ exec node "$AX" verify
 const RUNNERS = {
   run: ['tools/run.mjs', '사용자가 여는 AI CLI를 연결한다'],
   bridge: ['tools/bridge.mjs', '열린 로컬 AI 세션에 작업을 전달한다'],
+  monitor: ['tools/monitor.mjs', '세션과 요청 파이프라인을 실시간으로 표시한다'],
+  pipeline: ['tools/pipeline.mjs', '대화 안 파이프라인 표시와 CLI 상태줄을 연결한다'],
   gate: ['governance/gate.mjs', '이 MR 이 정족수를 채웠는가'],
   vote: ['governance/vote.mjs', '표를 던진다'],
   bus: ['tools/bus.mjs', '에이전트 사이 쪽지함'],
@@ -2834,6 +2836,8 @@ const HELP = `axmap - AI 에이전트 작업 선점 프로토콜
   axmap vote                         표를 던진다
   axmap bus                          에이전트 사이 쪽지함 (post · list · read · reply)
   axmap bridge                       로컬 세션·자동 대화 (serve · sessions · send · chat · dialogue)
+  axmap monitor                      에이전트·요청 파이프라인·최근 이벤트 실시간 화면
+  axmap pipeline                     대화 안 표시·Claude/agy 상태줄 연결 (--help)
   axmap run agy [인수...]             연결된 Antigravity CLI를 직접 연다
   axmap mr-target                    이 브랜치가 저 브랜치로 갈 수 있는가
   axmap version                      브랜치 단계로 다음 버전을 정한다
@@ -2876,6 +2880,8 @@ switch (cmd) {
   // 이름을 경로로 바꿔 주는 것들 (RUNNERS). 인자는 손대지 않고 그대로 간다.
   case 'setup':
   case 'bridge':
+  case 'monitor':
+  case 'pipeline':
   case 'run':
   case 'gate':
   case 'vote':

package/mcp/README.md

@@ -30,10 +30,16 @@ https://github.com/rl2aderjoon/axmap/blob/main/mcp/SETUP-FOR-AI.md
 
 ## 도구
 
+현재 대화 안의 파이프라인 패널과 Claude Code·agy 상태줄 설치는
+[PIPELINE-CLIENTS.md](../docs/PIPELINE-CLIENTS.md)를 참고한다.
+
 | 도구 | 언제 |
 |---|---|
 | `ax_brief()` | 이 저장소에서 처음 일할 때 **가장 먼저** |
 | `ax_status()` | 지금 누가 어디를 잡고 있나 |
+| `ax_pipeline()` | 대화 안의 파이프라인 패널 또는 텍스트 스냅샷 |
+| `ax_pipeline_state()` | MCP Apps 패널의 상태 갱신 전용 |
+| `ax_pipeline_watch()` | 현재 도구 호출의 진행 알림으로 상태 관찰 |
 | `ax_check(paths)` | 내가 건드릴 곳이 비었나 — **선언은 안 한다.** 계획 세울 때 |
 | `ax_claim(paths, intent, task?)` | **파일을 고치기 전에 반드시.** intent 는 사람이 화면에서 읽는다 |
 | `ax_release(paths?)` | 끝나면 즉시. 생략하면 전부 반납 |
@@ -41,6 +47,9 @@ https://github.com/rl2aderjoon/axmap/blob/main/mcp/SETUP-FOR-AI.md
 | `ax_inbox(id?)` | 다른 에이전트가 나에게 보낸 쪽지를 읽는다 |
 | `ax_sessions()` | 같은 repo의 연결된 세션·역할·상태·사용량 |
 | `ax_dispatch(to, prompt)` / `ax_result(id)` | 연결된 세션에 단일 작업 전달·결과 조회 |
+| `ax_message(to, text)` | 일반 협업 알림 무호출 큐 저장. 즉시 전달은 명시적 긴급 사유 필요 |
+| `ax_mailbox(to, take, at)` | 안전한 작업 경계에서 메시지 묶음 회수. 모델 호출 없음 |
+| `ax_mailbox_flush(to, at)` | 필요할 때 idle 상대에게 대기 메시지를 한 요청으로 전달 |
 | `ax_chat(left, right, prompt, maxTurns?, maxTokens?)` | 관리형 세션 두 개의 제한된 자동 대화를 백그라운드 접수 |
 | `ax_dialogue(id)` / `ax_chat_stop(id)` | 대화·토큰 조회 / 추가 중계 중단 |
 | `ax_send(to?, subject, body)` | 다른 에이전트에게 쪽지를 보낸다 |

package/mcp/pipeline.html

@@ -0,0 +1,184 @@
+<!doctype html>
+<html lang="ko">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+@import url('https://cdn.jsdelivr.net/npm/pretendard@1.3.9/dist/web/static/pretendard.css');
+:root { color-scheme:light dark; --surface:var(--color-background-primary,light-dark(#fff,#17191d)); --ink:var(--color-text-primary,light-dark(#20242b,#edf0f5)); --muted:var(--color-text-secondary,light-dark(#5b6574,#afb8c6)); --line:var(--color-border-primary,light-dark(#dce1e8,#3b414b)); --accent:light-dark(#2461c6,#80b0ff); --soft:light-dark(#edf3ff,#25364e); --warning:light-dark(#8a5600,#f5c56b); }
+:root[data-theme="dark"] { color-scheme:dark; }
+:root[data-theme="light"] { color-scheme:light; }
+* { box-sizing:border-box; }
+body { margin:0; padding:18px; background:var(--surface); color:var(--ink); font:14px/1.55 Pretendard,system-ui,sans-serif; }
+h1 { font-size:18px; font-weight:600; margin:0; }
+h2 { font-size:12px; font-weight:500; color:var(--muted); margin:20px 0 8px; }
+header { display:flex; flex-wrap:wrap; align-items:center; gap:12px; }
+.status { display:flex; align-items:center; gap:7px; color:var(--muted); font-size:12px; }
+.status::before { content:''; width:7px; height:7px; border-radius:50%; background:var(--muted); }
+body[data-live="true"] .status::before { background:var(--accent); }
+.scope { font-size:12px; color:var(--muted); margin:6px 0 16px; overflow-wrap:anywhere; }
+button { margin-left:auto; font:inherit; color:var(--ink); background:var(--surface); border:1px solid var(--line); border-radius:6px; padding:5px 10px; cursor:pointer; }
+button:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
+.topology { position:relative; padding-top:6px; }
+.router { width:max-content; max-width:100%; margin:0 auto 28px; padding:14px 24px; border:1px solid var(--accent); border-radius:8px; text-align:center; background:var(--soft); }
+.router strong { display:block; font-size:16px; }
+.router::after { content:''; display:block; position:absolute; height:28px; width:1px; background:var(--line); left:50%; margin-top:14px; }
+.sessions { display:grid; grid-template-columns:repeat(auto-fit,minmax(210px,1fr)); gap:20px; }
+.session { position:relative; display:flex; flex-direction:column; gap:7px; align-items:stretch; border:1px solid var(--line); padding:14px; border-radius:8px; min-width:0; overflow-wrap:anywhere; }
+.session::before { content:''; position:absolute; height:20px; width:1px; background:var(--line); left:50%; top:-21px; }
+.session.running { border-color:var(--accent); background:var(--soft); }
+.session.running::after { content:''; position:absolute; width:6px; height:6px; border-radius:50%; background:var(--accent); left:calc(50% - 3px); top:-20px; animation:packet 1.4s linear infinite; }
+body:not([data-live="true"]) .session.running::after { animation-play-state:paused; }
+.session .identity { font-size:12px; color:var(--muted); }
+.session .usage { font-variant-numeric:tabular-nums; border-top:1px solid var(--line); padding-top:7px; }
+.session .activity { font-size:12px; color:var(--muted); }
+.session .state { font-weight:500; }
+.claims { padding:12px 0; color:var(--muted); overflow-wrap:anywhere; }
+@keyframes packet { from { transform:translateY(0); } to { transform:translateY(20px); } }
+.session strong { font-weight:600; }
+.subtle { color:var(--muted); }
+.job { padding:14px 0; border-bottom:1px solid var(--line); }
+.job:last-child { border-bottom:0; }
+.route { font-weight:500; overflow-wrap:anywhere; }
+.task { margin-top:9px; color:var(--muted); overflow-wrap:anywhere; }
+.steps { display:grid; grid-template-columns:repeat(4,minmax(0,1fr)); gap:8px; margin-top:16px; }
+.step { position:relative; display:flex; flex-direction:column; align-items:center; text-align:center; gap:6px; font-size:12px; }
+.step:not(:last-child)::after { content:''; position:absolute; top:14px; left:calc(50% + 18px); width:calc(100% - 28px); height:1px; background:var(--line); }
+.mark { display:grid; place-items:center; position:relative; width:28px; height:28px; border-radius:50%; background:var(--line); color:var(--ink); }
+.step.done .mark,.step.current .mark { background:var(--soft); }
+.step.current .mark::after { content:''; position:absolute; inset:-3px; border:2px solid transparent; border-top-color:var(--accent); border-radius:50%; animation:spin 1s linear infinite; }
+body:not([data-live="true"]) .step.current .mark::after { animation-play-state:paused; }
+.issue { color:var(--warning); margin-top:10px; overflow-wrap:anywhere; }
+.events { list-style:none; padding:0; margin:0; font-size:12px; }
+.events li { padding:3px 0; overflow-wrap:anywhere; }
+time { color:var(--muted); margin-right:10px; font-variant-numeric:tabular-nums; }
+footer { border-top:1px solid var(--line); padding-top:10px; margin-top:14px; color:var(--muted); font-size:12px; }
+@keyframes spin { to { transform:rotate(360deg); } }
+@media (prefers-reduced-motion:reduce) { .step.current .mark::after,.session.running::after { animation:none; } }
+@media(max-width:420px) { body{padding:12px;} .steps{grid-template-columns:1fr;gap:10px;} .step{flex-direction:row;text-align:left;gap:12px;} .step:not(:last-child)::after{top:31px;left:14px;height:7px;width:1px;} button{margin-left:0;} }
+</style>
+</head>
+<body data-live="false">
+<main id="axmap-pipeline">
+  <header><h1>axMap 실행 흐름</h1><span class="status" id="status">연결 확인 중</span><button type="button" id="pause">새로고침 일시정지</button></header>
+  <div class="scope" id="scope">실제 작업 상태를 기다리는 중</div>
+  <section class="topology" aria-label="등록된 세션과 로컬 메시지 연결">
+    <div class="router"><strong>axMap · 로컬 라우터</strong><span class="subtle">기존 대화 유지 · 요청 ID 추적 · Git 왕복 없음</span></div>
+    <div class="sessions" id="sessions"></div>
+  </section>
+  <section aria-label="요청 파이프라인" id="jobs"></section>
+  <div class="issue" id="issue" role="status" aria-live="polite"></div>
+  <section id="event-section"><h2>최근 이벤트</h2><ul class="events" id="events"></ul></section>
+  <footer id="checked">대화 안에서 상태만 조회합니다. 모델 호출·작업 재전송·자동 승인 없음.</footer>
+</main>
+<script>
+(() => {
+  const root=document.getElementById('axmap-pipeline');
+  const status=document.getElementById('status'),scope=document.getElementById('scope');
+  const sessions=document.getElementById('sessions'),jobs=document.getElementById('jobs');
+  const issue=document.getElementById('issue'),events=document.getElementById('events');
+  const checked=document.getElementById('checked'),pause=document.getElementById('pause');
+  const requests=new Map();let sequence=0,ready=false,mode='standard',cwd=null,requestedCwd=null,paused=false,stopped=false,inflight=false,timer,unavailable=false;
+  const pending=new Set(['sending','submitted','unknown']);
+  const states={sending:'전달 중',submitted:'응답 대기',completed:'완료 확인',unknown:'전송 확인 필요',failed:'실패',superseded:'다른 입력으로 대체됨'};
+  const sessionStates={starting:'시작 중',running:'작업 중',idle:'대기',awaiting_user:'승인 필요',settling:'대기 전환 중',closed:'종료',unknown:'상태 미확인'};
+  const connectionStates={connected:'연결됨',closed:'종료됨',unreachable:'연결 확인 불가',unverified:'확인 미지원'};
+  const text=value=>String(value??'').replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g,' ').slice(0,600);
+  const node=(tag,content,className)=>{const el=document.createElement(tag);if(content!==undefined)el.textContent=text(content);if(className)el.className=className;return el};
+  const notify=(method,params)=>window.parent.postMessage({jsonrpc:'2.0',method,params},'*');
+  function request(method,params){
+    const id=`axmap-ui-${++sequence}`;
+    return new Promise((resolve,reject)=>{
+      const timeout=setTimeout(()=>{requests.delete(id);reject(new Error('호스트 응답 시간 초과'))},10000);
+      requests.set(id,{resolve,reject,timeout});window.parent.postMessage({jsonrpc:'2.0',id,method,params},'*');
+    });
+  }
+  function context(value){
+    if(value?.theme==='light'||value?.theme==='dark')document.documentElement.dataset.theme=value.theme;
+    const allowed=new Set(['--color-background-primary','--color-text-primary','--color-text-secondary','--color-border-primary']);
+    for(const [key,color]of Object.entries(value?.styles?.variables||{}))if(allowed.has(key)&&typeof color==='string')document.documentElement.style.setProperty(key,color);
+  }
+  function setLive(value,message){document.body.dataset.live=String(value);status.textContent=message;}
+  function render(data){
+    if(!data||data.schemaVersion!==1||data.type!=='pipeline'||typeof data.cwd!=='string'||!Array.isArray(data.requests)||!Array.isArray(data.sessions))return;
+    if(cwd&&data.cwd!==cwd){issue.textContent='다른 저장소의 상태를 받았습니다. 현재 패널의 저장소를 유지합니다.';setLive(false,'저장소 확인 필요');return;}
+    cwd=data.cwd;scope.textContent=text(cwd);sessions.replaceChildren();jobs.replaceChildren();events.replaceChildren();
+    const ordered=[...data.sessions].sort((a,b)=>Number(b.connection==='connected')-Number(a.connection==='connected'));
+    for(const session of ordered.slice(0,6)){
+      const waiting=data.requests.filter(job=>job.to===session.id&&pending.has(job.state));
+      const line=node('article',undefined,`session${waiting.length&&session.connection==='connected'?' running':''}`);
+      line.append(node('strong',session.role||`${session.provider} 세션`),node('span',`${session.provider} · ${text(session.id).slice(0,8)} · ${session.transport||'연결 방식 미확인'}`,'identity'),node('span',`${session.pendingApproval?'사용자 승인 필요':sessionStates[session.state]||'상태 미확인'} · ${connectionStates[session.connection]||'확인 미지원'}`,'state'),node('span',session.model||'모델 미확인','identity'));
+      line.append(node('div',session.usage?.totalTokens==null?'토큰 미측정':`누적 처리 ${session.usage.totalTokens.toLocaleString()} tokens`,'usage'),node('div',waiting.length?`${waiting.length}건 응답 대기`:session.state==='idle'?'새 요청을 받을 수 있음':'대기 중인 axMap 요청 없음','activity'));
+      sessions.append(line);
+    }
+    const active=data.requests.filter(r=>pending.has(r.state));
+    const selected=[...active,...data.requests.filter(r=>!pending.has(r.state))].slice(0,4);
+    if(!selected.length)jobs.append(node('p','새 요청을 기다리는 중','subtle'));
+    for(const job of selected){
+      const item=node('article',undefined,'job');item.append(node('div',`${text(job.from)} → ${text(job.to).slice(0,8)} · ${states[job.state]||'확인 필요'}`,'route'));
+      const steps=node('div',undefined,'steps');
+      const done=job.state==='completed',sent=job.state==='submitted'||done;
+      ['접수','전달','응답','완료 확인'].forEach((label,index)=>{
+        const complete=done||index===0||(sent&&index===1);
+        const current=!done&&((job.state==='sending'&&index===1)||(job.state==='submitted'&&index===2));
+        const step=node('div',undefined,`step${complete?' done':current?' current':''}`);
+        const mark=node('span',complete?'✓':job.state==='unknown'&&index===1?'?':String(index+1),'mark');mark.setAttribute('aria-hidden','true');
+        step.append(mark,node('span',current&&index===2?'응답 대기':label));steps.append(step);
+      });
+      item.append(steps,node('div',job.task,'task'));if(job.error)item.append(node('div',job.error,'issue'));jobs.append(item);
+      const measured=[];
+      if(Number.isFinite(job.latencyMs))measured.push(`왕복 ${(job.latencyMs/1000).toFixed(2)}초`);
+      measured.push(job.usage?.totalTokens==null?'요청 토큰 미측정':`요청 처리 ${job.usage.totalTokens.toLocaleString()} tokens`);
+      item.append(node('div',measured.join(' · '),'task'));
+    }
+    for(const event of (data.events||[]).slice(0,5)){
+      const row=node('li');const date=new Date(event.at);row.append(node('time',Number.isFinite(date.getTime())?date.toLocaleTimeString('en-GB',{hour12:false}):'시각 미확인'),node('span',event.label));events.append(row);
+    }
+    issue.textContent=(data.issues||[]).slice(0,2).map(text).join(' · ');
+    checked.textContent=`관측 ${text(data.checkedAt)} · 상태 조회만 수행 · 작업 제어 없음`;
+    setLive(ready&&!paused&&!document.hidden,!ready?(unavailable?'현재 상태 · 자동 갱신 미지원':'연결 확인 중'):paused?'새로고침 일시정지':document.hidden?'화면 숨김':`진행 확인 ${active.length}개`);
+  }
+  function consume(result){if(result?.isError)throw new Error(result.content?.[0]?.text||'상태 조회 실패');render(result?.structuredContent);}
+  function schedule(){clearTimeout(timer);if(ready&&!paused&&!stopped&&!document.hidden)timer=setTimeout(poll,1200);}
+  async function poll(){
+    if(inflight||!ready||paused||stopped||document.hidden)return;
+    inflight=true;
+    try{const scope=cwd||requestedCwd,args=scope?{cwd:scope}:{};const result=mode==='local'?await window.axmapLocalRead():mode==='openai'?await window.openai.callTool('ax_pipeline_state',args):await request('tools/call',{name:'ax_pipeline_state',arguments:args});consume(result);}
+    catch(error){setLive(false,'연결 확인 필요');issue.textContent=text(error?.message||error);}
+    finally{inflight=false;schedule();}
+  }
+  window.addEventListener('message',event=>{
+    if(event.source!==window.parent)return;const message=event.data;if(!message||message.jsonrpc!=='2.0')return;
+    if(requests.has(message.id)){const waiting=requests.get(message.id);requests.delete(message.id);clearTimeout(waiting.timeout);message.error?waiting.reject(new Error(message.error.message||'호스트 오류')):waiting.resolve(message.result);return;}
+    if(message.method==='ui/notifications/tool-result'){try{consume(message.params)}catch(error){issue.textContent=text(error.message);}}
+    if(message.method==='ui/notifications/tool-input'&&!cwd&&typeof message.params?.arguments?.cwd==='string')requestedCwd=message.params.arguments.cwd;
+    if(message.method==='ui/notifications/host-context-changed')context(message.params);
+    if(message.method==='ui/resource-teardown'){
+      stopped=true;clearTimeout(timer);resize.disconnect();setLive(false,'관측 종료');
+      if(message.id!==undefined)window.parent.postMessage({jsonrpc:'2.0',id:message.id,result:{}},'*');
+    }
+  });
+  document.addEventListener('visibilitychange',()=>{if(document.hidden){clearTimeout(timer);setLive(false,'화면 숨김')}else if(!paused){void poll()}});
+  pause.addEventListener('click',()=>{paused=!paused;pause.textContent=paused?'실시간 새로고침 재개':'새로고침 일시정지';if(paused){clearTimeout(timer);setLive(false,'새로고침 일시정지')}else{void poll()}});
+  let reportedHeight=0;
+  const resize=new ResizeObserver(()=>{if(!ready||mode!=='standard'||stopped)return;const height=Math.ceil(root.getBoundingClientRect().height)+36;if(height!==reportedHeight){reportedHeight=height;notify('ui/notifications/size-changed',{height})}});
+  resize.observe(root);
+  window.addEventListener('pagehide',()=>{stopped=true;clearTimeout(timer);resize.disconnect()});
+  if(window.openai?.toolOutput)render(window.openai.toolOutput);
+  (async()=>{
+    if(document.documentElement.dataset.axmapLocal==='true'){mode='local';ready=true;void poll();return;}
+    try{
+      const result=await request('ui/initialize',{protocolVersion:'2026-01-26',appInfo:{name:'axmap-pipeline',version:'1.0.0'},appCapabilities:{availableDisplayModes:['inline']}});
+      context(result?.hostContext);notify('ui/notifications/initialized',{});
+      ready=!!result?.hostCapabilities?.serverTools;
+      if(!ready){unavailable=true;setLive(false,'자동 갱신 미지원');issue.textContent='현재 호스트가 상태 조회 도구 호출을 제공하지 않습니다. ax_pipeline_watch로 진행 상태를 확인할 수 있습니다.';return;}
+    }catch(error){
+      if(typeof window.openai?.callTool==='function'){mode='openai';ready=true;}
+      else{unavailable=true;setLive(false,'MCP Apps 연결 필요');issue.textContent='이 화면에서는 실시간 UI 연결을 확인하지 못했습니다. 현재 대화에서 ax_pipeline_watch를 사용할 수 있습니다.';return;}
+    }
+    void poll();
+  })();
+})();
+</script>
+</body>
+</html>

package/mcp/server.mjs

@@ -40,7 +40,7 @@
  * stdio 전송 — 줄바꿈으로 구분된 JSON-RPC 2.0.
  */
 
-import { spawnSync } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 import readline from 'node:readline'
@@ -212,7 +212,58 @@ const TTL = process.env.AXMAP_TTL ?? '45m'
  */
 const SESSION = process.env.AXMAP_SESSION || process.env.CLAUDE_CODE_SESSION_ID || `mcp-${process.pid}`
 
-const BRIDGE_TOOLS = new Set(['ax_sessions', 'ax_dispatch', 'ax_result', 'ax_chat', 'ax_dialogue', 'ax_chat_stop'])
+const BRIDGE_TOOLS = new Set(['ax_sessions', 'ax_dispatch', 'ax_result', 'ax_chat', 'ax_dialogue', 'ax_chat_stop', 'ax_message', 'ax_mailbox', 'ax_mailbox_flush'])
+const PIPELINE_TOOLS = new Set(['ax_pipeline', 'ax_pipeline_state', 'ax_pipeline_watch'])
+const PIPELINE_URI = 'ui://axmap/pipeline/v1.html'
+const PIPELINE_MIME = 'text/html;profile=mcp-app'
+let clientHasApps = false
+const runningPipeline = new Map()
+
+/** Each observation captures its repo. It may run beside a long dispatch without
+ * changing REPO, switching claims, or blocking UI refresh behind model work. */
+function pipeline(action, args, req, cwd) {
+  return new Promise(resolve => {
+    const offered = req.params?._meta?.progressToken
+    const token = typeof offered === 'string' || Number.isInteger(offered) ? offered : undefined
+    let buffer = '', stderr = '', result = null, ended = false, sequence = 0, reason = ''
+    const child = spawn(process.execPath, [path.join(SELF, 'tools', 'pipeline.mjs'), action], {
+      cwd, windowsHide: true, env: { ...process.env, AXMAP_AGENT: AGENT }, stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+    })
+    const finish = fallback => {
+      if (ended) return
+      ended = true; clearTimeout(timer); runningPipeline.delete(req.id)
+      const answer = result || { content: [{ type: 'text', text: fallback || reason || stderr || '파이프라인 응답을 확인하지 못했습니다. 요청을 자동 재전송하지 않습니다.' }], isError: true }
+      if (answer.structuredContent) answer.structuredContent.display = { mode: clientHasApps ? 'mcp-app' : 'text-progress', progress: token !== undefined }
+      resolve(answer)
+    }
+    const timer = setTimeout(() => { reason = '파이프라인 조회 시간 초과. 이미 전달한 작업은 계속될 수 있습니다.'; child.kill() }, 45000)
+    runningPipeline.set(req.id, () => {
+      reason = '조회 대기를 중단했습니다. 이미 전달한 작업은 계속 실행됩니다.'
+      // A dispatch holds a cross-process lock during submission. Let it finish
+      // that atomic step, then stop waiting; killing it could strand the lock.
+      if (child.connected) child.send({ type: 'cancel-observation' }, () => {})
+    })
+    child.stdout.setEncoding('utf8')
+    child.stdout.on('data', chunk => {
+      buffer += chunk
+      if (Buffer.byteLength(buffer) > 2 * 1024 * 1024) { reason = '파이프라인 응답 크기 제한 초과'; child.kill(); return }
+      while (buffer.includes('\n')) {
+        const at = buffer.indexOf('\n'), line = buffer.slice(0, at); buffer = buffer.slice(at + 1)
+        try {
+          const event = JSON.parse(line)
+          if (event.type === 'progress' && token !== undefined && !result && !ended && !reason) {
+            send({ jsonrpc: '2.0', method: 'notifications/progress', params: { progressToken: token, progress: ++sequence, message: String(event.message) } })
+          } else if (event.type === 'result' && event.result?.content) result = event.result
+        } catch { reason = '파이프라인 응답 형식 오류'; child.kill() }
+      }
+    })
+    child.stderr.on('data', chunk => { stderr = (stderr + chunk.toString('utf8')).slice(-8192) })
+    child.stdin.on('error', () => {})
+    child.once('error', error => finish(error.message))
+    child.once('close', () => finish())
+    child.stdin.end(JSON.stringify({ ...args, __progress: token !== undefined }))
+  })
+}
 function bridge(args, input) {
   const r = spawnSync(process.execPath, [path.join(SELF, 'tools', 'bridge.mjs'), ...args], {
     cwd: REPO, input, encoding: 'utf8', windowsHide: true,
@@ -385,17 +436,68 @@ function cli(args) {
 // ---------------------------------------------------------------------------
 
 const TOOLS = [
+  {
+    name: 'ax_pipeline',
+    description: '현재 대화에서 axMap 실행 흐름을 연다. MCP Apps 지원 화면은 실시간 패널, 다른 클라이언트는 같은 상태를 텍스트로 표시한다. 상태 조회만 수행하며 새 창이나 모델을 실행하지 않는다.',
+    annotations: { readOnlyHint: true, openWorldHint: false },
+    inputSchema: { type: 'object', properties: {} },
+    _meta: { ui: { resourceUri: PIPELINE_URI }, 'openai/outputTemplate': PIPELINE_URI, 'antigravity/alwaysLoad': true },
+  },
+  {
+    name: 'ax_pipeline_state',
+    description: '열린 파이프라인 패널의 실제 상태를 갱신한다. 다른 작업을 중단하거나 재전송하지 않는다.',
+    annotations: { readOnlyHint: true, openWorldHint: false },
+    inputSchema: { type: 'object', properties: {} },
+    _meta: { ui: { visibility: ['app'] } },
+  },
+  {
+    name: 'ax_pipeline_watch',
+    description: '현재 대화의 도구 진행 표시로 axMap 상태를 관측한다. progressToken이 있는 클라이언트에 MCP 진행 알림을 보내며, 없는 경우 현재 상태를 한 번 반환한다. 모델 호출이나 새 창 없음.',
+    annotations: { readOnlyHint: true, openWorldHint: false },
+    inputSchema: { type: 'object', properties: {
+      duration_ms: { type: 'integer', minimum: 0, maximum: 25000, description: '최대 관측 시간. 기본 5000ms.' },
+      interval_ms: { type: 'integer', minimum: 500, maximum: 5000, description: '조회 간격. 기본 1000ms.' },
+    } },
+  },
   {
     name: 'ax_sessions',
     description: '현재 repo에 연결된 로컬 AI 세션, 역할, 상태와 측정 토큰 사용량을 확인한다. stdio는 사용자가 bridge serve로 시작한 관리형 세션이다. 등록만으로 연결 가능성이나 실행 성공을 보장하지 않는다.',
     inputSchema: { type: 'object', properties: {} },
   },
+  {
+    name: 'ax_message',
+    description: '에이전트 협업 메시지. 일반 진행·결과·계약 확인은 기본 boundary 큐에 저장하며 새 턴을 만들지 않는다. 긴급 중단·데이터 손상·현재 작업 무효화만 immediate와 reason을 명시한다. 긴급도 작업 중인 세션을 강제 중단하지 않으며 deferred/unknown을 전달 성공으로 취급하지 않는다. 단순 알림 ACK 금지.',
+    inputSchema: { type: 'object', properties: {
+      to: { type: 'string' }, text: { type: 'string' },
+      priority: { type: 'string', enum: ['boundary', 'immediate'], default: 'boundary' },
+      reason: { type: 'string', enum: ['stop', 'data-loss', 'work-invalidated'] },
+      topic: { type: 'string', description: '명시적으로 같은 주제인 대기 업데이트만 최신으로 대체. 발신자별 분리.' },
+      key: { type: 'string', description: '동일 메시지 재접수 방지. 같은 키에 다른 내용은 거절.' },
+      ttl_seconds: { type: 'integer', minimum: 1, maximum: 86400, default: 3600 },
+    }, required: ['to', 'text'] },
+  },
+  {
+    name: 'ax_mailbox',
+    description: '작업 시작·테스트 완료·실험 종료 등 안전한 경계에서 받은 협업 메시지를 한 번에 읽는다. 기본 조회는 읽음 처리하지 않는다. take=true와 at을 명시하면 묶음 회수하며 새 모델 턴은 없다. collected는 실행 완료나 사람 승인이 아니다. 단순 결과 알림에 회신하지 말고 필요한 결정만 모아 처리한다.',
+    inputSchema: { type: 'object', properties: {
+      to: { type: 'string' }, take: { type: 'boolean', default: false }, all: { type: 'boolean', default: false },
+      at: { type: 'string', enum: ['task-complete', 'test-complete', 'experiment-complete', 'checkpoint'] },
+    }, required: ['to'] },
+  },
+  {
+    name: 'ax_mailbox_flush',
+    description: '명시한 작업 경계에서 대기 메시지를 idle 상대에게 한 요청으로 전달한다. 수신자가 직접 ax_mailbox로 회수하는 방법을 우선한다. 빈 큐는 모델 호출 없음. 전달불명·프로세스 중단 후 자동 재전송하지 않는다.',
+    inputSchema: { type: 'object', properties: { to: { type: 'string' },
+      at: { type: 'string', enum: ['task-complete', 'test-complete', 'experiment-complete', 'checkpoint'] },
+    }, required: ['to', 'at'] },
+  },
   {
     name: 'ax_dispatch',
-    description: '사용자가 허용한 작업을 연결된 상대 세션에 전달한다. 기존 맥락을 유지하며 새 모델 프로세스를 만들지 않는다. submitted는 완료가 아니다. unknown이면 자동 재시도하지 말고 ax_result로 확인한다. Codex/agy 관리형 stdio, 별도로 실행한 Windows agy console, 실험용 PTY/agentapi 연결을 지원한다.',
+    description: '명시적으로 상대의 실행 턴이 필요한 작업용 저수준 전달이다. 일반 진행·완료·계약 확인 알림에는 새 턴 없는 ax_message를 사용하고 수신자가 작업 경계에서 ax_mailbox로 묶음 회수한다. 기존 맥락을 유지하며 새 모델 프로세스를 만들지 않는다. submitted는 완료가 아니다. unknown이면 자동 재시도하지 말고 ax_result로 확인한다. 작업 중인 세션을 강제 중단하지 않는다.',
     inputSchema: { type: 'object', properties: {
       to: { type: 'string', description: 'ax_sessions에서 확인한 상대 세션 UUID' },
       prompt: { type: 'string', description: '상대가 실행할 작업 요청' },
+      wait_ms: { type: 'integer', minimum: 0, maximum: 30000, description: '전달 후 회신을 로컬에서 기다릴 최대 시간(ms). 짧은 요청은 30000으로 한 번에 회수한다. 기본 0.' },
     }, required: ['to', 'prompt'] },
   },
   {
@@ -403,6 +505,7 @@ const TOOLS = [
     description: '작업 요청의 제출/완료/불명 상태, 결과와 측정 사용량을 확인한다. 관리형 세션은 구조화된 완료 이벤트, PTY는 종료 훅, 독립 Windows console은 요청 UUID가 있는 대화 기록과 현재 빈 입력창의 대기 상태로 판정한다.',
     inputSchema: { type: 'object', properties: {
       id: { type: 'string', description: 'ax_dispatch가 반환한 요청 UUID' },
+      wait_ms: { type: 'integer', minimum: 0, maximum: 30000, description: '로컬 회신 대기(ms). 모델 호출 없이 완료 즉시 반환. 기본 0.' },
     }, required: ['id'] },
   },
   {
@@ -848,8 +951,12 @@ function dispatch(name, args = {}) {
 
   switch (name) {
     case 'ax_sessions': return bridge(['sessions'])
-    case 'ax_dispatch': return bridge(['send', '--to', args.to], args.prompt)
-    case 'ax_result': return bridge(['result', args.id])
+    case 'ax_message': return bridge(['message', '--to', args.to, '--priority', args.priority ?? 'boundary',
+      ...[['reason', args.reason], ['topic', args.topic], ['key', args.key], ['ttl-seconds', args.ttl_seconds]].flatMap(([k, v]) => v === undefined ? [] : [`--${k}`, String(v)])], args.text)
+    case 'ax_mailbox': return bridge(['mailbox', '--to', args.to, ...(args.take ? ['--take'] : []), ...(args.all ? ['--all'] : []), ...(args.at ? ['--at', args.at] : [])])
+    case 'ax_mailbox_flush': return bridge(['flush', '--to', args.to, '--at', args.at])
+    case 'ax_dispatch': return bridge(['send', '--to', args.to, '--wait-ms', String(args.wait_ms ?? 0)], args.prompt)
+    case 'ax_result': return bridge(['result', args.id, '--wait-ms', String(args.wait_ms ?? 0)])
     case 'ax_chat': return bridge(['chat', '--background', '--left', args.left, '--right', args.right,
       ...['maxTurns', 'maxTokens', 'maxMessageChars'].flatMap(key => args[key] === undefined ? [] :
         [`--${key.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`)}`, String(args[key])])], args.prompt)
@@ -1041,13 +1148,28 @@ async function handle(req) {
 
   if (method === 'initialize') {
     rootsSupported = !!params?.capabilities?.roots
+    clientHasApps = !!params?.capabilities?.extensions?.['io.modelcontextprotocol/ui']?.mimeTypes?.includes(PIPELINE_MIME)
     return {
       protocolVersion: '2024-11-05',
-      capabilities: { tools: {} },
+      capabilities: { tools: {}, resources: {} },
       serverInfo: { name: 'axmap', version: VERSION },
+      instructions: 'axMap works across ChatGPT, Claude and agy. Routine collaboration updates go through ax_message (boundary queue, no new turn). At safe task/test/experiment checkpoints collect your ax_mailbox with take=true and at; batch decisions, do not ACK informational updates. Use immediate only for stop/data-loss/work-invalidated; busy delivery is deferred, not an interrupt. ax_dispatch starts an explicit execution request, not a routine notification. Open ax_pipeline once for an inline panel when the host supports MCP Apps. Otherwise ax_pipeline_watch and ax_dispatch/ax_result with wait_ms report standard MCP progress when the client supplies progressToken. Observations never call a model. Do not resubmit unknown requests.',
     }
   }
-  if (method === 'tools/list') return { tools: TOOLS }
+  if (method === 'tools/list') return { tools: TOOLS.filter(tool => clientHasApps || tool.name !== 'ax_pipeline_state').map(tool => {
+    if (clientHasApps || !tool._meta?.ui?.resourceUri) return tool
+    const { ui, 'openai/outputTemplate': outputTemplate, ...metadata } = tool._meta
+    return { ...tool, _meta: metadata }
+  }) }
+  if (method === 'resources/list') return { resources: [{ uri: PIPELINE_URI, name: 'axmap-pipeline', title: 'axMap 실행 흐름', mimeType: PIPELINE_MIME }] }
+  if (method === 'resources/read') {
+    if (params?.uri !== PIPELINE_URI) throw Object.assign(new Error('알 수 없는 UI 리소스입니다.'), { code: -32602 })
+    return { contents: [{ uri: PIPELINE_URI, mimeType: PIPELINE_MIME,
+      text: fs.readFileSync(path.join(SELF, 'mcp', 'pipeline.html'), 'utf8'),
+      _meta: { ui: { prefersBorder: true, csp: { connectDomains: [], resourceDomains: ['https://cdn.jsdelivr.net'] } },
+        'openai/widgetCSP': { connect_domains: [], resource_domains: ['https://cdn.jsdelivr.net'] } },
+    }] }
+  }
   if (method === 'tools/call') {
     if (rootsSupported && !process.env.AXMAP_REPO) {
       if (!rootsTask || rootsError) refreshRoots()
@@ -1055,7 +1177,19 @@ async function handle(req) {
       let task
       do { task = rootsTask; await task } while (task !== rootsTask)
     }
-    const r = callTool(params?.name, params?.arguments ?? {})
+    const args = params?.arguments ?? {}
+    if (PIPELINE_TOOLS.has(params?.name)) {
+      const cwd = resolveRepo(args)
+      return pipeline(params.name === 'ax_pipeline_watch' ? 'watch' : 'snapshot', args, req, cwd)
+    }
+    if (['ax_dispatch', 'ax_result'].includes(params?.name)) {
+      let switched
+      try { switched = syncRepo(args) } catch (e) { return { content: [{ type: 'text', text: e.message }], isError: true } }
+      const answer = await pipeline(params.name === 'ax_dispatch' ? 'dispatch' : 'result', args, req, REPO)
+      if (switched) answer.content[0].text = switchNotice(switched) + '\n\n' + answer.content[0].text
+      return answer
+    }
+    const r = callTool(params?.name, args)
     const localBridge = BRIDGE_TOOLS.has(params?.name)
     const warning = r.ok && !localBridge ? syncConfiguredProfile(REPO, BUS, { ...process.env, AXMAP_AGENT: AGENT }) : ''
     return { content: [{ type: 'text', text: r.text + (warning ? '\n' + warning : '') + (r.ok && !localBridge ? unreadBanner(params?.name, r.text) : '') }], isError: !r.ok }
@@ -1067,6 +1201,16 @@ async function handle(req) {
 const rl = readline.createInterface({ input: process.stdin })
 // Execute tools in order, but keep reading client replies while a tool awaits roots.
 let requests = Promise.resolve()
+let initialized = Promise.resolve(), concurrentViews = 0
+async function respond(req) {
+  try {
+    const result = await handle(req)
+    if (result === null) send({ jsonrpc: '2.0', id: req.id, error: { code: -32601, message: `지원하지 않는 메서드: ${req.method}` } })
+    else send({ jsonrpc: '2.0', id: req.id, result })
+  } catch (e) {
+    send({ jsonrpc: '2.0', id: req.id, error: { code: typeof e.code === 'number' ? e.code : -32603, message: e.message } })
+  }
+}
 rl.on('line', (line) => {
   const s = line.trim()
   if (!s) return
@@ -1083,22 +1227,19 @@ rl.on('line', (line) => {
     return
   }
   if (req.id === undefined) {
+    if (req.method === 'notifications/cancelled') { runningPipeline.get(req.params?.requestId)?.(); return }
     if (rootsSupported && !process.env.AXMAP_REPO &&
       ['notifications/initialized', 'notifications/roots/list_changed'].includes(req.method)) refreshRoots()
     return
   }
-  requests = requests.then(async () => {
-    try {
-      const result = await handle(req)
-      if (result === null) {
-        send({ jsonrpc: '2.0', id: req.id, error: { code: -32601, message: `지원하지 않는 메서드: ${req.method}` } })
-      } else {
-        send({ jsonrpc: '2.0', id: req.id, result })
-      }
-    } catch (e) {
-      send({ jsonrpc: '2.0', id: req.id, error: { code: -32603, message: e.message } })
-    }
-  })
+  if ((req.method === 'tools/call' && PIPELINE_TOOLS.has(req.params?.name)) || ['resources/list', 'resources/read'].includes(req.method)) {
+    if (concurrentViews >= 4) { send({ jsonrpc: '2.0', id: req.id, error: { code: -32000, message: '동시 파이프라인 조회 한도입니다. 잠시 후 다시 조회하세요.' } }); return }
+    concurrentViews++
+    void initialized.then(() => respond(req)).finally(() => { concurrentViews-- })
+    return
+  }
+  requests = requests.then(() => respond(req))
+  if (req.method === 'initialize') initialized = requests
 })
 
 process.stderr.write(`axMap MCP · 저장소 ${REPO} · 에이전트 ${AGENT} (${ACTOR})\n`)