axmap-cli 1.10.0 → 1.11.0

package/README.ko.md

@@ -31,6 +31,23 @@ axmap setup
 
 최신 변경부터 정리합니다.
 
+### 1.11.0
+
+<sub>2026.11.05</sub>
+
+**Claude 데스크톱 앱과 Codex 앱이 대화 모드로 서로 일을 주고받습니다.**
+
+- 콘솔 창이 없는 앱 세션(Claude 데스크톱 앱의 Code 탭, Codex 앱, axMap 래퍼 없이 연 `codex`)을 공급자 자신의 훅이 대화 ID로 등록합니다.
+- 각 앱에 대화 모드를 켜 달라고 하고(`ax_dialogue_mode`), `ax_dispatch(to, from_session)`로 보냅니다. 받는 쪽의 응답이 끝나면 응답 끝(Stop) 훅이 그 요청으로 같은 대화를 이어 가고, 마지막 답이 결과가 되어 보낸 쪽의 다음 응답 끝에 돌아갑니다. 기다리는 동안 모델을 부르지 않습니다.
+- 대화 모드는 직접 켤 때만 동작하며 시간(기본 30분), 이어 가기 횟수(기본 8회), 한 번의 기다림(최대 540초)으로 제한됩니다. 사람이 입력하면 진행 중이던 요청은 밀려나고, 모드를 끄면 아직 전달하지 않은 요청은 실패로 기록됩니다.
+- 쉬고 있는 앱을 밖에서 깨우지 않습니다. 대화 모드를 켠 뒤 상대 앱에 한마디 걸어 기다림을 시작시키세요.
+- `axmap setup`을 다시 실행해야 Stop 훅 제한 시간 600초가 적용됩니다. Codex가 바뀐 훅의 신뢰 확인을 요구할 수 있으며 axMap은 이를 우회하지 않습니다.
+
+Windows에서 실제 Claude 데스크톱 앱과 Codex 앱 사이의 왕복과, 사람 입력 없는 2회차 왕복으로 검증했습니다. 앱 세션의 토큰 사용량은 측정하지 않으므로 `ax_chat`의 예산 한도는 적용되지 않습니다.
+[연결 안내 →](docs/SESSION-BRIDGE.md)
+
+---
+
 ### 1.10.0
 
 <sub>2026.11.03</sub>

package/README.md

@@ -31,6 +31,23 @@ View pipeline state inside compatible MCP Apps hosts, or add it to the existing
 
 Newest changes first.
 
+### 1.11.0
+
+<sub>November 5, 2026</sub>
+
+**Claude and Codex desktop apps can now hand work back and forth with dialogue mode.**
+
+- App sessions without a console window (the Claude desktop app's Code tab, the Codex app, or `codex` without the axMap wrapper) are registered by the provider's own hooks under their conversation ID.
+- Ask each app to turn on dialogue mode (`ax_dialogue_mode`), then send with `ax_dispatch(to, from_session)`. When the recipient finishes its turn, its Stop hook continues the same conversation with the request; the final answer becomes the result and returns to the sender's next Stop. Waiting makes no model calls.
+- Dialogue mode is opt-in and bounded by time (default 30 minutes), turns (default 8) and a wait of at most 540 seconds per turn. A human prompt supersedes an in-flight request; turning the mode off fails undelivered requests.
+- An idle app is never woken from outside. Say one thing to the other app after turning dialogue mode on so its wait begins.
+- Run `axmap setup` again to install the 600-second Stop hook timeout. Codex may ask you to trust the changed hook; axMap does not bypass that.
+
+Validated on Windows between the real Claude desktop app and Codex app, including a second exchange with no human input. Token usage is not measured for app sessions, so `ax_chat` budgets do not apply to them.
+[Connection guide →](docs/SESSION-BRIDGE.md)
+
+---
+
 ### 1.10.0
 
 <sub>November 3, 2026</sub>

package/mcp/server.mjs

@@ -227,7 +227,7 @@ const TTL = process.env.AXMAP_TTL ?? '45m'
  */
 const SESSION = process.env.AXMAP_SESSION || process.env.CLAUDE_CODE_SESSION_ID || `mcp-${process.pid}`
 
-const BRIDGE_TOOLS = new Set(['ax_sessions', 'ax_dispatch', 'ax_result', 'ax_chat', 'ax_dialogue', 'ax_chat_stop', 'ax_message', 'ax_mailbox', 'ax_mailbox_flush'])
+const BRIDGE_TOOLS = new Set(['ax_sessions', 'ax_dialogue_mode', 'ax_dispatch', 'ax_result', 'ax_chat', 'ax_dialogue', 'ax_chat_stop', 'ax_message', 'ax_mailbox', 'ax_mailbox_flush'])
 const PIPELINE_TOOLS = new Set(['ax_pipeline', 'ax_pipeline_state', 'ax_pipeline_watch'])
 const PIPELINE_URI = 'ui://axmap/pipeline/v1.html'
 const PIPELINE_MIME = 'text/html;profile=mcp-app'
@@ -513,8 +513,19 @@ const TOOLS = [
       to: { type: 'string', description: 'ax_sessions에서 확인한 상대 세션 UUID' },
       prompt: { type: 'string', description: '상대가 실행할 작업 요청' },
       wait_ms: { type: 'integer', minimum: 0, maximum: 30000, description: '전달 후 회신을 로컬에서 기다릴 최대 시간(ms). 짧은 요청은 30000으로 한 번에 회수한다. 기본 0.' },
+      from_session: { type: 'string', description: '내 axMap 세션 UUID(대화 시작 때 안내된 값). 상대가 앱 세션이면 그 답이 내 대화 모드로 돌아온다.' },
     }, required: ['to', 'prompt'] },
   },
+  {
+    name: 'ax_dialogue_mode',
+    description: '앱 세션(Claude 앱·Codex 앱·codex, transport=hook)의 대화 모드를 켜거나 끈다. 사용자가 이 세션에서 다른 AI 세션과 사람 없이 주고받으며 작업을 이어 가라고 할 때만 켠다. 켜진 세션은 응답이 끝날 때마다 최대 540초 상대의 요청·회신을 모델 호출 없이 기다렸다가 같은 대화에서 이어 가며, 그동안 앱은 작업 중으로 보인다. 쉬고 있는 앱을 밖에서 깨우지는 못한다. 기본 30분·자동 이어 가기 8회.',
+    inputSchema: { type: 'object', properties: {
+      session: { type: 'string', description: '대화 모드를 바꿀 앱 세션 UUID. 보통 이 대화에 안내된 내 세션 ID' },
+      on: { type: 'boolean' },
+      minutes: { type: 'integer', minimum: 1, maximum: 240, description: '켜 둘 시간. 기본 30' },
+      max_turns: { type: 'integer', minimum: 1, maximum: 50, description: '자동으로 이어 갈 최대 횟수. 기본 8 (Claude 기본 연속 이어 가기 한도와 같다)' },
+    }, required: ['session', 'on'] },
+  },
   {
     name: 'ax_result',
     description: '작업 요청의 제출/완료/불명 상태, 결과와 측정 사용량을 확인한다. 관리형 세션은 구조화된 완료 이벤트, PTY는 종료 훅, 독립 Windows console은 요청 UUID가 있는 대화 기록과 현재 빈 입력창의 대기 상태로 판정한다.',
@@ -970,7 +981,10 @@ function dispatch(name, args = {}) {
       ...[['reason', args.reason], ['topic', args.topic], ['key', args.key], ['ttl-seconds', args.ttl_seconds]].flatMap(([k, v]) => v === undefined ? [] : [`--${k}`, String(v)])], args.text)
     case 'ax_mailbox': return bridge(['mailbox', '--to', args.to, ...(args.take ? ['--take'] : []), ...(args.all ? ['--all'] : []), ...(args.at ? ['--at', args.at] : [])])
     case 'ax_mailbox_flush': return bridge(['flush', '--to', args.to, '--at', args.at])
-    case 'ax_dispatch': return bridge(['send', '--to', args.to, '--wait-ms', String(args.wait_ms ?? 0)], args.prompt)
+    case 'ax_dispatch': return bridge(['send', '--to', args.to, '--wait-ms', String(args.wait_ms ?? 0),
+      ...(args.from_session ? ['--from-session', String(args.from_session)] : [])], args.prompt)
+    case 'ax_dialogue_mode': return bridge(['mode', '--session', String(args.session), args.on ? '--on' : '--off',
+      ...[['minutes', args.minutes], ['max-turns', args.max_turns]].flatMap(([k, v]) => v === undefined ? [] : [`--${k}`, String(v)])])
     case 'ax_result': return bridge(['result', args.id, '--wait-ms', String(args.wait_ms ?? 0)])
     case 'ax_chat': return bridge(['chat', '--background', '--left', args.left, '--right', args.right,
       ...['maxTurns', 'maxTokens', 'maxMessageChars'].flatMap(key => args[key] === undefined ? [] :

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

package/src/app-session.mjs

@@ -0,0 +1,324 @@
+// Generated from src/app-session.mts. Edit the .mts source and run npm run build.
+/** 앱 세션(Claude 데스크톱 앱의 Code 탭, Codex 앱, axMap 래퍼 없는 codex TUI)의 대화 모드.
+ *
+ * 이 세션들에는 axMap 이 글자를 대신 입력할 콘솔 창이 없다. 그래서 공급자 자신의 훅만 쓴다.
+ * - 훅이 올 때마다 대화 ID 로 세션을 등록한다(transport: 'hook').
+ * - 대화 모드가 켜진 세션은 응답이 끝날 때(Stop) 상대의 요청이나 회신을 로컬에서 기다린다.
+ *   오면 공식 계약 {"decision":"block","reason":...} 으로 같은 대화를 이어 가게 한다.
+ * - 쉬고 있는 앱을 밖에서 깨울 방법은 없다. 기다림이 끝난 세션은 사용자가 다음에 말을 걸 때까지 쉰다.
+ * 기다리는 동안 모델을 부르지 않고, 새 모델 프로세스를 띄우지 않는다(D26). */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { withRepoLock } from './repolock.mjs';
+import { bridgeHome, repoKey, readJSON, writeJSON } from './bridge.mjs';
+const UUID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+/** 공급자 훅 제한 시간(600초, 두 공급자 문서의 기본값)보다 짧게 둔다. 훅이 강제 종료되면
+ * 이미 꺼낸 요청을 전달했는지 알 수 없게 되므로, 우리가 먼저 빈손으로 끝낸다. */
+export const MAX_WAIT_SECONDS = 540;
+/** Claude Code 는 사용자 입력 없이 Stop 훅으로 이어 가는 것을 기본 8회에서 끊는다
+ * (CLAUDE_CODE_STOP_HOOK_BLOCK_CAP). 기본값을 그보다 크게 잡으면 끝이 우리 한도가 아니라 공급자 한도가 된다. */
+const DEFAULT_MAX_TURNS = 8;
+/** Claude 는 훅이 넣는 문자열을 1만 자에서 자른다. 머리말을 붙일 자리를 남긴다. */
+const MAX_REPLY_CHARS = 8000;
+const sessionsDir = () => path.join(bridgeHome(), 'sessions');
+const requestsDir = () => path.join(bridgeHome(), 'requests');
+const sessionPath = (id) => path.join(sessionsDir(), `${id}.json`);
+const requestPath = (id) => path.join(requestsDir(), `${id}.json`);
+/** dispatchRequest 가 같은 수신자에 쓰는 잠금과 같은 파일이다. 꺼내기와 넣기가 서로 엇갈리지 않는다. */
+const queueLock = (id) => path.join(requestsDir(), `${id}.lock`);
+export function appSessionId(provider, conversationId) {
+    const hex = createHash('sha256').update(`${provider}-hook:${conversationId}`).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)}`;
+}
+function claudeHome() { return process.env.AXMAP_CLAUDE_HOME || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'); }
+/** 훅 입력은 공급자가 준 것이지만, 다른 대화의 기록 파일을 가리키지 않는지는 확인한다.
+ * null 은 "등록하지 않을 대화"다. 오류가 아니므로 조용히 넘긴다. */
+function hookIdentity(input, provider) {
+    const conversationId = input.session_id;
+    if (typeof conversationId !== 'string' || !UUID.test(conversationId))
+        throw new Error('훅 입력에 대화 UUID(session_id)가 없습니다.');
+    if (typeof input.cwd !== 'string' || !path.isAbsolute(input.cwd))
+        throw new Error('훅 입력에 작업 폴더(cwd)가 없습니다.');
+    const log = input.transcript_path;
+    if (provider === 'claude') {
+        const relative = typeof log === 'string' ? path.relative(path.join(claudeHome(), 'projects'), path.resolve(log)) : '..';
+        if (!log || relative.startsWith('..') || path.isAbsolute(relative) || path.basename(log) !== `${conversationId}.jsonl`) {
+            throw new Error('Claude 훅의 대화 기록 경로가 이 대화의 것이 아닙니다.');
+        }
+        return { conversationId, transcript: path.resolve(log), cwd: input.cwd };
+    }
+    // Codex 앱은 메시지마다 제목 생성 같은 보조 대화를 띄우고, 이 대화는 기록 파일 없이(transcript_path null)
+    // Stop·SessionEnd 도 없이 사라진다(2026-11-05 Codex 앱 실측). 등록하면 '작업 중' 세션으로 영영 남으므로,
+    // 이 대화의 rollout 기록 파일이 있는 대화만 받는다. 파일 이름에 대화 ID 가 들어간다(rollout-<시각>-<ID>.jsonl).
+    if (typeof log !== 'string' || !path.isAbsolute(log))
+        return null;
+    const name = path.basename(log);
+    if (!name.endsWith(`${conversationId}.jsonl`))
+        throw new Error('Codex 훅의 대화 기록 경로가 이 대화의 것이 아닙니다.');
+    return { conversationId, transcript: path.resolve(log), cwd: input.cwd };
+}
+/** Codex 는 사용자가 중단한 차례에 Stop 훅을 부르지 않는다. 기록 파일 끝에 turn_aborted 가
+ * 마지막 차례 이벤트로 남아 있으면 그 차례는 끝난 것이다. 못 읽으면 판정하지 않는다(null). */
+export function codexTurnAborted(transcript) {
+    if (!transcript)
+        return null;
+    let fd;
+    try {
+        fd = fs.openSync(transcript, 'r');
+        const size = fs.fstatSync(fd).size;
+        const length = Math.min(size, 256 * 1024);
+        const buffer = Buffer.alloc(length);
+        fs.readSync(fd, buffer, 0, length, size - length);
+        const lines = buffer.toString('utf8').split('\n').reverse();
+        for (const line of lines) {
+            if (!line.includes('"event_msg"'))
+                continue;
+            let type;
+            try {
+                type = JSON.parse(line)?.payload?.type;
+            }
+            catch {
+                continue;
+            }
+            if (type === 'turn_aborted')
+                return true;
+            if (type === 'task_started' || type === 'task_complete')
+                return false;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+/** 상태 표시용: 마지막 훅이 '작업 중'이라 적은 Codex 앱 세션이 실제로는 사용자 중단으로 끝났는지. */
+export function appTurnAborted(id) {
+    try {
+        const s = readJSON(sessionPath(id));
+        return s.transport === 'hook' && s.provider === 'codex' && s.state === 'running' && codexTurnAborted(s.transcript) === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 같은 대화가 작업 폴더를 옮기면 훅의 cwd 가 옛 폴더와 새 폴더 사이를 오간다(Claude 앱 실측).
+ * 마지막 하나로 덮으면 방금까지 주고받던 저장소에서 사라지므로, 본 적 있는 곳을 최근 순으로 쌓는다. */
+const MAX_PLACES = 8;
+function remember(previous, value) {
+    return [...(previous || []).filter(v => v !== value), value].slice(-MAX_PLACES);
+}
+function listRequests() {
+    if (!fs.existsSync(requestsDir()))
+        return [];
+    return fs.readdirSync(requestsDir()).filter(n => /^[0-9a-f-]{36}\.json$/i.test(n))
+        .flatMap(n => { try {
+        return [readJSON(path.join(requestsDir(), n))];
+    }
+    catch {
+        return [];
+    } });
+}
+export function modeActive(mode, now = Date.now()) {
+    return !!mode && Date.parse(mode.until) > now && mode.used < mode.maxTurns;
+}
+/** 이 저장소가 axMap 을 쓰는지. 안 쓰는 저장소의 대화에는 세션 ID 안내를 넣지 않는다(토큰 낭비). */
+function usesAxmap(cwd) {
+    const r = spawnSync('git', ['for-each-ref', '--count=1', '--format=x', 'refs/heads/axmap/claims', 'refs/remotes/*/axmap/claims'], { cwd, encoding: 'utf8', windowsHide: true });
+    return r.status === 0 && r.stdout.trim() === 'x';
+}
+function announcement(id) {
+    return `axMap: 이 대화의 세션 ID는 ${id} 입니다. 다른 AI 세션과 대화 모드로 주고받을 때 ` +
+        `ax_dialogue_mode(session) 와 ax_dispatch(from_session) 에 이 값을 씁니다. 사용자가 요청하지 않으면 쓰지 않습니다.`;
+}
+/** 훅 하나를 처리하고 공급자에게 돌려줄 JSON 을 만든다. 오류는 호출한 쪽이 삼키고 {} 를 낸다 —
+ * 훅 실패가 사용자의 대화를 막으면 안 된다. */
+export function handleAppHook(input, event, provider, options = {}) {
+    if (!['claude', 'codex'].includes(provider))
+        return {};
+    if (!['SessionStart', 'UserPromptSubmit', 'Stop', 'SessionEnd'].includes(event))
+        return {};
+    const now = options.now || Date.now;
+    const sleep = options.sleep || ((ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms));
+    const who = hookIdentity(input, provider);
+    if (!who)
+        return {};
+    const repo = repoKey(who.cwd);
+    const id = appSessionId(provider, who.conversationId);
+    fs.mkdirSync(requestsDir(), { recursive: true, mode: 0o700 });
+    const update = (change) => withRepoLock(queueLock(id), () => {
+        const previous = fs.existsSync(sessionPath(id)) ? readJSON(sessionPath(id)) : null;
+        const base = { ...(previous || {}), id, provider: provider, transport: 'hook',
+            conversationId: who.conversationId, ...(who.transcript ? { transcript: who.transcript } : {}),
+            workspaces: remember(previous?.workspaces, path.resolve(who.cwd)), repos: remember(previous?.repos, repo), registeredAt: new Date(now()).toISOString(), event,
+            ...(input.model && typeof input.model === 'string' ? { model: input.model } : {}) };
+        const next = change(base);
+        writeJSON(sessionPath(id), next);
+        return { previous, next };
+    });
+    if (event === 'SessionEnd') {
+        update(s => ({ ...s, state: 'closed', fullyIdle: false, dialogueMode: undefined }));
+        failQueued(id, '받는 세션이 종료돼 전달하지 않았습니다.');
+        return {};
+    }
+    if (event === 'SessionStart' || event === 'UserPromptSubmit') {
+        const { previous } = update(s => ({ ...s, state: event === 'SessionStart' ? 'idle' : 'running', fullyIdle: event === 'SessionStart' }));
+        if (event === 'UserPromptSubmit')
+            supersedeInFlight(id, typeof input.prompt === 'string' ? input.prompt : '');
+        if (previous?.announced || !usesAxmap(who.cwd))
+            return {};
+        update(s => ({ ...s, announced: true }));
+        return { hookSpecificOutput: { hookEventName: event, additionalContext: announcement(id) } };
+    }
+    // Stop: 방금 끝난 차례가 우리가 넣은 요청이었으면 그 답을 결과로 적는다.
+    const { next: session } = update(s => ({ ...s, state: 'idle', fullyIdle: true }));
+    completeInFlight(id, input, who.transcript);
+    if (!modeActive(session.dialogueMode, now()))
+        return {};
+    const waitMs = Math.min(session.dialogueMode.waitSeconds, MAX_WAIT_SECONDS) * 1000;
+    const deadline = Math.min(now() + waitMs, Date.parse(session.dialogueMode.until));
+    for (;;) {
+        const delivery = takeNext(id, now);
+        if (delivery)
+            return { decision: 'block', reason: delivery };
+        if (now() >= deadline)
+            return {};
+        sleep(Math.max(0, Math.min(500, deadline - now())));
+    }
+}
+function failQueued(id, reason) {
+    withRepoLock(queueLock(id), () => {
+        for (const r of listRequests().filter(r => r.to === id && r.state === 'queued')) {
+            writeJSON(requestPath(r.id), { ...r, state: 'failed', error: reason });
+        }
+    });
+}
+/** 우리가 넣은 요청을 처리하던 중에 사람이 다른 말을 넣었다면, 다음 답은 그 요청의 답이 아니다. */
+function supersedeInFlight(id, prompt) {
+    withRepoLock(queueLock(id), () => {
+        for (const r of listRequests().filter(r => r.to === id && r.state === 'submitted')) {
+            // Codex 는 이어 가기 문구를 새 프롬프트로 만들 수 있다. 그 문구에는 우리 표식이 있다.
+            if (prompt.includes(`[axMap request ${r.id}]`))
+                continue;
+            writeJSON(requestPath(r.id), { ...r, state: 'superseded', error: '사용자 입력이 끼어들어 이 요청의 답을 확정할 수 없습니다.' });
+        }
+    });
+}
+function lastClaudeAnswer(transcript) {
+    if (!transcript || !fs.existsSync(transcript))
+        return undefined;
+    const lines = fs.readFileSync(transcript, 'utf8').split('\n').filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let entry;
+        try {
+            entry = JSON.parse(lines[i]);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type === 'user')
+            return undefined;
+        if (entry.type !== 'assistant')
+            continue;
+        const content = entry.message?.content;
+        const text = typeof content === 'string' ? content : Array.isArray(content)
+            ? content.filter((b) => b?.type === 'text').map((b) => b.text || '').join('\n') : '';
+        if (text.trim())
+            return text;
+    }
+    return undefined;
+}
+function completeInFlight(id, input, transcript) {
+    withRepoLock(queueLock(id), () => {
+        for (const r of listRequests().filter(r => r.to === id && r.state === 'submitted')) {
+            const answer = typeof input.last_assistant_message === 'string' ? input.last_assistant_message : lastClaudeAnswer(transcript);
+            writeJSON(requestPath(r.id), typeof answer === 'string'
+                ? { ...r, state: 'completed', result: answer, completedAt: new Date().toISOString() }
+                // 답을 못 읽은 것과 답이 없는 것은 다르다. 완료로 치지 않는다.
+                : { ...r, state: 'unknown', error: '응답이 끝났지만 마지막 답을 읽지 못했습니다.' });
+        }
+    });
+}
+/** 다음에 이어 갈 내용 하나를 꺼낸다: 내게 온 요청(먼저 온 순서), 없으면 내가 보낸 요청의 회신. */
+function takeNext(id, now) {
+    return withRepoLock(queueLock(id), () => {
+        const s = readJSON(sessionPath(id));
+        if (!modeActive(s.dialogueMode, now()))
+            return null;
+        const all = listRequests().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        const remaining = s.dialogueMode.maxTurns - s.dialogueMode.used - 1;
+        const request = all.find(r => r.to === id && r.state === 'queued');
+        const reply = request ? undefined : all.find(r => r.fromSession === id && !r.returnedAt &&
+            ['completed', 'failed', 'superseded', 'unknown'].includes(r.state));
+        if (!request && !reply)
+            return null;
+        let text;
+        if (request) {
+            writeJSON(requestPath(request.id), { ...request, state: 'submitted', deliveredAt: new Date(now()).toISOString() });
+            text = `[axMap request ${request.id}]\n요청자: ${request.fromSession ? `세션 ${request.fromSession}` : request.from}\n${request.prompt}\n\n` +
+                `— axMap 대화 모드: 이 요청에 대한 마지막 답변이 그대로 요청자에게 전달됩니다.` +
+                (request.fromSession ? ` 답과 별개로 상대에게 새로 맡길 일이 있을 때만 ax_dispatch(to="${request.fromSession}", from_session="${id}")를 쓰세요.` : '') +
+                ` 남은 자동 이어 가기 ${remaining}회.`;
+        }
+        else {
+            const r = reply;
+            writeJSON(requestPath(r.id), { ...r, returnedAt: new Date(now()).toISOString() });
+            const body = typeof r.result === 'string' ? r.result : '';
+            const clipped = body.length > MAX_REPLY_CHARS ? `${body.slice(0, MAX_REPLY_CHARS)}\n…(잘림. 전체는 ax_result(id="${r.id}"))` : body;
+            text = `[axMap reply ${r.id}]\n세션 ${r.to}에 보낸 요청이 ${r.state === 'completed' ? '끝났습니다. 답:' : `완료되지 않았습니다(${r.state}): ${r.error || ''}`}\n${clipped}\n\n` +
+                `— axMap 대화 모드: 이어서 맡길 일이 있으면 ax_dispatch(to="${r.to}", from_session="${id}")로 보내고, 작업이 끝났으면 보내지 마세요. 남은 자동 이어 가기 ${remaining}회.`;
+        }
+        writeJSON(sessionPath(id), { ...s, state: 'running', fullyIdle: false,
+            dialogueMode: { ...s.dialogueMode, used: s.dialogueMode.used + 1 } });
+        return text;
+    });
+}
+/** 앱 세션으로 가는 요청은 언제나 대기열에 넣는다. 꺼내는 것은 받는 쪽의 Stop 훅뿐이다. */
+export function enqueueAppRequest(s, request) {
+    if (s.state === 'closed')
+        throw new Error('받는 앱 세션이 종료됐습니다.');
+    if (!modeActive(s.dialogueMode))
+        throw new Error('받는 앱 세션의 대화 모드가 꺼져 있습니다. 그 세션에서 ax_dialogue_mode 로 켠 뒤 보내세요.');
+    return withRepoLock(queueLock(s.id), () => {
+        if (listRequests().filter(r => r.to === s.id && r.state === 'queued').length >= 100)
+            throw new Error('받는 앱 세션의 대기열이 가득 찼습니다.');
+        const record = { ...request, id: randomUUID(), createdAt: new Date().toISOString(), baseline: null, state: 'queued' };
+        writeJSON(requestPath(record.id), record);
+        return record;
+    });
+}
+export function setDialogueMode({ session, cwd, on, minutes = 30, maxTurns = DEFAULT_MAX_TURNS, waitSeconds = MAX_WAIT_SECONDS }) {
+    if (!UUID.test(session || ''))
+        throw new Error('세션 ID는 UUID여야 합니다.');
+    for (const [name, value, max] of [['minutes', minutes, 240], ['maxTurns', maxTurns, 50], ['waitSeconds', waitSeconds, MAX_WAIT_SECONDS]]) {
+        if (!Number.isSafeInteger(value) || value < 1 || value > max)
+            throw new Error(`${name} 는 1~${max} 정수여야 합니다.`);
+    }
+    if (!fs.existsSync(sessionPath(session)))
+        throw new Error('등록되지 않은 세션입니다.');
+    const repo = repoKey(cwd);
+    const result = withRepoLock(queueLock(session), () => {
+        const s = readJSON(sessionPath(session));
+        if (!s.repos.includes(repo))
+            throw new Error('이 세션은 현재 작업 저장소에 등록되지 않았습니다.');
+        if (s.transport !== 'hook')
+            throw new Error('대화 모드는 앱 세션(transport: hook)에만 있습니다. 터미널·관리형 세션은 이미 바로 받습니다.');
+        if (on && s.state === 'closed')
+            throw new Error('종료된 세션입니다.');
+        const dialogueMode = on
+            ? { until: new Date(Date.now() + minutes * 60000).toISOString(), maxTurns, used: 0, waitSeconds } : undefined;
+        writeJSON(sessionPath(session), { ...s, dialogueMode });
+        return { session, on, ...(dialogueMode ? { dialogueMode } : {}) };
+    });
+    if (!on)
+        failQueued(session, '받는 세션의 대화 모드가 꺼져 전달하지 않았습니다.');
+    return { ...result, note: on
+            ? '이 세션은 응답이 끝날 때마다 최대 ' + waitSeconds + '초 동안 상대의 요청·회신을 기다렸다가 같은 대화에서 이어 갑니다. 기다리는 동안 앱은 작업 중으로 보입니다.'
+            : '대화 모드를 껐습니다. 아직 전달하지 않은 요청은 failed 로 적었습니다.' };
+}

package/src/app-session.mts

@@ -0,0 +1,294 @@
+/** 앱 세션(Claude 데스크톱 앱의 Code 탭, Codex 앱, axMap 래퍼 없는 codex TUI)의 대화 모드.
+ *
+ * 이 세션들에는 axMap 이 글자를 대신 입력할 콘솔 창이 없다. 그래서 공급자 자신의 훅만 쓴다.
+ * - 훅이 올 때마다 대화 ID 로 세션을 등록한다(transport: 'hook').
+ * - 대화 모드가 켜진 세션은 응답이 끝날 때(Stop) 상대의 요청이나 회신을 로컬에서 기다린다.
+ *   오면 공식 계약 {"decision":"block","reason":...} 으로 같은 대화를 이어 가게 한다.
+ * - 쉬고 있는 앱을 밖에서 깨울 방법은 없다. 기다림이 끝난 세션은 사용자가 다음에 말을 걸 때까지 쉰다.
+ * 기다리는 동안 모델을 부르지 않고, 새 모델 프로세스를 띄우지 않는다(D26). */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createHash, randomUUID } from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+import { withRepoLock } from './repolock.mjs'
+import { bridgeHome, repoKey, readJSON, writeJSON } from './bridge.mjs'
+import type { HookInput, RequestRecord, SessionRecord, DialogueMode } from './session-types.mjs'
+
+const UUID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i
+/** 공급자 훅 제한 시간(600초, 두 공급자 문서의 기본값)보다 짧게 둔다. 훅이 강제 종료되면
+ * 이미 꺼낸 요청을 전달했는지 알 수 없게 되므로, 우리가 먼저 빈손으로 끝낸다. */
+export const MAX_WAIT_SECONDS = 540
+/** Claude Code 는 사용자 입력 없이 Stop 훅으로 이어 가는 것을 기본 8회에서 끊는다
+ * (CLAUDE_CODE_STOP_HOOK_BLOCK_CAP). 기본값을 그보다 크게 잡으면 끝이 우리 한도가 아니라 공급자 한도가 된다. */
+const DEFAULT_MAX_TURNS = 8
+/** Claude 는 훅이 넣는 문자열을 1만 자에서 자른다. 머리말을 붙일 자리를 남긴다. */
+const MAX_REPLY_CHARS = 8000
+
+const sessionsDir = () => path.join(bridgeHome(), 'sessions')
+const requestsDir = () => path.join(bridgeHome(), 'requests')
+const sessionPath = (id: string) => path.join(sessionsDir(), `${id}.json`)
+const requestPath = (id: string) => path.join(requestsDir(), `${id}.json`)
+/** dispatchRequest 가 같은 수신자에 쓰는 잠금과 같은 파일이다. 꺼내기와 넣기가 서로 엇갈리지 않는다. */
+const queueLock = (id: string) => path.join(requestsDir(), `${id}.lock`)
+
+export function appSessionId(provider: string, conversationId: string): string {
+  const hex = createHash('sha256').update(`${provider}-hook:${conversationId}`).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)}`
+}
+
+function claudeHome() { return process.env.AXMAP_CLAUDE_HOME || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude') }
+
+/** 훅 입력은 공급자가 준 것이지만, 다른 대화의 기록 파일을 가리키지 않는지는 확인한다.
+ * null 은 "등록하지 않을 대화"다. 오류가 아니므로 조용히 넘긴다. */
+function hookIdentity(input: HookInput, provider: string): { conversationId: string; transcript?: string; cwd: string } | null {
+  const conversationId = input.session_id
+  if (typeof conversationId !== 'string' || !UUID.test(conversationId)) throw new Error('훅 입력에 대화 UUID(session_id)가 없습니다.')
+  if (typeof input.cwd !== 'string' || !path.isAbsolute(input.cwd)) throw new Error('훅 입력에 작업 폴더(cwd)가 없습니다.')
+  const log = input.transcript_path
+  if (provider === 'claude') {
+    const relative = typeof log === 'string' ? path.relative(path.join(claudeHome(), 'projects'), path.resolve(log)) : '..'
+    if (!log || relative.startsWith('..') || path.isAbsolute(relative) || path.basename(log) !== `${conversationId}.jsonl`) {
+      throw new Error('Claude 훅의 대화 기록 경로가 이 대화의 것이 아닙니다.')
+    }
+    return { conversationId, transcript: path.resolve(log), cwd: input.cwd }
+  }
+  // Codex 앱은 메시지마다 제목 생성 같은 보조 대화를 띄우고, 이 대화는 기록 파일 없이(transcript_path null)
+  // Stop·SessionEnd 도 없이 사라진다(2026-11-05 Codex 앱 실측). 등록하면 '작업 중' 세션으로 영영 남으므로,
+  // 이 대화의 rollout 기록 파일이 있는 대화만 받는다. 파일 이름에 대화 ID 가 들어간다(rollout-<시각>-<ID>.jsonl).
+  if (typeof log !== 'string' || !path.isAbsolute(log)) return null
+  const name = path.basename(log)
+  if (!name.endsWith(`${conversationId}.jsonl`)) throw new Error('Codex 훅의 대화 기록 경로가 이 대화의 것이 아닙니다.')
+  return { conversationId, transcript: path.resolve(log), cwd: input.cwd }
+}
+
+/** Codex 는 사용자가 중단한 차례에 Stop 훅을 부르지 않는다. 기록 파일 끝에 turn_aborted 가
+ * 마지막 차례 이벤트로 남아 있으면 그 차례는 끝난 것이다. 못 읽으면 판정하지 않는다(null). */
+export function codexTurnAborted(transcript: string | undefined): boolean | null {
+  if (!transcript) return null
+  let fd: number | undefined
+  try {
+    fd = fs.openSync(transcript, 'r')
+    const size = fs.fstatSync(fd).size
+    const length = Math.min(size, 256 * 1024)
+    const buffer = Buffer.alloc(length)
+    fs.readSync(fd, buffer, 0, length, size - length)
+    const lines = buffer.toString('utf8').split('\n').reverse()
+    for (const line of lines) {
+      if (!line.includes('"event_msg"')) continue
+      let type: unknown
+      try { type = JSON.parse(line)?.payload?.type } catch { continue }
+      if (type === 'turn_aborted') return true
+      if (type === 'task_started' || type === 'task_complete') return false
+    }
+    return null
+  } catch { return null } finally { if (fd !== undefined) fs.closeSync(fd) }
+}
+
+/** 상태 표시용: 마지막 훅이 '작업 중'이라 적은 Codex 앱 세션이 실제로는 사용자 중단으로 끝났는지. */
+export function appTurnAborted(id: string): boolean {
+  try {
+    const s = readJSON<SessionRecord>(sessionPath(id))
+    return s.transport === 'hook' && s.provider === 'codex' && s.state === 'running' && codexTurnAborted(s.transcript) === true
+  } catch { return false }
+}
+
+/** 같은 대화가 작업 폴더를 옮기면 훅의 cwd 가 옛 폴더와 새 폴더 사이를 오간다(Claude 앱 실측).
+ * 마지막 하나로 덮으면 방금까지 주고받던 저장소에서 사라지므로, 본 적 있는 곳을 최근 순으로 쌓는다. */
+const MAX_PLACES = 8
+function remember(previous: string[] | undefined, value: string): string[] {
+  return [...(previous || []).filter(v => v !== value), value].slice(-MAX_PLACES)
+}
+
+function listRequests(): RequestRecord[] {
+  if (!fs.existsSync(requestsDir())) return []
+  return fs.readdirSync(requestsDir()).filter(n => /^[0-9a-f-]{36}\.json$/i.test(n))
+    .flatMap(n => { try { return [readJSON<RequestRecord>(path.join(requestsDir(), n))] } catch { return [] } })
+}
+
+export function modeActive(mode: DialogueMode | undefined, now = Date.now()): mode is DialogueMode {
+  return !!mode && Date.parse(mode.until) > now && mode.used < mode.maxTurns
+}
+
+/** 이 저장소가 axMap 을 쓰는지. 안 쓰는 저장소의 대화에는 세션 ID 안내를 넣지 않는다(토큰 낭비). */
+function usesAxmap(cwd: string): boolean {
+  const r = spawnSync('git', ['for-each-ref', '--count=1', '--format=x', 'refs/heads/axmap/claims', 'refs/remotes/*/axmap/claims'],
+    { cwd, encoding: 'utf8', windowsHide: true })
+  return r.status === 0 && r.stdout.trim() === 'x'
+}
+
+function announcement(id: string): string {
+  return `axMap: 이 대화의 세션 ID는 ${id} 입니다. 다른 AI 세션과 대화 모드로 주고받을 때 ` +
+    `ax_dialogue_mode(session) 와 ax_dispatch(from_session) 에 이 값을 씁니다. 사용자가 요청하지 않으면 쓰지 않습니다.`
+}
+
+type HookOutput = Record<string, unknown>
+export interface AppHookOptions { now?: () => number; sleep?: (ms: number) => void }
+
+/** 훅 하나를 처리하고 공급자에게 돌려줄 JSON 을 만든다. 오류는 호출한 쪽이 삼키고 {} 를 낸다 —
+ * 훅 실패가 사용자의 대화를 막으면 안 된다. */
+export function handleAppHook(input: HookInput, event: string, provider: string, options: AppHookOptions = {}): HookOutput {
+  if (!['claude', 'codex'].includes(provider)) return {}
+  if (!['SessionStart', 'UserPromptSubmit', 'Stop', 'SessionEnd'].includes(event)) return {}
+  const now = options.now || Date.now
+  const sleep = options.sleep || ((ms: number) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms))
+  const who = hookIdentity(input, provider)
+  if (!who) return {}
+  const repo = repoKey(who.cwd)
+  const id = appSessionId(provider, who.conversationId)
+  fs.mkdirSync(requestsDir(), { recursive: true, mode: 0o700 })
+
+  const update = (change: (s: SessionRecord) => SessionRecord) => withRepoLock(queueLock(id), () => {
+    const previous = fs.existsSync(sessionPath(id)) ? readJSON<SessionRecord>(sessionPath(id)) : null
+    const base: SessionRecord = { ...(previous || {}), id, provider: provider as SessionRecord['provider'], transport: 'hook',
+      conversationId: who.conversationId, ...(who.transcript ? { transcript: who.transcript } : {}),
+      workspaces: remember(previous?.workspaces, path.resolve(who.cwd)), repos: remember(previous?.repos, repo), registeredAt: new Date(now()).toISOString(), event,
+      ...(input.model && typeof input.model === 'string' ? { model: input.model } : {}) }
+    const next = change(base)
+    writeJSON(sessionPath(id), next)
+    return { previous, next }
+  })
+
+  if (event === 'SessionEnd') {
+    update(s => ({ ...s, state: 'closed', fullyIdle: false, dialogueMode: undefined }))
+    failQueued(id, '받는 세션이 종료돼 전달하지 않았습니다.')
+    return {}
+  }
+  if (event === 'SessionStart' || event === 'UserPromptSubmit') {
+    const { previous } = update(s => ({ ...s, state: event === 'SessionStart' ? 'idle' : 'running', fullyIdle: event === 'SessionStart' }))
+    if (event === 'UserPromptSubmit') supersedeInFlight(id, typeof input.prompt === 'string' ? input.prompt : '')
+    if (previous?.announced || !usesAxmap(who.cwd)) return {}
+    update(s => ({ ...s, announced: true }))
+    return { hookSpecificOutput: { hookEventName: event, additionalContext: announcement(id) } }
+  }
+
+  // Stop: 방금 끝난 차례가 우리가 넣은 요청이었으면 그 답을 결과로 적는다.
+  const { next: session } = update(s => ({ ...s, state: 'idle', fullyIdle: true }))
+  completeInFlight(id, input, who.transcript)
+  if (!modeActive(session.dialogueMode, now())) return {}
+
+  const waitMs = Math.min(session.dialogueMode.waitSeconds, MAX_WAIT_SECONDS) * 1000
+  const deadline = Math.min(now() + waitMs, Date.parse(session.dialogueMode.until))
+  for (;;) {
+    const delivery = takeNext(id, now)
+    if (delivery) return { decision: 'block', reason: delivery }
+    if (now() >= deadline) return {}
+    sleep(Math.max(0, Math.min(500, deadline - now())))
+  }
+}
+
+function failQueued(id: string, reason: string) {
+  withRepoLock(queueLock(id), () => {
+    for (const r of listRequests().filter(r => r.to === id && r.state === 'queued')) {
+      writeJSON(requestPath(r.id), { ...r, state: 'failed', error: reason })
+    }
+  })
+}
+
+/** 우리가 넣은 요청을 처리하던 중에 사람이 다른 말을 넣었다면, 다음 답은 그 요청의 답이 아니다. */
+function supersedeInFlight(id: string, prompt: string) {
+  withRepoLock(queueLock(id), () => {
+    for (const r of listRequests().filter(r => r.to === id && r.state === 'submitted')) {
+      // Codex 는 이어 가기 문구를 새 프롬프트로 만들 수 있다. 그 문구에는 우리 표식이 있다.
+      if (prompt.includes(`[axMap request ${r.id}]`)) continue
+      writeJSON(requestPath(r.id), { ...r, state: 'superseded', error: '사용자 입력이 끼어들어 이 요청의 답을 확정할 수 없습니다.' })
+    }
+  })
+}
+
+function lastClaudeAnswer(transcript: string | undefined): string | undefined {
+  if (!transcript || !fs.existsSync(transcript)) return undefined
+  const lines = fs.readFileSync(transcript, 'utf8').split('\n').filter(Boolean)
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let entry: { type?: string; message?: { content?: unknown } }
+    try { entry = JSON.parse(lines[i]!) } catch { continue }
+    if (entry.type === 'user') return undefined
+    if (entry.type !== 'assistant') continue
+    const content = entry.message?.content
+    const text = typeof content === 'string' ? content : Array.isArray(content)
+      ? content.filter((b: { type?: string }) => b?.type === 'text').map((b: { text?: string }) => b.text || '').join('\n') : ''
+    if (text.trim()) return text
+  }
+  return undefined
+}
+
+function completeInFlight(id: string, input: HookInput, transcript: string | undefined) {
+  withRepoLock(queueLock(id), () => {
+    for (const r of listRequests().filter(r => r.to === id && r.state === 'submitted')) {
+      const answer = typeof input.last_assistant_message === 'string' ? input.last_assistant_message : lastClaudeAnswer(transcript)
+      writeJSON(requestPath(r.id), typeof answer === 'string'
+        ? { ...r, state: 'completed', result: answer, completedAt: new Date().toISOString() }
+        // 답을 못 읽은 것과 답이 없는 것은 다르다. 완료로 치지 않는다.
+        : { ...r, state: 'unknown', error: '응답이 끝났지만 마지막 답을 읽지 못했습니다.' })
+    }
+  })
+}
+
+/** 다음에 이어 갈 내용 하나를 꺼낸다: 내게 온 요청(먼저 온 순서), 없으면 내가 보낸 요청의 회신. */
+function takeNext(id: string, now: () => number): string | null {
+  return withRepoLock(queueLock(id), () => {
+    const s = readJSON<SessionRecord>(sessionPath(id))
+    if (!modeActive(s.dialogueMode, now())) return null
+    const all = listRequests().sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+    const remaining = s.dialogueMode.maxTurns - s.dialogueMode.used - 1
+    const request = all.find(r => r.to === id && r.state === 'queued')
+    const reply = request ? undefined : all.find(r => r.fromSession === id && !r.returnedAt &&
+      ['completed', 'failed', 'superseded', 'unknown'].includes(r.state))
+    if (!request && !reply) return null
+    let text: string
+    if (request) {
+      writeJSON(requestPath(request.id), { ...request, state: 'submitted', deliveredAt: new Date(now()).toISOString() })
+      text = `[axMap request ${request.id}]\n요청자: ${request.fromSession ? `세션 ${request.fromSession}` : request.from}\n${request.prompt}\n\n` +
+        `— axMap 대화 모드: 이 요청에 대한 마지막 답변이 그대로 요청자에게 전달됩니다.` +
+        (request.fromSession ? ` 답과 별개로 상대에게 새로 맡길 일이 있을 때만 ax_dispatch(to="${request.fromSession}", from_session="${id}")를 쓰세요.` : '') +
+        ` 남은 자동 이어 가기 ${remaining}회.`
+    } else {
+      const r = reply!
+      writeJSON(requestPath(r.id), { ...r, returnedAt: new Date(now()).toISOString() })
+      const body = typeof r.result === 'string' ? r.result : ''
+      const clipped = body.length > MAX_REPLY_CHARS ? `${body.slice(0, MAX_REPLY_CHARS)}\n…(잘림. 전체는 ax_result(id="${r.id}"))` : body
+      text = `[axMap reply ${r.id}]\n세션 ${r.to}에 보낸 요청이 ${r.state === 'completed' ? '끝났습니다. 답:' : `완료되지 않았습니다(${r.state}): ${r.error || ''}`}\n${clipped}\n\n` +
+        `— axMap 대화 모드: 이어서 맡길 일이 있으면 ax_dispatch(to="${r.to}", from_session="${id}")로 보내고, 작업이 끝났으면 보내지 마세요. 남은 자동 이어 가기 ${remaining}회.`
+    }
+    writeJSON(sessionPath(id), { ...s, state: 'running', fullyIdle: false,
+      dialogueMode: { ...s.dialogueMode, used: s.dialogueMode.used + 1 } })
+    return text
+  })
+}
+
+/** 앱 세션으로 가는 요청은 언제나 대기열에 넣는다. 꺼내는 것은 받는 쪽의 Stop 훅뿐이다. */
+export function enqueueAppRequest(s: SessionRecord, request: Omit<RequestRecord, 'id' | 'createdAt' | 'state' | 'baseline'>): RequestRecord {
+  if (s.state === 'closed') throw new Error('받는 앱 세션이 종료됐습니다.')
+  if (!modeActive(s.dialogueMode)) throw new Error('받는 앱 세션의 대화 모드가 꺼져 있습니다. 그 세션에서 ax_dialogue_mode 로 켠 뒤 보내세요.')
+  return withRepoLock(queueLock(s.id), () => {
+    if (listRequests().filter(r => r.to === s.id && r.state === 'queued').length >= 100) throw new Error('받는 앱 세션의 대기열이 가득 찼습니다.')
+    const record: RequestRecord = { ...request, id: randomUUID(), createdAt: new Date().toISOString(), baseline: null, state: 'queued' }
+    writeJSON(requestPath(record.id), record)
+    return record
+  })
+}
+
+export interface ModeOptions { session: string; cwd: string; on: boolean; minutes?: number; maxTurns?: number; waitSeconds?: number }
+export function setDialogueMode({ session, cwd, on, minutes = 30, maxTurns = DEFAULT_MAX_TURNS, waitSeconds = MAX_WAIT_SECONDS }: ModeOptions) {
+  if (!UUID.test(session || '')) throw new Error('세션 ID는 UUID여야 합니다.')
+  for (const [name, value, max] of [['minutes', minutes, 240], ['maxTurns', maxTurns, 50], ['waitSeconds', waitSeconds, MAX_WAIT_SECONDS]] as const) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > max) throw new Error(`${name} 는 1~${max} 정수여야 합니다.`)
+  }
+  if (!fs.existsSync(sessionPath(session))) throw new Error('등록되지 않은 세션입니다.')
+  const repo = repoKey(cwd)
+  const result = withRepoLock(queueLock(session), () => {
+    const s = readJSON<SessionRecord>(sessionPath(session))
+    if (!s.repos.includes(repo)) throw new Error('이 세션은 현재 작업 저장소에 등록되지 않았습니다.')
+    if (s.transport !== 'hook') throw new Error('대화 모드는 앱 세션(transport: hook)에만 있습니다. 터미널·관리형 세션은 이미 바로 받습니다.')
+    if (on && s.state === 'closed') throw new Error('종료된 세션입니다.')
+    const dialogueMode: DialogueMode | undefined = on
+      ? { until: new Date(Date.now() + minutes * 60000).toISOString(), maxTurns, used: 0, waitSeconds } : undefined
+    writeJSON(sessionPath(session), { ...s, dialogueMode })
+    return { session, on, ...(dialogueMode ? { dialogueMode } : {}) }
+  })
+  if (!on) failQueued(session, '받는 세션의 대화 모드가 꺼져 전달하지 않았습니다.')
+  return { ...result, note: on
+    ? '이 세션은 응답이 끝날 때마다 최대 ' + waitSeconds + '초 동안 상대의 요청·회신을 기다렸다가 같은 대화에서 이어 갑니다. 기다리는 동안 앱은 작업 중으로 보입니다.'
+    : '대화 모드를 껐습니다. 아직 전달하지 않은 요청은 failed 로 적었습니다.' }
+}
+

package/src/bridge.mjs

@@ -9,6 +9,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { withRepoLock } from './repolock.mjs';
 import { submitConsole, checkConsole, validateConsolePrompt, findConsoleTranscript, externalStatus } from './external-console.mjs';
+import { enqueueAppRequest } from './app-session.mjs';
 import { errorCode, errorMessage, RPC_NOT_DELIVERED_EXIT } from './session-types.mjs';
 import { commonKey, resolveTarget } from './workspace.mjs';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -134,6 +135,7 @@ function publicSession(s, liveness) {
         // 호스트가 살아 있는지 확인하지 못했으면 저장된 "대기"를 대기로 보고하지 않는다.
         fullyIdle: liveness === 'unverified' ? false : s.fullyIdle,
         role: s.role, usage: s.usage, usageKnown: s.usageKnown, maxTokens: s.maxTokens, pendingApproval: s.pendingApproval,
+        ...(s.dialogueMode ? { dialogueMode: s.dialogueMode } : {}),
         ...(liveness ? { liveness } : {}) };
 }
 /** 관리형 세션(pty·stdio)의 로컬 제어 파이프. 세션 호스트가 살아 있는 동안만 존재한다. */
@@ -221,7 +223,7 @@ function sessionFor(id, cwd) {
     const s = readJSON(file('sessions', id));
     if (!s.repos.includes(repoKey(cwd)))
         throw new Error('이 세션은 현재 작업 저장소에 등록되지 않았습니다.');
-    if (s.provider !== 'agy' && !(s.provider === 'claude' && s.transport === 'console') && !['pty', 'stdio'].includes(s.transport || ''))
+    if (s.provider !== 'agy' && !(s.provider === 'claude' && s.transport === 'console') && !['pty', 'stdio', 'hook'].includes(s.transport || ''))
         throw new Error('아직 지원하지 않는 수신 세션입니다.');
     return s;
 }
@@ -256,6 +258,9 @@ export function requestResult(id, cwd) {
     if (!['queued', 'submitted', 'unknown'].includes(request.state))
         return request;
     let s = sessionFor(request.to, cwd);
+    // 앱 세션의 요청 상태는 받는 쪽 훅이 직접 적는다. 여기서 추측하지 않는다.
+    if (s.transport === 'hook')
+        return request;
     if (request.state === 'queued' && s.transport === 'console')
         return request;
     if (['pty', 'stdio'].includes(s.transport || '')) {
@@ -336,7 +341,7 @@ export function sessionLeasePath(id) {
         throw new Error('세션 ID는 UUID여야 합니다.');
     return path.join(bridgeHome(), 'dialogues', `session-${id}.lock`);
 }
-export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null, queueIfBusy = false }) {
+export function dispatchRequest({ to, prompt, cwd, from = 'axmap', fromSession, dialogueId = null, queueIfBusy = false }) {
     // 보내기 시작 전에 난 오류(이전 요청 미확정, 대기 미확인 등)는 확실히 전달되지 않은 것이다.
     // 받은 편지함이 이를 "전달 불명"과 구별해야 쪽지를 다시 대기열로 돌릴 수 있다.
     let sending = false;
@@ -349,6 +354,16 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
             throw new Error('이 세션은 자동 대화가 사용 중입니다. 해당 대화가 끝난 뒤 요청하세요.');
         const dir = path.join(bridgeHome(), 'requests');
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (fromSession !== undefined) {
+            if (fromSession === to)
+                throw new Error('자기 자신에게는 보낼 수 없습니다.');
+            sessionFor(fromSession, cwd);
+        }
+        if (s.transport === 'hook') {
+            if (dialogueId)
+                throw new Error('앱 세션은 자동 대화 중계(ax_chat)를 지원하지 않습니다. 사용량을 측정하지 못합니다.');
+            return enqueueAppRequest(s, { to, from, repo: repoKey(cwd), prompt, ...(fromSession ? { fromSession } : {}) });
+        }
         if (queueIfBusy && s.provider === 'claude' && s.transport === 'console') {
             validateConsolePrompt(prompt, from);
             if (s.state === 'closed')
@@ -358,7 +373,7 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
                     .filter(r => r.to === to && r.state === 'queued');
                 if (pending.length >= 100)
                     throw new Error('Claude command queue is full');
-                const request = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt, createdAt: new Date().toISOString(), baseline: null, state: 'queued' };
+                const request = { id: randomUUID(), to, from, ...(fromSession ? { fromSession } : {}), repo: repoKey(cwd), prompt, createdAt: new Date().toISOString(), baseline: null, state: 'queued' };
                 writeJSON(file('requests', request.id), request);
                 return request;
             });
@@ -391,7 +406,7 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
                 if (!s.fullyIdle || s.event !== 'Stop')
                     throw new Error('상대 세션의 대기 상태를 아직 확인하지 못했습니다. 작업 종료 훅을 기다리세요.');
             }
-            const request = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt,
+            const request = { id: randomUUID(), to, from, ...(fromSession ? { fromSession } : {}), repo: repoKey(cwd), prompt,
                 createdAt: new Date().toISOString(), baseline: ['pty', 'stdio'].includes(s.transport || '') ? null : s.transcript ? transcript(s).length : 0, state: 'sending' };
             const target = file('requests', request.id);
             writeJSON(target, request);

package/src/bridge.mts

@@ -8,6 +8,7 @@ import { spawn, spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { withRepoLock } from './repolock.mjs'
 import { submitConsole, checkConsole, validateConsolePrompt, findConsoleTranscript, externalStatus } from './external-console.mjs'
+import { enqueueAppRequest } from './app-session.mjs'
 import { errorCode, errorMessage, RPC_NOT_DELIVERED_EXIT } from './session-types.mjs'
 import { commonKey, resolveTarget } from './workspace.mjs'
 import type { HostLiveness } from './session-types.mjs'
@@ -111,6 +112,7 @@ function publicSession(s: SessionRecord, liveness?: HostLiveness): PublicSession
     // 호스트가 살아 있는지 확인하지 못했으면 저장된 "대기"를 대기로 보고하지 않는다.
     fullyIdle: liveness === 'unverified' ? false : s.fullyIdle,
     role: s.role, usage: s.usage, usageKnown: s.usageKnown, maxTokens: s.maxTokens, pendingApproval: s.pendingApproval,
+    ...(s.dialogueMode ? { dialogueMode: s.dialogueMode } : {}),
     ...(liveness ? { liveness } : {}) }
 }
 
@@ -178,7 +180,7 @@ export function sessions(cwd: string): PublicSession[] {
 function sessionFor(id: string, cwd: string): SessionRecord {
   const s = readJSON<SessionRecord>(file('sessions', id))
   if (!s.repos.includes(repoKey(cwd))) throw new Error('이 세션은 현재 작업 저장소에 등록되지 않았습니다.')
-  if (s.provider !== 'agy' && !(s.provider === 'claude' && s.transport === 'console') && !['pty', 'stdio'].includes(s.transport || '')) throw new Error('아직 지원하지 않는 수신 세션입니다.')
+  if (s.provider !== 'agy' && !(s.provider === 'claude' && s.transport === 'console') && !['pty', 'stdio', 'hook'].includes(s.transport || '')) throw new Error('아직 지원하지 않는 수신 세션입니다.')
   return s
 }
 
@@ -209,6 +211,8 @@ export function requestResult(id: string, cwd: string): RequestRecord {
   if (request.repo !== repoKey(cwd)) throw new Error('이 요청은 현재 작업 저장소의 요청이 아닙니다.')
   if (!['queued', 'submitted', 'unknown'].includes(request.state)) return request
   let s = sessionFor(request.to, cwd)
+  // 앱 세션의 요청 상태는 받는 쪽 훅이 직접 적는다. 여기서 추측하지 않는다.
+  if (s.transport === 'hook') return request
   if (request.state === 'queued' && s.transport === 'console') return request
   if (['pty', 'stdio'].includes(s.transport || '')) {
     try { Object.assign(request, terminalRPC(s.id, { action: 'result', id })) }
@@ -271,7 +275,7 @@ export function sessionLeasePath(id: string): string {
   return path.join(bridgeHome(), 'dialogues', `session-${id}.lock`)
 }
 
-export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId = null, queueIfBusy = false }: DispatchOptions): RequestRecord {
+export function dispatchRequest({ to, prompt, cwd, from = 'axmap', fromSession, dialogueId = null, queueIfBusy = false }: DispatchOptions): RequestRecord {
   // 보내기 시작 전에 난 오류(이전 요청 미확정, 대기 미확인 등)는 확실히 전달되지 않은 것이다.
   // 받은 편지함이 이를 "전달 불명"과 구별해야 쪽지를 다시 대기열로 돌릴 수 있다.
   let sending = false
@@ -282,6 +286,14 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
   if (fs.existsSync(lease) && readJSON<{ dialogueId: string }>(lease).dialogueId !== dialogueId) throw new Error('이 세션은 자동 대화가 사용 중입니다. 해당 대화가 끝난 뒤 요청하세요.')
   const dir = path.join(bridgeHome(), 'requests')
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  if (fromSession !== undefined) {
+    if (fromSession === to) throw new Error('자기 자신에게는 보낼 수 없습니다.')
+    sessionFor(fromSession, cwd)
+  }
+  if (s.transport === 'hook') {
+    if (dialogueId) throw new Error('앱 세션은 자동 대화 중계(ax_chat)를 지원하지 않습니다. 사용량을 측정하지 못합니다.')
+    return enqueueAppRequest(s, { to, from, repo: repoKey(cwd), prompt, ...(fromSession ? { fromSession } : {}) })
+  }
   if (queueIfBusy && s.provider === 'claude' && s.transport === 'console') {
     validateConsolePrompt(prompt, from)
     if (s.state === 'closed') throw new Error('Claude terminal is closed')
@@ -289,7 +301,7 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
       const pending = fs.readdirSync(dir).filter(n => n.endsWith('.json')).map(n => readJSON<RequestRecord>(path.join(dir, n)))
         .filter(r => r.to === to && r.state === 'queued')
       if (pending.length >= 100) throw new Error('Claude command queue is full')
-      const request: RequestRecord = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt, createdAt: new Date().toISOString(), baseline: null, state: 'queued' }
+      const request: RequestRecord = { id: randomUUID(), to, from, ...(fromSession ? { fromSession } : {}), repo: repoKey(cwd), prompt, createdAt: new Date().toISOString(), baseline: null, state: 'queued' }
       writeJSON(file('requests', request.id), request)
       return request
     })
@@ -313,7 +325,7 @@ export function dispatchRequest({ to, prompt, cwd, from = 'axmap', dialogueId =
       runAPI(s, ['get-conversation-metadata', to])
       if (!s.fullyIdle || s.event !== 'Stop') throw new Error('상대 세션의 대기 상태를 아직 확인하지 못했습니다. 작업 종료 훅을 기다리세요.')
     }
-    const request: RequestRecord = { id: randomUUID(), to, from, repo: repoKey(cwd), prompt,
+    const request: RequestRecord = { id: randomUUID(), to, from, ...(fromSession ? { fromSession } : {}), repo: repoKey(cwd), prompt,
       createdAt: new Date().toISOString(), baseline: ['pty', 'stdio'].includes(s.transport || '') ? null : s.transcript ? transcript(s).length : 0, state: 'sending' }
     const target = file('requests', request.id)
     writeJSON(target, request)

package/src/pipeline-mcp.mjs

@@ -81,7 +81,10 @@ export async function runPipelineOperation(action, args, emit = () => { }, cance
                 throw new Error('to와 prompt 문자열이 필요합니다.');
             if (progress)
                 emit('axMap · 대상 세션과 입력 상태 확인');
-            request = dispatchRequest({ to: args.to, prompt: args.prompt, cwd, from: process.env.AXMAP_AGENT || 'axmap', queueIfBusy: true });
+            if (args.from_session !== undefined && typeof args.from_session !== 'string')
+                throw new Error('from_session 은 세션 UUID 문자열이어야 합니다.');
+            request = dispatchRequest({ to: args.to, prompt: args.prompt, cwd, from: process.env.AXMAP_AGENT || 'axmap',
+                ...(args.from_session ? { fromSession: args.from_session } : {}), queueIfBusy: true });
         }
         else {
             if (typeof args.id !== 'string')

package/src/pipeline-mcp.mts

@@ -83,7 +83,9 @@ export async function runPipelineOperation(action: string, args: Record<string,
     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', queueIfBusy: true })
+      if (args.from_session !== undefined && typeof args.from_session !== 'string') throw new Error('from_session 은 세션 UUID 문자열이어야 합니다.')
+      request = dispatchRequest({ to: args.to, prompt: args.prompt, cwd, from: process.env.AXMAP_AGENT || 'axmap',
+        ...(args.from_session ? { fromSession: args.from_session } : {}), queueIfBusy: true })
     } else {
       if (typeof args.id !== 'string') throw new Error('요청 UUID가 필요합니다.')
       request = requestResult(args.id, cwd)

package/src/session-status.mjs

@@ -2,6 +2,7 @@
 import { sessions } from './bridge.mjs';
 import { sendTerminal } from './terminal-bridge.mjs';
 import { externalStatus } from './external-console.mjs';
+import { appTurnAborted } from './app-session.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()) {
@@ -21,6 +22,11 @@ export async function sessionStatus(cwd = process.cwd()) {
                 return snapshot('unknown', 'unreachable');
             }
         }
+        // 앱 세션은 물어볼 연결이 없다. 마지막 훅이 적은 상태만 보여 주고, 대기로 확정하지 않는다.
+        // 단 Codex 는 사용자가 중단한 차례에 Stop 훅이 없으므로, 기록 파일의 turn_aborted 로 '작업 중'을 바로잡는다.
+        if (session.transport === 'hook') {
+            return snapshot(appTurnAborted(session.id) ? 'idle' : session.state || 'unknown', 'unverified');
+        }
         if (!['pty', 'stdio'].includes(session.transport || ''))
             return snapshot('unknown', 'unverified');
         try {
@@ -49,6 +55,9 @@ export function formatSessionStatus(listed) {
         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}`;
+            const m = s.dialogueMode;
+            const mode = s.transport !== 'hook' ? '' : `\n  앱 세션 · 대화 모드 ${m && Date.parse(m.until) > Date.now() && m.used < m.maxTurns
+                ? `켜짐 (이어 가기 ${m.used}/${m.maxTurns}, ${m.until}까지)` : '꺼짐'}`;
+            return `${safe(s.provider)}  ${safe(s.id)}\n  ${connections[s.connection] || '상태 미확인'} · ${labels[s.state] || '상태 미확인'}${s.role ? ` · ${safe(s.role)}` : ''}${mode}\n  확인된 누적 처리 토큰: ${usage}`;
         })].join('\n');
 }

package/src/session-status.mts

@@ -1,6 +1,7 @@
 import { sessions } from './bridge.mjs'
 import { sendTerminal } from './terminal-bridge.mjs'
 import { externalStatus } from './external-console.mjs'
+import { appTurnAborted } from './app-session.mjs'
 import type { PublicSession, SessionSnapshot, SessionState, ConnectionState } from './session-types.mjs'
 
 /** Probe only the authenticated local control pipe. A saved idle/running record
@@ -18,6 +19,11 @@ export async function sessionStatus(cwd = process.cwd()): Promise<SessionSnapsho
         return snapshot(live.state, 'connected')
       } catch { return snapshot('unknown', 'unreachable') }
     }
+    // 앱 세션은 물어볼 연결이 없다. 마지막 훅이 적은 상태만 보여 주고, 대기로 확정하지 않는다.
+    // 단 Codex 는 사용자가 중단한 차례에 Stop 훅이 없으므로, 기록 파일의 turn_aborted 로 '작업 중'을 바로잡는다.
+    if (session.transport === 'hook') {
+      return snapshot(appTurnAborted(session.id) ? 'idle' : session.state || 'unknown', 'unverified')
+    }
     if (!['pty', 'stdio'].includes(session.transport || '')) return snapshot('unknown', 'unverified')
     try {
       const raw: unknown = await sendTerminal(session.id, { action: 'status' }, null, { timeoutMs: 1000 })
@@ -45,6 +51,9 @@ export function formatSessionStatus(listed: readonly SessionSnapshot[]): string
   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}`
+    const m = s.dialogueMode
+    const mode = s.transport !== 'hook' ? '' : `\n  앱 세션 · 대화 모드 ${m && Date.parse(m.until) > Date.now() && m.used < m.maxTurns
+      ? `켜짐 (이어 가기 ${m.used}/${m.maxTurns}, ${m.until}까지)` : '꺼짐'}`
+    return `${safe(s.provider)}  ${safe(s.id)}\n  ${connections[s.connection] || '상태 미확인'} · ${labels[s.state] || '상태 미확인'}${s.role ? ` · ${safe(s.role)}` : ''}${mode}\n  확인된 누적 처리 토큰: ${usage}`
   })].join('\n')
 }

package/src/session-types.mts

@@ -1,6 +1,6 @@
 /** Shared contracts for the local bridge. Runtime input checks still guard external data. */
 export type Provider = 'codex' | 'agy' | 'claude'
-export type Transport = 'console' | 'stdio' | 'pty' | 'agentapi'
+export type Transport = 'console' | 'stdio' | 'pty' | 'agentapi' | 'hook'
 export type SessionState = 'starting' | 'running' | 'idle' | 'awaiting_user' | 'settling' | 'closed' | 'unknown'
 export type RequestState = 'queued' | 'sending' | 'submitted' | 'unknown' | 'completed' | 'failed' | 'superseded'
 export type ConnectionState = 'connected' | 'closed' | 'unreachable' | 'unverified'
@@ -19,6 +19,8 @@ export interface Usage {
   totalTokens: number
   providerTotalTokens: number
 }
+/** 앱 세션의 대화 모드. 기다리는 쪽은 Stop 훅이고, used 는 이 모드로 이어 간 횟수다. */
+export interface DialogueMode { until: string; maxTurns: number; used: number; waitSeconds: number }
 export interface PendingApproval { id: string | number; method?: string; [key: string]: unknown }
 export interface SessionRecord {
   id: string
@@ -46,9 +48,12 @@ export interface SessionRecord {
   /** 로컬 파이프를 연 `bridge serve`·`run` 프로세스. 비 Windows 생존 확인에 쓴다. */
   hostPid?: number
   closedReason?: string
+  /** transport 'hook' 만: 대화 모드와 세션 ID 안내 여부 */
+  dialogueMode?: DialogueMode
+  announced?: boolean
 }
 export type PublicSession = Pick<SessionRecord, 'id' | 'provider' | 'workspaces' | 'model' | 'transport' |
-  'state' | 'pid' | 'registeredAt' | 'event' | 'fullyIdle' | 'role' | 'usage' | 'usageKnown' | 'maxTokens' | 'pendingApproval' | 'conversationId'> & { liveness?: HostLiveness }
+  'state' | 'pid' | 'registeredAt' | 'event' | 'fullyIdle' | 'role' | 'usage' | 'usageKnown' | 'maxTokens' | 'pendingApproval' | 'conversationId' | 'dialogueMode'> & { liveness?: HostLiveness }
 export interface SessionSnapshot extends PublicSession {
   lastKnownState: SessionState | null
   state: SessionState
@@ -70,8 +75,12 @@ export interface RequestRecord {
   completedAt?: string
   conversationId?: string
   usage?: Usage | null
+  /** 보낸 쪽이 axMap 세션이면 그 ID. 앱 세션이면 회신이 이 세션의 Stop 훅으로 돌아간다. */
+  fromSession?: string
+  deliveredAt?: string
+  returnedAt?: string
 }
-export interface DispatchOptions { to: string; prompt: string; cwd: string; from?: string; dialogueId?: string | null; queueIfBusy?: boolean }
+export interface DispatchOptions { to: string; prompt: string; cwd: string; from?: string; fromSession?: string; dialogueId?: string | null; queueIfBusy?: boolean }
 export interface HookInput {
   cwd?: string
   transcript_path?: string

package/src/terminal-bridge.mjs

@@ -311,7 +311,9 @@ export function installTerminalHooks(home = os.homedir(), provider = 'agy') {
                 const hooks = group.hooks.filter(h => h.statusMessage !== 'axMap terminal bridge');
                 return hooks.length ? [{ ...group, hooks }] : [];
             });
-            config.hooks[event].push({ hooks: [{ type: 'command', command, timeout: 10, statusMessage: 'axMap terminal bridge' }] });
+            // Stop 은 대화 모드에서 상대를 최대 540초 기다린다(src/app-session). 공급자 기본 한도 600초를 그대로 준다.
+            // 대화 모드가 꺼져 있으면 지금처럼 바로 끝난다.
+            config.hooks[event].push({ hooks: [{ type: 'command', command, timeout: event === 'Stop' ? 600 : 10, statusMessage: 'axMap terminal bridge' }] });
         }
     }
     if (provider === 'agy')

package/src/terminal-bridge.mts

@@ -237,7 +237,9 @@ export function installTerminalHooks(home = os.homedir(), provider = 'agy') {
         const hooks = group.hooks.filter(h => h.statusMessage !== 'axMap terminal bridge')
         return hooks.length ? [{ ...group, hooks }] : []
       })
-      config.hooks[event].push({ hooks: [{ type: 'command', command, timeout: 10, statusMessage: 'axMap terminal bridge' }] })
+      // Stop 은 대화 모드에서 상대를 최대 540초 기다린다(src/app-session). 공급자 기본 한도 600초를 그대로 준다.
+      // 대화 모드가 꺼져 있으면 지금처럼 바로 끝난다.
+      config.hooks[event].push({ hooks: [{ type: 'command', command, timeout: event === 'Stop' ? 600 : 10, statusMessage: 'axMap terminal bridge' }] })
     }
   }
   if (provider === 'agy') config['axmap-terminal'] = definition

package/tools/bridge.mjs

@@ -9,6 +9,11 @@ import { sendTerminal } from '../src/terminal-bridge.mjs'
 import { sessionStatus, formatSessionStatus } from '../src/session-status.mjs'
 import { attachConsole } from '../src/external-console.mjs'
 import { postMail, collectMail, flushMail } from '../src/session-mailbox.mjs'
+import { setDialogueMode } from '../src/app-session.mjs'
+
+// Windows PowerShell 5.1 은 파이프로 넘기는 글 앞에 BOM 을 붙이고 줄바꿈을 CRLF 로 보낸다(2026-11-05 실측).
+// 그대로 두면 상대 AI 의 프롬프트 첫 글자에 보이지 않는 문자가 섞인다.
+const stdinText = () => fs.readFileSync(0, 'utf8').replace(/^\uFEFF/, '').replace(/\r\n/g, '\n')
 
 const args = process.argv.slice(2)
 const [command] = args
@@ -17,7 +22,7 @@ const output = (value) => console.log(JSON.stringify(value, null, 2))
 try {
   switch (command) {
     case 'message': {
-      const r = postMail({ to: option('to'), cwd: process.cwd(), text: fs.readFileSync(0, 'utf8'),
+      const r = postMail({ to: option('to'), cwd: process.cwd(), text: stdinText(),
         priority: option('priority') || 'boundary', reason: option('reason'), topic: option('topic'), key: option('key'),
         ttlSeconds: Number(option('ttl-seconds') || 3600) })
       output(r)
@@ -51,7 +56,7 @@ try {
       break
     }
     case 'chat': {
-      const options = { ...(option('id') ? { id: option('id') } : {}), left: option('left'), right: option('right'), prompt: fs.readFileSync(0, 'utf8'),
+      const options = { ...(option('id') ? { id: option('id') } : {}), left: option('left'), right: option('right'), prompt: stdinText(),
         maxTurns: Number(option('max-turns') || 4), maxTokens: Number(option('max-tokens') || 50000),
         maxMessageChars: Number(option('max-message-chars') || 2000),
         ...(option('timeout-ms') ? { timeoutMs: Number(option('timeout-ms')) } : {}),
@@ -63,7 +68,7 @@ try {
       break
     }
     case 'dialogue': output(dialogueResult(args[1])); break
-    case 'notice': output(await sendTerminal(option('to'), { action: 'notice', text: fs.readFileSync(0, 'utf8') })); break
+    case 'notice': output(await sendTerminal(option('to'), { action: 'notice', text: stdinText() })); break
     case 'stop': output(stopDialogue(args[1])); break
     case 'answer': output(await sendTerminal(option('to'), { action: 'answer', id: option('request'), decision: option('decision') })); break
     case 'install':
@@ -80,6 +85,14 @@ try {
       break
     }
     case 'sessions': output(sessions(process.cwd())); break
+    case 'mode': {
+      const on = args.includes('--on'), off = args.includes('--off')
+      if (on === off) throw new Error('bridge mode --session <UUID> --on|--off 중 하나를 주세요.')
+      const num = name => option(name) === undefined ? undefined : Number(option(name))
+      output(setDialogueMode({ session: option('session'), cwd: process.cwd(), on,
+        ...[['minutes', num('minutes')], ['maxTurns', num('max-turns')], ['waitSeconds', num('wait-seconds')]].reduce((o, [k, v]) => v === undefined ? o : { ...o, [k]: v }, {}) }))
+      break
+    }
     case 'status': {
       const listed = await sessionStatus()
       if (args.includes('--json')) output(listed)
@@ -89,7 +102,7 @@ try {
     case 'send': {
       const waitMs = Number(option('wait-ms') || 0)
       if (!Number.isInteger(waitMs) || waitMs < 0 || waitMs > 30000) throw new Error('wait-ms는 0~30000 정수여야 합니다.')
-      const r = dispatchRequest({ to: option('to'), prompt: fs.readFileSync(0, 'utf8'), cwd: process.cwd(), from: process.env.AXMAP_AGENT || 'axmap', queueIfBusy: !args.includes('--no-queue') })
+      const r = dispatchRequest({ to: option('to'), prompt: stdinText(), cwd: process.cwd(), from: process.env.AXMAP_AGENT || 'axmap', ...(option('from-session') ? { fromSession: option('from-session') } : {}), queueIfBusy: !args.includes('--no-queue') })
       const result = waitMs && ['queued', 'submitted'].includes(r.state) ? await waitForRequest(r.id, process.cwd(), waitMs) : r
       output(result)
       if (result.state === 'unknown') process.exitCode = 2
@@ -131,6 +144,9 @@ axmap bridge mailbox --to <UUID> [--all]
     읽기만 합니다. --take --at checkpoint로 작업 경계에서 묶음 회수 (모델 호출 없음).
 axmap bridge flush --to <UUID> --at task-complete|test-complete|experiment-complete|checkpoint
     필요할 때만 idle 수신자에게 큐를 한 요청으로 전달. 자동 감시·중단·재전송 없음.
+axmap bridge mode --session <앱 세션 UUID> --on|--off [--minutes 30] [--max-turns 8] [--wait-seconds 540]
+    앱(Claude 앱·Codex 앱)·codex 세션의 대화 모드. 켜면 응답이 끝날 때 상대 요청·회신을 기다렸다가 같은 대화에서 이어 갑니다.
+axmap bridge send ... --from-session <내 세션 UUID>   상대가 앱 세션이면 그 답이 내 세션으로 돌아옵니다(내가 대화 모드일 때)
 axmap bridge result <요청 UUID> [--wait-ms 30000]    제출/완료/불명 상태와 결과. 대기 중 모델 호출 없음
 관리형 stdio: Codex App Server / agy stream-json. PTY와 agentapi는 별도 실험 경로입니다.`)
       break

package/tools/run.mjs

@@ -4,6 +4,7 @@ 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'
+import { handleAppHook } from '../src/app-session.mjs'
 import { RPC_NOT_DELIVERED_EXIT } from '../src/session-types.mjs'
 
 const [command, ...args] = process.argv.slice(2)
@@ -22,13 +23,24 @@ try {
     }
   } else if (command === 'hook') {
     const input = JSON.parse(fs.readFileSync(0, 'utf8'))
+    let output = {}
     if (process.env.AXMAP_TERMINAL_SESSION && 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 || input.session_id)) {
-      try { registerExternalHook(input, args[0], args.includes('--provider') ? args[args.indexOf('--provider') + 1] : undefined) }
-      catch (e) { console.error(`axMap 독립 콘솔: ${e.message}`) }
+    } else if (input.conversationId || input.session_id) {
+      const provider = args.includes('--provider') ? args[args.indexOf('--provider') + 1] : undefined
+      // 콘솔 창이 있는 Windows agy·Claude 는 지금처럼 창에 입력하는 경로를 쓴다.
+      // 창이 없으면(앱, codex) 훅만으로 받는 앱 세션 경로로 간다.
+      let viaConsole = false
+      if (process.platform === 'win32' && provider !== 'codex') {
+        try { viaConsole = !!registerExternalHook(input, args[0], provider).id }
+        catch (e) { console.error(`axMap 독립 콘솔: ${e.message}`) }
+      }
+      if (!viaConsole && ['claude', 'codex'].includes(provider)) {
+        try { output = handleAppHook(input, args[0], provider) }
+        catch (e) { console.error(`axMap 앱 세션: ${e.message}`) }
+      }
     }
-    console.log('{}')
+    console.log(JSON.stringify(output))
   } else if (command === '--help' || !command) {
     console.log('axmap run agy|codex [기존 CLI 인수...] [--cwd 작업폴더]\n사용자가 여는 실제 CLI 터미널을 유지합니다. 별도 연결 URL은 필요 없습니다.')
   } else {