axmap-cli 1.4.0 → 1.5.0

package/README.ko.md

@@ -25,6 +25,22 @@ axmap setup
 
 최신 변경부터 정리합니다.
 
+### 1.5.0
+
+<sub>2026.10.21</sub>
+
+**Windows에서 따로 실행한 Antigravity 대화창을 재시작 없이 연결합니다.**
+
+- 일반 `agy`로 직접 연 대화창도 설치된 훅으로 자동 등록합니다. 이미 열린 창은 대상 저장소에서 `axmap bridge attach --pid <PID>`로 연결합니다.
+- `ax_dispatch`와 `ax_result`가 기존 프로세스와 대화를 유지합니다. 빈 입력창의 대기 상태를 확인해 전달하고, 요청 UUID가 있는 대화 기록과 현재 콘솔 상태로 결과를 판정합니다.
+- `axmap bridge status [--json]`으로 모델 작업을 보내지 않고 로컬 연결 상태를 확인합니다.
+- 독립 콘솔 연결은 현재 Windows agy만 지원합니다. 토큰 예산을 검사하는 `ax_chat`은 관리형 stdio 세션을 사용합니다.
+
+실제 기존 agy 창의 메시지 왕복과 회귀 테스트 574개 통과를 확인했습니다. 독립 콘솔의 자동 등록, 한글 전달, 입력 보호와 프로세스 식별 검사도 포함합니다.
+[연결 안내 →](docs/SESSION-BRIDGE.md)
+
+---
+
 ### 1.4.0
 
 <sub>2026.10.20</sub>

package/README.md

@@ -25,6 +25,22 @@ Each Git repository's ledger is prepared on first use. Collaborators must share
 
 Newest changes first.
 
+### 1.5.0
+
+<sub>October 21, 2026</sub>
+
+**Connect an existing Windows Antigravity conversation without restarting it.**
+
+- Interactive `agy` sessions launched directly register through the installed hooks. Use `axmap bridge attach --pid <PID>` from the target repository for an already open console.
+- `ax_dispatch` and `ax_result` preserve the existing process and conversation. Delivery requires an empty, idle input box; results match the request UUID in the transcript and the live console state.
+- `axmap bridge status [--json]` checks local connections without submitting model work.
+- Independent console connections currently support Windows agy only. Token-budgeted `ax_chat` still requires managed stdio sessions.
+
+Validated against an existing real agy console and 574 passing regression tests, including independent-console registration, Unicode delivery, input protection and process identity checks.
+[Connection guide →](docs/SESSION-BRIDGE.md)
+
+---
+
 ### 1.4.0
 
 <sub>October 20, 2026</sub>

package/mcp/server.mjs

@@ -392,7 +392,7 @@ const TOOLS = [
   },
   {
     name: 'ax_dispatch',
-    description: '사용자가 허용한 작업을 연결된 상대 세션에 전달한다. 기존 맥락을 유지하며 새 모델 프로세스를 만들지 않는다. submitted는 완료가 아니다. unknown이면 자동 재시도하지 말고 ax_result로 확인한다. Codex/agy 관리형 stdio, 실험용 PTY/agentapi 연결을 지원한다.',
+    description: '사용자가 허용한 작업을 연결된 상대 세션에 전달한다. 기존 맥락을 유지하며 새 모델 프로세스를 만들지 않는다. submitted는 완료가 아니다. unknown이면 자동 재시도하지 말고 ax_result로 확인한다. Codex/agy 관리형 stdio, 별도로 실행한 Windows agy console, 실험용 PTY/agentapi 연결을 지원한다.',
     inputSchema: { type: 'object', properties: {
       to: { type: 'string', description: 'ax_sessions에서 확인한 상대 세션 UUID' },
       prompt: { type: 'string', description: '상대가 실행할 작업 요청' },
@@ -400,7 +400,7 @@ const TOOLS = [
   },
   {
     name: 'ax_result',
-    description: '작업 요청의 제출/완료/불명 상태, 결과와 측정 사용량을 확인한다. 관리형 세션은 CLI의 구조화된 실행 완료 이벤트, 실험용 터미널은 해당 요청의 종료 훅으로 판정한다.',
+    description: '작업 요청의 제출/완료/불명 상태, 결과와 측정 사용량을 확인한다. 관리형 세션은 구조화된 완료 이벤트, PTY는 종료 훅, 독립 Windows console은 요청 UUID가 있는 대화 기록과 현재 빈 입력창의 대기 상태로 판정한다.',
     inputSchema: { type: 'object', properties: {
       id: { type: 'string', description: 'ax_dispatch가 반환한 요청 UUID' },
     }, required: ['id'] },

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

package/src/bridge.mjs

@@ -7,6 +7,7 @@ import { randomUUID } from 'node:crypto'
 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'
 
 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)), '..')
@@ -59,7 +60,7 @@ function runAPI(session, args) {
   return null
 }
 function transcript(session) {
-  const expected = path.join(agyHome(), 'brain', session.id, '.system_generated', 'logs', 'transcript.jsonl')
+  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')
   // A trailing incomplete record may be in flight; malformed complete records fail.
@@ -68,7 +69,7 @@ function transcript(session) {
 }
 function publicSession(s) {
   return { id: s.id, provider: s.provider, workspaces: s.workspaces, model: s.model,
-    transport: s.transport || 'agentapi', state: s.state,
+    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 }
 }
@@ -112,13 +113,23 @@ export function requestResult(id, cwd) {
   const request = readJSON(target)
   if (request.repo !== repoKey(cwd)) throw new Error('이 요청은 현재 작업 저장소의 요청이 아닙니다.')
   if (!['submitted', 'unknown'].includes(request.state)) return request
-  const s = sessionFor(request.to, cwd)
+  let s = sessionFor(request.to, cwd)
   if (['pty', 'stdio'].includes(s.transport)) {
     try { Object.assign(request, terminalRPC(s.id, { action: 'result', id })) }
     catch (e) { request.state = 'unknown'; request.error = e.message }
     writeJSON(target, request)
     return request
   }
+  if (s.transport === 'console') {
+    try { s.fullyIdle = externalStatus(s).state === 'idle' }
+    catch (e) {
+      request.state = 'unknown'; request.error = e.message
+      writeJSON(target, request)
+      return request
+    }
+    s = findConsoleTranscript(s, request)
+    if (!s.transcript) return request
+  }
   const entries = transcript(s)
   const marker = `[axMap request ${id}]`
   const start = entries.findIndex((e, i) => i >= request.baseline && e.type === 'USER_INPUT' && String(e.content).includes(marker))
@@ -127,12 +138,12 @@ export function requestResult(id, cwd) {
   if (tail.some(e => e.type === 'USER_INPUT')) {
     request.state = 'superseded'
     request.error = '다른 사용자 입력이 이어져 이 요청의 완료를 확정할 수 없습니다.'
-  } else if (s.event === 'Stop' && s.fullyIdle && s.registeredAt > request.createdAt) {
+  } else if (s.transport === 'console' ? s.fullyIdle : s.event === 'Stop' && s.fullyIdle && s.registeredAt > request.createdAt) {
     const answer = tail.filter(e => e.source === 'MODEL' && e.type === 'PLANNER_RESPONSE' && e.status === 'DONE').at(-1)
     if (answer) {
       request.state = 'completed'
       request.result = answer.content
-      request.completedAt = s.registeredAt
+      request.completedAt = s.transport === 'console' ? new Date().toISOString() : s.registeredAt
     }
   }
   if (['completed', 'superseded'].includes(request.state)) writeJSON(target, request)
@@ -160,16 +171,17 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
       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.
-    if (!['pty', 'stdio'].includes(s.transport)) {
+    if (s.transport === 'console') { validateConsolePrompt(prompt, from); 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 : transcript(s).length, state: 'sending' }
+      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 = ['pty', 'stdio'].includes(s.transport)
+      request.receipt = s.transport === 'console' ? submitConsole(s, request) : ['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'

package/src/external-console.mjs

@@ -0,0 +1,116 @@
+/** Attach to an existing Windows console; never launch or resume a model. */
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { createHash } from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { bridgeHome, repoKey, readJSON, writeJSON } from './bridge.mjs'
+
+const helper = fileURLToPath(new URL('../tools/windows-console.ps1', import.meta.url))
+export function consoleCall(pid, action = 'snapshot', payload = {}) {
+  if (process.platform !== 'win32') throw new Error('독립 agy 콘솔 연결은 현재 Windows에서 지원합니다.')
+  if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error('양의 정수 PID가 필요합니다.')
+  const r = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass',
+    '-File', helper, '-TargetPid', String(pid), '-Action', action], {
+    input: JSON.stringify(payload), encoding: 'utf8', windowsHide: true, timeout: 8000, maxBuffer: 1024 * 1024,
+  })
+  let data
+  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() || '기존 콘솔 연결 실패')
+  return data
+}
+function identityID({ pid, startedAt }) {
+  const hex = createHash('sha256').update(`agy-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) {
+  // 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
+  const top = borders.at(-2), bottom = borders.at(-1)
+  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)
+}
+export function attachConsole({ pid, cwd }) {
+  const live = consoleCall(pid)
+  const id = identityID(live)
+  const previous = fs.existsSync(target(id)) ? readJSON(target(id)) : {}
+  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,
+    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)) throw new Error('지원하지 않는 훅 이벤트입니다.')
+  const identity = consoleCall(process.pid, 'ancestor')
+  if (identity.ignored) return {}
+  const id = identityID(identity)
+  const previous = fs.existsSync(target(id)) ? readJSON(target(id)) : {}
+  const workspaces = input.workspacePaths || previous.workspaces
+  if (!Array.isArray(workspaces) || !workspaces.length || workspaces.some(p => !path.isAbsolute(p))) throw new Error('훅의 작업 저장소 경로가 없습니다.')
+  const conversationId = input.conversationId
+  if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(conversationId || '')) throw new Error('훅의 대화 UUID가 없습니다.')
+  const transcript = path.join(process.env.AXMAP_AGY_HOME || path.join(os.homedir(), '.gemini', 'antigravity-cli'),
+    'brain', conversationId, '.system_generated', 'logs', 'transcript.jsonl')
+  if (path.resolve(input.transcriptPath || '') !== transcript) throw new Error('훅의 대화 기록 경로가 다릅니다.')
+  const idle = event === 'Stop' && input.fullyIdle === true
+  writeJSON(target(id), { ...previous, ...identity, id, provider: 'agy', transport: 'console', conversationId,
+    transcript, workspaces, repos: [...new Set(workspaces.map(repoKey))], model: input.modelName || previous.model,
+    event, state: idle ? 'idle' : 'running', fullyIdle: idle, registeredAt: new Date().toISOString() })
+  return { id }
+}
+export function externalStatus(s) {
+  s = readJSON(target(s.id))
+  const live = consoleCall(s.pid, 'snapshot', { startedAt: s.startedAt })
+  const state = consoleIdle(live.screen) ? 'idle' : 'unknown'
+  writeJSON(target(s.id), { ...readJSON(target(s.id)), state, fullyIdle: state === 'idle' })
+  return { id: s.id, state }
+}
+export function checkConsole(s) {
+  const live = consoleCall(s.pid, 'snapshot', { startedAt: s.startedAt })
+  if (!consoleIdle(live.screen)) throw new Error('상대 콘솔이 빈 입력창에서 대기 중이지 않습니다. 입력을 보내지 않았습니다.')
+  return live
+}
+export function validateConsolePrompt(prompt, from) {
+  if (/[\x00-\x08\x0b-\x1f\x7f]/.test(prompt.replace(/\r\n/g, '\n')) || /[\x00-\x1f\x7f]/.test(from)) throw new Error('콘솔 요청에는 제어 문자를 포함할 수 없습니다.')
+}
+export function findConsoleTranscript(s, request) {
+  if (s.transcript) 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}]`
+  const matches = []
+  for (const entry of fs.readdirSync(brain, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !/^[0-9a-f-]{36}$/i.test(entry.name)) continue
+    const log = path.join(brain, entry.name, '.system_generated', 'logs', 'transcript.jsonl')
+    let stat
+    try { stat = fs.statSync(log) } catch { continue }
+    if (stat.mtimeMs < Date.parse(request.createdAt) || stat.size > 32 * 1024 * 1024) continue
+    const records = fs.readFileSync(log, 'utf8').split('\n').slice(0, -1)
+    if (records.some(line => {
+      try { const e = JSON.parse(line); return e.type === 'USER_INPUT' && String(e.content).includes(marker) }
+      catch { return false }
+    })) matches.push({ conversationId: entry.name, transcript: log })
+  }
+  if (matches.length !== 1) return s
+  const updated = { ...readJSON(target(s.id)), ...matches[0] }
+  writeJSON(target(s.id), updated)
+  return updated
+}
+export function submitConsole(s, request) {
+  validateConsolePrompt(request.prompt, request.from)
+  const live = checkConsole(s)
+  // 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(s.pid, 'send', { startedAt: s.startedAt, expectedScreen: live.screen, text })
+  writeJSON(target(s.id), { ...readJSON(target(s.id)), state: 'running', fullyIdle: false })
+  return { accepted: true, pid: s.pid }
+}

package/src/session-status.mjs

@@ -0,0 +1,48 @@
+import { sessions } from './bridge.mjs'
+import { sendTerminal } from './terminal-bridge.mjs'
+import { externalStatus } from './external-console.mjs'
+
+/** Probe only the authenticated local control pipe. A saved idle/running record
+ * cannot establish that its host still exists; no model request is submitted. */
+export async function sessionStatus(cwd = process.cwd()) {
+  const listed = sessions(cwd)
+  return Promise.all(listed.map(async session => {
+    const base = { ...session, lastKnownState: session.state ?? null }
+    const snapshot = (state, connection, extra = {}) => ({ ...base, ...extra, state, connection,
+      fullyIdle: connection === 'connected' && state === 'idle', checkedAt: new Date().toISOString() })
+    if (session.state === 'closed') return snapshot('closed', 'closed')
+    if (session.transport === 'console') {
+      try {
+        const live = externalStatus(session)
+        return snapshot(live.state, 'connected')
+      } catch { return snapshot('unknown', 'unreachable') }
+    }
+    if (!['pty', 'stdio'].includes(session.transport)) return snapshot('unknown', 'unverified')
+    try {
+      const live = await sendTerminal(session.id, { action: 'status' }, null, { timeoutMs: 1000 })
+      if (live?.id !== session.id || !['starting', 'running', 'idle', 'awaiting_user', 'settling', 'closed'].includes(live.state)) {
+        return snapshot('unknown', 'unreachable')
+      }
+      return snapshot(live.state, 'connected', {
+        usage: live.usage === undefined ? session.usage : live.usage,
+        pendingApproval: live.pendingApproval,
+      })
+    } catch {
+      // A disconnected host or a timeout is not proof of a completed task.
+      return snapshot('unknown', 'unreachable')
+    }
+  }))
+}
+
+const labels = { starting: '시작 중', running: '작업 중', idle: '대기', awaiting_user: '승인 대기',
+  settling: '대기 전환 중', closed: '종료', unknown: '상태 미확인' }
+const connections = { connected: '연결됨', closed: '종료됨', unreachable: '연결 확인 불가', unverified: '확인 미지원' }
+const safe = value => String(value ?? '').replace(/[\x00-\x1f\x7f-\x9f]/g, ' ')
+
+export function formatSessionStatus(listed) {
+  if (!listed.length) return '이 저장소에 등록된 로컬 세션이 없습니다.'
+  return ['axMap 세션 상태', ...listed.map(s => {
+    const usage = s.usage?.totalTokens == null ? '미확인' : `${s.usage.totalTokens}${s.maxTokens ? ` / ${s.maxTokens}` : ''}`
+    return `${safe(s.provider)}  ${safe(s.id)}\n  ${connections[s.connection] || '상태 미확인'} · ${labels[s.state] || '상태 미확인'}${s.role ? ` · ${safe(s.role)}` : ''}\n  확인된 누적 처리 토큰: ${usage}`
+  })].join('\n')
+}

package/src/terminal-bridge.mjs

@@ -18,7 +18,8 @@ const sessionFile = id => {
 const pipeFor = id => process.platform === 'win32'
   ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`)
 
-export function sendTerminal(id, message, token = null) {
+export function sendTerminal(id, message, token = null, { timeoutMs = 10000 } = {}) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new Error('양의 응답 시간 한도가 필요합니다.')
   const s = readJSON(sessionFile(id))
   if (!['pty', 'stdio'].includes(s.transport)) throw new Error('로컬 관리형 세션이 아닙니다.')
   return new Promise((resolve, reject) => {
@@ -26,7 +27,7 @@ export function sendTerminal(id, message, token = null) {
     socket.setEncoding('utf8')
     let buffer = ''
     const fail = e => { socket.destroy(); reject(e) }
-    socket.setTimeout(10000, () => fail(new Error('로컬 세션 응답 시간 초과. 자동 재전송하지 마세요.')))
+    socket.setTimeout(timeoutMs, () => fail(new Error('로컬 세션 응답 시간 초과. 자동 재전송하지 마세요.')))
     socket.on('error', fail)
     socket.on('connect', () => socket.write(JSON.stringify({ ...message, token: token || s.token }) + '\n'))
     socket.on('data', chunk => {

package/tools/bridge.mjs

@@ -6,6 +6,8 @@ import { dispatchRequest, installHooks, registerHook, requestResult, sessions, u
 import { startManagedSession } from '../src/managed-session.mjs'
 import { runDialogue, startBackgroundDialogue, dialogueResult, stopDialogue } from '../src/session-dialogue.mjs'
 import { sendTerminal } from '../src/terminal-bridge.mjs'
+import { sessionStatus, formatSessionStatus } from '../src/session-status.mjs'
+import { attachConsole } from '../src/external-console.mjs'
 
 const args = process.argv.slice(2)
 const [command] = args
@@ -13,6 +15,7 @@ const option = (name) => { const i = args.indexOf(`--${name}`); return i < 0 ? u
 const output = (value) => console.log(JSON.stringify(value, null, 2))
 try {
   switch (command) {
+    case 'attach': output(attachConsole({ pid: Number(option('pid')), cwd: process.cwd() })); break
     case 'serve': {
       const provider = args[1]
       if (!['codex', 'agy'].includes(provider)) throw new Error('axmap bridge serve codex|agy를 사용하세요.')
@@ -54,6 +57,12 @@ try {
       break
     }
     case 'sessions': output(sessions(process.cwd())); break
+    case 'status': {
+      const listed = await sessionStatus()
+      if (args.includes('--json')) output(listed)
+      else console.log(formatSessionStatus(listed))
+      break
+    }
     case 'send': {
       const r = dispatchRequest({ to: option('to'), prompt: fs.readFileSync(0, 'utf8'), cwd: process.cwd(), from: process.env.AXMAP_AGENT || 'axmap' })
       output(r)
@@ -76,6 +85,8 @@ axmap bridge stop <대화 UUID>                        추가 중계 중단 (이
 axmap bridge install --experimental --executable <agy 절대 경로>   연결 훅 실험
 axmap bridge uninstall                             추가한 연결 훅 해제
 axmap bridge sessions                              이 repo에 연결된 세션
+axmap bridge attach --pid <PID>                    이미 실행한 Windows agy 콘솔을 현재 repo에 연결
+axmap bridge status [--json]                        로컬 연결·작업·승인 대기·종료 상태 조회 (모델 호출 없음)
 axmap bridge send --to <세션 UUID>                  본문은 stdin. 기존 세션에 전달
 axmap bridge result <요청 UUID>                     제출/완료/불명 상태와 결과
 관리형 stdio: Codex App Server / agy stream-json. PTY와 agentapi는 별도 실험 경로입니다.`)

package/tools/run.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { spawnSync } from 'node:child_process'
 import { startTerminal, sendTerminal, installTerminalHooks, installTerminalRuntime } from '../src/terminal-bridge.mjs'
+import { registerExternalHook } from '../src/external-console.mjs'
 
 const [command, ...args] = process.argv.slice(2)
 try {
@@ -13,9 +14,12 @@ try {
   } else if (command === 'rpc') {
     console.log(JSON.stringify(await sendTerminal(args[0], JSON.parse(fs.readFileSync(0, 'utf8')))))
   } else if (command === 'hook') {
-    // Installed once, harmless for sessions not launched through axMap.
+    const input = JSON.parse(fs.readFileSync(0, 'utf8'))
     if (process.env.AXMAP_TERMINAL_SESSION && process.env.AXMAP_TERMINAL_TOKEN) {
-      await sendTerminal(process.env.AXMAP_TERMINAL_SESSION, { action: 'hook', event: args[0], input: JSON.parse(fs.readFileSync(0, 'utf8')) }, process.env.AXMAP_TERMINAL_TOKEN)
+      await sendTerminal(process.env.AXMAP_TERMINAL_SESSION, { action: 'hook', event: args[0], input }, process.env.AXMAP_TERMINAL_TOKEN)
+    } else if (process.platform === 'win32' && input.conversationId) {
+      try { registerExternalHook(input, args[0]) }
+      catch (e) { console.error(`axMap 독립 콘솔: ${e.message}`) }
     }
     console.log('{}')
   } else if (command === '--help' || !command) {

package/tools/setup.mjs

@@ -257,7 +257,7 @@ if (!has('--no-register')) {
   else {
     const hookRunner = path.join(DEST, 'tools', 'run.mjs')
     const r = spawnSync(process.execPath, [hookRunner, 'install-hooks'], { encoding: 'utf8', windowsHide: true })
-    if (r.status === 0) ok('세션 연결', 'axmap run agy로 여는 CLI가 자동 연결됩니다')
+    if (r.status === 0) ok('세션 연결', 'Windows에서 직접 여는 agy와 axmap run CLI가 자동 연결됩니다')
     else no('세션 연결', r.stderr?.trim() || '연결 훅 등록 실패')
   }
 }

package/tools/windows-console.ps1

@@ -0,0 +1,91 @@
+param([int]$TargetPid, [string]$Action = 'snapshot')
+$ErrorActionPreference = 'Stop'
+$utf8 = New-Object System.Text.UTF8Encoding($false)
+[Console]::InputEncoding = $utf8
+[Console]::OutputEncoding = $utf8
+$payload = [Console]::In.ReadToEnd() | ConvertFrom-Json
+# Keep the original pipe writer: AttachConsole replaces the standard handles.
+$reply = [Console]::Out
+if ($Action -eq 'ancestor') {
+ for ($i = 0; $i -lt 12 -and $TargetPid -gt 0; $i++) {
+  $entry = Get-CimInstance Win32_Process -Filter "ProcessId=$TargetPid"
+  if (!$entry) { break }
+  if ($entry.Name -eq 'agy.exe') {
+   if ($entry.CommandLine -match '--input-format|--print(?:\s|=|$)|(?:^|\s)-p(?:\s|$)') { $reply.WriteLine('{"ignored":true}'); exit 0 }
+   $proc = Get-Process -Id $TargetPid
+   $reply.WriteLine((@{ pid=$TargetPid; startedAt=$proc.StartTime.ToUniversalTime().ToString('o') } | ConvertTo-Json -Compress))
+   exit 0
+  }
+  $TargetPid = $entry.ParentProcessId
+ }
+ throw 'No interactive agy ancestor found'
+}
+Add-Type -TypeDefinition @'
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.ComponentModel;
+public static class AxConsole {
+ [StructLayout(LayoutKind.Sequential)] public struct Coord { public short X,Y; }
+ [StructLayout(LayoutKind.Sequential)] public struct Rect { public short Left,Top,Right,Bottom; }
+ [StructLayout(LayoutKind.Sequential)] public struct Info { public Coord Size,Cursor; public short Attr; public Rect Window; public Coord Max; }
+ [StructLayout(LayoutKind.Explicit, CharSet=CharSet.Unicode, Size=20)] public struct Record {
+  [FieldOffset(0)] public short Type;
+  [FieldOffset(4)] public int Down;
+  [FieldOffset(8)] public short Repeat;
+  [FieldOffset(10)] public short Key;
+  [FieldOffset(14)] public char Char;
+ }
+ [DllImport("kernel32.dll", SetLastError=true)] static extern bool AttachConsole(uint pid);
+ [DllImport("kernel32.dll")] public static extern bool FreeConsole();
+ [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateFile(string name,uint access,uint share,IntPtr sec,uint mode,uint flags,IntPtr template);
+ [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetConsoleScreenBufferInfo(IntPtr h,out Info info);
+ [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool ReadConsoleOutputCharacter(IntPtr h,[Out] char[] text,uint count,Coord at,out uint read);
+ [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool WriteConsoleInput(IntPtr h,Record[] input,uint count,out uint written);
+ [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
+ static void Check(bool ok) { if(!ok) throw new Win32Exception(Marshal.GetLastWin32Error()); }
+ public static void Attach(int pid) { FreeConsole(); Check(AttachConsole((uint)pid)); }
+ static IntPtr Open(string name) { var h=CreateFile(name,0xC0000000,3,IntPtr.Zero,3,0,IntPtr.Zero); if(h==new IntPtr(-1)) throw new Win32Exception(Marshal.GetLastWin32Error()); return h; }
+ public static string Snapshot() {
+  var h=Open("CONOUT$"); try {
+   Info info; Check(GetConsoleScreenBufferInfo(h,out info));
+   var text=new StringBuilder();
+   for(short y=info.Window.Top;y<=info.Window.Bottom;y++) {
+    uint read; var row=new char[info.Size.X]; Check(ReadConsoleOutputCharacter(h,row,(uint)row.Length,new Coord { X=0,Y=y },out read)); text.AppendLine(new string(row,0,(int)read).TrimEnd());
+   }
+   return text.ToString();
+  } finally { CloseHandle(h); }
+ }
+ public static void Send(string text) {
+  var h=Open("CONIN$"); try {
+   var records=new Record[text.Length*2];
+   for(int i=0;i<text.Length;i++) {
+    var r=new Record {Type=1,Down=1,Repeat=1,Char=text[i],Key=(short)(text[i]=='\r'?13:0)};
+    records[i*2]=r; r.Down=0; records[i*2+1]=r;
+   }
+   uint written; Check(WriteConsoleInput(h,records,(uint)records.Length,out written));
+   if(written!=records.Length) throw new Exception("Partial console delivery; do not retry automatically.");
+  } finally { CloseHandle(h); }
+ }
+}
+'@
+try {
+ $proc = Get-Process -Id $TargetPid
+ if ($proc.ProcessName -ne 'agy') { throw 'Target is not agy.exe' }
+ $commandLine = (Get-CimInstance Win32_Process -Filter "ProcessId=$TargetPid").CommandLine
+ if ($commandLine -match '--input-format|--print(?:\s|=|$)|(?:^|\s)-p(?:\s|$)') { throw 'Target is not an interactive agy console' }
+ if ($payload.startedAt -and $proc.StartTime.ToUniversalTime().ToString('o') -ne $payload.startedAt) { throw 'Process identity changed' }
+ [AxConsole]::Attach($TargetPid)
+ $screen = [AxConsole]::Snapshot()
+ if ($Action -eq 'send') {
+  if ($payload.expectedScreen -cne $screen) { throw 'Console changed before delivery; input was not sent' }
+  [AxConsole]::Send($payload.text)
+ }
+ $result = @{ screen = $screen; startedAt = $proc.StartTime.ToUniversalTime().ToString('o'); pid = $TargetPid }
+ [AxConsole]::FreeConsole() | Out-Null
+ $reply.WriteLine(($result | ConvertTo-Json -Compress))
+} catch {
+ [AxConsole]::FreeConsole() | Out-Null
+ $reply.WriteLine((@{ error = $_.Exception.Message } | ConvertTo-Json -Compress))
+ exit 1
+}