@galaxy-yearn/codex-deepseek-gateway 0.1.3 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # Codex DeepSeek Gateway
 
-A small local gateway for using DeepSeek V4 models from Codex.
+A small local gateway for using DeepSeek models from Codex.
 
 Codex keeps sending OpenAI `Responses API` requests to a local endpoint. The gateway converts those requests to DeepSeek-compatible `Chat Completions`, calls DeepSeek, then converts the result back to Responses JSON or streaming `response.*` events.
 
@@ -43,7 +43,7 @@ Put your DeepSeek API key in `gateway.local.json`:
 "upstreamApiKey": "sk-..."
 ```
 
-`model-aliases.json` controls the gateway-facing model IDs exposed on `GET /v1/models` and used by the `sessions` picker. Edit it only if you want to add or rename model aliases.
+`model-aliases.json` controls the gateway-facing model IDs exposed on `GET /v1/models` and used by the `new` and `sessions` pickers. Edit it only if you want to add or rename model aliases.
 
 If the key is already configured, `install` also starts the gateway. If this is your first install, add the key and then run:
 
@@ -97,7 +97,7 @@ Important fields:
 - `codexReasoningEffort` should match `model_reasoning_effort`
 - `deepseekThinking` shows the DeepSeek `thinking` payload
 - `deepseekReasoningEffort` shows the DeepSeek effort sent upstream
-- `gatewayEmitsReasoningSummary` should be `true` when DeepSeek thinking is enabled
+- `reasoningDisplayMode` shows whether reasoning is shown as `summary`, `hidden`, or `disabled`
 - `tavilyWebSearchReady` and `firecrawlWebFetchReady` show whether optional web search backends are usable
 
 Avoid running Codex through a proxy while using the local gateway. Some proxy clients intercept `http://127.0.0.1:3000` and can break local gateway requests.
@@ -125,7 +125,7 @@ The gateway serves these aliases directly on `GET /v1/models`. If you also want
 "fetchUpstreamModels": true
 ```
 
-Whether Codex TUI `/model` shows custom provider models depends on the Codex client build. `config.toml` and the `sessions` command remain the reliable ways to choose a model.
+Whether Codex TUI `/model` shows custom provider models depends on the Codex client build. `config.toml`, `new`, and `sessions` remain the reliable ways to choose a model.
 
 ## Reasoning
 
@@ -171,6 +171,34 @@ DeepSeek receives compact text context containing the search query, sources, sni
 
 The web payload is intentionally text-focused. Tavily is called with `include_raw_content: false`; Firecrawl defaults to main content, removes base64 images, rejects local/private URLs, and truncates page text before it reaches the model.
 
+## New Conversations
+
+Start a new Codex conversation with a temporary gateway model override:
+
+```sh
+npx @galaxy-yearn/codex-deepseek-gateway new
+```
+
+The command first lets you choose a model from `~/.codex/deepseek-gateway/config/model-aliases.json`, then choose Codex reasoning effort, then runs:
+
+```sh
+codex -c model_provider=deepseek-gateway -c model=<model> -c model_reasoning_effort=<effort>
+```
+
+This does not edit `~/.codex/config.toml`; the `model_providers.deepseek-gateway` provider entry still needs to exist there.
+
+You can skip the picker:
+
+```sh
+npx @galaxy-yearn/codex-deepseek-gateway new --model deepseek-v4-flash --reasoning-effort low
+```
+
+Print the generated launch command instead of running Codex:
+
+```sh
+npx @galaxy-yearn/codex-deepseek-gateway new --print
+```
+
 ## Sessions
 
 Open a cross-provider session picker from a project:
@@ -189,8 +217,8 @@ Flow:
 
 - choose a model from `~/.codex/deepseek-gateway/config/model-aliases.json`
 - choose Codex reasoning effort
-- choose the session to resume
-- use `Up/Down` to select, `Enter` to confirm, `Left` to go back, and `Esc` to quit
+- choose `[New conversation]` or the session to resume
+- use `↑/↓` to select, `Enter` to confirm, `←` to go back, and `Esc` to quit
 
 Print copyable resume commands instead of opening the picker:
 
@@ -204,6 +232,18 @@ Include sessions outside the current project:
 npx @galaxy-yearn/codex-deepseek-gateway sessions --all
 ```
 
+Resume a matching session directly by row number or unique session id prefix:
+
+```sh
+npx @galaxy-yearn/codex-deepseek-gateway sessions --exec <id-or-row>
+```
+
+Limit how many session rows are shown or offered in the picker:
+
+```sh
+npx @galaxy-yearn/codex-deepseek-gateway sessions --limit 50
+```
+
 The command does not edit session files, change provider ownership, or change Codex's native resume picker filters. It only helps you find the hidden session id and resume it with explicit config overrides.
 
 ## Commands
@@ -214,6 +254,7 @@ npx @galaxy-yearn/codex-deepseek-gateway start
 npx @galaxy-yearn/codex-deepseek-gateway stop
 npx @galaxy-yearn/codex-deepseek-gateway status
 npx @galaxy-yearn/codex-deepseek-gateway doctor
+npx @galaxy-yearn/codex-deepseek-gateway new
 npx @galaxy-yearn/codex-deepseek-gateway sessions
 npx @galaxy-yearn/codex-deepseek-gateway uninstall
 ```
@@ -233,6 +274,7 @@ If `start` returns without visible output on your terminal, run `status`; `"reac
 - lightweight local `previous_response_id` / `conversation` history while the gateway process is running
 - `GET /v1/models` with local model aliases and optional upstream discovery
 - optional Tavily/Firecrawl-backed `web_search` emulation
+- new-conversation launcher with per-run Codex config overrides
 - read-only cross-provider session picker
 
 ## Limits
@@ -244,7 +286,7 @@ Chat Completions is not a full Responses API replacement. Some Responses feature
 - URL citations are returned in the Responses metadata path. Whether they appear as clickable links in the terminal depends on the Codex client build and how it renders custom-provider citation annotations.
 - OpenAI `file_id` values are passed through; the gateway cannot fetch private OpenAI-hosted files.
 - In-memory conversation history is lost when the gateway restarts.
-- The gateway exposes model aliases on `/v1/models`, including aliases from `config/model-aliases.json`. Whether Codex TUI `/model` actually shows custom provider models depends on the Codex build. `config.toml` remains the reliable fallback.
+- The gateway exposes model aliases on `/v1/models`, including aliases from `config/model-aliases.json`. Whether Codex TUI `/model` actually shows custom provider models depends on the Codex build. `config.toml`, `new`, and `sessions` remain the reliable ways to choose a model.
 
 ## License
 

package/bin/codex-deepseek-gateway.js

@@ -13,6 +13,7 @@ import { createRequire } from 'node:module';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadConfig } from '../src/config.js';
+import { newConversation } from '../src/codex-launch.js';
 import { sessions } from '../src/codex-sessions.js';
 import { toProviderChatCompletionsRequest } from '../src/protocol.js';
 
@@ -33,6 +34,7 @@ Usage:
   codex-deepseek-gateway stop
   codex-deepseek-gateway status
   codex-deepseek-gateway doctor
+  codex-deepseek-gateway new
   codex-deepseek-gateway sessions
   codex-deepseek-gateway uninstall
 
@@ -40,13 +42,14 @@ Options:
   --dir <path>     Install directory, defaults to ~/.codex/deepseek-gateway
   --no-edit        Do not open the local config file after install
   --all            With sessions, include sessions outside the current project
-  --provider <id>  With sessions, target model_provider override
-  --model <id>     With sessions, target model override
+  --provider <id>  With new/sessions, target model_provider override
+  --model <id>     With new/sessions, target model override
   --reasoning-effort <level>
-                  With sessions, target Codex reasoning effort
+                  With new/sessions, target Codex reasoning effort
   --exec <id>      With sessions, run the generated codex resume command
   --limit <n>      With sessions, max rows to print, defaults to 20
-  --print          With sessions, print copyable resume commands instead of picker
+  --print          With new, print the launch command. With sessions, print
+                  copyable resume commands instead of picker
 `);
 }
 
@@ -363,7 +366,6 @@ async function doctor(options) {
     : thinkingEnabled
     ? 'summary'
     : 'disabled';
-  const codexSummaryConfigured = supportsReasoningSummaries && summaryMode && summaryMode !== 'none';
   print(JSON.stringify({
     packageVersion: packageJson.version,
     installDir: options.dir,
@@ -380,8 +382,6 @@ async function doctor(options) {
     deepseekThinking: upstreamRequest.thinking || null,
     deepseekReasoningEffort: upstreamRequest.reasoning_effort || null,
     reasoningDisplayMode,
-    gatewayEmitsReasoningSummary: reasoningDisplayMode === 'summary',
-    codexSummaryConfigured,
     tavilyWebSearchEnabled: Boolean(config.tavilyWebSearchEnabled),
     tavilyWebSearchReady: Boolean(config.tavilyWebSearchEnabled && config.tavilyApiKey),
     firecrawlWebFetchEnabled: Boolean(config.firecrawlWebFetchEnabled),
@@ -404,7 +404,7 @@ async function main() {
     usage();
     return;
   }
-  const commands = { install, start, stop, status, doctor, sessions, uninstall };
+  const commands = { install, start, stop, status, doctor, new: newConversation, sessions, uninstall };
   const handler = commands[command];
   if (!handler) {
     throw new Error(`Unknown command: ${command}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galaxy-yearn/codex-deepseek-gateway",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Local OpenAI Codex Responses API gateway for DeepSeek Chat Completions.",
   "type": "module",
   "main": "src/server.js",

package/src/codex-launch.js

@@ -0,0 +1,233 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { clearScreenDown, cursorTo } from 'node:readline';
+import { readCodexConfig } from './codex-config.js';
+
+export const DEFAULT_PROVIDER = 'deepseek-gateway';
+export const REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+const SELECTED_ROW = '\x1b[38;5;81m';
+const RESET_STYLE = '\x1b[0m';
+
+function print(message = '') {
+  process.stdout.write(message);
+}
+
+export function defaultCodexHome() {
+  return process.env.CODEX_HOME || join(process.env.USERPROFILE || process.env.HOME || process.cwd(), '.codex');
+}
+
+export function findProjectRoot(start) {
+  let current = resolve(start);
+  while (true) {
+    if (existsSync(join(current, '.git'))) return current;
+    const parent = dirname(current);
+    if (parent === current) return resolve(start);
+    current = parent;
+  }
+}
+
+function readJsonObject(file) {
+  if (!existsSync(file)) return {};
+  const value = JSON.parse(readFileSync(file, 'utf8'));
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+export function gatewayModels(installDir) {
+  return Object.keys(readJsonObject(join(installDir, 'config', 'model-aliases.json'))).sort();
+}
+
+export function createLaunchContext(options) {
+  const codexHome = defaultCodexHome();
+  const models = gatewayModels(options.dir);
+  const codexConfig = readCodexConfig();
+  const configModel = codexConfig.modelProvider === DEFAULT_PROVIDER && models.includes(codexConfig.model) ? codexConfig.model : '';
+  return {
+    all: options.all,
+    codexHome,
+    installDir: options.dir,
+    models,
+    projectRoot: findProjectRoot(process.cwd()),
+    provider: options.provider || DEFAULT_PROVIDER,
+    model: options.model || configModel || models[0] || '',
+    reasoningEffort: options.reasoningEffort || codexConfig.modelReasoningEffort || 'low',
+  };
+}
+
+export function missingModelMessage(context) {
+  return `No gateway models found in ${join(context.installDir, 'config', 'model-aliases.json')}\n`;
+}
+
+function configOverrideArgs(context) {
+  return [
+    '-c',
+    `model_provider=${JSON.stringify(context.provider)}`,
+    '-c',
+    `model=${JSON.stringify(context.model)}`,
+    '-c',
+    `model_reasoning_effort=${JSON.stringify(context.reasoningEffort)}`,
+  ];
+}
+
+function configOverrideCommandParts(context) {
+  return [
+    '-c',
+    `model_provider=${context.provider}`,
+    '-c',
+    `model=${context.model}`,
+    '-c',
+    `model_reasoning_effort=${context.reasoningEffort}`,
+  ];
+}
+
+export function codexNewArgs(context) {
+  return configOverrideArgs(context);
+}
+
+export function codexResumeArgs(sessionId, context) {
+  return ['resume', sessionId, ...configOverrideArgs(context)];
+}
+
+export function codexNewCommand(context) {
+  return ['codex', ...configOverrideCommandParts(context)].join(' ');
+}
+
+export function codexResumeCommand(sessionId, context) {
+  return ['codex', 'resume', sessionId, ...configOverrideCommandParts(context)].join(' ');
+}
+
+export async function runCodex(args) {
+  const child = spawn('codex', args, {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+  process.exitCode = await new Promise((resolveChild) => {
+    child.on('exit', (exitCode) => resolveChild(exitCode ?? 0));
+  });
+}
+
+function rowOffset(header) {
+  return header ? 4 : 2;
+}
+
+function renderRow(state, index) {
+  cursorTo(process.stdout, 0, rowOffset(state.header) + index);
+  const row = `${index === state.selected ? '>' : ' '} ${state.rows[index]}`;
+  const styled = index === state.selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row;
+  print(`\x1b[2K${styled}`);
+}
+
+function renderPicker(state) {
+  const { title, rows, selected, header } = state;
+  cursorTo(process.stdout, 0, 0);
+  clearScreenDown(process.stdout);
+  let output = `${title}\n\n`;
+  if (header) output += `  ${header}\n  ${'-'.repeat(header.length)}\n`;
+  for (const [index] of rows.entries()) {
+    const row = `${index === selected ? '>' : ' '} ${rows[index]}`;
+    output += `${index === selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row}\n`;
+  }
+  output += '\n↑/↓ select  Enter confirm  ← back  Esc quit\n';
+  print(output);
+}
+
+function openPickerScreen() {
+  process.stdout.write('\x1b[?1049h\x1b[?25l');
+}
+
+function closePickerScreen() {
+  process.stdout.write('\x1b[?25h\x1b[?1049l');
+}
+
+export async function pick(title, rows, header = '') {
+  if (!rows.length) return { action: 'back' };
+  let selected = 0;
+  const stdin = process.stdin;
+  const state = { title, rows, selected, header };
+  renderPicker(state);
+
+  return await new Promise((resolvePick) => {
+    const done = (result) => {
+      stdin.off('data', onData);
+      resolvePick(result);
+    };
+    const onData = (chunk) => {
+      const key = chunk.toString('utf8');
+      if (key === '\u0003' || key === '\u001b') return done({ action: 'cancel' });
+      if (key === '\u001b[D') return done({ action: 'back' });
+      if (key === '\r' || key === '\n') return done({ action: 'select', index: selected });
+      const previous = selected;
+      if (key === '\u001b[A') selected = Math.max(0, selected - 1);
+      else if (key === '\u001b[B') selected = Math.min(rows.length - 1, selected + 1);
+      else return;
+      if (selected === previous) return;
+      state.selected = selected;
+      renderRow(state, previous);
+      renderRow(state, selected);
+    };
+    stdin.on('data', onData);
+  });
+}
+
+export async function withPickerScreen(callback) {
+  const stdin = process.stdin;
+  stdin.resume();
+  stdin.setRawMode(true);
+  openPickerScreen();
+  try {
+    return await callback();
+  } finally {
+    stdin.setRawMode(false);
+    stdin.pause();
+    closePickerScreen();
+  }
+}
+
+export async function pickModel(context) {
+  const result = await pick('Choose gateway model', context.models);
+  if (result.action === 'select') context.model = context.models[result.index];
+  return result.action;
+}
+
+export async function pickReasoning(context) {
+  const result = await pick(`Choose Codex reasoning effort for ${context.model}`, REASONING_EFFORTS);
+  if (result.action === 'select') context.reasoningEffort = REASONING_EFFORTS[result.index];
+  return result.action;
+}
+
+export async function chooseLaunchContext(context) {
+  return await withPickerScreen(async () => {
+    let step = 'model';
+    while (true) {
+      if (step === 'model') {
+        const action = await pickModel(context);
+        if (action !== 'select') return false;
+        step = 'reasoning';
+      } else {
+        const action = await pickReasoning(context);
+        if (action === 'cancel') return false;
+        if (action === 'back') step = 'model';
+        else return true;
+      }
+    }
+  });
+}
+
+export async function newConversation(options) {
+  const context = createLaunchContext(options);
+  if (!context.model) {
+    print(missingModelMessage(context));
+    return;
+  }
+  const canPick = process.stdin.isTTY && process.stdout.isTTY;
+  const hasLaunchOverrides = options.provider || options.model || options.reasoningEffort;
+  if (!hasLaunchOverrides && !options.print && canPick) {
+    const selected = await chooseLaunchContext(context);
+    if (!selected) return;
+  }
+  if (options.print || (!hasLaunchOverrides && !canPick)) {
+    print(`${codexNewCommand(context)}\n`);
+    return;
+  }
+  await runCodex(codexNewArgs(context));
+}

package/src/codex-sessions.js

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import {
   closeSync,
   existsSync,
@@ -7,27 +6,32 @@ import {
   readdirSync,
   readSync,
 } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { clearLine, clearScreenDown, cursorTo } from 'node:readline';
-import { readCodexConfig } from './codex-config.js';
+import { join, resolve } from 'node:path';
+import {
+  codexNewArgs,
+  codexResumeArgs,
+  codexResumeCommand,
+  createLaunchContext,
+  missingModelMessage,
+  pick,
+  pickModel,
+  pickReasoning,
+  runCodex,
+  withPickerScreen,
+} from './codex-launch.js';
 
-const DEFAULT_PROVIDER = 'deepseek-gateway';
-const REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
 const TIME_WIDTH = 10;
-const PROVIDER_WIDTH = 18;
+const PROVIDER_WIDTH = 17;
 const ID_WIDTH = 36;
 const TITLE_WIDTH = 16;
 const TABLE_INDENT = '    ';
-const COLUMN_GAP = '    ';
+const COLUMN_GAP = '  ';
+const NEW_SESSION_ROW = '[New conversation]';
 
 function print(message = '') {
   process.stdout.write(message);
 }
 
-function defaultCodexHome() {
-  return process.env.CODEX_HOME || join(process.env.USERPROFILE || process.env.HOME || process.cwd(), '.codex');
-}
-
 function readStart(file, bytes = 256 * 1024) {
   const handle = openSync(file, 'r');
   try {
@@ -107,16 +111,6 @@ function normalizePath(path) {
   return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
 }
 
-function findProjectRoot(start) {
-  let current = resolve(start);
-  while (true) {
-    if (existsSync(join(current, '.git'))) return current;
-    const parent = dirname(current);
-    if (parent === current) return resolve(start);
-    current = parent;
-  }
-}
-
 function isInsideProject(cwd, projectRoot) {
   if (!cwd) return false;
   const sessionCwd = normalizePath(cwd);
@@ -138,31 +132,6 @@ function readSession(file, indexById) {
   };
 }
 
-function shellQuoteTomlString(key, value) {
-  return `-c ${key}=${value}`;
-}
-
-function resumeCommand(sessionId, context) {
-  return [
-    'codex',
-    'resume',
-    sessionId,
-    shellQuoteTomlString('model_provider', context.provider),
-    shellQuoteTomlString('model', context.model),
-    shellQuoteTomlString('model_reasoning_effort', context.reasoningEffort),
-  ].join(' ');
-}
-
-function readJsonObject(file) {
-  if (!existsSync(file)) return {};
-  const value = JSON.parse(readFileSync(file, 'utf8'));
-  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
-
-function gatewayModels(installDir) {
-  return Object.keys(readJsonObject(join(installDir, 'config', 'model-aliases.json'))).sort();
-}
-
 function resolveSessionSelection(selection, sessionsList) {
   if (/^\d+$/.test(selection)) {
     const byIndex = sessionsList[Number(selection) - 1];
@@ -172,29 +141,6 @@ function resolveSessionSelection(selection, sessionsList) {
   return matches.length === 1 ? matches[0] : null;
 }
 
-function resumeArgs(session, context) {
-  return [
-    'resume',
-    session.id,
-    '-c',
-    `model_provider=${JSON.stringify(context.provider)}`,
-    '-c',
-    `model=${JSON.stringify(context.model)}`,
-    '-c',
-    `model_reasoning_effort=${JSON.stringify(context.reasoningEffort)}`,
-  ];
-}
-
-async function runCodexResume(session, context) {
-  const child = spawn('codex', resumeArgs(session, context), {
-    stdio: 'inherit',
-    shell: process.platform === 'win32',
-  });
-  process.exitCode = await new Promise((resolveChild) => {
-    child.on('exit', (exitCode) => resolveChild(exitCode ?? 0));
-  });
-}
-
 function printSessions(sessionsList, options, context) {
   const listed = sessionsList.slice(0, options.limit || 20);
   print(`Codex sessions ${options.all ? `under ${context.codexHome}` : `for project ${context.projectRoot}`}\n`);
@@ -204,11 +150,11 @@ function printSessions(sessionsList, options, context) {
     return;
   }
   print(`${TABLE_INDENT}${sessionHeader()}\n`);
-  print(`${TABLE_INDENT}${'-'.repeat(TIME_WIDTH)}${COLUMN_GAP}${'-'.repeat(PROVIDER_WIDTH)}${COLUMN_GAP}${'-'.repeat(ID_WIDTH)}${COLUMN_GAP}${'-'.repeat(TITLE_WIDTH)}\n`);
+  print(`${TABLE_INDENT}${'-'.repeat(sessionHeader().length)}\n`);
   listed.forEach((session, index) => {
     print(`${String(index + 1).padStart(2, ' ')}  ${sessionRow(session)}\n`);
     if (options.all) print(`    cwd: ${session.cwd || '(unknown cwd)'}\n`);
-    print(`    resume: ${resumeCommand(session.id, context)}\n\n`);
+    print(`    resume: ${codexResumeCommand(session.id, context)}\n\n`);
   });
   if (sessionsList.length > listed.length) print(`Showing ${listed.length} of ${sessionsList.length}. Use --limit ${sessionsList.length} or --all as needed.\n`);
 }
@@ -225,134 +171,47 @@ function sessionRows(sessionsList) {
   return sessionsList.map((session) => sessionRow(session));
 }
 
-function rowOffset(header) {
-  return header ? 4 : 2;
-}
-
-function renderRow(state, index) {
-  cursorTo(process.stdout, 0, rowOffset(state.header) + index);
-  clearLine(process.stdout, 0);
-  print(`${index === state.selected ? '>' : ' '} ${state.rows[index]}`);
-}
-
-function renderPicker(state) {
-  const { title, rows, selected, header } = state;
-  cursorTo(process.stdout, 0, 0);
-  clearScreenDown(process.stdout);
-  let output = `${title}\n\n`;
-  if (header) output += `  ${header}\n  ${'-'.repeat(header.length)}\n`;
-  for (const [index, row] of rows.entries()) output += `${index === selected ? '>' : ' '} ${row}\n`;
-  output += '\n↑/↓ select  Enter confirm  ← back  Esc quit\n';
-  print(output);
-}
-
-function openPickerScreen() {
-  process.stdout.write('\x1b[?1049h\x1b[?25l');
-}
-
-function closePickerScreen() {
-  process.stdout.write('\x1b[?25h\x1b[?1049l');
-}
-
-async function pick(title, rows, header = '') {
-  if (!rows.length) return { action: 'back' };
-  let selected = 0;
-  const stdin = process.stdin;
-  const state = { title, rows, selected, header };
-  renderPicker(state);
-
-  return await new Promise((resolvePick) => {
-    const done = (result) => {
-      stdin.off('data', onData);
-      resolvePick(result);
-    };
-    const onData = (chunk) => {
-      const key = chunk.toString('utf8');
-      if (key === '\u0003' || key === '\u001b') return done({ action: 'cancel' });
-      if (key === '\u001b[D') return done({ action: 'back' });
-      if (key === '\r' || key === '\n') return done({ action: 'select', index: selected });
-      const previous = selected;
-      if (key === '\u001b[A') selected = Math.max(0, selected - 1);
-      else if (key === '\u001b[B') selected = Math.min(rows.length - 1, selected + 1);
-      else return;
-      if (selected === previous) return;
-      state.selected = selected;
-      renderRow(state, previous);
-      renderRow(state, selected);
-    };
-    stdin.on('data', onData);
-  });
-}
-
 async function chooseSessionFlow(allSessions, context, limit) {
-  const models = gatewayModels(context.installDir);
-  const listed = allSessions.slice(0, limit);
-  const header = sessionHeader();
-  if (!listed.length) {
-    print('No matching sessions found.\n');
-    return null;
-  }
-  if (!models.length) {
-    print(`No gateway models found in ${join(context.installDir, 'config', 'model-aliases.json')}\n`);
+  if (!context.models.length) {
+    print(missingModelMessage(context));
     return null;
   }
 
-  const stdin = process.stdin;
-  stdin.resume();
-  stdin.setRawMode(true);
-  openPickerScreen();
-  try {
+  const listed = allSessions.slice(0, limit);
+  const header = sessionHeader();
+  return await withPickerScreen(async () => {
     let step = 'model';
     while (true) {
       if (step === 'model') {
-        const result = await pick('Choose gateway model', models);
-        if (result.action !== 'select') return null;
-        context.model = models[result.index];
+        const action = await pickModel(context);
+        if (action !== 'select') return null;
         step = 'reasoning';
       } else if (step === 'reasoning') {
-        const result = await pick(`Choose Codex reasoning effort for ${context.model}`, REASONING_EFFORTS);
-        if (result.action === 'cancel') return null;
-        if (result.action === 'back') step = 'model';
-        else {
-          context.reasoningEffort = REASONING_EFFORTS[result.index];
-          step = 'session';
-        }
+        const action = await pickReasoning(context);
+        if (action === 'cancel') return null;
+        if (action === 'back') step = 'model';
+        else step = 'session';
       } else {
-        const result = await pick(`Choose Codex session for ${context.provider} / ${context.model} / ${context.reasoningEffort}`, sessionRows(listed), header);
+        const rows = [NEW_SESSION_ROW, ...sessionRows(listed)];
+        const result = await pick(`Choose Codex session for ${context.provider} / ${context.model} / ${context.reasoningEffort}`, rows, header);
         if (result.action === 'cancel') return null;
         if (result.action === 'back') step = 'reasoning';
-        else return listed[result.index];
+        else if (result.index === 0) return { newConversation: true };
+        else return listed[result.index - 1];
       }
     }
-  } finally {
-    stdin.setRawMode(false);
-    stdin.pause();
-    closePickerScreen();
-  }
+  });
 }
 
 export async function sessions(options) {
-  const codexHome = defaultCodexHome();
-  const sessionsDir = join(codexHome, 'sessions');
-  const indexById = readSessionIndex(codexHome);
-  const projectRoot = findProjectRoot(process.cwd());
-  const codexConfig = readCodexConfig();
-  const models = gatewayModels(options.dir);
-  const configModel = codexConfig.modelProvider === DEFAULT_PROVIDER && models.includes(codexConfig.model) ? codexConfig.model : '';
-  const context = {
-    all: options.all,
-    codexHome,
-    installDir: options.dir,
-    projectRoot,
-    provider: options.provider || DEFAULT_PROVIDER,
-    model: options.model || configModel || models[0] || '',
-    reasoningEffort: options.reasoningEffort || codexConfig.modelReasoningEffort || 'low',
-  };
+  const context = createLaunchContext(options);
+  const sessionsDir = join(context.codexHome, 'sessions');
+  const indexById = readSessionIndex(context.codexHome);
   const seen = new Map();
 
   for (const file of walkJsonl(sessionsDir)) {
     const session = readSession(file, indexById);
-    if (!session || (!options.all && !isInsideProject(session.cwd, projectRoot))) continue;
+    if (!session || (!options.all && !isInsideProject(session.cwd, context.projectRoot))) continue;
     const prior = seen.get(session.id);
     if (!prior || session.updatedAt > prior.updatedAt) seen.set(session.id, session);
   }
@@ -361,7 +220,7 @@ export async function sessions(options) {
   if (options.exec) {
     const session = resolveSessionSelection(options.exec, allSessions);
     if (!session) throw new Error(`Session not found or ambiguous: ${options.exec}`);
-    await runCodexResume(session, context);
+    await runCodex(codexResumeArgs(session.id, context));
     return;
   }
 
@@ -370,6 +229,7 @@ export async function sessions(options) {
     return;
   }
 
-  const session = await chooseSessionFlow(allSessions, context, options.limit || 20);
-  if (session) await runCodexResume(session, context);
+  const selected = await chooseSessionFlow(allSessions, context, options.limit || 20);
+  if (selected?.newConversation) await runCodex(codexNewArgs(context));
+  else if (selected) await runCodex(codexResumeArgs(selected.id, context));
 }