sideby 0.4.3 → 0.6.0

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/quota-cache.d.ts

@@ -12,6 +12,13 @@ export declare function cacheStateDir(env: Env): string;
 export declare function accountNameFromEnv(env: Env): string | null;
 /** Extracts the 5h and 7d windows from status line JSON; null when there is nothing usable. */
 export declare function parseRateLimits(input: string, observedAt: Date): ClaudeQuotaCache | null;
+/**
+ * Merges a status line reading into the cached windows. Each session reports the Quota of its own last request, so an
+ * idle session of the same Account reports older numbers, sometimes of a window that has already reset: within one
+ * window the higher use wins, otherwise the later reset; a window the reading lacks is kept. Null when the reading
+ * only repeats older numbers, so nothing is written and `observedAt` keeps the time of the newer reading.
+ */
+export declare function mergeQuotaCache(cached: readonly QuotaWindow[], next: ClaudeQuotaCache): ClaudeQuotaCache | null;
 /** Writes the cache atomically; creates the private parent directory first (writeFileAtomic does not). */
 export declare function writeQuotaCache(stateDir: string, name: string, cache: ClaudeQuotaCache): Promise<void>;
 export type CacheRead = {

package/dist/src/families/claude/quota-cache.js

@@ -64,6 +64,46 @@ export function parseRateLimits(input, observedAt) {
     }
     return windows.length ? { version: 1, observedAt: observedAt.toISOString(), windows } : null;
 }
+/** Two readings belong to one window when their resets are less than a quarter of the window apart. */
+function sameWindow(a, b) {
+    return Math.abs(Date.parse(a.resetsAt) - Date.parse(b.resetsAt)) < (a.windowMinutes * 60_000) / 4;
+}
+const sameReading = (a, b) => a.label === b.label &&
+    a.windowMinutes === b.windowMinutes &&
+    a.usedPercent === b.usedPercent &&
+    a.resetsAt === b.resetsAt;
+const order = (label) => {
+    const i = WINDOWS.findIndex((w) => w.label === label);
+    return i < 0 ? WINDOWS.length : i;
+};
+/**
+ * Merges a status line reading into the cached windows. Each session reports the Quota of its own last request, so an
+ * idle session of the same Account reports older numbers, sometimes of a window that has already reset: within one
+ * window the higher use wins, otherwise the later reset; a window the reading lacks is kept. Null when the reading
+ * only repeats older numbers, so nothing is written and `observedAt` keeps the time of the newer reading.
+ */
+export function mergeQuotaCache(cached, next) {
+    let older = false;
+    const windows = next.windows.map((w) => {
+        const c = cached.find((x) => x.label === w.label);
+        if (!c)
+            return w;
+        const keep = sameWindow(c, w)
+            ? c.usedPercent > w.usedPercent
+            : Date.parse(c.resetsAt) > Date.parse(w.resetsAt);
+        if (keep)
+            older = true;
+        return keep ? c : w;
+    });
+    for (const c of cached)
+        if (!windows.some((w) => w.label === c.label))
+            windows.push(c);
+    windows.sort((a, b) => order(a.label) - order(b.label));
+    const unchanged = windows.length === cached.length && windows.every((w) => cached.some((c) => sameReading(c, w)));
+    if (older && unchanged)
+        return null;
+    return { ...next, windows };
+}
 /** Writes the cache atomically; creates the private parent directory first (writeFileAtomic does not). */
 export async function writeQuotaCache(stateDir, name, cache) {
     const file = claudeQuotaCacheFile(stateDir, name);

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. */

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

@@ -174,6 +174,42 @@ export function fileTokens(events) {
         return null;
     return fileDeltas(events).reduce(plus, ZERO);
 }
+/** The newest `turn_context` of a rollout: the model and effort its last turn ran with. */
+async function lastContext(file, read) {
+    const lines = createInterface({ input: createReadStream(file), crlfDelay: Number.POSITIVE_INFINITY });
+    let best = null;
+    try {
+        for await (const line of lines) {
+            if (!line.includes('turn_context'))
+                continue;
+            let o;
+            try {
+                o = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isObj(o) || o.type !== 'turn_context' || !isObj(o.payload))
+                continue;
+            const at = typeof o.timestamp === 'string' ? Date.parse(o.timestamp) : Number.NaN;
+            if (!Number.isFinite(at) || (best && at < best.at))
+                continue;
+            const { model, effort } = o.payload;
+            best = {
+                at,
+                ...(typeof model === 'string' && model ? { model } : {}),
+                ...(typeof effort === 'string' && effort ? { effort } : {}),
+            };
+        }
+    }
+    catch {
+        read.failed = true;
+    }
+    finally {
+        lines.close();
+    }
+    return best;
+}
 async function fileUsage(file) {
     const read = { failed: false };
     const times = [];
@@ -184,10 +220,11 @@ async function fileUsage(file) {
         if (t)
             events.push({ at, ...t });
     }
-    return { times, events, deltas: fileDeltas(events), failed: read.failed };
+    const context = await lastContext(file, read);
+    return { times, events, deltas: fileDeltas(events), context, failed: read.failed };
 }
 /** Parsed token totals per Account directory; a rollout is read again only after it changed. */
-export const codexUsageMemo = new FileMemo({ name: 'codex-usage', version: 1 });
+export const codexUsageMemo = new FileMemo({ name: 'codex-usage', version: 2 });
 /**
  * Token totals for events in the last `days` x 24 h, from rollout files modified in that window (mtime only
  * picks which files to read). Each event counts its fileDeltas increment, so a long session resumed today
@@ -207,13 +244,16 @@ export async function readCodexUsage(dir, now, days = USAGE_DAYS) {
     let sawTokenCount = false;
     let sawTotals = false;
     let last = Number.NEGATIVE_INFINITY;
+    let lastContextSeen = null;
     const daily = dailyBuckets(now, days);
     const sum = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
     const memo = codexUsageMemo.pass(dir);
     for (const f of files) {
-        const { times, events, deltas } = await memo.get(f.path, f.stats, () => fileUsage(f.path), (v) => !v.failed);
+        const { times, events, deltas, context } = await memo.get(f.path, f.stats, () => fileUsage(f.path), (v) => !v.failed);
         if (times.length)
             sawTokenCount = true;
+        if (context?.model && context.at <= end && (!lastContextSeen || context.at >= lastContextSeen.at))
+            lastContextSeen = context;
         for (const at of times)
             if (at <= end && at > last)
                 last = at;
@@ -250,5 +290,7 @@ export async function readCodexUsage(dir, now, days = USAGE_DAYS) {
         totalTokens: sum.inputTokens + sum.outputTokens + sum.cacheReadTokens + sum.cacheWriteTokens,
         daily: daily.daily,
         ...(Number.isFinite(last) ? { lastActivityAt: new Date(last).toISOString() } : {}),
+        ...(lastContextSeen?.model ? { lastModel: lastContextSeen.model } : {}),
+        ...(lastContextSeen?.effort ? { lastEffort: lastContextSeen.effort } : {}),
     };
 }

package/dist/src/families/grok/handoff.js

@@ -191,7 +191,7 @@ export const grokHookSetup = {
         await rmdir(join(ctx.home, '.grok', 'hooks')).catch(() => { });
         return {
             ok: true,
-            message: `removed ${shown}; run \`sideby doctor grok --fix\` to remove the copies in other Grok accounts`,
+            message: `removed ${shown}; the copies in other Grok accounts (hooks/sideby-handoff.json) stay and do nothing outside a sideby hand-over; delete them yourself if you no longer want them`,
         };
     },
 };

package/dist/src/families/shared/model-args.d.ts

@@ -0,0 +1,7 @@
+/** Takes every occurrence of the flags in `names` out of `args`; the last value wins. */
+export declare function takeFlag(args: readonly string[], names: readonly string[]): {
+    value?: string;
+    rest: string[];
+};
+/** A model name sideby passes on: letters, digits and `._:/[]-` (for example `claude-opus-5-5[1m]`). */
+export declare const MODEL_NAME: RegExp;

package/dist/src/families/shared/model-args.js

@@ -0,0 +1,28 @@
+// Reading and writing a model or effort choice as Host arguments (spec §3.19): the value of `--name v`, `--name=v`
+// or `-x v`, wherever it is. Built-in Families use it for `modelChoice`.
+/** Takes every occurrence of the flags in `names` out of `args`; the last value wins. */
+export function takeFlag(args, names) {
+    const rest = [];
+    let value;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        // Past `--` everything is the Host's prompt text, not an option.
+        if (a === '--') {
+            rest.push(...args.slice(i));
+            break;
+        }
+        const eq = names.find((n) => n.startsWith('--') && a.startsWith(`${n}=`));
+        if (eq) {
+            value = a.slice(eq.length + 1);
+            continue;
+        }
+        if (names.includes(a) && i + 1 < args.length) {
+            value = args[++i];
+            continue;
+        }
+        rest.push(a);
+    }
+    return value === undefined ? { rest } : { value, rest };
+}
+/** A model name sideby passes on: letters, digits and `._:/[]-` (for example `claude-opus-5-5[1m]`). */
+export const MODEL_NAME = /^[A-Za-z0-9._:/[\]-]{1,100}$/;

package/dist/src/handoff/messages.js

@@ -9,7 +9,7 @@ const TEMPLATE = [
 ].join('; ');
 const RULES = 'Reference specs, ADRs, commits and diffs by path instead of repeating them, list the skills the next agent should use, and never include keys, passwords or personal data.';
 export function prepareMessage(brief, pressure) {
-    return `sideby: this account's quota is at ${Math.round(pressure)}%, so another account may take over soon. Write a handoff brief to ${brief} now (${TEMPLATE}). ${RULES} Keep it current after each step, then go on with the task.`;
+    return `sideby: this account's quota is at ${Math.round(pressure)}%. Write a handoff brief to ${brief} now (${TEMPLATE}). ${RULES} Keep it current after each step, then go on with the task. Do not tell the user that the work will move to another account: sideby decides that and tells them itself.`;
 }
 export function thresholdMessage(brief, pressure) {
     return `sideby: this account's quota is at ${Math.round(pressure)}%. Finish the current step, update the handoff brief at ${brief} (${TEMPLATE}; ${RULES}), then end your turn. sideby will start the next account from that brief.`;

package/dist/src/panel/handler.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { type HandoffSettings } from '../core/config.ts';
+import { type AccountModel } from '../core/model-choice.ts';
 import type { AccountStatus, DoctorHistory, FamilyInfo, Runtime } from '../runtime.ts';
 import type { Account, FamilyLogo, QuotaResult, QuotaSetupPlan, UsageResult } from '../types.ts';
 import { type PanelTheme } from './theme.ts';
@@ -47,6 +48,8 @@ export type PanelAccount = (AccountStatus | (Account & Partial<AccountStatus>))
     aliases?: string[];
     /** Host arguments of those aliases that add any (alias → arguments); absent when none do. */
     aliasArgs?: Record<string, string[]>;
+    /** The model and effort it starts with and where each comes from (spec §3.19); absent for Families without a choice. */
+    modelInfo?: Omit<AccountModel, 'ref' | 'family'>;
 };
 export type { DoctorHistory };
 /** Counts of failing and warning Findings per checked Account, from the Doctor history. */

package/dist/src/panel/handler.js

@@ -4,7 +4,10 @@ import { aliasesByAccount } from '../core/accounts.js';
 import { aliasArgs, aliasRefs } from '../core/config.js';
 import { UserError } from '../core/errors.js';
 import { planHandoff } from '../core/handoff.js';
+import { applyHandoffEnable, planHandoffEnable } from '../core/handoff-enable.js';
+import { handoffOverview } from '../core/handoff-overview.js';
 import { configureHandoff, handoffStatus } from '../core/handoff-status.js';
+import { accountModel, setAccountModel } from '../core/model-choice.js';
 import { tildify } from '../core/paths.js';
 import { MIN_CALLS } from '../core/tuning.js';
 import { buildId, packageVersion } from '../core/version.js';
@@ -168,8 +171,23 @@ async function accountState(rt, account, families) {
         login: 'unknown',
     };
     errors.push(...(status?.problems ?? []));
+    let modelInfo;
+    if (rt.families.get(account.family)?.modelChoice) {
+        const last = usage?.status === 'ok'
+            ? {
+                ...(usage.lastModel ? { model: usage.lastModel } : {}),
+                ...(usage.lastEffort ? { effort: usage.lastEffort } : {}),
+            }
+            : {};
+        const info = await guard(accountModel(rt, account, last));
+        if (info) {
+            const { ref: _r, family: _f, ...rest } = info;
+            modelInfo = rest;
+        }
+    }
     return {
         ...base,
+        ...(modelInfo ? { modelInfo } : {}),
         ...(quota ? { quota } : {}),
         ...(usage ? { usage } : {}),
         ...(errors.length ? { error: errors.join('; ') } : {}),
@@ -393,6 +411,57 @@ export function createPanelHandler(opts) {
                 return { ...r, file: tildify(r.file, rt.paths.home) };
             },
         },
+        // Model and effort per Account (spec §3.19, ADR-0014): without `confirm` only the config diff.
+        // `model` / `effort`: left out keeps it, null goes back to the Host's default, a string sets it.
+        '/api/account/model': {
+            writes: (body) => body.confirm === true,
+            async run(body) {
+                const account = optString(body, 'account');
+                if (!account)
+                    throw new HttpError(400, '"account" is required');
+                const change = {};
+                for (const k of ['model', 'effort']) {
+                    const v = body[k];
+                    if (v === undefined)
+                        continue;
+                    if (v !== null && typeof v !== 'string')
+                        throw new HttpError(400, `"${k}" must be a string, or null for the default`);
+                    change[k] = v;
+                }
+                const rt = await getRuntime();
+                const found = await rt.resolve(account);
+                const r = await setAccountModel(rt, found, change, { apply: optBool(body, 'confirm') });
+                return { ref: found.ref, ...r, file: tildify(r.file, rt.paths.home) };
+            },
+        },
+        // The Auto Handoff page (spec §3.17): where work would go next and the last hand-overs. Reads only.
+        '/api/handoff/overview': {
+            writes: () => false,
+            async run() {
+                return handoffOverview(await getRuntime());
+            },
+        },
+        // Turning it on in one step (ADR-0013): without `confirm` only the plan; with it, every step in order.
+        '/api/handoff/enable': {
+            writes: (body) => body.confirm === true,
+            async run(body) {
+                // Left out keeps the current setting; true or false sets it.
+                const sameFamily = body.sameFamily === undefined ? undefined : optBool(body, 'sameFamily');
+                const rt = await getRuntime();
+                const home = rt.paths.home;
+                const show = (p) => ({
+                    ...p,
+                    steps: p.steps.map((s) => (s.file ? { ...s, file: tildify(s.file, home) } : s)),
+                });
+                const opts = sameFamily === undefined ? {} : { sameFamily };
+                if (!optBool(body, 'confirm'))
+                    return show(await planHandoffEnable(rt, opts));
+                // `expect`: the key of the plan the person saw; a different plan now is shown again, not applied.
+                const expect = optString(body, 'expect');
+                const r = await applyHandoffEnable(rt, expect === undefined ? opts : { ...opts, expect });
+                return { ...r, plan: show(r.plan) };
+            },
+        },
         // Undo for the setup above; the Runtime turns a teardown that throws into `{ ok: false, message }`.
         '/api/quota/teardown': {
             async run(body) {