sideby 0.4.0 → 0.4.1

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261013T091101-030f9b"}
+{"id":"20261013T093231-6fb759"}

package/dist/src/cli/commands.js

@@ -312,6 +312,8 @@ function tuneChangeLines(plan, home) {
     ];
     if (plan.affected.length > 1)
         lines.push(`  Careful: this file is shared, so it also changes ${plan.affected.slice(1).join(', ')}`);
+    if (plan.overrides.length)
+        lines.push(`  Careful: these models save a size of their own, which wins over this one: ${plan.overrides.map((o) => `${o.model} (${compactNumber(o.value)})`).join(', ')}`);
     lines.push('  Sessions already running keep the old value; new ones use the new one. You can undo it.');
     return lines;
 }

package/dist/src/cli/format.js

@@ -83,7 +83,7 @@ const TUNING_REASON = {
     'already-best': 'already the cheapest setting we can estimate',
     'insufficient-calls': `too few calls to estimate (needs ${MIN_CALLS})`,
     'no-compactions': 'no compaction recorded to estimate from',
-    'no-optimum': 'the cheapest point is at the bottom of the range tried, so there is no clear best value',
+    'no-optimum': 'the model window is below the lowest size Claude Code accepts (100K), so there is nothing to set',
     'unknown-model': 'not a Claude model, so the cost weights do not apply',
     'observe-only': 'observation only (no public default for this host)',
 };

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

@@ -211,6 +211,7 @@ export const OUTPUT_SCHEMAS = {
             current: Type.Union([Type.Number(), Type.Null()]),
             next: Type.Union([Type.Number(), Type.Null()]),
             creates: Type.Boolean(),
+            overrides: Type.Optional(Type.Array(Type.Object({ model: Str, value: Type.Number() }))),
             reason: Type.Optional(Str),
         })),
         message: Type.Optional(Str),

package/dist/src/core/tuning-apply.d.ts

@@ -1,7 +1,7 @@
 import type { Account, ReadContext } from '../types.ts';
 export declare const TUNE_KEY = "autoCompactWindow";
-export declare const MIN_WINDOW = 10000;
-export declare const MAX_WINDOW = 2000000;
+export declare const MIN_WINDOW = 100000;
+export declare const MAX_WINDOW = 1000000;
 export interface TuneApplyPlan {
     /** `ready`: will write; `unchanged`: already that value; `blocked`: `reason` says why and what to do. */
     status: 'ready' | 'unchanged' | 'blocked';
@@ -17,8 +17,14 @@ export interface TuneApplyPlan {
     next: number | null;
     /** The file does not exist yet and will be created. */
     creates: boolean;
+    /** Models that save a size of their own (`modelSettings`), which wins over this one for them. */
+    overrides: ModelOverride[];
     reason?: string;
 }
+export interface ModelOverride {
+    model: string;
+    value: number;
+}
 export interface TuneUndoRecord {
     file: string;
     /** The value before sideby wrote, or null when the key was not there. */
@@ -47,5 +53,11 @@ export declare function undoTune(account: Account, ctx: ReadContext): Promise<{
 }>;
 /** The real file an Account's setting lives in (canonical, so Accounts sharing it get the same answer). */
 export declare function settingsFileOf(account: Account): Promise<string>;
-/** The size in the Account's settings file now, or null when there is none (the default). Reads only that key. */
-export declare function currentTuneValue(account: Account): Promise<number | null>;
+/**
+ * The size in the Account's settings file now (null: the default) and the sizes models save for themselves. Reads
+ * only those `autoCompactWindow` numbers.
+ */
+export declare function readTuneSettings(account: Account): Promise<{
+    current: number | null;
+    overrides: ModelOverride[];
+}>;

package/dist/src/core/tuning-apply.js

@@ -7,9 +7,10 @@ import { mkdir, readFile, rm, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { UserError } from './errors.js';
 import { fileHash, lstatOrNull, realpathOrNull, sha256, writeFileAtomic, writeIfUnchanged, } from './fs-safe.js';
+import { MAX_COMPACT_WINDOW, MIN_COMPACT_WINDOW } from './tuning.js';
 export const TUNE_KEY = 'autoCompactWindow';
-export const MIN_WINDOW = 10_000;
-export const MAX_WINDOW = 2_000_000;
+export const MIN_WINDOW = MIN_COMPACT_WINDOW;
+export const MAX_WINDOW = MAX_COMPACT_WINDOW;
 const MAX_BYTES = 5_000_000;
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function checkValue(value) {
@@ -47,6 +48,19 @@ async function readObject(file) {
         return { error: 'it is not a JSON object' };
     return { text, obj: parsed };
 }
+/** The sizes models save for themselves under `modelSettings`: only those `autoCompactWindow` numbers are read. */
+function overridesOf(obj) {
+    const ms = obj.modelSettings;
+    if (!isObj(ms))
+        return [];
+    const out = [];
+    for (const [model, entry] of Object.entries(ms)) {
+        const v = isObj(entry) ? entry[TUNE_KEY] : undefined;
+        if (typeof v === 'number' && Number.isFinite(v))
+            out.push({ model, value: v });
+    }
+    return out;
+}
 /** Where the Account's settings really live, and whether `settings.json` is a link to it. */
 async function locate(account) {
     const path = join(account.dir, 'settings.json');
@@ -91,6 +105,7 @@ export async function planTuneApply(account, value, accounts) {
         current: null,
         next: value,
         creates: false,
+        overrides: [],
     };
     if (where.broken)
         return {
@@ -117,7 +132,13 @@ export async function planTuneApply(account, value, accounts) {
         if (loc.exists && loc.file === where.file)
             affected.push(other.ref);
     }
-    return { ...base, affected, current, status: current === value ? 'unchanged' : 'ready' };
+    return {
+        ...base,
+        affected,
+        current,
+        overrides: overridesOf(read.obj),
+        status: current === value ? 'unchanged' : 'ready',
+    };
 }
 /** Plans, and writes only when the plan is `ready`. */
 export async function applyTune(account, value, accounts, ctx) {
@@ -224,14 +245,20 @@ export async function undoTune(account, ctx) {
 export async function settingsFileOf(account) {
     return (await locate(account)).file;
 }
-/** The size in the Account's settings file now, or null when there is none (the default). Reads only that key. */
-export async function currentTuneValue(account) {
+/**
+ * The size in the Account's settings file now (null: the default) and the sizes models save for themselves. Reads
+ * only those `autoCompactWindow` numbers.
+ */
+export async function readTuneSettings(account) {
     const where = await locate(account);
     if (!where.exists)
-        return null;
+        return { current: null, overrides: [] };
     const read = await readObject(where.file);
     if ('error' in read)
-        return null;
+        return { current: null, overrides: [] };
     const v = read.obj[TUNE_KEY];
-    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+    return {
+        current: typeof v === 'number' && Number.isFinite(v) ? v : null,
+        overrides: overridesOf(read.obj),
+    };
 }

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

@@ -7,6 +7,12 @@ export declare const WEIGHT: {
     readonly write1h: 2;
     readonly output: 5;
 };
+/**
+ * The sizes Claude Code accepts for the auto-compact window: 100K to 1M tokens, never above the model's context
+ * window (https://code.claude.com/docs/en/model-config#set-the-auto-compact-window).
+ */
+export declare const MIN_COMPACT_WINDOW = 100000;
+export declare const MAX_COMPACT_WINDOW = 1000000;
 /** A model with fewer turns than this in the window gets no suggestion. */
 export declare const MIN_CALLS = 200;
 /** Candidate thresholds as a share of the model's context window. */
@@ -33,6 +39,8 @@ export interface ModelRecords {
     sessions: Turn[][];
     compactions: Compaction[];
     contextWindow: number;
+    /** Where the Host compacts when nothing is set (documented), or null when that is not known. */
+    defaultThreshold?: number | null;
 }
 export interface SummarizeOptions {
     /** The Account's configured threshold in tokens; null is the Host default. */
@@ -77,6 +85,13 @@ export interface TuneEntry {
 }
 /** The Accounts that share one settings file: they get one suggestion and one thing to apply. */
 export interface TuneGroup {
+    /** The size in the file is outside what Claude Code accepts, so it cannot be offered again. */
+    outOfRange: boolean;
+    /** Models that save an auto-compact size of their own, which wins over the file's size for them. */
+    overrides: {
+        model: string;
+        value: number;
+    }[];
     /** The real settings file. */
     file: string;
     members: string[];

package/dist/src/core/tuning.js

@@ -1,5 +1,11 @@
 /** Relative cost of a token, input = 1. These are Anthropic's published multipliers, not prices (spec §3.18). */
 export const WEIGHT = { input: 1, cacheRead: 0.1, write5m: 1.25, write1h: 2, output: 5 };
+/**
+ * The sizes Claude Code accepts for the auto-compact window: 100K to 1M tokens, never above the model's context
+ * window (https://code.claude.com/docs/en/model-config#set-the-auto-compact-window).
+ */
+export const MIN_COMPACT_WINDOW = 100_000;
+export const MAX_COMPACT_WINDOW = 1_000_000;
 /** A model with fewer turns than this in the window gets no suggestion. */
 export const MIN_CALLS = 200;
 /** Candidate thresholds as a share of the model's context window. */
@@ -68,7 +74,13 @@ export function summarizeModel(rec, o) {
     const pre = rec.compactions.map((c) => c.pre).filter((n) => n > 0);
     const posts = rec.compactions.map((c) => c.post).filter((n) => n > 0);
     const autoPre = auto.map((c) => c.pre).filter((n) => n > 0);
-    const effective = o.configured !== null ? Math.min(o.configured, rec.contextWindow) : median(autoPre);
+    // What is in effect: the configured size, else what the Host did, else where it compacts by default.
+    // A size outside 100K-1M is not one Claude Code runs with (the documentation does not say what it does with it),
+    // so it is not taken as the baseline.
+    const usable = o.configured !== null && o.configured >= MIN_COMPACT_WINDOW && o.configured <= MAX_COMPACT_WINDOW;
+    const effective = usable && o.configured !== null
+        ? Math.min(o.configured, rec.contextWindow)
+        : (median(autoPre) ?? rec.defaultThreshold ?? null);
     const base = {
         model: rec.model,
         calls,
@@ -96,9 +108,16 @@ export function summarizeModel(rec, o) {
     const post = median(posts);
     if (post === null)
         return stop('no-compactions');
+    // Only sizes Claude Code accepts: the lowest allowed one is always a candidate.
+    const top = Math.min(rec.contextWindow, MAX_COMPACT_WINDOW);
+    const candidates = new Set([MIN_COMPACT_WINDOW]);
+    for (const pct of CANDIDATE_PERCENTS)
+        candidates.add(roundTokens((rec.contextWindow * pct) / 100));
+    const sizes = [...candidates].filter((t) => t >= MIN_COMPACT_WINDOW && t <= top).sort((x, y) => x - y);
+    if (!sizes.length)
+        return stop('no-optimum');
     let best = null;
-    for (const pct of CANDIDATE_PERCENTS) {
-        const threshold = roundTokens((rec.contextWindow * pct) / 100);
+    for (const threshold of sizes) {
         const cost = replay(rec.sessions, threshold, post);
         // On a tie the larger threshold wins: fewer compactions for the same cost.
         if (!best || cost < best.cost || (cost === best.cost && threshold > best.threshold))
@@ -106,10 +125,7 @@ export function summarizeModel(rec, o) {
     }
     if (!best)
         return stop('insufficient-calls');
-    // A best value at the lowest candidate means the cheapest point may lie below the range that was replayed, so it
-    // is a cut-off of the search, not an optimum, and is not suggested.
-    if (best.threshold === roundTokens((rec.contextWindow * CANDIDATE_PERCENTS[0]) / 100))
-        return stop('no-optimum');
+    // The lowest allowed size can still be the cheapest: that is a real answer, "as low as Claude Code lets you".
     if (effective === null)
         return {
             ...base,

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

@@ -14,6 +14,12 @@ 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);
+/**
+ * Models with a native 1M window, which compact at about 967K when nothing is set: the Fable models, Sonnet 5 and
+ * later, Haiku 5.5 and Opus 4.7 and later (https://code.claude.com/docs/en/model-config).
+ */
+const NATIVE_1M = /^claude-(fable|sonnet-[5-9]|haiku-[5-9]|opus-(4-[7-9]|[5-9]))/;
+const NATIVE_DEFAULT_THRESHOLD = 967_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 };
@@ -180,8 +186,18 @@ export async function readClaudeTuning(account, 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 };
+        const native = NATIVE_1M.test(model);
+        // Elsewhere the window comes from the records: a context past 200K means the model runs with 1M.
+        const window = native
+            ? 1_000_000
+            : Math.max(windowOf(maxCtx), windowOf(Math.max(0, ...comps.map((c) => c.pre))));
+        return {
+            model,
+            sessions: list,
+            compactions: comps,
+            contextWindow: window,
+            defaultThreshold: native ? NATIVE_DEFAULT_THRESHOLD : window,
+        };
     });
     return tuningResult(USAGE_DAYS, records, { configured, known: isKnownClaudeModel, mayRecommend: true });
 }

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

@@ -251,6 +251,8 @@ declare const en: {
     'tune.noCompactions': string;
     'tune.groupShared': string;
     'tune.basis': string;
+    'tune.outOfRange': string;
+    'tune.overrides': string;
     'tune.groupNone': string;
     'tune.details': string;
     'tune.detailsObserved': string;

package/dist/src/panel/i18n.js

@@ -253,6 +253,8 @@ const en = {
     'tune.noCompactions': 'It did not compact in this period.',
     'tune.groupShared': 'One setting for these accounts, because they share a settings file: {list}',
     'tune.basis': 'Based on {model} on {ref}, the one used most.',
+    'tune.outOfRange': 'The size now in the file ({size}) is outside what Claude Code accepts (100K to 1M). Pick Default or a size from the menu to replace it.',
+    'tune.overrides': 'These models save a size of their own (set with /autocompact), which wins over this one: {list}',
     'tune.groupNone': 'Not used enough to suggest a size yet. You can still pick one below.',
     'tune.details': 'Details for each account',
     'tune.detailsObserved': 'Only observed (there is no setting to change)',
@@ -277,7 +279,7 @@ const en = {
     'tune.reason.already-best': 'The current setting is already about the cheapest we can estimate for how you work.',
     'tune.reason.insufficient-calls': 'Not enough use in this period to estimate (needs {min} calls).',
     'tune.reason.no-compactions': 'It has not compacted in this period, so there is nothing to estimate from.',
-    'tune.reason.no-optimum': 'No clear best value: the cheapest point is outside the range we tried.',
+    'tune.reason.no-optimum': "This model's window is smaller than the lowest size Claude Code accepts (100K), so there is nothing to set.",
     'tune.reason.unknown-model': 'This is not a Claude model, so sideby cannot estimate it.',
     'tune.reason.observe-only': 'For Codex sideby only shows what happened; it cannot suggest a value yet.',
     'tpage.title': 'Context tuning',
@@ -632,6 +634,8 @@ const zh = {
     'tune.noCompactions': '这段时间没有压缩过。',
     'tune.groupShared': '这些账号共用一个设置文件，所以用同一个设置：{list}',
     'tune.basis': '按用得最多的 {model}（{ref}）来定。',
+    'tune.outOfRange': '文件里现在的大小（{size}）超出了 Claude Code 接受的范围（100K 到 1M）。请选「默认」或菜单里的某个大小来替换它。',
+    'tune.overrides': '这些模型自己保存了一个大小（用 /autocompact 设的），对它们来说那个优先于这里的设置：{list}',
     'tune.groupNone': '用得还不够多，暂时给不出建议值。你仍然可以在下面自己选一个。',
     'tune.details': '各账号的详情',
     'tune.detailsObserved': '只做观测（没有可以改的设置）',
@@ -656,7 +660,7 @@ const zh = {
     'tune.reason.already-best': '按你的用法，现在的设置已经差不多是我们能估算出的最省了。',
     'tune.reason.insufficient-calls': '这段时间用得太少，估不准（至少要 {min} 次）。',
     'tune.reason.no-compactions': '这段时间还没压缩过，没有可以参考的数据。',
-    'tune.reason.no-optimum': '没有明确的最佳值：最省的点在我们试的范围之外。',
+    'tune.reason.no-optimum': '这个模型的窗口比 Claude Code 接受的最小值（100K）还小，没有可以设置的值。',
     'tune.reason.unknown-model': '这不是 Claude 的模型，sideby 没法估算。',
     'tune.reason.observe-only': 'Codex 目前只能看到发生了什么，还不能给建议值。',
     'tpage.title': '上下文调优',

package/dist/src/panel/page-script.js

@@ -1315,6 +1315,7 @@ const MAIN = String.raw `
         h('li', null, t('tune.change') + ': ' + tuneSize(plan.current) + ' → ' + tuneSize(plan.next)),
         h('li', null, t('tune.file') + ': ', h('code', null, plan.file + (plan.creates ? ' ' + t('tune.willCreate') : '')))),
       plan.affected.length > 1 ? h('p', { class: 'note note-warn' }, t('tune.shared', { list: plan.affected.join(', ') })) : null,
+      plan.overrides && plan.overrides.length ? h('p', { class: 'note note-warn' }, t('tune.overrides', { list: plan.overrides.map((o) => o.model + ' (' + tokens(o.value) + ')').join(', ') })) : null,
       h('p', { class: 'muted small' }, t('tune.newSessions')),
       h('div', { class: 'row-actions' },
         h('button', { class: 'btn btn-primary btn-sm', type: 'button', onclick: useConfirm }, t('tune.confirm')),
@@ -1323,12 +1324,12 @@ const MAIN = String.raw `
   // The card for one settings file.
   function tuneGroupCard(g, entries) {
     const pick = g.pick
-    const sizes = new Set([50000, 80000, 100000, 120000, 160000, 200000, 300000, 500000, 800000])
+    const sizes = new Set([100000, 150000, 200000, 300000, 500000, 800000, 1000000])
     let top = 200000
     for (const e of entries) if (e.tuning.status === 'ok') for (const m of e.tuning.models) top = Math.max(top, m.contextWindow)
     for (const v of [...sizes]) if (v > top) sizes.delete(v)
     if (pick) sizes.add(pick.threshold)
-    if (g.current) sizes.add(g.current)
+    if (g.current && !g.outOfRange) sizes.add(g.current)
     const key = (v) => (v === null ? 'default' : String(v))
     const chosen = tuneSel[g.id] !== undefined ? tuneSel[g.id] : key(g.current)
     const sel = h('select', { 'aria-label': t('tune.setting') },
@@ -1346,7 +1347,13 @@ const MAIN = String.raw `
       pick ? h('div', null, h('span', { class: 'muted small' }, t('tune.best')), h('div', { class: 'tune-num tune-best' }, tokens(pick.threshold))) : null))
     if (pick && pick.savedPercent !== null) rows.push(h('p', { class: 'small' }, t('tune.saved', { n: Math.round(pick.savedPercent) })))
     if (pick) rows.push(h('p', { class: 'muted small' }, t('tune.basis', { model: pick.model, ref: pick.ref })))
-    else rows.push(h('p', { class: 'note' }, t('tune.groupNone')))
+    else {
+      // Say why there is no suggestion: when a model is already at its cheapest, that is the news, not "not enough use".
+      const why = entries.flatMap((e) => (e.tuning.status === 'ok' ? e.tuning.models : [])).some((m) => m.reason === 'already-best') ? t('tune.reason.already-best') : t('tune.groupNone')
+      rows.push(h('p', { class: 'note' }, why))
+    }
+    if (g.overrides && g.overrides.length) rows.push(h('p', { class: 'note note-warn' }, t('tune.overrides', { list: g.overrides.map((o) => o.model + ' (' + tokens(o.value) + ')').join(', ') })))
+    if (g.outOfRange) rows.push(h('p', { class: 'note note-warn' }, t('tune.outOfRange', { size: tokens(g.current) })))
     if (!BOOT.readOnly) {
       if (pick && !asking) rows.push(h('div', { class: 'row-actions' }, h('button', { class: 'btn btn-primary', type: 'button', onclick: () => useAsk(g, pick.threshold) }, t('tune.use', { size: tokens(pick.threshold) }))))
       rows.push(h('div', { class: 'tune-setting' },

package/dist/src/runtime.js

@@ -15,8 +15,8 @@ import { resolvePaths } from './core/paths.js';
 import { findResumeRoute } from './core/resume.js';
 import { shareMeaning } from './core/share-meaning.js';
 import { SHELLS, shellInitScript, writeShellInitFile, } from './core/shell-init.js';
-import { groupSuggestion } from './core/tuning.js';
-import { applyTune, currentTuneValue, planTuneApply, settingsFileOf, tuneUndoInfo, undoTune, } from './core/tuning-apply.js';
+import { groupSuggestion, MAX_COMPACT_WINDOW, MIN_COMPACT_WINDOW, } from './core/tuning.js';
+import { applyTune, planTuneApply, readTuneSettings, settingsFileOf, tuneUndoInfo, undoTune, } from './core/tuning-apply.js';
 import { packageVersion } from './core/version.js';
 import { BUILTIN_PLUGINS } from './families/index.js';
 import { HookBus } from './plugins/bus.js';
@@ -492,7 +492,7 @@ export async function createRuntime(opts = {}) {
                 for (const m of members)
                     list.push(await entryOf(m));
                 const pick = groupSuggestion(list);
-                const current = await currentTuneValue(members[0]);
+                const { current, overrides } = await readTuneSettings(members[0]);
                 const target = members.find((m) => m.ref === pick?.ref) ?? members[0];
                 const undo = await tuneUndoInfo(target, readContext());
                 groups.push({
@@ -500,6 +500,8 @@ export async function createRuntime(opts = {}) {
                     members: members.map((m) => m.ref),
                     target: target.ref,
                     current,
+                    outOfRange: current !== null && (current < MIN_COMPACT_WINDOW || current > MAX_COMPACT_WINDOW),
+                    overrides,
                     pick,
                     undo: undo ? { value: undo.applied, previous: undo.previous } : null,
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sideby",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Run work, personal and API-key accounts at the same time, without their configs drifting apart.",
   "license": "MIT",
   "author": "Adonis0123 (https://github.com/Adonis0123)",

package/schemas/tune-change.json

@@ -95,6 +95,24 @@
         "creates": {
           "type": "boolean"
         },
+        "overrides": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": [
+              "model",
+              "value"
+            ],
+            "properties": {
+              "model": {
+                "type": "string"
+              },
+              "value": {
+                "type": "number"
+              }
+            }
+          }
+        },
         "reason": {
           "type": "string"
         }

package/skills/sideby/SKILL.md

@@ -2,7 +2,7 @@
 name: sideby
 description: Use when the user runs, or wants to run, several AI coding accounts (Claude Code, Codex, Grok Build, pi) side by side. Covers installing sideby and setting up a new account ("install sideby", "set up another Claude account", "add cc008", "配置一个 cc00x", "再加一个 Codex 账号"), explaining what accounts share and what stays separate ("what do my accounts share?", "这些账号共享了什么"), showing which account a session is ("show [cc001] in the status line", "加上账号标识"), seeing accounts, quota and usage, moving on when one hits its 5-hour or weekly limit, adding a short command (alias), and repairing drifted account directories (skills, hooks, rules or settings not shared, wrong symlinks, credential file permissions). Drives the `sideby` CLI with `--json`; the agent does every step except browser sign-in, filling in secrets and starting interactive sessions, which it hands to the user as one command.
 metadata:
-  version: "0.4.0"
+  version: "0.4.1"
   requires:
     bins: [sideby, node]
   cliHelp: sideby --help

package/skills/sideby/references/diagnose.md

@@ -48,4 +48,4 @@ Quota is only as fresh as each account's last session; `observedAt` says when it
 
 ## Context tuning
 
-`sideby tune [ref|family] --json` estimates, per model, the auto-compact threshold that spends the fewest tokens, from the account's last 7 days of local sessions. It is read-only and an estimate: each model has `reason` (`suggested` carries `suggestion.threshold`; the others say why there is none: `insufficient-calls`, `no-compactions`, `no-optimum` (the cheapest point is at the bottom of the range tried, so there is no clear best), `unknown-model`, `already-best`, `observe-only`). Only Claude gets suggestions; Codex is observation only; Grok and pi return `no-source`. The analysis changes nothing. To use a suggestion run `sideby tune apply <ref> [tokens]`: it prints the file, the change and every account sharing that file (a linked `settings.json` is one shared file) and exits 10. Show that to the user in plain words, and only after a yes rerun with `--yes`. `sideby tune undo <ref> --yes` puts the old value back. Do not hand-edit `settings.json` for the user.
+`sideby tune [ref|family] --json` estimates, per model, the auto-compact threshold that spends the fewest tokens, from the account's last 7 days of local sessions. It is read-only and an estimate: each model has `reason` (`suggested` carries `suggestion.threshold`; the others say why there is none: `insufficient-calls`, `no-compactions`, `no-optimum` (the model window is below 100K, the lowest size Claude Code accepts), `unknown-model`, `already-best`, `observe-only`). Only Claude gets suggestions; Codex is observation only; Grok and pi return `no-source`. The analysis changes nothing. To use a suggestion run `sideby tune apply <ref> [tokens]`: it prints the file, the change and every account sharing that file (a linked `settings.json` is one shared file) and exits 10. Show that to the user in plain words, and only after a yes rerun with `--yes`. `sideby tune undo <ref> --yes` puts the old value back. Do not hand-edit `settings.json` for the user.