axmap-cli 1.8.0 → 1.10.0

package/mcp/server.mjs

@@ -46,6 +46,7 @@ import path from 'node:path'
 import readline from 'node:readline'
 import { fileURLToPath } from 'node:url'
 import { syncConfiguredProfile } from '../src/identity.mjs'
+import { resolveTarget } from '../src/workspace.mjs'
 
 const HERE = path.dirname(fileURLToPath(import.meta.url))
 
@@ -77,14 +78,26 @@ let rootsTask = null
 let rootsGeneration = 0
 let rootRequestId = 0
 const pendingRoots = new Map()
-let REPO = resolveRepo()
-
-function gitRoot(cwd) {
-  const r = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', windowsHide: true })
-  const top = r.status === 0 ? (r.stdout ?? '').trim() : ''
-  return top ? fs.realpathSync(top) : null
+/**
+ * 🔴 시작 폴더가 여러 저장소를 담은 작업 폴더라 모호하면 여기서 죽지 않는다.
+ *    서버가 떠야 도구 호출이 그 모호함과 고르는 방법을 에이전트에게 알려 줄 수 있다.
+ *    대상은 도구를 부를 때마다 다시 정하므로, 사람이 `.axmap.json` 을 쓰면 다음
+ *    호출부터 바로 따른다.
+ */
+let REPO
+try { REPO = resolveRepo() } catch (e) {
+  REPO = process.cwd()
+  process.stderr.write(`axMap MCP: 대상 저장소를 아직 정하지 못했습니다.\n${e.message}\n`)
 }
 
+/**
+ * 폴더 → 대상 저장소. 위로 찾기(Git 안)를 먼저 하고, Git 밖이면 작업 폴더 규칙
+ * (`.axmap.json` 수동 설정 → 바로 아래 저장소 자동 탐색 → 모호하면 오류)을 쓴다.
+ * 규칙은 `src/workspace.mjs` 한 곳에 있다 — CLI·로컬 세션 연결과 같은 답을 내야 한다.
+ * 저장소가 없으면 null, 모호하거나 판정하지 못하면 예외다.
+ */
+function gitRoot(cwd) { return resolveTarget(cwd) }
+
 /** Explicit pin > per-call cwd > client roots > launch cwd.
  * A global desktop selection must never redirect another CLI session. */
 function resolveRepo(args = {}) {
@@ -111,7 +124,9 @@ function resolveRepo(args = {}) {
       return top
     }))]
     if (dirs.length === 1) return dirs[0]
-    const launched = gitRoot(process.cwd())
+    // 시작 폴더는 여러 roots 중 하나를 고르는 근거로만 쓴다. 판정하지 못하면 근거가 없는 것이다.
+    let launched = null
+    try { launched = gitRoot(process.cwd()) } catch { /* 고를 근거 없음 → 아래 오류 */ }
     if (dirs.includes(launched)) return launched
     throw new Error('작업 저장소를 하나로 정할 수 없습니다. 도구의 cwd 에 작업 폴더 절대 경로를 지정하세요.')
   }
@@ -493,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.8.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,11 +5,12 @@ 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';
-import { errorCode, errorMessage } from './session-types.mjs';
+import { errorCode, errorMessage, RPC_NOT_DELIVERED_EXIT } from './session-types.mjs';
+import { commonKey, resolveTarget } from './workspace.mjs';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const bridgeHome = () => path.join(process.env.AXMAP_STATE_DIR || path.join(os.homedir(), '.axmap'), 'bridge');
@@ -45,14 +46,23 @@ function writeJSON(p, data) {
             fs.unlinkSync(tmp);
     }
 }
-function repoKey(cwd) {
+function commonDirKey(cwd) {
     const r = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
         cwd, encoding: 'utf8', windowsHide: true,
     });
-    if (r.status !== 0)
+    return r.status === 0 ? commonKey(fs.realpathSync(r.stdout.trim())) : null;
+}
+function repoKey(cwd) {
+    // Git 안이면 지금까지와 같은 한 번의 git 호출로 끝낸다. 실패했을 때만 작업 폴더
+    // 규칙(수동 설정 → 자식 저장소 자동 탐색 → 모호하면 오류)으로 대상 저장소를 정한다.
+    const direct = commonDirKey(cwd);
+    if (direct)
+        return direct;
+    const repo = resolveTarget(cwd);
+    const key = repo && commonDirKey(repo);
+    if (!key)
         throw new Error(`Git 작업 저장소를 확인하지 못했습니다: ${cwd}`);
-    const key = fs.realpathSync(r.stdout.trim());
-    return process.platform === 'win32' ? key.toLowerCase() : key;
+    return key;
 }
 function addressError(address) {
     // Only a loopback address exported by a local provider hook is accepted.
@@ -90,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('등록된 대화 기록 경로가 올바르지 않습니다.');
@@ -98,26 +126,102 @@ function transcript(session) {
     lines.pop();
     return lines.filter(s => s.trim()).map(s => JSON.parse(s));
 }
-function publicSession(s) {
+function publicSession(s, liveness) {
     return { id: s.id, provider: s.provider, workspaces: s.workspaces, model: s.model,
         conversationId: s.conversationId,
         transport: s.transport || 'agentapi', state: s.state, pid: s.pid,
-        registeredAt: s.registeredAt, event: s.event, fullyIdle: s.fullyIdle,
-        role: s.role, usage: s.usage, usageKnown: s.usageKnown, maxTokens: s.maxTokens, pendingApproval: s.pendingApproval };
+        registeredAt: s.registeredAt, event: s.event,
+        // 호스트가 살아 있는지 확인하지 못했으면 저장된 "대기"를 대기로 보고하지 않는다.
+        fullyIdle: liveness === 'unverified' ? false : s.fullyIdle,
+        role: s.role, usage: s.usage, usageKnown: s.usageKnown, maxTokens: s.maxTokens, pendingApproval: s.pendingApproval,
+        ...(liveness ? { liveness } : {}) };
+}
+/** 관리형 세션(pty·stdio)의 로컬 제어 파이프. 세션 호스트가 살아 있는 동안만 존재한다. */
+export const hostPipe = (id) => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`);
+/** Windows 의 열린 파이프 이름 목록. 읽지 못하면 오류 자체를 돌려준다 —
+ * "목록에 없음"과 "목록을 못 읽음"을 같은 것으로 보면 산 세션을 닫힘으로 적는다. */
+function openPipes() {
+    try {
+        return new Set(fs.readdirSync('\\\\.\\pipe\\').map(n => n.toLowerCase()));
+    }
+    catch (e) {
+        return e instanceof Error ? e : new Error(String(e));
+    }
+}
+/**
+ * 저장된 상태가 아니라 호스트가 실제로 살아 있는지. 연결 요청은 보내지 않는다.
+ *
+ * `bridge serve` 가 강제 종료되면 종료 처리(state: closed)를 쓰지 못해 기록이
+ * 영원히 `idle` 로 남는다 (실측: 세션 d3cde187, 파이프 없음). 파이프는 호스트가
+ * listen 한 뒤에만 기록을 쓰므로, 파이프가 없다는 것은 호스트가 끝났다는 뜻이다.
+ *   Windows : 파이프 이름 목록에 없으면 dead, 목록을 못 읽으면 unverified
+ *   그 밖   : 소켓 파일이 없으면 dead. 있으면 기록된 호스트 pid 로 판단하고,
+ *             pid 가 없으면(이전 버전 기록) unverified — 남은 소켓 파일만으로는 모른다.
+ */
+function hostLiveness(s, pipes) {
+    if (process.platform === 'win32') {
+        const listed = pipes();
+        if (listed instanceof Error)
+            return 'unverified';
+        return listed.has(`axmap-${s.id}`.toLowerCase()) ? 'alive' : 'dead';
+    }
+    try {
+        fs.statSync(hostPipe(s.id));
+    }
+    catch (e) {
+        return errorCode(e) === 'ENOENT' ? 'dead' : 'unverified';
+    }
+    if (!Number.isSafeInteger(s.hostPid) || s.hostPid <= 0)
+        return 'unverified';
+    try {
+        process.kill(s.hostPid, 0);
+        return 'alive';
+    }
+    catch (e) {
+        return errorCode(e) === 'ESRCH' ? 'dead' : errorCode(e) === 'EPERM' ? 'alive' : 'unverified';
+    }
+}
+function markClosed(target, s) {
+    // 호스트가 끝난 뒤 기록을 바꾸는 쪽은 여기뿐이지만, 막 종료 처리 중인 호스트가 더
+    // 최신 기록(사용량 등)을 썼을 수 있어 다시 읽고 바꾼다.
+    let latest = s;
+    try {
+        latest = readJSON(target);
+    }
+    catch { /* 아래에서 읽은 기록으로 표시만 한다 */ }
+    if (latest.state === 'closed')
+        return latest;
+    const closed = { ...latest, state: 'closed', fullyIdle: false,
+        closedReason: '세션 호스트의 로컬 연결 파이프가 없습니다. 정상 종료 처리 없이 끝난 것으로 보입니다.' };
+    // 저장에 실패해도 이번 조회에는 닫힘으로 보고한다. 다음 조회가 다시 시도한다.
+    try {
+        writeJSON(target, closed);
+    }
+    catch { /* 위와 같다 */ }
+    return closed;
 }
 export function sessions(cwd) {
     const dir = path.join(bridgeHome(), 'sessions');
     if (!fs.existsSync(dir))
         return [];
     const repo = repoKey(cwd);
+    let pipes;
+    const listPipes = () => (pipes ??= openPipes());
     return fs.readdirSync(dir).filter(n => UUID.test(n.replace(/\.json$/, '')) && n.endsWith('.json'))
-        .map(n => readJSON(path.join(dir, n))).filter(s => s.repos.includes(repo)).map(publicSession);
+        .map(n => [path.join(dir, n), readJSON(path.join(dir, n))])
+        .filter(([, s]) => s.repos.includes(repo))
+        .map(([target, s]) => {
+        if (!['pty', 'stdio'].includes(s.transport || '') || s.state === 'closed')
+            return publicSession(s);
+        const liveness = hostLiveness(s, listPipes);
+        return liveness === 'dead' ? publicSession(markClosed(target, s), 'dead') : publicSession(s, liveness);
+    });
 }
 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;
 }
@@ -149,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;
@@ -206,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()))));
     }
@@ -216,60 +336,106 @@ 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 }) {
-    if (typeof prompt !== 'string' || !prompt.trim() || Buffer.byteLength(prompt) > 32768)
-        throw new Error('요청 본문은 1~32768바이트여야 합니다.');
-    const s = sessionFor(to, cwd);
-    const lease = sessionLeasePath(to);
-    if (fs.existsSync(lease) && readJSON(lease).dialogueId !== dialogueId)
-        throw new Error('이 세션은 자동 대화가 사용 중입니다. 해당 대화가 끝난 뒤 요청하세요.');
-    const dir = path.join(bridgeHome(), 'requests');
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    return withRepoLock(path.join(dir, `${to}.lock`), () => {
+export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null, queueIfBusy = false }) {
+    // 보내기 시작 전에 난 오류(이전 요청 미확정, 대기 미확인 등)는 확실히 전달되지 않은 것이다.
+    // 받은 편지함이 이를 "전달 불명"과 구별해야 쪽지를 다시 대기열로 돌릴 수 있다.
+    let sending = false;
+    try {
+        if (typeof prompt !== 'string' || !prompt.trim() || Buffer.byteLength(prompt) > 32768)
+            throw new Error('요청 본문은 1~32768바이트여야 합니다.');
+        const s = sessionFor(to, cwd);
+        const lease = sessionLeasePath(to);
         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))
-                continue;
-            const latest = previous.state === 'sending' ? previous : requestResult(previous.id, cwd);
-            if (['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;
-        if (s.transport === 'console') {
+            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);
-            consolePreflight = checkConsole(s);
-        }
-        if (!['pty', 'stdio', 'console'].includes(s.transport || '')) {
-            runAPI(s, ['get-conversation-metadata', to]);
-            if (!s.fullyIdle || s.event !== 'Stop')
-                throw new Error('상대 세션의 대기 상태를 아직 확인하지 못했습니다. 작업 종료 훅을 기다리세요.');
-        }
-        const request = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt,
-            createdAt: new Date().toISOString(), baseline: ['pty', 'stdio'].includes(s.transport || '') ? null : s.transcript ? transcript(s).length : 0, state: 'sending' };
-        const target = file('requests', request.id);
-        writeJSON(target, request);
-        try {
-            request.receipt = s.transport === 'console' ? submitConsole(s, request, consolePreflight) : ['pty', 'stdio'].includes(s.transport || '')
-                ? terminalRPC(to, { action: 'submit', request })
-                : runAPI(s, ['send-message', to, `[axMap request ${request.id}]\n요청자: ${from}\n${prompt}`]);
-            request.state = 'submitted';
-        }
-        catch (e) {
-            // A timeout may occur after delivery. Never retry automatically.
-            request.state = 'unknown';
-            request.error = errorMessage(e);
+            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;
         }
-        writeJSON(target, request);
-        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 || !['queued', 'sending', 'submitted', 'unknown'].includes(previous.state))
+                    continue;
+                const latest = previous.state === 'sending' ? previous : requestResult(previous.id, cwd);
+                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;
+            if (s.transport === 'console') {
+                validateConsolePrompt(prompt, from);
+                consolePreflight = checkConsole(s);
+            }
+            if (!['pty', 'stdio', 'console'].includes(s.transport || '')) {
+                runAPI(s, ['get-conversation-metadata', to]);
+                if (!s.fullyIdle || s.event !== 'Stop')
+                    throw new Error('상대 세션의 대기 상태를 아직 확인하지 못했습니다. 작업 종료 훅을 기다리세요.');
+            }
+            const request = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt,
+                createdAt: new Date().toISOString(), baseline: ['pty', 'stdio'].includes(s.transport || '') ? null : s.transcript ? transcript(s).length : 0, state: 'sending' };
+            const target = file('requests', request.id);
+            writeJSON(target, request);
+            sending = true;
+            try {
+                request.receipt = s.transport === 'console' ? submitConsole(s, request, consolePreflight) : ['pty', 'stdio'].includes(s.transport || '')
+                    ? 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 = request.receipt?.queued ? 'queued' : 'submitted';
+            }
+            catch (e) {
+                if (notDelivered(e)) {
+                    // 로컬 파이프에 연결조차 못 했다(ENOENT·ECONNREFUSED). 한 바이트도 보내지
+                    // 않았으므로 확실히 전달되지 않았다. unknown 으로 두면 이 세션의 다음 요청이
+                    // 전부 막힌다. 자동 재전송은 여전히 하지 않는다.
+                    request.state = 'failed';
+                    request.error = `전달되지 않았습니다: ${errorMessage(e)}`;
+                }
+                else {
+                    // A timeout may occur after delivery. Never retry automatically.
+                    request.state = 'unknown';
+                    request.error = errorMessage(e);
+                }
+            }
+            writeJSON(target, request);
+            return request;
+        });
+    }
+    catch (e) {
+        if (!sending && e instanceof Error)
+            Object.assign(e, { notDelivered: true });
+        throw e;
+    }
 }
+/** 연결 전에 실패해 아무것도 보내지 않은 오류만 true. 문구가 아니라 종료 코드나 보내기 전 단계로 가른다. */
+export const notDelivered = (e) => e instanceof Error && e.notDelivered === true;
 function terminalRPC(id, message) {
     const r = spawnSync(process.execPath, [path.join(ROOT, 'tools', 'run.mjs'), 'rpc', id], {
         input: JSON.stringify(message), encoding: 'utf8', windowsHide: true, timeout: 15000,
     });
+    // 시간 초과(r.error)나 그 밖의 실패는 연결 뒤에 났을 수 있어 전달 여부를 모른다.
+    if (!r.error && r.status === RPC_NOT_DELIVERED_EXIT) {
+        throw Object.assign(new Error(r.stderr?.trim() || '로컬 세션 파이프에 연결하지 못했습니다.'), { notDelivered: true });
+    }
     if (r.error || r.status !== 0)
         throw new Error(r.error?.message || r.stderr?.trim() || '터미널 세션에 연결하지 못했습니다.');
     return JSON.parse(r.stdout);
@@ -333,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;
+    }
+}