sideby 0.5.0 → 0.6.0

package/README.md

@@ -55,7 +55,7 @@ The agent checks Node and your Host CLIs, installs sideby and the skill, creates
 
 ## What it looks like
 
-<img alt="Two terminals: the personal account and the work account running at the same time, then the local quota panel" src="https://raw.githubusercontent.com/Adonis0123/sideby/main/docs/assets/demo.gif" width="1280">
+<img alt="Two terminals: the personal account and the work account running at the same time, both linked to the main account's skills and settings, then the local quota panel, and at 95% Auto Handoff moving work's session to the next account" src="https://raw.githubusercontent.com/Adonis0123/sideby/main/docs/assets/demo.gif" width="1280">
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Adonis0123/sideby/main/docs/assets/panel-dark.png">
@@ -71,6 +71,7 @@ The agent checks Node and your Host CLIs, installs sideby and the skill, creates
 | Find and fix config drift between accounts | `sideby doctor --fix` | [Doctor](docs/guide/usage.md#doctor) |
 | See Claude quota (Codex needs no setup) | `sideby quota setup claude --yes` | [Claude quota](docs/guide/usage.md#claude-quota) |
 | Find the cheapest auto-compact size from your own sessions, and use it in one click | `sideby tune` (or the panel's Context tuning tab) | [Context tuning](docs/guide/usage.md#context-tuning) |
+| See each account's model and effort, and set them per account | `sideby model <account>` (or click the model in the panel) | [Model and effort](docs/guide/usage.md#model-and-effort) |
 | Move on when an account hits its limit | `sideby next claude` | [Handoff](docs/guide/usage.md#when-an-account-hits-its-limit) |
 | Let a running task move to the next account by itself when quota runs low (off by default; see the risk) | `sideby handoff enable` (or the panel) | [Auto Handoff](docs/guide/usage.md#auto-handoff) |
 | Short commands such as `ccw` | `sideby alias add ccw claude:work` | [Shell functions](docs/guide/configuration.md#shell-functions) |

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261014T061214-0f7370"}
+{"id":"20261014T070544-66900c"}

package/dist/src/cli/commands.d.ts

@@ -43,6 +43,11 @@ export declare function cmdResume(a: ParsedArgs, io: Io): Promise<number>;
 /** `sideby next <family>`: recommend the Account with the most room, then start it (spec §3.13). */
 export declare function cmdNext(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdDoctor(a: ParsedArgs, io: Io): Promise<number>;
+/**
+ * `sideby model <account> [<model>|default] [--effort <level>|default] [--yes]` (spec §3.19, ADR-0014): shows the
+ * Account's model and effort; with a change, shows it (exit 10) and writes it with --yes.
+ */
+export declare function cmdModel(a: ParsedArgs, io: Io): Promise<number>;
 /** `sideby tune [account|family]`: estimated Compaction Threshold per model (spec §3.18). */
 export declare function cmdTune(a: ParsedArgs, io: Io): Promise<number>;
 export declare function cmdQuota(a: ParsedArgs, io: Io): Promise<number>;

package/dist/src/cli/commands.js

@@ -6,6 +6,7 @@ import { requestHandoff } from '../core/handoff-chain.js';
 import { explain, readyDecision, runWithHandoff } from '../core/handoff-run.js';
 import { configureHandoff, handoffHint, handoffStatus } from '../core/handoff-status.js';
 import { runHost } from '../core/launch.js';
+import { accountModel, setAccountModel } from '../core/model-choice.js';
 import { resolvePaths, tildify } from '../core/paths.js';
 import { USAGE_DAYS } from '../core/quota-levels.js';
 import { SHELLS } from '../core/shell-init.js';
@@ -401,6 +402,72 @@ async function cmdTuneChange(a, io, action) {
         io.out(r.message);
     return r.ok ? 0 : 1;
 }
+const FROM = {
+    sideby: 'set by sideby',
+    host: 'from the host config',
+    last: 'last session',
+};
+/**
+ * `sideby model <account> [<model>|default] [--effort <level>|default] [--yes]` (spec §3.19, ADR-0014): shows the
+ * Account's model and effort; with a change, shows it (exit 10) and writes it with --yes.
+ */
+export async function cmdModel(a, io) {
+    const [ref, model] = a.positionals;
+    if (!ref || a.positionals.length > 2 || a.flags.get('effort') === true)
+        throw new UsageError('usage: sideby model <account> [<model>|default] [--effort <level>|default] [--yes] [--json]');
+    const wantJson = a.flags.has('json');
+    const rt = await createRuntime();
+    const account = await rt.resolve(ref);
+    const effort = a.flags.get('effort');
+    const view = await accountModel(rt, account);
+    const shown = {
+        account: account.ref,
+        family: account.family,
+        settable: view.settable,
+        ...(view.reason ? { reason: view.reason } : {}),
+        efforts: view.efforts,
+        models: view.models,
+        sideby: view.sideby,
+        host: view.host,
+        last: view.last,
+        ...(view.model ? { model: view.model } : {}),
+        ...(view.effort ? { effort: view.effort } : {}),
+    };
+    if (model === undefined && effort === undefined) {
+        if (a.flags.has('yes'))
+            throw new UsageError('--yes needs a change: sideby model <account> <model> or --effort <level>');
+        if (wantJson)
+            json(io, shown);
+        else {
+            io.out(account.ref);
+            io.out(`  model   ${view.model ? `${view.model.value}  (${FROM[view.model.from]})` : 'the host default'}`);
+            io.out(`  effort  ${view.effort ? `${view.effort.value}  (${FROM[view.effort.from]})` : 'the host default'}`);
+            if (view.settable)
+                io.out(c.dim(`Change it: sideby model ${account.ref} <model|default> --effort <${view.efforts.join('|')}|default>`));
+            else if (view.reason)
+                io.out(c.dim(view.reason));
+        }
+        return 0;
+    }
+    const asChange = (v) => (v === undefined ? undefined : v === 'default' ? null : v);
+    const change = {
+        ...(model !== undefined ? { model: asChange(model) } : {}),
+        ...(typeof effort === 'string' ? { effort: asChange(effort) } : {}),
+    };
+    const yes = a.flags.has('yes');
+    const r = await setAccountModel(rt, account, change, { apply: yes });
+    const home = rt.paths.home;
+    const result = { ...r, file: tilde(r.file, home) };
+    if (wantJson)
+        json(io, { ...shown, change: result });
+    else if (!r.changed)
+        io.out('Nothing to change.');
+    else if (!yes)
+        io.out(`${r.diff}Run again with --yes to apply. It affects sessions started with sideby from now on.`);
+    else
+        io.out(`Saved. New sessions of ${account.ref} started with sideby use: ${r.args.join(' ') || 'the host defaults'}`);
+    return r.changed && !yes ? 10 : 0;
+}
 /** `sideby tune [account|family]`: estimated Compaction Threshold per model (spec §3.18). */
 export async function cmdTune(a, io) {
     if (a.positionals[0] === 'apply' || a.positionals[0] === 'undo')

package/dist/src/cli/json-schemas.js

@@ -6,6 +6,11 @@ const Str = Type.String();
 const Level = Type.Union([Type.Literal('ok'), Type.Literal('warn'), Type.Literal('fail')]);
 const Kind = Type.Union([Type.Literal('subscription'), Type.Literal('api')]);
 const Version = Type.Literal(1);
+const Choice = Type.Object({ model: Type.Optional(Str), effort: Type.Optional(Str) });
+const Shown = Type.Object({
+    value: Str,
+    from: Type.Union([Type.Literal('sideby'), Type.Literal('host'), Type.Literal('last')]),
+});
 const AppPlatform = Type.Union([Type.Literal('darwin'), Type.Literal('linux')]);
 const Account = Type.Object({
     family: Str,
@@ -162,6 +167,8 @@ const Usage = Type.Union([
             description: 'Tokens per local day (YYYY-MM-DD), oldest first, days without records as 0.',
         })),
         lastActivityAt: Type.Optional(Str),
+        lastModel: Type.Optional(Str),
+        lastEffort: Type.Optional(Str),
     }),
     Type.Object({ status: Type.Literal('unavailable'), reason: Str, detail: Type.Optional(Str) }),
 ]);
@@ -219,6 +226,29 @@ export const OUTPUT_SCHEMAS = {
         })),
         message: Type.Optional(Str),
     }, { title: 'sideby tune apply|undo --json' }),
+    model: Type.Object({
+        schemaVersion: Version,
+        account: Str,
+        family: Str,
+        settable: Type.Boolean({
+            description: 'Whether sideby can set the model and effort for this account.',
+        }),
+        reason: Type.Optional(Str),
+        efforts: Type.Array(Str),
+        models: Type.Array(Str, { description: 'Model names to offer; any other name may be given.' }),
+        sideby: Choice,
+        host: Choice,
+        last: Choice,
+        model: Type.Optional(Shown),
+        effort: Type.Optional(Shown),
+        change: Type.Optional(Type.Object({
+            changed: Type.Boolean(),
+            applied: Type.Boolean(),
+            file: Str,
+            diff: Str,
+            args: Type.Array(Str, { description: 'The account arguments in the config after the change.' }),
+        })),
+    }, { title: 'sideby model --json' }),
     tune: Type.Object({
         schemaVersion: Version,
         accounts: Type.Array(Type.Object({ ref: Str, family: Str, tuning: Tuning })),

package/dist/src/cli/main.js

@@ -32,6 +32,8 @@ Usage:
   sideby quota teardown claude        undo it, restoring the original file
   sideby tune [account|family]        estimate the cheapest auto-compact threshold per model
                                       from your last 7 days of sessions (read-only)
+  sideby model <account> [<model>|default] [--effort <level>|default] [--yes]
+                                      show or set the model and effort sideby starts this account with
   sideby handoff status               what Auto Handoff still needs on this machine
   sideby handoff enable [--yes]       turn it on (shows the config change first); --same-family,
                                       --order claude=codex001,cc002, --threshold n, --prepare-at n
@@ -154,6 +156,7 @@ const COMMANDS = {
     doctor: { flags: ['fix', 'force', 'json'] },
     quota: { flags: ['json', 'yes'] },
     tune: { flags: ['json', 'yes'] },
+    model: { flags: ['json', 'yes'], valued: ['effort'] },
     handoff: {
         flags: ['json', 'yes', 'same-family', 'no-same-family'],
         valued: ['brief', 'order', 'prepare-at', 'threshold', 'wait-minutes', 'countdown'],
@@ -255,6 +258,8 @@ export async function main(argv) {
                 return await cmds.cmdQuota(parsed, io);
             case 'tune':
                 return await cmds.cmdTune(parsed, io);
+            case 'model':
+                return await cmds.cmdModel(parsed, io);
             case 'handoff':
                 return await cmds.cmdHandoff(parsed, io);
             case 'ui':

package/dist/src/core/config.d.ts

@@ -85,6 +85,20 @@ export declare function editConfigHandoff(file: string, edit: (current: HandoffC
     before: HandoffConfig | undefined;
     after: HandoffConfig | undefined;
 }>;
+export type AccountsConfig = NonNullable<Config['accounts']>;
+/**
+ * `sideby model` (spec §3.19): changes the config `accounts` key with `edit` (see `editConfigKey` for how the file is
+ * written). With `dryRun`, shows the change without writing.
+ */
+export declare function editConfigAccounts(file: string, 
+/** Returns null to leave the file as it is. */
+edit: (current: AccountsConfig) => AccountsConfig | null, opts?: {
+    dryRun?: boolean;
+}): Promise<{
+    changed: boolean;
+    before: AccountsConfig | undefined;
+    after: AccountsConfig | undefined;
+}>;
 /**
  * Adds `alias → ref` to the config file's `aliases`, as `{ account, args }` when `args` is not empty (see
  * `editConfigAliases` for how the file is written). Refuses an invalid alias, or one that already starts another

package/dist/src/core/config.js

@@ -224,6 +224,15 @@ async function editConfigAliases(file, retry, edit) {
 export function editConfigHandoff(file, edit, opts = {}) {
     return editConfigKey(file, 'handoff', 'run the command', (current) => edit(current ?? {}), opts);
 }
+/**
+ * `sideby model` (spec §3.19): changes the config `accounts` key with `edit` (see `editConfigKey` for how the file is
+ * written). With `dryRun`, shows the change without writing.
+ */
+export function editConfigAccounts(file, 
+/** Returns null to leave the file as it is. */
+edit, opts = {}) {
+    return editConfigKey(file, 'accounts', 'run the command', (current) => edit(current ?? {}), opts);
+}
 /**
  * Adds `alias → ref` to the config file's `aliases`, as `{ account, args }` when `args` is not empty (see
  * `editConfigAliases` for how the file is written). Refuses an invalid alias, or one that already starts another

package/dist/src/core/model-choice.d.ts

@@ -0,0 +1,41 @@
+import type { Runtime } from '../runtime.ts';
+import type { Account, ModelChoice } from '../types.ts';
+/** Where a shown value comes from: sideby's own argument, the Host's config, or the last session. */
+export type ChoiceSource = 'sideby' | 'host' | 'last';
+export interface AccountModel {
+    ref: string;
+    family: string;
+    /** Whether sideby can set it for this Account; when not, `reason` says why. */
+    settable: boolean;
+    reason?: string;
+    efforts: string[];
+    models: string[];
+    sideby: ModelChoice;
+    host: ModelChoice;
+    last: ModelChoice;
+    model?: {
+        value: string;
+        from: ChoiceSource;
+    };
+    effort?: {
+        value: string;
+        from: ChoiceSource;
+    };
+}
+/** `last` is the model and effort of the newest session, from the usage reader when the caller already has it. */
+export declare function accountModel(rt: Runtime, account: Account, last?: ModelChoice): Promise<AccountModel>;
+/** A change: `undefined` keeps what sideby sets now, `null` goes back to the Host's default. */
+export interface ModelChange {
+    model?: string | null;
+    effort?: string | null;
+}
+/** Shows, or with `apply` writes, the change to the Account's model and effort arguments. */
+export declare function setAccountModel(rt: Runtime, account: Account, change: ModelChange, opts: {
+    apply: boolean;
+}): Promise<{
+    changed: boolean;
+    applied: boolean;
+    file: string;
+    diff: string;
+    args: string[];
+}>;

package/dist/src/core/model-choice.js

@@ -0,0 +1,128 @@
+// Model and effort per Account (spec §3.19, ADR-0014): what an Account starts with, and the one change sideby makes,
+// to the model and effort arguments in the config's `accounts.<ref>.args`. No Host file is written.
+import { join } from 'node:path';
+import { MODEL_NAME } from '../families/shared/model-args.js';
+import { editConfigAccounts } from './config.js';
+import { UserError } from './errors.js';
+import { lineDiff } from './handoff-status.js';
+function pick(key, sideby, host, last) {
+    if (sideby[key])
+        return { value: sideby[key], from: 'sideby' };
+    if (host[key])
+        return { value: host[key], from: 'host' };
+    if (last[key])
+        return { value: last[key], from: 'last' };
+    return undefined;
+}
+/** `last` is the model and effort of the newest session, from the usage reader when the caller already has it. */
+export async function accountModel(rt, account, last) {
+    const f = rt.families.get(account.family);
+    const mc = f?.modelChoice;
+    const base = {
+        ref: account.ref,
+        family: account.family,
+        efforts: [],
+        models: [],
+        sideby: {},
+        host: {},
+        last: {},
+    };
+    if (!mc)
+        return { ...base, settable: false, reason: `${f?.title ?? account.family} has no model choice in sideby` };
+    let seen = last;
+    if (!seen) {
+        const u = await rt.usage(account).catch(() => null);
+        seen =
+            u?.status === 'ok'
+                ? {
+                    ...(u.lastModel ? { model: u.lastModel } : {}),
+                    ...(u.lastEffort ? { effort: u.lastEffort } : {}),
+                }
+                : {};
+    }
+    const sideby = mc.fromArgs(rt.config.accounts?.[account.ref]?.args ?? []).choice;
+    // An API account's model is the one its proxy.env names (the Family's `model` reader); the effort still comes from settings.
+    const apiModel = account.kind === 'api' ? await f.model?.(account).catch(() => undefined) : undefined;
+    const configured = await mc.configured(account, sideby.model ?? apiModel, seen.model);
+    const host = apiModel ? { ...configured, model: apiModel } : configured;
+    const models = [...new Set([...mc.models, ...(seen.model ? [seen.model] : [])])];
+    const out = {
+        ...base,
+        settable: account.kind !== 'api',
+        efforts: [...mc.efforts],
+        models,
+        sideby,
+        host,
+        last: seen,
+    };
+    if (account.kind === 'api')
+        out.reason = 'an API account takes its model from proxy.env';
+    const m = pick('model', sideby, host, seen);
+    const e = pick('effort', sideby, host, seen);
+    if (m)
+        out.model = m;
+    if (e)
+        out.effort = e;
+    return out;
+}
+const pretty = (v) => JSON.stringify(v ?? {}, null, 2);
+/** Shows, or with `apply` writes, the change to the Account's model and effort arguments. */
+export async function setAccountModel(rt, account, change, opts) {
+    const f = rt.families.get(account.family);
+    const mc = f?.modelChoice;
+    if (!mc)
+        throw new UserError(`${f?.title ?? account.family} has no model choice in sideby`, {
+            code: 'unsupported',
+        });
+    if (account.kind === 'api')
+        throw new UserError(`${account.ref} is an API account: its model comes from proxy.env, so set it there`, {
+            code: 'api-account',
+        });
+    if (typeof change.model === 'string' && !MODEL_NAME.test(change.model))
+        throw new UserError(`"${change.model}" is not a model name sideby passes on: use letters, digits and . _ : / [ ] - only, for example ${mc.models[0] ?? 'gpt-5'}`, { code: 'bad-value' });
+    if (typeof change.effort === 'string' && !mc.efforts.includes(change.effort))
+        throw new UserError(`"${change.effort}" is not an effort level for ${f.title}; use one of: ${mc.efforts.join(', ')}, default`, {
+            code: 'bad-value',
+        });
+    let args = [];
+    const r = await editConfigAccounts(rt.paths.configFile, (current) => {
+        const now = current[account.ref]?.args ?? [];
+        const unchanged = (list) => list.length === now.length && list.every((x, i) => x === now[i]);
+        const { choice, rest } = mc.fromArgs(now);
+        const next = { ...choice };
+        for (const k of ['model', 'effort']) {
+            if (change[k] === null)
+                delete next[k];
+            else if (change[k] !== undefined)
+                next[k] = change[k];
+        }
+        // After a `--` everything is prompt text, so the choice goes in front of it.
+        const dd = rest.indexOf('--');
+        const add = mc.toArgs(next);
+        args = dd < 0 ? [...rest, ...add] : [...rest.slice(0, dd), ...add, ...rest.slice(dd)];
+        // Nothing to write, not even an empty `accounts` key in a config that has none.
+        if (unchanged(args))
+            return null;
+        const out = { ...current };
+        if (args.length)
+            out[account.ref] = { ...current[account.ref], args };
+        else {
+            const { args: _gone, ...others } = current[account.ref] ?? {};
+            if (Object.keys(others).length)
+                out[account.ref] = others;
+            else
+                delete out[account.ref];
+        }
+        return out;
+    }, { dryRun: !opts.apply });
+    const file = rt.paths.configFile;
+    return {
+        changed: r.changed,
+        applied: r.changed && opts.apply,
+        file,
+        diff: r.changed
+            ? `--- ${join('sideby', 'config.json')} (accounts)\n${lineDiff(pretty(r.before), pretty(r.after))}\n`
+            : '',
+        args,
+    };
+}

package/dist/src/families/claude/index.js

@@ -8,6 +8,7 @@ import { BUILTIN_LOGOS } from '../logos.js';
 import { dirWrittenAt, groupedEntryWrittenAt, resumeFlagSession, withoutResumeFlag, } from '../shared/sessions.js';
 import { claudeHandoff } from './handoff.js';
 import { CLAUDE_LAYOUT } from './layout.js';
+import { claudeModelChoice } from './model.js';
 import { readClaudeQuota } from './quota.js';
 import { readClaudeTuning } from './tuning.js';
 import { readClaudeUsage } from './usage.js';
@@ -114,6 +115,7 @@ export const claudeFamily = {
     },
     loginState,
     model,
+    modelChoice: claudeModelChoice,
     identity: claudeIdentity,
     readQuota: readClaudeQuota,
     readUsage: readClaudeUsage,

package/dist/src/families/claude/model.d.ts

@@ -0,0 +1,2 @@
+import type { FamilyModelChoice } from '../../types.ts';
+export declare const claudeModelChoice: FamilyModelChoice;

package/dist/src/families/claude/model.js

@@ -0,0 +1,42 @@
+// The model and effort a Claude Code Account starts with (spec §3.19, ADR-0014). Reads only `model`,
+// `effortLevel` and `modelSettings.<model>.effortLevel` of the Account's `settings.json`.
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { takeFlag } from '../shared/model-args.js';
+const MAX_BYTES = 1_000_000;
+const str = (v) => (typeof v === 'string' && v ? v : undefined);
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+async function configured(account, model, lastModel) {
+    try {
+        const file = join(account.dir, 'settings.json');
+        const st = await stat(file);
+        if (!st.isFile() || st.size > MAX_BYTES)
+            return {};
+        const s = JSON.parse(await readFile(file, 'utf8'));
+        if (!isObj(s))
+            return {};
+        const m = str(s.model);
+        const ms = isObj(s.modelSettings) ? s.modelSettings : {};
+        const per = (name) => name && isObj(ms[name]) ? str(ms[name].effortLevel) : undefined;
+        // The level saved for the model the session will run: the one passed in, else the file's own, else the last one used.
+        const effort = per(model ?? m ?? lastModel) ?? str(s.effortLevel);
+        return { ...(m ? { model: m } : {}), ...(effort ? { effort } : {}) };
+    }
+    catch {
+        return {};
+    }
+}
+export const claudeModelChoice = {
+    efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+    models: ['fable', 'opus', 'sonnet', 'haiku'],
+    configured,
+    toArgs: (c) => [...(c.model ? ['--model', c.model] : []), ...(c.effort ? ['--effort', c.effort] : [])],
+    fromArgs(args) {
+        const m = takeFlag(args, ['--model']);
+        const e = takeFlag(m.rest, ['--effort']);
+        return {
+            choice: { ...(m.value ? { model: m.value } : {}), ...(e.value ? { effort: e.value } : {}) },
+            rest: e.rest,
+        };
+    },
+};

package/dist/src/families/claude/usage.d.ts

@@ -7,6 +7,8 @@ interface Entry {
     output: number;
     cacheRead: number;
     cacheWrite: number;
+    model?: string;
+    effort?: string;
 }
 export declare function listJsonl(dir: string, out?: string[]): Promise<string[]>;
 /** What one session log holds: its usage rows in file order, keyed for the "last line wins" dedupe. */

package/dist/src/families/claude/usage.js

@@ -64,6 +64,13 @@ async function parseFile(file) {
                     output: count(usage.output_tokens),
                     cacheRead: count(usage.cache_read_input_tokens),
                     cacheWrite: count(usage.cache_creation_input_tokens),
+                    // Claude Code logs a placeholder model for some local rows; it is not a model anyone chose.
+                    ...(typeof row.message?.model === 'string' &&
+                        row.message.model &&
+                        row.message.model !== '<synthetic>'
+                        ? { model: row.message.model }
+                        : {}),
+                    ...(typeof row.effort === 'string' && row.effort ? { effort: row.effort } : {}),
                 },
             ]);
         }
@@ -75,7 +82,7 @@ async function parseFile(file) {
     return out;
 }
 /** Parsed session logs per Account directory; a file is parsed again only after it changed. */
-export const claudeUsageMemo = new FileMemo({ name: 'claude-usage', version: 1 });
+export const claudeUsageMemo = new FileMemo({ name: 'claude-usage', version: 2 });
 export async function readClaudeUsage(account, ctx) {
     const files = await listJsonl(join(account.dir, 'projects'));
     if (!files.length)
@@ -113,6 +120,7 @@ export async function readClaudeUsage(account, ctx) {
     const sessions = new Set();
     const days = dailyBuckets(ctx.now);
     let last = Number.NEGATIVE_INFINITY;
+    let lastTurn;
     let inputTokens = 0;
     let outputTokens = 0;
     let cacheReadTokens = 0;
@@ -122,6 +130,8 @@ export async function readClaudeUsage(account, ctx) {
             continue;
         if (e.timestamp > last)
             last = e.timestamp;
+        if (e.model && (!lastTurn || e.timestamp >= lastTurn.timestamp))
+            lastTurn = e;
         if (e.timestamp < since)
             continue;
         sessions.add(e.session);
@@ -142,5 +152,7 @@ export async function readClaudeUsage(account, ctx) {
         totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens,
         daily: days.daily,
         ...(Number.isFinite(last) ? { lastActivityAt: new Date(last).toISOString() } : {}),
+        ...(lastTurn?.model ? { lastModel: lastTurn.model } : {}),
+        ...(lastTurn?.effort ? { lastEffort: lastTurn.effort } : {}),
     };
 }

package/dist/src/families/codex/index.js

@@ -5,6 +5,7 @@ import { BUILTIN_LOGOS } from '../logos.js';
 import { nestedFileWrittenAt, resumeSubcommandSession } from '../shared/sessions.js';
 import { topLevelTomlString } from '../shared/toml.js';
 import { codexHandoff } from './handoff.js';
+import { codexModelChoice } from './model.js';
 import { readCodexQuota, readCodexUsage } from './rollout.js';
 import { readCodexTuning } from './tuning.js';
 const FILE_STORE_KEY = 'cli_auth_credentials_store';
@@ -60,6 +61,7 @@ export const codexFamily = {
         }
     },
     model: readModel,
+    modelChoice: codexModelChoice,
     identity: codexIdentity,
     readQuota: (account) => readCodexQuota(account.dir),
     readUsage: (account, ctx) => readCodexUsage(account.dir, ctx.now),

package/dist/src/families/codex/model.d.ts

@@ -0,0 +1,2 @@
+import type { FamilyModelChoice } from '../../types.ts';
+export declare const codexModelChoice: FamilyModelChoice;

package/dist/src/families/codex/model.js

@@ -0,0 +1,59 @@
+// The model and effort a Codex Account starts with (spec §3.19, ADR-0014). Reads only the top-level `model` and
+// `model_reasoning_effort` of the Account's `config.toml`.
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { takeFlag } from '../shared/model-args.js';
+import { topLevelTomlString } from '../shared/toml.js';
+const EFFORT_KEY = 'model_reasoning_effort';
+async function configured(account) {
+    try {
+        const text = await readFile(join(account.dir, 'config.toml'), 'utf8');
+        const model = topLevelTomlString(text, 'model');
+        const effort = topLevelTomlString(text, EFFORT_KEY);
+        return { ...(model ? { model } : {}), ...(effort ? { effort } : {}) };
+    }
+    catch {
+        return {};
+    }
+}
+/** `-c model_reasoning_effort=…` is one of possibly many `-c` overrides: only that one is taken out. */
+function takeEffort(args) {
+    const rest = [];
+    let value;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--') {
+            rest.push(...args.slice(i));
+            break;
+        }
+        const inline = a.startsWith('--config=') ? a.slice('--config='.length) : null;
+        const next = (a === '-c' || a === '--config') && i + 1 < args.length ? args[i + 1] : null;
+        const kv = inline ?? next;
+        if (kv?.startsWith(`${EFFORT_KEY}=`)) {
+            value = kv.slice(EFFORT_KEY.length + 1).replace(/^(["'])(.*)\1$/, '$2');
+            if (next !== null)
+                i++;
+            continue;
+        }
+        rest.push(a);
+    }
+    return value === undefined ? { rest } : { value, rest };
+}
+export const codexModelChoice = {
+    // Codex: "Available levels depend on the model and client"; these are the levels its docs name.
+    efforts: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+    models: [],
+    configured,
+    toArgs: (c) => [
+        ...(c.model ? ['-m', c.model] : []),
+        ...(c.effort ? ['-c', `${EFFORT_KEY}="${c.effort}"`] : []),
+    ],
+    fromArgs(args) {
+        const m = takeFlag(args, ['-m', '--model']);
+        const e = takeEffort(m.rest);
+        return {
+            choice: { ...(m.value ? { model: m.value } : {}), ...(e.value ? { effort: e.value } : {}) },
+            rest: e.rest,
+        };
+    },
+};

package/dist/src/families/codex/rollout.d.ts

@@ -54,6 +54,11 @@ interface FileUsage {
         turn: Totals | null;
     }[];
     deltas: Totals[];
+    context: {
+        at: number;
+        model?: string;
+        effort?: string;
+    } | null;
     failed: boolean;
 }
 /** Parsed token totals per Account directory; a rollout is read again only after it changed. */