sideby 0.2.2 → 0.4.0

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

@@ -0,0 +1,115 @@
+// How Claude Code takes part in a Handoff (spec §3.17): hooks through `--settings`, which merges with the
+// Account's own settings hooks (verified 2026-10-09), and the Brief's directory through `--add-dir`.
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { writeFileAtomic } from '../../core/fs-safe.js';
+import { carryArgs, hasOption, promptAfterDashes } from '../shared/handoff-args.js';
+import { claudeBrief } from './brief.js';
+/** From `claude --help`: options that take a value, so it is never mistaken for the old prompt. */
+export const CLAUDE_ARGS = {
+    valued: [
+        '--agent',
+        '--agents',
+        '--append-system-prompt',
+        '--append-system-prompt-file',
+        '--autocompact',
+        '--debug-file',
+        '--effort',
+        '--environment',
+        '--fallback-model',
+        '--input-format',
+        '--json-schema',
+        '--max-budget-usd',
+        '--model',
+        '-n',
+        '--name',
+        '--output-format',
+        '--permission-mode',
+        '--permission-prompts',
+        '--plugin-dir',
+        '--plugin-url',
+        '--remote-control-session-name-prefix',
+        '--session-id',
+        '--setting-sources',
+        '--settings',
+        '--system-prompt',
+        '--system-prompt-file',
+        '--system-prompt-snapshot',
+    ],
+    variadic: [
+        '--add-dir',
+        '--allowedTools',
+        '--allowed-tools',
+        '--betas',
+        '--disallowedTools',
+        '--disallowed-tools',
+        '--file',
+        '--mcp-config',
+        '--tools',
+    ],
+    optional: [
+        '--cloud',
+        '-d',
+        '--debug',
+        '--from-pr',
+        '--prompt-suggestions',
+        '--remote-control',
+        '-r',
+        '--resume',
+        '--teleport',
+        '-w',
+        '--worktree',
+    ],
+    drop: [
+        '-r',
+        '--resume',
+        '-c',
+        '--continue',
+        '--fork-session',
+        '--session-id',
+        '--from-pr',
+        '--teleport',
+        '-n',
+        '--name',
+        '-p',
+        '--print',
+    ],
+};
+export const claudeHandoff = {
+    starts: ['quota', 'limit'],
+    async hookArgs(command, stateDir) {
+        const dir = join(stateDir, 'handoff');
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        const hook = (event) => [
+            { hooks: [{ type: 'command', command: command(event) }] },
+        ];
+        const settings = {
+            hooks: {
+                PostToolUse: hook('PostToolUse'),
+                Stop: hook('Stop'),
+                StopFailure: [
+                    { matcher: 'rate_limit', hooks: [{ type: 'command', command: command('StopFailure') }] },
+                ],
+            },
+        };
+        const file = join(dir, 'claude-settings.json');
+        await writeFileAtomic(file, `${JSON.stringify(settings, null, 2)}\n`, 0o600);
+        return ['--settings', file];
+    },
+    dirArgs: (dir) => ['--add-dir', dir],
+    promptArgs: promptAfterDashes,
+    continueArgs: (args) => carryArgs(args, CLAUDE_ARGS),
+    resumeArgs: (id) => ['--resume', id],
+    async eligibility(args) {
+        if (hasOption(args, ['-p', '--print']))
+            return { start: false, receive: false, reason: 'a headless run (`-p`) has nobody to hand over to' };
+        if (hasOption(args, ['--settings']))
+            return {
+                start: false,
+                receive: true,
+                reason: '`--settings` is already given, so sideby cannot add its hooks',
+            };
+        return { start: true, receive: true };
+    },
+    briefFromSession: claudeBrief,
+};

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

@@ -5,9 +5,11 @@ import { identityFromJsonFile, identityOf } from '../../core/identity.js';
 import { readSecretFile } from '../../core/secret-file.js';
 import { claudeStatusline } from '../../quota/claude-statusline.js';
 import { BUILTIN_LOGOS } from '../logos.js';
-import { groupedEntryWrittenAt, resumeFlagSession } from '../shared/sessions.js';
+import { dirWrittenAt, groupedEntryWrittenAt, resumeFlagSession, withoutResumeFlag, } from '../shared/sessions.js';
+import { claudeHandoff } from './handoff.js';
 import { CLAUDE_LAYOUT } from './layout.js';
 import { readClaudeQuota } from './quota.js';
+import { readClaudeTuning } from './tuning.js';
 import { readClaudeUsage } from './usage.js';
 const LINKED = [
     'settings.json',
@@ -115,9 +117,14 @@ export const claudeFamily = {
     identity: claudeIdentity,
     readQuota: readClaudeQuota,
     readUsage: readClaudeUsage,
+    readTuning: readClaudeTuning,
     quotaSetup: claudeStatusline,
     resumedSession: resumeFlagSession,
     sessionWrittenAt: (account, id) => groupedEntryWrittenAt(join(account.dir, 'projects'), `${id}.jsonl`, 'file'),
+    // Claude Code makes this directory for SessionStart hooks before the first message is saved (ADR-0009).
+    sessionStartedAt: (account, id) => dirWrittenAt(join(account.dir, 'session-env', id)),
+    withoutResume: withoutResumeFlag,
+    handoff: claudeHandoff,
 };
 export const claudePlugin = {
     name: 'claude',

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

@@ -0,0 +1,22 @@
+import { FileMemo } from '../../core/file-memo.ts';
+import type { Account, ReadContext, TuningResult } from '../../types.ts';
+/** Context window of a model, from the table or the records: a context that grew past 200K is a 1M window. */
+export declare const isKnownClaudeModel: (id: string) => boolean;
+/** `[key, ts, session, model, ctx, out, write5m, write1h]` */
+type TurnRow = [string, number, string, string, number, number, number, number];
+/** `[ts, session, model, trigger, pre, post]` */
+type CompactionRow = [number, string, string, string, number, number];
+/** What one session log contributes: only what the replay needs, never message text. */
+interface Summary {
+    lines: number;
+    parsed: number;
+    turns: TurnRow[];
+    compactions: CompactionRow[];
+    failed: boolean;
+}
+/** Per-file summaries per Account directory; a file is parsed again only after it changed. */
+export declare const claudeTuningMemo: FileMemo<Summary>;
+/** The Account's configured Compaction Threshold, or null for the Host default. Reads exactly one key. */
+export declare function readAutoCompactWindow(dir: string): Promise<number | null>;
+export declare function readClaudeTuning(account: Account, ctx: ReadContext): Promise<TuningResult>;
+export {};

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

@@ -0,0 +1,187 @@
+// Context tuning for a Claude Code Account (spec §3.18): replays its recent session logs against candidate
+// Compaction Thresholds. Read-only and local. The one Host config value read is `autoCompactWindow` from the
+// Account's `settings.json`; no other key of that file is returned, logged or cached.
+import { createReadStream } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { FileMemo } from '../../core/file-memo.js';
+import { USAGE_DAYS } from '../../core/quota-levels.js';
+import { getOrCreate, tuningResult, } from '../../core/tuning.js';
+import { listJsonl } from './usage.js';
+const DAY_MS = 86_400_000;
+const SETTINGS_MAX_BYTES = 1_000_000;
+/** Context window of a model, from the table or the records: a context that grew past 200K is a 1M window. */
+export const isKnownClaudeModel = (id) => id.startsWith('claude-');
+const windowOf = (maxCtx) => (maxCtx > 200_000 ? 1_000_000 : 200_000);
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0);
+async function parseFile(file, since) {
+    const out = { lines: 0, parsed: 0, turns: [], compactions: [], failed: false };
+    const byKey = new Map();
+    const lastModel = new Map();
+    // Compactions logged before the first assistant row of their session in this file: they take that row's model.
+    const orphans = new Map();
+    try {
+        const rl = createInterface({ input: createReadStream(file), crlfDelay: Number.POSITIVE_INFINITY });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            out.lines++;
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            out.parsed++;
+            const ts = typeof row?.timestamp === 'string' ? Date.parse(row.timestamp) : Number.NaN;
+            const session = typeof row?.sessionId === 'string' ? row.sessionId : file;
+            if (row?.type === 'system' && row.subtype === 'compact_boundary') {
+                const m = row.compactMetadata;
+                const pre = num(m?.preTokens);
+                const post = num(m?.postTokens);
+                if (!Number.isFinite(ts) || ts < since || !pre || !post)
+                    continue;
+                const t = m?.trigger;
+                const entry = [
+                    ts,
+                    session,
+                    lastModel.get(session) ?? '',
+                    t === 'auto' || t === 'manual' ? t : 'unknown',
+                    pre,
+                    post,
+                ];
+                out.compactions.push(entry);
+                if (!entry[2])
+                    orphans.set(session, [...(orphans.get(session) ?? []), entry]);
+                continue;
+            }
+            if (row?.type !== 'assistant' || row.isSidechain === true)
+                continue;
+            const usage = row.message?.usage;
+            const model = row.message?.model;
+            if (typeof usage !== 'object' ||
+                usage === null ||
+                typeof model !== 'string' ||
+                !model ||
+                model === '<synthetic>')
+                continue;
+            lastModel.set(session, model);
+            for (const o of orphans.get(session) ?? [])
+                o[2] = model;
+            orphans.delete(session);
+            if (!Number.isFinite(ts) || ts < since)
+                continue;
+            const id = row.message?.id;
+            const key = typeof id === 'string'
+                ? id
+                : typeof row.requestId === 'string'
+                    ? `request:${row.requestId}`
+                    : `${file}:${out.lines}`;
+            const cc = usage.cache_creation;
+            const cacheWrite = num(usage.cache_creation_input_tokens);
+            const w1h = Math.min(num(cc?.ephemeral_1h_input_tokens), cacheWrite);
+            const ctx = num(usage.input_tokens) + num(usage.cache_read_input_tokens) + cacheWrite;
+            // Re-insert so the last line of a message wins, as in the usage reader.
+            byKey.delete(key);
+            byKey.set(key, [key, ts, session, model, ctx, num(usage.output_tokens), cacheWrite - w1h, w1h]);
+        }
+    }
+    catch {
+        out.failed = true;
+    }
+    out.turns = [...byKey.values()];
+    return out;
+}
+/** Per-file summaries per Account directory; a file is parsed again only after it changed. */
+export const claudeTuningMemo = new FileMemo({ name: 'claude-tuning', version: 2 });
+/** The Account's configured Compaction Threshold, or null for the Host default. Reads exactly one key. */
+export async function readAutoCompactWindow(dir) {
+    try {
+        const file = join(dir, 'settings.json');
+        const st = await stat(file);
+        if (!st.isFile() || st.size > SETTINGS_MAX_BYTES)
+            return null;
+        const json = JSON.parse(await readFile(file, 'utf8'));
+        const v = json && typeof json === 'object' ? json.autoCompactWindow : undefined;
+        return typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.round(v) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readClaudeTuning(account, ctx) {
+    const files = await listJsonl(join(account.dir, 'projects'));
+    if (!files.length)
+        return {
+            status: 'unavailable',
+            reason: 'no-session',
+            detail: 'no Claude Code sessions recorded for this account yet',
+        };
+    const now = ctx.now.getTime();
+    const since = now - USAGE_DAYS * DAY_MS;
+    const turns = new Map();
+    const compactions = [];
+    const compactionKeys = new Set();
+    let lines = 0;
+    let parsed = 0;
+    const memo = claudeTuningMemo.pass(account.dir);
+    for (const file of files) {
+        const st = await stat(file).catch(() => null);
+        if (!st || st.mtimeMs < since)
+            continue;
+        const s = await memo.get(file, st, () => parseFile(file, since), (v) => !v.failed);
+        lines += s.lines;
+        parsed += s.parsed;
+        for (const t of s.turns) {
+            turns.delete(t[0]);
+            turns.set(t[0], t);
+        }
+        // A resumed session can repeat its history in a new file; one compaction counts once.
+        for (const c of s.compactions)
+            if (!compactionKeys.has(`${c[1]}:${c[0]}:${c[4]}`)) {
+                compactionKeys.add(`${c[1]}:${c[0]}:${c[4]}`);
+                compactions.push(c);
+            }
+    }
+    memo.done();
+    if (lines > 0 && parsed === 0)
+        return {
+            status: 'unavailable',
+            reason: 'unrecognized',
+            detail: `session logs in the last ${USAGE_DAYS} days could not be parsed as JSON lines`,
+        };
+    // A compaction whose own file never named a model takes the model its session used in another file. The rows
+    // belong to the cache, so a resolved copy is made instead of editing them.
+    const sessionModel = new Map();
+    for (const t of [...turns.values()].sort((x, y) => x[1] - y[1]))
+        sessionModel.set(t[2], t[3]);
+    const resolved = compactions.map((c) => (c[2] ? c : [c[0], c[1], sessionModel.get(c[1]) ?? '', c[3], c[4], c[5]]));
+    // Group per model, then per session; a session that switched models is replayed once per model.
+    const byModel = new Map();
+    for (const [, ts, session, model, c, out, w5, w1] of turns.values()) {
+        if (ts > now || ts < since)
+            continue;
+        const sessions = getOrCreate(byModel, model, () => new Map());
+        const list = getOrCreate(sessions, session, () => []);
+        list.push({ ts, ctx: c, out, write5m: w5, write1h: w1 });
+    }
+    if (!byModel.size)
+        return {
+            status: 'unavailable',
+            reason: 'no-session',
+            detail: `no Claude Code turns in the last ${USAGE_DAYS} days`,
+        };
+    const configured = await readAutoCompactWindow(account.dir);
+    const records = [...byModel].map(([model, sessions]) => {
+        const list = [...sessions.values()].map((t) => t.sort((a, b) => a.ts - b.ts));
+        const maxCtx = Math.max(0, ...list.flat().map((t) => t.ctx));
+        const comps = resolved
+            .filter((c) => c[2] === model && c[0] >= since && c[0] <= now)
+            .map((c) => ({ ts: c[0], trigger: c[3], pre: c[4], post: c[5] }));
+        const window = Math.max(windowOf(maxCtx), windowOf(Math.max(0, ...comps.map((c) => c.pre))));
+        return { model, sessions: list, compactions: comps, contextWindow: window };
+    });
+    return tuningResult(USAGE_DAYS, records, { configured, known: isKnownClaudeModel, mayRecommend: true });
+}

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

@@ -8,6 +8,7 @@ interface Entry {
     cacheRead: number;
     cacheWrite: number;
 }
+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. */
 interface Parsed {
     lines: number;

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

@@ -9,7 +9,7 @@ import { FileMemo } from '../../core/file-memo.js';
 import { USAGE_DAYS } from '../../core/quota-levels.js';
 import { dailyBuckets } from '../../core/usage-days.js';
 const DAY_MS = 86_400_000;
-async function listJsonl(dir, out = []) {
+export async function listJsonl(dir, out = []) {
     let entries;
     try {
         entries = await readdir(dir, { withFileTypes: true });
@@ -75,7 +75,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();
+export const claudeUsageMemo = new FileMemo({ name: 'claude-usage', version: 1 });
 export async function readClaudeUsage(account, ctx) {
     const files = await listJsonl(join(account.dir, 'projects'));
     if (!files.length)

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

@@ -0,0 +1,5 @@
+import type { Account } from '../../types.ts';
+export declare function codexBrief(_account: Account, session: {
+    id?: string;
+    transcriptPath?: string;
+}): Promise<string | undefined>;

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

@@ -0,0 +1,49 @@
+// A Brief from a Codex rollout (`sessions/**/rollout-*.jsonl`), for when the session could not write one, for
+// example under a read-only sandbox. Codex's hook input carries the rollout path.
+import { readFile } from 'node:fs/promises';
+import { DigestBuilder, formatDigest } from '../shared/brief.js';
+/** Context Codex injects as user messages (AGENTS.md, environment), not something the user asked. */
+const INJECTED = /^\s*(<|# AGENTS\.md)/;
+const PATCH_FILE = /^\*\*\* (?:Update|Add) File: (.+)$/gm;
+export async function codexBrief(_account, session) {
+    const file = session.transcriptPath;
+    if (!file)
+        return undefined;
+    let text;
+    try {
+        text = await readFile(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const b = new DigestBuilder();
+    for (const line of text.split('\n')) {
+        if (!line.includes('"response_item"'))
+            continue;
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const p = o.payload;
+        if (o.type !== 'response_item' || !p)
+            continue;
+        if (p.type === 'message' && Array.isArray(p.content)) {
+            for (const c of p.content) {
+                if (typeof c?.text !== 'string')
+                    continue;
+                if (p.role === 'user' && c.type === 'input_text' && !INJECTED.test(c.text))
+                    b.user(c.text);
+                else if (p.role === 'assistant' && c.type === 'output_text')
+                    b.assistant(c.text);
+            }
+        }
+        else if (p.type === 'custom_tool_call' && p.name === 'apply_patch' && typeof p.input === 'string')
+            for (const m of p.input.matchAll(PATCH_FILE))
+                b.file(m[1].trim());
+    }
+    const d = b.result();
+    return d ? formatDigest(d) : undefined;
+}

package/dist/src/families/codex/handoff-hook.d.ts

@@ -0,0 +1,2 @@
+import { type HookReader } from '../../handoff/reader.ts';
+export declare const codexHookReader: HookReader;

package/dist/src/families/codex/handoff-hook.js

@@ -0,0 +1,16 @@
+// Codex for the handoff hook (spec §3.17): Quota Pressure from the current session's rollout. Codex has no hook
+// for a failed turn, so it starts a Handoff only before its limit. Leaf module: the hook runs on every tool call.
+import { quotaPressure } from '../../core/quota-levels.js';
+import { field } from '../../handoff/reader.js';
+import { lastRateLimits } from './rate-limits.js';
+export const codexHookReader = {
+    async pressure(input, _env, now) {
+        const file = field(input, 'transcript_path');
+        if (!file)
+            return null;
+        const windows = await lastRateLimits(file);
+        return windows
+            ? quotaPressure({ status: 'ok', windows, observedAt: now.toISOString(), source: file }, now)
+            : null;
+    },
+};

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

@@ -0,0 +1,5 @@
+import type { FamilyHandoff } from '../../types.ts';
+import { type ArgRules } from '../shared/handoff-args.ts';
+/** From `codex --help`. `-c` is a config override in Codex, not a continue flag, so it is kept. */
+export declare const CODEX_ARGS: ArgRules;
+export declare const codexHandoff: FamilyHandoff;

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

@@ -0,0 +1,121 @@
+// How Codex takes part in a Handoff (spec §3.17): hooks through `-c hooks.<event>=…` (the session-flags layer is a
+// hook source; verified 2026-10-09), each Account trusting them once in `/hooks`. No hook fires on a failed turn,
+// so Codex starts a Handoff only before its limit.
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { carryArgs, hasOption, optionValue, promptAfterDashes, } from '../shared/handoff-args.js';
+import { topLevelTomlString } from '../shared/toml.js';
+import { codexBrief } from './brief.js';
+/** From `codex --help`. `-c` is a config override in Codex, not a continue flag, so it is kept. */
+export const CODEX_ARGS = {
+    valued: [
+        '-c',
+        '--config',
+        '--enable',
+        '--disable',
+        '--remote',
+        '--remote-auth-token-env',
+        '-m',
+        '--model',
+        '--local-provider',
+        '-p',
+        '--profile',
+        '-s',
+        '--sandbox',
+        '-C',
+        '--cd',
+        '--add-dir',
+        '-a',
+        '--ask-for-approval',
+    ],
+    variadic: ['-i', '--image'],
+    drop: ['--last', '--all', '--include-non-interactive', '-i', '--image'],
+};
+/** Subcommands that are not an interactive session; `resume` and `fork` are. */
+const NOT_INTERACTIVE = new Set([
+    'exec',
+    'e',
+    'review',
+    'login',
+    'logout',
+    'mcp',
+    'mcp-server',
+    'plugin',
+    'app-server',
+    'remote-control',
+    'app',
+    'completion',
+    'update',
+    'doctor',
+    'sandbox',
+    'debug',
+    'apply',
+    'archive',
+    'delete',
+    'migrate-rollouts',
+    'unarchive',
+    'cloud',
+    'exec-server',
+    'features',
+    'help',
+    'agents',
+]);
+/** The first argument that is not an option or an option's value. */
+function firstPositional(args) {
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--')
+            return args[i + 1];
+        if (!a.startsWith('-'))
+            return a;
+        if (!a.includes('=') && CODEX_ARGS.valued.includes(a))
+            i++;
+    }
+    return undefined;
+}
+/** `-s`/`--sandbox`, else `-c sandbox_mode=…`, else `sandbox_mode` in the Account's config.toml (profiles not read). */
+async function sandboxMode(args, dir) {
+    const flag = optionValue(args, ['-s', '--sandbox']);
+    if (flag)
+        return flag;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--')
+            break;
+        const kv = args[i] === '-c' || args[i] === '--config' ? args[i + 1] : undefined;
+        const m = kv && /^sandbox_mode\s*=\s*["']?([\w-]+)["']?$/.exec(kv);
+        if (m)
+            return m[1];
+    }
+    try {
+        return topLevelTomlString(await readFile(join(dir, 'config.toml'), 'utf8'), 'sandbox_mode');
+    }
+    catch {
+        return undefined;
+    }
+}
+const hookValue = (event, command) => `hooks.${event}=[{hooks=[{type="command",command="${command}"}]}]`;
+export const codexHandoff = {
+    starts: ['quota'],
+    async hookArgs(command) {
+        return ['-c', hookValue('PostToolUse', command('PostToolUse')), '-c', hookValue('Stop', command('Stop'))];
+    },
+    dirArgs: (dir) => ['--add-dir', dir],
+    promptArgs: promptAfterDashes,
+    continueArgs: (args) => carryArgs(args, CODEX_ARGS),
+    resumeArgs: (id) => ['resume', id],
+    async eligibility(args, account) {
+        const sub = firstPositional(args);
+        if (sub && NOT_INTERACTIVE.has(sub))
+            return { start: false, receive: false, reason: `\`codex ${sub}\` is not an interactive session` };
+        if (hasOption(args, ['--remote']))
+            return {
+                start: false,
+                receive: false,
+                reason: '`--remote` talks to a remote app server: another local account cannot take over its session',
+            };
+        // Under a read-only sandbox the session cannot write its Brief; sideby puts one together instead.
+        const sandbox = await sandboxMode(args, account.dir);
+        return { start: true, receive: true, ...(sandbox === 'read-only' ? { agentBrief: false } : {}) };
+    },
+    briefFromSession: codexBrief,
+};

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

@@ -4,7 +4,9 @@ import { identityFromJsonFile, identityOf, jwtEmail } from '../../core/identity.
 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 { readCodexQuota, readCodexUsage } from './rollout.js';
+import { readCodexTuning } from './tuning.js';
 const FILE_STORE_KEY = 'cli_auth_credentials_store';
 async function readModel(account) {
     try {
@@ -47,6 +49,8 @@ export const codexFamily = {
             return [];
         return ['-c', `${FILE_STORE_KEY}="file"`];
     },
+    // `tui.terminal_title` takes only built-in items; an empty list leaves the title sideby set alone.
+    keepTitle: { key: 'tui.terminal_title', args: ['-c', 'tui.terminal_title=[]'] },
     async loginState(account) {
         try {
             return (await stat(join(account.dir, 'auth.json'))).isFile() ? 'logged-in' : 'unknown';
@@ -59,8 +63,10 @@ export const codexFamily = {
     identity: codexIdentity,
     readQuota: (account) => readCodexQuota(account.dir),
     readUsage: (account, ctx) => readCodexUsage(account.dir, ctx.now),
+    readTuning: readCodexTuning,
     resumedSession: resumeSubcommandSession,
     sessionWrittenAt: (account, id) => nestedFileWrittenAt(join(account.dir, 'sessions'), `-${id}.jsonl`),
+    handoff: codexHandoff,
 };
 export const codexPlugin = {
     name: 'codex',

package/dist/src/families/codex/rate-limits.d.ts

@@ -0,0 +1,16 @@
+import type { QuotaWindow } from '../../types.ts';
+type Obj = Record<string, unknown>;
+export declare const isObj: (v: unknown) => v is Obj;
+export declare const isNum: (v: unknown) => v is number;
+export declare function windowLabel(minutes: number): string;
+/** The windows of one `token_count` payload, or null when its `rate_limits` is missing or malformed. */
+export declare function rateLimits(payload: Obj): {
+    windows: QuotaWindow[];
+    plan?: string;
+} | null;
+/**
+ * The windows of the last well-formed `rate_limits` in the rollout's last 256 KB, or null. A line cut by the read
+ * window or still being written is skipped. Codex writes `rate_limits` after caching them, so they may lag.
+ */
+export declare function lastRateLimits(file: string): Promise<QuotaWindow[] | null>;
+export {};