axmap-cli 1.9.0 → 1.10.0

package/README.ko.md

@@ -31,6 +31,22 @@ axmap setup
 
 최신 변경부터 정리합니다.
 
+### 1.10.0
+
+<sub>2026.11.03</sub>
+
+**일반 Windows Claude Code 터미널을 연결하고, 상대가 준비될 때까지 실행 요청을 큐에 보관합니다.**
+
+- `axmap setup` 후 Git 저장소에서 평소처럼 `claude`를 실행하면 원래 프로세스와 대화가 자동 등록됩니다. `ax_dispatch` / `ax_result`로 새 모델 프로세스 없이 요청·응답을 주고받습니다.
+- 관리형 Claude Code·Codex·agy와 일반 Windows Claude 콘솔에서 실행 요청을 FIFO로 접수합니다. 입력 초안과 승인 화면을 유지하며, 큐 확인과 대기 중에는 모델을 호출하지 않습니다. AI 답변 생성에는 기존처럼 토큰이 사용됩니다.
+- `bridge serve claude`의 지속 연결을 지원합니다. 자동 대화에서 코드 블록에 감싼 JSON 응답, 실행 시간 제한과 `--done-by` 종료 주체 지정을 제공합니다.
+- 확정 미전달과 전달 불명을 구별하고 불명 요청은 자동 재전송하지 않습니다. 대기 조회가 큐에서 전송 중으로 넘어가는 순간에도 완료까지 기다립니다.
+
+Windows의 실제 일반 Claude Code 터미널과 Codex 요청·응답으로 검증했습니다. 일반 콘솔 연결은 Windows 범위이며, 토큰 예산을 검사하는 `ax_chat`은 관리형 stdio 세션을 사용합니다. 앱의 도구 승인 절차는 유지합니다.
+[연결 안내 →](docs/SESSION-BRIDGE.md)
+
+---
+
 ### 1.9.0
 
 <sub>2026.10.29</sub>

package/README.md

@@ -31,6 +31,22 @@ View pipeline state inside compatible MCP Apps hosts, or add it to the existing
 
 Newest changes first.
 
+### 1.10.0
+
+<sub>November 3, 2026</sub>
+
+**Connect ordinary Windows Claude Code terminals and queue execution requests until the recipient is ready.**
+
+- After `axmap setup`, launch `claude` normally in a Git repository. Hooks register the original process and conversation; `ax_dispatch` / `ax_result` deliver requests and collect replies without starting another model process.
+- Managed Claude Code, Codex and agy sessions, plus ordinary Windows Claude consoles, accept FIFO execution queues. Input drafts and approval screens are preserved. Waiting and queue handling make no model calls; generating a response still uses provider tokens.
+- `bridge serve claude` supports persistent stream-json conversations. Automatic dialogue accepts fenced JSON responses and provides execution timeouts and `--done-by` termination control.
+- Requests that were not delivered remain distinct from uncertain delivery. Unknown requests are never automatically replayed. Wait operations now follow the queued-to-sending handoff through completion.
+
+Validated with real Claude Code terminals and Codex request/reply exchanges on Windows. Ordinary console attachment is Windows-only; token-budgeted `ax_chat` continues to require managed stdio sessions. Tool approvals remain under the host's control.
+[Connection guide →](docs/SESSION-BRIDGE.md)
+
+---
+
 ### 1.9.0
 
 <sub>October 29, 2026</sub>

package/mcp/server.mjs

@@ -508,7 +508,7 @@ const TOOLS = [
   },
   {
     name: 'ax_dispatch',
-    description: '명시적으로 상대의 실행 턴이 필요한 작업용 저수준 전달이다. 일반 진행·완료·계약 확인 알림에는 새 턴 없는 ax_message를 사용하고 수신자가 작업 경계에서 ax_mailbox로 묶음 회수한다. 기존 맥락을 유지하며 새 모델 프로세스를 만들지 않는다. submitted는 완료가 아니다. unknown이면 자동 재시도하지 말고 ax_result로 확인한다. 작업 중인 세션을 강제 중단하지 않는다.',
+    description: '명시적으로 상대의 실행 턴이 필요한 작업용 전달이다. 관리형 Claude Code·Codex·agy와 Windows 일반 Claude Code(console)는 대기 중 실행하고 작업·입력·승인 대기 중이면 FIFO 큐에 접수해 idle에서 자동 실행한다. 기존 맥락과 프로세스를 유지한다. queued/submitted는 완료가 아니며 ax_result로 확인한다. unknown은 재전송하지 않는다. 일반 진행 알림에는 새 턴 없는 ax_message를 사용한다. 작업 중인 세션을 강제 중단하지 않는다.',
     inputSchema: { type: 'object', properties: {
       to: { type: 'string', description: 'ax_sessions에서 확인한 상대 세션 UUID' },
       prompt: { type: 'string', description: '상대가 실행할 작업 요청' },

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.9.0",
+  "version": "1.10.0",
   "//private": "🔴 여기 있던 \"private\": true 를 2026-08-28 에 지웠다. 그 줄이 있는 동안 npm publish 는 거부됐다. 되돌리려면 다시 넣으면 되지만, 이미 올라간 버전은 그래도 안 사라진다 — npm 은 같은 번호를 덮어쓰지 못하고 삭제도 72시간 안에만 된다. 즉 이 줄을 되살리는 것은 '앞으로 안 올린다' 는 뜻이지 '올린 것을 없앤다' 는 뜻이 아니다.",
   "//publishConfig": "axmap-cli 는 스코프가 없어서 기본이 이미 공개다. 즉 지금은 없어도 된다. 그래도 남겨 두는 이유: 나중에 @조직/axmap 처럼 스코프를 붙이는 날 이 줄이 없으면 publish 가 '유료 플랜이 필요하다'는 엉뚱한 말로 실패한다.",
   "publishConfig": {

package/src/bridge.mjs

@@ -5,7 +5,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { withRepoLock } from './repolock.mjs';
 import { submitConsole, checkConsole, validateConsolePrompt, findConsoleTranscript, externalStatus } from './external-console.mjs';
@@ -100,6 +100,24 @@ function runAPI(session, args) {
     return null;
 }
 function transcript(session) {
+    if (session.provider === 'claude') {
+        const home = process.env.AXMAP_CLAUDE_HOME || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+        const relative = session.transcript ? path.relative(path.join(home, 'projects'), session.transcript) : '..';
+        if (!session.transcript || relative.startsWith('..') || path.isAbsolute(relative) || path.basename(session.transcript) !== `${session.conversationId}.jsonl`)
+            throw new Error('Claude transcript identity mismatch');
+        if (!fs.existsSync(session.transcript))
+            return [];
+        return fs.readFileSync(session.transcript, 'utf8').split('\n').slice(0, -1).filter(Boolean).flatMap(line => {
+            const entry = JSON.parse(line);
+            if (entry.sessionId && entry.sessionId !== session.conversationId)
+                return [];
+            const content = entry.message?.content;
+            const text = typeof content === 'string' ? content : Array.isArray(content) ? content.filter(b => b.type === 'text').map(b => b.text || '').join('\n') : '';
+            if (!text || !['user', 'assistant'].includes(entry.type || ''))
+                return [];
+            return [{ type: entry.type === 'user' ? 'USER_INPUT' : 'PLANNER_RESPONSE', source: 'MODEL', status: 'DONE', content: text }];
+        });
+    }
     const expected = path.join(agyHome(), 'brain', session.conversationId || session.id, '.system_generated', 'logs', 'transcript.jsonl');
     if (session.transcript !== expected)
         throw new Error('등록된 대화 기록 경로가 올바르지 않습니다.');
@@ -203,7 +221,7 @@ function sessionFor(id, cwd) {
     const s = readJSON(file('sessions', id));
     if (!s.repos.includes(repoKey(cwd)))
         throw new Error('이 세션은 현재 작업 저장소에 등록되지 않았습니다.');
-    if (s.provider !== 'agy' && !['pty', 'stdio'].includes(s.transport || ''))
+    if (s.provider !== 'agy' && !(s.provider === 'claude' && s.transport === 'console') && !['pty', 'stdio'].includes(s.transport || ''))
         throw new Error('아직 지원하지 않는 수신 세션입니다.');
     return s;
 }
@@ -235,16 +253,32 @@ export function requestResult(id, cwd) {
     const request = readJSON(target);
     if (request.repo !== repoKey(cwd))
         throw new Error('이 요청은 현재 작업 저장소의 요청이 아닙니다.');
-    if (!['submitted', 'unknown'].includes(request.state))
+    if (!['queued', 'submitted', 'unknown'].includes(request.state))
         return request;
     let s = sessionFor(request.to, cwd);
+    if (request.state === 'queued' && s.transport === 'console')
+        return request;
     if (['pty', 'stdio'].includes(s.transport || '')) {
         try {
             Object.assign(request, terminalRPC(s.id, { action: 'result', id }));
         }
         catch (e) {
-            request.state = 'unknown';
-            request.error = errorMessage(e);
+            const saved = path.join(bridgeHome(), 'jobs', `${id}.json`);
+            // A normal host exit persists outcomes before closing the pipe. Never replay
+            // a queued job after a crash or mistake an unexecuted job for completion.
+            if (s.transport === 'stdio' && fs.existsSync(saved)) {
+                const job = readJSON(saved);
+                if (job.id === id && job.to === s.id && ['completed', 'failed', 'unknown'].includes(job.state))
+                    Object.assign(request, job);
+                else {
+                    request.state = 'unknown';
+                    request.error = errorMessage(e);
+                }
+            }
+            else {
+                request.state = 'unknown';
+                request.error = errorMessage(e);
+            }
         }
         writeJSON(target, request);
         return request;
@@ -292,7 +326,7 @@ export async function waitForRequest(id, cwd, timeoutMs = 30000) {
     const deadline = performance.now() + timeoutMs;
     for (;;) {
         const result = requestResult(id, cwd);
-        if (result.state !== 'submitted' || performance.now() >= deadline)
+        if (!['queued', 'sending', 'submitted'].includes(result.state) || performance.now() >= deadline)
             return result;
         await new Promise(resolve => setTimeout(resolve, Math.min(100, Math.max(0, deadline - performance.now()))));
     }
@@ -302,7 +336,7 @@ export function sessionLeasePath(id) {
         throw new Error('세션 ID는 UUID여야 합니다.');
     return path.join(bridgeHome(), 'dialogues', `session-${id}.lock`);
 }
-export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null }) {
+export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null, queueIfBusy = false }) {
     // 보내기 시작 전에 난 오류(이전 요청 미확정, 대기 미확인 등)는 확실히 전달되지 않은 것이다.
     // 받은 편지함이 이를 "전달 불명"과 구별해야 쪽지를 다시 대기열로 돌릴 수 있다.
     let sending = false;
@@ -315,15 +349,35 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
             throw new Error('이 세션은 자동 대화가 사용 중입니다. 해당 대화가 끝난 뒤 요청하세요.');
         const dir = path.join(bridgeHome(), 'requests');
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (queueIfBusy && s.provider === 'claude' && s.transport === 'console') {
+            validateConsolePrompt(prompt, from);
+            if (s.state === 'closed')
+                throw new Error('Claude terminal is closed');
+            const request = withRepoLock(path.join(dir, `${to}.lock`), () => {
+                const pending = fs.readdirSync(dir).filter(n => n.endsWith('.json')).map(n => readJSON(path.join(dir, n)))
+                    .filter(r => r.to === to && r.state === 'queued');
+                if (pending.length >= 100)
+                    throw new Error('Claude command queue is full');
+                const request = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt, createdAt: new Date().toISOString(), baseline: null, state: 'queued' };
+                writeJSON(file('requests', request.id), request);
+                return request;
+            });
+            const worker = spawn(process.execPath, [path.join(ROOT, 'tools', 'console-queue.mjs'), to, cwd], { detached: true, windowsHide: true, stdio: 'ignore' });
+            worker.on('error', () => { });
+            worker.unref();
+            return request;
+        }
         return withRepoLock(path.join(dir, `${to}.lock`), () => {
             if (fs.existsSync(lease) && readJSON(lease).dialogueId !== dialogueId)
                 throw new Error('이 세션은 자동 대화가 사용 중입니다.');
             for (const n of fs.readdirSync(dir).filter(n => n.endsWith('.json'))) {
                 const previous = readJSON(path.join(dir, n));
-                if (previous.to !== to || !['sending', 'submitted', 'unknown'].includes(previous.state))
+                if (previous.to !== to || !['queued', 'sending', 'submitted', 'unknown'].includes(previous.state))
                     continue;
                 const latest = previous.state === 'sending' ? previous : requestResult(previous.id, cwd);
-                if (['sending', 'submitted', 'unknown'].includes(latest.state))
+                if (queueIfBusy && s.transport === 'stdio' && ['queued', 'submitted'].includes(latest.state))
+                    continue;
+                if (['queued', 'sending', 'submitted', 'unknown'].includes(latest.state))
                     throw new Error(`이 세션의 이전 요청이 아직 확정되지 않았습니다: ${latest.id}`);
             }
             // No fallback to `agy -p` or --conversation: both would start a separate process.
@@ -344,9 +398,9 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
             sending = true;
             try {
                 request.receipt = s.transport === 'console' ? submitConsole(s, request, consolePreflight) : ['pty', 'stdio'].includes(s.transport || '')
-                    ? terminalRPC(to, { action: 'submit', request })
+                    ? terminalRPC(to, { action: 'submit', request, ...(queueIfBusy && s.transport === 'stdio' ? { queueIfBusy: true } : {}) })
                     : runAPI(s, ['send-message', to, `[axMap request ${request.id}]\n요청자: ${from}\n${prompt}`]);
-                request.state = 'submitted';
+                request.state = request.receipt?.queued ? 'queued' : 'submitted';
             }
             catch (e) {
                 if (notDelivered(e)) {
@@ -445,3 +499,89 @@ export function installHooks({ executable, home = os.homedir() }) {
     return { hooks: target, backup: original === null ? null : backup,
         note: '기존 실행 중인 CLI가 새 훅을 읽지 않으면 같은 대화를 재개해 한 번 다시 열어야 합니다. Remote Control은 필요 없습니다.' };
 }
+/** One local worker per ordinary Claude terminal; no provider is launched. */
+export function runConsoleQueue(to, cwd) {
+    const dir = path.join(bridgeHome(), 'requests');
+    const runnerLock = path.join(dir, `${to}.runner.lock`);
+    if (fs.existsSync(runnerLock)) {
+        const owner = readJSON(runnerLock);
+        try {
+            process.kill(owner.pid, 0);
+        }
+        catch (e) {
+            if (errorCode(e) === 'ESRCH')
+                fs.unlinkSync(runnerLock);
+        }
+    }
+    try {
+        withRepoLock(runnerLock, () => {
+            for (;;) {
+                const records = withRepoLock(path.join(dir, `${to}.lock`), () => fs.readdirSync(dir)
+                    .filter(n => n.endsWith('.json')).map(n => readJSON(path.join(dir, n)))
+                    .filter(r => r.to === to).sort((a, b) => a.createdAt.localeCompare(b.createdAt)));
+                const queued = records.filter(r => r.state === 'queued');
+                if (!queued.length)
+                    return;
+                let waiting = false;
+                for (const r of records.filter(r => ['sending', 'submitted', 'unknown'].includes(r.state))) {
+                    const latest = r.state === 'sending' ? r : requestResult(r.id, cwd);
+                    if (['unknown', 'sending'].includes(latest.state))
+                        return;
+                    if (latest.state === 'submitted')
+                        waiting = true;
+                }
+                const s = sessionFor(to, cwd);
+                if (s.pid) {
+                    try {
+                        process.kill(s.pid, 0);
+                    }
+                    catch (e) {
+                        if (errorCode(e) === 'ESRCH') {
+                            for (const r of queued)
+                                writeJSON(file('requests', r.id), { ...r, state: 'failed', error: 'Claude process exited before execution' });
+                            return;
+                        }
+                    }
+                }
+                if (s.state === 'closed') {
+                    for (const r of queued)
+                        writeJSON(file('requests', r.id), { ...r, state: 'failed', error: 'Claude terminal closed before execution' });
+                    return;
+                }
+                let live;
+                try {
+                    live = checkConsole(s);
+                }
+                catch {
+                    waiting = true;
+                }
+                if (waiting || !live) {
+                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+                    continue;
+                }
+                withRepoLock(path.join(dir, `${to}.lock`), () => {
+                    const r = readJSON(file('requests', queued[0].id));
+                    if (r.state !== 'queued')
+                        return;
+                    r.baseline = transcript(s).length;
+                    r.state = 'sending';
+                    writeJSON(file('requests', r.id), r);
+                    try {
+                        r.receipt = submitConsole(s, r, live);
+                        r.state = 'submitted';
+                    }
+                    catch (e) {
+                        r.state = notDelivered(e) ? 'queued' : 'unknown';
+                        r.error = errorMessage(e);
+                    }
+                    writeJSON(file('requests', r.id), r);
+                });
+            }
+        }, 1000);
+    }
+    catch (e) {
+        // Another worker won the runner lease. It owns draining; never replay here.
+        if (!fs.existsSync(runnerLock))
+            throw e;
+    }
+}

package/src/bridge.mts

@@ -4,7 +4,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { randomUUID } from 'node:crypto'
-import { spawnSync } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { withRepoLock } from './repolock.mjs'
 import { submitConsole, checkConsole, validateConsolePrompt, findConsoleTranscript, externalStatus } from './external-console.mjs'
@@ -82,6 +82,20 @@ function runAPI(session: SessionRecord, args: string[]): unknown {
   return null
 }
 function transcript(session: SessionRecord): TranscriptEntry[] {
+  if (session.provider === 'claude') {
+    const home = process.env.AXMAP_CLAUDE_HOME || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
+    const relative = session.transcript ? path.relative(path.join(home, 'projects'), session.transcript) : '..'
+    if (!session.transcript || relative.startsWith('..') || path.isAbsolute(relative) || path.basename(session.transcript) !== `${session.conversationId}.jsonl`) throw new Error('Claude transcript identity mismatch')
+    if (!fs.existsSync(session.transcript)) return []
+    return fs.readFileSync(session.transcript, 'utf8').split('\n').slice(0, -1).filter(Boolean).flatMap(line => {
+      const entry = JSON.parse(line) as { type?: string; sessionId?: string; message?: { content?: string | Array<{ type: string; text?: string }> } }
+      if (entry.sessionId && entry.sessionId !== session.conversationId) return []
+      const content = entry.message?.content
+      const text = typeof content === 'string' ? content : Array.isArray(content) ? content.filter(b => b.type === 'text').map(b => b.text || '').join('\n') : ''
+      if (!text || !['user', 'assistant'].includes(entry.type || '')) return []
+      return [{ type: entry.type === 'user' ? 'USER_INPUT' : 'PLANNER_RESPONSE', source: 'MODEL', status: 'DONE', content: text }]
+    })
+  }
   const expected = path.join(agyHome(), 'brain', session.conversationId || session.id, '.system_generated', 'logs', 'transcript.jsonl')
   if (session.transcript !== expected) throw new Error('등록된 대화 기록 경로가 올바르지 않습니다.')
   const lines = fs.readFileSync(expected, 'utf8').split('\n')
@@ -164,7 +178,7 @@ export function sessions(cwd: string): PublicSession[] {
 function sessionFor(id: string, cwd: string): SessionRecord {
   const s = readJSON<SessionRecord>(file('sessions', id))
   if (!s.repos.includes(repoKey(cwd))) throw new Error('이 세션은 현재 작업 저장소에 등록되지 않았습니다.')
-  if (s.provider !== 'agy' && !['pty', 'stdio'].includes(s.transport || '')) throw new Error('아직 지원하지 않는 수신 세션입니다.')
+  if (s.provider !== 'agy' && !(s.provider === 'claude' && s.transport === 'console') && !['pty', 'stdio'].includes(s.transport || '')) throw new Error('아직 지원하지 않는 수신 세션입니다.')
   return s
 }
 
@@ -193,11 +207,21 @@ export function requestResult(id: string, cwd: string): RequestRecord {
   const target = file('requests', id)
   const request = readJSON<RequestRecord>(target)
   if (request.repo !== repoKey(cwd)) throw new Error('이 요청은 현재 작업 저장소의 요청이 아닙니다.')
-  if (!['submitted', 'unknown'].includes(request.state)) return request
+  if (!['queued', 'submitted', 'unknown'].includes(request.state)) return request
   let s = sessionFor(request.to, cwd)
+  if (request.state === 'queued' && s.transport === 'console') return request
   if (['pty', 'stdio'].includes(s.transport || '')) {
     try { Object.assign(request, terminalRPC(s.id, { action: 'result', id })) }
-    catch (e) { request.state = 'unknown'; request.error = errorMessage(e) }
+    catch (e) {
+      const saved = path.join(bridgeHome(), 'jobs', `${id}.json`)
+      // A normal host exit persists outcomes before closing the pipe. Never replay
+      // a queued job after a crash or mistake an unexecuted job for completion.
+      if (s.transport === 'stdio' && fs.existsSync(saved)) {
+        const job = readJSON<Pick<RequestRecord, 'id' | 'to' | 'state'>>(saved)
+        if (job.id === id && job.to === s.id && ['completed', 'failed', 'unknown'].includes(job.state)) Object.assign(request, job)
+        else { request.state = 'unknown'; request.error = errorMessage(e) }
+      } else { request.state = 'unknown'; request.error = errorMessage(e) }
+    }
     writeJSON(target, request)
     return request
   }
@@ -237,7 +261,7 @@ export async function waitForRequest(id: string, cwd: string, timeoutMs = 30000)
   const deadline = performance.now() + timeoutMs
   for (;;) {
     const result = requestResult(id, cwd)
-    if (result.state !== 'submitted' || performance.now() >= deadline) return result
+    if (!['queued', 'sending', 'submitted'].includes(result.state) || performance.now() >= deadline) return result
     await new Promise(resolve => setTimeout(resolve, Math.min(100, Math.max(0, deadline - performance.now()))))
   }
 }
@@ -247,7 +271,7 @@ export function sessionLeasePath(id: string): string {
   return path.join(bridgeHome(), 'dialogues', `session-${id}.lock`)
 }
 
-export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null }: DispatchOptions): RequestRecord {
+export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null, queueIfBusy = false }: DispatchOptions): RequestRecord {
   // 보내기 시작 전에 난 오류(이전 요청 미확정, 대기 미확인 등)는 확실히 전달되지 않은 것이다.
   // 받은 편지함이 이를 "전달 불명"과 구별해야 쪽지를 다시 대기열로 돌릴 수 있다.
   let sending = false
@@ -258,13 +282,29 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
   if (fs.existsSync(lease) && readJSON<{ dialogueId: string }>(lease).dialogueId !== dialogueId) throw new Error('이 세션은 자동 대화가 사용 중입니다. 해당 대화가 끝난 뒤 요청하세요.')
   const dir = path.join(bridgeHome(), 'requests')
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  if (queueIfBusy && s.provider === 'claude' && s.transport === 'console') {
+    validateConsolePrompt(prompt, from)
+    if (s.state === 'closed') throw new Error('Claude terminal is closed')
+    const request = withRepoLock(path.join(dir, `${to}.lock`), () => {
+      const pending = fs.readdirSync(dir).filter(n => n.endsWith('.json')).map(n => readJSON<RequestRecord>(path.join(dir, n)))
+        .filter(r => r.to === to && r.state === 'queued')
+      if (pending.length >= 100) throw new Error('Claude command queue is full')
+      const request: RequestRecord = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt, createdAt: new Date().toISOString(), baseline: null, state: 'queued' }
+      writeJSON(file('requests', request.id), request)
+      return request
+    })
+    const worker = spawn(process.execPath, [path.join(ROOT, 'tools', 'console-queue.mjs'), to, cwd], { detached: true, windowsHide: true, stdio: 'ignore' })
+    worker.on('error', () => {}); worker.unref()
+    return request
+  }
   return withRepoLock(path.join(dir, `${to}.lock`), () => {
     if (fs.existsSync(lease) && readJSON<{ dialogueId: string }>(lease).dialogueId !== dialogueId) throw new Error('이 세션은 자동 대화가 사용 중입니다.')
     for (const n of fs.readdirSync(dir).filter(n => n.endsWith('.json'))) {
       const previous = readJSON<RequestRecord>(path.join(dir, n))
-      if (previous.to !== to || !['sending', 'submitted', 'unknown'].includes(previous.state)) continue
+      if (previous.to !== to || !['queued', 'sending', 'submitted', 'unknown'].includes(previous.state)) continue
       const latest = previous.state === 'sending' ? previous : requestResult(previous.id, cwd)
-      if (['sending', 'submitted', 'unknown'].includes(latest.state)) throw new Error(`이 세션의 이전 요청이 아직 확정되지 않았습니다: ${latest.id}`)
+      if (queueIfBusy && s.transport === 'stdio' && ['queued', 'submitted'].includes(latest.state)) continue
+      if (['queued', 'sending', 'submitted', 'unknown'].includes(latest.state)) throw new Error(`이 세션의 이전 요청이 아직 확정되지 않았습니다: ${latest.id}`)
     }
     // No fallback to `agy -p` or --conversation: both would start a separate process.
     let consolePreflight
@@ -280,9 +320,9 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
     sending = true
     try {
       request.receipt = s.transport === 'console' ? submitConsole(s, request, consolePreflight) : ['pty', 'stdio'].includes(s.transport || '')
-        ? terminalRPC(to, { action: 'submit', request })
+        ? terminalRPC(to, { action: 'submit', request, ...(queueIfBusy && s.transport === 'stdio' ? { queueIfBusy: true } : {}) })
         : runAPI(s, ['send-message', to, `[axMap request ${request.id}]\n요청자: ${from}\n${prompt}`])
-      request.state = 'submitted'
+      request.state = (request.receipt as { queued?: boolean })?.queued ? 'queued' : 'submitted'
     } catch (e) {
       if (notDelivered(e)) {
         // 로컬 파이프에 연결조차 못 했다(ENOENT·ECONNREFUSED). 한 바이트도 보내지
@@ -372,3 +412,57 @@ export function installHooks({ executable, home = os.homedir() }: { executable:
   return { hooks: target, backup: original === null ? null : backup,
     note: '기존 실행 중인 CLI가 새 훅을 읽지 않으면 같은 대화를 재개해 한 번 다시 열어야 합니다. Remote Control은 필요 없습니다.' }
 }
+
+/** One local worker per ordinary Claude terminal; no provider is launched. */
+export function runConsoleQueue(to: string, cwd: string) {
+  const dir = path.join(bridgeHome(), 'requests')
+  const runnerLock = path.join(dir, `${to}.runner.lock`)
+  if (fs.existsSync(runnerLock)) {
+    const owner = readJSON<{ pid: number }>(runnerLock)
+    try { process.kill(owner.pid, 0) } catch (e) {
+      if (errorCode(e) === 'ESRCH') fs.unlinkSync(runnerLock)
+    }
+  }
+  try { withRepoLock(runnerLock, () => {
+    for (;;) {
+      const records: RequestRecord[] = withRepoLock(path.join(dir, `${to}.lock`), () => fs.readdirSync(dir)
+        .filter(n => n.endsWith('.json')).map(n => readJSON<RequestRecord>(path.join(dir, n)))
+        .filter(r => r.to === to).sort((a, b) => a.createdAt.localeCompare(b.createdAt)))
+      const queued = records.filter(r => r.state === 'queued')
+      if (!queued.length) return
+      let waiting = false
+      for (const r of records.filter(r => ['sending', 'submitted', 'unknown'].includes(r.state))) {
+        const latest = r.state === 'sending' ? r : requestResult(r.id, cwd)
+        if (['unknown', 'sending'].includes(latest.state)) return
+        if (latest.state === 'submitted') waiting = true
+      }
+      const s = sessionFor(to, cwd)
+      if (s.pid) {
+        try { process.kill(s.pid, 0) } catch (e) {
+          if (errorCode(e) === 'ESRCH') {
+            for (const r of queued) writeJSON(file('requests', r.id), { ...r, state: 'failed', error: 'Claude process exited before execution' })
+            return
+          }
+        }
+      }
+      if (s.state === 'closed') {
+        for (const r of queued) writeJSON(file('requests', r.id), { ...r, state: 'failed', error: 'Claude terminal closed before execution' })
+        return
+      }
+      let live
+      try { live = checkConsole(s) } catch { waiting = true }
+      if (waiting || !live) { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200); continue }
+      withRepoLock(path.join(dir, `${to}.lock`), () => {
+        const r = readJSON<RequestRecord>(file('requests', queued[0]!.id))
+        if (r.state !== 'queued') return
+        r.baseline = transcript(s).length; r.state = 'sending'; writeJSON(file('requests', r.id), r)
+        try { r.receipt = submitConsole(s, r, live); r.state = 'submitted' }
+        catch (e) { r.state = notDelivered(e) ? 'queued' : 'unknown'; r.error = errorMessage(e) }
+        writeJSON(file('requests', r.id), r)
+      })
+    }
+  }, 1000) } catch (e) {
+    // Another worker won the runner lease. It owns draining; never replay here.
+    if (!fs.existsSync(runnerLock)) throw e
+  }
+}

package/src/external-console.mjs

@@ -25,19 +25,19 @@ export function consoleCall(pid, action = 'snapshot', payload = {}) {
     }
     catch { /* report the underlying failure */ }
     if (r.error || r.status !== 0 || data?.error || !data)
-        throw new Error(data?.error || r.error?.message || r.stderr?.trim() || '기존 콘솔 연결 실패');
+        throw Object.assign(new Error(data?.error || r.error?.message || r.stderr?.trim() || '기존 콘솔 연결 실패'), { notDelivered: !r.error && data?.notDelivered === true });
     if (action === 'ancestor' && data.ignored)
         return { ignored: true };
     if (typeof data.pid !== 'number' || typeof data.startedAt !== 'string' || (action !== 'ancestor' && typeof data.screen !== 'string'))
         throw new Error('기존 콘솔 응답 형식이 올바르지 않습니다.');
     return data;
 }
-function identityID({ pid, startedAt }) {
-    const hex = createHash('sha256').update(`agy-console:${pid}:${startedAt}`).digest('hex');
+function identityID({ pid, startedAt, provider = 'agy' }) {
+    const hex = createHash('sha256').update(`${provider}-console:${pid}:${startedAt}`).digest('hex');
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
 }
 const target = (id) => path.join(bridgeHome(), 'sessions', `${id}.json`);
-export function consoleIdle(screen) {
+export function consoleIdle(screen, live) {
     // Use the last input box only. Old answers may contain quoted prompt boxes.
     const borders = [...screen.matchAll(/^[─━]{10,}\r?$/gm)];
     if (borders.length < 2)
@@ -47,7 +47,15 @@ export function consoleIdle(screen) {
         return false;
     const input = screen.slice(top.index + top[0].length, bottom.index).trim();
     const footer = screen.slice(bottom.index + bottom[0].length);
-    return input === '>' && /\? for shortcuts/.test(footer) && !/esc to cancel/i.test(footer);
+    const empty = /^[>❯]$/.test(input);
+    // Claude paints a suggestion after the cursor in an otherwise empty editor.
+    // Require the cursor to remain at that editor's start, never just match text.
+    const placeholder = live?.provider === 'claude' && live.cursorX === 2 &&
+        /^[>❯]\s+Try "[^"\r\n]+"$/.test(input) &&
+        live.cursorRow === screen.slice(0, top.index + top[0].length).split('\n').length;
+    const claudeEditor = live?.provider === 'claude' && live.cursorX === 2 &&
+        live.cursorRow === screen.slice(0, top.index + top[0].length).split('\n').length;
+    return (empty || placeholder) && (live?.provider === 'claude' ? claudeEditor : /\? for shortcuts/.test(footer)) && !/esc to (cancel|interrupt)/i.test(footer);
 }
 export function attachConsole({ pid, cwd }) {
     const live = consoleCall(pid);
@@ -56,19 +64,38 @@ export function attachConsole({ pid, cwd }) {
     const repo = repoKey(cwd);
     if (previous.repos && !previous.repos.includes(repo))
         throw new Error('이 프로세스는 다른 저장소에 등록되어 있습니다.');
-    const idle = consoleIdle(live.screen);
-    const s = { ...previous, id, provider: 'agy', transport: 'console', pid, startedAt: live.startedAt,
+    const idle = consoleIdle(live.screen, live);
+    const s = { ...previous, id, provider: live.provider || 'agy', transport: 'console', pid, startedAt: live.startedAt,
         workspaces: previous.workspaces || [path.resolve(cwd)], repos: previous.repos || [repo],
         state: idle ? 'idle' : 'unknown', fullyIdle: idle, registeredAt: new Date().toISOString(), event: previous.event || 'attach' };
     writeJSON(target(id), s);
     return { id, provider: s.provider, transport: s.transport, pid, state: s.state, workspaces: s.workspaces };
 }
-export function registerExternalHook(input, event) {
-    if (!['SessionStart', 'PreInvocation', 'Stop'].includes(event))
+export function registerExternalHook(input, event, provider = 'agy') {
+    if (!['SessionStart', 'PreInvocation', 'UserPromptSubmit', 'Stop', 'SessionEnd'].includes(event))
         throw new Error('지원하지 않는 훅 이벤트입니다.');
     const identity = consoleCall(process.pid, 'ancestor');
     if (identity.ignored)
         return {};
+    if (identity.provider && identity.provider !== provider)
+        return {};
+    if (provider === 'claude') {
+        const conversationId = input.session_id;
+        const log = input.transcript_path;
+        const home = process.env.AXMAP_CLAUDE_HOME || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+        const relative = typeof log === 'string' ? path.relative(path.join(home, 'projects'), path.resolve(log)) : '..';
+        if (!conversationId || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(conversationId) ||
+            !log || relative.startsWith('..') || path.isAbsolute(relative) || path.basename(log) !== `${conversationId}.jsonl` ||
+            !input.cwd || !path.isAbsolute(input.cwd))
+            throw new Error('Claude 훅의 대화 기록·작업 폴더 신원이 올바르지 않습니다.');
+        const id = identityID(identity);
+        const previous = fs.existsSync(target(id)) ? readJSON(target(id)) : {};
+        const state = event === 'SessionEnd' ? 'closed' : event === 'Stop' || event === 'SessionStart' ? 'settling' : 'running';
+        writeJSON(target(id), { ...previous, ...identity, id, provider: 'claude', transport: 'console', conversationId,
+            transcript: path.resolve(log), workspaces: [path.resolve(input.cwd)], repos: [repoKey(input.cwd)],
+            state, fullyIdle: false, event, registeredAt: new Date().toISOString() });
+        return { id };
+    }
     const id = identityID(identity);
     const previous = fs.existsSync(target(id)) ? readJSON(target(id)) : {};
     const workspaces = input.workspacePaths || previous.workspaces;
@@ -89,7 +116,8 @@ export function registerExternalHook(input, event) {
 export function externalStatus(session) {
     const s = readJSON(target(session.id));
     const live = consoleCall(consolePID(s), 'snapshot', { startedAt: s.startedAt });
-    const state = consoleIdle(live.screen) ? 'idle' : 'unknown';
+    const eligible = s.provider !== 'claude' || ['SessionStart', 'Stop'].includes(s.event || '');
+    const state = s.state === 'closed' ? 'closed' : eligible && consoleIdle(live.screen, live) ? 'idle' : 'unknown';
     writeJSON(target(s.id), { ...readJSON(target(s.id)), state, fullyIdle: state === 'idle' });
     return { id: s.id, state };
 }
@@ -100,7 +128,9 @@ function consolePID(s) {
 }
 export function checkConsole(s) {
     const live = consoleCall(consolePID(s), 'snapshot', { startedAt: s.startedAt });
-    if (!consoleIdle(live.screen))
+    if (s.provider === 'claude' && !['SessionStart', 'Stop'].includes(s.event || ''))
+        throw new Error('Claude가 실행·승인 대기 중입니다.');
+    if (!consoleIdle(live.screen, live))
         throw new Error('상대 콘솔이 빈 입력창에서 대기 중이지 않습니다. 입력을 보내지 않았습니다.');
     return live;
 }
@@ -111,6 +141,8 @@ export function validateConsolePrompt(prompt, from) {
 export function findConsoleTranscript(s, request) {
     if (s.transcript)
         return s;
+    if (s.provider === 'claude')
+        return s;
     const brain = path.join(process.env.AXMAP_AGY_HOME || path.join(os.homedir(), '.gemini', 'antigravity-cli'), 'brain');
     if (!fs.existsSync(brain))
         return s;
@@ -153,7 +185,8 @@ export function submitConsole(s, request, preflight) {
     // Bracketed paste preserves multiline prompts and prevents embedded Enter keys
     // from becoming separate submissions. Only the final CR submits the message.
     const text = `\x1b[200~[axMap request ${request.id}]\n요청자: ${request.from}\n${request.prompt.replace(/\r\n/g, '\n')}\x1b[201~\r`;
-    consoleCall(consolePID(s), 'send', { startedAt: s.startedAt, expectedScreen: live.screen, text });
+    consoleCall(consolePID(s), 'send', { startedAt: s.startedAt, expectedScreen: live.screen,
+        expectedCursorX: live.cursorX, expectedCursorRow: live.cursorRow, text });
     writeJSON(target(s.id), { ...readJSON(target(s.id)), state: 'running', fullyIdle: false });
     return { accepted: true, pid: s.pid };
 }