axmap-cli 1.8.0 → 1.9.0

package/src/bridge.mjs

@@ -9,7 +9,8 @@ import { 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.
@@ -98,20 +108,96 @@ 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));
@@ -217,59 +303,85 @@ export function sessionLeasePath(id) {
     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`), () => {
+    // 보내기 시작 전에 난 오류(이전 요청 미확정, 대기 미확인 등)는 확실히 전달되지 않은 것이다.
+    // 받은 편지함이 이를 "전달 불명"과 구별해야 쪽지를 다시 대기열로 돌릴 수 있다.
+    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') {
-            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);
-        }
-        writeJSON(target, request);
-        return request;
-    });
+            throw new Error('이 세션은 자동 대화가 사용 중입니다. 해당 대화가 끝난 뒤 요청하세요.');
+        const dir = path.join(bridgeHome(), 'requests');
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        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))
+                    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') {
+                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 })
+                    : runAPI(s, ['send-message', to, `[axMap request ${request.id}]\n요청자: ${from}\n${prompt}`]);
+                request.state = '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);

package/src/bridge.mts

@@ -8,7 +8,9 @@ import { 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'
+import type { HostLiveness } from './session-types.mjs'
 import type { SessionRecord, PublicSession, RequestRecord, DispatchOptions, HookInput, TranscriptEntry } from './session-types.mjs'
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
@@ -37,13 +39,21 @@ function writeJSON(p: string, data: unknown): void {
     }
   } finally { if (fs.existsSync(tmp)) fs.unlinkSync(tmp) }
 }
-function repoKey(cwd: string): string {
+function commonDirKey(cwd: string): string | null {
   const r = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
     cwd, encoding: 'utf8', windowsHide: true,
   })
-  if (r.status !== 0) throw new Error(`Git 작업 저장소를 확인하지 못했습니다: ${cwd}`)
-  const key = fs.realpathSync(r.stdout.trim())
-  return process.platform === 'win32' ? key.toLowerCase() : key
+  return r.status === 0 ? commonKey(fs.realpathSync(r.stdout.trim())) : null
+}
+function repoKey(cwd: string): string {
+  // 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}`)
+  return key
 }
 function addressError(address: unknown): asserts address is string {
   // Only a loopback address exported by a local provider hook is accepted.
@@ -79,19 +89,77 @@ function transcript(session: SessionRecord): TranscriptEntry[] {
   lines.pop()
   return lines.filter(s => s.trim()).map(s => JSON.parse(s) as TranscriptEntry)
 }
-function publicSession(s: SessionRecord): PublicSession {
+function publicSession(s: SessionRecord, liveness?: HostLiveness): PublicSession {
   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: string) => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`)
+
+/** Windows 의 열린 파이프 이름 목록. 읽지 못하면 오류 자체를 돌려준다 —
+ * "목록에 없음"과 "목록을 못 읽음"을 같은 것으로 보면 산 세션을 닫힘으로 적는다. */
+function openPipes(): Set<string> | Error {
+  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: SessionRecord, pipes: () => Set<string> | Error): HostLiveness {
+  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 as number) <= 0) return 'unverified'
+  try { process.kill(s.hostPid as number, 0); return 'alive' } catch (e) {
+    return errorCode(e) === 'ESRCH' ? 'dead' : errorCode(e) === 'EPERM' ? 'alive' : 'unverified'
+  }
+}
+
+function markClosed(target: string, s: SessionRecord): SessionRecord {
+  // 호스트가 끝난 뒤 기록을 바꾸는 쪽은 여기뿐이지만, 막 종료 처리 중인 호스트가 더
+  // 최신 기록(사용량 등)을 썼을 수 있어 다시 읽고 바꾼다.
+  let latest = s
+  try { latest = readJSON<SessionRecord>(target) } catch { /* 아래에서 읽은 기록으로 표시만 한다 */ }
+  if (latest.state === 'closed') return latest
+  const closed: SessionRecord = { ...latest, state: 'closed', fullyIdle: false,
+    closedReason: '세션 호스트의 로컬 연결 파이프가 없습니다. 정상 종료 처리 없이 끝난 것으로 보입니다.' }
+  // 저장에 실패해도 이번 조회에는 닫힘으로 보고한다. 다음 조회가 다시 시도한다.
+  try { writeJSON(target, closed) } catch { /* 위와 같다 */ }
+  return closed
+}
+
 export function sessions(cwd: string): PublicSession[] {
   const dir = path.join(bridgeHome(), 'sessions')
   if (!fs.existsSync(dir)) return []
   const repo = repoKey(cwd)
+  let pipes: Set<string> | Error | undefined
+  const listPipes = () => (pipes ??= openPipes())
   return fs.readdirSync(dir).filter(n => UUID.test(n.replace(/\.json$/, '')) && n.endsWith('.json'))
-    .map(n => readJSON<SessionRecord>(path.join(dir, n))).filter(s => s.repos.includes(repo)).map(publicSession)
+    .map(n => [path.join(dir, n), readJSON<SessionRecord>(path.join(dir, n))] as const)
+    .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: string, cwd: string): SessionRecord {
   const s = readJSON<SessionRecord>(file('sessions', id))
@@ -180,6 +248,10 @@ export function sessionLeasePath(id: string): string {
 }
 
 export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null }: DispatchOptions): RequestRecord {
+  // 보내기 시작 전에 난 오류(이전 요청 미확정, 대기 미확인 등)는 확실히 전달되지 않은 것이다.
+  // 받은 편지함이 이를 "전달 불명"과 구별해야 쪽지를 다시 대기열로 돌릴 수 있다.
+  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)
@@ -205,25 +277,45 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
       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 })
         : 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 (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: unknown) => e instanceof Error && (e as Error & { notDelivered?: boolean }).notDelivered === true
+
 function terminalRPC(id: string, message: unknown): unknown {
   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)
 }

package/src/managed-session.mjs

@@ -6,11 +6,12 @@ import path from 'node:path';
 import net from 'node:net';
 import { spawn } from 'node:child_process';
 import { randomUUID, randomBytes, timingSafeEqual } from 'node:crypto';
-import { bridgeHome, repoKey, writeJSON } from './bridge.mjs';
+import { bridgeHome, hostPipe, repoKey, writeJSON } from './bridge.mjs';
 import { normalizeUsage, usageDelta } from './session-usage.mjs';
 import { errorMessage } from './session-types.mjs';
 import { connectCodexProxy } from './codex-connection.mjs';
-const pipeFor = (id) => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`);
+// 생존 확인(bridge.sessions)이 같은 이름을 보도록 한 곳에서 만든다.
+const pipeFor = hostPipe;
 const uuid = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value || '');
 export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '', existingThreadId, socketPath, observeActive = false, cwd = process.cwd(), maxTokens = 100000, timeoutMs = 120000, onEvent = () => { } }) {
     if (!['codex', 'agy'].includes(provider))
@@ -24,7 +25,7 @@ export async function startManagedSession({ provider, executable = provider, pre
     const id = randomUUID(), token = randomBytes(32).toString('hex');
     const sessionPath = path.join(bridgeHome(), 'sessions', `${id}.json`);
     const s = { id, token, provider, transport: 'stdio', role, model: model || null,
-        workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false,
+        workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false, hostPid: process.pid,
         registeredAt: new Date().toISOString(), usage: null, usageKnown: true, maxTokens };
     const jobs = new Map();
     let attachedUsageOrigin = null;

package/src/managed-session.mts

@@ -5,7 +5,7 @@ import path from 'node:path'
 import net from 'node:net'
 import { spawn } from 'node:child_process'
 import { randomUUID, randomBytes, timingSafeEqual } from 'node:crypto'
-import { bridgeHome, repoKey, writeJSON } from './bridge.mjs'
+import { bridgeHome, hostPipe, repoKey, writeJSON } from './bridge.mjs'
 import { normalizeUsage, usageDelta } from './session-usage.mjs'
 import { errorMessage } from './session-types.mjs'
 import { connectCodexProxy } from './codex-connection.mjs'
@@ -31,7 +31,8 @@ interface ProviderMessage {
 }
 interface AgyResult { conversation_id: string; status: string; response?: unknown; error?: string; usage?: unknown }
 
-const pipeFor = (id: string) => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`)
+// 생존 확인(bridge.sessions)이 같은 이름을 보도록 한 곳에서 만든다.
+const pipeFor = hostPipe
 const uuid = (value: string | undefined) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value || '')
 
 export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '', existingThreadId, socketPath, observeActive = false,
@@ -43,7 +44,7 @@ export async function startManagedSession({ provider, executable = provider, pre
   const id = randomUUID(), token = randomBytes(32).toString('hex')
   const sessionPath = path.join(bridgeHome(), 'sessions', `${id}.json`)
   const s: SessionRecord = { id, token, provider, transport: 'stdio', role, model: model || null,
-    workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false,
+    workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false, hostPid: process.pid,
     registeredAt: new Date().toISOString(), usage: null, usageKnown: true, maxTokens }
   const jobs = new Map<string, JobRecord>()
   let attachedUsageOrigin: Usage | null = null

package/src/session-mailbox.mjs

@@ -4,7 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { bridgeHome, repoKey, sessions, readJSON, writeJSON, dispatchRequest } from './bridge.mjs';
+import { bridgeHome, repoKey, sessions, readJSON, writeJSON, dispatchRequest, notDelivered } from './bridge.mjs';
 import { withRepoLock } from './repolock.mjs';
 import { errorMessage } from './session-types.mjs';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -31,7 +31,7 @@ function load(target) {
         !['boundary', 'immediate'].includes(m.priority) || !states.includes(m.state) ||
         !Number.isFinite(Date.parse(m.createdAt)) || !Number.isFinite(Date.parse(m.expiresAt))) ||
         b.batches.some(x => !x || !UUID.test(x.id || '') || typeof x.repo !== 'string' || !Array.isArray(x.ids) ||
-            !['sending', 'submitted', 'unknown'].includes(x.state)))
+            !['sending', 'submitted', 'unknown', 'failed'].includes(x.state)))
         throw new Error('받은 편지함 기록이 손상됐습니다. 빈 큐로 바꾸지 않습니다.');
     return b;
 }
@@ -169,22 +169,32 @@ export function flushMail({ to, cwd, at, immediateId }) {
         writeJSON(target, b);
         try {
             const r = dispatchRequest({ to, cwd, from: 'axmap-agent-mailbox', prompt });
-            batch.state = r.state === 'submitted' ? 'submitted' : 'unknown';
+            batch.state = r.state === 'submitted' ? 'submitted' : r.state === 'failed' ? 'failed' : 'unknown';
             batch.requestId = r.id;
             batch.error = r.error;
         }
         catch (e) {
             // A storage error can happen after the provider accepted a request. Even
-            // thrown errors must not put this batch back into an executable queue.
-            batch.state = 'unknown';
+            // thrown errors must not put this batch back into an executable queue —
+            // unless the error came before anything was sent.
+            batch.state = notDelivered(e) ? 'failed' : 'unknown';
             batch.error = errorMessage(e);
         }
-        for (const m of selected) {
-            m.state = batch.state;
-            m.requestId = batch.requestId;
-            m.error = batch.error;
-        }
+        // 확실히 전달되지 않은 묶음의 쪽지는 대기열로 돌려 다음 경계에서 다시 보낼 수 있게 한다.
+        // 자동으로 다시 보내지는 않는다. 묶음 기록은 이력으로 남는다.
+        if (batch.state === 'failed')
+            for (const m of selected) {
+                m.state = 'queued';
+                m.error = batch.error;
+            }
+        else
+            for (const m of selected) {
+                m.state = batch.state;
+                m.requestId = batch.requestId;
+                m.error = batch.error;
+            }
         writeJSON(target, b);
-        return { ...batch, modelInvocationRequested: batch.state === 'submitted', modelInvoked: null };
+        return { ...batch, modelInvocationRequested: batch.state === 'submitted', modelInvoked: null,
+            ...(batch.state === 'failed' ? { requeued: selected.length } : {}) };
     });
 }

package/src/session-mailbox.mts

@@ -3,7 +3,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { randomUUID } from 'node:crypto'
-import { bridgeHome, repoKey, sessions, readJSON, writeJSON, dispatchRequest } from './bridge.mjs'
+import { bridgeHome, repoKey, sessions, readJSON, writeJSON, dispatchRequest, notDelivered } from './bridge.mjs'
 import { withRepoLock } from './repolock.mjs'
 import { errorMessage } from './session-types.mjs'
 
@@ -15,7 +15,7 @@ export interface Mail {
   createdAt: string; expiresAt: string; state: State
   supersededBy?: string; batchId?: string; requestId?: string; error?: string
 }
-interface Batch { id: string; repo: string; ids: string[]; state: 'sending' | 'submitted' | 'unknown'; requestId?: string; error?: string }
+interface Batch { id: string; repo: string; ids: string[]; state: 'sending' | 'submitted' | 'unknown' | 'failed'; requestId?: string; error?: string }
 interface Box { version: 1; messages: Mail[]; batches: Batch[] }
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
 const reasons = ['stop', 'data-loss', 'work-invalidated']
@@ -38,7 +38,7 @@ function load(target: string): Box {
     !['boundary', 'immediate'].includes(m.priority) || !states.includes(m.state) ||
     !Number.isFinite(Date.parse(m.createdAt)) || !Number.isFinite(Date.parse(m.expiresAt))) ||
     b.batches.some(x => !x || !UUID.test(x.id || '') || typeof x.repo !== 'string' || !Array.isArray(x.ids) ||
-      !['sending', 'submitted', 'unknown'].includes(x.state))) throw new Error('받은 편지함 기록이 손상됐습니다. 빈 큐로 바꾸지 않습니다.')
+      !['sending', 'submitted', 'unknown', 'failed'].includes(x.state))) throw new Error('받은 편지함 기록이 손상됐습니다. 빈 큐로 바꾸지 않습니다.')
   return b
 }
 function expire(b: Box) {
@@ -144,14 +144,19 @@ export function flushMail({ to, cwd, at, immediateId }:
     writeJSON(target, b)
     try {
       const r = dispatchRequest({ to, cwd, from: 'axmap-agent-mailbox', prompt })
-      batch.state = r.state === 'submitted' ? 'submitted' : 'unknown'; batch.requestId = r.id; batch.error = r.error
+      batch.state = r.state === 'submitted' ? 'submitted' : r.state === 'failed' ? 'failed' : 'unknown'; batch.requestId = r.id; batch.error = r.error
     } catch (e) {
       // A storage error can happen after the provider accepted a request. Even
-      // thrown errors must not put this batch back into an executable queue.
-      batch.state = 'unknown'; batch.error = errorMessage(e)
+      // thrown errors must not put this batch back into an executable queue —
+      // unless the error came before anything was sent.
+      batch.state = notDelivered(e) ? 'failed' : 'unknown'; batch.error = errorMessage(e)
     }
-    for (const m of selected) { m.state = batch.state; m.requestId = batch.requestId; m.error = batch.error }
+    // 확실히 전달되지 않은 묶음의 쪽지는 대기열로 돌려 다음 경계에서 다시 보낼 수 있게 한다.
+    // 자동으로 다시 보내지는 않는다. 묶음 기록은 이력으로 남는다.
+    if (batch.state === 'failed') for (const m of selected) { m.state = 'queued'; m.error = batch.error }
+    else for (const m of selected) { m.state = batch.state as State; m.requestId = batch.requestId; m.error = batch.error }
     writeJSON(target, b)
-    return { ...batch, modelInvocationRequested: batch.state === 'submitted', modelInvoked: null }
+    return { ...batch, modelInvocationRequested: batch.state === 'submitted', modelInvoked: null,
+      ...(batch.state === 'failed' ? { requeued: selected.length } : {}) }
   })
 }

package/src/session-types.mjs

@@ -1,4 +1,7 @@
 // Generated from src/session-types.mts. Edit the .mts source and run npm run build.
+/** `run.mjs rpc` 가 로컬 파이프에 연결조차 못 했을 때(ENOENT·ECONNREFUSED)의 종료 코드.
+ * 이 경우에만 요청이 확실히 전달되지 않았다고 판단한다. */
+export const RPC_NOT_DELIVERED_EXIT = 3;
 export function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }