sideby 0.4.0 → 0.4.2

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261013T091101-030f9b"}
+{"id":"20261013T095821-360786"}

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)',
 };
@@ -93,7 +93,7 @@ export function tuningLines(t) {
         return [t.reason === 'no-source' ? 'no public source for this host' : (t.detail ?? t.reason)];
     return t.models.map((m) => {
         const now = m.configured === null ? 'Host default' : `${compactNumber(m.configured)}`;
-        const head = `${m.model}  ${m.calls} calls  now ${now}  ${m.compactions.total} compactions`;
+        const head = `${m.model}  ${m.calls} calls  now ${now}  ${m.compactions.total} compactions${m.compactions.idle ? ` (${m.compactions.idle} after idle)` : ''}`;
         if (m.suggestion) {
             const saved = m.suggestion.savedPercent === null
                 ? ''

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

@@ -115,6 +115,9 @@ const TuningModel = Type.Object({
         }),
         auto: Type.Number(),
         manual: Type.Number(),
+        idle: Type.Number({
+            description: 'Automatic compactions Claude Code did after the conversation sat idle; the size setting does not control them.',
+        }),
         preTokensP50: Type.Union([Type.Number(), Type.Null()]),
         preTokensMax: Type.Union([Type.Number(), Type.Null()]),
     }),
@@ -211,6 +214,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,26 @@ 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;
+/**
+ * Claude Code compacts a conversation on its own when it has sat idle for about 90% of the one-hour prompt cache
+ * and holds at least 200K tokens (read from Claude Code 2.1.296 and matched against real logs: 30 of 31 automatic
+ * compactions came after 54-55 minutes of silence and none was smaller than 202K). `autoCompactWindow` does not
+ * control it. A compaction after this much silence is recorded as `idle`.
+ */
+export declare const IDLE_AFTER_MS: number;
+export declare const IDLE_MIN_CTX = 200000;
+/**
+ * How long a silence must be to call a logged compaction `idle`. Deliberately a little below `IDLE_AFTER_MS`, since the log
+ * only has the timestamp of the last message. Replaying with 45, 50 or 54 minutes gave the same simulated counts on real
+ * logs, so the difference does not matter; why the replay finds fewer idle compactions than were logged is not this.
+ */
+export declare const IDLE_OBSERVED_MS: number;
 /** 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. */
@@ -24,6 +44,8 @@ export interface Turn {
 export interface Compaction {
     ts: number;
     trigger: 'auto' | 'manual' | 'unknown';
+    /** Claude Code did it by itself after the conversation sat idle (not because a size was reached). */
+    idle?: boolean;
     pre: number;
     post: number;
 }
@@ -33,7 +55,11 @@ 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;
 }
+/** Weighted cost of the sessions at a threshold. Exported for the tests of the engine. */
+export declare function replay(sessions: Turn[][], threshold: number, post: number, idle: boolean): number;
 export interface SummarizeOptions {
     /** The Account's configured threshold in tokens; null is the Host default. */
     configured: number | null;
@@ -77,6 +103,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,25 @@
 /** 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;
+/**
+ * Claude Code compacts a conversation on its own when it has sat idle for about 90% of the one-hour prompt cache
+ * and holds at least 200K tokens (read from Claude Code 2.1.296 and matched against real logs: 30 of 31 automatic
+ * compactions came after 54-55 minutes of silence and none was smaller than 202K). `autoCompactWindow` does not
+ * control it. A compaction after this much silence is recorded as `idle`.
+ */
+export const IDLE_AFTER_MS = 54 * 60_000;
+export const IDLE_MIN_CTX = 200_000;
+/**
+ * How long a silence must be to call a logged compaction `idle`. Deliberately a little below `IDLE_AFTER_MS`, since the log
+ * only has the timestamp of the last message. Replaying with 45, 50 or 54 minutes gave the same simulated counts on real
+ * logs, so the difference does not matter; why the replay finds fewer idle compactions than were logged is not this.
+ */
+export const IDLE_OBSERVED_MS = 50 * 60_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. */
@@ -20,7 +40,7 @@ function writeWeight(t) {
     return n > 0 ? (t.write5m * WEIGHT.write5m + t.write1h * WEIGHT.write1h) / n : WEIGHT.write5m;
 }
 /** Weighted cost of one session's turns if the Host compacted whenever the context reached `threshold`. */
-function replaySession(turns, threshold, post) {
+function replaySession(turns, threshold, post, idle) {
     const first = turns[0];
     if (!first)
         return 0;
@@ -41,7 +61,9 @@ function replaySession(turns, threshold, post) {
             continue;
         const d = t.ctx - prev.ctx;
         const g = d >= 0 ? d : usual;
-        if (ctx + g >= threshold) {
+        // Long silence with a big context: Claude Code compacts by itself, whatever the threshold is.
+        const lapsed = idle && t.ts - prev.ts >= IDLE_AFTER_MS && ctx >= IDLE_MIN_CTX;
+        if (lapsed || ctx + g >= threshold) {
             // The whole context goes in as input, a summary of about `post` tokens comes out, and the next turn
             // writes that summary to the cache again.
             cost += ctx * WEIGHT.input + post * WEIGHT.output + post * WEIGHT.write5m;
@@ -55,10 +77,11 @@ function replaySession(turns, threshold, post) {
     }
     return cost;
 }
-function replay(sessions, threshold, post) {
+/** Weighted cost of the sessions at a threshold. Exported for the tests of the engine. */
+export function replay(sessions, threshold, post, idle) {
     let total = 0;
     for (const s of sessions)
-        total += replaySession(s, threshold, post);
+        total += replaySession(s, threshold, post, idle);
     return total;
 }
 const roundTokens = (n) => Math.round(n / 1000) * 1000;
@@ -67,8 +90,21 @@ export function summarizeModel(rec, o) {
     const auto = rec.compactions.filter((c) => c.trigger === 'auto');
     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);
+    // Threshold-triggered compactions only: the idle ones say nothing about the size Claude Code was set to.
+    const autoPre = auto
+        .filter((c) => !c.idle)
+        .map((c) => c.pre)
+        .filter((n) => n > 0);
+    const idleCount = auto.filter((c) => c.idle).length;
+    // Replay idle compaction too once the records show Claude Code doing it for this Account.
+    const idleMode = idleCount > 0;
+    // What is in effect: the configured size, else where Claude Code compacts by default, else what it did.
+    // 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)
+        : (rec.defaultThreshold ?? median(autoPre));
     const base = {
         model: rec.model,
         calls,
@@ -79,6 +115,7 @@ export function summarizeModel(rec, o) {
             total: rec.compactions.length,
             auto: auto.length,
             manual: rec.compactions.filter((c) => c.trigger === 'manual').length,
+            idle: idleCount,
             preTokensP50: pre.length ? Math.round(median(pre)) : null,
             preTokensMax: pre.length ? Math.max(...pre) : null,
         },
@@ -96,27 +133,31 @@ 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);
-        const cost = replay(rec.sessions, threshold, post);
+    for (const threshold of sizes) {
+        const cost = replay(rec.sessions, threshold, post, idleMode);
         // On a tie the larger threshold wins: fewer compactions for the same cost.
         if (!best || cost < best.cost || (cost === best.cost && threshold > best.threshold))
             best = { threshold, cost };
     }
     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,
             reason: 'suggested',
             suggestion: { threshold: best.threshold, savedPercent: null, savedWeighted: null },
         };
-    const current = replay(rec.sessions, effective, post);
+    const current = replay(rec.sessions, effective, post, idleMode);
     const saved = current - best.cost;
     const percent = current > 0 ? (saved / current) * 100 : 0;
     if (percent < MIN_SAVING_PERCENT)

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

@@ -4,8 +4,8 @@ import type { Account, ReadContext, TuningResult } from '../../types.ts';
 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];
+/** `[ts, session, model, trigger, pre, post, silentMs]`; `silentMs` is how long the session was quiet before it (-1 unknown). */
+type CompactionRow = [number, string, string, string, number, number, number];
 /** What one session log contributes: only what the replay needs, never message text. */
 interface Summary {
     lines: number;

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

@@ -7,13 +7,19 @@ 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 { getOrCreate, IDLE_OBSERVED_MS, 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);
+/**
+ * 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 };
@@ -21,6 +27,8 @@ async function parseFile(file, since) {
     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();
+    // When each session last spoke, to tell a compaction that came after a long silence from one a size triggered.
+    const lastSpoke = new Map();
     try {
         const rl = createInterface({ input: createReadStream(file), crlfDelay: Number.POSITIVE_INFINITY });
         for await (const line of rl) {
@@ -44,6 +52,7 @@ async function parseFile(file, since) {
                 if (!Number.isFinite(ts) || ts < since || !pre || !post)
                     continue;
                 const t = m?.trigger;
+                const before = lastSpoke.get(session);
                 const entry = [
                     ts,
                     session,
@@ -51,12 +60,19 @@ async function parseFile(file, since) {
                     t === 'auto' || t === 'manual' ? t : 'unknown',
                     pre,
                     post,
+                    before === undefined ? -1 : ts - before,
                 ];
                 out.compactions.push(entry);
+                // The compaction itself is activity: a second one right after it did not follow a silence of its own.
+                lastSpoke.set(session, ts);
                 if (!entry[2])
                     orphans.set(session, [...(orphans.get(session) ?? []), entry]);
                 continue;
             }
+            if ((row?.type === 'assistant' || row?.type === 'user') &&
+                row.isSidechain !== true &&
+                Number.isFinite(ts))
+                lastSpoke.set(session, ts);
             if (row?.type !== 'assistant' || row.isSidechain === true)
                 continue;
             const usage = row.message?.usage;
@@ -95,7 +111,7 @@ async function parseFile(file, since) {
     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 });
+export const claudeTuningMemo = new FileMemo({ name: 'claude-tuning', version: 3 });
 /** The Account's configured Compaction Threshold, or null for the Host default. Reads exactly one key. */
 export async function readAutoCompactWindow(dir) {
     try {
@@ -157,7 +173,7 @@ export async function readClaudeTuning(account, ctx) {
     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]]));
+    const resolved = compactions.map((c) => (c[2] ? c : [c[0], c[1], sessionModel.get(c[1]) ?? '', c[3], c[4], c[5], c[6]]));
     // 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()) {
@@ -179,9 +195,25 @@ export async function readClaudeTuning(account, ctx) {
         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 };
+            .map((c) => ({
+            ts: c[0],
+            trigger: c[3],
+            pre: c[4],
+            post: c[5],
+            idle: c[3] === 'auto' && c[6] >= IDLE_OBSERVED_MS,
+        }));
+        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,9 @@ declare const en: {
     'tune.noCompactions': string;
     'tune.groupShared': string;
     'tune.basis': string;
+    'tune.outOfRange': string;
+    'tune.overrides': string;
+    'tune.idle': string;
     'tune.groupNone': string;
     'tune.details': string;
     'tune.detailsObserved': string;

package/dist/src/panel/i18n.js

@@ -253,6 +253,9 @@ 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.idle': '{n} of its {total} compactions came after the conversation sat idle for about an hour. Claude Code does that by itself, and this size does not change it.',
     '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 +280,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 +635,9 @@ const zh = {
     'tune.noCompactions': '这段时间没有压缩过。',
     'tune.groupShared': '这些账号共用一个设置文件，所以用同一个设置：{list}',
     'tune.basis': '按用得最多的 {model}（{ref}）来定。',
+    'tune.outOfRange': '文件里现在的大小（{size}）超出了 Claude Code 接受的范围（100K 到 1M）。请选「默认」或菜单里的某个大小来替换它。',
+    'tune.overrides': '这些模型自己保存了一个大小（用 /autocompact 设的），对它们来说那个优先于这里的设置：{list}',
+    'tune.idle': '它的 {total} 次压缩里有 {n} 次是对话安静了大约一小时之后发生的。这是 Claude Code 自己做的，这个大小改不了它。',
     'tune.groupNone': '用得还不够多，暂时给不出建议值。你仍然可以在下面自己选一个。',
     'tune.details': '各账号的详情',
     'tune.detailsObserved': '只做观测（没有可以改的设置）',
@@ -656,7 +662,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,17 @@ 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')))
+    if (pick) {
+      const seen = entries.find((e) => e.ref === pick.ref)
+      const stats = seen && seen.tuning.status === 'ok' ? seen.tuning.models.find((m) => m.model === pick.model) : null
+      if (stats && stats.compactions.idle > 0) rows.push(h('p', { class: 'muted small' }, t('tune.idle', { n: stats.compactions.idle, total: stats.compactions.total })))
+    } 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' },
@@ -1369,6 +1380,7 @@ const MAIN = String.raw `
       m.suggestion ? h('div', null, h('span', { class: 'muted small' }, t('tune.best')), h('div', { class: 'small' }, tokens(m.suggestion.threshold))) : null))
     if (!m.suggestion) rows.push(h('p', { class: 'muted small' }, t('tune.reason.' + m.reason, { min: minCalls })))
     rows.push(h('p', { class: 'muted small' }, m.compactions.total ? tn('tune.compactions', m.compactions.total, { size: tokens(m.compactions.preTokensP50 || 0) }) : t('tune.noCompactions')))
+    if (m.compactions.idle > 0) rows.push(h('p', { class: 'muted small' }, t('tune.idle', { n: m.compactions.idle, total: m.compactions.total })))
     return h('div', { class: 'tune-detail' }, rows)
   }
   function tuneDetails(entries, minCalls, label) {

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/dist/src/types.d.ts

@@ -261,6 +261,8 @@ export interface TuningModel {
         total: number;
         auto: number;
         manual: number;
+        /** Automatic compactions Claude Code did after the conversation sat idle; the size setting does not control them. */
+        idle: number;
         preTokensP50: number | null;
         preTokensMax: number | null;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sideby",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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/schemas/tune.json

@@ -100,6 +100,7 @@
                             "total",
                             "auto",
                             "manual",
+                            "idle",
                             "preTokensP50",
                             "preTokensMax"
                           ],
@@ -114,6 +115,10 @@
                             "manual": {
                               "type": "number"
                             },
+                            "idle": {
+                              "type": "number",
+                              "description": "Automatic compactions Claude Code did after the conversation sat idle; the size setting does not control them."
+                            },
                             "preTokensP50": {
                               "anyOf": [
                                 {

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.2"
   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.