sideby 0.13.0 → 0.14.0

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

@@ -1,5 +1,5 @@
-// How Grok Build takes part in a Handoff (spec §3.17). It has no public Quota, so it starts one only after a turn
-// failed at the limit. Interactive `grok` has no launch option for hooks: `sideby handoff setup grok` adds
+// How Grok Build takes part in a Handoff (spec §3.17). Since its Quota comes from its own CLI (spec §3.26), it starts
+// one at the Handoff Threshold, and still after a turn failed at the limit. Interactive `grok` has no launch option for hooks: `sideby handoff setup grok` adds
 // `hooks/sideby-handoff.json` to the Main Account and Doctor copies it to the others (verified 2026-10-09).
 // The hook inherits Grok's sandbox, so the profile decides whether a run may start or receive.
 import { mkdir, readFile, rm, rmdir } from 'node:fs/promises';
@@ -124,10 +124,22 @@ export function grokEligibility(policy, args, home) {
     };
 }
 const hookCommand = (event) => `sideby handoff-hook grok ${event}`;
-/** The whole file setup writes; teardown removes it only while it is still exactly this. */
+/**
+ * The file sideby 0.13 and earlier wrote: no `PostToolUse`, since Grok had no Quota to prepare a Handoff from then.
+ * Setup replaces it, teardown removes it (spec §3.26).
+ */
+export const GROK_HOOK_FILE_V1 = `${JSON.stringify({
+    hooks: {
+        Stop: [{ hooks: [{ type: 'command', command: hookCommand('Stop') }] }],
+        StopFailure: [{ hooks: [{ type: 'command', command: hookCommand('StopFailure'), timeout: 60 }] }],
+    },
+}, null, 2)}\n`;
+/** The whole file setup writes; teardown removes it only while it is still exactly this (or `GROK_HOOK_FILE_V1`). */
 export function grokHookFileText() {
     const hooks = {
         hooks: {
+            // Quota Pressure after each tool call, to prepare and start a Handoff before the limit (spec §3.26).
+            PostToolUse: [{ hooks: [{ type: 'command', command: hookCommand('PostToolUse') }] }],
             Stop: [{ hooks: [{ type: 'command', command: hookCommand('Stop') }] }],
             // Observation hooks get 5 seconds by default; putting a Brief together may take longer.
             StopFailure: [{ hooks: [{ type: 'command', command: hookCommand('StopFailure'), timeout: 60 }] }],
@@ -143,7 +155,8 @@ async function plan(ctx) {
     const have = await textOrNull(file);
     if (have === want)
         return { status: 'enabled', file, diff: '', message: `already set up in ${shown}` };
-    if (have !== null)
+    const upgrade = have === GROK_HOOK_FILE_V1;
+    if (have !== null && !upgrade)
         return {
             status: 'blocked',
             file,
@@ -153,19 +166,22 @@ async function plan(ctx) {
     const problem = await sidebyBinProblem(ctx.env, 'Grok runs `sideby handoff-hook` when a turn ends');
     if (problem)
         return { status: 'blocked', file, diff: '', message: problem };
+    const lines = (text, mark) => text
+        .trimEnd()
+        .split('\n')
+        .map((l) => `${mark}${l}`)
+        .join('\n');
     return {
         status: 'ready',
         file,
-        diff: `--- /dev/null\n+++ ${shown}\n${want
-            .trimEnd()
-            .split('\n')
-            .map((l) => `+${l}`)
-            .join('\n')}\n`,
-        message: `adds ${shown} so Grok tells sideby when a turn hits the usage limit; then run \`sideby doctor grok --fix\` to copy it to every Grok account; undo with \`sideby handoff teardown grok\``,
+        diff: upgrade
+            ? `--- ${shown}\n+++ ${shown}\n${lines(have, '-')}\n${lines(want, '+')}\n`
+            : `--- /dev/null\n+++ ${shown}\n${lines(want, '+')}\n`,
+        message: `${upgrade ? 'updates' : 'adds'} ${shown} so Grok tells sideby how full its quota is after each tool call and when a turn hits the usage limit; then run \`sideby doctor grok --fix\` to copy it to every Grok account; undo with \`sideby handoff teardown grok\``,
     };
 }
 export const grokHookSetup = {
-    summary: 'Adds one sideby hook file to ~/.grok/hooks so a Grok session that hits its usage limit can hand over.',
+    summary: 'Adds one sideby hook file to ~/.grok/hooks so a Grok session can hand over when its quota runs low or hits the limit.',
     plan,
     async apply(ctx) {
         const p = await plan(ctx);
@@ -175,13 +191,14 @@ export const grokHookSetup = {
         await writeFileAtomic(p.file, grokHookFileText(), 0o644);
         return { ...p, status: 'enabled' };
     },
+    earlierTexts: [GROK_HOOK_FILE_V1],
     async teardown(ctx) {
         const file = hookFile(ctx);
         const shown = tildify(file, ctx.home);
         const have = await textOrNull(file);
         if (have === null)
             return { ok: true, message: `${shown} is not there; nothing to undo` };
-        if (sha256(have) !== sha256(grokHookFileText()))
+        if (sha256(have) !== sha256(grokHookFileText()) && have !== GROK_HOOK_FILE_V1)
             return {
                 ok: false,
                 message: `${shown} changed since setup; delete it yourself if you no longer want it`,
@@ -196,7 +213,7 @@ export const grokHookSetup = {
     },
 };
 export const grokHandoff = {
-    starts: ['limit'],
+    starts: ['quota', 'limit'],
     promptArgs: promptAfterDashes,
     continueArgs: (args) => carryArgs(args, GROK_ARGS),
     resumeArgs: (id) => ['--resume', id],

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

@@ -5,6 +5,8 @@ import { BUILTIN_LOGOS } from '../logos.js';
 import { groupedEntryWrittenAt, resumeFlagSession } from '../shared/sessions.js';
 import { topLevelTomlString } from '../shared/toml.js';
 import { grokHandoff } from './handoff.js';
+import { grokQuotaFetch } from './quota.js';
+import { readGrokLogQuota } from './quota-log.js';
 // Grok's sandbox rejects these paths when they are symlinks; doctor quotes the Host's own words.
 const HOOKS_DIR_MESSAGE = 'Grok hooks directory has wrong type (expected real directory)';
 const REAL_FILE_MESSAGE = 'Grok hooks-paths registry has wrong type (expected real file)';
@@ -71,6 +73,9 @@ export const grokFamily = {
     },
     model: readModel,
     identity: grokIdentity,
+    // Quota (spec §3.26, ADR-0025): Grok's own billing lines in its log, and its CLI asked at most every 15 minutes.
+    readQuota: (account) => readGrokLogQuota(account.dir),
+    fetchQuota: grokQuotaFetch,
     resumedSession: resumeFlagSession,
     handoff: grokHandoff,
     // One directory per session, grouped by working directory: sessions/<encoded cwd>/<id>/.

package/dist/src/families/grok/quota-log.d.ts

@@ -0,0 +1,30 @@
+import { FileMemo } from '../../core/file-memo.ts';
+import type { QuotaResult, QuotaWindow } from '../../types.ts';
+export type GrokQuota = Extract<QuotaResult, {
+    status: 'ok';
+}>;
+export declare const GROK_BILLING_MSG = "billing: fetched credits config";
+/** How far back the CLI and the Panel look (Grok halves the file at 5 MB) and how far the handoff hook does. */
+export declare const LOG_READ_BYTES: number;
+export declare const HOOK_LOG_READ_BYTES: number;
+export declare function grokLogFile(accountDir: string): string;
+/**
+ * A Quota reading from Grok's billing answer: `{ config, subscription_tier }` from `_x.ai/billing`, or the log line's
+ * `ctx` (`{ config, subscriptionTier }`). Null when it holds no usable window.
+ */
+export declare function grokQuota(answer: unknown, observedAt: string, source: string): GrokQuota | null;
+/** The newest billing line in the last `maxBytes` of `file`, read backwards a chunk at a time; null when none. */
+export declare function lastGrokBilling(file: string, maxBytes: number, source?: string): Promise<GrokQuota | null>;
+/** The log's reading per Account directory; the file is read again only after it changed. */
+export declare const grokQuotaMemo: FileMemo<{
+    status: 'ok';
+    windows: QuotaWindow[];
+    observedAt: string;
+    source: string;
+    plan?: string;
+    from?: string;
+    fetched?: boolean;
+    fetchError?: string;
+} | null>;
+/** Grok's local Quota for one Account directory: its newest billing line. */
+export declare function readGrokLogQuota(accountDir: string): Promise<QuotaResult>;

package/dist/src/families/grok/quota-log.js

@@ -0,0 +1,140 @@
+// Grok Build's Quota (spec §3.26, ADR-0025): how its billing answer becomes a Quota reading, and the local copy Grok
+// writes into `$GROK_HOME/logs/unified.jsonl` at every session start and finished turn. Other lines of that file carry
+// the user id and the end of the bearer token, so only lines whose `msg` is exactly the billing one are parsed, and
+// only the Quota fields and the plan name are kept. Leaf module: the handoff hook reads the log too.
+import { open, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { FileMemo } from '../../core/file-memo.js';
+export const GROK_BILLING_MSG = 'billing: fetched credits config';
+const WEEKLY = 'USAGE_PERIOD_TYPE_WEEKLY';
+const WEEK_MINUTES = 7 * 24 * 60;
+const CHUNK = 64 * 1024;
+/** How far back the CLI and the Panel look (Grok halves the file at 5 MB) and how far the handoff hook does. */
+export const LOG_READ_BYTES = 8 * 1024 * 1024;
+export const HOOK_LOG_READ_BYTES = 512 * 1024;
+export function grokLogFile(accountDir) {
+    return join(accountDir, 'logs', 'unified.jsonl');
+}
+const record = (v) => typeof v === 'object' && v !== null && !Array.isArray(v) ? v : {};
+const num = (v) => {
+    const n = typeof v === 'string' && v.trim() ? Number(v) : v;
+    return typeof n === 'number' && Number.isFinite(n) ? n : undefined;
+};
+const str = (v) => (typeof v === 'string' && v ? v : undefined);
+/**
+ * A Quota reading from Grok's billing answer: `{ config, subscription_tier }` from `_x.ai/billing`, or the log line's
+ * `ctx` (`{ config, subscriptionTier }`). Null when it holds no usable window.
+ */
+export function grokQuota(answer, observedAt, source) {
+    const top = record(answer);
+    const config = record(top.config);
+    const period = record(config.currentPeriod);
+    const weekly = period.type === WEEKLY;
+    const end = Date.parse(str(period.end) ?? str(config.billingPeriodEnd) ?? '');
+    if (!Number.isFinite(end))
+        return null;
+    const start = Date.parse(str(period.start) ?? str(config.billingPeriodStart) ?? '');
+    let used = num(config.creditUsagePercent) ?? num(top.creditUsagePercent);
+    if (used === undefined) {
+        const spent = num(record(config.used).val);
+        const limit = num(record(config.monthlyLimit).val);
+        if (spent !== undefined && limit)
+            used = (spent / limit) * 100;
+        else if (weekly)
+            used = 0;
+    }
+    if (used === undefined)
+        return null;
+    let minutes = Number.isFinite(start) && end > start ? Math.round((end - start) / 60_000) : undefined;
+    if (weekly)
+        minutes = WEEK_MINUTES;
+    if (minutes === undefined)
+        return null;
+    const days = Math.max(1, Math.round(minutes / 1440));
+    const window = {
+        label: minutes === WEEK_MINUTES ? '7d' : `${days}d`,
+        windowMinutes: minutes,
+        usedPercent: Math.max(0, Math.min(100, used)),
+        resetsAt: new Date(end).toISOString(),
+    };
+    const plan = str(top.subscription_tier) ?? str(top.subscriptionTier);
+    return { status: 'ok', windows: [window], observedAt, source, ...(plan ? { plan } : {}) };
+}
+/** The Quota of one log line, or null for every line that is not Grok's billing line. */
+function billingLine(line, source) {
+    // A cheap check first: most lines are never parsed.
+    if (!line.includes(GROK_BILLING_MSG))
+        return null;
+    let data;
+    try {
+        data = record(JSON.parse(line));
+    }
+    catch {
+        return null;
+    }
+    const ts = str(data.ts);
+    if (data.msg !== GROK_BILLING_MSG || !ts || !Number.isFinite(Date.parse(ts)))
+        return null;
+    const ctx = record(data.ctx);
+    return grokQuota({ config: ctx.config, subscriptionTier: ctx.subscriptionTier }, new Date(Date.parse(ts)).toISOString(), source);
+}
+/** The newest billing line in the last `maxBytes` of `file`, read backwards a chunk at a time; null when none. */
+export async function lastGrokBilling(file, maxBytes, source = file) {
+    let fh;
+    try {
+        fh = await open(file, 'r');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const size = (await fh.stat()).size;
+        let pos = size;
+        // The start of the earliest line read so far, which may continue in the chunk before it.
+        let head = Buffer.alloc(0);
+        while (pos > 0 && size - pos < maxBytes) {
+            const len = Math.min(CHUNK, pos);
+            pos -= len;
+            const buf = Buffer.alloc(len);
+            await fh.read(buf, 0, len, pos);
+            const chunk = Buffer.concat([buf, head]);
+            const cut = pos > 0 ? chunk.indexOf(0x0a) : -1;
+            head = cut >= 0 ? chunk.subarray(0, cut) : Buffer.alloc(0);
+            const lines = chunk
+                .subarray(cut + 1)
+                .toString('utf8')
+                .split('\n');
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const q = billingLine(lines[i], source);
+                if (q)
+                    return q;
+            }
+        }
+        return null;
+    }
+    finally {
+        await fh.close();
+    }
+}
+/** The log's reading per Account directory; the file is read again only after it changed. */
+export const grokQuotaMemo = new FileMemo();
+/** Grok's local Quota for one Account directory: its newest billing line. */
+export async function readGrokLogQuota(accountDir) {
+    const file = grokLogFile(accountDir);
+    const none = {
+        status: 'unavailable',
+        reason: 'no-session',
+        detail: 'Grok has not reported the quota of this account yet',
+    };
+    let st;
+    try {
+        st = await stat(file);
+    }
+    catch {
+        return none;
+    }
+    const memo = grokQuotaMemo.pass(accountDir);
+    const q = await memo.get(file, st, () => lastGrokBilling(file, LOG_READ_BYTES, 'logs/unified.jsonl'));
+    memo.done();
+    return q ?? none;
+}

package/dist/src/families/grok/quota.d.ts

@@ -0,0 +1,5 @@
+import type { Account, QuotaFetch, QuotaFetchContext, QuotaResult } from '../../types.ts';
+export declare const GROK_QUOTA_ARGS: readonly ['agent', '--no-leader', 'stdio'];
+export declare const GROK_BILLING_METHOD = "_x.ai/billing";
+export declare function fetchGrokQuota(account: Account, ctx: QuotaFetchContext): Promise<QuotaResult>;
+export declare const grokQuotaFetch: QuotaFetch;

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

@@ -0,0 +1,112 @@
+// Asks the Grok CLI for an Account's Quota (spec §3.26, ADR-0025): `grok agent --no-leader stdio` answers the ACP
+// extension method `_x.ai/billing` with the request it makes itself, using the login of the `GROK_HOME` it runs under.
+// sideby never reads the token and never sends a request of its own; no session is started.
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { createInterface } from 'node:readline';
+import { grokQuota } from './quota-log.js';
+export const GROK_QUOTA_ARGS = ['agent', '--no-leader', 'stdio'];
+export const GROK_BILLING_METHOD = '_x.ai/billing';
+/** How long Grok may take to exit after its stdin closes before sideby ends it. */
+const EXIT_GRACE_MS = 10_000;
+/** How long to wait before asking again after a failed answer, while Grok refreshes an expired token. */
+const RETRY_MS = 1500;
+const METHOD_NOT_FOUND = -32601;
+const AUTH_REQUIRED = -32000;
+const failed = (detail) => ({ status: 'unavailable', reason: 'fetch-failed', detail });
+/** Why an error answer gave no Quota, and what to do. Grok's own message is never repeated (only matched). */
+function errorDetail(account, error) {
+    if (error.code === METHOD_NOT_FOUND)
+        return 'this Grok version cannot report the quota; update Grok, then refresh';
+    if (error.code === AUTH_REQUIRED) {
+        const text = `${typeof error.data === 'string' ? error.data : ''} ${typeof error.message === 'string' ? error.message : ''}`;
+        if (text.includes('grok.com'))
+            return 'this account is signed in with an API key, which has no subscription quota';
+        return `Grok is not signed in for this account; run \`sideby login ${account.ref}\``;
+    }
+    return `Grok could not get the quota from xAI (error ${typeof error.code === 'number' ? error.code : 'unknown'}); sideby asks again later, or start Grok in this account once`;
+}
+export async function fetchGrokQuota(account, ctx) {
+    if (ctx.signal.aborted)
+        return failed('the quota check was stopped');
+    const child = spawn('grok', [...GROK_QUOTA_ARGS], {
+        cwd: tmpdir(),
+        env: { ...ctx.hostEnv, GROK_DISABLE_AUTOUPDATER: '1' },
+        stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    const stop = () => {
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill('SIGTERM');
+    };
+    const finish = () => {
+        // Grok exits by itself once its stdin closes; it is ended only when it does not.
+        child.stdin.end();
+        const timer = setTimeout(stop, EXIT_GRACE_MS);
+        timer.unref();
+        child.once('exit', () => clearTimeout(timer));
+        child.unref();
+    };
+    ctx.signal.addEventListener('abort', stop, { once: true });
+    try {
+        return await new Promise((resolve) => {
+            const lines = createInterface({ input: child.stdout });
+            let done = false;
+            const settle = (r) => {
+                if (done)
+                    return;
+                done = true;
+                lines.close();
+                resolve(r);
+            };
+            child.on('error', (err) => settle(failed(err.code === 'ENOENT'
+                ? 'Grok is not installed or not on PATH; install it, then refresh'
+                : `could not start Grok (${err.code ?? 'error'})`)));
+            // `close` comes after the last stdout line, so an answer written just before exiting still counts.
+            child.on('close', () => settle(failed('Grok exited without answering; sideby asks again later')));
+            ctx.signal.addEventListener('abort', () => settle(failed('the quota check was stopped')), {
+                once: true,
+            });
+            child.stdin.on('error', () => { });
+            let id = 1;
+            const ask = () => child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method: GROK_BILLING_METHOD, params: {} })}\n`);
+            lines.on('line', (line) => {
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    return;
+                }
+                if (msg?.id !== id)
+                    return;
+                if (msg.error && typeof msg.error === 'object') {
+                    const error = msg.error;
+                    // A login whose token just expired fails once: Grok sends the old token and refreshes it as it starts
+                    // (seen 2026-10-17), so the same process is asked once more after a moment.
+                    if (id === 1 && error.code !== METHOD_NOT_FOUND && error.code !== AUTH_REQUIRED) {
+                        id = 2;
+                        setTimeout(() => {
+                            if (!done)
+                                ask();
+                        }, RETRY_MS).unref();
+                        return;
+                    }
+                    settle(failed(errorDetail(account, error)));
+                    return;
+                }
+                const q = grokQuota(msg.result, ctx.now.toISOString(), 'grok agent');
+                settle(q ?? failed('Grok answered in a form sideby does not recognise; update sideby'));
+            });
+            ask();
+        });
+    }
+    finally {
+        ctx.signal.removeEventListener('abort', stop);
+        finish();
+    }
+}
+export const grokQuotaFetch = {
+    everyMinutes: 15,
+    summary: "Grok asks xAI for each account's weekly quota, at most every 15 minutes",
+    fetch: fetchGrokQuota,
+};

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

@@ -1,11 +1,11 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { type AppProfileStatus } from '../core/app-profiles.ts';
 import { type BrowserReport } from '../core/browser-profiles.ts';
-import { type HandoffSettings } from '../core/config.ts';
+import { type DisplayConfig, type HandoffSettings } from '../core/config.ts';
 import { type AccountModel } from '../core/model-choice.ts';
 import type { RemoteControlGroup } from '../core/remote-control.ts';
 import * as update from '../core/update.ts';
-import type { AccountStatus, DoctorHistory, FamilyInfo, Runtime } from '../runtime.ts';
+import type { AccountStatus, DoctorHistory, FamilyInfo, QuotaCheckInfo, Runtime } from '../runtime.ts';
 import type { Account, FamilyLogo, QuotaResult, QuotaSetupPlan, UsageResult } from '../types.ts';
 import { type PanelTheme } from './theme.ts';
 export declare const PANEL_VERSION: string;
@@ -92,8 +92,10 @@ export interface PanelUpdate {
     command?: string;
     canRun: boolean;
     releaseNotes?: string;
-    /** The command that updates the sideby skill, which sideby never runs itself. */
+    /** The command that installs the sideby skill by hand. */
     skill: string;
+    /** The installed sideby skill, which an Update brings along (spec §3.23); absent when none is installed. */
+    skillUpdate?: import('../core/update.ts').SkillUpdatePlan;
 }
 export interface PanelState {
     schemaVersion: 1;
@@ -138,6 +140,10 @@ export interface PanelState {
      * Absent without Claude, Codex or Grok subscription Accounts. Nothing of the browser is read while `enabled` is false.
      */
     browser?: BrowserReport;
+    /** Display Order (spec §3.25): config `display` as it is, an empty object when the user never dragged. */
+    display: DisplayConfig;
+    /** Families that ask for Quota in a way that costs a request (spec §3.26), with their switch; absent when none. */
+    quotaChecks?: QuotaCheckInfo[];
 }
 /** The `handoff` map of the Panel state, from the statuses and Quota already read for the page. */
 export declare function handoffByFamily(rt: Runtime, accounts: readonly PanelAccount[], now: Date): Record<string, string>;

package/dist/src/panel/handler.js

@@ -4,7 +4,7 @@ import { aliasesByAccount } from '../core/accounts.js';
 import { listAppProfiles, openAppProfile, removeAppProfile, } from '../core/app-profiles.js';
 import { FAVICON_SVG, ICON_SVG } from '../core/brand-mark.js';
 import { browserReport, openInBrowser, setBrowserSignIns, } from '../core/browser-profiles.js';
-import { aliasArgs, aliasRefs, editConfigUpdate } from '../core/config.js';
+import { aliasArgs, aliasRefs, editConfigUpdate, } from '../core/config.js';
 import { openDesktopApp, withDesktopApps } from '../core/desktop-app.js';
 import { UserError } from '../core/errors.js';
 import { planHandoff } from '../core/handoff.js';
@@ -61,6 +61,9 @@ async function updateState(rt, readOnly) {
         });
     const method = await update.installMethod(rt.env);
     const plan = cache.latest ? update.shownPlan(update.planFrom(method, current, cache.latest, rt.env)) : null;
+    const skillUpdate = await update
+        .skillUpdatePlan(rt.paths.home, plan?.available ? plan.latest : current)
+        .catch(() => null);
     return {
         current,
         ...(cache.latest ? { latest: cache.latest } : {}),
@@ -72,6 +75,7 @@ async function updateState(rt, readOnly) {
         ...(plan ? { command: plan.command, releaseNotes: plan.releaseNotes } : {}),
         canRun: Boolean(plan?.canRun),
         skill: SKILL_INSTALL,
+        ...(skillUpdate ? { skillUpdate } : {}),
     };
 }
 /** The `handoff` map of the Panel state, from the statuses and Quota already read for the page. */
@@ -82,7 +86,7 @@ export function handoffByFamily(rt, accounts, now) {
         // Count logins, not directories: a Same Login group (spec §3.21) is one Quota, so it alone is no alternative.
         const subs = list.filter((a) => a.kind === 'subscription');
         const logins = subs.filter((a, i) => !subs.slice(0, i).some((b) => a.sameLogin?.includes(b.ref))).length;
-        if (!f.readQuota || logins < 2)
+        if ((!f.readQuota && !f.fetchQuota) || logins < 2)
             continue;
         const plan = planHandoff(id, list.map((a) => ({
             ref: a.ref,
@@ -199,7 +203,8 @@ async function accountState(rt, account, families) {
     };
     const [status, quota, usage] = await Promise.all([
         guard(rt.status(account)),
-        guard(rt.quota(account)),
+        // The kept answer of a Quota check shows now; a stale one is asked again behind it (spec §3.26).
+        guard(rt.quota(account, { fetch: 'background' })),
         guard(rt.usage(account)),
     ]);
     const fam = families.find((f) => f.id === account.family);
@@ -299,8 +304,36 @@ async function buildState(rt, opts) {
         },
         ...(upd ? { update: upd } : {}),
         ...(showBrowser ? { browser } : {}),
+        display: rt.displayOrder(),
+        ...(rt.quotaChecks().length ? { quotaChecks: rt.quotaChecks() } : {}),
     };
 }
+/** The `display` of a /api/display-order body: null, or string lists only; anything else is refused. */
+function displayBody(body) {
+    const d = body.display;
+    if (d === null)
+        return undefined;
+    const names = (v, what) => {
+        if (!Array.isArray(v) || !v.every((x) => typeof x === 'string' && x))
+            throw new HttpError(400, `${what} must be a list of names`);
+        return [...v];
+    };
+    if (!d || typeof d !== 'object' || Array.isArray(d))
+        throw new HttpError(400, '"display" must be an object or null');
+    const out = {};
+    for (const [k, v] of Object.entries(d)) {
+        if (k === 'families')
+            out.families = names(v, '"families"');
+        else if (k === 'accounts') {
+            if (!v || typeof v !== 'object' || Array.isArray(v))
+                throw new HttpError(400, '"accounts" must be an object');
+            out.accounts = Object.fromEntries(Object.entries(v).map(([f, list]) => [f, names(list, `"accounts.${f}"`)]));
+        }
+        else
+            throw new HttpError(400, `unknown key "${k}"`);
+    }
+    return out;
+}
 /** The `change` of a /api/handoff/configure body, with every field checked; unknown fields are refused. */
 function handoffChange(body) {
     const c = body.change;
@@ -643,6 +676,7 @@ export function createPanelHandler(opts) {
                     message: r.message,
                     restartedPanel: r.restartedPanel,
                     refreshedApp: r.refreshedApp,
+                    ...(r.skillUpdated === undefined ? {} : { skillUpdated: r.skillUpdated }),
                 };
             },
         },
@@ -666,6 +700,34 @@ export function createPanelHandler(opts) {
                 };
             },
         },
+        // Display Order (spec §3.25): replaces config `display`, or removes it for null. The drag itself is the preview.
+        '/api/display-order': {
+            async run(body) {
+                const display = displayBody(body);
+                const rt = await getRuntime();
+                return { display: await rt.setDisplayOrder(display) };
+            },
+        },
+        // Asks every Family that fetches Quota again now, and waits (spec §3.26); the page reloads its state after.
+        '/api/quota/refresh': {
+            async run() {
+                const rt = await getRuntime();
+                await rt.refreshQuota();
+                return { ok: true };
+            },
+        },
+        // A Family's Quota check on or off: config `quota.check.<family>` (spec §3.26).
+        '/api/quota/check': {
+            async run(body) {
+                const family = optString(body, 'family');
+                if (!family)
+                    throw new HttpError(400, '"family" is required');
+                if (typeof body.on !== 'boolean')
+                    throw new HttpError(400, '"on" must be true or false');
+                const rt = await getRuntime();
+                return { family, ...(await rt.setQuotaCheck(family, body.on)) };
+            },
+        },
         // Undo for the quota setup above; the Runtime turns a teardown that throws into `{ ok: false, message }`.
         '/api/quota/teardown': {
             async run(body) {

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

@@ -20,6 +20,9 @@ declare const en: {
     'upd.after': string;
     'upd.cannot': string;
     'upd.skill': string;
+    'upd.skillToo': string;
+    'upd.skillDone': string;
+    'upd.skillManaged': string;
     'upd.checksOff': string;
     'upd.latest': string;
     'upd.latestNow': string;
@@ -138,6 +141,26 @@ declare const en: {
     'sort.pressure': string;
     'sort.name': string;
     'sort.recent': string;
+    'sort.manual': string;
+    'order.handle': string;
+    'order.moveFamily': string;
+    'order.moveAccount': string;
+    'order.position': string;
+    'order.failed': string;
+    'order.resetButton': string;
+    'order.resetHint': string;
+    'order.reset': string;
+    'quota.fetchFailed': string;
+    'quota.checkOff': string;
+    'quota.checkOffHint': string;
+    'quota.fetchedFrom': string;
+    'quota.lastCheckFailed': string;
+    'quota.refreshFailed': string;
+    'quota.checkOnToast': string;
+    'quota.checkOffToast': string;
+    'quota.checkFailed': string;
+    'set.quotaCheck': string;
+    'set.quotaCheckHint': string;
     'tb.quota': string;
     'tb.used': string;
     'tb.left': string;
@@ -196,13 +219,10 @@ declare const en: {
     'quota.dataFrom': string;
     'quota.asOf': string;
     'quota.sharedFrom': string;
-    'quota.readFrom': string;
-    'login.count': string;
     'login.label': string;
+    'login.shared': string;
+    'login.sharedHint': string;
     'login.hint': string;
-    'login.sharedAbove': string;
-    'login.collapse': string;
-    'login.expand': string;
     'quota.noWindows': string;
     'quota.off': string;
     'quota.turnOnFamily': string;