sideby 0.13.1 → 0.15.0

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;
@@ -81,12 +81,15 @@ export interface PanelUpdate {
     checkedAt?: string;
     /** Why Update Checks are off; absent when they are on. */
     checksOff?: string;
+    checksOffCode?: update.ChecksOffCode;
     /** Config `update.auto`. */
     auto: boolean;
     method: {
         kind: update.InstallKind;
         canUpdate: boolean;
         reason?: string;
+        reasonCode?: update.ReasonCode;
+        reasonAt?: string;
     };
     /** The command an Update runs, or the one to run by hand when `canRun` is false. */
     command?: string;
@@ -94,7 +97,10 @@ export interface PanelUpdate {
     releaseNotes?: string;
     /** 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. */
+    /**
+     * The installed sideby skill, which an Update brings along (spec §3.23); absent when none is installed, and for a
+     * Local Build, which `pnpm local --off` brings back to npm together with the skill.
+     */
     skillUpdate?: import('../core/update.ts').SkillUpdatePlan;
 }
 export interface PanelState {
@@ -140,6 +146,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';
@@ -53,7 +53,7 @@ let checking = null;
  */
 async function updateState(rt, readOnly) {
     const current = packageVersion();
-    const off = update.checksOff(rt.env, rt.config);
+    const off = update.checksOffWhy(rt.env, rt.config);
     const cache = await update.readUpdateCache(rt.paths);
     if (!off && !readOnly && !checking && update.checkDue(cache, new Date()))
         checking = update.refreshUpdateCheck(rt.paths, rt.env).finally(() => {
@@ -61,15 +61,15 @@ 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);
+    const skillUpdate = method.kind === 'local'
+        ? null
+        : await update.skillUpdatePlan(rt.paths.home, plan?.available ? plan.latest : current).catch(() => null);
     return {
         current,
         ...(cache.latest ? { latest: cache.latest } : {}),
         available: Boolean(plan?.available),
         ...(cache.checkedAt ? { checkedAt: cache.checkedAt } : {}),
-        ...(off ? { checksOff: off } : {}),
+        ...(off ? { checksOff: off.text, checksOffCode: off.code } : {}),
         auto: rt.config.update?.auto === true,
         method: update.shownMethod(method),
         ...(plan ? { command: plan.command, releaseNotes: plan.releaseNotes } : {}),
@@ -86,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,
@@ -203,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);
@@ -303,8 +304,41 @@ 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 if (k === 'pinned') {
+            if (!v || typeof v !== 'object' || Array.isArray(v))
+                throw new HttpError(400, '"pinned" must be an object');
+            out.pinned = Object.fromEntries(Object.entries(v).map(([f, list]) => [f, names(list, `"pinned.${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;
@@ -632,6 +666,17 @@ export function createPanelHandler(opts) {
                 const shown = update.shownPlan(plan);
                 if (!optBool(body, 'confirm'))
                     return { ...shown, updated: false };
+                // The CLI is current and the skill is behind: `skill: true` updates it alone, as `sideby update --yes` does.
+                if (optBool(body, 'skill')) {
+                    if (plan.available || plan.method.kind === 'local')
+                        return { ...shown, updated: false, changed: true };
+                    const r = await update.applySkillOnly(rt.paths, plan.skill, rt.env);
+                    if (!r)
+                        return { ...shown, updated: false, changed: true };
+                    if (!r.ok)
+                        throw new UserError(r.message);
+                    return { ...shown, updated: false, skillUpdated: true, message: r.message };
+                }
                 // A confirmation that runs nothing always says why: the registry names another version (or none newer) now.
                 if (body.version !== plan.latest || !plan.available)
                     return { ...shown, updated: false, changed: true };
@@ -671,6 +716,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

@@ -19,7 +19,6 @@ declare const en: {
     'upd.runs': string;
     'upd.after': string;
     'upd.cannot': string;
-    'upd.skill': string;
     'upd.skillToo': string;
     'upd.skillDone': string;
     'upd.skillManaged': string;
@@ -50,6 +49,29 @@ declare const en: {
     'upd.done': string;
     'upd.reloading': string;
     'upd.restartHint': string;
+    'upd.skillLabel': string;
+    'upd.skillLater': string;
+    'upd.skillLabelLong': string;
+    'upd.skillBehind': string;
+    'upd.skillNoVer': string;
+    'upd.skillWhat': string;
+    'upd.skillNow': string;
+    'upd.skillDoneOnly': string;
+    'upd.skillChanged': string;
+    'upd.manual': string;
+    'upd.localAvail': string;
+    'upd.autoLocal': string;
+    'why.local-build': string;
+    'why.npx': string;
+    'why.volta': string;
+    'why.not-writable': string;
+    'why.project': string;
+    'why.source': string;
+    'why.skill-in-git': string;
+    'off.local-build': string;
+    'off.env': string;
+    'off.config': string;
+    'off.ci': string;
     'acct.title': string;
     'err.noAnswer': string;
     'err.session': string;
@@ -141,6 +163,45 @@ 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;
+    'sort.arrange': string;
+    'set.order': string;
+    'set.orderMine': string;
+    'set.orderDefault': string;
+    'order.resetButton': string;
+    'order.resetHint': string;
+    'order.reset': string;
+    'order.bar': string;
+    'order.done': string;
+    'order.saved': string;
+    'order.undo': string;
+    'order.undone': string;
+    'order.up': string;
+    'order.down': string;
+    'order.sameFamily': string;
+    'pin.pin': string;
+    'pin.unpin': string;
+    'pin.pinName': string;
+    'pin.unpinName': string;
+    'pin.full': string;
+    'pin.mark': string;
+    'pin.failed': 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;
@@ -176,8 +237,10 @@ declare const en: {
     'acct.signInHint': string;
     'acct.signedOutLabel': string;
     'acct.next': string;
-    'acct.nextHint': string;
-    'acct.nextLabel': string;
+    'acct.nextWhy': string;
+    'acct.nextCopy': string;
+    'stat.needWho': string;
+    'stat.needWhoMore': string;
     'acct.sameLogin': string;
     'acct.sameLoginHint': string;
     'acct.notInstalled': string;
@@ -199,13 +262,16 @@ declare const en: {
     'quota.dataFrom': string;
     'quota.asOf': string;
     'quota.sharedFrom': string;
-    'quota.readFrom': string;
-    'login.count': string;
     'login.label': string;
+    'login.dirs': string;
+    'login.explain': string;
+    'login.copyRun': string;
+    'login.showAs': string;
+    'login.showAsHint': string;
+    'login.shown': string;
+    'login.shownHint': string;
+    'login.section': string;
     'login.hint': string;
-    'login.sharedAbove': string;
-    'login.collapse': string;
-    'login.expand': string;
     'quota.noWindows': string;
     'quota.off': string;
     'quota.turnOnFamily': string;
@@ -226,6 +292,36 @@ declare const en: {
     'col.account': string;
     'col.used': string;
     'col.left': string;
+    'finding.link.real-file': string;
+    'finding.symlink-forbidden': string;
+    'finding.link.other-target': string;
+    'finding.link.dangling': string;
+    'finding.missing': string;
+    'finding.copy.type-mismatch': string;
+    'finding.copy.main-empty': string;
+    'finding.copy.stale': string;
+    'finding.unsupported-type': string;
+    'finding.json-key.symlink': string;
+    'finding.json-key.main-unreadable': string;
+    'finding.json-key.main-not-object': string;
+    'finding.json-key.not-object': string;
+    'finding.json-key.would-remove': string;
+    'finding.json-key.drift': string;
+    'finding.credential.mode': string;
+    'finding.path.invalid': string;
+    'finding.local.is-link': string;
+    'finding.api.needs-own': string;
+    'finding.main.missing': string;
+    'finding.name.backup-like': string;
+    'finding.secret.not-file': string;
+    'finding.plugin.error': string;
+    'finding.extra-check.error': string;
+    'finding.fixHint': string;
+    'finding.raw': string;
+    'win.5h': string;
+    'win.7d': string;
+    'quota.resetsIn': string;
+    'quota.staleShort': string;
     'col.tokens': string;
     'col.last': string;
     'col.health': string;
@@ -278,12 +374,44 @@ declare const en: {
     'fix.off': string;
     'fix.whyNoCheck': string;
     'fix.whyManual': string;
+    'fix.whyButton': string;
+    'fix.copyAi': string;
+    'fix.copyAiTitle': string;
+    'fix.promptShown': string;
+    'fix.promptLead': string;
+    'fix.promptHint': string;
+    'fix.promptFixFirst': string;
+    'fix.promptCheck': string;
     'fix.whyNothing': string;
     'fix.result': string;
     'fix.nothing': string;
     'menu.title': string;
     'menu.label': string;
     'menu.copyRun': string;
+    'menu.groupOpen': string;
+    'ai.title': string;
+    'ai.installed': string;
+    'ai.notInstalled': string;
+    'ai.intro': string;
+    'ai.ready': string;
+    'ai.install': string;
+    'ai.examples': string;
+    'ai.copy': string;
+    'ai.ask.quota': string;
+    'ai.ask.new': string;
+    'ai.ask.pin': string;
+    'ai.ask.fix': string;
+    'ai.ask.handoff': string;
+    'ai.ask.rc': string;
+    'ai.orderHint': string;
+    'ai.emptyHint': string;
+    'ai.how': string;
+    'att.quota': string;
+    'att.fix': string;
+    'att.check': string;
+    'menu.groupCopy': string;
+    'menu.groupManage': string;
+    'row.copyRun': string;
     'menu.copyAlias': string;
     'menu.copyLogin': string;
     'menu.copyDir': string;
@@ -452,6 +580,7 @@ declare const en: {
     'tune.hostDefaultLong': string;
     'tune.suggestedTag': string;
     'tune.useThis': string;
+    'tune.custom': string;
     'tune.working': string;
     'tune.confirmTitle': string;
     'tune.change': string;
@@ -476,6 +605,7 @@ declare const en: {
     'tpage.idle': string;
     'nf.title': string;
     'nf.intro': string;
+    'nf.more': string;
     'nf.tool': string;
     'nf.accounts.one': string;
     'nf.accounts.other': string;