@loicngr/kobo 1.7.6 → 1.7.8

package/dist/server/services/agent/engines/codex/server-requests.js

@@ -0,0 +1,99 @@
+export function handleServerRequest(args) {
+    const { method, params, requestId, emit, register, respondError } = args;
+    const p = (params ?? {});
+    const callId = typeof p.callId === 'string' ? p.callId : `srv_${requestId}`;
+    if (method === 'mcpServer/elicitation/request') {
+        // Codex asks an external MCP server's elicitation prompt to be surfaced to
+        // the user. Kōbō doesn't model MCP elicitations yet — respond with a
+        // JSON-RPC "method not supported" error so the server doesn't block.
+        respondError?.(requestId, -32601, 'MCP elicitations not supported by this client');
+        return true;
+    }
+    // v2 and v1 method aliases for the same approval semantics. v1 legacy names
+    // (`execCommandApproval`, `applyPatchApproval`) are kept for compat with
+    // older Codex CLI builds that haven't transitioned to the v2 namespace.
+    if (method === 'item/commandExecution/requestApproval' || method === 'execCommandApproval') {
+        register(callId, { requestId, kind: 'command', payload: p });
+        emit({
+            kind: 'session:user-input-requested',
+            requestKind: 'permission',
+            toolCallId: callId,
+            toolName: 'Bash',
+            payload: { command: p.command, cwd: p.cwd, reason: p.reason },
+        });
+        return true;
+    }
+    if (method === 'item/fileChange/requestApproval' || method === 'applyPatchApproval') {
+        register(callId, { requestId, kind: 'file_change', payload: p });
+        emit({
+            kind: 'session:user-input-requested',
+            requestKind: 'permission',
+            toolCallId: callId,
+            toolName: 'Edit',
+            payload: { changes: p.changes, reason: p.reason },
+        });
+        return true;
+    }
+    if (method === 'item/tool/requestUserInput') {
+        register(callId, { requestId, kind: 'user_input', payload: p });
+        emit({
+            kind: 'session:user-input-requested',
+            requestKind: 'question',
+            toolCallId: callId,
+            toolName: 'AskUserQuestion',
+            payload: { questions: p.questions },
+        });
+        return true;
+    }
+    if (method === 'item/permissions/requestApproval') {
+        register(callId, { requestId, kind: 'permissions', payload: p });
+        emit({
+            kind: 'session:user-input-requested',
+            requestKind: 'permission',
+            toolCallId: callId,
+            toolName: 'Permissions',
+            payload: p,
+        });
+        return true;
+    }
+    return false; // unknown method
+}
+/**
+ * Build the JSON-RPC response Codex expects for a given pending request.
+ *
+ * Decision enum values come from
+ * `codex-rs/protocol/src/approvals.rs:CommandExecutionApprovalDecision`
+ * (and the matching `FileChangeApprovalDecision`): `'accept' | 'acceptForSession' | 'decline' | 'cancel'`.
+ * NOT `'approve' / 'reject'` — those would be silently rejected as unknown
+ * variants, which breaks the strict and interactive permission modes.
+ *
+ * `PermissionsRequestApprovalResponse` has a completely different shape:
+ * `{ permissions, scope, strictAutoReview? }` — no `decision` field. Since
+ * Kōbō doesn't yet model permission grants, we deny the request by sending
+ * an empty permissions response. A future iteration could add a UI for
+ * granular permission grants.
+ */
+export function buildResponseForResolve(pending, response) {
+    if (pending.kind === 'command' || pending.kind === 'file_change') {
+        if (response.kind === 'permission-allow')
+            return { decision: 'accept' };
+        return { decision: 'decline' };
+    }
+    if (pending.kind === 'permissions') {
+        // Codex's PermissionsRequestApprovalResponse shape — not { decision }.
+        // We don't yet model granular permission grants, so deny by returning an
+        // empty permissions object; Codex falls back to the existing turn policy.
+        return { permissions: {}, scope: 'turn' };
+    }
+    if (pending.kind === 'user_input') {
+        if (response.kind === 'question') {
+            const answers = {};
+            for (const [qid, val] of Object.entries(response.answers)) {
+                answers[qid] = { answers: [val] };
+            }
+            return { answers };
+        }
+        return { answers: {} };
+    }
+    return null;
+}

package/dist/server/services/agent/engines/codex/spawn.js

@@ -0,0 +1,27 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+const requireFn = createRequire(import.meta.url);
+export function resolveCodexBinary() {
+    try {
+        const pkgPath = requireFn.resolve('@openai/codex/package.json');
+        const pkg = requireFn(pkgPath);
+        const binRel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.codex;
+        if (binRel) {
+            const url = new URL(binRel, `file://${pkgPath}`);
+            return url.pathname;
+        }
+    }
+    catch {
+        // fall through to default
+    }
+    return 'codex';
+}
+export function spawnAppServer(opts) {
+    const bin = resolveCodexBinary();
+    return nodeSpawn(bin, ['app-server'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: opts.cwd,
+        env: opts.env,
+        signal: opts.signal,
+    });
+}

package/dist/server/services/agent/engines/registry.js

@@ -1,6 +1,8 @@
 import { createClaudeCodeEngine } from './claude-code/engine.js';
+import { createCodexEngine } from './codex/engine.js';
 const ENGINES = {
     'claude-code': createClaudeCodeEngine(),
+    codex: createCodexEngine(),
 };
 export function listEngines() {
     return Object.values(ENGINES);

package/dist/server/services/agent/orchestrator.js

@@ -298,7 +298,7 @@ function readEffectiveSettingsSafe(projectPath) {
     catch (err) {
         console.warn('[orchestrator] Failed to load settings, using defaults:', err);
         return {
-            model: 'claude-opus-4-7',
+            model: 'auto',
             dangerouslySkipPermissions: true,
             prPromptTemplate: '',
             reviewPromptTemplate: '',

package/dist/server/services/settings-service.js

@@ -266,6 +266,94 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 17,
+        name: 'add-voice-transcription-settings',
+        migrate({ global }) {
+            if (typeof global.voiceEnabled !== 'boolean')
+                global.voiceEnabled = false;
+            if (global.voicePttKey !== 'alt' && global.voicePttKey !== 'ctrl+space')
+                global.voicePttKey = 'alt';
+            if (typeof global.voiceLanguage !== 'string' || global.voiceLanguage.length === 0)
+                global.voiceLanguage = 'auto';
+            if (typeof global.voiceModel !== 'string' && global.voiceModel !== null)
+                global.voiceModel = null;
+            if (typeof global.voiceCommandPath !== 'string')
+                global.voiceCommandPath = '';
+            if (typeof global.voiceFfmpegPath !== 'string')
+                global.voiceFfmpegPath = '';
+        },
+    },
+    {
+        version: 18,
+        name: 'add-voice-advanced-settings',
+        migrate({ global }) {
+            const t = Number(global.voiceTemperature);
+            if (!Number.isFinite(t) || t < 0 || t > 1)
+                global.voiceTemperature = 0;
+            if (typeof global.voicePrompt !== 'string')
+                global.voicePrompt = '';
+            if (typeof global.voiceTranslateToEnglish !== 'boolean')
+                global.voiceTranslateToEnglish = false;
+            if (typeof global.voiceSuppressNonSpeechTokens !== 'boolean')
+                global.voiceSuppressNonSpeechTokens = true;
+        },
+    },
+    {
+        version: 19,
+        name: 'split-default-model-by-engine',
+        // Codex was added alongside Claude Code; the single `defaultModel` is now
+        // ambiguous (different engines have different model catalogues). Split it
+        // into a per-engine map. Preserve the legacy value as the claude-code
+        // default for back-compat, and seed codex with `'auto'`.
+        migrate({ global }) {
+            const existing = global.defaultModelByEngine;
+            if (typeof existing !== 'object' || existing === null || Array.isArray(existing)) {
+                const legacyModel = typeof global.defaultModel === 'string' && global.defaultModel.length > 0
+                    ? global.defaultModel
+                    : 'auto';
+                global.defaultModelByEngine = {
+                    'claude-code': legacyModel,
+                    codex: 'auto',
+                };
+            }
+            else {
+                // Backfill any missing engine entries idempotently.
+                const map = existing;
+                if (typeof map['claude-code'] !== 'string')
+                    map['claude-code'] = 'auto';
+                if (typeof map.codex !== 'string')
+                    map.codex = 'auto';
+            }
+            // Drop the legacy field once migrated.
+            delete global.defaultModel;
+        },
+    },
+    {
+        version: 20,
+        name: 'split-default-permission-mode-by-engine',
+        // Mirrors v19 for permission modes. Both engines accept the full mode set.
+        migrate({ global }) {
+            const existing = global.defaultPermissionModeByEngine;
+            const legacyMode = typeof global.defaultPermissionMode === 'string' && global.defaultPermissionMode.length > 0
+                ? global.defaultPermissionMode
+                : 'plan';
+            if (typeof existing !== 'object' || existing === null || Array.isArray(existing)) {
+                global.defaultPermissionModeByEngine = {
+                    'claude-code': legacyMode,
+                    codex: legacyMode,
+                };
+            }
+            else {
+                const map = existing;
+                if (typeof map['claude-code'] !== 'string')
+                    map['claude-code'] = legacyMode;
+                if (typeof map.codex !== 'string')
+                    map.codex = legacyMode;
+            }
+            delete global.defaultPermissionMode;
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -293,7 +381,7 @@ function defaultSettings() {
     return {
         schemaVersion: SETTINGS_SCHEMA_VERSION,
         global: {
-            defaultModel: 'claude-opus-4-7',
+            defaultModelByEngine: { 'claude-code': 'auto', codex: 'auto' },
             dangerouslySkipPermissions: true,
             prPromptTemplate: DEFAULT_PR_PROMPT_TEMPLATE,
             reviewPromptTemplate: DEFAULT_REVIEW_PROMPT_TEMPLATE,
@@ -307,12 +395,22 @@ function defaultSettings() {
             audioNotificationVolume: 1,
             notionStatusProperty: '',
             notionInProgressStatus: '',
-            defaultPermissionMode: 'plan',
+            defaultPermissionModeByEngine: { 'claude-code': 'plan', codex: 'plan' },
             notionMcpKey: '',
             sentryMcpKey: '',
             tags: [...DEFAULT_WORKSPACE_TAGS],
             worktreesPath: WORKTREES_PATH,
             worktreesPrefixByProject: false,
+            voiceEnabled: false,
+            voicePttKey: 'alt',
+            voiceLanguage: 'auto',
+            voiceModel: null,
+            voiceCommandPath: '',
+            voiceFfmpegPath: '',
+            voiceTemperature: 0,
+            voicePrompt: '',
+            voiceTranslateToEnglish: false,
+            voiceSuppressNonSpeechTokens: true,
         },
         projects: [],
     };
@@ -497,8 +595,9 @@ export function getEffectiveSettings(projectPath) {
     const settings = readSettings();
     const project = settings.projects.find((p) => p.path === projectPath) ?? null;
     if (!project) {
+        const claudeCodeDefault = settings.global.defaultModelByEngine?.['claude-code'] ?? 'auto';
         return {
-            model: settings.global.defaultModel,
+            model: claudeCodeDefault,
             dangerouslySkipPermissions: settings.global.dangerouslySkipPermissions,
             prPromptTemplate: settings.global.prPromptTemplate,
             reviewPromptTemplate: settings.global.reviewPromptTemplate,
@@ -512,8 +611,14 @@ export function getEffectiveSettings(projectPath) {
             notionInProgressStatus: settings.global.notionInProgressStatus,
         };
     }
+    // `model` here is the legacy single-string field exposed via EffectiveSettings
+    // for back-compat with existing callers. The engine-aware default lives in
+    // `global.defaultModelByEngine[engineId]` and is read directly by the create
+    // flow / settings UI. Fall back through claude-code's entry (the historical
+    // semantics) so this field never goes empty.
+    const claudeCodeDefault = settings.global.defaultModelByEngine?.['claude-code'] ?? 'auto';
     return {
-        model: project.defaultModel || settings.global.defaultModel,
+        model: project.defaultModel || claudeCodeDefault,
         dangerouslySkipPermissions: project.dangerouslySkipPermissions ?? settings.global.dangerouslySkipPermissions,
         prPromptTemplate: project.prPromptTemplate || settings.global.prPromptTemplate,
         reviewPromptTemplate: project.reviewPromptTemplate || settings.global.reviewPromptTemplate,
@@ -531,7 +636,7 @@ export function getEffectiveSettings(projectPath) {
 export function updateGlobalSettings(data) {
     const settings = readSettings();
     const allowedGlobalKeys = [
-        'defaultModel',
+        'defaultModelByEngine',
         'dangerouslySkipPermissions',
         'prPromptTemplate',
         'reviewPromptTemplate',
@@ -545,12 +650,22 @@ export function updateGlobalSettings(data) {
         'audioNotificationVolume',
         'notionStatusProperty',
         'notionInProgressStatus',
-        'defaultPermissionMode',
+        'defaultPermissionModeByEngine',
         'notionMcpKey',
         'sentryMcpKey',
         'tags',
         'worktreesPath',
         'worktreesPrefixByProject',
+        'voiceEnabled',
+        'voicePttKey',
+        'voiceLanguage',
+        'voiceModel',
+        'voiceCommandPath',
+        'voiceFfmpegPath',
+        'voiceTemperature',
+        'voicePrompt',
+        'voiceTranslateToEnglish',
+        'voiceSuppressNonSpeechTokens',
     ];
     const filtered = pickKnownKeys(data, allowedGlobalKeys);
     if (filtered.tags !== undefined) {
@@ -564,6 +679,10 @@ export function updateGlobalSettings(data) {
         const v = Number(filtered.audioNotificationVolume);
         filtered.audioNotificationVolume = Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 1;
     }
+    if (filtered.voiceTemperature !== undefined) {
+        const t = Number(filtered.voiceTemperature);
+        filtered.voiceTemperature = Number.isFinite(t) ? Math.max(0, Math.min(1, t)) : settings.global.voiceTemperature;
+    }
     if (filtered.worktreesPath !== undefined) {
         filtered.worktreesPath = validateWorktreesPath(filtered.worktreesPath, { allowEmpty: false });
         ensureGlobalWorktreesRootExists(filtered.worktreesPath);

package/dist/server/services/transcription-service.js

@@ -0,0 +1,206 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { getKoboHome } from '../utils/paths.js';
+import { getGlobalSettings } from './settings-service.js';
+const execFileAsync = promisify(execFile);
+const MAX_LANG_LENGTH = 16;
+export class VoiceError extends Error {
+    code;
+    status;
+    constructor(message, code, status = 400) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = 'VoiceError';
+    }
+}
+export const VOICE_MODELS = [
+    {
+        name: 'tiny',
+        fileName: 'ggml-tiny.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin?download=true',
+    },
+    {
+        name: 'base',
+        fileName: 'ggml-base.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin?download=true',
+    },
+    {
+        name: 'small',
+        fileName: 'ggml-small.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.bin?download=true',
+    },
+    {
+        name: 'medium',
+        fileName: 'ggml-medium.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium.bin?download=true',
+    },
+    {
+        name: 'large-v3',
+        fileName: 'ggml-large-v3.bin',
+        url: 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3.bin?download=true',
+    },
+];
+function voiceHome() {
+    return path.join(getKoboHome(), 'voice');
+}
+function modelsDir() {
+    return path.join(voiceHome(), 'models', 'whisper');
+}
+function resolveWhisperCommand() {
+    const global = getGlobalSettings();
+    const fromSettings = (global.voiceCommandPath ?? '').trim();
+    if (fromSettings.length > 0)
+        return fromSettings;
+    return process.env.WHISPER_CPP_COMMAND || 'whisper-cli';
+}
+function resolveFfmpegCommand() {
+    const global = getGlobalSettings();
+    const fromSettings = (global.voiceFfmpegPath ?? '').trim();
+    if (fromSettings.length > 0)
+        return fromSettings;
+    return 'ffmpeg';
+}
+function ensureVoiceDirs() {
+    fs.mkdirSync(modelsDir(), { recursive: true });
+}
+function resolveModel(name) {
+    const model = VOICE_MODELS.find((m) => m.name === name);
+    if (!model)
+        throw new VoiceError(`Unknown voice model '${name}'`, 'MODEL_UNKNOWN', 400);
+    return model;
+}
+export function listVoiceModels() {
+    ensureVoiceDirs();
+    const settings = getGlobalSettings();
+    const available = VOICE_MODELS.map((m) => ({
+        name: m.name,
+        fileName: m.fileName,
+        installed: fs.existsSync(path.join(modelsDir(), m.fileName)),
+    }));
+    return { available, activeModel: settings.voiceModel };
+}
+export async function getVoiceRuntimeStatus() {
+    const command = resolveWhisperCommand();
+    let ffmpegAvailable = true;
+    let ffmpegError;
+    try {
+        await execFileAsync(resolveFfmpegCommand(), ['-version'], { timeout: 5000 });
+    }
+    catch (err) {
+        ffmpegAvailable = false;
+        ffmpegError = err instanceof Error ? err.message : String(err);
+    }
+    try {
+        await execFileAsync(command, ['-h'], { timeout: 5000 });
+        return { available: ffmpegAvailable, command, ffmpegAvailable, ffmpegError };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { available: false, command, error: message, ffmpegAvailable, ffmpegError };
+    }
+}
+export async function downloadVoiceModel(name) {
+    ensureVoiceDirs();
+    const model = resolveModel(name);
+    const res = await fetch(model.url);
+    if (!res.ok) {
+        throw new VoiceError(`Failed to download model '${name}' (HTTP ${res.status})`, 'MODEL_DOWNLOAD_FAILED', 500);
+    }
+    const filePath = path.join(modelsDir(), model.fileName);
+    const tmpPath = `${filePath}.tmp`;
+    try {
+        const bytes = Buffer.from(await res.arrayBuffer());
+        fs.writeFileSync(tmpPath, bytes);
+        fs.renameSync(tmpPath, filePath);
+    }
+    finally {
+        if (fs.existsSync(tmpPath))
+            fs.rmSync(tmpPath, { force: true });
+    }
+    return { name, filePath };
+}
+export function deleteVoiceModel(name) {
+    const model = resolveModel(name);
+    const filePath = path.join(modelsDir(), model.fileName);
+    if (fs.existsSync(filePath))
+        fs.unlinkSync(filePath);
+}
+function getInstalledModelPath(name) {
+    const model = resolveModel(name);
+    const fullPath = path.join(modelsDir(), model.fileName);
+    if (!fs.existsSync(fullPath)) {
+        throw new VoiceError(`Model '${name}' is not installed`, 'MODEL_NOT_INSTALLED', 400);
+    }
+    return fullPath;
+}
+export async function transcribeAudio(params) {
+    const { audioBuffer, modelName } = params;
+    const language = params.language && params.language.trim().length > 0 ? params.language : 'auto';
+    const temperature = Number.isFinite(Number(params.temperature))
+        ? Math.max(0, Math.min(1, Number(params.temperature)))
+        : 0;
+    const prompt = (params.prompt ?? '').trim();
+    const translateToEnglish = params.translateToEnglish === true;
+    const suppressNst = params.suppressNonSpeechTokens !== false;
+    if (language.length > MAX_LANG_LENGTH || !/^[a-z-]+$/i.test(language)) {
+        throw new VoiceError(`Invalid language '${language}'`, 'LANGUAGE_INVALID', 400);
+    }
+    const modelPath = getInstalledModelPath(modelName);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kobo-voice-'));
+    const audioPath = path.join(tmpDir, 'input.webm');
+    const wavPath = path.join(tmpDir, 'input.wav');
+    try {
+        fs.writeFileSync(audioPath, audioBuffer);
+        // Normalize browser-recorded audio (webm/ogg/...) to a mono WAV file that
+        // whisper-cli can decode reliably across platforms.
+        await execFileAsync(resolveFfmpegCommand(), ['-y', '-i', audioPath, '-ar', '16000', '-ac', '1', wavPath], {
+            timeout: 60000,
+        });
+        const cmd = resolveWhisperCommand();
+        const args = [
+            '-m',
+            modelPath,
+            '-f',
+            wavPath,
+            '-otxt',
+            '-of',
+            path.join(tmpDir, 'out'),
+            '--temperature',
+            String(temperature),
+        ];
+        if (language !== 'auto')
+            args.push('-l', language);
+        if (translateToEnglish)
+            args.push('--translate');
+        if (suppressNst)
+            args.push('--suppress-nst');
+        if (prompt.length > 0)
+            args.push('--prompt', prompt);
+        const start = Date.now();
+        const { stderr } = await execFileAsync(cmd, args, { timeout: 120000 });
+        const durationMs = Date.now() - start;
+        const outTxt = path.join(tmpDir, 'out.txt');
+        if (!fs.existsSync(outTxt)) {
+            throw new VoiceError(`Transcription output missing (${stderr || 'no stderr'})`, 'TRANSCRIPTION_FAILED', 500);
+        }
+        const text = fs.readFileSync(outTxt, 'utf-8').trim();
+        return { text, durationMs, model: modelName, language };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('ENOENT')) {
+            throw new VoiceError('Voice runtime missing (whisper-cli or ffmpeg)', 'VOICE_RUNTIME_MISSING', 500);
+        }
+        if (message.includes('timed out')) {
+            throw new VoiceError('Whisper transcription timed out', 'TRANSCRIPTION_TIMEOUT', 500);
+        }
+        throw err;
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}

package/dist/server/utils/paths.js

@@ -100,8 +100,15 @@ export function getTemplatesPath() {
  * Absolute path to the compiled MCP server entry (shipped in the published
  * package as dist/mcp-server/kobo-tasks-server.js). Returns null if not
  * present — callers (orchestrator) then fall back to the TS source for dev.
+ *
+ * `KOBO_ENFORCE_LOCAL_HOME=1` (set by `npm run dev`) forces the source path
+ * even if a stale `dist/mcp-server/` from a prior `npm run build` is hanging
+ * around. Without this guard, edits to `kobo-tasks-server.ts` are silently
+ * ignored during dev (the orchestrator spawns the months-old compiled binary).
  */
 export function getCompiledMcpServerPath() {
+    if (process.env.KOBO_ENFORCE_LOCAL_HOME === '1')
+        return null;
     const compiled = getPackageAssetPath('dist', 'mcp-server', 'kobo-tasks-server.js');
     return fs.existsSync(compiled) ? compiled : null;
 }

package/dist/shared/codex-models.js

@@ -0,0 +1,43 @@
+/**
+ * Codex model catalogue — kept in sync with the official roster published at
+ * developers.openai.com/codex/models. The Codex CLI accepts arbitrary strings
+ * in `--model`, so power users can still pin a model not listed here by
+ * editing the workspace `model` field directly. This list reflects the
+ * recommended set surfaced in the create-workspace selector.
+ *
+ * Auth caveat: `gpt-5.5` is currently only reachable when authenticated via
+ * ChatGPT (Plus/Pro/Team/Enterprise). API-key auth is limited to `gpt-5.4`
+ * and below.
+ */
+export const CODEX_MODELS = [
+    {
+        id: 'auto',
+        label: 'Auto',
+        i18nLabelKey: 'model.auto',
+        i18nDescriptionKey: 'model.autoDescription',
+    },
+    {
+        id: 'gpt-5.5',
+        label: 'GPT-5.5',
+        i18nLabelKey: 'model.gpt55',
+        i18nDescriptionKey: 'model.gpt55Description',
+    },
+    {
+        id: 'gpt-5.4',
+        label: 'GPT-5.4',
+        i18nLabelKey: 'model.gpt54',
+        i18nDescriptionKey: 'model.gpt54Description',
+    },
+    {
+        id: 'gpt-5.4-mini',
+        label: 'GPT-5.4 mini',
+        i18nLabelKey: 'model.gpt54mini',
+        i18nDescriptionKey: 'model.gpt54miniDescription',
+    },
+    {
+        id: 'gpt-5.3-codex',
+        label: 'GPT-5.3 Codex',
+        i18nLabelKey: 'model.gpt53codex',
+        i18nDescriptionKey: 'model.gpt53codexDescription',
+    },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.7.6",
+  "version": "1.7.8",
   "description": "Kōbō — multi-workspace agent manager for Claude Code. Orchestrates isolated git worktrees with dev servers, Notion integration, and MCP tools.",
   "type": "module",
   "license": "GPL-3.0-or-later",
@@ -66,25 +66,28 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.126",
-    "@hono/node-server": "^1.19.13",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.90",
+    "@emnapi/core": "^1.10.0",
+    "@emnapi/runtime": "^1.10.0",
+    "@hono/node-server": "^2.0.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "better-sqlite3": "^12.8.0",
+    "@openai/codex": "^0.130.0",
+    "better-sqlite3": "^12.9.0",
     "cron-parser": "^5.5.0",
-    "hono": "^4.12.12",
-    "nanoid": "^5.1.7",
+    "hono": "^4.12.18",
+    "nanoid": "^5.1.11",
     "node-pty": "^1.1.0",
     "ws": "^8.20.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.10",
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.2",
     "@types/ws": "^8.18.1",
-    "@vitest/runner": "^4.1.2",
+    "@vitest/runner": "^4.1.5",
     "concurrently": "^9.2.1",
     "tsx": "^4.21.0",
-    "typescript": "^6.0.2",
-    "vitest": "^3.2.4"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   }
 }