sideby 0.7.0 → 0.8.0

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261014T084812-64e992"}
+{"id":"20261014T102906-2ab079"}

package/dist/src/cli/commands.js

@@ -71,8 +71,10 @@ export async function cmdList(a, io) {
             io.out(`Run ${installed.map((f) => f.bin).join(' or ')} once, then \`sideby new <family> <name>\`.`);
     }
     else {
+        // `= main`: the other Accounts of its Same Login, which share its Quota (spec §3.21).
+        const sameMark = (refs) => refs?.length ? ` ${c.dim(`= ${refs.map((r) => r.slice(r.indexOf(':') + 1)).join(', ')}`)}` : '';
         const rows = statuses.map((s) => [
-            c.bold(s.ref),
+            `${c.bold(s.ref)}${sameMark(s.sameLogin)}`,
             s.isMain ? 'main' : s.kind === 'api' ? c.cyan('api') : 'sub',
             s.login === 'logged-in'
                 ? c.green('✓')
@@ -87,6 +89,8 @@ export async function cmdList(a, io) {
             ...(hasDesktop ? [s.desktopApp?.running ? c.green('open') : c.dim('—')] : []),
         ]);
         io.out(table(rows, ['ACCOUNT', 'TYPE', 'LOGIN', 'EMAIL', 'MODEL', 'DIR', ...(hasDesktop ? ['DESKTOP'] : [])]));
+        if (statuses.some((s) => s.sameLogin?.length))
+            io.out(c.dim('\n= <account>: signed in as the same login as that account, so they share one quota.'));
         io.out(c.dim('\nsideby run <account>  ·  sideby new <family> <name>  ·  sideby quota  ·  sideby ui'));
     }
     for (const s of statuses)
@@ -216,6 +220,8 @@ export async function cmdNext(a, io) {
     }
     const now = rt.readContext().now;
     const note = (e) => {
+        if (e.sameLoginAs)
+            return `same login as ${e.sameLoginAs}, which shares its quota; skipped`;
         if (e.state === 'ready')
             return `fullest window ${Math.round(e.pressure ?? 0)}%`;
         if (e.state === 'unknown')
@@ -239,11 +245,13 @@ export async function cmdNext(a, io) {
         const why = plan.earliestReset
             ? `every ${family} account is at its limit; ${plan.earliestReset.ref} is back at ${clock(plan.earliestReset.at, now)}`
             : `no ${family} account can be used now`;
+        const same = plan.accounts.filter((e) => e.sameLoginAs).map((e) => e.ref);
+        const sameNote = same.length ? `; ${same.join(', ')} share the quota of ${plan.from}` : '';
         const next = [
             ...(out.length ? [`sign in with \`${out.join('` or `')}\``] : []),
             ...(apiLeft ? ['add --include-api to use an API account'] : []),
         ];
-        io.err(c.yellow(`\n${why}${next.length ? `; ${next.join(', or ')}` : ''}.`));
+        io.err(c.yellow(`\n${why}${sameNote}${next.length ? `; ${next.join(', or ')}` : ''}.`));
         return 1;
     }
     const picked = plan.accounts.find((e) => e.ref === plan.pick);
@@ -530,7 +538,11 @@ export async function cmdQuota(a, io) {
         return 0;
     }
     const now = new Date();
-    io.out(table(rows.map((r) => [c.bold(r.ref), quotaText(r.quota, now), usageText(r.usage)]), ['ACCOUNT', 'QUOTA', `USAGE (${USAGE_DAYS}d)`]));
+    io.out(table(rows.map((r) => [
+        c.bold(r.ref),
+        `${quotaText(r.quota, now)}${r.quota.status === 'ok' && r.quota.from ? c.dim(` read from ${r.quota.from} (same login)`) : ''}`,
+        usageText(r.usage),
+    ]), ['ACCOUNT', 'QUOTA', `USAGE (${USAGE_DAYS}d)`]));
     for (const r of rows)
         if (r.quota.status === 'unavailable' && r.quota.detail)
             io.out(c.dim(`${r.ref}: ${r.quota.detail}`));

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

@@ -36,6 +36,9 @@ const AccountStatus = Type.Intersect([
         identity: Type.Optional(Type.Object({ email: Type.Optional(Str), org: Type.Optional(Str) }, {
             description: "Who the account is signed in as, from the host's login file: identity fields only, never a token (ADR-0003).",
         })),
+        sameLogin: Type.Optional(Type.Array(Str, {
+            description: 'The other accounts signed in as the same login (same family, email and organization), which share one quota (spec §3.21). Absent when there are none.',
+        })),
         problems: Type.Optional(Type.Array(Str)),
         desktopApp: Type.Optional(Type.Object({ app: Str, installed: Type.Boolean(), running: Type.Boolean() }, {
             description: "The family's desktop app for this account (macOS, subscription accounts of claude and codex): whether it is installed and whether this account's own window runs now. Open it with `sideby desktop <account>`.",
@@ -106,6 +109,9 @@ const Quota = Type.Union([
         observedAt: Str,
         source: Str,
         plan: Type.Optional(Str),
+        from: Type.Optional(Type.String({
+            description: 'The account this reading was taken from, when it is another account of the same login (spec §3.21); observedAt is its time.',
+        })),
     }),
     Type.Object({ status: Type.Literal('unavailable'), reason: Str, detail: Type.Optional(Str) }),
 ]);
@@ -263,6 +269,9 @@ export const OUTPUT_SCHEMAS = {
     next: Type.Object({
         schemaVersion: Version,
         family: Str,
+        from: Type.Optional(Type.String({
+            description: 'The account `sideby next` runs in (SIDEBY_ACCOUNT, set by sideby for the sessions it starts), when it belongs to this family.',
+        })),
         pick: Type.Union([Str, Type.Null()], {
             description: 'The recommended account; null when none can be used now (exit code 1).',
         }),
@@ -283,6 +292,12 @@ export const OUTPUT_SCHEMAS = {
             }),
             resetsAt: Type.Optional(Type.String({ description: 'For full: when its last full window resets.' })),
             observedAt: Type.Optional(Type.String({ description: "When the account's quota was recorded (its last session)." })),
+            quotaFrom: Type.Optional(Type.String({
+                description: 'The account the quota was read from, when it is another account of the same login.',
+            })),
+            sameLoginAs: Type.Optional(Type.String({
+                description: 'The current account (`from`), when this one is signed in as the same login: it shares that quota and is never picked.',
+            })),
         }), { description: 'Every account of the family, best first.' }),
         hasQuota: Type.Boolean({
             description: 'False when no account has quota data: the pick is then a guess, and `sideby next` does not start it (exit 1).',

package/dist/src/core/desktop-app.js

@@ -139,11 +139,22 @@ export function instanceOf(app, appData, procs) {
         return after === '' || after.startsWith(' ') || after === '/' || after.startsWith('/ ');
     });
 }
-/** Brings a running app to the front through NSRunningApplication (no Automation permission needed). */
+/**
+ * Brings a running app to the front as a Dock click does: a reopen event (`aevt/rapp`) to that one process, so an
+ * app whose windows were all closed opens one again, then NSRunningApplication activation. Activation alone makes
+ * such an app frontmost with nothing on screen (seen 2026-10-14 with the Codex app). Neither needs the Automation
+ * permission.
+ */
 async function activate(deps, pid) {
+    const p = Math.trunc(pid);
     const script = [
         "ObjC.import('AppKit');",
-        `const app = $.NSRunningApplication.runningApplicationWithProcessIdentifier(${Math.trunc(pid)});`,
+        `const app = $.NSRunningApplication.runningApplicationWithProcessIdentifier(${p});`,
+        'if (!app.isNil()) {',
+        `  const target = $.NSAppleEventDescriptor.descriptorWithProcessIdentifier(${p});`,
+        '  const reopen = $.NSAppleEventDescriptor.appleEventWithEventClassEventIDTargetDescriptorReturnIDTransactionID(0x61657674, 0x72617070, target, -1, 0);',
+        '  reopen.sendEventWithOptionsTimeoutError(1, 5, null);',
+        '}',
         "app.isNil() ? 'missing' : (app.activateWithOptions($.NSApplicationActivateAllWindows | $.NSApplicationActivateIgnoringOtherApps) ? 'ok' : 'refused')",
     ].join(' ');
     const r = await deps.exec(OSASCRIPT, ['-l', 'JavaScript', '-e', script]);

package/dist/src/core/handoff-run.d.ts

@@ -10,6 +10,8 @@ export interface HandoffIo {
 }
 /** How long the Host gets to exit after SIGTERM (time for its SessionEnd hooks) before sideby gives up. */
 export declare const EXIT_GRACE_MS = 10000;
+/** Accounts the decision left out and why (spec §3.21), as `; skipped claude:main (…)`, or ''. */
+export declare function skippedText(d: HandoffDecision): string;
 export declare function explain(d: HandoffDecision): string;
 /** `args` with `extra` before the first `--`, so a user's own `--` cannot turn sideby's options into prompt text. */
 export declare function beforeDashes(args: readonly string[], extra: readonly string[]): string[];

package/dist/src/core/handoff-run.js

@@ -18,14 +18,20 @@ const PLAN_REFRESH_MS = 60_000;
 const READY_POLL_MS = 1000;
 const hookCommand = (family) => (event) => `sideby handoff-hook ${family} ${event}`;
 const clock = (iso) => new Date(iso).toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
+/** Accounts the decision left out and why (spec §3.21), as `; skipped claude:main (…)`, or ''. */
+export function skippedText(d) {
+    if (d.kind === 'wait' || !d.skipped?.length)
+        return '';
+    return `; skipped ${d.skipped.map((x) => `${x.ref} (${x.reason})`).join(', ')}`;
+}
 export function explain(d) {
     if (d.kind === 'wait')
         return `the full window resets at ${clock(d.until)}, so waiting beats moving on`;
     if (d.kind === 'none')
-        return d.earliestReset
+        return `${d.earliestReset
             ? `${d.reason}; ${d.earliestReset.ref} is back first, at ${clock(d.earliestReset.at)}`
-            : d.reason;
-    return `next: ${d.ref}`;
+            : d.reason}${skippedText(d)}`;
+    return `next: ${d.ref}${skippedText(d)}`;
 }
 /** Resolves with the ready file once the hook writes one for `runId`; `stop()` ends the watch. */
 function watchReady(dir, runId) {
@@ -287,7 +293,7 @@ opts = {}) {
         await writeJsonFile(join(dir, FILES.chain), hops);
         await rm(join(dir, FILES.ready), { force: true });
         await rm(join(dir, FILES.request), { force: true });
-        io.err(`sideby: ${account.ref} saved its session and is handing over because ${WHY[ready.trigger]}; next is ${decision.ref}. Brief: ${done.path}`);
+        io.err(`sideby: ${account.ref} saved its session and is handing over because ${WHY[ready.trigger]}; next is ${decision.ref}${skippedText(decision)}. Brief: ${done.path}`);
         if (settings.countdownSeconds > 0 &&
             (await countdown(io, settings.countdownSeconds, decision.ref, account.ref))) {
             io.err(`sideby: staying in ${account.ref}`);

package/dist/src/core/handoff-select.d.ts

@@ -9,14 +9,22 @@ export interface SelectCandidate {
     login: LoginState | 'not-needed';
     quota: QuotaResult;
     identity?: AccountIdentity;
+    /** The other Accounts of its Same Login (spec §3.21); they share its Quota. */
+    sameLogin?: readonly string[];
     /** Whether the Account's Host is on PATH. */
     installed: boolean;
     /** Whether its Family can start as the next Account (has `handoff`, and the run would be eligible). */
     receive: boolean;
 }
+/** An Account the Handoff Order lists that was left out, and why (spec §3.21). */
+export interface SkippedAccount {
+    ref: string;
+    reason: string;
+}
 export type HandoffDecision = {
     kind: 'pick';
     ref: string;
+    skipped?: SkippedAccount[];
 } | {
     kind: 'wait';
     until: string;
@@ -27,6 +35,7 @@ export type HandoffDecision = {
         ref: string;
         at: string;
     };
+    skipped?: SkippedAccount[];
 };
 /** Organizations when both have one, else email domains when both have one, else the same. */
 export declare function sameOrganization(a?: AccountIdentity, b?: AccountIdentity): boolean;

package/dist/src/core/handoff-select.js

@@ -70,7 +70,14 @@ export function selectNext(input) {
         const ranked = planHandoff(origin.family, own, now, { includeApi: true }).accounts.map((e) => byRef.get(e.ref));
         list = [...ranked, ...input.candidates.filter((c) => c.family !== origin.family && c.kind === 'api')];
     }
-    const eligible = list.filter((c) => !used.has(c.ref) &&
+    // The same login shares the origin's Quota, so taking over there gains nothing (spec §3.21).
+    const sameLogin = new Set(origin.sameLogin ?? []);
+    const skipped = list
+        .filter((c) => sameLogin.has(c.ref))
+        .map((c) => ({ ref: c.ref, reason: `same login as ${origin.ref}, so it shares the same quota` }));
+    const withSkipped = skipped.length ? { skipped } : {};
+    const eligible = list.filter((c) => !sameLogin.has(c.ref) &&
+        !used.has(c.ref) &&
         c.installed &&
         c.receive &&
         // An API account pays per request, so it gets past no vendor's limit: sameFamily does not apply to it.
@@ -80,7 +87,7 @@ export function selectNext(input) {
     const first = states.find(({ e }) => e.state === 'ready' || e.state === 'unknown') ??
         states.find(({ e }) => e.state === 'api');
     if (first)
-        return { kind: 'pick', ref: first.c.ref };
+        return { kind: 'pick', ref: first.c.ref, ...withSkipped };
     const full = states
         .filter(({ e }) => e.state === 'full' && e.resetsAt)
         .sort((a, b) => Date.parse(a.e.resetsAt) - Date.parse(b.e.resetsAt))[0];
@@ -90,5 +97,6 @@ export function selectNext(input) {
             ? 'every account that may take over is full or signed out'
             : 'no account may take over',
         ...(full ? { earliestReset: { ref: full.c.ref, at: full.e.resetsAt } } : {}),
+        ...withSkipped,
     };
 }

package/dist/src/core/handoff-status.js

@@ -68,6 +68,18 @@ export async function handoffStatus(rt) {
         }
         if (unknown.length)
             notes.push(`order names ${unknown.join(', ')}, which sideby cannot find; they are skipped`);
+        // Same Login (spec §3.21): one note per group, so a skipped account in the order is no surprise.
+        const seen = new Set();
+        for (const a of accounts.filter((x) => x.family === f.id)) {
+            if (seen.has(a.ref))
+                continue;
+            const peers = await rt.sameLogin(a);
+            if (!peers.length)
+                continue;
+            for (const r of [a.ref, ...peers])
+                seen.add(r);
+            notes.push(`${[a.ref, ...peers].join(', ')} are signed in as the same login and share one quota; a handoff from one never goes to another`);
+        }
         families.push({
             family: f.id,
             starts,

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

@@ -7,6 +7,8 @@ export interface HandoffCandidate {
     kind: Account['kind'];
     login: LoginState | 'not-needed';
     quota: QuotaResult;
+    /** The other Accounts of its Same Login (spec §3.21). */
+    sameLogin?: readonly string[];
 }
 export interface HandoffEntry {
     ref: string;
@@ -18,9 +20,18 @@ export interface HandoffEntry {
     resetsAt?: string;
     /** When the Quota was recorded; it is only as fresh as the Account's last session. */
     observedAt?: string;
+    /** The Account the Quota was read from, when it is another Account of the same login (spec §3.21). */
+    quotaFrom?: string;
+    /**
+     * The current Account, when this one is signed in as the same login (spec §3.21): it shares that Quota, so it is
+     * never picked.
+     */
+    sameLoginAs?: string;
 }
 export interface HandoffPlan {
     family: string;
+    /** The Account this process runs in (`SIDEBY_ACCOUNT`), when it belongs to the Family. */
+    from?: string;
     /** The recommended Account, or null when none can be used now. */
     pick: string | null;
     /** Every Account, best first; the ones that cannot be picked come last. */
@@ -38,4 +49,5 @@ export interface HandoffPlan {
 }
 export declare function planHandoff(family: string, candidates: readonly HandoffCandidate[], now: Date, opts?: {
     includeApi?: boolean;
+    from?: string;
 }): HandoffPlan;

package/dist/src/core/handoff.js

@@ -9,6 +9,7 @@ function entry(c, now) {
         kind: c.kind,
         pressure,
         ...(c.quota.status === 'ok' ? { observedAt: c.quota.observedAt } : {}),
+        ...(c.quota.status === 'ok' && c.quota.from ? { quotaFrom: c.quota.from } : {}),
     };
     if (c.kind === 'api')
         return { ...base, state: 'api' };
@@ -29,6 +30,7 @@ function entry(c, now) {
     return { ...base, state: 'full', ...(last === undefined ? {} : { resetsAt: new Date(last).toISOString() }) };
 }
 export function planHandoff(family, candidates, now, opts = {}) {
+    const current = opts.from ? candidates.find((c) => c.ref === opts.from) : undefined;
     const byRef = new Map(candidates.map((c) => [c.ref, c]));
     const tie = (a, b) => {
         const x = byRef.get(a.ref);
@@ -36,15 +38,22 @@ export function planHandoff(family, candidates, now, opts = {}) {
         return Number(y.isMain) - Number(x.isMain) || x.name.localeCompare(y.name, undefined, { numeric: true });
     };
     const accounts = candidates
-        .map((c) => entry(c, now))
-        .sort((a, b) => ORDER[a.state] - ORDER[b.state] ||
+        .map((c) => {
+        const e = entry(c, now);
+        return current?.sameLogin?.includes(c.ref) ? { ...e, sameLoginAs: current.ref } : e;
+    })
+        .sort((a, b) => 
+    // A Same Login partner of the current Account can never be picked, so it goes with the others that cannot.
+    Number(Boolean(a.sameLoginAs)) - Number(Boolean(b.sameLoginAs)) ||
+        ORDER[a.state] - ORDER[b.state] ||
         (a.state === 'ready' ? a.pressure - b.pressure : 0) ||
         (a.state === 'full' ? resetTime(a) - resetTime(b) || 0 : 0) ||
         tie(a, b));
-    const usable = (e) => e.state === 'ready' || e.state === 'unknown' || (e.state === 'api' && Boolean(opts.includeApi));
+    const usable = (e) => !e.sameLoginAs &&
+        (e.state === 'ready' || e.state === 'unknown' || (e.state === 'api' && Boolean(opts.includeApi)));
     const pick = accounts.find(usable)?.ref ?? null;
     const hasQuota = accounts.some((e) => e.state === 'ready' || e.state === 'full');
-    const plan = { family, pick, accounts, hasQuota };
+    const plan = { family, ...(current ? { from: current.ref } : {}), pick, accounts, hasQuota };
     if (pick === null) {
         const first = accounts.find((e) => e.state === 'full' && e.resetsAt);
         if (first?.resetsAt)

package/dist/src/core/same-login.d.ts

@@ -0,0 +1,24 @@
+import type { Account, AccountIdentity, QuotaResult } from '../types.ts';
+/**
+ * Families whose Identity tells one Quota apart. Codex is left out: its Identity is an email only, and one email can
+ * belong to several ChatGPT workspaces, each with its own Quota (ADR-0016).
+ */
+export declare const SAME_LOGIN_FAMILIES: ReadonlySet<string>;
+export interface LoginMember {
+    ref: string;
+    family: string;
+    kind: Account['kind'];
+    identity?: AccountIdentity;
+}
+/**
+ * Whether two Accounts are the same login: same Family (one that groups), both subscriptions, the same email, and the
+ * same organization (both have one and it is equal, or neither has one). Without an email nothing groups.
+ */
+export declare function isSameLogin(a: LoginMember, b: LoginMember): boolean;
+/** Ref → the other refs of its Same Login, in the order given; Accounts without one are left out. */
+export declare function sameLoginGroups(members: readonly LoginMember[]): Map<string, string[]>;
+/**
+ * The Quota an Account of a Same Login shows: the freshest `ok` reading of the group (its own wins a tie), marked
+ * with `from` when it is another member's. Without any `ok` reading the Account keeps its own result.
+ */
+export declare function sharedQuota(ref: string, readings: ReadonlyMap<string, QuotaResult>, peers: readonly string[]): QuotaResult;

package/dist/src/core/same-login.js

@@ -0,0 +1,52 @@
+/**
+ * Families whose Identity tells one Quota apart. Codex is left out: its Identity is an email only, and one email can
+ * belong to several ChatGPT workspaces, each with its own Quota (ADR-0016).
+ */
+export const SAME_LOGIN_FAMILIES = new Set(['claude']);
+const norm = (s) => s?.trim().toLowerCase();
+/**
+ * Whether two Accounts are the same login: same Family (one that groups), both subscriptions, the same email, and the
+ * same organization (both have one and it is equal, or neither has one). Without an email nothing groups.
+ */
+export function isSameLogin(a, b) {
+    if (a.ref === b.ref || a.family !== b.family || !SAME_LOGIN_FAMILIES.has(a.family))
+        return false;
+    if (a.kind !== 'subscription' || b.kind !== 'subscription')
+        return false;
+    const ea = norm(a.identity?.email);
+    if (!ea || ea !== norm(b.identity?.email))
+        return false;
+    return norm(a.identity?.org) === norm(b.identity?.org);
+}
+/** Ref → the other refs of its Same Login, in the order given; Accounts without one are left out. */
+export function sameLoginGroups(members) {
+    const out = new Map();
+    for (const a of members) {
+        const peers = members.filter((b) => isSameLogin(a, b)).map((b) => b.ref);
+        if (peers.length)
+            out.set(a.ref, peers);
+    }
+    return out;
+}
+/**
+ * The Quota an Account of a Same Login shows: the freshest `ok` reading of the group (its own wins a tie), marked
+ * with `from` when it is another member's. Without any `ok` reading the Account keeps its own result.
+ */
+export function sharedQuota(ref, readings, peers) {
+    const own = readings.get(ref) ?? { status: 'unavailable', reason: 'unrecognized' };
+    let best;
+    for (const r of [ref, ...peers]) {
+        const q = readings.get(r);
+        if (q?.status !== 'ok')
+            continue;
+        const t = Date.parse(q.observedAt);
+        if (!Number.isFinite(t))
+            continue;
+        if (!best || t > best.t)
+            best = { ref: r, q, t };
+    }
+    if (!best || best.ref === ref)
+        return own;
+    const { from: _from, ...reading } = best.q;
+    return { ...reading, from: best.ref };
+}

package/dist/src/panel/handler.js

@@ -44,7 +44,10 @@ export function handoffByFamily(rt, accounts, now) {
     const out = {};
     for (const [id, f] of rt.families) {
         const list = accounts.filter((a) => a.family === id);
-        if (!f.readQuota || list.filter((a) => a.kind === 'subscription').length < 2)
+        // 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)
             continue;
         const plan = planHandoff(id, list.map((a) => ({
             ref: a.ref,

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

@@ -134,6 +134,8 @@ declare const en: {
     'acct.next': string;
     'acct.nextHint': string;
     'acct.nextLabel': string;
+    'acct.sameLogin': string;
+    'acct.sameLoginHint': string;
     'acct.notInstalled': string;
     'acct.readError': string;
     'acct.installHost': string;
@@ -148,6 +150,7 @@ declare const en: {
     'quota.resetNoData': string;
     'quota.dataFrom': string;
     'quota.asOf': string;
+    'quota.sharedFrom': string;
     'quota.noWindows': string;
     'quota.off': string;
     'quota.turnOnFamily': string;

package/dist/src/panel/i18n.js

@@ -136,6 +136,8 @@ const en = {
     'acct.next': 'Next',
     'acct.nextHint': 'The account to move on to when this family runs low: most quota left. Click to copy `sideby next {family}`.',
     'acct.nextLabel': '{ref} is next: copy `sideby next {family}`',
+    'acct.sameLogin': 'Same login as {names}',
+    'acct.sameLoginHint': 'Signed in as the same login as {names}. The vendor counts one quota for all of them, so they show the same quota and a handoff never moves between them.',
     'acct.notInstalled': 'Tool missing',
     'acct.readError': 'Could not read this account.',
     'acct.installHost': '{host} is not installed on this machine. {link}',
@@ -150,6 +152,7 @@ const en = {
     'quota.resetNoData': 'Window reset · no new data since {date}',
     'quota.dataFrom': 'Data from {ago}',
     'quota.asOf': 'As of {ago}',
+    'quota.sharedFrom': 'Same login as {name}; quota read from {name}, {ago}',
     'quota.noWindows': 'No quota windows reported.',
     'quota.off': 'Quota not on',
     'quota.turnOnFamily': 'Turn on quota',
@@ -593,6 +596,8 @@ const zh = {
     'acct.next': '下一个',
     'acct.nextHint': '这个家族额度用完时换到这里：剩余额度最多。点击复制 `sideby next {family}`。',
     'acct.nextLabel': '{ref} 是下一个：复制 `sideby next {family}`',
+    'acct.sameLogin': '与 {names} 同一登录',
+    'acct.sameLoginHint': '与 {names} 用同一个身份登录。供应商只算一份额度，所以它们显示同一份额度，交接也不会在它们之间进行。',
     'acct.notInstalled': '未安装工具',
     'acct.readError': '无法读取这个账号。',
     'acct.installHost': '本机没有安装 {host}。{link}',
@@ -607,6 +612,7 @@ const zh = {
     'quota.resetNoData': '已重置，{date}后无新数据',
     'quota.dataFrom': '数据来自 {ago}',
     'quota.asOf': '截至 {ago}',
+    'quota.sharedFrom': '与 {name} 同一登录；额度读自 {name}，{ago}',
     'quota.noWindows': '没有额度窗口数据。',
     'quota.off': '额度未开启',
     'quota.turnOnFamily': '开启额度显示',

package/dist/src/panel/page-logic.d.ts

@@ -26,7 +26,11 @@ export interface LogicAccount {
         }[];
         observedAt?: string;
         plan?: string;
+        /** The Account the reading came from, when it is another Account of the same login (spec §3.21). */
+        from?: string;
     };
+    /** The other Accounts of its Same Login (spec §3.21). */
+    sameLogin?: string[];
     usage?: {
         status: string;
         inputTokens?: number;
@@ -65,7 +69,8 @@ export declare function passedWindow(w: {
 export declare function quotaPressure(a: LogicAccount, now: number): number;
 /**
  * Why an Account needs a look, most serious first: `error`, `health-fail`, `signed-out`, `not-installed`,
- * `quota-high` (a live window at or over the warning level), `health-warn`. Empty when all is well.
+ * `quota-high` (a live window at or over the warning level), `health-warn`. Empty when all is well. A Quota read from
+ * another Account of the same login (`quota.from`, spec §3.21) is that Account's warning, so it counts once per group.
  */
 export declare function attentionReasons(a: LogicAccount, health: {
     fail: number;

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

@@ -55,7 +55,8 @@ export function quotaPressure(a, now) {
 }
 /**
  * Why an Account needs a look, most serious first: `error`, `health-fail`, `signed-out`, `not-installed`,
- * `quota-high` (a live window at or over the warning level), `health-warn`. Empty when all is well.
+ * `quota-high` (a live window at or over the warning level), `health-warn`. Empty when all is well. A Quota read from
+ * another Account of the same login (`quota.from`, spec §3.21) is that Account's warning, so it counts once per group.
  */
 export function attentionReasons(a, health, now, warn) {
     const out = [];
@@ -68,7 +69,7 @@ export function attentionReasons(a, health, now, warn) {
     if (a.hostInstalled === false)
         out.push('not-installed');
     const q = a.quota;
-    if (q && q.status === 'ok' && q.windows)
+    if (q && q.status === 'ok' && q.windows && !q.from)
         for (const w of q.windows) {
             const reset = Date.parse(w.resetsAt);
             if (Number.isFinite(reset) && reset <= now)

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

@@ -837,7 +837,9 @@ const MAIN = String.raw `
     if (q.status !== 'ok') return h('div', { class: 'quota' }, quotaNote(a, q))
     const stale = isStale(q.observedAt, now)
     const wins = q.windows || []
-    return h('div', { class: 'quota' + (stale ? ' is-stale' : ''), title: stale ? null : t('quota.dataFrom', { ago: ago(q.observedAt) }) },
+    // A reading borrowed from another Account of the same login says where it came from (spec §3.21).
+    const from = q.from ? t('quota.sharedFrom', { name: refName(q.from), ago: ago(q.observedAt) }) : null
+    return h('div', { class: 'quota' + (stale ? ' is-stale' : ''), title: from || (stale ? null : t('quota.dataFrom', { ago: ago(q.observedAt) })) },
       wins.length ? cols.map((c) => {
         const w = wins.find((x) => x.label === c)
         return w ? meter(w, now, stale, q.observedAt) : noMeter(c)
@@ -884,6 +886,9 @@ const MAIN = String.raw `
         return h('span', { class: 'tag tag-alias', title: args ? t('acct.aliasArgs', { args: args.join(' ') }) : t('acct.alias') }, x)
       }),
       a.kind === 'api' ? h('span', { class: 'tag tag-warn', title: t('tip.api.body') }, t('acct.api')) : null,
+      a.sameLogin && a.sameLogin.length
+        ? h('span', { class: 'tag', title: t('acct.sameLoginHint', { names: a.sameLogin.map(refName).join(', ') }) }, t('acct.sameLogin', { names: a.sameLogin.map(refName).join(', ') }))
+        : null,
       isNext(a)
         ? h('button', { class: 'tag tag-ok tag-btn', type: 'button', title: t('acct.nextHint', { family: a.family }), 'aria-label': t('acct.nextLabel', { ref: a.ref, family: a.family }), onclick: () => copyText('sideby next ' + a.family) }, t('acct.next'))
         : null,
@@ -892,6 +897,8 @@ const MAIN = String.raw `
         : null,
       a.hostInstalled === false ? h('span', { class: 'tag tag-warn' }, t('acct.notInstalled')) : null)
   }
+  // The name part of a ref (claude:001 gives 001), as rows show other Accounts of the same Family.
+  function refName(ref) { return String(ref).slice(String(ref).indexOf(':') + 1) }
   // Who the account is signed in as, under its name; masked while "Hide emails" is on.
   function emailLine(a) {
     const id = a.identity

package/dist/src/runtime.d.ts

@@ -103,6 +103,10 @@ export interface AccountStatus extends Account {
     model?: string;
     /** Who the Account is signed in as (email, organization), when its Family can tell. */
     identity?: AccountIdentity;
+    /**
+     * The other Accounts signed in as the same login, which share its Quota (spec §3.21); absent when there are none.
+     */
+    sameLogin?: string[];
     /** Plugin errors met while reading this Account (for example an unreadable settings file). */
     problems?: string[];
     /**
@@ -197,7 +201,13 @@ export interface Runtime {
      * (spec §3.15). Throws UnknownFamilyError, or a UserError when the Family cannot route sessions.
      */
     resumeLaunch(familyId: string, userArgs: readonly string[]): Promise<ResumeLaunch>;
+    /**
+     * The Account's Quota. For an Account of a Same Login (spec §3.21) it is the group's freshest reading, with `from`
+     * naming the Account it was read from when that is another one.
+     */
     quota(account: Account): Promise<QuotaResult>;
+    /** The other Accounts signed in as the same login as this one (spec §3.21), in discovery order; empty when none. */
+    sameLogin(account: Account): Promise<string[]>;
     usage(account: Account): Promise<UsageResult>;
     /** Estimated Compaction Threshold per model for one Account (spec §3.18); read-only. */
     tuning(account: Account): Promise<TuningResult>;

package/dist/src/runtime.js

@@ -14,6 +14,7 @@ import { prepareLaunch, which } from './core/launch.js';
 import { memoStore } from './core/memo-store.js';
 import { resolvePaths } from './core/paths.js';
 import { findResumeRoute } from './core/resume.js';
+import { SAME_LOGIN_FAMILIES, sameLoginGroups, sharedQuota } from './core/same-login.js';
 import { shareMeaning } from './core/share-meaning.js';
 import { SHELLS, shellInitScript, writeShellInitFile, } from './core/shell-init.js';
 import { groupSuggestion, MAX_COMPACT_WINDOW, MIN_COMPACT_WINDOW, } from './core/tuning.js';
@@ -84,6 +85,56 @@ export async function createRuntime(opts = {}) {
             out.push(...(await discoverAccounts(f, paths.home, ignore)));
         return out;
     };
+    /** Same Login groups (spec §3.21) among `list`: ref → the other refs. Only Families that group take part. */
+    const groupsOf = async (list) => {
+        const members = await Promise.all(list
+            .filter((a) => a.kind === 'subscription' && SAME_LOGIN_FAMILIES.has(a.family) && families.has(a.family))
+            .map(async (a) => {
+            const identity = await readIdentity(familyOf(a.family), a);
+            return { ref: a.ref, family: a.family, kind: a.kind, ...(identity ? { identity } : {}) };
+        }));
+        return sameLoginGroups(members);
+    };
+    /** The Accounts of `account`'s Same Login, other than itself; reads only its own Family. */
+    const peersOf = async (account) => {
+        const f = families.get(account.family);
+        if (!f || account.kind === 'api' || !SAME_LOGIN_FAMILIES.has(f.id))
+            return [];
+        const list = await discoverAccounts(f, paths.home, ignore);
+        const peers = (await groupsOf(list)).get(account.ref) ?? [];
+        return list.filter((a) => peers.includes(a.ref));
+    };
+    /** Every Account's Quota as shown (shared within a Same Login), reading each Account's own cache once. */
+    const quotasOf = async (list) => {
+        const [own, groups] = await Promise.all([
+            Promise.all(list.map(async (a) => [a.ref, await ownQuota(a)])).then((e) => new Map(e)),
+            groupsOf(list),
+        ]);
+        return new Map(list.map((a) => [a.ref, sharedQuota(a.ref, own, groups.get(a.ref) ?? [])]));
+    };
+    const ownQuota = async (account) => {
+        if (account.kind === 'api')
+            return { status: 'unavailable', reason: 'api-account' };
+        const f = familyOf(account.family);
+        if (!f.readQuota)
+            return { status: 'unavailable', reason: 'no-source' };
+        await memos.ready();
+        try {
+            const q = await f.readQuota(account, readContext());
+            // Only sideby marks a reading as borrowed from another Account (spec §3.21); a reader's own `from` is dropped.
+            if (q.status === 'ok' && q.from !== undefined) {
+                const { from: _from, ...own } = q;
+                return own;
+            }
+            return q;
+        }
+        catch (err) {
+            return { status: 'unavailable', reason: 'unrecognized', detail: err.message };
+        }
+        finally {
+            memos.saveSoon();
+        }
+    };
     const loginOf = async (a) => {
         if (a.kind === 'api')
             return 'not-needed';
@@ -208,13 +259,14 @@ export async function createRuntime(opts = {}) {
                     return undefined;
                 }
             };
-            const [installed, login, model, identity] = await Promise.all([
+            const [installed, login, model, identity, peers] = await Promise.all([
                 which(f.bin, env),
                 account.kind === 'api'
                     ? undefined
                     : safe('login state', f.loginState && (() => f.loginState(account))),
                 safe('model', f.model && (() => f.model(account))),
                 readIdentity(f, account),
+                peersOf(account).catch(() => []),
             ]);
             return {
                 ...account,
@@ -223,6 +275,7 @@ export async function createRuntime(opts = {}) {
                 login: account.kind === 'api' ? 'not-needed' : (login ?? 'unknown'),
                 ...(model ? { model } : {}),
                 ...(identity ? { identity } : {}),
+                ...(peers.length ? { sameLogin: peers.map((p) => p.ref) } : {}),
                 ...(problems.length ? { problems } : {}),
             };
         },
@@ -436,21 +489,13 @@ export async function createRuntime(opts = {}) {
             };
         },
         async quota(account) {
-            if (account.kind === 'api')
-                return { status: 'unavailable', reason: 'api-account' };
-            const f = familyOf(account.family);
-            if (!f.readQuota)
-                return { status: 'unavailable', reason: 'no-source' };
-            await memos.ready();
-            try {
-                return await f.readQuota(account, readContext());
-            }
-            catch (err) {
-                return { status: 'unavailable', reason: 'unrecognized', detail: err.message };
-            }
-            finally {
-                memos.saveSoon();
-            }
+            const peers = await peersOf(account);
+            if (!peers.length)
+                return ownQuota(account);
+            return (await quotasOf([account, ...peers])).get(account.ref);
+        },
+        async sameLogin(account) {
+            return (await peersOf(account)).map((a) => a.ref);
         },
         async usage(account) {
             const f = familyOf(account.family);
@@ -556,21 +601,36 @@ export async function createRuntime(opts = {}) {
                 throw new UserError(`no ${f.title} accounts yet; create one with \`sideby new ${f.id} <name>\``, {
                     code: 'no-accounts',
                 });
-            // Only the login state and Quota: no identity, model or Host lookups are needed to rank.
+            // Login state, Quota and Same Login (spec §3.21): no model or Host lookups are needed to rank.
+            const [quotas, groups] = await Promise.all([quotasOf(list), groupsOf(list)]);
             const candidates = await Promise.all(list.map(async (a) => {
-                const [login, quota] = await Promise.all([loginOf(a), rt.quota(a)]);
-                return { ref: a.ref, name: a.name, isMain: a.isMain, kind: a.kind, login, quota };
+                const peers = groups.get(a.ref);
+                return {
+                    ref: a.ref,
+                    name: a.name,
+                    isMain: a.isMain,
+                    kind: a.kind,
+                    login: await loginOf(a),
+                    quota: quotas.get(a.ref),
+                    ...(peers ? { sameLogin: peers } : {}),
+                };
             }));
-            return planHandoff(f.id, candidates, readContext().now, o);
+            // The current Account: the one sideby started this process from, when it belongs to this Family.
+            const current = env.SIDEBY_ACCOUNT;
+            const from = current && list.some((a) => a.ref === current) ? current : undefined;
+            return planHandoff(f.id, candidates, readContext().now, { ...o, ...(from ? { from } : {}) });
         },
         handoffSettings: () => handoffSettings(config),
         async handoffDecision(origin, used, opts = {}) {
-            const candidates = await Promise.all((await accounts()).map(async (a) => {
+            const all = await accounts();
+            const [quotas, groups] = await Promise.all([quotasOf(all), groupsOf(all)]);
+            const candidates = await Promise.all(all.map(async (a) => {
                 const f = familyOf(a.family);
-                const [installed, login, quota, identity] = await Promise.all([
+                const quota = quotas.get(a.ref);
+                const peers = groups.get(a.ref);
+                const [installed, login, identity] = await Promise.all([
                     which(f.bin, env),
                     loginOf(a),
-                    rt.quota(a),
                     readIdentity(f, a),
                 ]);
                 let receive = false;
@@ -590,6 +650,7 @@ export async function createRuntime(opts = {}) {
                     login,
                     quota,
                     ...(identity ? { identity } : {}),
+                    ...(peers ? { sameLogin: peers } : {}),
                     installed: installed !== null,
                     receive,
                 };

package/dist/src/types.d.ts

@@ -214,6 +214,11 @@ export type QuotaResult = {
     observedAt: string;
     source: string;
     plan?: string;
+    /**
+     * Set by sideby, never by a Family's reader: the Account this reading was taken from, when it is another
+     * Account signed in as the same login (spec §3.21). `observedAt` is that Account's time.
+     */
+    from?: string;
 } | {
     status: 'unavailable';
     reason: QuotaUnavailableReason;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sideby",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "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/list.json

@@ -147,6 +147,13 @@
                 },
                 "description": "Who the account is signed in as, from the host's login file: identity fields only, never a token (ADR-0003)."
               },
+              "sameLogin": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "description": "The other accounts signed in as the same login (same family, email and organization), which share one quota (spec §3.21). Absent when there are none."
+              },
               "problems": {
                 "type": "array",
                 "items": {

package/schemas/next.json

@@ -17,6 +17,10 @@
     "family": {
       "type": "string"
     },
+    "from": {
+      "type": "string",
+      "description": "The account `sideby next` runs in (SIDEBY_ACCOUNT, set by sideby for the sessions it starts), when it belongs to this family."
+    },
     "pick": {
       "anyOf": [
         {
@@ -97,6 +101,14 @@
           "observedAt": {
             "type": "string",
             "description": "When the account's quota was recorded (its last session)."
+          },
+          "quotaFrom": {
+            "type": "string",
+            "description": "The account the quota was read from, when it is another account of the same login."
+          },
+          "sameLoginAs": {
+            "type": "string",
+            "description": "The current account (`from`), when this one is signed in as the same login: it shares that quota and is never picked."
           }
         }
       },

package/schemas/quota.json

@@ -86,6 +86,10 @@
                   },
                   "plan": {
                     "type": "string"
+                  },
+                  "from": {
+                    "type": "string",
+                    "description": "The account this reading was taken from, when it is another account of the same login (spec §3.21); observedAt is its time."
                   }
                 }
               },

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.7.0"
+  version: "0.8.0"
   requires:
     bins: [sideby, node]
   cliHelp: sideby --help

package/skills/sideby/references/handoff.md

@@ -15,7 +15,7 @@ Use this when the user says an account hit its 5-hour or weekly limit ("usage li
    | `full` | A live window is at 85% or more; `resetsAt` is when it is usable again | No |
    | `logged-out` | Needs `sideby login <ref>` | No |
 
-   Each entry's `observedAt` says when its quota was recorded. If `hasQuota` is `false`, no account has quota data: the pick is only a guess, so say so and suggest turning quota on (see the routing table in SKILL.md) or letting the user choose.
+   Each entry's `observedAt` says when its quota was recorded (`quotaFrom` when it was read from another account of the same login). An entry with `sameLoginAs` is signed in as the same login as the account you run in: it shares that quota and is never picked. If `hasQuota` is `false`, no account has quota data: the pick is only a guess, so say so and suggest turning quota on (see the routing table in SKILL.md) or letting the user choose.
 3. Give the user the command to run in their own terminal: `sideby next <family>` (starts the pick) or `sideby run <pick>`. Host arguments go after `--`. Do not run it yourself.
 4. Offer a handoff note: the new session starts empty, because each account keeps its own sessions. Write a short note the user can paste into it: the goal, what is done, what is in progress, the files involved, and the next step.
 

package/skills/sideby/references/quota.md

@@ -11,4 +11,6 @@ Accounts with their own (not linked) `settings.json` show quota `not-enabled` un
 
 After setup, each account shows quota once it has had one session with a reply. Codex quota needs no setup: sideby reads it from Codex's own session files.
 
+Two Claude accounts signed in as the same login (same email and organization; `sameLogin` in `sideby list --json`) share one quota: both show the freshest reading, and `quota.from` names the account it was read from. Explain that to the user rather than calling the numbers wrong; usage stays per account, and sideby never merges or deletes either directory.
+
 Usage (7-day tokens) is read by sideby itself from Claude Code and Codex local records; no ccusage is needed. Grok and pi have no quota or usage source.