axmap-cli 1.7.0 → 1.9.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 에 작업 폴더 절대 경로를 지정하세요.')
   }

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

package/skills/axmap-view/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: axmap-view
+description: Show the current Git repository's axMap sessions, active claims, pending mailbox and recent events in a terminal view.
+---
+
+Use the current Git repository or the user's explicitly designated repository. Run `axmap view --cwd <absolute-repository>` in an interactive terminal; `q`, Esc or Ctrl+C closes the view. If the host cannot provide an interactive terminal, run `axmap view --cwd <absolute-repository> --once` and identify it as a snapshot. Slash-menu availability depends on the host and installed skill; do not imply that a bare slash command works in every terminal.
+
+The display reads local evidence only. It does not start an AI session, submit work, send or collect mail, or imply that an unobserved session is idle. Never invent progress percentages or token counts.

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/monitor-cli.mjs

@@ -3,12 +3,13 @@ import path from 'node:path';
 import { createMonitor, renderMonitor } from './monitor.mjs';
 import { errorMessage } from './session-types.mjs';
 import { renderPipelineGraph } from './pipeline-graph.mjs';
+import { createView, renderView } from './view.mjs';
 export async function runMonitor(args) {
     if (args.includes('--help') || args.includes('-h')) {
         console.log('axmap monitor [--cwd <repo>] [--interval 1000] [--once | --json] [--no-color]\n세션·요청 파이프라인·자동 대화·선점·최근 이벤트를 실시간으로 표시합니다.\nTTY에서는 계속 갱신하며, 파이프/리디렉션에서는 한 번만 출력합니다. q / Esc / Ctrl+C 종료.');
         return;
     }
-    const allowed = new Set(['--cwd', '--interval', '--once', '--json', '--no-color', '--graph']);
+    const allowed = new Set(['--cwd', '--interval', '--once', '--json', '--no-color', '--graph', '--view']);
     for (let i = 0; i < args.length; i++) {
         if (!allowed.has(args[i]))
             throw new Error(`알 수 없는 옵션: ${args[i]}`);
@@ -22,8 +23,9 @@ export async function runMonitor(args) {
     const interval = Number(option('--interval') || 1000);
     if (!Number.isInteger(interval) || interval < 250 || interval > 60000)
         throw new Error('interval은 250~60000ms 정수여야 합니다.');
-    const collect = createMonitor(path.resolve(option('--cwd') || process.cwd()));
-    const render = args.includes('--graph') ? renderPipelineGraph : renderMonitor;
+    const cwd = path.resolve(option('--cwd') || process.cwd());
+    const collect = args.includes('--view') ? createView(cwd) : createMonitor(cwd);
+    const render = args.includes('--view') ? renderView : args.includes('--graph') ? renderPipelineGraph : renderMonitor;
     const live = !!process.stdout.isTTY && !!process.stdin.isTTY && process.env.TERM !== 'dumb' && !args.includes('--once') && !args.includes('--json');
     const color = !!process.stdout.isTTY && !args.includes('--no-color') && process.env.NO_COLOR === undefined && process.env.TERM !== 'dumb';
     if (!live) {