@deepseek-harness-tui/dsh-tui 0.14.1 → 0.16.0

package/lib/types/backends/codex/session/input.js

@@ -1,4 +1,4 @@
-import { t } from '../../../i18n.js';
+import { codexText } from '../text.js';
 import { errorText, rec, str } from '../narrow.js';
 import { CLIENT } from '../protocol/index.js';
 import { codexImageInputs } from './images.js';
@@ -18,8 +18,13 @@ export function userInputOf(input) {
 export function createInputQueue(deps) {
     /** The running turn (from its start answer or `turn/started`). */
     let activeTurnId;
+    /** Inline reviews can use a different id for items/completion than the
+     *  one announced by `turn/started` (Codex 0.160.1). */
+    let reviewTurnId;
     /** A `turn/start` in flight: resolves with the turn id (undefined = it failed). */
     let starting;
+    /** Reviews announce their interrupt id separately from their request id. */
+    let resolveReviewStart;
     /** Inputs not sent yet (the client follow-up queue). */
     let queue = [];
     /** Sent with `turn/start`, not yet claimed by their user message. */
@@ -45,6 +50,13 @@ export function createInputQueue(deps) {
         deps.clock.clearTimeout(forceTimer);
         forceTimer = undefined;
     };
+    const settleReviewStart = (id) => {
+        if (resolveReviewStart === undefined)
+            return;
+        resolveReviewStart(id);
+        resolveReviewStart = undefined;
+        starting = undefined;
+    };
     /** Send one input as a new turn. */
     const startTurn = async (entry) => {
         started.set(entry.id, entry);
@@ -68,7 +80,7 @@ export function createInputQueue(deps) {
             deps.startFailed?.(error, overrides);
             started.delete(entry.id);
             resolveStart(undefined);
-            const reason = t('codex-turn-start-failed', { err: errorText(error) });
+            const reason = codexText('codex-turn-start-failed', { err: errorText(error) });
             deps.debug(`codex: turn/start failed (${errorText(error)})`);
             deps.emit([pendingEvent({ discarded: [entry.id] })]);
             return { accepted: false, reason };
@@ -86,7 +98,7 @@ export function createInputQueue(deps) {
             return;
         void startTurn(next).then(result => {
             if (!result.accepted)
-                deps.emit([{ type: 'notice', level: 'error', text: result.reason ?? t('codex-turn-start-failed', { err: '' }) }]);
+                deps.emit([{ type: 'notice', level: 'error', text: result.reason ?? codexText('codex-turn-start-failed', { err: '' }) }]);
             else
                 drain();
         });
@@ -112,14 +124,16 @@ export function createInputQueue(deps) {
             queue.push(entry);
             if (!steerFallbackSaid) {
                 steerFallbackSaid = true;
-                deps.emit([{ type: 'notice', level: 'info', text: t('codex-steer-fallback') }]);
+                deps.emit([{ type: 'notice', level: 'info', text: codexText('codex-steer-fallback') }]);
             }
             drain();
             return { accepted: true };
         }
     };
-    const interrupt = async () => {
-        const turnId = activeTurnId ?? await starting;
+    const interrupt = async (waitForReviewStart = true) => {
+        // Dispose has already stopped notification delivery. It cannot wait for
+        // a review lifecycle id that only a notification could resolve.
+        const turnId = activeTurnId ?? (resolveReviewStart !== undefined && !waitForReviewStart ? undefined : await starting);
         if (turnId === undefined)
             return true;
         try {
@@ -134,8 +148,8 @@ export function createInputQueue(deps) {
                 forceTimer = undefined;
                 if (activeTurnId !== turnId)
                     return;
-                deps.emit([{ type: 'notice', level: 'warning', text: t('codex-cancel-forced') }]);
-                deps.forceClose();
+                deps.emit([{ type: 'notice', level: 'warning', text: codexText('codex-cancel-forced') }]);
+                deps.forceClose(turnId, reviewTurnId);
                 onTurnCompleted(turnId, true);
             }, deps.forceSettleMs);
         }
@@ -143,10 +157,12 @@ export function createInputQueue(deps) {
     };
     /** The turn ended: settle unclaimed inputs, then start the next queued one. */
     const onTurnCompleted = (turnId, interrupted) => {
-        if (turnId !== undefined && activeTurnId !== undefined && turnId !== activeTurnId)
+        if (turnId !== undefined && activeTurnId !== undefined && turnId !== activeTurnId && turnId !== reviewTurnId)
             return;
         clearForceTimer();
+        settleReviewStart();
         activeTurnId = undefined;
+        reviewTurnId = undefined;
         const cause = cancelCause;
         cancelCause = undefined;
         const events = [];
@@ -184,14 +200,14 @@ export function createInputQueue(deps) {
         busy() { return activeTurnId !== undefined || starting !== undefined; },
         async submit(input, placement, wireInput) {
             if (deps.closed())
-                throw new Error(t('codex-session-closed'));
+                throw new Error(codexText('codex-session-closed'));
             if (dead)
-                throw new Error(t('codex-connection-dead'));
+                throw new Error(codexText('codex-connection-dead'));
             if ((input.images ?? []).length === 0 && (input.blocks ?? []).some(block => block.type === 'image'))
-                throw new Error(t('codex-image-unreadable', { name: input.clientMessageId }));
+                throw new Error(codexText('codex-image-unreadable', { name: input.clientMessageId }));
             const pictureInputs = await codexImageInputs(input.images ?? []);
             if (deps.closed())
-                throw new Error(t('codex-session-closed'));
+                throw new Error(codexText('codex-session-closed'));
             const entry = { id: input.clientMessageId, text: input.text, input: [...(wireInput ?? userInputOf(input)), ...pictureInputs], placement: placement === 'steer' ? 'steer' : 'followup' };
             if (offline) {
                 queue.push(entry);
@@ -249,6 +265,28 @@ export function createInputQueue(deps) {
         },
         onTurnStarted(turnId) {
             activeTurnId = turnId;
+            settleReviewStart(turnId);
+        },
+        /** Reserve the turn before review/start reaches the server. The returned
+         *  cleanup releases only this request's wait if its RPC fails. */
+        beginReview() {
+            const pending = new Promise(resolve => { resolveReviewStart = resolve; });
+            starting = pending;
+            return () => {
+                if (starting !== pending)
+                    return;
+                settleReviewStart();
+                reviewTurnId = undefined;
+                cancelCause = undefined;
+                drain();
+            };
+        },
+        onReviewStarted(turnId) {
+            reviewTurnId = turnId;
+            // review/start's id cannot be used by turn/interrupt. Keep submissions
+            // queued and let an early Esc wait for the native lifecycle id.
+            if (activeTurnId === undefined && starting === undefined)
+                starting = new Promise(resolve => { resolveReviewStart = resolve; });
         },
         onTurnCompleted,
         /** Re-queue a rejection's reason as the next turn (D10). */
@@ -260,7 +298,9 @@ export function createInputQueue(deps) {
         connectionLost() {
             offline = true;
             clearForceTimer();
+            settleReviewStart();
             activeTurnId = undefined;
+            reviewTurnId = undefined;
             const lost = [...started.keys(), ...steered.keys()];
             started.clear();
             steered.clear();
@@ -284,9 +324,11 @@ export function createInputQueue(deps) {
         /** Dispose: forget everything, stop the timer. */
         close() {
             clearForceTimer();
+            settleReviewStart();
             queue = [];
             started.clear();
             steered.clear();
+            reviewTurnId = undefined;
         },
         /** Interrupt the running turn (best-effort, dispose path). */
         interrupt,

package/lib/types/backends/codex/session/plan-review.js

@@ -1,4 +1,4 @@
-import { t } from '../../../i18n.js';
+import { codexText } from '../text.js';
 import { errorText } from '../narrow.js';
 import { PLAN_IMPLEMENTATION_PROMPT } from './prompts.js';
 export function createPlanReview(deps) {
@@ -15,13 +15,13 @@ export function createPlanReview(deps) {
             withdraw();
             if (plan.trim() === '')
                 return;
-            const yes = t('codex-plan-yes');
-            const clear = t('codex-plan-clear');
-            const stay = t('codex-plan-stay');
+            const yes = codexText('codex-plan-yes');
+            const clear = codexText('codex-plan-clear');
+            const stay = codexText('codex-plan-stay');
             const id = `codex-plan:${turnId}`;
             pending = { id, plan, yes, clear, stay };
             deps.emit([{ type: 'question.request', request: { requestId: id, questions: [{
-                                question: t('codex-plan-implement'), header: t('codex-mode-plan'), detail: plan,
+                                question: codexText('codex-plan-implement'), header: codexText('codex-mode-plan'), detail: plan,
                                 options: [{ label: yes }, { label: clear }, { label: stay }],
                                 intent: { kind: 'plan-review', approve: yes, approveAlso: [clear], decline: stay },
                             }] } }]);
@@ -38,7 +38,7 @@ export function createPlanReview(deps) {
                 : selected === current.yes ? () => deps.implement()
                     : answer?.custom?.trim() ? () => deps.followup(answer.custom.trim()) : undefined;
             if (action !== undefined)
-                void action().catch(error => deps.emit([{ type: 'notice', level: 'error', key: 'codex-plan-action', text: t('codex-plan-action-failed', { error: errorText(error) }) }]));
+                void action().catch(error => deps.emit([{ type: 'notice', level: 'error', key: 'codex-plan-action', text: codexText('codex-plan-action-failed', { error: errorText(error) }) }]));
         },
         cancel(id) { if (pending?.id === id)
             withdraw(); },

package/lib/types/backends/codex/session/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/session.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAc,YAAY,EAAoD,MAAM,2BAA2B,CAAA;AAI3H,OAAO,EAAuC,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAwB5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAOhE,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY,CAkB7E;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAKpF;AAED;;qBAEqB;AACrB,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAwrBpF"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/session.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAc,YAAY,EAAoD,MAAM,2BAA2B,CAAA;AAI3H,OAAO,EAAuC,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAyB5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAOhE,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY,CAkB7E;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAKpF;AAED;;qBAEqB;AACrB,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAuuBpF"}

package/lib/types/backends/codex/session/session.js

@@ -20,8 +20,8 @@
  *   detach and release the hub. Idempotent.
  */
 import { randomUUID } from 'node:crypto';
-import { t } from '../../../i18n.js';
-import { CODEX_BACKEND_ID, codexVersionDrift, VALIDATED_CODEX_VERSIONS } from '../contract.js';
+import { codexText, installCodexLocale } from '../text.js';
+import { CODEX_BACKEND_ID, codexVersionDrift, compareCodexVersions, MIN_CODEX_BEFORE_TURN_FORK_VERSION, parseCodexVersion, VALIDATED_CODEX_VERSIONS } from '../contract.js';
 import { CODEX_MODE_PARAMS, DEFAULT_CODEX_MODE, isCodexModeId, modeIdOf } from '../modes.js';
 import { arr, errorText, num, rec, str, text } from '../narrow.js';
 import { CLIENT, NOTIFY } from '../protocol/index.js';
@@ -34,6 +34,7 @@ import { rateLimitOf } from '../translate/usage.js';
 import { resolveCodexStartOptions } from '../prefs.js';
 import { createCodexAuthCapability } from '../auth/status.js';
 import { createApprovalBridge } from './approvals.js';
+import { createAsyncQuestions } from './async-questions.js';
 import { createCodexControls } from './controls.js';
 import { createCodexCommands } from './commands.js';
 import { createPlanReview, PLAN_IMPLEMENTATION_PROMPT } from './plan-review.js';
@@ -73,15 +74,21 @@ export function openedThread(response, fallbackCwd) {
 export function openFailureText(error, threadId) {
     const message = errorText(error);
     if (/already has an active writer/iu.test(message))
-        return t('codex-thread-busy', { id: threadId ?? '' });
+        return codexText('codex-thread-busy', { id: threadId ?? '' });
     if (threadId !== undefined && rpcCode(error) === RPC_ERROR.invalidRequest)
-        return t('codex-resume-not-found', { id: threadId, err: message });
+        return codexText('codex-resume-not-found', { id: threadId, err: message });
     return message;
 }
 /** Open (create or resume) a thread and wrap it as a session. Throws a
  *  user-facing sentence when the thread cannot be opened; the hub retain is
  *  released then. */
 export async function openCodexSession(deps) {
+    // This backend's own copy follows the host's language (B-5): a session the
+    // host opened has already installed it in `detect()`/`open()`, and a caller
+    // that builds the deps itself (a regression fixture) says so here or keeps
+    // the documented `zh` fallback.
+    if (deps.host.locale !== undefined)
+        installCodexLocale(deps.host.locale);
     const { hub } = deps;
     const clock = deps.clock ?? REAL_CLOCK;
     const debug = deps.host.debug;
@@ -127,7 +134,7 @@ export async function openCodexSession(deps) {
     if (opened.threadId === '') {
         detach?.();
         deps.release();
-        throw new Error(t('codex-open-failed', { err: 'no thread id' }));
+        throw new Error(codexText('codex-open-failed', { err: 'no thread id' }));
     }
     let threadId = opened.threadId;
     const ctx = createItemContext({ cwd: opened.cwd, debug, model: opened.model, ...(deps.now === undefined ? {} : { now: deps.now }) });
@@ -215,7 +222,14 @@ export async function openCodexSession(deps) {
         overrides: () => controls.turnOverrides(),
         startFailed: (error, overrides) => controls.turnFailed(error, overrides),
         closed: () => disposing || permanentlyLost,
-        forceClose: () => { output.flush(); emit(live.forceClose({ kind: 'interrupted' })); },
+        forceClose: (turnId, reviewTurnId) => {
+            output.flush();
+            asyncQuestions.withdraw();
+            seenOf(turnId).ended = true;
+            if (reviewTurnId !== undefined)
+                seenOf(reviewTurnId).ended = true;
+            emit([...live.forceClose({ kind: 'interrupted' }), { type: 'session.status', status: 'idle' }]);
+        },
         clock,
         forceSettleMs: deps.forceSettleMs ?? DEFAULT_FORCE_SETTLE_MS,
     });
@@ -235,6 +249,7 @@ export async function openCodexSession(deps) {
         enqueueFollowup: (id, followup) => input.enqueueFollowup(id, followup),
         interruptTurn: () => { void input.interrupt(); },
     });
+    const asyncQuestions = createAsyncQuestions({ input, emit: events => emit(events, 'sync', true) });
     const activity = createCodexActivity({ clock, now: ctx.now, emit });
     const subagents = createCodexSubagents({ hub, cwd: opened.cwd, threadId: () => threadId, nextSeq: ctx.nextSeq, now: ctx.now, emit: (events, wake) => deliver(events, wake ?? 'sync'), debug });
     subagents.seed(replayHistory ?? []);
@@ -244,7 +259,7 @@ export async function openCodexSession(deps) {
     const submitText = async (text) => {
         const result = await input.submit({ text, clientMessageId: randomUUID() }, 'followup');
         if (!result.accepted)
-            throw new Error(result.reason ?? t('codex-turn-start-failed', { err: '' }));
+            throw new Error(result.reason ?? codexText('codex-turn-start-failed', { err: '' }));
     };
     const controls = createCodexControls({
         hub, prefs: deps.prefs, ctx, settings, cwd: opened.cwd,
@@ -254,12 +269,27 @@ export async function openCodexSession(deps) {
         actualModel: id => deps.channels?.active()?.models?.[id] ?? id,
     });
     const sideQueries = createCodexSideQuery({ hub, settings, cwd: opened.cwd, clock, threadId: () => threadId, closed: () => disposing || permanentlyLost, debug });
+    const noteReviewStarted = (id) => {
+        // Completed and force-settled reviews may still send new item ids or a
+        // late review/start answer; neither may reopen the input wait gate.
+        if (seenTurns.get(id)?.ended !== true)
+            input.onReviewStarted(id);
+    };
     const commands = createCodexCommands({
         hub, ctx, cwd: opened.cwd, threadId: () => threadId, busy: () => input.busy(), emit,
         lastDiff: () => lastDiff, planSupported: () => controls.planSupported,
         setPlan: () => controls.capabilities.modes.set('plan'),
+        exitPlan: async () => {
+            // The same target the plan-review exits use: the permission preset that
+            // was active before Plan. Skip the write when Plan is already off —
+            // there is nothing to restore and `set` still issues a settings update.
+            if (controls.capabilities.modes.current() !== 'plan')
+                return;
+            await controls.capabilities.modes.set(settings.permissionMode ?? DEFAULT_CODEX_MODE);
+        },
         submit: (next, placement, wire) => input.submit(next, placement, wire),
-        noteTurnStarted: id => input.onTurnStarted(id),
+        beginReview: () => input.beginReview(),
+        noteReviewStarted,
     });
     const planReview = createPlanReview({
         emit: events => emit(events, 'sync', true),
@@ -311,9 +341,10 @@ export async function openCodexSession(deps) {
         const response = rec(await hub.call(CLIENT.threadStart, { cwd: opened.cwd, ...resumeOverrides() })) ?? {};
         const next = openedThread(response, opened.cwd);
         if (next.threadId === '')
-            throw new Error(t('codex-open-failed', { err: 'no thread id' }));
+            throw new Error(codexText('codex-open-failed', { err: 'no thread id' }));
         const previous = threadId;
         approvals.withdrawAll();
+        asyncQuestions.withdraw();
         authBridge?.withdrawAll();
         output.close();
         for (const unroute of childRoutes.values())
@@ -364,7 +395,7 @@ export async function openCodexSession(deps) {
             if (entry.kind === 'stderr' && /bubblewrap/iu.test(entry.message)) {
                 bubblewrapWarned = true;
                 if (process.platform === 'linux' && settings.permissionMode !== 'full-access')
-                    emit([{ type: 'notice', level: 'warning', key: 'codex-bwrap', text: t('codex-bwrap-warning') }]);
+                    emit([{ type: 'notice', level: 'warning', key: 'codex-bwrap', text: codexText('codex-bwrap-warning') }]);
             }
         },
         notification(method, params) {
@@ -411,6 +442,7 @@ export async function openCodexSession(deps) {
             tasks.notification(method, params);
             if (goals.notification(method, params))
                 return;
+            asyncQuestions.notification(method, params);
             commands.note(method);
             if (controls.note(method, params))
                 return;
@@ -426,6 +458,8 @@ export async function openCodexSession(deps) {
                 }
                 case NOTIFY.itemStarted: {
                     const item = rec(params.item);
+                    if (item?.type === 'enteredReviewMode' && nativeTurn !== undefined)
+                        noteReviewStarted(nativeTurn);
                     const clientId = item?.type === 'userMessage' ? str(item.clientId) : undefined;
                     if (clientId !== undefined) {
                         const claimed = input.claim(clientId);
@@ -454,9 +488,13 @@ export async function openCodexSession(deps) {
             }
             if (method === NOTIFY.turnCompleted) {
                 approvals.turnEnded();
+                asyncQuestions.withdraw();
                 const turn = rec(params.turn);
                 deliver([...before, ...events, { type: 'session.status', status: 'idle' }], wakeOf(method, events));
+                const activeTurnId = input.activeTurnId;
                 input.onTurnCompleted(str(turn?.id), str(turn?.status) === 'interrupted');
+                if (activeTurnId !== undefined && input.activeTurnId !== activeTurnId)
+                    seenOf(activeTurnId).ended = true;
                 if (str(turn?.status) === 'completed' && settings.modeId === 'plan' && lastPlan !== undefined && approvals.size === 0 && !input.busy())
                     planReview.offer(str(turn?.id) ?? ctx.turnId, lastPlan);
                 return;
@@ -484,6 +522,7 @@ export async function openCodexSession(deps) {
             sideQueries.reset();
             permanentlyLost = permanent;
             approvals.withdrawAll();
+            asyncQuestions.withdraw();
             authBridge?.withdrawAll();
             activity.reset();
             planReview.withdraw();
@@ -494,7 +533,7 @@ export async function openCodexSession(deps) {
                 // ever drain that queue, so parking forever would lie to the user.
                 ...(permanent ? live.forceClose({ kind: 'error', message: errorText(error) }) : []),
                 ...(permanent ? input.permanentLoss() : input.connectionLost()),
-                { type: 'notice', level: permanent ? 'error' : 'warning', key: 'codex-connection', text: permanent ? t('codex-connection-failed', { err: errorText(error) }) : t('codex-connection-lost') },
+                { type: 'notice', level: permanent ? 'error' : 'warning', key: 'codex-connection', text: permanent ? codexText('codex-connection-failed', { err: errorText(error) }) : codexText('codex-connection-lost') },
                 { type: 'session.status', status: !permanent && ctx.turnOpen ? 'running' : 'idle' },
             ]);
         },
@@ -530,8 +569,8 @@ export async function openCodexSession(deps) {
                     permanentlyLost = true;
                     rejoining = false;
                     reconnectHeld.length = 0;
-                    emit([...live.forceClose({ kind: 'error', message: t('codex-reconnect-incomplete') }),
-                        { type: 'notice', level: 'warning', key: 'codex-connection', text: t('codex-reconnect-incomplete') },
+                    emit([...live.forceClose({ kind: 'error', message: codexText('codex-reconnect-incomplete') }),
+                        { type: 'notice', level: 'warning', key: 'codex-connection', text: codexText('codex-reconnect-incomplete') },
                         { type: 'session.status', status: 'idle' }]);
                 };
                 while (cursor !== undefined && !atKnownTurn()) {
@@ -586,7 +625,7 @@ export async function openCodexSession(deps) {
                 connected = true;
                 if (active !== undefined)
                     input.onTurnStarted(active);
-                emit([{ type: 'notice', level: 'info', key: 'codex-connection', text: t('codex-reconnected') }, { type: 'session.status', status: active === undefined ? 'idle' : 'running' }]);
+                emit([{ type: 'notice', level: 'info', key: 'codex-connection', text: codexText('codex-reconnected') }, { type: 'session.status', status: active === undefined ? 'idle' : 'running' }]);
                 for (const deliver of reconnectHeld.splice(0))
                     deliver();
                 await tasks.refresh();
@@ -610,7 +649,7 @@ export async function openCodexSession(deps) {
                 reconnectHeld.length = 0;
                 emit([...live.forceClose({ kind: 'error', message: errorText(error) }),
                     ...input.permanentLoss(),
-                    { type: 'notice', level: 'error', key: 'codex-connection', text: t('codex-connection-failed', { err: errorText(error) }) },
+                    { type: 'notice', level: 'error', key: 'codex-connection', text: codexText('codex-connection-failed', { err: errorText(error) }) },
                     { type: 'session.status', status: 'idle' }]);
             });
         },
@@ -630,7 +669,7 @@ export async function openCodexSession(deps) {
             if (view !== undefined)
                 events.push({ type: 'rate-limit', info: view });
             if (reached !== undefined)
-                events.push({ type: 'notice', level: 'warning', key: 'codex-rate-limit', text: t('codex-rate-limit-reached', { kind: reached }) });
+                events.push({ type: 'notice', level: 'warning', key: 'codex-rate-limit', text: codexText('codex-rate-limit-reached', { kind: reached }) });
             emit(events);
             return;
         }
@@ -639,7 +678,7 @@ export async function openCodexSession(deps) {
             if (method === NOTIFY.configWarning && /bubblewrap/iu.test(summary)) {
                 bubblewrapWarned = true;
                 if (process.platform === 'linux' && settings.permissionMode !== 'full-access')
-                    emit([{ type: 'notice', level: 'warning', key: 'codex-bwrap', text: t('codex-bwrap-warning') }]);
+                    emit([{ type: 'notice', level: 'warning', key: 'codex-bwrap', text: codexText('codex-bwrap-warning') }]);
                 return;
             }
             const notice = warningNotice(method, params);
@@ -666,7 +705,7 @@ export async function openCodexSession(deps) {
     for (const notice of deps.startNotices ?? [])
         emit([{ type: 'notice', level: 'warning', text: notice }]);
     if (drift !== undefined)
-        emit([{ type: 'notice', level: 'warning', key: 'codex-drift', text: t('codex-version-drift', { version: drift, validated: VALIDATED_CODEX_VERSIONS.join(', ') }) }]);
+        emit([{ type: 'notice', level: 'warning', key: 'codex-drift', text: codexText('codex-version-drift', { version: drift, validated: VALIDATED_CODEX_VERSIONS.join(', ') }) }]);
     emit([{ type: 'mode.changed', modeId: opened.modeId }], 'none');
     const rememberedColor = deps.prefs.read().colors?.[threadId];
     if (rememberedColor !== undefined)
@@ -712,11 +751,11 @@ export async function openCodexSession(deps) {
                 async fork(anchor, title) {
                     const lastTurnId = anchor === undefined ? undefined : ctx.anchorTurns.get(anchor) ?? str(history.turns.find(turn => arr(turn.items).some(item => str(rec(item)?.id) === anchor))?.id);
                     if (anchor !== undefined && lastTurnId === undefined)
-                        throw new Error(t('codex-anchor-missing'));
+                        throw new Error(codexText('codex-anchor-missing'));
                     const response = rec(await hub.call(CLIENT.threadFork, { threadId, excludeTurns: true, ...(lastTurnId === undefined ? {} : { lastTurnId }) }));
                     const id = str(rec(response?.thread)?.id);
                     if (id === undefined)
-                        throw new Error(t('codex-open-failed', { err: 'no thread id' }));
+                        throw new Error(codexText('codex-open-failed', { err: 'no thread id' }));
                     if (title !== undefined)
                         await hub.call(CLIENT.threadNameSet, { threadId: id, name: title });
                     await hub.call(CLIENT.threadUnsubscribe, { threadId: id });
@@ -726,23 +765,31 @@ export async function openCodexSession(deps) {
             rewind: {
                 async rewind(anchor, mode) {
                     if (mode !== 'conversation')
-                        return { kind: 'refused', reason: t('codex-rewind-files-unsupported') };
+                        return { kind: 'refused', reason: codexText('codex-rewind-files-unsupported') };
                     const selected = ctx.anchorTurns.get(anchor) ?? str(history.turns.find(turn => arr(turn.items).some(item => str(rec(item)?.id) === anchor))?.id);
                     if (selected === undefined)
-                        return { kind: 'refused', reason: t('codex-anchor-missing') };
+                        return { kind: 'refused', reason: codexText('codex-anchor-missing') };
                     if (input.busy())
-                        return { kind: 'refused', reason: t('codex-command-idle') };
+                        return { kind: 'refused', reason: codexText('codex-command-idle') };
                     const previous = history.previousTurnId(anchor);
-                    const retained = history.turns;
-                    const index = retained.findIndex(turn => str(turn.id) === selected);
-                    if (previous === undefined && (index < 0 || history.capability.hasOlder()))
-                        return { kind: 'refused', reason: t('codex-rewind-load-older') };
-                    const response = rec(await hub.call(previous === undefined ? CLIENT.threadStart : CLIENT.threadFork, previous === undefined
-                        ? { cwd: opened.cwd, ...resumeOverrides() }
-                        : { threadId, lastTurnId: previous, excludeTurns: true, ...resumeOverrides() }));
+                    // A daemon may differ from the local CLI. Use the live handshake,
+                    // and never let an unknown/old server ignore the cutoff silently.
+                    const serverVersion = parseCodexVersion(hub.info?.userAgent ?? '');
+                    if (previous === undefined && (serverVersion === undefined || (compareCodexVersions(serverVersion, MIN_CODEX_BEFORE_TURN_FORK_VERSION) ?? -1) < 0)) {
+                        return { kind: 'refused', reason: codexText('codex-rewind-upgrade', { min: MIN_CODEX_BEFORE_TURN_FORK_VERSION }) };
+                    }
+                    // Codex can cut before a known turn even when its predecessor is
+                    // not loaded or retained locally. For the first turn this persists
+                    // an empty branch; a turnless thread/start cannot be resumed.
+                    const response = rec(await hub.call(CLIENT.threadFork, {
+                        threadId,
+                        ...(previous === undefined ? { beforeTurnId: selected } : { lastTurnId: previous }),
+                        excludeTurns: true,
+                        ...resumeOverrides(),
+                    }));
                     const id = str(rec(response?.thread)?.id);
                     if (id === undefined)
-                        throw new Error(t('codex-open-failed', { err: 'no thread id' }));
+                        throw new Error(codexText('codex-open-failed', { err: 'no thread id' }));
                     await hub.call(CLIENT.threadUnsubscribe, { threadId: id });
                     return { kind: 'rewound', session: { backendId: CODEX_BACKEND_ID, sessionId: id } };
                 },
@@ -758,6 +805,10 @@ export async function openCodexSession(deps) {
                 respond: (requestId, answers) => {
                     if (authBridge?.respondQuestion(requestId, answers))
                         return;
+                    if (asyncQuestions.owns(requestId)) {
+                        asyncQuestions.respond(requestId, answers);
+                        return;
+                    }
                     if (planReview.owns(requestId))
                         planReview.respond(requestId, answers);
                     else
@@ -766,6 +817,10 @@ export async function openCodexSession(deps) {
                 cancel: requestId => {
                     if (authBridge?.cancelQuestion(requestId))
                         return;
+                    if (asyncQuestions.owns(requestId)) {
+                        asyncQuestions.cancel(requestId);
+                        return;
+                    }
                     if (planReview.owns(requestId))
                         planReview.cancel(requestId);
                     else
@@ -775,13 +830,13 @@ export async function openCodexSession(deps) {
             pendingRetraction: { remove: id => input.remove(id) },
             diagnostics: {
                 lines: () => [
-                    t('codex-doctor-cli', { path: deps.executable.path, source: deps.executable.source, version: version ?? t('doctor-unknown') }),
-                    ...(drift === undefined ? [] : [t('codex-version-drift', { version: drift, validated: VALIDATED_CODEX_VERSIONS.join(', ') })]),
-                    t('codex-doctor-home', { home: hub.info?.codexHome ?? t('doctor-unknown') }),
-                    t('codex-doctor-thread', { id: threadId, provider: opened.provider === '' ? t('doctor-unknown') : opened.provider, model: settings.model === '' ? t('doctor-unknown') : settings.model }),
-                    t('codex-doctor-mode', { mode: settings.modeId }),
-                    ...(connected ? [] : [t('codex-connection-lost')]),
-                    ...((bubblewrapWarned || hub.bubblewrapMissing || deps.doctor?.bubblewrapMissing === true) && process.platform === 'linux' ? [t('codex-doctor-bubblewrap')] : []),
+                    codexText('codex-doctor-cli', { path: deps.executable.path, source: deps.executable.source, version: version ?? codexText('doctor-unknown') }),
+                    ...(drift === undefined ? [] : [codexText('codex-version-drift', { version: drift, validated: VALIDATED_CODEX_VERSIONS.join(', ') })]),
+                    codexText('codex-doctor-home', { home: hub.info?.codexHome ?? codexText('doctor-unknown') }),
+                    codexText('codex-doctor-thread', { id: threadId, provider: opened.provider === '' ? codexText('doctor-unknown') : opened.provider, model: settings.model === '' ? codexText('doctor-unknown') : settings.model }),
+                    codexText('codex-doctor-mode', { mode: settings.modeId }),
+                    ...(connected ? [] : [codexText('codex-connection-lost')]),
+                    ...((bubblewrapWarned || hub.bubblewrapMissing || deps.doctor?.bubblewrapMissing === true) && process.platform === 'linux' ? [codexText('codex-doctor-bubblewrap')] : []),
                 ],
             },
         },
@@ -804,17 +859,19 @@ export async function openCodexSession(deps) {
         },
         submit(next, placement) {
             if (disposing)
-                return Promise.reject(new Error(t('codex-session-closed')));
+                return Promise.reject(new Error(codexText('codex-session-closed')));
             if (permanentlyLost)
-                return Promise.reject(new Error(t('codex-connection-failed', { err: '' })));
+                return Promise.reject(new Error(codexText('codex-connection-failed', { err: '' })));
             planReview.withdraw();
             return commands.submit(next, placement).then(result => result ?? input.submit(next, placement));
         },
         async cancel(cause) {
             if (disposing)
                 return { stillQueued: [], outcome: 'unknown' };
-            if (cause === 'switch' || cause === 'dispose')
+            if (cause === 'switch' || cause === 'dispose') {
                 approvals.withdrawAll();
+                asyncQuestions.withdraw();
+            }
             return input.cancel(cause);
         },
         dispose() {
@@ -822,6 +879,7 @@ export async function openCodexSession(deps) {
                 return disposePromise;
             disposePromise = (async () => {
                 approvals.withdrawAll();
+                asyncQuestions.withdraw();
                 authBridge?.dispose();
                 planReview.withdraw();
                 output.close();
@@ -835,7 +893,7 @@ export async function openCodexSession(deps) {
                 const busy = input.busy();
                 disposing = true;
                 if (busy)
-                    await input.interrupt().catch(() => false);
+                    await input.interrupt(false).catch(() => false);
                 input.close();
                 offGlobal();
                 for (const unroute of childRoutes.values())

package/lib/types/backends/codex/session/side-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"side-query.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/side-query.ts"],"names":[],"mappings":"AAMA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,eAAe,CAAA;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAG5D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,QAAQ,IAAI,MAAM,CAAC;IAAC,MAAM,IAAI,OAAO,CAAC;IAAC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;;;2BA4F+3N,CAAC;2BAA8B,CAAC;;;0BAAsF,CAAC;;;iBAzF7rO,IAAI;aAuFsB,IAAI;EACrD"}
+{"version":3,"file":"side-query.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/session/side-query.ts"],"names":[],"mappings":"AAMA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,eAAe,CAAA;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAG5D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,QAAQ,IAAI,MAAM,CAAC;IAAC,MAAM,IAAI,OAAO,CAAC;IAAC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;;;2BA6GuiM,CAAC;2BAA8B,CAAC;;;0BAAsF,CAAC;;;iBA1Gr2M,IAAI;aAwGsB,IAAI;EACrD"}