@jingyi0605/codingns4dsh 0.1.2 → 0.1.7-rc.3

package/data/build/dist/host/cli-adapters/codex-driver.js

@@ -1,15 +1,22 @@
 import { spawn, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
-import { JsonRpcProcess } from './json-rpc-process.js';
+import { basename, join, resolve } from 'node:path';
+import { JsonRpcProcess, JsonRpcRequestError } from './json-rpc-process.js';
 import { detectBinary, emptyCatalog, isRecord, textValue, usageChunk } from './rpc-driver-utils.js';
 import { CODEX_CATALOG, isProviderDefaultModel } from './model-catalog.js';
 import { probeStoredSession, readFirstJsonRecord } from './session-probe.js';
 import { firstToolText, normalizeToolStatus, serializeToolValue } from './tool-observation.js';
 import { isQuestionEvent, questionAnswersRecord, readAgentQuestions } from './interaction-events.js';
+// 只有 Provider 已明确报告超过窗口时才主动压缩；接近上限仍交给 Codex
+// 自身的 auto-compact，避免对正常的高占用回合重复发起压缩。
+const CODEX_COMPACTION_THRESHOLD = 1;
+const CODEX_COMPACTION_TIMEOUT_MS = 60_000;
 /** Codex app-server 的 JSON-RPC 驱动，Host 只暴露统一文本流，不暴露线程和 token。 */
 export class CodexAppServerDriver {
     descriptor = { id: 'codex', name: 'Codex', protocol: 'json-rpc', capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage', 'permission', 'questions', 'steer'] };
+    // Codex 一个 Provider turn 可能同时包含多个工具调用。只有 assistant item
+    // 切换后才分段，不能在每个工具完成后注入下一 step。
     supportsSegmentedTurns = true;
     binaries;
     runSpawnSync;
@@ -72,11 +79,12 @@ export class CodexAppServerDriver {
         const command = this.cachedBinary ?? (await this.detect()).command;
         if (command === null)
             throw new Error('Codex 未安装');
-        if (input.splitToolSteps) {
+        if (input.splitToolSteps && this.supportsSegmentedTurns) {
             yield* this.executeSegmentedTurn(input, command);
             return;
         }
         const session = await this.getSession(input, command);
+        prepareCodexSession(session, input);
         const rpc = session.rpc;
         try {
             if (session.threadId === '') {
@@ -86,13 +94,28 @@ export class CodexAppServerDriver {
                 session.threadId = readId(thread) ?? input.providerSessionId ?? input.sessionId;
                 session.providerSessionId = session.threadId;
             }
+            await this.ensureContextCapacity(session, input);
+            yield* drainCompactionEvents(session);
             yield { type: 'session-binding', providerSessionId: session.providerSessionId };
             const eventQueue = createCodexTurnEventQueue();
             let activeTurnId = null;
             let turnStartResolved = false;
             const notificationsBeforeTurnStart = [];
             let terminalReason = null;
+            let sawMeaningfulEvent = false;
             const acceptNotification = (message, allowUnidentifiedTool) => {
+                // Codex 自动压缩可能在独立的内部 turn 中运行。它不属于当前用户 turn，
+                // 但压缩 item 和 thread/compacted 必须继续进入公共投影层，否则压缩虽已发生，
+                // 原生会话不会显示任何 compaction 活动。
+                if (isCodexCompactionNotification(message, session.threadId)) {
+                    const notificationTurnId = readTurnId(message);
+                    // 显式 thread/compact/start 由 waitForCompaction 独占消费通知并生成
+                    // start/summary/end，当前 turn 队列不能再次投影同一组事件。
+                    if (!session.suppressCompactionNotifications
+                        && (notificationTurnId === null || !session.suppressedCompactionTurnIds.has(notificationTurnId)))
+                        eventQueue.push(message);
+                    return;
+                }
                 if (!isCodexNotificationForTurn(message, session.threadId, activeTurnId, allowUnidentifiedTool))
                     return;
                 const turnId = readTurnId(message);
@@ -129,20 +152,18 @@ export class CodexAppServerDriver {
             else
                 input.signal?.addEventListener('abort', onAbort, { once: true });
             try {
-                const response = await rpc.request('turn/start', {
-                    threadId: session.threadId,
-                    input: [{ type: 'text', text: input.prompt }],
-                    ...(input.effortId ? { effort: input.effortId } : {}),
-                }, { signal: input.signal, killOnAbort: false });
+                const response = await this.startTurn(session, input);
+                // turn/start 可能因上下文超限内部触发 compact；压缩事件在重试成功后
+                // 仍需先交给公共投影器，不能留在驱动的暂存队列里。
+                yield* drainCompactionEvents(session);
                 const responseTurnId = readTurnId(response);
                 if (responseTurnId !== null) {
                     activeTurnId = responseTurnId;
                     session.turnId = responseTurnId;
                 }
                 turnStartResolved = true;
-                // 响应前缓存的通知可能来自 thread/resume 的旧历史。没有 turnId 的工具
-                // 事件无法证明属于本次回合，因此只能丢弃；有明确 turnId 的事件仍按
-                // 原有规则处理。
+                // 响应前缓存的通知可能来自 thread/resume 的旧历史。没有 turnId 的事件
+                // 无法证明属于本次回合，因此只能丢弃；有明确 turnId 的事件仍按原有规则处理。
                 for (const message of notificationsBeforeTurnStart.splice(0))
                     acceptNotification(message, false);
                 // 某些 app-server 会直接在 turn/start 响应中返回终态。父仓库把它
@@ -151,9 +172,13 @@ export class CodexAppServerDriver {
                 if (responseTerminal !== null)
                     onNotification(responseTerminal);
                 for await (const message of eventQueue.iterable) {
-                    const chunk = codexMessageToChunk(message);
-                    if (chunk !== null)
-                        yield chunk;
+                    const rawChunk = codexMessageToChunk(message);
+                    if (rawChunk === null)
+                        continue;
+                    if (rawChunk.type !== 'finish')
+                        sawMeaningfulEvent = true;
+                    const chunk = stabilizeCodexEvent(session, rawChunk);
+                    yield chunk;
                 }
                 if (input.signal?.aborted)
                     await this.interrupt(input.sessionId);
@@ -168,18 +193,28 @@ export class CodexAppServerDriver {
                 removeNotificationListener();
                 eventQueue.close();
             }
-            yield { type: 'finish', reason: input.signal?.aborted ? 'cancel' : terminalReason ?? 'stop' };
+            // 终态 chunk 之后调用方不会再拉动本迭代器，turnId 必须在产出 finish
+            // 前复位，否则下一轮 steer/interrupt 会指向已经结束的 turn。
+            session.turnId = null;
+            if (!input.signal?.aborted && terminalReason !== 'cancel' && !sawMeaningfulEvent) {
+                yield { type: 'text-delta', text: 'CODINGNS_PROVIDER_EMPTY_RESPONSE: Codex Provider 未返回任何有效事件。' };
+                yield { type: 'finish', reason: 'error' };
+            }
+            else {
+                yield { type: 'finish', reason: input.signal?.aborted ? 'cancel' : terminalReason ?? 'stop' };
+            }
         }
         finally { /* app-server 在会话结束前保持连接。 */ }
     }
     /**
-     * 将一个 Codex turn 按工具完成点切成多个 DSH step。
+     * 将一个 Codex turn 按 assistant item 切成多个 DSH step。
      *
      * DSH 的 step 边界只能由 Agent Loop 提交；这里仅提前结束本次 llm/stream，
      * 保留同一个 Codex turn 的通知队列，下一次 llm/stream 再继续消费它。
      */
     async *executeSegmentedTurn(input, command) {
         const session = await this.getSession(input, command);
+        prepareCodexSession(session, input);
         const rpc = session.rpc;
         let active;
         try {
@@ -190,13 +225,31 @@ export class CodexAppServerDriver {
                 session.threadId = readId(thread) ?? input.providerSessionId ?? input.sessionId;
                 session.providerSessionId = session.threadId;
             }
-            active = session.segmentedTurn ?? await this.startSegmentedTurn(session, input);
-            const isNew = session.segmentedTurn === undefined;
+            // 只有 Host 显式声明续段时才复用挂起的 Provider 运行。新用户回合、注入
+            // 失败或取消后的下一次执行必须丢弃旧段：旧段要么已经跑完，要么其队列
+            // 已关闭，复用只会立刻产出 stop，把新消息变成空回合。
+            const suspended = input.resumeSegmentedTurn === true
+                && session.segmentedTurn !== undefined
+                && !session.segmentedTurn.done
+                ? session.segmentedTurn
+                : undefined;
+            if (suspended === undefined && session.segmentedTurn !== undefined) {
+                this.closeSegmentedTurn(session, session.segmentedTurn);
+            }
+            // 分段 step 仍属于同一个 Provider turn；恢复它时不能插入 compact turn。
+            const hasSuspendedTurn = suspended !== undefined;
+            if (!hasSuspendedTurn)
+                await this.ensureContextCapacity(session, input);
+            if (!hasSuspendedTurn)
+                yield* drainCompactionEvents(session);
+            active = suspended ?? await this.startSegmentedTurn(session, input);
+            yield* drainCompactionEvents(session);
+            const isNew = suspended === undefined;
             if (isNew)
                 session.segmentedTurn = active;
             if (isNew)
                 yield { type: 'session-binding', providerSessionId: session.providerSessionId };
-            for await (const chunk of this.consumeSegment(active, input))
+            for await (const chunk of this.consumeSegment(session, active, input))
                 yield chunk;
             if (active.done && session.segmentedTurn === active)
                 session.segmentedTurn = undefined;
@@ -219,9 +272,21 @@ export class CodexAppServerDriver {
             removeNotificationListener: () => undefined,
             terminalReason: null,
             done: false,
+            pendingChunk: undefined,
+            currentAssistantMessageId: undefined,
+            sawCompletedTool: false,
             removeAbortListener: () => undefined,
         };
         const acceptNotification = (message, allowUnidentifiedTool) => {
+            if (isCodexCompactionNotification(message, session.threadId)) {
+                const notificationTurnId = readTurnId(message);
+                // 显式 thread/compact/start 由 waitForCompaction 独占消费通知并生成
+                // start/summary/end，当前分段 turn 不能再次投影同一组事件。
+                if (!session.suppressCompactionNotifications
+                    && (notificationTurnId === null || !session.suppressedCompactionTurnIds.has(notificationTurnId)))
+                    eventQueue.push(message);
+                return;
+            }
             if (!isCodexNotificationForTurn(message, session.threadId, activeTurnId, allowUnidentifiedTool))
                 return;
             const turnId = readTurnId(message);
@@ -254,11 +319,7 @@ export class CodexAppServerDriver {
         else
             input.signal?.addEventListener('abort', onAbort, { once: true });
         try {
-            const response = await session.rpc.request('turn/start', {
-                threadId: session.threadId,
-                input: [{ type: 'text', text: input.prompt }],
-                ...(input.effortId ? { effort: input.effortId } : {}),
-            }, { signal: input.signal, killOnAbort: false });
+            const response = await this.startTurn(session, input);
             const responseTurnId = readTurnId(response);
             if (responseTurnId !== null) {
                 activeTurnId = responseTurnId;
@@ -277,28 +338,56 @@ export class CodexAppServerDriver {
             throw error;
         }
     }
-    async *consumeSegment(active, input) {
+    async *consumeSegment(session, active, input) {
         while (true) {
-            const next = await active.queue.next();
-            if (next.done) {
+            let chunk;
+            if (active.pendingChunk !== undefined) {
+                chunk = active.pendingChunk;
+                active.pendingChunk = undefined;
+            }
+            else {
+                const next = await active.queue.next();
+                if (next.done) {
+                    if (input.signal?.aborted)
+                        throw new Error('请求已取消');
+                    active.done = true;
+                    session.turnId = null;
+                    // finish 是调用方看到的最后一个 chunk，之后不会再拉动本迭代器。
+                    // 悬挂段必须在产出终态前解除，否则它会被当成下一轮的可续段复用。
+                    if (session.segmentedTurn === active)
+                        session.segmentedTurn = undefined;
+                    active.removeAbortListener();
+                    active.removeNotificationListener();
+                    yield { type: 'finish', reason: active.terminalReason ?? 'stop' };
+                    return;
+                }
                 if (input.signal?.aborted)
                     throw new Error('请求已取消');
-                active.done = true;
-                active.removeAbortListener();
-                active.removeNotificationListener();
-                yield { type: 'finish', reason: active.terminalReason ?? 'stop' };
-                return;
+                chunk = codexMessageToChunk(next.value);
             }
-            if (input.signal?.aborted)
-                throw new Error('请求已取消');
-            const chunk = codexMessageToChunk(next.value);
             if (chunk === null)
                 continue;
-            yield chunk;
-            if (chunk.type === 'tool-event' && (chunk.status === 'completed' || chunk.status === 'failed')) {
-                yield { type: 'step-boundary' };
-                return;
+            // 一个 assistant item 可能在多个工具调用之间切换。把新 item 的首个
+            // 正文留给下一次 llm/stream，当前流只返回边界，确保 DSH 先创建新 step。
+            if ((chunk.type === 'text-delta' || chunk.type === 'reasoning-delta')
+                && chunk.messageId !== undefined) {
+                const previousMessageId = active.currentAssistantMessageId;
+                if (previousMessageId !== undefined
+                    && previousMessageId !== chunk.messageId
+                    && active.sawCompletedTool) {
+                    active.pendingChunk = chunk;
+                    active.currentAssistantMessageId = chunk.messageId;
+                    active.sawCompletedTool = false;
+                    yield { type: 'step-boundary' };
+                    return;
+                }
+                active.currentAssistantMessageId = chunk.messageId;
             }
+            const stabilizedChunk = stabilizeCodexEvent(session, chunk);
+            if (stabilizedChunk.type === 'tool-event' && (stabilizedChunk.status === 'completed' || stabilizedChunk.status === 'failed')) {
+                active.sawCompletedTool = true;
+            }
+            yield stabilizedChunk;
         }
     }
     closeSegmentedTurn(session, active) {
@@ -309,6 +398,144 @@ export class CodexAppServerDriver {
         if (session.segmentedTurn === active)
             session.segmentedTurn = undefined;
     }
+    /** 在下一轮开始前主动压缩，避免把已满的线程直接交给 turn/start。 */
+    async ensureContextCapacity(session, input) {
+        if (session.contextWindow === undefined || session.contextTokens === undefined)
+            return;
+        // 达到窗口上限时下一轮还会追加用户输入，必须在 turn/start 前压缩；
+        // 只用严格大于会把恰好满窗的会话直接送进超限错误路径。
+        if (session.contextTokens < session.contextWindow * CODEX_COMPACTION_THRESHOLD)
+            return;
+        await this.compactThread(session, input);
+    }
+    /** turn/start 遇到上下文超限时压缩一次并重试，兼容关闭自动压缩的 Codex 配置。 */
+    async startTurn(session, input) {
+        try {
+            return await session.rpc.request('turn/start', codexTurnStartParams(input, session.threadId), { signal: input.signal, killOnAbort: false });
+        }
+        catch (error) {
+            if (!isContextWindowError(error))
+                throw error;
+            await this.compactThread(session, input);
+            return session.rpc.request('turn/start', codexTurnStartParams(input, session.threadId), { signal: input.signal, killOnAbort: false });
+        }
+    }
+    /** thread/compact/start 立即返回，真正完成由 contextCompaction turn 的终态通知表示。 */
+    async compactThread(session, input) {
+        if (session.compacting !== undefined)
+            return session.compacting;
+        // 在创建异步等待器前同步设置，避免多个 RPC 监听器交错处理同一批通知时
+        // 另一个监听器重复投影显式压缩事件。
+        session.suppressCompactionNotifications = true;
+        const compacting = this.waitForCompaction(session, input);
+        session.compacting = compacting;
+        try {
+            await compacting;
+            session.contextTokens = 0;
+        }
+        finally {
+            if (session.compacting === compacting)
+                session.compacting = undefined;
+            session.suppressCompactionNotifications = false;
+        }
+    }
+    async waitForCompaction(session, input) {
+        const compactionId = `codex-compaction-${randomUUID()}`;
+        session.pendingCompactionEvents.push({ type: 'context-compaction', phase: 'start', compactionId });
+        let compactTurnId = null;
+        let sawCompaction = false;
+        let summary;
+        let shadowedTokenCount;
+        let shadowedItemCount;
+        let resolveDone;
+        let rejectDone;
+        const done = new Promise((resolve, reject) => { resolveDone = resolve; rejectDone = reject; });
+        const onNotification = (message) => {
+            const params = isRecord(message.params) ? message.params : null;
+            if (readScopedId(params, ['threadId', 'thread_id'], 'thread') !== session.threadId)
+                return;
+            if (message.method === 'thread/compacted') {
+                const details = compactionDetails(params);
+                summary = details.summary ?? summary;
+                shadowedTokenCount = details.shadowedTokenCount ?? shadowedTokenCount;
+                shadowedItemCount = details.shadowedItemCount ?? shadowedItemCount;
+                resolveDone?.();
+                return;
+            }
+            if (message.method === 'item/started') {
+                const item = isRecord(params?.item) ? params.item : null;
+                if (isCodexCompactionItemType(item?.type)) {
+                    sawCompaction = true;
+                    compactTurnId = readTurnId(message);
+                    if (compactTurnId !== null)
+                        session.suppressedCompactionTurnIds.add(compactTurnId);
+                }
+                return;
+            }
+            if (message.method === 'item/completed') {
+                const item = isRecord(params?.item) ? params.item : null;
+                if (isCodexCompactionItemType(item?.type)) {
+                    const itemTurnId = readTurnId(message);
+                    if (itemTurnId !== null)
+                        session.suppressedCompactionTurnIds.add(itemTurnId);
+                    const details = compactionDetails(item);
+                    summary = details.summary ?? summary;
+                    shadowedTokenCount = details.shadowedTokenCount ?? shadowedTokenCount;
+                    shadowedItemCount = details.shadowedItemCount ?? shadowedItemCount;
+                }
+                return;
+            }
+            if (message.method !== 'turn/completed')
+                return;
+            const turnId = readTurnId(message);
+            if (sawCompaction && compactTurnId !== null && turnId !== compactTurnId)
+                return;
+            if (!sawCompaction && compactTurnId === null)
+                return;
+            const turn = isRecord(params?.turn) ? params.turn : null;
+            if (turn?.status === 'failed' || turn?.status === 'interrupted' || turn?.status === 'cancelled') {
+                rejectDone?.(new Error('Codex 上下文压缩失败'));
+            }
+            else {
+                resolveDone?.();
+            }
+        };
+        const removeListener = session.rpc.addNotificationListener(onNotification);
+        const timer = setTimeout(() => rejectDone?.(new Error('Codex 上下文压缩超时')), CODEX_COMPACTION_TIMEOUT_MS);
+        timer.unref?.();
+        try {
+            await session.rpc.request('thread/compact/start', { threadId: session.threadId }, { signal: input.signal, killOnAbort: false });
+            await done;
+            if (summary !== undefined || shadowedTokenCount !== undefined || shadowedItemCount !== undefined) {
+                // Codex 的 app-server 通知通常不携带被压缩 token 数。DSH 的
+                // contextPressure 必须用该数扣除已被替换的 surface；这里使用压缩前
+                // 最后一次 Provider prompt 规模作为保守锚点，不能把缺失值写成 0。
+                const resolvedShadowedTokenCount = shadowedTokenCount ?? session.contextTokens;
+                session.pendingCompactionEvents.push({
+                    type: 'context-compaction',
+                    phase: 'summary',
+                    compactionId,
+                    ...(summary === undefined ? {} : { summary }),
+                    ...(resolvedShadowedTokenCount === undefined ? {} : { shadowedTokenCount: resolvedShadowedTokenCount }),
+                    ...(shadowedItemCount === undefined ? {} : { shadowedItemCount }),
+                });
+            }
+            session.pendingCompactionEvents.push({ type: 'context-compaction', phase: 'end', compactionId });
+        }
+        catch (error) {
+            session.pendingCompactionEvents.push({
+                type: 'context-compaction',
+                phase: 'end',
+                compactionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            removeListener();
+        }
+    }
     /** 将新输入 steer 到当前 Codex turn。 */
     async steer(sessionId, prompt) {
         const session = this.sessions.get(sessionId);
@@ -329,17 +556,35 @@ export class CodexAppServerDriver {
         }
         catch { /* app-server 可能已经发出 turn/completed */ }
     }
+    /**
+     * 丢弃等待下一个 DSH step 的分段运行（取消、注入失败或切换适配器时）。
+     * 队列关闭后旧回合的通知不会再被投影进下一轮，续段标记同时解除。
+     */
+    discardSegmentedTurn(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session?.segmentedTurn === undefined)
+            return;
+        this.closeSegmentedTurn(session, session.segmentedTurn);
+    }
     /** 回传原生权限请求；审批值只在 Host 进程中流转。 */
     respondPermission(sessionId, response) {
         const session = this.sessions.get(sessionId);
-        const resolve = session?.pendingPermissions.get(response.requestId);
-        if (resolve === undefined || session === undefined)
+        const pending = session?.pendingPermissions.get(response.requestId);
+        if (pending === undefined || session === undefined)
             throw new Error('Codex 权限请求不存在');
         session.pendingPermissions.delete(response.requestId);
-        resolve({
-            approved: response.approved,
-            ...(response.reason?.trim() ? { reason: response.reason.trim().slice(0, 512) } : {}),
-        });
+        if (pending.response === 'file-change') {
+            pending.resolve({ decision: response.approved ? 'accept' : 'decline' });
+        }
+        else if (pending.response === 'command') {
+            pending.resolve({ decision: response.approved ? 'accept' : 'decline' });
+        }
+        else {
+            pending.resolve({
+                approved: response.approved,
+                ...(response.reason?.trim() ? { reason: response.reason.trim().slice(0, 512) } : {}),
+            });
+        }
     }
     /** 回传 requestUserInput 的结构化回答。 */
     respondQuestion(sessionId, response) {
@@ -354,8 +599,8 @@ export class CodexAppServerDriver {
         for (const session of this.sessions.values()) {
             if (session.segmentedTurn !== undefined)
                 this.closeSegmentedTurn(session, session.segmentedTurn);
-            for (const resolve of session.pendingPermissions.values())
-                resolve({ approved: false });
+            for (const pending of session.pendingPermissions.values())
+                pending.resolve({ approved: false });
             session.pendingPermissions.clear();
             for (const resolve of session.pendingQuestions.values())
                 resolve({ answers: {} });
@@ -377,16 +622,23 @@ export class CodexAppServerDriver {
         const session = {
             rpc,
             cwd: input.cwd,
+            modelId: input.modelId,
+            contextWindow: undefined,
+            contextTokens: undefined,
             threadId: '',
             turnId: null,
             providerSessionId: input.providerSessionId ?? input.sessionId,
             pendingPermissions: new Map(),
             pendingQuestions: new Map(),
             segmentedTurn: undefined,
+            compacting: undefined,
+            suppressCompactionNotifications: false,
+            suppressedCompactionTurnIds: new Set(),
+            pendingCompactionEvents: [],
         };
         this.processes.add(rpc);
         this.sessions.set(input.sessionId, session);
-        await rpc.request('initialize', { clientInfo: { name: 'codingns4dsh', version: '0.1.1' }, capabilities: {} }, { signal: input.signal, killOnAbort: false });
+        await rpc.request('initialize', { clientInfo: { name: 'codingns4dsh', version: '0.1.1' }, capabilities: { experimentalApi: true } }, { signal: input.signal, killOnAbort: false });
         rpc.notify('initialized', {});
         rpc.setServerRequestHandler((request) => {
             const requestId = readRequestId(request);
@@ -399,11 +651,60 @@ export class CodexAppServerDriver {
             if (isQuestionEvent(`${method} ${type}`)) {
                 return new Promise((resolve) => session.pendingQuestions.set(requestId, resolve));
             }
-            return new Promise((resolve) => session.pendingPermissions.set(requestId, resolve));
+            return new Promise((resolve) => session.pendingPermissions.set(requestId, {
+                resolve,
+                response: permissionResponseKind(method, params),
+            }));
         });
         return session;
     }
 }
+function stabilizeCodexUsage(session, event) {
+    if (event.type !== 'usage')
+        return event;
+    if (event.contextTokens !== undefined)
+        session.contextTokens = event.contextTokens;
+    if (event.contextWindow === undefined)
+        return event;
+    if (session.contextWindow === undefined) {
+        session.contextWindow = event.contextWindow;
+        return event;
+    }
+    if (session.contextWindow === event.contextWindow)
+        return event;
+    // 同一 Codex thread/model 的 usage 通知可能带有全局默认窗口或迟到旧值。
+    // 它不能覆盖首个已确认窗口，否则 DSH 会把 256K 错显示成 1M，并跳过压缩。
+    const contextTokens = event.contextTokens ?? event.inputTokens;
+    return {
+        ...event,
+        contextWindow: session.contextWindow,
+        contextTokens,
+        contextUsageRatio: Number(Math.min(1, contextTokens / session.contextWindow).toFixed(6)),
+    };
+}
+function stabilizeCodexEvent(session, event) {
+    if (event.type !== 'context-compaction')
+        return stabilizeCodexUsage(session, event);
+    // 自动压缩的 item 通知没有独立 usage。压缩结束后清零本地状态，避免下一轮
+    // 把压缩前的旧 prompt 规模误认为当前上下文并再次发起压缩。
+    if (event.phase === 'end') {
+        session.contextTokens = 0;
+        return event;
+    }
+    if (event.phase !== 'summary' || event.shadowedTokenCount !== undefined || session.contextTokens === undefined)
+        return event;
+    return { ...event, shadowedTokenCount: session.contextTokens };
+}
+function prepareCodexSession(session, input) {
+    // 未提供 modelId 表示沿用当前 Codex thread 的模型，不能因为配置字段缺省
+    // 就把已经确认的上下文容量清空。
+    if (input.modelId === undefined || session.modelId === input.modelId)
+        return;
+    // 模型切换意味着上下文容量可能改变；只有这类明确路由变化才允许重置
+    // 稳定窗口，同一模型的迟到 usage 不能触发重置。
+    session.modelId = input.modelId;
+    session.contextWindow = undefined;
+}
 function parseCodexCatalog(value) {
     const root = isRecord(value) && isRecord(value.data) ? value.data : value;
     const models = Array.isArray(root)
@@ -449,6 +750,39 @@ function codexMessageToChunk(message) {
     const method = typeof message.method === 'string' ? message.method : '';
     const type = typeof item.type === 'string' ? item.type : '';
     const text = textValue(params.delta ?? params.text ?? params.content ?? params.message);
+    if (isCodexCompactionItemType(type)) {
+        const details = compactionDetails(item);
+        const compactionId = firstToolText(item.id, params.itemId);
+        const phase = method === 'thread/compacted'
+            ? 'end'
+            : method.includes('started') || method.includes('start')
+                ? 'start'
+                : method.includes('completed') || method.includes('compacted') || method.includes('summary')
+                    ? 'summary'
+                    : 'end';
+        return {
+            type: 'context-compaction',
+            phase,
+            ...(compactionId === undefined ? {} : { compactionId }),
+            ...(details.summary === undefined ? {} : { summary: details.summary }),
+            ...(details.shadowedTokenCount === undefined ? {} : { shadowedTokenCount: details.shadowedTokenCount }),
+            ...(details.shadowedItemCount === undefined ? {} : { shadowedItemCount: details.shadowedItemCount }),
+        };
+    }
+    if (method === 'thread/compacted') {
+        const details = compactionDetails(params);
+        return {
+            type: 'context-compaction',
+            phase: 'end',
+            ...(details.summary === undefined ? {} : { summary: details.summary }),
+            ...(details.shadowedTokenCount === undefined ? {} : { shadowedTokenCount: details.shadowedTokenCount }),
+            ...(details.shadowedItemCount === undefined ? {} : { shadowedItemCount: details.shadowedItemCount }),
+        };
+    }
+    if (method === 'turn/completed' && isContextCompactionTurn(params.turn)) {
+        const compactionId = readTurnId(message);
+        return { type: 'context-compaction', phase: 'end', ...(compactionId === null ? {} : { compactionId }) };
+    }
     if (isQuestionEvent(`${method} ${type}`)) {
         const requestId = readRequestId(message) ?? readRequestId(params);
         const questions = readAgentQuestions(params.questions ?? item.questions ?? params);
@@ -457,9 +791,17 @@ function codexMessageToChunk(message) {
     }
     if (method.includes('permission') || method.includes('Approval') || type.includes('permission') || type.includes('approval')) {
         const requestId = readRequestId(message) ?? readRequestId(params);
-        const detail = text ?? (typeof params.command === 'string' ? params.command : typeof params.description === 'string' ? params.description : null);
+        const permission = codexPermissionDetails(method, params, item);
+        const detail = permission.detail ?? text ?? undefined;
         if (requestId !== null)
-            return { type: 'permission-request', requestId, kind: typeof params.kind === 'string' ? params.kind : 'unknown', ...(detail ? { detail } : {}) };
+            return {
+                type: 'permission-request',
+                requestId,
+                kind: permission.kind,
+                ...(permission.toolName === undefined ? {} : { toolName: permission.toolName }),
+                ...(permission.callId === undefined ? {} : { callId: permission.callId }),
+                ...(detail === undefined ? {} : { detail }),
+            };
     }
     const messageId = firstToolText(params.itemId, item.id);
     if (method.includes('agentMessage') || method.includes('message') && (type.includes('text') || type === '')) {
@@ -469,10 +811,10 @@ function codexMessageToChunk(message) {
         return text ? { type: 'reasoning-delta', text, ...(messageId === undefined ? {} : { messageId }) } : null;
     }
     if (isCodexToolEvent(method, type)) {
-        const name = firstToolText(item.name, item.toolName, item.tool, item.command !== undefined ? 'command_execution' : undefined, type);
+        const name = firstToolText(isFileChangeType(type) ? 'edit_file' : undefined, item.name, item.toolName, item.tool, item.command !== undefined ? 'command_execution' : undefined, type);
         const callId = firstToolText(item.callId, item.call_id, item.toolCallId, item.id, params.itemId);
         const agentId = firstToolText(item.agentId, item.agent_id, type.includes('agent') || type.includes('collab') ? item.id : undefined);
-        const input = serializeToolValue(item.arguments ?? item.input ?? item.command);
+        const input = serializeToolValue(isFileChangeType(type) ? fileChangeToolInput(item) : item.arguments ?? item.input ?? item.command);
         const rawOutput = item.result ?? item.output ?? item.aggregated_output;
         const explicitError = serializeToolValue(item.error);
         const output = serializeToolValue(rawOutput);
@@ -496,7 +838,71 @@ function codexMessageToChunk(message) {
     }
     return codexUsageChunk(params);
 }
-/** Codex app-server 的 tokenUsage 使用未缓存输入和缓存输入两个独立桶。 */
+function* drainCompactionEvents(session) {
+    while (session.pendingCompactionEvents.length > 0) {
+        const event = session.pendingCompactionEvents.shift();
+        if (event !== undefined)
+            yield event;
+    }
+}
+function compactionDetails(value) {
+    if (!isRecord(value))
+        return {};
+    const nested = isRecord(value.compaction) ? value.compaction : isRecord(value.item) ? value.item : value;
+    const summary = textValue(nested.summary ?? nested.summaryText ?? nested.compactionSummary);
+    const shadowedTokenCount = optionalToken(nested.shadowedTokenCount ?? nested.shadowed_tokens ?? nested.compactedTokens);
+    const shadowedItemCount = optionalToken(nested.shadowedItemCount ?? nested.shadowed_items ?? nested.compactedItems);
+    return {
+        ...(summary === null || summary.trim() === '' ? {} : { summary: summary.trim() }),
+        ...(shadowedTokenCount === undefined ? {} : { shadowedTokenCount }),
+        ...(shadowedItemCount === undefined ? {} : { shadowedItemCount }),
+    };
+}
+function isContextCompactionTurn(value) {
+    if (!isRecord(value))
+        return false;
+    const kind = String(value.type ?? value.kind ?? value.name ?? '').toLowerCase();
+    return kind.includes('contextcompaction') || kind.includes('compaction');
+}
+function codexPermissionDetails(method, params, item) {
+    const fileChange = method.includes('fileChange') || method.includes('file_change') || String(item.type ?? '').toLowerCase() === 'filechange';
+    const command = typeof params.command === 'string' ? params.command : typeof item.command === 'string' ? item.command : undefined;
+    const reason = typeof params.reason === 'string' ? params.reason : typeof params.description === 'string' ? params.description : undefined;
+    const grantRoot = typeof params.grantRoot === 'string' ? params.grantRoot : undefined;
+    const paths = permissionPaths(params.fileChanges ?? params.file_changes ?? item.changes);
+    const callId = firstToolText(params.callId, params.call_id, params.itemId, item.id);
+    const detail = [reason, command, paths.length > 0 ? `文件: ${paths.join(', ')}` : undefined, grantRoot ? `允许写入: ${grantRoot}` : undefined]
+        .filter((value) => value !== undefined && value.trim() !== '')
+        .join('；');
+    return {
+        kind: typeof params.kind === 'string' ? params.kind : fileChange ? 'file_change' : 'command',
+        ...(fileChange ? { toolName: 'edit' } : {}),
+        ...(callId === undefined ? {} : { callId }),
+        ...(detail === '' ? {} : { detail }),
+    };
+}
+function permissionPaths(value) {
+    if (Array.isArray(value))
+        return value.flatMap((entry) => permissionPaths(entry));
+    if (!isRecord(value))
+        return [];
+    const path = firstToolText(value.path, value.filePath, value.file_path);
+    return path === undefined ? [] : [path];
+}
+function isFileChangeType(type) {
+    return type.replace(/[_-]/gu, '').toLowerCase() === 'filechange';
+}
+function fileChangeToolInput(item) {
+    const changes = Array.isArray(item.changes) ? item.changes : [];
+    return {
+        changes: changes.map((change) => isRecord(change) ? {
+            file_path: firstToolText(change.path, change.filePath, change.file_path) ?? '',
+            ...(typeof change.kind === 'string' ? { kind: change.kind } : {}),
+            ...(typeof change.diff === 'string' ? { diff: change.diff } : typeof change.patch === 'string' ? { diff: change.patch } : {}),
+        } : change),
+    };
+}
+/** Codex app-server 的 inputTokens 是含缓存读取的完整输入，cachedInputTokens 是其中已命中的子集。 */
 function codexUsageChunk(params) {
     const tokenUsage = isRecord(params.tokenUsage) ? params.tokenUsage : isRecord(params.token_usage) ? params.token_usage : null;
     if (tokenUsage === null)
@@ -510,11 +916,10 @@ function codexUsageChunk(params) {
                 : isRecord(tokenUsage.total)
                     ? tokenUsage.total
                     : tokenUsage;
-    const uncachedInputTokens = optionalToken(latest.inputTokens ?? latest.input_tokens);
+    const inputTokens = optionalToken(latest.inputTokens ?? latest.input_tokens);
     const cacheReadTokens = optionalToken(latest.cachedInputTokens ?? latest.cached_input_tokens);
     const usage = usageChunk({
-        inputTokens: uncachedInputTokens ?? 0,
-        ...(uncachedInputTokens === undefined ? {} : { uncachedInputTokens }),
+        inputTokens: inputTokens ?? 0,
         ...(latest.outputTokens === undefined && latest.output_tokens === undefined ? {} : { outputTokens: latest.outputTokens ?? latest.output_tokens }),
         ...(cacheReadTokens === undefined ? {} : { cacheReadTokens }),
         ...(latest.totalTokens === undefined && latest.total_tokens === undefined ? {} : { totalTokens: latest.totalTokens ?? latest.total_tokens }),
@@ -534,7 +939,7 @@ function codexUsageChunk(params) {
         ?? params.contextWindow
         ?? params.context_window);
     const contextWindow = contextWindowValue !== undefined && contextWindowValue > 0 ? contextWindowValue : undefined;
-    const contextTokens = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+    const contextTokens = usage.inputTokens;
     return {
         ...usage,
         ...(contextWindow === undefined ? {} : {
@@ -616,12 +1021,46 @@ function isCodexNotificationForTurn(message, threadId, turnId, allowUnidentified
     const notificationTurnId = readTurnId(message);
     if (notificationThreadId !== null && notificationThreadId !== threadId)
         return false;
-    // turn/start 响应前的无 turnId 工具通知无法证明属于本次回合，通常是
-    // thread/resume 的迟到历史；响应后则把它交给当前开放的 DSH step 处理。
-    if (notificationTurnId === null && isCodexToolNotification(message) && !allowUnidentifiedTool)
+    // 权限/问题审批是 Codex 发起的 JSON-RPC 请求，必须先交给交互层，不能因
+    // 它的 turnId 尚未出现在 turn/start 响应中而丢弃。
+    if (message.id !== undefined && message.id !== null)
+        return true;
+    // 响应返回前 activeTurnId 为空；带 turnId 的旧通知不能提前关闭新回合队列。
+    if (turnId === null && notificationTurnId !== null)
+        return false;
+    // turn/start 响应前的无 turnId 通知无法证明属于本次回合，尤其不能让迟到的
+    // 无标识 turn/completed 直接关闭新回合；响应后再交给当前开放的 DSH step。
+    if (notificationTurnId === null && !allowUnidentifiedTool)
         return false;
     return turnId === null || notificationTurnId === null || notificationTurnId === turnId;
 }
+function isCodexCompactionNotification(message, threadId) {
+    const params = isRecord(message.params) ? message.params : null;
+    if (readScopedId(params, ['threadId', 'thread_id'], 'thread') !== null
+        && readScopedId(params, ['threadId', 'thread_id'], 'thread') !== threadId)
+        return false;
+    if (message.method === 'thread/compacted')
+        return true;
+    if (message.method !== 'item/started' && message.method !== 'item/completed')
+        return false;
+    const item = isRecord(params?.item) ? params.item : null;
+    return isCodexCompactionItemType(item?.type);
+}
+function isCodexCompactionItemType(value) {
+    return value === 'contextCompaction' || value === 'context_compaction' || value === 'context-compaction';
+}
+function isContextWindowError(error) {
+    if (error instanceof JsonRpcRequestError)
+        return hasContextWindowError(error.data);
+    return hasContextWindowError(error);
+}
+function hasContextWindowError(value) {
+    if (typeof value === 'string')
+        return /context[_-]?window[_-]?exceeded|context window exceeded/iu.test(value);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, child]) => /context.?window.?exceeded/iu.test(key) || hasContextWindowError(child));
+}
 function readCodexTerminalReason(message) {
     if (message.method === 'error') {
         const params = isRecord(message.params) ? message.params : null;
@@ -631,7 +1070,7 @@ function readCodexTerminalReason(message) {
         return null;
     const params = isRecord(message.params) ? message.params : null;
     const turn = isRecord(params?.turn) ? params.turn : null;
-    if (turn?.status === 'failed')
+    if (turn?.status === 'failed' || hasContextWindowError(turn?.error))
         return 'error';
     if (turn?.status === 'interrupted' || turn?.status === 'cancelled')
         return 'cancel';
@@ -661,16 +1100,33 @@ function isCodexToolEvent(method, type) {
     const normalized = type.replace(/[_-]/gu, '').toLowerCase();
     return ['commandexecution', 'filechange', 'mcptoolcall', 'functioncall', 'customtoolcall', 'dynamictoolcall'].includes(normalized);
 }
-function isCodexToolNotification(message) {
-    // 带 id 的消息是 Codex 发起的 JSON-RPC 服务请求（例如权限审批），
-    // 必须交给 serverRequestHandler，不能被当成实时工具通知过滤掉。
-    if (message.id !== undefined && message.id !== null)
-        return false;
-    const params = isRecord(message.params) ? message.params : null;
-    const item = isRecord(params?.item) ? params.item : params;
-    const method = typeof message.method === 'string' ? message.method : '';
-    const type = typeof item?.type === 'string' ? item.type : '';
-    return isCodexToolEvent(method, type);
+function codexTurnStartParams(input, threadId) {
+    const cwd = resolve(input.cwd ?? process.cwd());
+    return {
+        threadId,
+        input: [{ type: 'text', text: input.prompt }],
+        cwd,
+        // DSH 的 workspace-write 只约束自身工具沙箱，不会自动传递给 Codex
+        // app-server。显式声明当前工作区，避免 Codex 将文件编辑误判为只读越权。
+        sandboxPolicy: {
+            type: 'workspaceWrite',
+            writableRoots: [cwd],
+            networkAccess: false,
+            excludeTmpdirEnvVar: false,
+            excludeSlashTmp: false,
+        },
+        approvalPolicy: 'on-request',
+        ...(input.effortId ? { effort: input.effortId } : {}),
+    };
+}
+function permissionResponseKind(method, params) {
+    if (method.includes('fileChange') || method.includes('file_change'))
+        return 'file-change';
+    // 新版 Codex 带 threadId/turnId/itemId，并要求 decision；旧版测试和旧
+    // app-server 使用 approved 字段，按请求形状保持向后兼容。
+    if (method.includes('commandExecution') && (params.threadId !== undefined || params.turnId !== undefined || params.itemId !== undefined))
+        return 'command';
+    return 'legacy';
 }
 function readId(value) {
     if (!isRecord(value))