axmap-cli 1.8.0 → 1.10.0

package/src/bridge.mts

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

package/src/external-console.mjs

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

package/src/external-console.mts

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