axmap-cli 1.4.0 → 1.6.0

package/src/monitor.mts

@@ -0,0 +1,195 @@
+/** Local observation only: no model submission, Git fetch, ledger bootstrap or approval. */
+import fs from 'node:fs'
+import path from 'node:path'
+import { bridgeHome, repoKey, requestResult } from './bridge.mjs'
+import { sessionStatus } from './session-status.mjs'
+import { errorCode, errorMessage } from './session-types.mjs'
+import type { RequestRecord, SessionSnapshot, DialogueRecord } from './session-types.mjs'
+
+export interface MonitorClaim { agent: string; session?: string | null; task?: string | null; intent?: string | null; paths: string[]; expiresAt: number }
+export interface MonitorEvent { id: string; at: string; label: string; tone: 'info' | 'success' | 'warning' }
+export interface MonitorSnapshot {
+  cwd: string; repo: string; checkedAt: string; sessions: SessionSnapshot[]; requests: RequestRecord[]
+  dialogues: DialogueRecord[]; claims: MonitorClaim[]; events: MonitorEvent[]; issues: string[]
+}
+const uuidFile = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\.json$/i
+const pending = new Set(['sending', 'submitted', 'unknown'])
+const requestLabels: Record<string, string> = { sending: '전달 중', submitted: '응답 대기', completed: '완료', failed: '실패', unknown: '전송 확인 필요', superseded: '다른 입력으로 대체됨' }
+const sessionLabels: Record<string, string> = { starting: '시작 중', running: '작업 중', idle: '대기', awaiting_user: '사용자 승인 필요', settling: '대기 전환 중', closed: '종료', unknown: '상태 미확인' }
+const dialogueLabels: Record<string, string> = { queued: '접수', running: '중계 중', stopping: '중단 대기', completed: '완료', failed: '실패', cancelled: '중단', token_limit: '토큰 한도', unknown: '확인 필요', usage_unavailable: '사용량 미확인', message_limit: '메시지 한도', invalid_response: '응답 형식 확인 필요', turn_limit: '횟수 한도' }
+
+function records(directory: string, issues: string[], label: string, uuidOnly = true): unknown[] {
+  try {
+    const files = fs.readdirSync(directory).filter(name => uuidOnly ? uuidFile.test(name) : name.endsWith('.json'))
+      .map(name => ({ name, stat: fs.statSync(path.join(directory, name)) }))
+      .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
+    if (files.length > 500) issues.push(`${label}: 최근 500개 기록만 표시합니다.`)
+    const result: unknown[] = []
+    for (const { name, stat } of files.slice(0, 500)) {
+      if (stat.size > 1024 * 1024) { issues.push(`${label}: 큰 기록을 건너뛰었습니다 (${name}).`); continue }
+      try { result.push(JSON.parse(fs.readFileSync(path.join(directory, name), 'utf8')) as unknown) }
+      catch { issues.push(`${label}: 읽을 수 없는 기록 (${name}).`) }
+    }
+    return result
+  } catch (e) { if (errorCode(e) !== 'ENOENT') issues.push(`${label}: ${errorMessage(e)}`); return [] }
+}
+const object = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v)
+const time = (v: unknown) => typeof v === 'string' ? Date.parse(v) || 0 : 0
+
+export function createMonitor(cwd: string, options: {
+  probe?: (cwd: string) => Promise<SessionSnapshot[]>
+  resolve?: (id: string, cwd: string) => RequestRecord
+  now?: () => number
+} = {}): () => Promise<MonitorSnapshot> {
+  const workspace = path.resolve(cwd), repo = repoKey(workspace)
+  const probe = options.probe || sessionStatus, resolve = options.resolve || requestResult, now = options.now || Date.now
+  const observed = new Map<string, string>(), events = new Map<string, MonitorEvent>()
+  const event = (id: string, at: string, label: string, tone: MonitorEvent['tone'] = 'info') => events.set(id, { id, at, label, tone })
+  return async () => {
+    const checkedAt = new Date(now()).toISOString(), issues: string[] = []
+    let sessions: SessionSnapshot[] = []
+    try { sessions = await probe(workspace) } catch (e) { issues.push(`세션 확인: ${errorMessage(e)}`) }
+    const requests: RequestRecord[] = []
+    for (const raw of records(path.join(bridgeHome(), 'requests'), issues, '요청')) {
+      if (!object(raw) || raw.repo !== repo) continue
+      if (typeof raw.id !== 'string' || typeof raw.to !== 'string' || typeof raw.prompt !== 'string' || typeof raw.from !== 'string' || typeof raw.createdAt !== 'string' || !Number.isFinite(Date.parse(raw.createdAt)) || typeof raw.state !== 'string' || !requestLabels[raw.state]) { issues.push('형식이 올바르지 않은 요청 기록이 있습니다.'); continue }
+      requests.push(raw as unknown as RequestRecord)
+    }
+    requests.sort((a, b) => time(b.createdAt) - time(a.createdAt))
+    // Refresh at most one pending request per session, never submit or retry it.
+    const refreshed = new Set<string>()
+    for (let index = 0; index < requests.length && refreshed.size < 4; index++) {
+      const request = requests[index]!
+      if (!['submitted', 'unknown'].includes(request.state) || refreshed.has(request.to)) continue
+      refreshed.add(request.to)
+      try { requests[index] = resolve(request.id, workspace) }
+      catch (e) { issues.push(`요청 ${request.id.slice(0, 8)}: ${errorMessage(e)}`) }
+    }
+    for (const request of requests) {
+      const key = `request:${request.id}`, previous = observed.get(key)
+      event(`${key}:created`, request.createdAt, `요청 접수 · ${request.from} → ${request.to.slice(0, 8)}`)
+      if (request.completedAt) event(`${key}:completed`, request.completedAt, `완료 확인 · ${request.to.slice(0, 8)}`, 'success')
+      if (previous !== undefined && previous !== request.state && !(request.state === 'completed' && request.completedAt)) event(`${key}:${request.state}`, checkedAt,
+        `${requestLabels[request.state]} · ${request.to.slice(0, 8)}`, request.state === 'completed' ? 'success' : request.state === 'submitted' ? 'info' : 'warning')
+      observed.set(key, request.state)
+    }
+    for (const session of sessions) {
+      const key = `session:${session.id}`, value = `${session.connection}:${session.state}`, previous = observed.get(key)
+      if (previous !== undefined && previous !== value) event(`${key}:${value}`, checkedAt,
+        `${session.provider} ${session.id.slice(0, 8)} · ${sessionLabels[session.state]}`, session.state === 'awaiting_user' || session.connection === 'unreachable' ? 'warning' : 'info')
+      observed.set(key, value)
+    }
+    const dialogues: DialogueRecord[] = []
+    for (const raw of records(path.join(bridgeHome(), 'dialogues'), issues, '대화')) {
+      if (!object(raw) || raw.repo !== repo) continue
+      if (typeof raw.id !== 'string' || typeof raw.state !== 'string' || !dialogueLabels[raw.state] || !Array.isArray(raw.turns)) { issues.push('형식이 올바르지 않은 대화 기록이 있습니다.'); continue }
+      dialogues.push(raw as unknown as DialogueRecord)
+    }
+    dialogues.sort((a, b) => time(b.createdAt) - time(a.createdAt))
+    const claims: MonitorClaim[] = []
+    const ledger = path.join(path.dirname(repo), '.axmap', 'ledger', 'claims')
+    for (const raw of records(ledger, issues, '선점', false)) {
+      if (!object(raw) || typeof raw.agent !== 'string' || !Array.isArray(raw.paths) || !raw.paths.every(p => typeof p === 'string') || typeof raw.since !== 'string' || typeof raw.ttlMs !== 'number') { issues.push('형식이 올바르지 않은 선점 기록이 있습니다.'); continue }
+      const expiresAt = time(raw.since) + raw.ttlMs
+      if (!Number.isFinite(expiresAt) || expiresAt <= now()) continue
+      claims.push({ agent: raw.agent, paths: raw.paths as string[], expiresAt,
+        session: typeof raw.session === 'string' ? raw.session : null, task: typeof raw.task === 'string' ? raw.task : null, intent: typeof raw.intent === 'string' ? raw.intent : null })
+    }
+    const recent = [...events.values()].sort((a, b) => time(b.at) - time(a.at)).slice(0, 40)
+    events.clear(); for (const entry of recent) events.set(entry.id, entry)
+    return { cwd: workspace, repo, checkedAt, sessions, requests: requests.slice(0, 50), dialogues: dialogues.slice(0, 20), claims, events: recent, issues }
+  }
+}
+
+/** Strip untrusted terminal controls, including OSC, CSI and bidi overrides. */
+export function terminalText(value: unknown): string {
+  return String(value ?? '').replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, ' ').replace(/\s+/g, ' ').trim()
+}
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+function cellWidth(text: string): number {
+  if (/\p{Extended_Pictographic}/u.test(text)) return 2
+  const cp = text.codePointAt(0) || 0
+  if (/^\p{Mark}+$/u.test(text)) return 0
+  return cp >= 0x1100 && (cp <= 0x115f || cp === 0x2329 || cp === 0x232a ||
+    cp >= 0x2e80 && cp <= 0xa4cf || cp >= 0xac00 && cp <= 0xd7a3 || cp >= 0xf900 && cp <= 0xfaff ||
+    cp >= 0xfe10 && cp <= 0xfe6f || cp >= 0xff01 && cp <= 0xff60 || cp >= 0xffe0 && cp <= 0xffe6 || cp >= 0x20000) ? 2 : 1
+}
+export function fitTerminal(value: unknown, width: number): string {
+  const text = terminalText(value), parts = [...segmenter.segment(text)].map(s => s.segment)
+  if (parts.reduce((n, c) => n + cellWidth(c), 0) <= width) return text
+  let out = '', used = 0
+  for (const part of parts) { const next = cellWidth(part); if (used + next > width - 1) break; out += part; used += next }
+  return width > 0 ? out + '…' : ''
+}
+const elapsed = (start: string, end: number): string => {
+  const seconds = Math.max(0, Math.floor((end - time(start)) / 1000))
+  return seconds < 60 ? `${seconds}초` : `${Math.floor(seconds / 60)}분 ${seconds % 60}초`
+}
+const clock = (value: string) => new Date(value).toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false })
+
+export function renderMonitor(snapshot: MonitorSnapshot, { columns = 100, rows = 36, color = false, now = Date.now(), frame = 0 } = {}): string {
+  const width = Math.max(1, Math.floor(columns)), height = Math.max(1, Math.floor(rows)), lines: string[] = []
+  const paint = (text: string, tone: 'info' | 'success' | 'warning' | 'muted' = 'info') => color ? `\x1b[${{ info: 36, success: 32, warning: 33, muted: 90 }[tone]}m${text}\x1b[0m` : text
+  const add = (text: string, tone?: Parameters<typeof paint>[1]) => {
+    const indent = Math.min(text.length - text.trimStart().length, 4, width)
+    lines.push(paint(' '.repeat(indent) + fitTerminal(text, width - indent), tone))
+  }
+  const heading = (text: string) => add(`── ${text} ${'─'.repeat(Math.max(0, width - 4 - [...text].reduce((n, c) => n + cellWidth(c), 0)))}`, 'muted')
+  const active = snapshot.requests.filter(r => pending.has(r.state)), attention = snapshot.sessions.filter(s => s.state === 'awaiting_user').length
+  add(`axMap  LIVE  · 진행 확인 ${active.length}개${attention ? `  · 승인 대기 ${attention}` : ''}`, attention ? 'warning' : 'info')
+  add(snapshot.cwd, 'muted')
+  add(`관측 ${clock(snapshot.checkedAt)} · 확인된 정보만 표시 · 모델 호출 없음`, 'muted')
+  if (width < 56 || height < 16) {
+    add('터미널을 넓히면 파이프라인과 최근 이벤트가 표시됩니다.', 'muted')
+    for (const s of snapshot.sessions.slice(0, Math.max(0, height - 7))) add(`${s.provider} ${s.id.slice(0, 8)} · ${sessionLabels[s.state]}`)
+    for (const r of active.slice(0, 2)) add(`${r.id.slice(0, 8)} · ${requestLabels[r.state]}`, 'warning')
+  } else {
+    heading('에이전트')
+    if (!snapshot.sessions.length) add('연결된 세션 기록이 없습니다. axmap bridge attach / serve로 연결하세요.', 'muted')
+    for (const session of snapshot.sessions.slice(0, Math.min(5, Math.max(1, Math.floor((height - 14) / 5))))) {
+      const state = sessionLabels[session.state], connection = { connected: '연결됨', closed: '종료됨', unreachable: '연결 확인 불가', unverified: '확인 미지원' }[session.connection]
+      const usage = session.usage?.totalTokens == null ? '토큰 미측정' : `처리 ${session.usage.totalTokens.toLocaleString()} 토큰`
+      add(`${session.state === 'idle' ? '○' : session.state === 'running' ? '●' : '◇'} ${session.provider.toUpperCase()}  ${session.id.slice(0, 8)}  ${state} · ${connection} · ${usage}`, session.state === 'awaiting_user' || session.connection === 'unreachable' ? 'warning' : 'info')
+      if (session.role) add(`  역할  ${session.role}`, 'muted')
+      if (session.pendingApproval) {
+        const detail = session.pendingApproval.command || session.pendingApproval.commandLine || session.pendingApproval.reason
+        if (typeof detail === 'string') add(`  승인 요청  ${detail}`, 'warning')
+      }
+    }
+    heading('요청 파이프라인')
+    const selected = [...active, ...snapshot.requests.filter(r => !pending.has(r.state))].slice(0, height >= 32 ? 3 : 1)
+    if (!selected.length) { add('새 요청을 기다리는 중', 'muted'); add('별도 터미널이나 AI에서 요청을 보내면 여기에 흐름이 나타납니다.', 'muted') }
+    for (const request of selected) {
+      const session = snapshot.sessions.find(s => s.id === request.to)
+      const target = `${session?.provider || '세션'} ${request.to.slice(0, 8)}`
+      const tone = request.state === 'completed' ? 'success' : ['unknown', 'failed', 'superseded'].includes(request.state) ? 'warning' : 'info'
+      add(`${request.from}  →  ${target}  · ${requestLabels[request.state]} · ${elapsed(request.createdAt, request.completedAt ? time(request.completedAt) : now)}`, tone)
+      const spin = ['◐', '◓', '◑', '◒'][frame % 4]
+      const stages = request.state === 'completed' ? '● 접수 ── ● 전달 ── ● 응답 ── ● 완료 확인' :
+        request.state === 'submitted' ? `● 접수 ── ● 전달 ── ${spin} 응답 대기 ── ○ 완료 확인` :
+        request.state === 'sending' ? `● 접수 ── ${spin} 전달 중 ── ○ 응답 ── ○ 완료 확인` :
+        request.state === 'unknown' ? '● 접수 ── ? 전달 확인 필요 ── ○ 완료 미확정' : '● 접수 ── ! 진행 중단 ── ○ 완료 미확정'
+      add(`  ${stages}`, tone)
+      add(`  작업  ${request.prompt}`, 'muted')
+      if (request.error) add(`  사유  ${request.error}`, 'warning')
+    }
+    const dialogue = snapshot.dialogues.find(d => ['queued', 'running', 'stopping'].includes(d.state))
+    if (dialogue) {
+      const used = dialogue.usage?.totalTokens ?? dialogue.knownUsage?.totalTokens
+      add(`자동 대화  ${dialogueLabels[dialogue.state]} · ${dialogue.turns.length}/${dialogue.limits?.maxTurns ?? '?'}회 · 처리 ${used == null ? '미확인' : used.toLocaleString()} 토큰${dialogue.usagePending ? ' (측정 대기 포함)' : ''}`)
+    }
+    if (snapshot.claims.length && lines.length < height - 6) {
+      heading('작업 선점')
+      for (const claim of snapshot.claims.slice(0, 2)) add(`${claim.agent} · ${claim.intent || claim.task || '작업 중'} · ${claim.paths.slice(0, 2).join(', ')}${claim.paths.length > 2 ? ` 외 ${claim.paths.length - 2}개` : ''}`, 'muted')
+    }
+    if (lines.length < height - 4) {
+      heading('최근 이벤트')
+      if (!snapshot.events.length) add('관측된 이벤트가 없습니다.', 'muted')
+      for (const event of snapshot.events.slice(0, Math.min(5, height - lines.length - 3))) add(`${clock(event.at)}  ${event.label}`, event.tone)
+    }
+  }
+  const warnings = snapshot.issues.slice(0, Math.min(2, height - 1)).map(issue => paint(fitTerminal(`! ${issue}`, width), 'warning'))
+  const footer = paint(fitTerminal('q / Esc 종료 · 모니터를 닫아도 진행 중인 작업은 계속됩니다.', width), 'muted')
+  return [...lines.slice(0, height - 1 - warnings.length), ...warnings, footer].join('\n')
+}

package/src/node-pty.d.ts

@@ -0,0 +1,13 @@
+/// <reference path="../node_modules/node-pty/node-pty.d.ts" />
+// The prebuilt package declares its original name; the runtime uses an npm alias.
+declare module 'node-pty' {
+  export * from '@lydell/node-pty'
+}
+// Preserve the bridge's existing Windows configuration during migration;
+// the package's declarations omit these legacy options.
+declare module '@lydell/node-pty' {
+  interface IWindowsPtyForkOptions {
+    useConpty?: boolean
+    useConptyDll?: boolean
+  }
+}

package/src/pipeline-mcp.mjs

@@ -0,0 +1,109 @@
+// Generated from src/pipeline-mcp.mts. Edit the .mts source and run npm run build.
+/** Portable MCP observation: structured snapshots, plain text and progress share one source. */
+import { createMonitor, terminalText, fitTerminal } from './monitor.mjs';
+import { dispatchRequest, requestResult } from './bridge.mjs';
+const labels = { sending: '전달 중', submitted: '응답 대기', completed: '완료 확인', unknown: '전송 확인 필요', failed: '실패', superseded: '다른 입력으로 대체됨' };
+const pending = new Set(['sending', 'submitted', 'unknown']);
+export function pipelineView(snapshot) {
+    return {
+        schemaVersion: 1, type: 'pipeline', cwd: snapshot.cwd, checkedAt: snapshot.checkedAt,
+        sessions: snapshot.sessions.map(s => ({ id: s.id, provider: s.provider, state: s.state, connection: s.connection,
+            role: fitTerminal(s.role, 120), usage: s.usage ?? null, pendingApproval: !!s.pendingApproval })),
+        requests: snapshot.requests.map(r => ({ id: r.id, to: r.to, from: terminalText(r.from), state: r.state,
+            task: fitTerminal(r.prompt, 200), createdAt: r.createdAt, completedAt: r.completedAt, error: fitTerminal(r.error, 240) })),
+        dialogues: snapshot.dialogues.map(d => ({ id: d.id, state: d.state, turns: d.turns.length,
+            maxTurns: d.limits?.maxTurns, usage: d.usage ?? null, usagePending: d.usagePending })),
+        claims: snapshot.claims.slice(0, 10).map(c => ({ agent: terminalText(c.agent), task: fitTerminal(c.intent || c.task, 160),
+            paths: c.paths.slice(0, 6).map(terminalText), pathCount: c.paths.length })),
+        events: snapshot.events.slice(0, 15).map(e => ({ ...e, label: terminalText(e.label) })),
+        issues: snapshot.issues.map(terminalText),
+    };
+}
+export function pipelineText(view) {
+    const active = view.requests.filter(r => pending.has(r.state));
+    const lines = [`axMap · 진행 확인 ${active.length}개 · ${view.sessions.length}개 세션`, `저장소: ${terminalText(view.cwd)}`];
+    for (const session of view.sessions.slice(0, 5))
+        lines.push(`${session.provider} ${session.id.slice(0, 8)} · ${session.pendingApproval ? '사용자 승인 필요' : session.state} · ${session.connection}`);
+    const selected = [...active, ...view.requests.filter(r => !pending.has(r.state))].slice(0, 3);
+    for (const request of selected) {
+        lines.push(`${request.from} → ${request.to.slice(0, 8)} · ${labels[request.state] || request.state}`);
+        lines.push(request.state === 'completed' ? '접수 ✓ → 전달 ✓ → 응답 ✓ → 완료 확인 ✓' :
+            request.state === 'submitted' ? '접수 ✓ → 전달 ✓ → 응답 대기 → 완료 미확정' :
+                request.state === 'unknown' ? '접수 ✓ → 전달 여부 확인 필요 → 완료 미확정' : `접수 → ${labels[request.state] || request.state} → 완료 미확정`);
+        lines.push(`작업: ${request.task}`);
+        if (request.error)
+            lines.push(`사유: ${request.error}`);
+    }
+    if (!selected.length)
+        lines.push('새 요청을 기다리는 중');
+    for (const issue of view.issues.slice(0, 2))
+        lines.push(`확인 필요: ${issue}`);
+    return lines.join('\n');
+}
+function integer(value, fallback, min, max, name) {
+    const result = value === undefined ? fallback : value;
+    if (typeof result !== 'number' || !Number.isInteger(result) || result < min || result > max)
+        throw new Error(`${name}: ${min}~${max} 정수여야 합니다.`);
+    return result;
+}
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const textResult = (text, structuredContent, isError = false) => ({ content: [{ type: 'text', text }], structuredContent, isError });
+export async function runPipelineOperation(action, args, emit = () => { }, cancelled = () => false) {
+    const cwd = process.cwd(), progress = args.__progress === true;
+    if (action === 'snapshot' || action === 'watch') {
+        const duration = integer(args.duration_ms, action === 'watch' ? 5000 : 0, 0, 25000, 'duration_ms');
+        const interval = integer(args.interval_ms, 1000, 500, 5000, 'interval_ms');
+        const collect = createMonitor(cwd), deadline = Date.now() + (progress ? duration : 0);
+        let view;
+        do {
+            view = pipelineView(await collect());
+            if (progress) {
+                const active = view.requests.filter(r => pending.has(r.state));
+                emit(active.length ? active.slice(0, 3).map(r => `${r.id.slice(0, 8)} ${labels[r.state]}`).join(' · ') : 'axMap · 진행 중인 요청 없음');
+            }
+            if (cancelled() || Date.now() >= deadline)
+                break;
+            await delay(Math.min(interval, Math.max(0, deadline - Date.now())));
+            if (cancelled())
+                break;
+        } while (true);
+        const note = action === 'watch' && !progress ? '\n클라이언트가 progressToken을 제공하지 않아 현재 상태를 한 번 반환했습니다.' : '';
+        return textResult(pipelineText(view) + note + (cancelled() ? '\n관측 대기를 중단했습니다. 이미 전달한 작업은 계속 실행될 수 있습니다.' : ''), view, cancelled());
+    }
+    if (action === 'dispatch' || action === 'result') {
+        // Validate the wait budget before any irreversible submission.
+        const waitMs = integer(args.wait_ms, 0, 0, 30000, 'wait-ms');
+        let request;
+        if (action === 'dispatch') {
+            if (typeof args.to !== 'string' || typeof args.prompt !== 'string')
+                throw new Error('to와 prompt 문자열이 필요합니다.');
+            if (progress)
+                emit('axMap · 대상 세션과 입력 상태 확인');
+            request = dispatchRequest({ to: args.to, prompt: args.prompt, cwd, from: process.env.AXMAP_AGENT || 'axmap' });
+        }
+        else {
+            if (typeof args.id !== 'string')
+                throw new Error('요청 UUID가 필요합니다.');
+            request = requestResult(args.id, cwd);
+        }
+        const deadline = Date.now() + waitMs;
+        let lastMessage = '', lastAt = 0;
+        do {
+            const message = `axMap · ${request.id.slice(0, 8)} · ${labels[request.state] || request.state}`;
+            if (progress && (message !== lastMessage || Date.now() - lastAt >= 1000)) {
+                emit(message);
+                lastMessage = message;
+                lastAt = Date.now();
+            }
+            if (cancelled() || request.state !== 'submitted' || Date.now() >= deadline)
+                break;
+            await delay(Math.min(200, Math.max(0, deadline - Date.now())));
+            if (cancelled())
+                break;
+            request = requestResult(request.id, cwd);
+        } while (true);
+        return textResult(JSON.stringify(request, null, 2), { schemaVersion: 1, type: 'request', request,
+            observationCancelled: cancelled() }, action === 'dispatch' && request.state === 'unknown');
+    }
+    throw new Error(`지원하지 않는 파이프라인 동작: ${action}`);
+}

package/src/pipeline-mcp.mts

@@ -0,0 +1,103 @@
+/** Portable MCP observation: structured snapshots, plain text and progress share one source. */
+import { createMonitor, terminalText, fitTerminal } from './monitor.mjs'
+import { dispatchRequest, requestResult } from './bridge.mjs'
+import type { MonitorSnapshot } from './monitor.mjs'
+import type { RequestRecord } from './session-types.mjs'
+
+export interface PipelineOutput {
+  content: Array<{ type: 'text'; text: string }>
+  structuredContent?: Record<string, unknown>
+  isError: boolean
+}
+export type PipelineEmit = (message: string) => void
+const labels: Record<string, string> = { sending: '전달 중', submitted: '응답 대기', completed: '완료 확인', unknown: '전송 확인 필요', failed: '실패', superseded: '다른 입력으로 대체됨' }
+const pending = new Set(['sending', 'submitted', 'unknown'])
+
+export function pipelineView(snapshot: MonitorSnapshot) {
+  return {
+    schemaVersion: 1, type: 'pipeline', cwd: snapshot.cwd, checkedAt: snapshot.checkedAt,
+    sessions: snapshot.sessions.map(s => ({ id: s.id, provider: s.provider, state: s.state, connection: s.connection,
+      role: fitTerminal(s.role, 120), usage: s.usage ?? null, pendingApproval: !!s.pendingApproval })),
+    requests: snapshot.requests.map(r => ({ id: r.id, to: r.to, from: terminalText(r.from), state: r.state,
+      task: fitTerminal(r.prompt, 200), createdAt: r.createdAt, completedAt: r.completedAt, error: fitTerminal(r.error, 240) })),
+    dialogues: snapshot.dialogues.map(d => ({ id: d.id, state: d.state, turns: d.turns.length,
+      maxTurns: d.limits?.maxTurns, usage: d.usage ?? null, usagePending: d.usagePending })),
+    claims: snapshot.claims.slice(0, 10).map(c => ({ agent: terminalText(c.agent), task: fitTerminal(c.intent || c.task, 160),
+      paths: c.paths.slice(0, 6).map(terminalText), pathCount: c.paths.length })),
+    events: snapshot.events.slice(0, 15).map(e => ({ ...e, label: terminalText(e.label) })),
+    issues: snapshot.issues.map(terminalText),
+  }
+}
+export type PipelineView = ReturnType<typeof pipelineView>
+export function pipelineText(view: PipelineView): string {
+  const active = view.requests.filter(r => pending.has(r.state))
+  const lines = [`axMap · 진행 확인 ${active.length}개 · ${view.sessions.length}개 세션`, `저장소: ${terminalText(view.cwd)}`]
+  for (const session of view.sessions.slice(0, 5)) lines.push(`${session.provider} ${session.id.slice(0, 8)} · ${session.pendingApproval ? '사용자 승인 필요' : session.state} · ${session.connection}`)
+  const selected = [...active, ...view.requests.filter(r => !pending.has(r.state))].slice(0, 3)
+  for (const request of selected) {
+    lines.push(`${request.from} → ${request.to.slice(0, 8)} · ${labels[request.state] || request.state}`)
+    lines.push(request.state === 'completed' ? '접수 ✓ → 전달 ✓ → 응답 ✓ → 완료 확인 ✓' :
+      request.state === 'submitted' ? '접수 ✓ → 전달 ✓ → 응답 대기 → 완료 미확정' :
+      request.state === 'unknown' ? '접수 ✓ → 전달 여부 확인 필요 → 완료 미확정' : `접수 → ${labels[request.state] || request.state} → 완료 미확정`)
+    lines.push(`작업: ${request.task}`)
+    if (request.error) lines.push(`사유: ${request.error}`)
+  }
+  if (!selected.length) lines.push('새 요청을 기다리는 중')
+  for (const issue of view.issues.slice(0, 2)) lines.push(`확인 필요: ${issue}`)
+  return lines.join('\n')
+}
+function integer(value: unknown, fallback: number, min: number, max: number, name: string): number {
+  const result = value === undefined ? fallback : value
+  if (typeof result !== 'number' || !Number.isInteger(result) || result < min || result > max) throw new Error(`${name}: ${min}~${max} 정수여야 합니다.`)
+  return result
+}
+const delay = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms))
+const textResult = (text: string, structuredContent?: Record<string, unknown>, isError = false): PipelineOutput => ({ content: [{ type: 'text', text }], structuredContent, isError })
+
+export async function runPipelineOperation(action: string, args: Record<string, unknown>, emit: PipelineEmit = () => {}, cancelled: () => boolean = () => false): Promise<PipelineOutput> {
+  const cwd = process.cwd(), progress = args.__progress === true
+  if (action === 'snapshot' || action === 'watch') {
+    const duration = integer(args.duration_ms, action === 'watch' ? 5000 : 0, 0, 25000, 'duration_ms')
+    const interval = integer(args.interval_ms, 1000, 500, 5000, 'interval_ms')
+    const collect = createMonitor(cwd), deadline = Date.now() + (progress ? duration : 0)
+    let view: PipelineView
+    do {
+      view = pipelineView(await collect())
+      if (progress) {
+        const active = view.requests.filter(r => pending.has(r.state))
+        emit(active.length ? active.slice(0, 3).map(r => `${r.id.slice(0, 8)} ${labels[r.state]}`).join(' · ') : 'axMap · 진행 중인 요청 없음')
+      }
+      if (cancelled() || Date.now() >= deadline) break
+      await delay(Math.min(interval, Math.max(0, deadline - Date.now())))
+      if (cancelled()) break
+    } while (true)
+    const note = action === 'watch' && !progress ? '\n클라이언트가 progressToken을 제공하지 않아 현재 상태를 한 번 반환했습니다.' : ''
+    return textResult(pipelineText(view) + note + (cancelled() ? '\n관측 대기를 중단했습니다. 이미 전달한 작업은 계속 실행될 수 있습니다.' : ''), view, cancelled())
+  }
+  if (action === 'dispatch' || action === 'result') {
+    // Validate the wait budget before any irreversible submission.
+    const waitMs = integer(args.wait_ms, 0, 0, 30000, 'wait-ms')
+    let request: RequestRecord
+    if (action === 'dispatch') {
+      if (typeof args.to !== 'string' || typeof args.prompt !== 'string') throw new Error('to와 prompt 문자열이 필요합니다.')
+      if (progress) emit('axMap · 대상 세션과 입력 상태 확인')
+      request = dispatchRequest({ to: args.to, prompt: args.prompt, cwd, from: process.env.AXMAP_AGENT || 'axmap' })
+    } else {
+      if (typeof args.id !== 'string') throw new Error('요청 UUID가 필요합니다.')
+      request = requestResult(args.id, cwd)
+    }
+    const deadline = Date.now() + waitMs
+    let lastMessage = '', lastAt = 0
+    do {
+      const message = `axMap · ${request.id.slice(0, 8)} · ${labels[request.state] || request.state}`
+      if (progress && (message !== lastMessage || Date.now() - lastAt >= 1000)) { emit(message); lastMessage = message; lastAt = Date.now() }
+      if (cancelled() || request.state !== 'submitted' || Date.now() >= deadline) break
+      await delay(Math.min(200, Math.max(0, deadline - Date.now())))
+      if (cancelled()) break
+      request = requestResult(request.id, cwd)
+    } while (true)
+    return textResult(JSON.stringify(request, null, 2), { schemaVersion: 1, type: 'request', request,
+      observationCancelled: cancelled() }, action === 'dispatch' && request.state === 'unknown')
+  }
+  throw new Error(`지원하지 않는 파이프라인 동작: ${action}`)
+}

package/src/pipeline-statusline.mjs

@@ -0,0 +1,135 @@
+// Generated from src/pipeline-statusline.mts. Edit the .mts source and run npm run build.
+/** Native CLI adapter. Reads local records only and preserves the user's old status command. */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+import { bridgeHome, repoKey, readJSON, writeJSON } from './bridge.mjs';
+import { createMonitor, fitTerminal, terminalText } from './monitor.mjs';
+const root = fileURLToPath(new URL('../', import.meta.url));
+const savedFile = (home, provider) => path.join(home, '.axmap', 'bridge', `statusline-${provider}.json`);
+function client(value) { if (value !== 'claude' && value !== 'agy')
+    throw new Error('claude 또는 agy를 지정하세요.'); return value; }
+function settings(home, provider) { return provider === 'claude' ? path.join(home, '.claude', 'settings.json') : path.join(home, '.gemini', 'antigravity-cli', 'settings.json'); }
+export function installPipelineStatusline(providerName, home = os.homedir(), remove = false) {
+    const provider = client(providerName), target = settings(home, provider), file = savedFile(home, provider);
+    const original = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : null;
+    const config = original === null ? {} : JSON.parse(original);
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        throw new Error('기존 설정을 읽지 못했습니다. 변경하지 않았습니다.');
+    const current = config.statusLine;
+    if (current !== undefined && (!current || typeof current !== 'object' || Array.isArray(current)))
+        throw new Error('기존 statusLine 설정이 객체가 아닙니다. 변경하지 않았습니다.');
+    const owned = typeof current?.command === 'string' && current.command.includes(`axmap-statusline-${provider}`);
+    if (remove && !owned)
+        return { provider, changed: false, note: '다른 상태줄 설정을 유지합니다.' };
+    const saved = fs.existsSync(file) ? readJSON(file) : null;
+    if (owned && !saved)
+        throw new Error('기존 상태줄 복원 정보를 찾지 못했습니다. 변경하지 않았습니다.');
+    const previous = owned ? saved.previous : current;
+    const script = path.join(root, 'tools', 'pipeline.mjs');
+    const wrapper = path.join(home, '.axmap', 'bridge', `axmap-statusline-${provider}${process.platform === 'win32' ? '.cmd' : '.sh'}`);
+    if (process.platform === 'win32' && [process.execPath, script, wrapper].some(p => /["\r\n%&|<>^!]/.test(p)))
+        throw new Error('상태줄 실행 경로에 지원하지 않는 셸 문자가 있습니다.');
+    if (process.platform === 'win32' && /\s/.test(wrapper))
+        throw new Error('이 Windows 상태줄 실행 경로에는 공백을 사용할 수 없습니다. 기존 설정을 유지합니다.');
+    const backup = `${target}.axmap-${randomUUID()}.bak`;
+    if (original !== null)
+        fs.writeFileSync(backup, original, { mode: 0o600 });
+    writeJSON(file, { previous, active: !remove });
+    if (remove) {
+        if (previous === undefined)
+            delete config.statusLine;
+        else
+            config.statusLine = previous;
+    }
+    else {
+        fs.mkdirSync(path.dirname(wrapper), { recursive: true });
+        const quote = (s) => `'${s.replaceAll("'", "'\\''")}'`;
+        const command = process.platform === 'win32'
+            ? `@echo off\r\n"${process.execPath}" "${script}" statusline --provider ${provider}\r\n`
+            : `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(script)} statusline --provider ${provider}\n`;
+        fs.writeFileSync(wrapper, command, { mode: 0o700 });
+        config.statusLine = { ...previous, type: 'command',
+            command: provider === 'claude' ? `"${wrapper.replaceAll('\\', '/')}"` : process.platform === 'win32' ? wrapper : quote(wrapper),
+            ...(provider === 'claude' ? { refreshInterval: previous?.refreshInterval ?? 2 } : { enabled: true, stack_with_default: previous?.stack_with_default ?? true }) };
+    }
+    writeJSON(target, config);
+    return { provider, changed: true, settings: target, backup: original === null ? null : backup,
+        previousPreserved: !!previous, installed: !remove };
+}
+function previousOutput(provider, home, input, previous) {
+    if (typeof previous?.command !== 'string' || !previous.command.trim())
+        return '';
+    let executable, args;
+    if (process.platform === 'win32' && provider === 'claude') {
+        const bash = [process.env.CLAUDE_CODE_GIT_BASH_PATH, path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Git', 'bin', 'bash.exe')].find(p => p && fs.existsSync(p));
+        if (!bash)
+            return '기존 상태줄: Git Bash 경로 확인 필요\n';
+        executable = bash;
+        args = ['-c', previous.command];
+    }
+    else if (process.platform === 'win32') {
+        executable = process.env.ComSpec || 'cmd.exe';
+        args = ['/d', '/s', '/c', previous.command];
+    }
+    else {
+        executable = '/bin/sh';
+        args = ['-c', previous.command];
+    }
+    // Only the user's pre-existing command is executed; provider JSON stays on stdin.
+    const options = { input, encoding: 'utf8', windowsHide: true, timeout: 1500, maxBuffer: 65536 };
+    const result = process.platform === 'win32' && provider === 'agy'
+        ? spawnSync(previous.command, { ...options, shell: process.env.ComSpec || 'cmd.exe' })
+        : spawnSync(executable, args, options);
+    return result.stdout || '';
+}
+export async function pipelineStatusline(providerName, input, home = os.homedir()) {
+    const provider = client(providerName), file = savedFile(home, provider);
+    const saved = fs.existsSync(file) ? readJSON(file) : null;
+    const prior = previousOutput(provider, home, input, saved?.previous);
+    if (saved?.active === false)
+        return prior;
+    const payload = JSON.parse(input);
+    const candidates = new Set([payload.workspace?.current_dir, payload.cwd].filter((p) => typeof p === 'string' && path.isAbsolute(p)));
+    const conversationId = payload.conversation_id || payload.session_id;
+    if (conversationId) {
+        const directory = path.join(bridgeHome(), 'sessions');
+        if (fs.existsSync(directory))
+            for (const name of fs.readdirSync(directory).filter(n => /^[0-9a-f-]{36}\.json$/i.test(n))) {
+                try {
+                    const s = readJSON(path.join(directory, name));
+                    if (s.conversationId === conversationId && s.workspaces?.length === 1)
+                        candidates.add(s.workspaces[0]);
+                }
+                catch { /* a partial record cannot establish scope */ }
+            }
+    }
+    let cwd;
+    for (const candidate of candidates) {
+        try {
+            repoKey(candidate);
+            cwd = candidate;
+            break;
+        }
+        catch { /* try an explicitly attached workspace */ }
+    }
+    const width = Math.max(20, Math.min(240, Number(payload.terminal_width || process.env.COLUMNS) || 100));
+    let line = 'axMap · 이 대화는 Git 저장소에 연결되지 않았습니다.';
+    if (cwd) {
+        const snapshot = await createMonitor(cwd, { probe: async () => [],
+            resolve: id => readJSON(path.join(bridgeHome(), 'requests', `${id}.json`)) })();
+        const active = snapshot.requests.find(r => ['sending', 'submitted', 'unknown'].includes(r.state));
+        const request = active || snapshot.requests[0];
+        const state = payload.tool_confirmation_pending ? '승인 필요' : { working: '작업 중', tool_use: '도구 실행', reviewing: '검토 중', idle: '대기', error: '오류', initializing: '시작 중', authenticating: '인증 중' }[payload.agent_state || ''];
+        const spin = ['◐', '◓', '◑', '◒'][Math.floor(Date.now() / 300) % 4];
+        const flow = !request ? '새 요청 대기' : request.state === 'completed' ? '접수 ✓ → 전달 ✓ → 응답 ✓ → 완료 ✓' : request.state === 'submitted'
+            ? `접수 ✓ → 전달 ✓ → ${spin} 응답 대기 → 완료 미확정` : request.state === 'sending' ? `${spin} 전달 중 → 응답 대기` : request.state === 'unknown' ? '전달 확인 필요 → 완료 미확정' : `${request.state} → 완료 미확정`;
+        line = `axMap${state ? ` · ${provider} ${state}` : ''} · ${!active && request ? '최근 요청 · ' : ''}${flow}`;
+        if (snapshot.issues.length)
+            line += ' · 기록 확인 필요';
+    }
+    return prior + (prior && !prior.endsWith('\n') ? '\n' : '') + fitTerminal(terminalText(line), width) + '\n';
+}