Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

feat(desktop): 供应商组先用快重置的配额,本机任务与外部任务同一套策略 (#6066)

Lizi779b5237917a
diff --git a/apps/desktop/src/main/provider-group/__tests__/directory.test.ts b/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
index a9a7b65523..bfd11fd37a 100644
--- a/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
@@ -229,6 +229,36 @@ describe('resolveMembers', () => {
expect(resolved.reportedRunning).toBeUndefined();
});
+ it.each(['resolve', 'reject'] as const)('bounds local load reads and ignores a late %s', async (outcome) => {
+ vi.useFakeTimers();
+ try {
+ const directory = createProviderGroupDirectory(deps({
+ localRunning: async () => {
+ await new Promise<void>((resolve) => setTimeout(resolve, 4_000));
+ if (outcome === 'reject') throw new Error('db busy');
+ return 6;
+ },
+ }));
+ const done = vi.fn();
+ void directory.resolveMembers('anthropic', {
+ strategy: 'least',
+ autoSwitch: true,
+ members: [{ key: 'local', kind: 'local', agentDeviceId: null, providerId: 'anthropic', limit: 4, weight: 1, paused: false }],
+ }).then(done);
+ await vi.advanceTimersByTimeAsync(1_000);
+ expect(done).toHaveBeenCalledTimes(1);
+ const [resolved] = done.mock.calls[0][0];
+ expect(resolved).toMatchObject({ state: 'ok', member: { key: 'local' } });
+ expect(resolved.reportedRunning).toBeUndefined();
+ await vi.advanceTimersByTimeAsync(3_000);
+ expect(done).toHaveBeenCalledTimes(1);
+ expect(resolved.reportedRunning).toBeUndefined();
+ expect(vi.getTimerCount()).toBe(0);
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
it('names members for activity records without the sharer’s computer name', () => {
const directory = createProviderGroupDirectory(deps());
const member = (patch: Partial<ProviderGroupConfig['members'][number]>) => ({
@@ -375,6 +405,36 @@ describe('resolving members quickly when choosing a computer (2026-10-11)', () =
}
});
+ it('keeps the local computer when its catalog is slow and its load read stalls', async () => {
+ vi.useFakeTimers();
+ try {
+ const local: ProviderGroupMember = {
+ key: 'local', kind: 'local', agentDeviceId: null, providerId: 'anthropic', limit: 4, weight: 1, paused: false,
+ };
+ const directory = createProviderGroupDirectory({
+ ...slowDeps(),
+ listLocalProviders: async () => {
+ await new Promise<void>((resolve) => setTimeout(resolve, 2_500));
+ return [view('anthropic', 'Anthropic')];
+ },
+ localRunning: () => new Promise<number | null>(() => undefined),
+ });
+ const done = vi.fn();
+ void directory.resolveMembers('anthropic', { ...config, members: [local, SLOW] }, {
+ quickMs: 3_000,
+ enough: (resolved) => resolved.state === 'ok',
+ }).then(done);
+ await vi.advanceTimersByTimeAsync(3_000);
+ expect(done).toHaveBeenCalledTimes(1);
+ expect(done.mock.calls[0][0]).toMatchObject([
+ { member: { key: local.key }, state: 'ok' },
+ { member: { key: SLOW.key }, state: 'offline', pending: true },
+ ]);
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
it('keeps waiting when the completed quota makes the known computer unavailable', async () => {
vi.useFakeTimers();
try {
diff --git a/apps/desktop/src/main/provider-group/__tests__/router.test.ts b/apps/desktop/src/main/provider-group/__tests__/router.test.ts
index 3e9c1f63e9..539f93ffb0 100644
--- a/apps/desktop/src/main/provider-group/__tests__/router.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/router.test.ts
@@ -195,22 +195,27 @@ describe('provider group details capability reader lifetime', () => {
});
describe('own tasks and incoming tasks', () => {
- it.each(['least', 'order', 'round', 'weight'] as const)('keeps own tasks local under %s even when paused and full', async (strategy) => {
- const config: ProviderGroupConfig = { strategy, autoSwitch: true, members: [SHARE_A, { ...LOCAL, paused: true }] };
- const router = harness({ [LOCAL.key]: 8 }, {}, [], config);
+ it.each(['least', 'order', 'round', 'weight'] as const)('assigns own tasks by %s like incoming tasks, letting them use a paused local computer', async (strategy) => {
const input = { providerId: 'anthropic', agentKind: 'claude-code' as const, model: MODEL };
- expect(await router.pick({ ...input, localTask: true })).toMatchObject({ kind: 'member', member: { key: LOCAL.key } });
- expect(await router.pick(input)).toMatchObject({ kind: 'member', member: { key: SHARE_A.key } });
- expect(config.members[1].paused).toBe(true);
+ // 本机满载:本机任务也按并发上限分到别的电脑,不再固定留在本机。
+ const full: ProviderGroupConfig = { strategy, autoSwitch: true, members: [SHARE_A, { ...LOCAL, paused: true }] };
+ const fullRouter = harness({ [LOCAL.key]: 8 }, {}, [], full);
+ expect(await fullRouter.pick({ ...input, localTask: true })).toMatchObject({ kind: 'member', member: { key: SHARE_A.key } });
+ // 本机暂停对外分配:外部任务不分过来,本机任务照常可以选它。
+ const paused: ProviderGroupConfig = { strategy, autoSwitch: true, members: [{ ...LOCAL, paused: true }, SHARE_A] };
+ const pausedRouter = harness({}, {}, [], paused);
+ expect(await pausedRouter.pick({ ...input, localTask: true })).toMatchObject({ kind: 'member', member: { key: LOCAL.key } });
+ expect(await pausedRouter.pick(input)).toMatchObject({ kind: 'member', member: { key: SHARE_A.key } });
+ expect(paused.members[0].paused).toBe(true);
});
- it('does not reset incoming round-robin allocation when an own task stays local', async () => {
+ it('lets own tasks take their turn in round-robin allocation', async () => {
const config: ProviderGroupConfig = { strategy: 'round', autoSwitch: true, members: [SHARE_A, SHARE_B, LOCAL] };
const router = harness({}, {}, [], config);
const input = { providerId: 'anthropic', agentKind: 'claude-code' as const, model: MODEL };
expect(await router.pick(input)).toMatchObject({ kind: 'member', member: { key: SHARE_A.key } });
- expect(await router.pick({ ...input, localTask: true })).toMatchObject({ kind: 'member', member: { key: LOCAL.key } });
- expect(await router.pick(input)).toMatchObject({ kind: 'member', member: { key: SHARE_B.key } });
+ expect(await router.pick({ ...input, localTask: true })).toMatchObject({ kind: 'member', member: { key: SHARE_B.key } });
+ expect(await router.pick(input)).toMatchObject({ kind: 'member', member: { key: LOCAL.key } });
});
it.each(['cooling', 'excluded'] as const)('falls back to the group when this computer is %s', async (reason) => {
@@ -297,7 +302,7 @@ describe('provider group quick picks with busy usable computers', () => {
const FAST = member('device:fast:anthropic', 'device', 'fast');
const SLOW = member('device:slow:anthropic', 'device', 'slow');
- function quickRouter(localLoad: number | Promise<number | null>, fastLoad: number | null, localView = view('anthropic')) {
+ function quickRouter(localLoad: number | Promise<number | null>, fastLoad: number | null, localView = view('anthropic'), localGroupLoad = 0) {
const config: ProviderGroupConfig = { strategy: 'order', autoSwitch: true, members: [LOCAL, FAST, SLOW] };
const devices = ['fast', 'slow'].map((deviceId): DeviceLinkDeviceView => ({
deviceId, name: deviceId, platform: 'win32', appVersion: '1.0.0', lastSeenAt: null,
@@ -319,73 +324,76 @@ describe('provider group quick picks with busy usable computers', () => {
});
const router = createProviderGroupRouter({
directory, readGroup: () => config, listBindings: () => ({}), isTurnRunning: () => false,
- externalRunning: (_providerId, key) => key === FAST.key ? fastLoad ?? 0 : 0,
+ externalRunning: (_providerId, key) => key === FAST.key ? fastLoad ?? 0 : key === LOCAL.key ? localGroupLoad : 0,
now: () => 1_000, random: () => 0,
});
return { router, config, localRunning, readDeviceProviders };
}
- it('does not wait for remote catalogs when this computer can run its own task', async () => {
- vi.useFakeTimers();
- try {
- const { router, config } = quickRouter(8, null);
- config.members[0] = { ...LOCAL, paused: true };
- expect(await router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, localTask: true }))
- .toMatchObject({ kind: 'member', member: { key: LOCAL.key } });
- expect(vi.getTimerCount()).toBe(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it.each([false, true])('does not query stalled local load for its own task (fresh=%s)', async (fresh) => {
- vi.useFakeTimers();
- try {
- const { router, config, localRunning, readDeviceProviders } = quickRouter(new Promise(() => undefined), null);
- config.members[0] = { ...LOCAL, paused: true };
- const done = vi.fn();
- void router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, localTask: true, fresh }).then(done);
- await vi.advanceTimersByTimeAsync(0);
- expect(done).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({
- kind: 'member', member: expect.objectContaining({ key: LOCAL.key }),
- }));
- expect(localRunning).not.toHaveBeenCalled();
- expect(readDeviceProviders).not.toHaveBeenCalled();
- expect(vi.getTimerCount()).toBe(0);
- } finally {
- vi.useRealTimers();
- }
- });
+ it.each([
+ { fastLoad: null, expected: LOCAL.key },
+ { fastLoad: 1, expected: FAST.key },
+ ].flatMap((scenario) => [false, true].map((own) => ({ ...scenario, own }))))(
+ 'keeps local availability and group counts when its load read stalls (fast load=$fastLoad, own task=$own)',
+ async ({ fastLoad, expected, own }) => {
+ vi.useFakeTimers();
+ try {
+ const localLoad = new Promise<number | null>(() => undefined);
+ const { router, config } = quickRouter(localLoad, fastLoad, view('anthropic'), 2);
+ config.strategy = 'least';
+ const done = vi.fn();
+ void router.pick({
+ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, ...(own ? { localTask: true as const } : {}),
+ }).then(done);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_PICK_QUICK_MS - 1);
+ expect(done).not.toHaveBeenCalled();
+ await vi.advanceTimersByTimeAsync(1);
+ expect(done).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({
+ kind: 'member', member: expect.objectContaining({ key: expected }),
+ }));
+ const resolved = done.mock.calls[0][0].resolved as ResolvedProviderGroupMember[];
+ const local = resolved.find((member) => member.member.key === LOCAL.key);
+ expect(local).toMatchObject({ state: 'ok' });
+ expect(local?.reportedRunning).toBeUndefined();
+ expect(router.running('anthropic', LOCAL.key)).toBe(2);
+ } finally {
+ vi.useRealTimers();
+ }
+ },
+ );
- it.each(['disconnected', 'wrong-model'] as const)('falls back within the quick window without reading local load when local is %s', async (reason) => {
+ it.each(['disconnected', 'wrong-model'] as const)('falls back within the quick window for an own task when local is %s', async (reason) => {
vi.useFakeTimers();
try {
const localView = view('anthropic');
if (reason === 'disconnected') localView.connected = false;
else localView.models = { 'claude-code': [] };
- const { router, localRunning } = quickRouter(new Promise(() => undefined), 0, localView);
+ const { router } = quickRouter(new Promise(() => undefined), 0, localView);
const done = vi.fn();
void router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, localTask: true }).then(done);
await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_PICK_QUICK_MS);
expect(done).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({
kind: 'member', member: expect.objectContaining({ key: FAST.key }),
}));
- expect(localRunning).not.toHaveBeenCalled();
} finally {
vi.useRealTimers();
}
});
+ // 本机任务与外部任务走同一条快速选择(本机任务只是不受本机的对外暂停限制)。
it.each([
{ label: 'a full local computer while both remote catalogs stall', localLoad: 4, fastLoad: null, expected: LOCAL.key },
{ label: 'a free computer before a full one, despite order strategy', localLoad: 4, fastLoad: 1, expected: FAST.key },
{ label: 'the least busy computer when every resolved computer is full', localLoad: 6, fastLoad: 4, expected: FAST.key },
- ])('finishes within the quick window with $label', async ({ localLoad, fastLoad, expected }) => {
+ ].flatMap((c) => [false, true].map((own) => ({ ...c, own }))))('finishes within the quick window with $label (own task=$own)', async ({ localLoad, fastLoad, expected, own }) => {
vi.useFakeTimers();
try {
- const { router } = quickRouter(localLoad, fastLoad);
+ const { router, config } = quickRouter(localLoad, fastLoad);
+ if (own) config.members[0] = { ...LOCAL, paused: true };
const done = vi.fn();
- void router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL }).then(done);
+ void router.pick({
+ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, ...(own ? { localTask: true as const } : {}),
+ }).then(done);
await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_PICK_QUICK_MS - 1);
expect(done).not.toHaveBeenCalled();
await vi.advanceTimersByTimeAsync(1);
diff --git a/apps/desktop/src/main/provider-group/__tests__/router.usage.test.ts b/apps/desktop/src/main/provider-group/__tests__/router.usage.test.ts
index 99a23da4d4..6d2e9aad34 100644
--- a/apps/desktop/src/main/provider-group/__tests__/router.usage.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/router.usage.test.ts
@@ -42,24 +42,60 @@ function harness() {
}
describe('provider-group quota routing', () => {
- it.each(PROVIDER_GROUP_STRATEGIES)('keeps local task priority with the %s strategy despite higher usage, load and external pause', async (strategy) => {
- const context = harness();
- context.config.strategy = strategy;
- const local = context.config.members[0];
- const remote = context.config.members[1].key;
- local.limit = 1;
- local.paused = true;
- context.usage.set(local.key, snapshot(85, 90));
- context.usage.set(remote, snapshot(10, 20));
+ it.each(PROVIDER_GROUP_STRATEGIES)('gives own tasks the same %s choice as incoming tasks, apart from the external pause', async (strategy) => {
+ const remote = harness().config.members[1].key;
+ const choose = async (localTask: boolean, paused: boolean, localUsage: [number, number]) => {
+ const h = harness();
+ h.config.strategy = strategy;
+ h.config.members[0].paused = paused;
+ h.usage.set('local', snapshot(...localUsage));
+ h.usage.set(remote, snapshot(12, 22));
+ const pick = await h.router.pick({
+ providerId: 'anthropic', agentKind: 'claude-code', model: OPUS, ...(localTask ? { localTask: true as const } : {}),
+ });
+ return pick.kind === 'member' ? pick.member.key : pick.kind;
+ };
+ // Quota comes first for every strategy: a clearly lower-usage computer wins for everyone.
+ expect(await choose(true, false, [85, 90])).toBe(remote);
+ expect(await choose(false, false, [85, 90])).toBe(remote);
+ // Similar usage leaves the choice to the strategy, which starts with this computer in group order.
+ expect(await choose(true, false, [10, 20])).toBe('local');
+ expect(await choose(false, false, [10, 20])).toBe('local');
+ expect(await choose(true, true, [10, 20])).toBe('local');
+ expect(await choose(false, true, [10, 20])).toBe(remote);
+ });
+
+ it('applies this computer’s concurrency limit to own tasks', async () => {
+ const h = harness();
+ h.config.strategy = 'order';
+ h.config.members[0].limit = 1;
const input = { providerId: 'anthropic', agentKind: 'claude-code' as const, model: OPUS, localTask: true as const };
- expect(await context.router.pick({ ...input, reserveFor: 'local-running' })).toMatchObject({ kind: 'member', member: { key: local.key } });
- expect(context.router.running('anthropic', local.key)).toBe(1);
- expect(await context.router.pick(input)).toMatchObject({ kind: 'member', member: { key: local.key } });
- expect(context.readUsage.mock.calls.every(([member]) => member.kind === 'local')).toBe(true);
- expect(await context.pick()).toMatchObject({ kind: 'member', member: { key: remote } });
+ expect(await h.router.pick({ ...input, reserveFor: 's1' })).toMatchObject({ kind: 'member', member: { key: 'local' } });
+ expect(await h.router.pick({ ...input, reserveFor: 's2' }))
+ .toMatchObject({ kind: 'member', member: { key: h.config.members[1].key } });
+ });
+
+ it.each([false, true])('uses quota that is about to reset first (own task=%s)', async (own) => {
+ const h = harness();
+ const remote = h.config.members[1].key;
+ const win = (utilization: number, inMs: number) => ({ utilization, resetsAt: (NOW + inMs) / 1000 });
+ const pick = () => h.router.pick({
+ providerId: 'anthropic', agentKind: 'claude-code', model: OPUS, ...(own ? { localTask: true as const } : {}),
+ });
+ // Weekly quota resetting within 5 hours wins over lower usage elsewhere.
+ h.usage.set('local', snapshot(10, 20));
+ h.usage.set(remote, { ...snapshot(10, 70), sevenDay: win(70, 3 * 3_600_000) });
+ expect(await pick()).toMatchObject({ kind: 'member', member: { key: remote } });
+ // Without an expiring weekly window, a 5-hour window in its last hour comes next.
+ h.usage.set('local', { updatedAt: NOW, fiveHour: win(30, 20 * 60_000), sevenDay: win(20, 3 * 86_400_000) });
+ h.usage.set(remote, { updatedAt: NOW, fiveHour: win(5, 3 * 3_600_000), sevenDay: win(10, 3 * 86_400_000) });
+ expect(await pick()).toMatchObject({ kind: 'member', member: { key: 'local' } });
+ // Nothing about to reset: back to plain usage balancing.
+ h.usage.set('local', { updatedAt: NOW, fiveHour: win(30, 2 * 3_600_000), sevenDay: win(20, 3 * 86_400_000) });
+ expect(await pick()).toMatchObject({ kind: 'member', member: { key: remote } });
});
- it.each(PROVIDER_GROUP_STRATEGIES)('applies quota prefiltering to local task priority with the %s strategy', async (strategy) => {
+ it.each(PROVIDER_GROUP_STRATEGIES)('applies quota prefiltering to own tasks with the %s strategy', async (strategy) => {
const context = harness();
context.config.strategy = strategy;
context.config.members[0].paused = true;
@@ -73,8 +109,6 @@ describe('provider-group quota routing', () => {
context.usage.set('local', { ...snapshot(10, 20), scoped: [{ modelDisplayName: 'Opus', utilization: 100, resetsAt: 80_000 }] });
expect(await context.router.pick(input)).toMatchObject({ kind: 'member', member: { key: remote } });
expect(await context.router.pick({ ...input, model: SONNET })).toMatchObject({ kind: 'member', member: { key: 'local' } });
- context.usage.set('local', null);
- expect(await context.router.pick(input)).toMatchObject({ kind: 'member', member: { key: 'local' } });
});
it.each(PROVIDER_GROUP_STRATEGIES)('excludes an exhausted account for the %s strategy', async (strategy) => {
diff --git a/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts b/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts
index 63ace64149..1ef81be3f7 100644
--- a/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/scheduler.test.ts
@@ -3,7 +3,14 @@
*/
import { describe, expect, it } from 'vitest';
-import { pickProviderGroupMember, type SchedulableMember } from '../scheduler';
+import type { ProviderGroupStrategy } from '../../../shared/providerGroup';
+import {
+ pickProviderGroupMember,
+ PROVIDER_GROUP_FIVE_HOUR_EXPIRING_MS,
+ PROVIDER_GROUP_SAME_RESET_MS,
+ PROVIDER_GROUP_WEEKLY_EXPIRING_MS,
+ type SchedulableMember,
+} from '../scheduler';
const m = (key: string, patch: Partial<SchedulableMember> = {}): SchedulableMember => ({
key,
@@ -64,3 +71,108 @@ describe('pickProviderGroupMember', () => {
expect(pickProviderGroupMember([full, m('other', { usagePercent: 5, running: 5 })], 'usage')).toBe('low');
});
});
+
+describe('quota about to reset is used first', () => {
+ const NOW = 10_000_000_000;
+ const HOUR = 60 * 60_000;
+ const pick = (members: SchedulableMember[], strategy: ProviderGroupStrategy = 'usage') =>
+ pickProviderGroupMember(members, strategy, { now: NOW });
+
+ it('prefers weekly quota resetting within 5 hours over lower usage, earliest reset first', () => {
+ const idle = m('idle', { usagePercent: 5 });
+ expect(pick([idle, m('weekly', { usagePercent: 70, weeklyResetAtMs: NOW + 4 * HOUR })])).toBe('weekly');
+ expect(pick([idle, m('weekly', { usagePercent: 70, weeklyResetAtMs: NOW + PROVIDER_GROUP_WEEKLY_EXPIRING_MS + 1 })]))
+ .toBe('idle');
+ expect(pick([
+ idle,
+ m('later', { usagePercent: 10, weeklyResetAtMs: NOW + 4 * HOUR }),
+ m('sooner', { usagePercent: 90, weeklyResetAtMs: NOW + 2 * HOUR }),
+ ])).toBe('sooner');
+ });
+
+ it('ranks the weekly tier ahead of the 5-hour tier, which only counts its last hour', () => {
+ const fiveHour = m('five-hour', { usagePercent: 20, fiveHourResetAtMs: NOW + 10 * 60_000 });
+ const weekly = m('weekly', { usagePercent: 60, weeklyResetAtMs: NOW + 3 * HOUR });
+ expect(pick([fiveHour, weekly])).toBe('weekly');
+ const idle = m('idle', { usagePercent: 5 });
+ expect(pick([idle, fiveHour])).toBe('five-hour');
+ expect(pick([idle, m('five-hour', { usagePercent: 20, fiveHourResetAtMs: NOW + PROVIDER_GROUP_FIVE_HOUR_EXPIRING_MS + 1 })]))
+ .toBe('idle');
+ });
+
+ it('balances computers that expire at nearly the same time', () => {
+ const reset = NOW + 30 * 60_000;
+ const sameTime = [
+ m('a', { usagePercent: 40, running: 2, fiveHourResetAtMs: reset }),
+ m('b', { usagePercent: 42, fiveHourResetAtMs: reset + PROVIDER_GROUP_SAME_RESET_MS }),
+ ];
+ expect(pick(sameTime)).toBe('b');
+ expect(pick([sameTime[0], { ...sameTime[1], fiveHourResetAtMs: reset + PROVIDER_GROUP_SAME_RESET_MS + 1 }])).toBe('a');
+ });
+
+ it('keeps concurrency limits ahead of expiring quota and ignores past or unknown resets', () => {
+ const fullExpiring = m('full', { usagePercent: 10, running: 4, weeklyResetAtMs: NOW + HOUR });
+ expect(pick([fullExpiring, m('open', { usagePercent: 80 })])).toBe('open');
+ // 都满了时仍然先用快到期的,而不是单看谁更空。
+ expect(pick([m('emptier', { usagePercent: 10, running: 4 }), { ...fullExpiring, key: 'expiring', running: 6 }])).toBe('expiring');
+ expect(pick([m('past', { usagePercent: 80, weeklyResetAtMs: NOW }), m('low', { usagePercent: 10 })])).toBe('low');
+ expect(pickProviderGroupMember([m('low', { usagePercent: 10 }), m('soon', { usagePercent: 80, weeklyResetAtMs: NOW + HOUR })], 'usage'))
+ .toBe('low');
+ });
+
+ it.each(['least', 'order', 'round', 'weight'] as const)('comes before the %s strategy', (strategy) => {
+ expect(pick([m('a', { usagePercent: 10 }), m('soon', { usagePercent: 80, running: 1, weeklyResetAtMs: NOW + HOUR })], strategy)).toBe('soon');
+ });
+
+ it.each(['least', 'usage', 'order', 'round', 'weight'] as const)(
+ 'keeps incomplete usage behind known usage before comparing reset times for %s', (strategy) => {
+ const members = [
+ m('unknown', { usagePercent: null, weeklyResetAtMs: NOW + 2 * HOUR }),
+ m('known', { usagePercent: 80, running: 1 }),
+ ];
+ expect(pick(members, strategy)).toBe('known');
+ expect(pick(members.map((member) => ({ ...member, running: member.running + 4 })), strategy)).toBe('known');
+ },
+ );
+
+ it('ignores reset times and keeps the original strategies when every usage reading is incomplete', () => {
+ const members = [
+ m('first', { usagePercent: null, running: 1 }),
+ m('expiring', { weeklyResetAtMs: NOW + 2 * HOUR }),
+ ];
+ expect(pick(members, 'order')).toBe('first');
+ expect(pick(members, 'least')).toBe('expiring');
+ expect(pick(members, 'usage')).toBe('expiring');
+ expect(pickProviderGroupMember(members, 'round', { now: NOW, lastPicked: 'expiring' })).toBe('first');
+ expect(pickProviderGroupMember(members, 'weight', { now: NOW, random: () => 0 })).toBe('first');
+ });
+});
+
+describe('quota comes first for every strategy; the strategy picks among similar computers', () => {
+ it.each(['least', 'order', 'round', 'weight'] as const)('sends %s picks to the lower-usage computer', (strategy) => {
+ expect(pickProviderGroupMember([m('busy-quota', { usagePercent: 80 }), m('spare', { usagePercent: 10, running: 3 })], strategy, {
+ lastPicked: 'spare', random: () => 0,
+ })).toBe('spare');
+ });
+
+ it('lets each strategy choose within the 5-point band', () => {
+ const similar = [
+ m('a', { usagePercent: 12, running: 2, weight: 1 }),
+ m('b', { usagePercent: 10, running: 1, weight: 3 }),
+ m('c', { usagePercent: 14, weight: 1 }),
+ m('far', { usagePercent: 40 }),
+ ];
+ expect(pickProviderGroupMember(similar, 'order')).toBe('a');
+ expect(pickProviderGroupMember(similar, 'least')).toBe('c');
+ expect(pickProviderGroupMember(similar, 'usage')).toBe('c');
+ expect(pickProviderGroupMember(similar, 'round', { lastPicked: 'a' })).toBe('b');
+ expect(pickProviderGroupMember(similar, 'round', { lastPicked: 'c' })).toBe('a');
+ expect(pickProviderGroupMember(similar, 'weight', { random: () => 0.5 })).toBe('b');
+ });
+
+ it('puts computers without readable usage after known ones, and keeps plain strategies when none is known', () => {
+ expect(pickProviderGroupMember([m('shared'), m('own', { usagePercent: 90, running: 3 })], 'order')).toBe('own');
+ expect(pickProviderGroupMember([m('a', { running: 1 }), m('b')], 'order')).toBe('a');
+ expect(pickProviderGroupMember([m('a', { running: 1 }), m('b')], 'least')).toBe('b');
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/service.test.ts b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
index b845e09ca0..ee1072750f 100644
--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
@@ -157,7 +157,7 @@ async function flush() {
describe('own tasks after this computer becomes available again', () => {
it.each([false, true].flatMap((paused) =>
(['start', 'turn', 'before-send', 'healthy'] as const).map((phase) => ({ paused, phase })),
- ))('prefers local only when another choice is needed ($phase, paused=$paused)', async ({ paused, phase }) => {
+ ))('reselects by the group strategy, not local first, when another choice is needed ($phase, paused=$paused)', async ({ paused, phase }) => {
const h = harness({ members: [MINI, STUDIO, { ...LOCAL, paused }], offline: [LOCAL.key] });
// 数据库读取返回快照,后续保存路由不会修改已经读出的行。
h.deps.readSessionRow.mockImplementation(async () => ({ ...h.row }));
@@ -167,7 +167,7 @@ describe('own tasks after this computer becomes available again', () => {
if (phase === 'start') {
const next = await h.service.nextAfterStartFailure(context!, new Error('[REMOTE_AGENT_UNAVAILABLE] failed to start'));
- expect(next?.member.key).toBe(LOCAL.key);
+ expect(next?.member.key).toBe(STUDIO.key);
} else if (phase === 'turn') {
await h.service.onTurnError('s1', { sdkError: 'rate_limit' }, 1);
expect(h.deps.continueSession).toHaveBeenCalledTimes(1);
@@ -182,9 +182,9 @@ describe('own tasks after this computer becomes available again', () => {
expect(h.deps.persistRoute).toHaveBeenCalledTimes(1);
expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
} else {
- // 组顺序本来会选仍可用的 STUDIO;本机自用故障重选仍优先已恢复的本机。
- expect(h.row).toMatchObject({ agentDeviceId: null, providerId: 'anthropic' });
- expect(h.bindings.get('s1')?.memberKey).toBe(LOCAL.key);
+ // 本机任务与其他使用方同一套组策略:按组顺序选仍可用的 STUDIO,不因本机已恢复就回到本机。
+ expect(h.row).toMatchObject({ agentDeviceId: STUDIO.agentDeviceId, providerId: STUDIO.providerId });
+ expect(h.bindings.get('s1')?.memberKey).toBe(STUDIO.key);
if (phase !== 'start') expect(h.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
}
expect(h.config.members[2].paused).toBe(paused);
@@ -205,11 +205,11 @@ describe('assignBeforeStart', () => {
expect(incoming.kind === 'member' && incoming.member.key).toBe(MINI.key);
});
- it('prefers this computer for own tasks regardless of the group order', async () => {
+ it('follows the group order for own tasks instead of preferring this computer', async () => {
const h = harness({ members: [MINI, LOCAL] });
const context = await h.service.assignBeforeStart({ sessionId: 's1', agentKind: 'claude-code', model: MODEL });
- expect(context?.member.key).toBe('local');
- expect(h.deps.persistRoute).not.toHaveBeenCalled();
+ expect(context?.member.key).toBe(MINI.key);
+ expect(h.deps.persistRoute).toHaveBeenCalledWith('s1', { agentDeviceId: 'mini', providerId: MINI.providerId });
});
it('falls back through the group when a paused local member cannot start its own task', async () => {
diff --git a/apps/desktop/src/main/provider-group/__tests__/usage.test.ts b/apps/desktop/src/main/provider-group/__tests__/usage.test.ts
index d24323df97..deead4e606 100644
--- a/apps/desktop/src/main/provider-group/__tests__/usage.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/usage.test.ts
@@ -41,7 +41,19 @@ describe('provider group quota eligibility', () => {
it('does not keep blocking a reset window or score it as zero before fresh data arrives', () => {
const value = { ...snapshot(100, 20), fiveHour: { utilization: 100, resetsAt: NOW / 1000 } };
- expect(providerGroupUsageState(value, 'opus', NOW)).toEqual({ limited: false, resetAtMs: null, usagePercent: null });
+ expect(providerGroupUsageState(value, 'opus', NOW)).toEqual({
+ limited: false, resetAtMs: null, usagePercent: null, weeklyResetAtMs: NOW + 86_400_000, fiveHourResetAtMs: null,
+ });
+ });
+
+ it('reports when unused quota resets, but not for used-up, past or unknown resets', () => {
+ expect(providerGroupUsageState(snapshot(20, 40), 'opus', NOW))
+ .toMatchObject({ weeklyResetAtMs: NOW + 86_400_000, fiveHourResetAtMs: NOW + 3_600_000 });
+ expect(providerGroupUsageState(snapshot(100, 100), 'opus', NOW))
+ .toMatchObject({ weeklyResetAtMs: null, fiveHourResetAtMs: null });
+ const unknown = { ...snapshot(), fiveHour: { utilization: 0, resetsAt: null }, sevenDay: { utilization: 10, resetsAt: (NOW - 1) / 1000 } };
+ expect(providerGroupUsageState(unknown, 'opus', NOW)).toMatchObject({ weeklyResetAtMs: null, fiveHourResetAtMs: null });
+ expect(providerGroupUsageState(null, 'opus', NOW)).toMatchObject({ weeklyResetAtMs: null, fiveHourResetAtMs: null });
});
it('keeps unknown and stale data distinct from low usage', () => {
diff --git a/apps/desktop/src/main/provider-group/directory.ts b/apps/desktop/src/main/provider-group/directory.ts
index a9958d9436..91d24d885c 100644
--- a/apps/desktop/src/main/provider-group/directory.ts
+++ b/apps/desktop/src/main/provider-group/directory.ts
@@ -78,13 +78,12 @@ export interface ResolveMembersOptions {
enough?(resolved: ResolvedProviderGroupMember): boolean;
/** 不用短时缓存,现读设备列表与每台的目录(试过不行之后拉最新状态)。 */
fresh?: boolean;
- /** 本机自用不按负载分配,可不读本机运行数,避免等待任务数据库;默认仍读取。 */
- includeLocalRunning?: boolean;
}
const CATALOG_TTL_MS = 15_000;
const CATALOG_FAILURE_TTL_MS = 5_000;
const DEVICES_TTL_MS = 10_000;
+const LOCAL_LOAD_TIMEOUT_MS = 1_000;
const SHARE_REASON = /^\[REMOTE_AGENT_SHARE_(PAUSED|REMOVED|UNAVAILABLE)\]/;
@@ -163,14 +162,25 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
return views.find((view) => view.id === providerId) ?? null;
}
- async function resolveLocal(member: ProviderGroupMember, includeRunning = true): Promise<ResolvedProviderGroupMember> {
+ async function resolveLocal(member: ProviderGroupMember): Promise<ResolvedProviderGroupMember> {
const label = deps.localDeviceName();
const appVersion = readProviderGroupAppVersion(deps.localAppVersion?.());
const base = { member, label, ...(appVersion ? { appVersion } : {}) };
- const view = await localGroupProvider(member.providerId);
- if (!view || !view.connected || view.suspended) return { ...base, state: 'unavailable', reason: 'disconnected' };
- const reportedRunning = includeRunning ? await deps.localRunning?.(member.providerId).catch(() => null) : undefined;
- return { ...base, state: 'ok', view, ...(typeof reportedRunning === 'number' ? { reportedRunning } : {}) };
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ const running = Promise.race([
+ deps.localRunning?.(member.providerId).catch(() => null),
+ new Promise<null>((resolve) => {
+ timer = setTimeout(() => resolve(null), LOCAL_LOAD_TIMEOUT_MS);
+ }),
+ ]);
+ const view = await localGroupProvider(member.providerId);
+ if (!view || !view.connected || view.suspended) return { ...base, state: 'unavailable', reason: 'disconnected' };
+ const reportedRunning = await running;
+ return { ...base, state: 'ok', view, ...(typeof reportedRunning === 'number' ? { reportedRunning } : {}) };
+ } finally {
+ clearTimeout(timer);
+ }
}
async function resolveDevice(
@@ -300,7 +310,7 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
const deviceListPromise = needsDevices ? readDevices().catch(() => null) : Promise.resolve(null);
// 额度补充读取可能慢于快速选路窗口:保留基础目录结果,避免已知可用的成员被误判成待定或离线。
const partialReads = config.members.map((member) => {
- if (member.kind === 'local') return resolveLocal(member, options?.includeLocalRunning);
+ if (member.kind === 'local') return resolveLocal(member);
if (member.kind === 'share') return resolveShare(member);
return deviceListPromise.then((deviceList) => resolveDevice(member, deviceList));
});
diff --git a/apps/desktop/src/main/provider-group/router.ts b/apps/desktop/src/main/provider-group/router.ts
index b892d89ade..b1d4811eb6 100644
--- a/apps/desktop/src/main/provider-group/router.ts
+++ b/apps/desktop/src/main/provider-group/router.ts
@@ -67,8 +67,8 @@ export interface ProviderGroupPickInput {
agentKind: AgentKind;
model: string;
/**
- * 仅本机任务入口设置:初次分配与故障重选时,本机可用就优先本机,不受对外暂停分配或负载影响。
- * 远程请求与分享中转不传,也不从请求载荷读取。
+ * 仅本机任务入口设置:本机任务与其他使用方走同一组策略(2026-10-15 用户裁决),只是本机的「暂停对外分配」
+ * 不拦本机自己的任务。远程请求与分享中转不传,也不从请求载荷读取,不能借它绕过暂停。
*/
localTask?: true;
exclude?: ReadonlySet<string>;
@@ -210,47 +210,40 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
const usable = (r: ResolvedProviderGroupMember) =>
offersModel(r, input.agentKind, input.model) && coolingUntil(input.providerId, r.member.key) === null
&& !providerGroupUsageState(r.claudeUsage, input.model, deps.now()).limited;
- const ownLocal = (r: ResolvedProviderGroupMember) => input.localTask === true && r.member.kind === 'local';
- const paused = (r: ResolvedProviderGroupMember) => r.member.paused && !ownLocal(r);
- const local = input.localTask === true ? config.members.find((m) => m.kind === 'local') : undefined;
- // 本机优先只读可用性,不等无关的负载查询或远端目录,也不因远端先返回而分配到别处。
- let resolved = local && !input.exclude?.has(local.key) && coolingUntil(input.providerId, local.key) === null
- ? await deps.directory.resolveMembers(
- input.providerId, { ...config, members: [local] }, {
- includeLocalRunning: false,
- ...(input.fresh ? { fresh: true } : {}),
- },
- )
- : [];
- if (!resolved.some(usable)) {
- resolved = await deps.directory.resolveMembers(input.providerId, config, {
- quickMs: PROVIDER_GROUP_PICK_QUICK_MS,
- // 已经有一台能用、可以分的电脑(满载仍可接):不再等慢的那几台。未满优先由调度器决定。
- enough: (r) => usable(r)
- && !paused(r)
- && !input.exclude?.has(r.member.key),
- ...(input.fresh ? { fresh: true } : {}),
- ...(input.localTask ? { includeLocalRunning: false } : {}),
- });
- }
- const schedulable: SchedulableMember[] = resolved.map((r) => ({
- key: r.member.key,
- usable: usable(r),
- paused: paused(r),
- running: memberRunning(input.providerId, r),
- limit: r.member.limit,
- weight: r.member.weight,
- usagePercent: providerGroupUsageState(r.claudeUsage, input.model, deps.now()).usagePercent,
- }));
- const preferred = resolved.find((r) => ownLocal(r) && usable(r) && !input.exclude?.has(r.member.key));
- const key = preferred?.member.key ?? pickProviderGroupMember(schedulable, config.strategy, {
+ // 「暂停对外分配」只拦本机以外的新任务;除此之外本机任务与其他使用方同一套组策略,不另设本机优先。
+ const paused = (r: ResolvedProviderGroupMember) =>
+ r.member.paused && !(input.localTask === true && r.member.kind === 'local');
+ const resolved = await deps.directory.resolveMembers(input.providerId, config, {
+ quickMs: PROVIDER_GROUP_PICK_QUICK_MS,
+ // 已经有一台能用、可以分的电脑(满载仍可接):不再等慢的那几台。未满优先由调度器决定。
+ enough: (r) => usable(r)
+ && !paused(r)
+ && !input.exclude?.has(r.member.key),
+ ...(input.fresh ? { fresh: true } : {}),
+ });
+ const now = deps.now();
+ const schedulable: SchedulableMember[] = resolved.map((r) => {
+ const quota = providerGroupUsageState(r.claudeUsage, input.model, now);
+ return {
+ key: r.member.key,
+ usable: usable(r),
+ paused: paused(r),
+ running: memberRunning(input.providerId, r),
+ limit: r.member.limit,
+ weight: r.member.weight,
+ usagePercent: quota.usagePercent,
+ weeklyResetAtMs: quota.weeklyResetAtMs,
+ fiveHourResetAtMs: quota.fiveHourResetAtMs,
+ };
+ });
+ const key = pickProviderGroupMember(schedulable, config.strategy, {
exclude: input.exclude,
lastPicked: lastPicked.get(input.providerId) ?? null,
random: deps.random,
+ now,
});
if (!key) return { kind: 'unavailable', resolved };
- // 本机优先不参与组策略轮询,避免本机自用打断外部任务的分配顺序。
- if (!preferred) lastPicked.set(input.providerId, key);
+ lastPicked.set(input.providerId, key);
if (input.reserveFor) {
provisional.set(input.reserveFor, {
providerId: input.providerId,
diff --git a/apps/desktop/src/main/provider-group/scheduler.ts b/apps/desktop/src/main/provider-group/scheduler.ts
index d7e16f0c06..21cf9e68b3 100644
--- a/apps/desktop/src/main/provider-group/scheduler.ts
+++ b/apps/desktop/src/main/provider-group/scheduler.ts
@@ -13,6 +13,10 @@ export interface SchedulableMember {
weight: number;
/** Higher of the current 5-hour / weekly usage percentages; unknown stays null. */
usagePercent?: number | null;
+ /** 总周额度还没用完时的重置时刻(unix ms);未知、已重置或已用完为 null。 */
+ weeklyResetAtMs?: number | null;
+ /** 5 小时额度还没用完时的重置时刻(unix ms);口径同上。 */
+ fiveHourResetAtMs?: number | null;
}
export interface PickOptions {
@@ -22,11 +26,30 @@ export interface PickOptions {
lastPicked?: string | null;
/** [0, 1) 随机数,按权重时使用。 */
random?: () => number;
+ /** 现在(unix ms),判断配额快到期时使用;不给时跳过快到期优先。 */
+ now?: number;
}
+/**
+ * 「快到期先用」(2026-10-15 用户裁决):配额一重置,没用完的部分就浪费了。按顺序看两档,
+ * 每周的优先,然后是 5 小时的;同一档里先用重置最早的。
+ */
+export const PROVIDER_GROUP_WEEKLY_EXPIRING_MS = 5 * 60 * 60_000;
+export const PROVIDER_GROUP_FIVE_HOUR_EXPIRING_MS = 60 * 60_000;
+/** 重置时刻相差不到这么多算同时到期,再比已用百分比,同时开的任务不全压到一台。 */
+export const PROVIDER_GROUP_SAME_RESET_MS = 10 * 60_000;
+/** 已用百分比与最低值相差不超过这么多算用量相近,交给组策略挑。 */
+export const PROVIDER_GROUP_SIMILAR_USAGE_PERCENT = 5;
+
+const EXPIRING_TIERS: ReadonlyArray<readonly [(m: SchedulableMember) => number | null | undefined, number]> = [
+ [(m) => m.weeklyResetAtMs, PROVIDER_GROUP_WEEKLY_EXPIRING_MS],
+ [(m) => m.fiveHourResetAtMs, PROVIDER_GROUP_FIVE_HOUR_EXPIRING_MS],
+];
+
/**
* 只分给可用、未暂停、没试过的电脑;优先未满载的,都满了时分给相对最空的一台(并发上限只用来
- * 分摊,不因满载拒绝用户的消息)。没有可分的电脑返回 null。
+ * 分摊,不因满载拒绝用户的消息)。先按配额排(byQuota),组策略只在剩下的几台里挑;都满了时同样先按配额排,
+ * 再选最空的。没有可分的电脑返回 null。
*/
export function pickProviderGroupMember(
members: readonly SchedulableMember[],
@@ -36,35 +59,63 @@ export function pickProviderGroupMember(
const eligible = members.filter((m) => m.usable && !m.paused && !options.exclude?.has(m.key));
if (eligible.length === 0) return null;
const open = eligible.filter((m) => m.running < m.limit);
- if (open.length === 0) return leastBusy(eligible).key;
+ if (open.length === 0) return leastBusy(byQuota(eligible, options.now)).key;
+ const candidates = byQuota(open, options.now);
switch (strategy) {
- case 'usage': {
- const known = open.filter((m) => typeof m.usagePercent === 'number' && Number.isFinite(m.usagePercent));
- if (known.length === 0) return leastBusy(open).key;
- const lowest = Math.min(...known.map((m) => m.usagePercent!));
- // Small quota differences should not send every simultaneous task to the same computer.
- return leastBusy(known.filter((m) => m.usagePercent! <= lowest + 5)).key;
- }
case 'order':
- return open[0].key;
+ return candidates[0].key;
case 'round': {
const lastIndex = options.lastPicked ? members.findIndex((m) => m.key === options.lastPicked) : -1;
- const next = open.find((m) => members.indexOf(m) > lastIndex) ?? open[0];
+ const next = candidates.find((m) => members.indexOf(m) > lastIndex) ?? candidates[0];
return next.key;
}
case 'weight': {
- const total = open.reduce((sum, m) => sum + Math.max(1, m.weight), 0);
+ const total = candidates.reduce((sum, m) => sum + Math.max(1, m.weight), 0);
let point = (options.random ?? Math.random)() * total;
- for (const member of open) {
+ for (const member of candidates) {
point -= Math.max(1, member.weight);
if (point < 0) return member.key;
}
- return open[open.length - 1].key;
+ return candidates[candidates.length - 1].key;
}
+ // 旧的「用量均衡」(usage):配额排序已对所有策略生效,剩下的按最少占用挑。
+ case 'usage':
case 'least':
default:
- return leastBusy(open).key;
+ return leastBusy(candidates).key;
+ }
+}
+
+/**
+ * 配额先比(2026-10-15 用户裁决:目的是尽快把快重置的配额用掉),对所有组策略生效:
+ * 先留快到期的那一批,再留已用百分比最低的(相差 5 个百分点以内都算)。读不到用量的电脑(别人分享的、
+ * 非 Claude 订阅的)排在读得到的后面;全部读不到时不筛,原样交给组策略。保持组里的顺序。
+ */
+function byQuota(open: readonly SchedulableMember[], now: number | undefined): readonly SchedulableMember[] {
+ const known = open.filter((member) => typeof member.usagePercent === 'number' && Number.isFinite(member.usagePercent));
+ if (known.length === 0) return open;
+ const pool = expiringFirst(known, now) ?? known;
+ const lowest = Math.min(...pool.map((member) => member.usagePercent!));
+ // Small quota differences should not send every simultaneous task to the same computer.
+ return pool.filter((member) => member.usagePercent! <= lowest + PROVIDER_GROUP_SIMILAR_USAGE_PERCENT);
+}
+
+/**
+ * 未满载的电脑里,额度快到期的那一批:先看每周的,没有再看 5 小时的;只留重置最早的(及与它几乎同时的)。
+ * 都不快到期返回 null。
+ */
+function expiringFirst(open: readonly SchedulableMember[], now: number | undefined): SchedulableMember[] | null {
+ if (now === undefined) return null;
+ for (const [resetAt, within] of EXPIRING_TIERS) {
+ const soon = open.filter((m) => {
+ const at = resetAt(m);
+ return typeof at === 'number' && at > now && at - now <= within;
+ });
+ if (soon.length === 0) continue;
+ const earliest = Math.min(...soon.map((m) => resetAt(m)!));
+ return soon.filter((m) => resetAt(m)! - earliest <= PROVIDER_GROUP_SAME_RESET_MS);
}
+ return null;
}
/** 正在运行最少的一台;相同时按组里的顺序。 */
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index 9dac72e6b8..3d8390690d 100644
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@ -1,7 +1,7 @@
/**
* 供应商组接到任务生命周期上的三个点(docs/product-rules/provider-groups.md §6):
*
- * 1. **分配**:新任务第一次启动 Agent 前(bootstrapSession),本机组优先本机,其余按组策略选电脑,把选择写回
+ * 1. **分配**:新任务第一次启动 Agent 前(bootstrapSession),按组策略选电脑(本机任务与其他使用方同一套),把选择写回
* 任务记录与绑定;Agent 还没开始运行就失败(连不上、登录失效、启动失败)时直接换下一台。
* 2. **自动换电脑**:运行中因那台电脑的原因失败(终态错误)时,交接到组里下一台并继续这一轮;
* 同一轮每台最多试一次,全部失败才交回原有的报错 / 等额度重置流程。那台是连不上(离线、断线)时先等它
@@ -656,7 +656,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
providerId,
agentKind,
model,
- // 本机自用每次需要选电脑时都优先本机,含故障重选;正常运行的已有绑定不走 pick。
+ // 本机任务与其他使用方同一套组策略,只是不受本机「暂停对外分配」限制;正常运行的已有绑定不走 pick。
localTask: true,
exclude,
reserveFor: sessionId,
diff --git a/apps/desktop/src/main/provider-group/usage.ts b/apps/desktop/src/main/provider-group/usage.ts
index c53a588660..605aedaac4 100644
--- a/apps/desktop/src/main/provider-group/usage.ts
+++ b/apps/desktop/src/main/provider-group/usage.ts
@@ -60,7 +60,16 @@ export function providerGroupUsageState(raw: unknown, model: string | null | und
const scopedUsage = current(scoped);
const usagePercent = fiveHour !== null && sevenDay !== null && (!scoped || scopedUsage !== null)
? Math.max(fiveHour, sevenDay, scopedUsage ?? 0) : null;
- return { limited: limit?.limited ?? false, resetAtMs: limit?.resetAtMs ?? null, usagePercent };
+ // Quota left in a window is lost when it resets; only a known future reset with quota left can be "expiring".
+ const unusedUntil = (w: ClaudeUsageWindow | null | undefined) =>
+ w?.resetsAt && w.resetsAt * 1000 > now && w.utilization < 100 ? w.resetsAt * 1000 : null;
+ return {
+ limited: limit?.limited ?? false,
+ resetAtMs: limit?.resetAtMs ?? null,
+ usagePercent,
+ weeklyResetAtMs: unusedUntil(snapshot?.sevenDay),
+ fiveHourResetAtMs: unusedUntil(snapshot?.fiveHour),
+ };
}
export interface ProviderGroupUsageReaderDeps {
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
index a303d5ec68..a6e8443c65 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
@@ -26,7 +26,6 @@ import { Select } from '@/components/ui/select';
import { Switch } from '@/components/ui/switch';
import { Tip } from '@/components/ui/tooltip';
import { useOptionalAuthDeviceId } from '@/contexts/AuthContext';
-import { useProviders } from '@/hooks/useProviders';
import { toast } from '@/lib/toast';
import { cn } from '@/lib/utils';
import { mapIpcErrorToI18nKey } from '@/utils/ipcError';
@@ -43,10 +42,16 @@ import {
import { providerShareComputerName, useProviderShareOwnerNameOf } from '../provider-share/providerShareNames';
import { GroupMemberQuota, groupMemberQuotaTarget } from './GroupMemberQuota';
import { GroupMemberDetailsButton, GroupMemberVersion } from './GroupMemberVersion';
-import { providerWeeklyQuotaSource } from '../../../shared/providerQuotaSource';
import { ProviderGroupAddDialog } from './ProviderGroupAddDialog';
import { useProviderGroup } from './useProviderGroup';
+/**
+ * Claude 订阅的配额排序已对所有组策略生效(provider-groups.md §5,2026-10-15),不再单列「用量均衡」;
+ * 旧组存的 `usage` 与最少占用挑法相同,按最少占用显示,用户改选时才写回新值。
+ */
+const SELECTABLE_STRATEGIES = PROVIDER_GROUP_STRATEGIES.filter((value) => value !== 'usage');
+const selectableStrategy = (strategy: ProviderGroupStrategy): ProviderGroupStrategy =>
+ strategy === 'usage' ? 'least' : strategy;
const LIMIT_OPTIONS = Array.from({ length: PROVIDER_GROUP_MAX_LIMIT }, (_, i) => String(i + 1));
const WEIGHT_OPTIONS = ['1', '2', '3', '5', '10', '20', '50', String(PROVIDER_GROUP_MAX_WEIGHT)];
@@ -54,9 +59,6 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
const { t } = useTranslation();
const { confirm } = useConfirmDialog();
const group = useProviderGroup(providerId, { live: true });
- const { providers } = useProviders();
- const provider = providers.find((entry) => entry.id === providerId);
- const supportsUsage = provider && providerWeeklyQuotaSource({ ...provider, connected: true, suspended: false }) === 'claude';
const [addOpen, setAddOpen] = useState(false);
const [saving, setSaving] = useState(false);
const config = group.view?.config ?? null;
@@ -173,21 +175,26 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
onRemove={(label) => void removeMember(member, label)}
/>
))}
- <div className="flex flex-wrap items-center gap-3 border-t border-[var(--settings-theme-card-border)] px-4 py-3">
- <span className="text-13 text-[var(--text-primary)]">{t('providerGroup.strategy.label')}</span>
- <SegmentedControl
- value={config.strategy}
- onValueChange={(strategy: ProviderGroupStrategy) => void save({ ...config, strategy })}
- aria-label={t('providerGroup.strategy.label')}
- options={PROVIDER_GROUP_STRATEGIES.filter((value) => value !== 'usage' || supportsUsage || config.strategy === 'usage').map((value) => ({
- value,
- label: t(`providerGroup.strategy.${value}`),
- disabled: saving,
- }))}
- />
- <span className="flex-1" />
- <span className="text-12 text-[var(--text-secondary)]">
- {t(`providerGroup.strategy.description.${config.strategy}`)}
+ <div className="flex flex-col gap-1.5 border-t border-[var(--settings-theme-card-border)] px-4 py-3">
+ <div className="flex flex-wrap items-center gap-3">
+ <span className="text-13 text-[var(--text-primary)]">{t('providerGroup.strategy.label')}</span>
+ <SegmentedControl
+ value={selectableStrategy(config.strategy)}
+ onValueChange={(strategy: ProviderGroupStrategy) => void save({ ...config, strategy })}
+ aria-label={t('providerGroup.strategy.label')}
+ options={SELECTABLE_STRATEGIES.map((value) => ({
+ value,
+ label: t(`providerGroup.strategy.${value}`),
+ disabled: saving,
+ }))}
+ />
+ <span className="flex-1" />
+ <span className="text-12 text-[var(--text-secondary)]">
+ {t(`providerGroup.strategy.description.${selectableStrategy(config.strategy)}`)}
+ </span>
+ </div>
+ <span className="text-12 leading-[1.4] text-[var(--text-tertiary)]">
+ {t('providerGroup.strategy.quotaFirst')}
</span>
</div>
<div className="flex items-start justify-between gap-3 border-t border-[var(--settings-theme-card-border)] px-4 py-3">
diff --git a/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx b/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
index 6b34797b0c..cc931314af 100644
--- a/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
@@ -230,8 +230,8 @@ describe('ProviderGroupSection', () => {
await screen.findAllByTestId('provider-group-member');
fireEvent.click(screen.getByRole('radio', { name: 'providerGroup.strategy.round' }));
await waitFor(() => expect(stored?.strategy).toBe('round'));
- fireEvent.click(screen.getByRole('radio', { name: 'providerGroup.strategy.usage' }));
- await waitFor(() => expect(stored?.strategy).toBe('usage'));
+ fireEvent.click(screen.getByRole('radio', { name: 'providerGroup.strategy.order' }));
+ await waitFor(() => expect(stored?.strategy).toBe('order'));
fireEvent.click(screen.getByRole('switch', { name: 'providerGroup.autoSwitch.label' }));
await waitFor(() => expect(stored?.autoSwitch).toBe(false));
});
@@ -245,24 +245,41 @@ describe('ProviderGroupSection', () => {
expect(confirmSpy).toHaveBeenCalledWith(expect.objectContaining({ confirmVariant: 'destructive' }));
});
- it('shows the actual Chinese usage-balancing option and saves it for a disconnected subscription', async () => {
+ it('explains in Chinese that quota comes first for a disconnected subscription and shows an old usage group as least busy', async () => {
realLocale = createInstance();
await realLocale.init({ lng: 'zh-CN', resources: { 'zh-CN': { translation: zhCN } }, interpolation: { escapeValue: false } });
providerState.providers[0].connected = false;
- stored = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ stored = { strategy: 'usage', autoSwitch: true, members: [LOCAL] };
render(<ProviderGroupSection providerId="anthropic" providerName="Claude" />);
- const option = await screen.findByRole('radio', { name: '用量均衡' });
- fireEvent.click(option);
- await waitFor(() => expect(stored?.strategy).toBe('usage'));
- expect(await screen.findByText('按5小时和每周用量分配')).toBeTruthy();
+ expect(await screen.findByText('能读取 Claude 订阅用量时,先用配额快重置的电脑,再选用量低的,相近时按组策略')).toBeTruthy();
+ expect(screen.getByRole('radio', { name: '最少占用' }).getAttribute('aria-checked')).toBe('true');
+ expect(screen.getByText('给最闲的那台')).toBeTruthy();
+ expect(screen.queryByRole('radio', { name: '用量均衡' })).toBeNull();
+ fireEvent.click(screen.getByRole('radio', { name: '按顺序' }));
+ await waitFor(() => expect(stored?.strategy).toBe('order'));
});
- it('does not offer subscription balancing for an API key connection', async () => {
+ it.each([
+ { kind: 'API-only', members: [LOCAL] },
+ { kind: 'mixed local API and remote subscription', members: [LOCAL, MINI] },
+ ])('explains when quota overrides the strategy for a $kind group', async ({ members }) => {
+ realLocale = createInstance();
+ await realLocale.init({ lng: 'zh-CN', resources: { 'zh-CN': { translation: zhCN } }, interpolation: { escapeValue: false } });
providerState.providers[0].auth.method = 'api-key';
+ // Group views do not expose remote authentication types; the local connection cannot gate this explanation.
+ stored = { strategy: 'order', autoSwitch: true, members };
+ render(<ProviderGroupSection providerId="anthropic" providerName="Anthropic" />);
+ await screen.findAllByTestId('provider-group-member');
+ expect(screen.getByText('能读取 Claude 订阅用量时,先用配额快重置的电脑,再选用量低的,相近时按组策略')).toBeTruthy();
+ expect(screen.getByRole('radio', { name: '按顺序' }).getAttribute('aria-checked')).toBe('true');
+ expect(screen.queryByRole('radio', { name: '用量均衡' })).toBeNull();
+ });
+
+ it('shows the quota hint for a subscription group', async () => {
stored = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
render(<ProviderGroupSection providerId="anthropic" providerName="Anthropic" />);
await screen.findAllByTestId('provider-group-member');
- expect(screen.queryByRole('radio', { name: 'providerGroup.strategy.usage' })).toBeNull();
+ expect(screen.getByText('providerGroup.strategy.quotaFirst')).toBeTruthy();
});
});
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index a9aa328f51..b603997e06 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -473,13 +473,12 @@
"round": "Round Robin",
"order": "In Order",
"weight": "By Weight",
- "usage": "Usage Balancing",
+ "quotaFirst": "When Claude subscription usage is available, prefer computers whose quota resets soon, then those with lower usage; apply the group strategy among similar ones",
"description": {
"least": "Goes to the least busy one",
"round": "Rotates across computers",
"order": "Earlier in the list first",
- "weight": "Split by weight",
- "usage": "Balance 5-hour and weekly usage"
+ "weight": "Split by weight"
}
},
"autoSwitch": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 104f713322..c506f58a24 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -470,13 +470,12 @@
"round": "順番に",
"order": "並び順",
"weight": "重み付け",
- "usage": "使用量で分散",
+ "quotaFirst": "Claude サブスクリプションの使用量を取得できる場合、クォータのリセットが近いパソコンを優先し、次に使用量の少ないものを選びます。同程度ならグループの割り当て方式で選びます",
"description": {
"least": "空いているパソコンへ",
"round": "順番に割り当て",
"order": "上のパソコンを優先",
- "weight": "重みの比率で",
- "usage": "5時間・週間の使用量で分散"
+ "weight": "重みの比率で"
}
},
"autoSwitch": {
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 23c8d9c0bf..85ef41627a 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -470,13 +470,12 @@
"round": "순환",
"order": "순서대로",
"weight": "가중치",
- "usage": "사용량 균형",
+ "quotaFirst": "Claude 구독 사용량을 확인할 수 있으면 할당량 초기화가 가까운 컴퓨터를 우선하고, 그다음 사용량이 적은 컴퓨터를 선택합니다. 비슷하면 그룹 배정 방식을 따릅니다",
"description": {
"least": "가장 여유로운 컴퓨터로",
"round": "차례대로 배정",
"order": "목록 앞쪽 우선",
- "weight": "가중치 비율로",
- "usage": "5시간·주간 사용량에 따라 배정"
+ "weight": "가중치 비율로"
}
},
"autoSwitch": {
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
index 1b55093c8a..f418ab0a22 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -470,13 +470,12 @@
"round": "轮询",
"order": "按顺序",
"weight": "按权重",
- "usage": "用量均衡",
+ "quotaFirst": "能读取 Claude 订阅用量时,先用配额快重置的电脑,再选用量低的,相近时按组策略",
"description": {
"least": "给最闲的那台",
"round": "依次轮流",
"order": "排前面的优先",
- "weight": "按权重比例",
- "usage": "按5小时和每周用量分配"
+ "weight": "按权重比例"
}
},
"autoSwitch": {
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
index b254184594..10c19037a7 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -470,13 +470,12 @@
"round": "輪詢",
"order": "依順序",
"weight": "依權重",
- "usage": "用量均衡",
+ "quotaFirst": "能讀取 Claude 訂閱用量時,先用配額快重置的電腦,再選用量低的,相近時依組策略",
"description": {
"least": "給最閒的那臺",
"round": "依序輪流",
"order": "排前面的優先",
- "weight": "依權重比例",
- "usage": "按5小時和每週用量分配"
+ "weight": "依權重比例"
}
},
"autoSwitch": {
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 272ec1d628..b907340176 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -1007,6 +1007,8 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
- **可选策略枚举扩展**:本地组配置与同账号组摘要的 `strategy` 增加 `usage`,原默认 `least` 不变。
旧版桌面读取未知策略时归一化为 `least`,旧版手机不依赖这个字段;远程 `pick` 仍由组所在电脑执行,因此
旧控制端连接新组所在电脑也能使用新策略。组所在电脑降级后按 `least` 分配,旧版再次保存组设置会写回 `least`。
+ 2026-10-15 起配额排序(快到期先用、已用百分比低的先用)对所有策略生效,设置界面不再提供 `usage`;枚举值与归一化
+ 保持不变,已存的 `usage` 照常读写,挑法与 `least` 相同。这只改组所在电脑本机的选择,不新增字段、不改通道。
- **复用已有同账号通道**:向成员电脑调用 `maker:usage:claude-subscription`,参数 `[member.providerId]`;本机走同一
订阅 reader。只信与请求一致的 `providerId` 回显;旧端未回显时仅允许默认 `anthropic`,具名账号按未知用量处理,
避免旧端忽略参数后拿默认账号的额度代替。通道不可用、失败、超时或快照过期时按未知处理,分配照常进行。
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index 8af9ba2f26..b65a363fc8 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -26,6 +26,10 @@
> 2026-10-11 用户确认:**换不换电脑统一成一个判定**——新建任务、工作中、发送前、协同、分享的人、手机都问同一处
> (`provider-group/failurePolicy.ts`);**默认出问题就换**,只有换到哪台都一样、或不是那台电脑的问题时不换;本机的操作不打断
> 进行中的远程一轮。见 §6.1「怎么判断换不换」。
+> 2026-10-15 用户裁决:**组策略谁用都是一套**——撤掉 2026-10-12 的「本机自用优先」,本机自己的任务与同账号其他电脑、
+> 分享的人一样按组策略分配,本机只是组里普通的一台;「暂停对外分配」仍只拦外部新任务。同日要求**配额先比、快到期的先用**
+> (目的是尽快把快重置的配额用掉):不论选哪种组策略,都先用每周配额 5 小时内重置的,然后是 5 小时配额 1 小时内重置的,
+> 再选已用百分比低的;组策略只在用量相近的几台里挑,「用量均衡」不再单列为选项,见 §5。
> 实现进度见 §12:P1 已实现;P2 全部已实现:同账号直连与模型列表只显示组(P2a)、分享的人经组中转与启动阶段换电脑(P2b)、
> 分享的人运行中换电脑与申请弹窗新说法(P2c);P3 已做按人用量与按组内电脑展开(§7)。
> 交互设计稿见 [`docs/design-previews/provider-groups/index.html`](../design-previews/provider-groups/index.html)。
@@ -40,8 +44,8 @@
不用自己挑电脑,哪台忙、离线或撞到用量上限时自动换一台,并且能把这个入口分享给别人。
做法是在某台电脑(下称**组所在电脑**)的某个供应商下建一个**供应商组**,把其他电脑上的同一个
-供应商加进来。本机自己的新任务优先本机,本机不可用时才按**组策略**选其他**组内电脑**;
-其他电脑与分享的人的新任务按组策略分配(2026-10-12 用户裁决)。组管理以下使用:
+供应商加进来。新任务按**组策略**选一台**组内电脑**,本机自己的任务、其他电脑与分享的人的任务都是同一套
+(2026-10-15 用户裁决)。组管理以下使用:
- 组所在电脑自己的任务;
- 同账号的其他电脑把组所在电脑的这个供应商当远程供应商使用(组所在电脑选电脑,那台电脑直接连过去);
@@ -69,7 +73,7 @@
- **组内电脑就是这台电脑已经能用的同一个供应商**,与模型列表里远程供应商区域是同一个来源。自己的电脑和
别人的电脑走同一套规则,与现有「自己用和被分享走同一套」一致(供应商分享 §3、§5):
1. **本机**:默认在组里,可以暂停对外分配。暂停只限制接收本机以外的新任务,不影响本机自用;
- 本机自己的新任务仍优先在本机运行,只有本机不可用时才选其他组内电脑。
+ 本机自己的新任务与其他使用方一样按组策略选电脑,不另设本机优先(2026-10-15)。
2. **已经能用的远程供应商**:同账号电脑上已打开「允许被远程调用」的,和别人分享给这个账号的,在同一个列表里
勾选加入,不需要再申请。
3. **还不能用的别人的电脑**:粘贴对方的分享链接,流程与加入分享相同:预览 → 发送申请 → 双方核对配对码
@@ -102,9 +106,9 @@
## 4. 哪些使用走组
-- 判断是否归组依据任务实际使用的供应商连接。§1 的三种使用共用绑定与故障恢复规则,初次分配与故障重选均区分来源:
- 组所在电脑自己的任务优先本机,不受本机的对外暂停、并发上限与组策略影响;本机不可用时才按组策略回退。
- 同账号其他电脑与分享的人的任务仍按组策略,尊重本机暂停对外分配。
+- 判断是否归组依据任务实际使用的供应商连接。§1 的三种使用共用绑定、故障恢复与组策略(2026-10-15):
+ 初次分配与故障重选都按组策略选电脑,只有本机的「暂停对外分配」区分来源——它拦同账号其他电脑与分享的人的任务,
+ 不拦组所在电脑自己的任务。
任务归属以任务所在电脑为准,手机或远控操作该电脑上的任务不把它变成外部新任务。
- 组内电脑是本机时,Agent 直接在本机运行,与现在一致。
- **组所在电脑自己的任务**:组内电脑是其他电脑时,组所在电脑作为控制端连过去:对「我的其他电脑」是同账号远程 Agent;
@@ -138,14 +142,15 @@
## 5. 组策略
-- **本机自用优先(2026-10-12 用户裁决)**:只要本机供应商与所选模型可用、不在冷却中且本轮没失败过,
- 本机自己的新任务就先在本机运行,即使组里别的电脑更空闲、本机已到并发上限或暂停对外分配。
- 下述订阅额度预筛选同样适用:可信快照显示所需额度耗尽时本机不可用,未知用量不阻塞本机优先。
- 本机任务已分到远端、远端发生启动失败、运行中故障或发送前故障,需要重选时,本机若已恢复可用,仍优先本机
- (2026-10-12 用户再次确认);本机不可用时才按下述策略选其他电脑。正常运行的任务不会仅因本机恢复而自动迁回。
- 本机优先由主进程的本机任务入口决定,远程请求与分享中转不能自报“本机任务”来绕过暂停。
+- **谁用都是一套(2026-10-15 用户裁决,撤销 2026-10-12 的「本机自用优先」)**:组所在电脑自己的任务、同账号其他电脑、
+ 分享的人,初次分配与故障重选都按同一个组策略、同一套可用性与并发上限选电脑,本机只是组里普通的一台。
+ 唯一的区别是本机的「暂停对外分配」只拦外部任务,组所在电脑自己的任务仍可以分到本机;这个豁免只由主进程的本机任务入口
+ 给出,远程请求与分享中转不能自报“本机任务”来绕过暂停。正常运行的任务不会因此迁移。
+ 代价(用户已知并接受):本机任务可能分到别的电脑运行,读文件、跑命令要在两台电脑之间往返;选电脑时与外部任务一样
+ 最多等组内电脑状态 3 秒。
- **选择方式**:最少占用(默认,选正在运行任务最少的那台)、轮询、按顺序(排在前面的优先,前面的不可用才用后面的)、
- 按权重、用量均衡(Claude Code 订阅组)。已有组与新组的默认仍为最少占用。
+ 按权重。读得到 Claude Code 订阅用量时,先按下方「配额先比」筛,组策略只在剩下的几台里挑(2026-10-15)。
+ 原来单列的「用量均衡」不再出现在设置里;已经存了它的组挑法与最少占用相同,界面按最少占用显示,用户改选时才写回新值。
- **并发上限**:每台组内电脑单独设置,默认 4,最多 16(远程 Agent 对每个控制端的上限);只统计经本组分到这台的任务,
包括同账号其他电脑经本组直连过去的任务:它们由任务所在的电脑在每一轮开始、结束时报告,运行期间每分钟再报一次,
组所在电脑 150 秒收不到就不再计入;刚选中、还没报告的任务先按占用记 30 秒,同时开的几个任务不会全落到同一台。
@@ -159,7 +164,8 @@
Agent 在别处运行的任务算在别处,转给组内另一台的任务算在那一台,不重复计。本机现算;同账号电脑在给本账号电脑的
供应商目录里报告(`runningTurns`),只报允许被远程调用的供应商,分享出去的目录里去掉,受邀者看不到。取值方式、
刷新时间与分享来的电脑相同;那台是旧版本时不报,照旧只算经本组的。因为算的是全部任务,那台的主人自己在用时
- 也会占它的并发上限。
+ 也会占它的并发上限。本机负载与目录并行读取,负载单次最多等 1 秒;超时或失败不影响已确认可用的本机,这一轮改用现有的经组占用计数,
+ 迟到的负载读数不改变已经返回的结果。回归见 `directory.test.ts` 与 `router.test.ts`。
- **只分给可用的电脑**:在线;对方仍允许远程控制,且仍对这个供应商允许被远程调用;分享未暂停、未删除;
不在冷却中;提供所选模型;未被设为「暂停分配」(本机自己的任务使用本机除外)。按组策略分配时优先分给未达到并发上限的;都满了时分给相对最空的一台,
并发上限只用来分摊,不因满载拒绝消息。
@@ -168,10 +174,21 @@
不必先运行失败一次。重置时刻与 [用量上限自动继续](usage-limit-auto-continue.md) 共用判定;已过重置时刻的旧窗口不再阻塞。
组状态把总窗口耗尽显示为冷却中;模型专属周额度只影响对应模型,不能把其他模型一起封住。快照判断不写入持久冷却,
原来由实际错误产生的冷却照旧保留。
- - **用量均衡**:先做上述排除,再从未达到并发上限的候选中比较 5 小时、总周与当前模型专属周窗口的
- **最高已用百分比**,越低越优先;与最低值相差不超过 5 个百分点时,选正在运行任务少的那台。
- 两个总窗口都有效且已知才参与比较;有对应模型的专属窗口时,它也必须有效。缺失值不当成 0%;
- 有可信用量的候选优先,没有时回退最少占用。全部达到并发上限时也回退最少占用。
+ - **配额先比**(2026-10-15 用户裁决:目的是尽快把快重置的配额用掉;不论选哪种组策略都先做这一步):先做上述排除,
+ 再在未达到并发上限的候选里先保留用量完整的电脑(窗口有效性见第 2 条),然后依次筛;全部读不到用量时不比较重置时间,
+ 也不按用量筛,原样交给组策略:
+ 1. **快到期的配额先用**:总周配额 5 小时内就重置、还没用完的先用;没有时,5 小时配额 1 小时内就重置、还没用完的
+ 先用。同一档里先用重置最早的;重置时刻相差 10 分钟以内的算同时,一起进入下一条。重置时刻未知、已过或配额已用完的
+ 不算快到期。
+ 2. **已用百分比低的先用**:比较 5 小时、总周与当前模型专属周窗口的**最高已用百分比**,只留与最低值相差不超过
+ 5 个百分点的几台。两个总窗口都有效且已知才参与比较;有对应模型的专属窗口时,它也必须有效。缺失值不当成 0%;
+ 读不到用量的电脑(别人分享的、非 Claude 订阅的)排在读得到的后面,全部读不到时不筛。
+ 3. **组策略在剩下的几台里挑**:最少占用选运行任务少的,按顺序选排在前面的,轮询接着上次往下轮,按权重按比例随机。
+ 全部达到并发上限时同样先按第 1、2 条筛,再选运行任务最少的;未满载的电脑永远排在满载的前面。设置页在组策略下始终显示适用条件与规则
+ 「能读取 Claude 订阅用量时,先用配额快重置的电脑,再选用量低的,相近时按组策略」;不能仅按组所属的本机连接类型隐藏说明,
+ 因为 API Key 连接建的组也能包含同品牌的远端订阅账号。实现见 `apps/desktop/src/main/provider-group/scheduler.ts`
+ 与 `apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx`,回归见同目录
+ `__tests__/scheduler.test.ts`、`router.usage.test.ts` 与 `ProviderGroupSection.test.tsx`。
- **取数与兜底**:复用原生 CLI 的订阅用量读取,不读凭证、不新增订阅 API 请求;每台按自己的供应商账号读取。
同账号远端快照短缓存 15 秒,同账号同一请求在途去重;单次最多等待 1.5 秒,超时或旧端不支持时按未知用量继续,
后台晚到结果供后续分配使用。快照超过 10 分钟或时间异常时不用于排除与排序;已重置但还没刷新的窗口也不当成零用量。
@@ -204,7 +221,7 @@
## 6. 任务与组内电脑的绑定
-- 任务第一次在组里运行时按 §5(本机任务优先本机,其余按组策略)选定一台组内电脑,之后固定在这台:对话记录保存在那台电脑上。只有正常运行时才保持
+- 任务第一次在组里运行时按 §5 的组策略选定一台组内电脑,之后固定在这台:对话记录保存在那台电脑上。只有正常运行时才保持
固定;那台电脑出问题时按下面的规则**自动换电脑**,不需要用户操作。
- 正在正常运行的任务不会因为组策略变化或其他电脑空闲而迁移。
- 只给从没运行过的任务按 §5 选电脑。已经运行过、正用着组那一项的任务不按策略挪走:留在原处并纳入组,之后出问题时
@@ -253,8 +270,8 @@
控制操作,不会因为 Agent 所在那台暂时连不上就把正在跑的一轮杀掉:没有要改的不去碰运行中的会话;要改而那台回不来时,这一轮结束后
再按已保存的设置重建。本机主动关掉会话不是那台电脑的问题,不触发换电脑。
- **怎么换**:
- - **重新选哪台**:沿用 §5 的来源规则,本机自己的任务仍优先可用本机,本机不可用才按组策略选择;
- 同账号其他电脑与分享的人的任务继续按组策略分配。连不上时先等原电脑恢复的规则不变。
+ - **重新选哪台**:沿用 §5,谁的任务都按组策略重选(本机恢复了也不优先回到本机);只有本机的「暂停对外分配」
+ 不拦组所在电脑自己的任务。连不上时先等原电脑恢复的规则不变。
- **还没开始运行**(打开任务、Agent 启动阶段)失败:直接换下一台,没有可感知的中断。
- **运行中失败**:把这台标为不可用(用量上限进入冷却,§5),复用现有的跨电脑交接,把任务交接到按上述规则选出的
下一台:新建会话并带上交接上下文,然后继续这一轮——这一轮还没有产出就重发原消息,已经有产出就发续跑指令,
@@ -492,7 +509,7 @@
并发上限(按权重时多一个权重)→ 参与分配开关 → 行内 `···` 菜单。三条由此固定:
- **参与分配只有一种控件。** `paused` 是同一个布尔值,本机与远程都用开关表达,不按来源分叉成
「开关 / 暂停分配按钮」两套;暂停后的含义由状态行文字说明,不另弹 toast。
- 本机这一行的暂停只限制接收外部新任务,本机自用优先与故障恢复不受影响(§5)。
+ 本机这一行的暂停只限制接收外部新任务,本机自己的任务仍可分到本机,故障恢复不受影响(§5)。
- **运行数是状态,上限是设置。** 运行数只出现在状态行,上限只出现在下拉里,同一个数字不在一行里说两遍。
**能用时状态词本身报负载**:跑 0 个说「空闲」,跑了就说「{N} 个任务运行中」,不写「可用」——
否则组里都空着时整列没有数字,看不出每台在跑几个。「已满」等于跑满上限,不再重复报数。
@@ -578,11 +595,11 @@
## 13. 验收
1. 链接的供应商与组不是同一个(§3 口径)、链接属于自己账号、链接失效时不发送申请,并给出对应提示。
-2. 组所在电脑自己的新任务优先本机,不受本机对外暂停、负载与组策略影响;本机不可用时才按组策略回退。
- 已分到远端的本机任务在启动、运行中或发送前故障后重新选择时仍优先已恢复的本机;正常运行的任务留在原电脑。
- 同账号其他电脑、分享的人的任务按组策略分配并尊重暂停;离线、冷却、不提供模型或可信快照显示所需 Claude 订阅额度
- 已耗尽的电脑不选(额度预筛选也适用于本机自用优先)。按组策略分配时优先未满载的,全部满载时仍选运行任务最少的。
- 用量均衡遵守 §5 的两步筛选、5 个百分点内按占用分摊与未知用量兜底,重置后的旧窗口不再阻塞。
+2. 组所在电脑自己的任务、同账号其他电脑与分享的人的任务,初次分配与故障重选都按同一个组策略选电脑;本机的
+ 对外暂停只拦外部任务。正常运行的任务留在原电脑。离线、冷却、不提供模型或可信快照显示所需 Claude 订阅额度
+ 已耗尽的电脑不选。按组策略分配时优先未满载的,全部满载时仍选运行任务最少的。
+ 所有组策略都先按 §5「配额先比」:先排除配额耗尽的,再按每周 5 小时内、5 小时配额 1 小时内的顺序先用快到期的
+ (重置早的先),再留已用百分比相差 5 个百分点以内的,最后由组策略挑;读不到用量时只按组策略,重置后的旧窗口不再阻塞。
3. 正常运行的任务固定在原电脑;原电脑因 §6.1 列出的原因失败时,自动交接到组内另一台继续这一轮,消息流显示换电脑的
活动记录;同一轮每台最多试一次,全部失败才报错并逐台列出原因;其中有撞上限的,等最早恢复的一台自动继续。
4. 用户停止、权限被拒、上下文超限、请求无效、内容被拒、工具出错时不换电脑;其余失败都换(含认不出的)。「故障 × 阶段」的判定表
diff --git a/i18n/GLOSSARY.md b/i18n/GLOSSARY.md
index 00c3be1d0d..1f32dd079c 100644
--- a/i18n/GLOSSARY.md
+++ b/i18n/GLOSSARY.md
@@ -309,7 +309,7 @@ Chat Server 的群角色,可由人或伙伴担任;不要与伙伴主人或
### Group Strategy
-供应商组为新任务选择组内电脑的规则:最少占用、轮询、按顺序、按权重、用量均衡。只决定新任务分到哪台,正常运行的任务不因均衡迁移。
+供应商组为新任务选择组内电脑的规则:最少占用、轮询、按顺序、按权重。读得到 Claude 订阅用量时先按配额筛(快重置的先用、用量低的先用),组策略只在用量相近的几台里挑。只决定新任务分到哪台,正常运行的任务不因均衡迁移。
### Thread (in a group chat)
@@ -599,7 +599,7 @@ Cindy 里的**持久 AI 助手实体**(原名 Bot):有长期身份、自
### Usage Balancing
-Claude 订阅供应商组的分配策略:先排除5小时或周配额耗尽的账号,再优先分给用量较低的可用账号;不迁移正常运行的任务。
+原 Claude 订阅供应商组的分配策略。2026-10-15 起配额排序(先用快重置的配额:周配额5小时内、5小时配额1小时内重置的;再选用量较低的账号)对所有组策略生效,设置里不再单列此选项,旧组存的此值按最少占用挑;不迁移正常运行的任务。
### Use my browser logins
diff --git a/i18n/glossary.json b/i18n/glossary.json
index a1e6ad2d79..2f045eecd6 100644
--- a/i18n/glossary.json
+++ b/i18n/glossary.json
@@ -2386,7 +2386,7 @@
"ko": "그룹 배정 방식"
},
"checkCase": false,
- "note": "供应商组为新任务选择组内电脑的规则:最少占用、轮询、按顺序、按权重、用量均衡。只决定新任务分到哪台,正常运行的任务不因均衡迁移。"
+ "note": "供应商组为新任务选择组内电脑的规则:最少占用、轮询、按顺序、按权重。读得到 Claude 订阅用量时先按配额筛(快重置的先用、用量低的先用),组策略只在用量相近的几台里挑。只决定新任务分到哪台,正常运行的任务不因均衡迁移。"
},
{
"id": "usage-balancing",
@@ -2399,7 +2399,7 @@
"ko": "사용량 균형"
},
"checkCase": false,
- "note": "Claude 订阅供应商组的分配策略:先排除5小时或周配额耗尽的账号,再优先分给用量较低的可用账号;不迁移正常运行的任务。"
+ "note": "原 Claude 订阅供应商组的分配策略。2026-10-15 起配额排序(先用快重置的配额:周配额5小时内、5小时配额1小时内重置的;再选用量较低的账号)对所有组策略生效,设置里不再单列此选项,旧组存的此值按最少占用挑;不迁移正常运行的任务。"
},
{
"id": "pairing-code",