axmap-cli 1.6.0 → 1.8.0

package/src/managed-session.mjs

@@ -9,21 +9,26 @@ import { randomUUID, randomBytes, timingSafeEqual } from 'node:crypto';
 import { bridgeHome, repoKey, writeJSON } from './bridge.mjs';
 import { normalizeUsage, usageDelta } from './session-usage.mjs';
 import { errorMessage } from './session-types.mjs';
+import { connectCodexProxy } from './codex-connection.mjs';
 const pipeFor = (id) => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`);
 const uuid = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value || '');
-export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '', cwd = process.cwd(), maxTokens = 100000, timeoutMs = 120000, onEvent = () => { } }) {
+export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '', existingThreadId, socketPath, observeActive = false, cwd = process.cwd(), maxTokens = 100000, timeoutMs = 120000, onEvent = () => { } }) {
     if (!['codex', 'agy'].includes(provider))
         throw new Error('지원하는 세션은 codex 또는 agy입니다.');
     if (!Number.isSafeInteger(maxTokens) || maxTokens < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1)
         throw new Error('양의 토큰/시간 한도가 필요합니다.');
     if (typeof role !== 'string' || role.length > 1000)
         throw new Error('역할은 1000자 이하여야 합니다.');
+    if (existingThreadId && (provider !== 'codex' || !uuid(existingThreadId) || !socketPath || model || args))
+        throw new Error('기존 Codex thread와 로컬 socket이 필요하며 모델·실행 인수를 바꾸지 않습니다.');
     const id = randomUUID(), token = randomBytes(32).toString('hex');
     const sessionPath = path.join(bridgeHome(), 'sessions', `${id}.json`);
     const s = { id, token, provider, transport: 'stdio', role, model: model || null,
         workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false,
         registeredAt: new Date().toISOString(), usage: null, usageKnown: true, maxTokens };
     const jobs = new Map();
+    let attachedUsageOrigin = null;
+    let initialThreadState = 'idle';
     const calls = new Map();
     let child, sequence = 0, pending = null, closed = false, buffer = '', stderr = '', turnTimer;
     const save = () => { s.registeredAt = new Date().toISOString(); writeJSON(sessionPath, s); };
@@ -55,8 +60,11 @@ export async function startManagedSession({ provider, executable = provider, pre
             completedAt: new Date().toISOString(), conversationId: s.conversationId });
         delete pending.baseline;
         delete pending.baselineKnown;
-        if (usage)
+        if (usage) {
             s.usage = usage;
+            if (existingThreadId && !attachedUsageOrigin)
+                attachedUsageOrigin = usage;
+        }
         s.usageKnown = usage !== null;
         emit({ event: 'result', request: { ...pending } });
         pending = null;
@@ -83,11 +91,20 @@ export async function startManagedSession({ provider, executable = provider, pre
         child?.kill();
         server.close();
     };
-    const handle = (message) => {
+    let checkingSubmission = false;
+    const handle = async (message) => {
         const offered = Buffer.from(typeof message.token === 'string' ? message.token : '');
         const expected = Buffer.from(token);
         if (offered.length !== expected.length || !timingSafeEqual(offered, expected))
             throw new Error('로컬 세션 인증 실패');
+        if (message.action === 'notice') {
+            if (!existingThreadId || provider !== 'codex' || typeof message.text !== 'string' || !message.text.trim() || Buffer.byteLength(message.text) > 8192)
+                throw new Error('기존 Codex 대화에 1~8192바이트 안내만 기록할 수 있습니다.');
+            const noticeId = randomUUID();
+            await rpc('thread/inject_items', { threadId: existingThreadId, items: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: `[axMap notice ${noticeId}; context only, no new model turn]\n${message.text}` }] }] });
+            writeJSON(path.join(bridgeHome(), 'notices', `${noticeId}.json`), { id: noticeId, to: id, conversationId: existingThreadId, repo: repoKey(cwd), text: message.text, createdAt: new Date().toISOString(), state: 'context_recorded', modelInvoked: false });
+            return { noticeId, conversationId: existingThreadId, state: 'context_recorded', modelInvoked: false };
+        }
         if (message.action === 'status')
             return { id, state: s.state, usage: s.usage, pendingApproval: s.pendingApproval };
         if (message.action === 'result') {
@@ -111,16 +128,31 @@ export async function startManagedSession({ provider, executable = provider, pre
         }
         if (message.action !== 'submit')
             throw new Error('지원하지 않는 로컬 세션 요청입니다.');
+        if (jobs.has(message.request?.id))
+            throw new Error('이미 접수한 요청 ID입니다. 다시 전송하지 않았습니다.');
         if (closed || s.state !== 'idle' || pending)
             throw new Error('세션이 대기 중이 아닙니다. 요청을 전달하지 않았습니다.');
+        if (existingThreadId) {
+            if (checkingSubmission)
+                throw new Error('다른 요청의 상태를 확인 중입니다.');
+            checkingSubmission = true;
+            try {
+                const read = await rpc('thread/read', { threadId: existingThreadId });
+                if (closed || pending || read.thread.id !== existingThreadId || read.thread.status.type !== 'idle')
+                    throw new Error('기존 대화가 다른 작업 중입니다. 새 요청을 전달하지 않았습니다.');
+            }
+            finally {
+                checkingSubmission = false;
+            }
+        }
         if (!s.usageKnown)
             throw new Error('직전 요청의 사용량을 확인하지 못했습니다. 새 연결에서 예산을 확인하세요.');
-        if (s.usage && s.usage.totalTokens >= maxTokens)
+        if (s.usage && s.usage.totalTokens - (existingThreadId ? attachedUsageOrigin?.totalTokens ?? s.usage.totalTokens : 0) >= maxTokens)
             throw new Error('세션 토큰 한도에 도달했습니다.');
         const request = message.request;
         if (!uuid(request?.id) || request.to !== id || typeof request.prompt !== 'string' || !request.prompt.trim() || Buffer.byteLength(request.prompt) > 32768)
             throw new Error('요청 형식이 올바르지 않습니다.');
-        pending = { id: request.id, to: id, state: 'submitted', baseline: s.usage, baselineKnown: s.usageKnown, result: '' };
+        pending = { id: request.id, to: id, state: 'submitted', baseline: s.usage, baselineKnown: s.usageKnown && (!existingThreadId || !!s.usage), result: '' };
         jobs.set(request.id, pending);
         s.state = 'running';
         s.fullyIdle = false;
@@ -130,7 +162,7 @@ export async function startManagedSession({ provider, executable = provider, pre
         if (provider === 'agy')
             write({ event: 'user', message: { content: prompt } });
         else
-            rpc('turn/start', { threadId: s.conversationId, input: [{ type: 'text', text: prompt }], effort: 'low' })
+            rpc('turn/start', { threadId: s.conversationId, input: [{ type: 'text', text: prompt }], ...(!existingThreadId ? { effort: 'low' } : {}) })
                 .then(r => { if (pending?.id === request.id)
                 pending.turnId = r.turn.id; })
                 .catch(e => shutdown(e.message));
@@ -152,7 +184,7 @@ export async function startManagedSession({ provider, executable = provider, pre
                 return;
             handled = true;
             try {
-                socket.end(JSON.stringify({ result: handle(JSON.parse(input.slice(0, end))) }) + '\n');
+                void handle(JSON.parse(input.slice(0, end))).then(result => socket.end(JSON.stringify({ result }) + '\n'), e => socket.end(JSON.stringify({ error: errorMessage(e) }) + '\n'));
             }
             catch (e) {
                 socket.end(JSON.stringify({ error: errorMessage(e) }) + '\n');
@@ -166,7 +198,7 @@ export async function startManagedSession({ provider, executable = provider, pre
     save();
     const cliArgs = args || (provider === 'codex' ? ['app-server', '--stdio']
         : ['--input-format', 'stream-json', '--output-format', 'stream-json', '--disable-slash-commands', '--effort', 'low', ...(model ? ['--model', model] : [])]);
-    child = spawn(executable, [...prefix, ...cliArgs], { cwd, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
+    child = existingThreadId ? connectCodexProxy({ executable, prefix, socketPath: socketPath, cwd }) : spawn(executable, [...prefix, ...cliArgs], { cwd, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
         env: { ...process.env, AXMAP_AGENT: `${provider}-${id.slice(0, 8)}`, AXMAP_SESSION: id } });
     child.stdin.on('error', e => shutdown(e.message));
     const exited = new Promise(resolve => {
@@ -175,6 +207,7 @@ export async function startManagedSession({ provider, executable = provider, pre
     });
     child.stderr.on('data', chunk => { stderr = (stderr + chunk.toString('utf8')).slice(-8192); });
     child.stdout.setEncoding('utf8');
+    child.stdout.on('error', e => shutdown(e.message));
     child.stdout.on('data', chunk => {
         buffer += chunk;
         if (Buffer.byteLength(buffer) > 4 * 1024 * 1024)
@@ -225,8 +258,24 @@ export async function startManagedSession({ provider, executable = provider, pre
                 }
                 if (m.params?.threadId !== s.conversationId)
                     continue;
-                if (m.method === 'thread/tokenUsage/updated' && pending)
-                    pending.rawUsage = m.params?.tokenUsage?.total;
+                if (m.method === 'thread/status/changed' && !pending) {
+                    const status = m.params?.status;
+                    s.state = status?.type === 'active' ? 'running' : status?.type === 'idle' ? 'idle' : 'unknown';
+                    s.fullyIdle = s.state === 'idle';
+                    save();
+                }
+                if (m.method === 'thread/tokenUsage/updated') {
+                    if (pending)
+                        pending.rawUsage = m.params?.tokenUsage?.total;
+                    else {
+                        const usage = normalizeUsage(provider, m.params?.tokenUsage?.total);
+                        if (usage) {
+                            s.usage = usage;
+                            s.usageKnown = true;
+                            save();
+                        }
+                    }
+                }
                 if (m.method === 'item/completed' && pending && m.params?.item?.type === 'agentMessage')
                     pending.result = m.params.item.text;
                 if (m.method === 'turn/completed' && pending) {
@@ -247,12 +296,25 @@ export async function startManagedSession({ provider, executable = provider, pre
         if (provider === 'codex') {
             await rpc('initialize', { clientInfo: { name: 'axmap', version: '1' } });
             write({ method: 'initialized' });
-            const r = await rpc('thread/start', { cwd: path.resolve(cwd), ...(model ? { model } : {}),
-                sandbox: 'read-only', approvalPolicy: 'on-request' });
+            if (existingThreadId) {
+                const read = await rpc('thread/read', { threadId: existingThreadId });
+                initialThreadState = read.thread.status.type;
+                if (read.thread.id !== existingThreadId || (initialThreadState !== 'idle' && !(observeActive && initialThreadState === 'active')))
+                    throw new Error('기존 thread가 idle 상태가 아닙니다. 전송하거나 새 대화를 만들지 않았습니다.');
+                // Parent workspace sessions can explicitly join a child Git repo. Never attach across unrelated roots.
+                const relative = path.relative(path.resolve(read.thread.cwd), path.resolve(cwd));
+                if (relative.startsWith('..') || path.isAbsolute(relative))
+                    throw new Error('기존 thread와 요청 저장소 경로가 다릅니다.');
+            }
+            const r = await rpc(existingThreadId ? 'thread/resume' : 'thread/start', existingThreadId
+                ? { threadId: existingThreadId, excludeTurns: true }
+                : { cwd: path.resolve(cwd), ...(model ? { model } : {}), sandbox: 'read-only', approvalPolicy: 'on-request' });
+            if (existingThreadId && r.thread.id !== existingThreadId)
+                throw new Error('기존 thread ID가 바뀌었습니다.');
             s.conversationId = r.thread.id;
             s.model = r.model || model || null;
-            s.state = 'idle';
-            s.fullyIdle = true;
+            s.state = initialThreadState === 'active' ? 'running' : 'idle';
+            s.fullyIdle = s.state === 'idle';
             save();
             emit({ event: 'ready', conversationId: s.conversationId });
         }

package/src/managed-session.mts

@@ -8,12 +8,17 @@ import { randomUUID, randomBytes, timingSafeEqual } from 'node:crypto'
 import { bridgeHome, repoKey, writeJSON } from './bridge.mjs'
 import { normalizeUsage, usageDelta } from './session-usage.mjs'
 import { errorMessage } from './session-types.mjs'
+import { connectCodexProxy } from './codex-connection.mjs'
+import type { ProviderProcess } from './codex-connection.mjs'
 import type { ChildProcessWithoutNullStreams } from 'node:child_process'
 import type { Provider, SessionRecord, RequestState, LocalMessage, JobRecord } from './session-types.mjs'
+import type { Usage } from './session-types.mjs'
 
 interface ManagedSessionOptions {
   provider: Provider; executable?: string; prefix?: string[]; args?: string[] | null; model?: string; role?: string
   cwd?: string; maxTokens?: number; timeoutMs?: number; onEvent?: (event: Record<string, unknown>) => void
+  existingThreadId?: string; socketPath?: string
+  observeActive?: boolean
 }
 interface ProviderMessage {
   id?: string | number; method?: string; event?: string; conversation_id?: string
@@ -29,19 +34,22 @@ interface AgyResult { conversation_id: string; status: string; response?: unknow
 const pipeFor = (id: string) => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`)
 const uuid = (value: string | undefined) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value || '')
 
-export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '',
+export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '', existingThreadId, socketPath, observeActive = false,
   cwd = process.cwd(), maxTokens = 100000, timeoutMs = 120000, onEvent = () => {} }: ManagedSessionOptions) {
   if (!['codex', 'agy'].includes(provider)) throw new Error('지원하는 세션은 codex 또는 agy입니다.')
   if (!Number.isSafeInteger(maxTokens) || maxTokens < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new Error('양의 토큰/시간 한도가 필요합니다.')
   if (typeof role !== 'string' || role.length > 1000) throw new Error('역할은 1000자 이하여야 합니다.')
+  if (existingThreadId && (provider !== 'codex' || !uuid(existingThreadId) || !socketPath || model || args)) throw new Error('기존 Codex thread와 로컬 socket이 필요하며 모델·실행 인수를 바꾸지 않습니다.')
   const id = randomUUID(), token = randomBytes(32).toString('hex')
   const sessionPath = path.join(bridgeHome(), 'sessions', `${id}.json`)
   const s: SessionRecord = { id, token, provider, transport: 'stdio', role, model: model || null,
     workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false,
     registeredAt: new Date().toISOString(), usage: null, usageKnown: true, maxTokens }
   const jobs = new Map<string, JobRecord>()
+  let attachedUsageOrigin: Usage | null = null
+  let initialThreadState = 'idle'
   const calls = new Map<string | number, { resolve: (result: unknown) => void; reject: (reason: Error) => void; timer: NodeJS.Timeout }>()
-  let child: ChildProcessWithoutNullStreams | undefined, sequence = 0, pending: JobRecord | null = null, closed = false, buffer = '', stderr = '', turnTimer: NodeJS.Timeout | undefined
+  let child: ProviderProcess | undefined, sequence = 0, pending: JobRecord | null = null, closed = false, buffer = '', stderr = '', turnTimer: NodeJS.Timeout | undefined
   const save = () => { s.registeredAt = new Date().toISOString(); writeJSON(sessionPath, s) }
   const emit = (event: Record<string, unknown>) => onEvent({ session: id, ...event })
   const write = (message: unknown) => {
@@ -62,7 +70,7 @@ export async function startManagedSession({ provider, executable = provider, pre
       completedAt: new Date().toISOString(), conversationId: s.conversationId })
     delete pending.baseline
     delete pending.baselineKnown
-    if (usage) s.usage = usage
+    if (usage) { s.usage = usage; if (existingThreadId && !attachedUsageOrigin) attachedUsageOrigin = usage }
     s.usageKnown = usage !== null
     emit({ event: 'result', request: { ...pending } })
     pending = null; s.state = 'idle'; s.fullyIdle = true; delete s.pendingApproval; save()
@@ -76,10 +84,18 @@ export async function startManagedSession({ provider, executable = provider, pre
     s.state = 'closed'; s.fullyIdle = false; save()
     child?.stdin.destroy(); child?.kill(); server.close()
   }
-  const handle = (message: LocalMessage) => {
+  let checkingSubmission = false
+  const handle = async (message: LocalMessage) => {
     const offered = Buffer.from(typeof message.token === 'string' ? message.token : '')
     const expected = Buffer.from(token)
     if (offered.length !== expected.length || !timingSafeEqual(offered, expected)) throw new Error('로컬 세션 인증 실패')
+    if (message.action === 'notice') {
+      if (!existingThreadId || provider !== 'codex' || typeof message.text !== 'string' || !message.text.trim() || Buffer.byteLength(message.text) > 8192) throw new Error('기존 Codex 대화에 1~8192바이트 안내만 기록할 수 있습니다.')
+      const noticeId = randomUUID()
+      await rpc('thread/inject_items', { threadId: existingThreadId, items: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: `[axMap notice ${noticeId}; context only, no new model turn]\n${message.text}` }] }] })
+      writeJSON(path.join(bridgeHome(), 'notices', `${noticeId}.json`), { id: noticeId, to: id, conversationId: existingThreadId, repo: repoKey(cwd), text: message.text, createdAt: new Date().toISOString(), state: 'context_recorded', modelInvoked: false })
+      return { noticeId, conversationId: existingThreadId, state: 'context_recorded', modelInvoked: false }
+    }
     if (message.action === 'status') return { id, state: s.state, usage: s.usage, pendingApproval: s.pendingApproval }
     if (message.action === 'result') {
       const result = jobs.get(message.id)
@@ -95,17 +111,26 @@ export async function startManagedSession({ provider, executable = provider, pre
       delete s.pendingApproval; s.state = 'running'; save(); return { answered: true }
     }
     if (message.action !== 'submit') throw new Error('지원하지 않는 로컬 세션 요청입니다.')
+    if (jobs.has(message.request?.id)) throw new Error('이미 접수한 요청 ID입니다. 다시 전송하지 않았습니다.')
     if (closed || s.state !== 'idle' || pending) throw new Error('세션이 대기 중이 아닙니다. 요청을 전달하지 않았습니다.')
+    if (existingThreadId) {
+      if (checkingSubmission) throw new Error('다른 요청의 상태를 확인 중입니다.')
+      checkingSubmission = true
+      try {
+        const read = await rpc<{ thread: { id: string; status: { type: string } } }>('thread/read', { threadId: existingThreadId })
+        if (closed || pending || read.thread.id !== existingThreadId || read.thread.status.type !== 'idle') throw new Error('기존 대화가 다른 작업 중입니다. 새 요청을 전달하지 않았습니다.')
+      } finally { checkingSubmission = false }
+    }
     if (!s.usageKnown) throw new Error('직전 요청의 사용량을 확인하지 못했습니다. 새 연결에서 예산을 확인하세요.')
-    if (s.usage && s.usage.totalTokens >= maxTokens) throw new Error('세션 토큰 한도에 도달했습니다.')
+    if (s.usage && s.usage.totalTokens - (existingThreadId ? attachedUsageOrigin?.totalTokens ?? s.usage.totalTokens : 0) >= maxTokens) throw new Error('세션 토큰 한도에 도달했습니다.')
     const request = message.request
     if (!uuid(request?.id) || request.to !== id || typeof request.prompt !== 'string' || !request.prompt.trim() || Buffer.byteLength(request.prompt) > 32768) throw new Error('요청 형식이 올바르지 않습니다.')
-    pending = { id: request.id, to: id, state: 'submitted', baseline: s.usage, baselineKnown: s.usageKnown, result: '' }
+    pending = { id: request.id, to: id, state: 'submitted', baseline: s.usage, baselineKnown: s.usageKnown && (!existingThreadId || !!s.usage), result: '' }
     jobs.set(request.id, pending); s.state = 'running'; s.fullyIdle = false; save()
     const prompt = `[axMap request ${request.id}]\n요청자: ${request.from || 'axmap'}\n${role ? `역할: ${role}\n` : ''}${request.prompt}`
     turnTimer = setTimeout(() => shutdown('실행 시간 한도 초과. 완료 여부가 불명확하므로 자동 재시도하지 않습니다.'), timeoutMs)
     if (provider === 'agy') write({ event: 'user', message: { content: prompt } })
-    else rpc<{ turn: { id: string } }>('turn/start', { threadId: s.conversationId, input: [{ type: 'text', text: prompt }], effort: 'low' })
+    else rpc<{ turn: { id: string } }>('turn/start', { threadId: s.conversationId, input: [{ type: 'text', text: prompt }], ...(!existingThreadId ? { effort: 'low' } : {}) })
       .then(r => { if (pending?.id === request.id) pending.turnId = r.turn.id })
       .catch(e => shutdown(e.message))
     return { accepted: true, session: id }
@@ -120,7 +145,7 @@ export async function startManagedSession({ provider, executable = provider, pre
       if (Buffer.byteLength(input) > 65536) return socket.destroy()
       const end = input.indexOf('\n'); if (end < 0) return
       handled = true
-      try { socket.end(JSON.stringify({ result: handle(JSON.parse(input.slice(0, end))) }) + '\n') }
+      try { void handle(JSON.parse(input.slice(0, end))).then(result => socket.end(JSON.stringify({ result }) + '\n'), e => socket.end(JSON.stringify({ error: errorMessage(e) }) + '\n')) }
       catch (e) { socket.end(JSON.stringify({ error: errorMessage(e) }) + '\n') }
     })
   })
@@ -130,7 +155,7 @@ export async function startManagedSession({ provider, executable = provider, pre
   save()
   const cliArgs = args || (provider === 'codex' ? ['app-server', '--stdio']
     : ['--input-format', 'stream-json', '--output-format', 'stream-json', '--disable-slash-commands', '--effort', 'low', ...(model ? ['--model', model] : [])])
-  child = spawn(executable, [...prefix, ...cliArgs], { cwd, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
+  child = existingThreadId ? connectCodexProxy({ executable, prefix, socketPath: socketPath!, cwd }) : spawn(executable, [...prefix, ...cliArgs], { cwd, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
     env: { ...process.env, AXMAP_AGENT: `${provider}-${id.slice(0, 8)}`, AXMAP_SESSION: id } })
   child.stdin.on('error', e => shutdown(e.message))
   const exited = new Promise<{ code: number | null; signal?: NodeJS.Signals | null; error?: string }>(resolve => {
@@ -139,6 +164,7 @@ export async function startManagedSession({ provider, executable = provider, pre
   })
   child.stderr.on('data', chunk => { stderr = (stderr + chunk.toString('utf8')).slice(-8192) })
   child.stdout.setEncoding('utf8')
+  child.stdout.on('error', e => shutdown(e.message))
   child.stdout.on('data', chunk => {
     buffer += chunk
     if (Buffer.byteLength(buffer) > 4 * 1024 * 1024) return shutdown('CLI 응답 크기 제한 초과')
@@ -169,7 +195,15 @@ export async function startManagedSession({ provider, executable = provider, pre
           continue
         }
         if (m.params?.threadId !== s.conversationId) continue
-        if (m.method === 'thread/tokenUsage/updated' && pending) pending.rawUsage = m.params?.tokenUsage?.total
+        if (m.method === 'thread/status/changed' && !pending) {
+          const status = m.params?.status as { type?: string } | undefined
+          s.state = status?.type === 'active' ? 'running' : status?.type === 'idle' ? 'idle' : 'unknown'
+          s.fullyIdle = s.state === 'idle'; save()
+        }
+        if (m.method === 'thread/tokenUsage/updated') {
+          if (pending) pending.rawUsage = m.params?.tokenUsage?.total
+          else { const usage = normalizeUsage(provider, m.params?.tokenUsage?.total); if (usage) { s.usage = usage; s.usageKnown = true; save() } }
+        }
         if (m.method === 'item/completed' && pending && m.params?.item?.type === 'agentMessage') pending.result = m.params.item.text
         if (m.method === 'turn/completed' && pending) {
           const r = m.params?.turn
@@ -184,9 +218,19 @@ export async function startManagedSession({ provider, executable = provider, pre
     if (provider === 'codex') {
       await rpc('initialize', { clientInfo: { name: 'axmap', version: '1' } })
       write({ method: 'initialized' })
-      const r = await rpc<{ thread: { id: string }; model?: string }>('thread/start', { cwd: path.resolve(cwd), ...(model ? { model } : {}),
-        sandbox: 'read-only', approvalPolicy: 'on-request' })
-      s.conversationId = r.thread.id; s.model = r.model || model || null; s.state = 'idle'; s.fullyIdle = true; save()
+      if (existingThreadId) {
+        const read = await rpc<{ thread: { id: string; cwd: string; status: { type: string } } }>('thread/read', { threadId: existingThreadId })
+        initialThreadState = read.thread.status.type
+        if (read.thread.id !== existingThreadId || (initialThreadState !== 'idle' && !(observeActive && initialThreadState === 'active'))) throw new Error('기존 thread가 idle 상태가 아닙니다. 전송하거나 새 대화를 만들지 않았습니다.')
+        // Parent workspace sessions can explicitly join a child Git repo. Never attach across unrelated roots.
+        const relative = path.relative(path.resolve(read.thread.cwd), path.resolve(cwd))
+        if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('기존 thread와 요청 저장소 경로가 다릅니다.')
+      }
+      const r = await rpc<{ thread: { id: string }; model?: string }>(existingThreadId ? 'thread/resume' : 'thread/start', existingThreadId
+        ? { threadId: existingThreadId, excludeTurns: true }
+        : { cwd: path.resolve(cwd), ...(model ? { model } : {}), sandbox: 'read-only', approvalPolicy: 'on-request' })
+      if (existingThreadId && r.thread.id !== existingThreadId) throw new Error('기존 thread ID가 바뀌었습니다.')
+      s.conversationId = r.thread.id; s.model = r.model || model || null; s.state = initialThreadState === 'active' ? 'running' : 'idle'; s.fullyIdle = s.state === 'idle'; save()
       emit({ event: 'ready', conversationId: s.conversationId })
     } else {
       const deadline = Date.now() + 30000

package/src/monitor-cli.mjs

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

package/src/monitor-cli.mts

@@ -2,13 +2,15 @@ import path from 'node:path'
 import { createMonitor, renderMonitor } from './monitor.mjs'
 import type { MonitorSnapshot } from './monitor.mjs'
 import { errorMessage } from './session-types.mjs'
+import { renderPipelineGraph } from './pipeline-graph.mjs'
+import { createView, renderView } from './view.mjs'
 
 export async function runMonitor(args: string[]): Promise<void> {
   if (args.includes('--help') || args.includes('-h')) {
     console.log('axmap monitor [--cwd <repo>] [--interval 1000] [--once | --json] [--no-color]\n세션·요청 파이프라인·자동 대화·선점·최근 이벤트를 실시간으로 표시합니다.\nTTY에서는 계속 갱신하며, 파이프/리디렉션에서는 한 번만 출력합니다. q / Esc / Ctrl+C 종료.')
     return
   }
-  const allowed = new Set(['--cwd', '--interval', '--once', '--json', '--no-color'])
+  const allowed = new Set(['--cwd', '--interval', '--once', '--json', '--no-color', '--graph', '--view'])
   for (let i = 0; i < args.length; i++) {
     if (!allowed.has(args[i]!)) throw new Error(`알 수 없는 옵션: ${args[i]}`)
     if (args[i] === '--cwd' || args[i] === '--interval') {
@@ -19,12 +21,14 @@ export async function runMonitor(args: string[]): Promise<void> {
   const option = (name: string) => { const index = args.indexOf(name); return index < 0 ? undefined : args[index + 1] }
   const interval = Number(option('--interval') || 1000)
   if (!Number.isInteger(interval) || interval < 250 || interval > 60000) throw new Error('interval은 250~60000ms 정수여야 합니다.')
-  const collect = createMonitor(path.resolve(option('--cwd') || process.cwd()))
+  const cwd = path.resolve(option('--cwd') || process.cwd())
+  const collect = args.includes('--view') ? createView(cwd) : createMonitor(cwd)
+  const render = args.includes('--view') ? renderView : args.includes('--graph') ? renderPipelineGraph : renderMonitor
   const live = !!process.stdout.isTTY && !!process.stdin.isTTY && process.env.TERM !== 'dumb' && !args.includes('--once') && !args.includes('--json')
   const color = !!process.stdout.isTTY && !args.includes('--no-color') && process.env.NO_COLOR === undefined && process.env.TERM !== 'dumb'
   if (!live) {
     const snapshot = await collect()
-    console.log(args.includes('--json') ? JSON.stringify(snapshot, null, 2) : renderMonitor(snapshot, { columns: process.stdout.columns || 100, rows: process.stdout.rows || 40, color }))
+    console.log(args.includes('--json') ? JSON.stringify(snapshot, null, 2) : render(snapshot, { columns: process.stdout.columns || 100, rows: process.stdout.rows || 56, color }))
     return
   }
   let stopped = false, frame = 0, timer: NodeJS.Timeout | undefined, animation: NodeJS.Timeout | undefined
@@ -42,7 +46,7 @@ export async function runMonitor(args: string[]): Promise<void> {
     const input = (text: string) => { if (text === '\x1b' || text.includes('\x03') || /^[qQ]+$/.test(text)) restore() }
     const draw = () => {
       if (stopped || !latest) return
-      const view = renderMonitor(latest, { columns: process.stdout.columns || 100, rows: Math.max(1, (process.stdout.rows || 36) - 1), color, frame: frame++ })
+      const view = render(latest, { columns: process.stdout.columns || 100, rows: Math.max(1, (process.stdout.rows || 36) - 1), color, frame: frame++ })
       process.stdout.write('\x1b[H' + view.replaceAll('\n', '\x1b[K\r\n') + '\x1b[K\x1b[J')
     }
     const update = async () => {

package/src/monitor.mjs

@@ -55,6 +55,11 @@ export function createMonitor(cwd, options = {}) {
             issues.push(`세션 확인: ${errorMessage(e)}`);
         }
         const requests = [];
+        for (const raw of records(path.join(bridgeHome(), 'notices'), issues, '안내')) {
+            if (!object(raw) || raw.repo !== repo || typeof raw.id !== 'string' || typeof raw.to !== 'string' || typeof raw.createdAt !== 'string' || !Number.isFinite(Date.parse(raw.createdAt)))
+                continue;
+            event(`notice:${raw.id}`, raw.createdAt, `문맥 안내 기록 · ${raw.to.slice(0, 8)} · 모델 턴 없음`, 'success');
+        }
         for (const raw of records(path.join(bridgeHome(), 'requests'), issues, '요청')) {
             if (!object(raw) || raw.repo !== repo)
                 continue;

package/src/monitor.mts

@@ -50,6 +50,10 @@ export function createMonitor(cwd: string, options: {
     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(), 'notices'), issues, '안내')) {
+      if (!object(raw) || raw.repo !== repo || typeof raw.id !== 'string' || typeof raw.to !== 'string' || typeof raw.createdAt !== 'string' || !Number.isFinite(Date.parse(raw.createdAt))) continue
+      event(`notice:${raw.id}`, raw.createdAt, `문맥 안내 기록 · ${raw.to.slice(0, 8)} · 모델 턴 없음`, 'success')
+    }
     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 }

package/src/pipeline-graph.mjs

@@ -0,0 +1,55 @@
+// Generated from src/pipeline-graph.mts. Edit the .mts source and run npm run build.
+/** Terminal topology, rendered from observations rather than fabricated progress. */
+import { terminalText, fitTerminal } from './monitor.mjs';
+export function renderPipelineGraph(snapshot, { columns = 110, rows = 42, color = false, frame = 0 } = {}) {
+    const width = Math.max(20, columns), lines = [];
+    const put = (text) => lines.push(fitTerminal(text, width));
+    const cell = (text) => [...text].reduce((v, c) => v + (c.codePointAt(0) >= 0x2e80 ? 2 : 1), 0);
+    const card = (title, details, inner = 42) => {
+        const n = Math.min(inner, width - 4);
+        const output = [`┌${'─'.repeat(n)}┐`];
+        for (const text of [title, ...details]) {
+            const s = fitTerminal(text, n - 2);
+            output.push(`│ ${s}${' '.repeat(Math.max(0, n - 1 - cell(s)))}│`);
+        }
+        output.push(`└${'─'.repeat(n)}┘`);
+        return output;
+    };
+    put('axMap /pipeline · LOCAL SESSION MAP');
+    put(snapshot.cwd);
+    put(`관측 ${snapshot.checkedAt} · 실제 이벤트만 표시`);
+    lines.push(...card('axMap · 로컬 메시지 라우터', ['요청 ID · 기존 대화 유지 · Git 왕복 없음']));
+    const labels = { idle: '대기', running: '실행 중', closed: '종료', awaiting_user: '사용자 승인 대기', unknown: '연결/상태 미확인', starting: '연결 중', settling: '대기 전환 중' };
+    const sessions = [...snapshot.sessions].sort((a, b) => Number(b.connection === 'connected') - Number(a.connection === 'connected')).slice(0, 6);
+    const count = width >= 105 ? 3 : width >= 70 ? 2 : 1;
+    const inner = Math.floor((width - (count - 1) * 2) / count) - 2;
+    const cards = [];
+    for (const s of sessions) {
+        const active = snapshot.requests.filter(r => r.to === s.id && ['sending', 'submitted'].includes(r.state));
+        const moving = active.length && s.connection === 'connected';
+        const link = `${moving ? ['●─────↓', '──●───↓', '────●─↓'][frame % 3] : '──────┤'} ${active.length ? `${active.length}건 응답 대기` : '전달 중인 요청 없음'}`;
+        const token = s.usage?.totalTokens == null ? '토큰 미측정' : `누적 처리 ${s.usage.totalTokens.toLocaleString()} tokens`;
+        cards.push([fitTerminal(link, inner + 2), ...card(`${s.provider.toUpperCase()} · ${s.role || s.id.slice(0, 8)}`, [`${labels[s.state] || s.state} · ${s.connection}`, `${s.model || '모델 미확인'} · ${s.transport || '연결 방식 미확인'}`, token], inner)]);
+    }
+    for (let at = 0; at < cards.length; at += count) {
+        const row = cards.slice(at, at + count);
+        for (let line = 0; line < row[0].length; line++)
+            lines.push(row.map(c => { const text = c[line] || ''; return text + ' '.repeat(Math.max(0, inner + 2 - cell(text))); }).join('  ').trimEnd());
+    }
+    if (!sessions.length)
+        put('등록된 세션 없음 · bridge connect / serve로 연결');
+    put('── 요청 · 응답 ──');
+    for (const r of snapshot.requests.slice(0, 4)) {
+        const elapsed = r.completedAt ? `${((Date.parse(r.completedAt) - Date.parse(r.createdAt)) / 1000).toFixed(2)}s` : '완료 미확정';
+        put(`${terminalText(r.from)} → ${r.to.slice(0, 8)} · ${r.state} · ${elapsed}`);
+        put(`  ${r.id.slice(0, 8)} · ${terminalText(r.prompt)}`);
+    }
+    put(`── 선점 ${snapshot.claims.length}건 · 최근 이벤트 ──`);
+    for (const e of snapshot.events.slice(0, 3))
+        put(`${e.at.slice(11, 19)} ${terminalText(e.label)}`);
+    for (const issue of snapshot.issues.slice(0, 2))
+        put(`확인 필요: ${terminalText(issue)}`);
+    put('q / Esc 종료 · 화면 종료는 작업 취소가 아님');
+    const view = lines.slice(0, Math.max(1, rows)).join('\n');
+    return color ? `\x1b[36m${view}\x1b[0m` : view;
+}

package/src/pipeline-graph.mts

@@ -0,0 +1,51 @@
+/** Terminal topology, rendered from observations rather than fabricated progress. */
+import { terminalText, fitTerminal } from './monitor.mjs'
+import type { MonitorSnapshot } from './monitor.mjs'
+export function renderPipelineGraph(snapshot: MonitorSnapshot, { columns = 110, rows = 42, color = false, frame = 0 } = {}): string {
+  const width = Math.max(20, columns), lines: string[] = []
+  const put = (text: string) => lines.push(fitTerminal(text, width))
+  const cell = (text: string) => [...text].reduce((v, c) => v + (c.codePointAt(0)! >= 0x2e80 ? 2 : 1), 0)
+  const card = (title: string, details: string[], inner = 42): string[] => {
+    const n = Math.min(inner, width - 4)
+    const output = [`┌${'─'.repeat(n)}┐`]
+    for (const text of [title, ...details]) {
+      const s = fitTerminal(text, n - 2)
+      output.push(`│ ${s}${' '.repeat(Math.max(0, n - 1 - cell(s)))}│`)
+    }
+    output.push(`└${'─'.repeat(n)}┘`)
+    return output
+  }
+  put('axMap /pipeline · LOCAL SESSION MAP')
+  put(snapshot.cwd)
+  put(`관측 ${snapshot.checkedAt} · 실제 이벤트만 표시`)
+  lines.push(...card('axMap · 로컬 메시지 라우터', ['요청 ID · 기존 대화 유지 · Git 왕복 없음']))
+  const labels: Record<string, string> = { idle: '대기', running: '실행 중', closed: '종료', awaiting_user: '사용자 승인 대기', unknown: '연결/상태 미확인', starting: '연결 중', settling: '대기 전환 중' }
+  const sessions = [...snapshot.sessions].sort((a, b) => Number(b.connection === 'connected') - Number(a.connection === 'connected')).slice(0, 6)
+  const count = width >= 105 ? 3 : width >= 70 ? 2 : 1
+  const inner = Math.floor((width - (count - 1) * 2) / count) - 2
+  const cards: string[][] = []
+  for (const s of sessions) {
+    const active = snapshot.requests.filter(r => r.to === s.id && ['sending', 'submitted'].includes(r.state))
+    const moving = active.length && s.connection === 'connected'
+    const link = `${moving ? ['●─────↓', '──●───↓', '────●─↓'][frame % 3] : '──────┤'} ${active.length ? `${active.length}건 응답 대기` : '전달 중인 요청 없음'}`
+    const token = s.usage?.totalTokens == null ? '토큰 미측정' : `누적 처리 ${s.usage.totalTokens.toLocaleString()} tokens`
+    cards.push([fitTerminal(link, inner + 2), ...card(`${s.provider.toUpperCase()} · ${s.role || s.id.slice(0, 8)}`, [`${labels[s.state] || s.state} · ${s.connection}`, `${s.model || '모델 미확인'} · ${s.transport || '연결 방식 미확인'}`, token], inner)])
+  }
+  for (let at = 0; at < cards.length; at += count) {
+    const row = cards.slice(at, at + count)
+    for (let line = 0; line < row[0]!.length; line++) lines.push(row.map(c => { const text = c[line] || ''; return text + ' '.repeat(Math.max(0, inner + 2 - cell(text))) }).join('  ').trimEnd())
+  }
+  if (!sessions.length) put('등록된 세션 없음 · bridge connect / serve로 연결')
+  put('── 요청 · 응답 ──')
+  for (const r of snapshot.requests.slice(0, 4)) {
+    const elapsed = r.completedAt ? `${((Date.parse(r.completedAt) - Date.parse(r.createdAt)) / 1000).toFixed(2)}s` : '완료 미확정'
+    put(`${terminalText(r.from)} → ${r.to.slice(0, 8)} · ${r.state} · ${elapsed}`)
+    put(`  ${r.id.slice(0, 8)} · ${terminalText(r.prompt)}`)
+  }
+  put(`── 선점 ${snapshot.claims.length}건 · 최근 이벤트 ──`)
+  for (const e of snapshot.events.slice(0, 3)) put(`${e.at.slice(11, 19)} ${terminalText(e.label)}`)
+  for (const issue of snapshot.issues.slice(0, 2)) put(`확인 필요: ${terminalText(issue)}`)
+  put('q / Esc 종료 · 화면 종료는 작업 취소가 아님')
+  const view = lines.slice(0, Math.max(1, rows)).join('\n')
+  return color ? `\x1b[36m${view}\x1b[0m` : view
+}

package/src/pipeline-mcp.mjs

@@ -8,9 +8,11 @@ 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,
+            model: s.model ?? null, transport: s.transport ?? null, conversationId: s.conversationId ?? null,
             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) })),
+            task: fitTerminal(r.prompt, 200), createdAt: r.createdAt, completedAt: r.completedAt, usage: r.usage ?? null,
+            latencyMs: r.completedAt ? Math.max(0, Date.parse(r.completedAt) - Date.parse(r.createdAt)) : null, 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),

package/src/pipeline-mcp.mts

@@ -17,9 +17,11 @@ 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,
+      model: s.model ?? null, transport: s.transport ?? null, conversationId: s.conversationId ?? null,
       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) })),
+      task: fitTerminal(r.prompt, 200), createdAt: r.createdAt, completedAt: r.completedAt, usage: r.usage ?? null,
+      latencyMs: r.completedAt ? Math.max(0, Date.parse(r.completedAt) - Date.parse(r.createdAt)) : null, 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),