codeclaw 0.2.7 → 0.2.9

package/dist/bot-telegram.js

@@ -12,11 +12,35 @@ import { Bot, VERSION, fmtTokens, fmtUptime, fmtBytes, whichSync, listSubdirs, b
 import { TelegramChannel } from './channel-telegram.js';
 import { splitText } from './channel-base.js';
 // ---------------------------------------------------------------------------
+// Context window sizes (max input tokens per model family)
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 // Telegram HTML formatting
 // ---------------------------------------------------------------------------
 function escapeHtml(t) {
     return t.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
+function claudeModelAlias(modelId) {
+    const value = String(modelId || '').trim().toLowerCase();
+    if (!value)
+        return null;
+    if (value === 'opus' || value.startsWith('claude-opus-'))
+        return 'opus';
+    if (value === 'sonnet' || value.startsWith('claude-sonnet-'))
+        return 'sonnet';
+    if (value === 'haiku' || value.startsWith('claude-haiku-'))
+        return 'haiku';
+    return null;
+}
+function modelMatchesSelection(agent, selection, currentModel) {
+    if (selection === currentModel)
+        return true;
+    if (agent !== 'claude')
+        return false;
+    const a = claudeModelAlias(selection);
+    const b = claudeModelAlias(currentModel);
+    return !!a && a === b;
+}
 function mdToTgHtml(text) {
     const result = [];
     const lines = text.split('\n');
@@ -321,6 +345,7 @@ export class TelegramBot extends Bot {
     static MENU_COMMANDS = [
         { command: 'sessions', description: 'List / switch sessions' },
         { command: 'agents', description: 'List / switch agents' },
+        { command: 'models', description: 'List / switch models' },
         { command: 'status', description: 'Bot status' },
         { command: 'host', description: 'Host machine info' },
         { command: 'switch', description: 'Switch working directory' },
@@ -336,6 +361,7 @@ export class TelegramBot extends Bot {
         await ctx.reply(`<b>codeclaw</b> v${VERSION}\n\n` +
             `/sessions \u2014 List / switch sessions\n` +
             `/agents \u2014 List / switch agents\n` +
+            `/models \u2014 List / switch models\n` +
             `/status \u2014 Bot status\n` +
             `/host \u2014 Host machine info\n` +
             `/switch \u2014 Switch working directory\n` +
@@ -454,6 +480,33 @@ export class TelegramBot extends Bot {
         }
         await ctx.reply(lines.join('\n'), { parseMode: 'HTML', keyboard: { inline_keyboard: rows } });
     }
+    async cmdModels(ctx) {
+        const cs = this.chat(ctx.chatId);
+        const res = this.fetchModels(cs.agent);
+        const currentModel = this.modelForAgent(cs.agent);
+        const lines = [`<b>Models for ${escapeHtml(cs.agent)}</b>`];
+        if (res.sources.length)
+            lines.push(`<i>Source: ${escapeHtml(res.sources.join(', '))}</i>`);
+        if (res.note)
+            lines.push(`<i>${escapeHtml(res.note)}</i>`);
+        lines.push('');
+        const rows = [];
+        if (!res.models.length) {
+            lines.push('<i>No discoverable models found.</i>');
+        }
+        for (const m of res.models) {
+            const isCurrent = modelMatchesSelection(cs.agent, m.id, currentModel);
+            const status = isCurrent ? '\u25CF' : '\u25CB';
+            const display = m.alias ? `${m.alias} (${m.id})` : m.id;
+            const currentSuffix = isCurrent
+                ? (m.id === currentModel ? ' \u2190 current' : ` \u2190 current (${escapeHtml(currentModel)})`)
+                : '';
+            lines.push(`${status} <code>${escapeHtml(display)}</code>${currentSuffix}`);
+            const label = isCurrent ? `\u25CF ${m.alias || m.id}` : (m.alias || m.id);
+            rows.push([{ text: label, callback_data: `mod:${m.id}` }]);
+        }
+        await ctx.reply(lines.join('\n'), { parseMode: 'HTML', keyboard: { inline_keyboard: rows } });
+    }
     async cmdRestart(ctx) {
         const activeTasks = this.activeTasks.size;
         if (activeTasks > 0) {
@@ -477,7 +530,8 @@ export class TelegramBot extends Bot {
         this.log(`restart: spawning \`${bin} ${allArgs.join(' ')}\``);
         // Collect all known chat IDs so the new process can send startup notices
         const knownIds = new Set(this.allowedChatIds);
-        for (const cid of this.channel.knownChats)
+        const knownChats = this.channel.knownChats instanceof Set ? this.channel.knownChats : new Set();
+        for (const cid of knownChats)
             knownIds.add(cid);
         const child = spawn(bin, allArgs, {
             stdio: 'inherit',
@@ -598,6 +652,14 @@ export class TelegramBot extends Bot {
                 tp.push(`cached: ${fmtTokens(result.cachedInputTokens)}`);
             if (result.outputTokens != null)
                 tp.push(`out: ${fmtTokens(result.outputTokens)}`);
+            // Context window usage percentage from CLI-reported contextWindow
+            // For Codex use cumulative input (= full session context); for Claude use inputTokens
+            const ctxMax = result.contextWindow;
+            const ctxInput = result.codexCumulative?.input ?? result.inputTokens;
+            if (ctxMax && ctxInput != null) {
+                const pct = (ctxInput / ctxMax * 100).toFixed(1);
+                tp.push(`ctx: ${pct}%`);
+            }
             tokenBlock = `\n<blockquote expandable>${tp.join('  ')}</blockquote>`;
         }
         const quickReplies = result.incomplete ? [] : detectQuickReplies(result.message);
@@ -736,11 +798,13 @@ export class TelegramBot extends Bot {
             const cs = this.chat(ctx.chatId);
             if (sessionId === 'new') {
                 cs.sessionId = null;
+                cs.codexCumulative = undefined;
                 await ctx.answerCallback('New session');
                 await ctx.editReply(ctx.messageId, 'Session reset. Send a message to start.', {});
             }
             else {
                 cs.sessionId = sessionId;
+                cs.codexCumulative = undefined;
                 await ctx.answerCallback(`Session: ${sessionId.slice(0, 12)}`);
                 await ctx.editReply(ctx.messageId, `Switched to session: <code>${escapeHtml(sessionId.slice(0, 16))}</code>`, { parseMode: 'HTML' });
             }
@@ -755,11 +819,28 @@ export class TelegramBot extends Bot {
             }
             cs.agent = agent;
             cs.sessionId = null;
+            cs.codexCumulative = undefined;
             this.log(`agent switched to ${agent} chat=${ctx.chatId}`);
             await ctx.answerCallback(`Switched to ${agent}`);
             await ctx.editReply(ctx.messageId, `<b>Switched to ${escapeHtml(agent)}</b>\n\nSession has been reset. Previous conversation history will not carry over.\nSend a message to start a new conversation.`, { parseMode: 'HTML' });
             return;
         }
+        if (data.startsWith('mod:')) {
+            const modelId = data.slice(4);
+            const cs = this.chat(ctx.chatId);
+            const currentModel = this.modelForAgent(cs.agent);
+            if (currentModel === modelId) {
+                await ctx.answerCallback(`Already using ${modelId}`);
+                return;
+            }
+            this.setModelForAgent(cs.agent, modelId);
+            cs.sessionId = null;
+            cs.codexCumulative = undefined;
+            this.log(`model switched to ${modelId} for ${cs.agent} chat=${ctx.chatId}`);
+            await ctx.answerCallback(`Switched to ${modelId}`);
+            await ctx.editReply(ctx.messageId, `<b>Model switched to <code>${escapeHtml(modelId)}</code></b>\n\nAgent: ${escapeHtml(cs.agent)}\nSession has been reset. Send a message to start a new conversation.`, { parseMode: 'HTML' });
+            return;
+        }
         if (data.startsWith('qr:')) {
             const parts = data.split(':');
             if (parts.length === 3) {
@@ -788,6 +869,9 @@ export class TelegramBot extends Bot {
                 case 'agents':
                     await this.cmdAgents(ctx);
                     return;
+                case 'models':
+                    await this.cmdModels(ctx);
+                    return;
                 case 'status':
                     await this.cmdStatus(ctx);
                     return;

package/dist/bot.js

@@ -7,8 +7,8 @@ import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
-import { doStream, getSessions, getUsage, listAgents, } from './code-agent.js';
-export const VERSION = '0.2.7';
+import { doStream, getSessions, getUsage, listAgents, listModels, } from './code-agent.js';
+export const VERSION = '0.2.9';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -186,6 +186,16 @@ export class Bot {
     fetchAgents() {
         return listAgents();
     }
+    fetchModels(agent) {
+        return listModels(agent, { workdir: this.workdir, currentModel: this.modelForAgent(agent) });
+    }
+    setModelForAgent(agent, modelId) {
+        if (agent === 'codex')
+            this.codexModel = modelId;
+        else
+            this.claudeModel = modelId;
+        this.log(`model for ${agent} changed to ${modelId}`);
+    }
     getStatusData(chatId) {
         const cs = this.chat(chatId);
         const mem = process.memoryUsage();
@@ -222,8 +232,10 @@ export class Bot {
     switchWorkdir(newPath) {
         const old = this.workdir;
         this.workdir = newPath;
-        for (const [, cs] of this.chats)
+        for (const [, cs] of this.chats) {
             cs.sessionId = null;
+            cs.codexCumulative = undefined;
+        }
         this.log(`switch workdir: ${old} -> ${newPath}`);
         return old;
     }
@@ -242,6 +254,7 @@ export class Bot {
             attachments: attachments.length ? attachments : undefined,
             codexModel: this.codexModel, codexFullAccess: this.codexFullAccess,
             codexExtraArgs: this.codexExtraArgs.length ? this.codexExtraArgs : undefined,
+            codexPrevCumulative: cs.codexCumulative,
             claudeModel: this.claudeModel, claudePermissionMode: this.claudePermissionMode,
             claudeExtraArgs: this.claudeExtraArgs.length ? this.claudeExtraArgs : undefined,
         };
@@ -253,6 +266,9 @@ export class Bot {
             this.stats.totalOutputTokens += result.outputTokens;
         if (result.cachedInputTokens)
             this.stats.totalCachedTokens += result.cachedInputTokens;
+        // Store cumulative Codex totals for next invocation delta
+        if (result.codexCumulative)
+            cs.codexCumulative = result.codexCumulative;
         // Only update sessionId if it hasn't been changed externally (e.g. user switched session during run)
         if (result.sessionId && cs.sessionId === snapshotSessionId)
             cs.sessionId = result.sessionId;

package/dist/code-agent.js

@@ -16,6 +16,8 @@ async function run(cmd, opts, parseLine) {
         sessionId: opts.sessionId, text: '', thinking: '', msgs: [], thinkParts: [],
         model: opts.model, thinkingEffort: opts.thinkingEffort, errors: null,
         inputTokens: null, outputTokens: null, cachedInputTokens: null,
+        contextWindow: null,
+        codexCumulative: null,
         stopReason: null,
     };
     const shellCmd = cmd.map(Q).join(' ');
@@ -89,6 +91,8 @@ async function run(cmd, opts, parseLine) {
         thinking: s.thinking.trim() || null,
         elapsedS: (Date.now() - start) / 1000,
         inputTokens: s.inputTokens, outputTokens: s.outputTokens, cachedInputTokens: s.cachedInputTokens,
+        contextWindow: s.contextWindow,
+        codexCumulative: s.codexCumulative,
         error,
         stopReason: s.stopReason,
         incomplete,
@@ -116,7 +120,7 @@ function codexCmd(o) {
     args.push('-');
     return args;
 }
-function codexParse(ev, s) {
+function codexParse(ev, s, opts) {
     const t = ev.type || '';
     if (t === 'thread.started') {
         s.sessionId = ev.thread_id ?? s.sessionId;
@@ -136,15 +140,26 @@ function codexParse(ev, s) {
     if (t === 'turn.completed') {
         const u = ev.usage;
         if (u) {
-            s.inputTokens = u.input_tokens ?? s.inputTokens;
-            s.cachedInputTokens = u.cached_input_tokens ?? s.cachedInputTokens;
-            s.outputTokens = u.output_tokens ?? s.outputTokens;
+            // Codex reports cumulative session totals in turn.completed.
+            // Store raw cumulative and compute per-invocation delta.
+            const cumInput = u.input_tokens ?? 0;
+            const cumOutput = u.output_tokens ?? 0;
+            const cumCached = u.cached_input_tokens ?? 0;
+            s.codexCumulative = { input: cumInput, output: cumOutput, cached: cumCached };
+            const prev = opts.codexPrevCumulative;
+            s.inputTokens = prev ? Math.max(0, cumInput - prev.input) : cumInput;
+            s.outputTokens = prev ? Math.max(0, cumOutput - prev.output) : cumOutput;
+            s.cachedInputTokens = prev ? Math.max(0, cumCached - prev.cached) : cumCached;
         }
         s.model = ev.model ?? s.model;
     }
 }
-export function doCodexStream(opts) {
-    return run(codexCmd(opts), opts, codexParse);
+export async function doCodexStream(opts) {
+    const result = await run(codexCmd(opts), opts, (ev, s) => codexParse(ev, s, opts));
+    // Codex doesn't report context_window in stream events; read from models_cache.json
+    if (!result.contextWindow)
+        result.contextWindow = readCodexContextWindow(result.model);
+    return result;
 }
 // --- claude ---
 const IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
@@ -260,6 +275,16 @@ function claudeParse(ev, s) {
             s.cachedInputTokens = (u.cache_read_input_tokens ?? u.cached_input_tokens) ?? s.cachedInputTokens;
             s.outputTokens = u.output_tokens ?? s.outputTokens;
         }
+        // Extract contextWindow from modelUsage (Claude CLI reports this in result event)
+        const mu = ev.modelUsage;
+        if (mu && typeof mu === 'object') {
+            for (const info of Object.values(mu)) {
+                if (info?.contextWindow > 0) {
+                    s.contextWindow = info.contextWindow;
+                    break;
+                }
+            }
+        }
     }
 }
 export async function doClaudeStream(opts) {
@@ -361,7 +386,7 @@ function readLastLine(filePath) {
     }
 }
 function parseCodexSession(filePath) {
-    const lines = readLines(filePath, 10);
+    const lines = readLines(filePath, 40);
     const line = lines[0];
     if (!line)
         return null;
@@ -370,24 +395,32 @@ function parseCodexSession(filePath) {
         if (ev.type !== 'session_meta')
             return null;
         const p = ev.payload || {};
+        let model = typeof p.model === 'string' ? p.model : null;
         let title = null;
         for (const raw of lines.slice(1)) {
             if (!raw || raw[0] !== '{')
                 continue;
             try {
                 const item = JSON.parse(raw);
+                if (!model && item.type === 'turn_context') {
+                    const payload = item.payload || {};
+                    model =
+                        (typeof payload.model === 'string' ? payload.model : null)
+                            || (typeof payload?.collaboration_mode?.settings?.model === 'string' ? payload.collaboration_mode.settings.model : null)
+                            || model;
+                }
                 if (item.type === 'response_item' && item.payload?.role === 'user' && item.payload?.type === 'message') {
                     const content = item.payload.content;
                     if (Array.isArray(content)) {
                         const textBlock = content.find((b) => b?.type === 'input_text' && b.text && !/^[<#]/.test(b.text));
-                        if (textBlock) {
+                        if (textBlock)
                             title = textBlock.text.slice(0, 120);
-                            break;
-                        }
                     }
                 }
             }
             catch { /* skip */ }
+            if (model && title)
+                break;
         }
         // Codex writes task_complete as the last event when done
         let running = false;
@@ -403,7 +436,7 @@ function parseCodexSession(filePath) {
             sessionId: p.id ?? path.basename(filePath, '.jsonl'),
             agent: 'codex',
             workdir: p.cwd ?? null,
-            model: p.model_provider ?? null,
+            model: model ?? null,
             createdAt: p.timestamp ?? null,
             title,
             running,
@@ -528,6 +561,258 @@ export function listAgents() {
         ],
     };
 }
+function shellOutput(cmd) {
+    try {
+        return execSync(cmd, { encoding: 'utf-8', timeout: 3000 }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function pushUnique(items, value) {
+    if (!items.includes(value))
+        items.push(value);
+}
+function pushModel(models, seen, id, alias) {
+    const cleanId = id.trim();
+    if (!cleanId || seen.has(cleanId))
+        return;
+    seen.add(cleanId);
+    models.push({ id: cleanId, alias: alias?.trim() || null });
+}
+function claudeModelAlias(modelId) {
+    const value = String(modelId || '').trim().toLowerCase();
+    if (!value)
+        return null;
+    if (value === 'opus' || value.startsWith('claude-opus-'))
+        return 'opus';
+    if (value === 'sonnet' || value.startsWith('claude-sonnet-'))
+        return 'sonnet';
+    if (value === 'haiku' || value.startsWith('claude-haiku-'))
+        return 'haiku';
+    return null;
+}
+function isClaudeModelToken(token) {
+    return token === 'opus' || token === 'sonnet' || token === 'haiku' || token.startsWith('claude-');
+}
+function addClaudeModel(models, seen, rawModel) {
+    const clean = String(rawModel || '').trim();
+    if (!clean)
+        return false;
+    const alias = claudeModelAlias(clean);
+    if (!alias && !clean.toLowerCase().startsWith('claude-'))
+        return false;
+    if (clean === alias) {
+        if (models.some((m) => m.alias === alias))
+            return false;
+        pushModel(models, seen, clean, null);
+        return true;
+    }
+    if (alias) {
+        const aliasIndex = models.findIndex((m) => m.id === alias && !m.alias);
+        if (aliasIndex >= 0) {
+            models.splice(aliasIndex, 1);
+            seen.delete(alias);
+        }
+    }
+    pushModel(models, seen, clean, alias);
+    return true;
+}
+function isCodexModelToken(token) {
+    return /^(?:o\d(?:-[a-z0-9.-]+)?|gpt-[a-z0-9.-]+|codex-mini(?:-[a-z0-9.-]+)?)$/i.test(token);
+}
+function addCodexModel(models, seen, rawModel) {
+    const clean = String(rawModel || '').trim();
+    if (!clean || !isCodexModelToken(clean))
+        return false;
+    pushModel(models, seen, clean, null);
+    return true;
+}
+function readCodexConfigModels(home) {
+    const configPath = path.join(home, '.codex', 'config.toml');
+    if (!fs.existsSync(configPath))
+        return [];
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const found = [];
+        const defaultModel = raw.match(/^\s*model\s*=\s*"([^"]+)"/m)?.[1];
+        if (defaultModel)
+            pushUnique(found, defaultModel);
+        const migrationsSection = raw.match(/\[notice\.model_migrations\]\n([\s\S]*?)(?:\n\[|$)/)?.[1] || '';
+        for (const match of migrationsSection.matchAll(/"[^"]+"\s*=\s*"([^"]+)"/g)) {
+            if (match[1])
+                pushUnique(found, match[1]);
+        }
+        return found.filter(isCodexModelToken);
+    }
+    catch {
+        return [];
+    }
+}
+function readCodexCachedModels(home) {
+    const cachePath = path.join(home, '.codex', 'models_cache.json');
+    if (!fs.existsSync(cachePath))
+        return [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+        const models = Array.isArray(raw?.models) ? raw.models : [];
+        return models
+            .filter((m) => m?.visibility === 'list')
+            .sort((a, b) => (Number(a?.priority) || 0) - (Number(b?.priority) || 0))
+            .map((m) => String(m?.slug || '').trim())
+            .filter(isCodexModelToken);
+    }
+    catch {
+        return [];
+    }
+}
+/** Look up context_window for a Codex model from ~/.codex/models_cache.json */
+function readCodexContextWindow(model) {
+    if (!model)
+        return null;
+    const home = process.env.HOME || '';
+    const cachePath = path.join(home, '.codex', 'models_cache.json');
+    if (!fs.existsSync(cachePath))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+        const models = Array.isArray(raw?.models) ? raw.models : [];
+        const entry = models.find((m) => m?.slug === model);
+        const cw = Number(entry?.context_window);
+        return cw > 0 ? cw : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readClaudeStateModels(home, workdir) {
+    const statePath = path.join(home, '.claude.json');
+    if (!fs.existsSync(statePath))
+        return [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        const projects = raw?.projects;
+        if (!projects || typeof projects !== 'object')
+            return [];
+        const found = [];
+        const addFromProject = (projectState) => {
+            const usage = projectState?.lastModelUsage;
+            if (!usage || typeof usage !== 'object')
+                return;
+            for (const modelId of Object.keys(usage)) {
+                if (isClaudeModelToken(modelId))
+                    pushUnique(found, modelId);
+            }
+        };
+        if (workdir && typeof projects[workdir] === 'object') {
+            addFromProject(projects[workdir]);
+        }
+        for (const [projectPath, projectState] of Object.entries(projects)) {
+            if (projectPath === workdir)
+                continue;
+            addFromProject(projectState);
+        }
+        return found;
+    }
+    catch {
+        return [];
+    }
+}
+function discoverClaudeModels(opts) {
+    const models = [];
+    const seen = new Set();
+    const sources = [];
+    const home = process.env.HOME || '';
+    if (opts.currentModel?.trim()) {
+        addClaudeModel(models, seen, opts.currentModel);
+        pushUnique(sources, 'current config');
+    }
+    let foundStateModel = false;
+    for (const modelId of readClaudeStateModels(home, opts.workdir)) {
+        foundStateModel = addClaudeModel(models, seen, modelId) || foundStateModel;
+    }
+    if (foundStateModel)
+        pushUnique(sources, '~/.claude.json');
+    const help = shellOutput('claude --help 2>/dev/null');
+    if (help) {
+        let foundHelpModel = false;
+        for (const match of help.matchAll(/\b(?:opus|sonnet|haiku|claude-(?:opus|sonnet|haiku)-[a-z0-9-]+)\b/gi)) {
+            const token = match[0].trim();
+            foundHelpModel = addClaudeModel(models, seen, token) || foundHelpModel;
+        }
+        if (foundHelpModel)
+            pushUnique(sources, 'claude --help');
+    }
+    if (opts.workdir) {
+        const sessions = getClaudeSessions({ agent: 'claude', workdir: opts.workdir, limit: 20 });
+        let foundSessionModel = false;
+        for (const session of sessions.sessions) {
+            if (!session.model)
+                continue;
+            foundSessionModel = addClaudeModel(models, seen, session.model) || foundSessionModel;
+        }
+        if (foundSessionModel)
+            pushUnique(sources, 'recent sessions');
+    }
+    return {
+        agent: 'claude',
+        models,
+        sources,
+        note: 'Claude CLI does not expose a machine-readable model list; entries are discovered from current config, ~/.claude.json, CLI help, and local session state.',
+    };
+}
+function discoverCodexModels(opts) {
+    const models = [];
+    const seen = new Set();
+    const sources = [];
+    const home = process.env.HOME || '';
+    let foundCacheModel = false;
+    for (const modelId of readCodexCachedModels(home)) {
+        foundCacheModel = addCodexModel(models, seen, modelId) || foundCacheModel;
+    }
+    if (foundCacheModel)
+        pushUnique(sources, '~/.codex/models_cache.json');
+    const help = shellOutput('codex --help 2>/dev/null');
+    if (help) {
+        let foundHelpModel = false;
+        for (const match of help.matchAll(/model="([^"]+)"/g)) {
+            addCodexModel(models, seen, match[1]);
+            foundHelpModel = true;
+        }
+        if (foundHelpModel)
+            pushUnique(sources, 'codex --help');
+    }
+    if (opts.currentModel?.trim()) {
+        addCodexModel(models, seen, opts.currentModel);
+        pushUnique(sources, 'current config');
+    }
+    let foundConfigModel = false;
+    for (const modelId of readCodexConfigModels(home)) {
+        foundConfigModel = addCodexModel(models, seen, modelId) || foundConfigModel;
+    }
+    if (foundConfigModel)
+        pushUnique(sources, '~/.codex/config.toml');
+    if (opts.workdir) {
+        const sessions = getCodexSessions({ agent: 'codex', workdir: opts.workdir, limit: 20 });
+        let foundSessionModel = false;
+        for (const session of sessions.sessions) {
+            if (!session.model)
+                continue;
+            foundSessionModel = addCodexModel(models, seen, session.model) || foundSessionModel;
+        }
+        if (foundSessionModel)
+            pushUnique(sources, 'recent sessions');
+    }
+    return {
+        agent: 'codex',
+        models,
+        sources,
+        note: 'Codex CLI does not expose a model-list subcommand; entries are discovered from the local Codex model cache and other local state.',
+    };
+}
+export function listModels(agent, opts = {}) {
+    return agent === 'codex' ? discoverCodexModels(opts) : discoverClaudeModels(opts);
+}
 function toIsoFromEpochSeconds(value) {
     const n = Number(value);
     if (!Number.isFinite(n) || n <= 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeclaw",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "The best IM-driven remote coding experience. Bridge AI coding agents to any IM.",
   "type": "module",
   "bin": {