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。

merge: sync main into provider-group usage balancing

MagicLizi41de219a5cdb
diff --cc apps/desktop/src/main/provider-group/__tests__/directory.test.ts
index 1c17ff106e,e9d50f40dc..63a86e3039
--- a/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/directory.test.ts
@@@ -331,32 -315,6 +331,64 @@@ describe('resolving members quickly whe
}
});
+ it('keeps an available computer when its quota read outlives the quick selection window', async () => {
+ vi.useFakeTimers();
+ try {
+ const usage = new Promise<null>(() => undefined);
+ const directory = createProviderGroupDirectory(deps({
+ readClaudeUsage: vi.fn(async () => usage),
+ }));
+ const done = vi.fn();
+ void directory.resolveMembers('anthropic', { strategy: 'usage', autoSwitch: true, members: [MINI] }, {
+ quickMs: 3_000,
+ enough: (r) => r.state === 'ok',
+ }).then(done);
+ await vi.advanceTimersByTimeAsync(2_999);
+ expect(done).not.toHaveBeenCalled();
+ await vi.advanceTimersByTimeAsync(1);
+ expect(done).toHaveBeenCalledTimes(1);
+ const resolved = done.mock.calls[0][0] as Array<{ state: string; pending?: boolean; claudeUsage?: unknown }>;
+ expect(resolved).toHaveLength(1);
+ expect(resolved[0]).toMatchObject({ state: 'ok' });
+ expect(resolved[0].pending).toBeUndefined();
+ expect(resolved[0].claudeUsage).toBeUndefined();
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
++ it('keeps waiting when the completed quota makes the known computer unavailable', async () => {
++ vi.useFakeTimers();
++ try {
++ const directory = createProviderGroupDirectory(deps({
++ listDevices: async () => [device('mini'), device('slow')],
++ readDeviceProviders: vi.fn((id: string) => id === 'slow'
++ ? new Promise<ProviderView[]>((resolve) => {
++ setTimeout(() => resolve([view('anthropic', 'Claude')]), 4_000);
++ })
++ : Promise.resolve([view('anthropic-1a2b3c4d', 'Claude')])),
++ readClaudeUsage: async (member) => member.key === MINI.key
++ ? { updatedAt: 0, fiveHour: { utilization: 100, resetsAt: 80_000 }, sevenDay: { utilization: 20, resetsAt: 80_000 } }
++ : null,
++ }));
++ const done = vi.fn();
++ void directory.resolveMembers('anthropic', config, {
++ quickMs: 3_000,
++ enough: (resolved) => resolved.state === 'ok' && resolved.claudeUsage?.fiveHour?.utilization !== 100,
++ }).then(done);
++ await vi.advanceTimersByTimeAsync(3_000);
++ expect(done).not.toHaveBeenCalled();
++ await vi.advanceTimersByTimeAsync(1_000);
++ expect(done).toHaveBeenCalledTimes(1);
++ expect(done.mock.calls[0][0]).toMatchObject([
++ { member: { key: SLOW.key }, state: 'ok' },
++ { member: { key: MINI.key }, state: 'ok', claudeUsage: { fiveHour: { utilization: 100 } } },
++ ]);
++ } finally {
++ vi.useRealTimers();
++ }
++ });
++
it('keeps waiting when none of the computers read so far can take the task', async () => {
vi.useFakeTimers();
try {
diff --cc apps/desktop/src/main/provider-group/__tests__/router.usage.test.ts
index 0664f6a8be,0000000000..99a23da4d4
mode 100644,000000..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
@@@ -1,105 -1,0 +1,140 @@@
+/** Real directory → quota eligibility → scheduler → status projection, using only in-memory accounts. */
+import type { ProviderView } from '@cindy/model-providers';
+import { describe, expect, it, vi } from 'vitest';
+import type { ClaudeSubscriptionUsageSnapshot } from '../../../shared/claudeSubscriptionUsage';
+import { normalizeProviderGroupConfig, PROVIDER_GROUP_STRATEGIES, type ProviderGroupMember } from '../../../shared/providerGroup';
+import { createProviderGroupDirectory } from '../directory';
+import { createProviderGroupRouter } from '../router';
+
+const NOW = 1_000_000;
+const OPUS = 'claude-opus-5-5';
+const SONNET = 'claude-sonnet-5';
+const view = (id: string): ProviderView => ({
+ id, name: id, agents: ['claude-code'], connected: true, auth: { method: 'oauth', native: 'claude' },
+ models: { 'claude-code': [OPUS, SONNET].map((id) => ({ id, name: id, efforts: [], defaultEffort: null })) },
+ routing: { 'claude-code': {} },
+}) as unknown as ProviderView;
+const snapshot = (fiveHour: number, sevenDay: number): ClaudeSubscriptionUsageSnapshot => ({
+ updatedAt: NOW, fiveHour: { utilization: fiveHour, resetsAt: 3_000 }, sevenDay: { utilization: sevenDay, resetsAt: 80_000 },
+});
+
+function harness() {
+ let now = NOW;
+ const config = normalizeProviderGroupConfig({
+ strategy: 'usage', members: [{ kind: 'local' }, { kind: 'device', agentDeviceId: 'mini', providerId: 'anthropic' }],
+ }, 'anthropic')!;
+ const usage = new Map<string, ClaudeSubscriptionUsageSnapshot | null>();
+ const readUsage = vi.fn(async (member: ProviderGroupMember) => usage.get(member.key) ?? null);
+ const directory = createProviderGroupDirectory({
+ listLocalProviders: async () => [view('anthropic')], localDeviceName: () => 'local',
+ listDevices: async () => [{ deviceId: 'mini', name: 'mini', online: true, remoteControlEnabled: true, controlEnabled: true,
+ isSelf: false, platform: 'darwin', appVersion: null, lastSeenAt: null, busy: false }],
+ readDeviceProviders: async () => [view('anthropic')], listReceivedShares: () => [],
+ isMobilePlatform: () => false, readClaudeUsage: readUsage, now: () => now,
+ });
+ const writeCooling = vi.fn();
+ const router = createProviderGroupRouter({
+ directory, readGroup: () => config, listBindings: () => ({}), isTurnRunning: () => false,
+ coolingStore: { read: () => ({}), write: writeCooling }, now: () => now, random: () => 0,
+ });
+ const pick = (model = OPUS, reserveFor?: string) => router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model, reserveFor });
+ return { config, usage, router, pick, writeCooling, readUsage, advance: (ms: number) => { now += ms; } };
+}
+
+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));
++ 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 } });
++ });
++
++ it.each(PROVIDER_GROUP_STRATEGIES)('applies quota prefiltering to local task priority with the %s strategy', async (strategy) => {
++ const context = harness();
++ context.config.strategy = strategy;
++ context.config.members[0].paused = true;
++ const remote = context.config.members[1].key;
++ context.usage.set(remote, snapshot(40, 60));
++ const input = { providerId: 'anthropic', agentKind: 'claude-code' as const, model: OPUS, localTask: true as const };
++ context.usage.set('local', snapshot(100, 5));
++ expect(await context.router.pick(input)).toMatchObject({ kind: 'member', member: { key: remote } });
++ context.usage.set('local', snapshot(5, 100));
++ expect(await context.router.pick(input)).toMatchObject({ kind: 'member', member: { key: remote } });
++ 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) => {
+ const h = harness();
+ h.config.strategy = strategy;
+ const remote = h.config.members[1].key;
+ h.usage.set('local', snapshot(100, 5));
+ h.usage.set(remote, snapshot(40, 60));
+ expect(await h.pick()).toMatchObject({ kind: 'member', member: { key: remote } });
+ expect((await h.router.view('anthropic')).members[0]).toMatchObject({ state: 'cooling', coolingUntil: 3_000_000 });
+ // Quota snapshots never overwrite error-derived cooldowns or turn a scoped limit into a persistent global one.
+ expect(h.writeCooling).not.toHaveBeenCalled();
+ h.usage.set('local', snapshot(5, 100));
+ expect(await h.pick()).toMatchObject({ kind: 'member', member: { key: remote } });
+ h.usage.set(remote, snapshot(100, 5));
+ expect(await h.pick()).toMatchObject({ kind: 'unavailable' });
+ });
+
+ it('balances eligible accounts by usage, reserving simultaneous assignments immediately', async () => {
+ const h = harness();
+ const remote = h.config.members[1].key;
+ h.usage.set('local', snapshot(20, 85));
+ h.usage.set(remote, snapshot(55, 40));
+ expect(await h.pick()).toMatchObject({ kind: 'member', member: { key: remote } });
+ h.usage.set('local', snapshot(20, 40));
+ h.usage.set(remote, snapshot(25, 43));
+ const assignments = await Promise.all([h.pick(OPUS, 's1'), h.pick(OPUS, 's2')]);
+ expect(assignments.map((p) => p.kind === 'member' ? p.member.key : p.kind)).toEqual(['local', remote]);
+ });
+
+ it('keeps model-specific limits out of the group-wide availability state', async () => {
+ const h = harness();
+ const remote = h.config.members[1].key;
+ h.usage.set('local', { ...snapshot(10, 20), scoped: [{ modelDisplayName: 'Opus', utilization: 100, resetsAt: 80_000 }] });
+ h.usage.set(remote, snapshot(40, 60));
+ expect(await h.pick(OPUS)).toMatchObject({ kind: 'member', member: { key: remote } });
+ expect(await h.pick(SONNET)).toMatchObject({ kind: 'member', member: { key: 'local' } });
+ expect((await h.router.view('anthropic')).members[0].state).toBe('available');
+ expect((await h.router.view('anthropic', OPUS)).members[0].state).toBe('cooling');
+ expect((await h.router.view('anthropic', SONNET)).members[0].state).toBe('available');
+ expect(h.router.coolingUntil('anthropic', 'local')).toBeNull();
+ });
+
+ it('does not promise an earlier recovery time when an exhausted window has no reset', async () => {
+ const h = harness();
+ h.usage.set('local', { ...snapshot(100, 20), fiveHour: { utilization: 100, resetsAt: null } });
+ h.router.markCooling('anthropic', 'local', NOW + 60_000);
+ const status = (await h.router.view('anthropic')).members[0];
+ expect(status.state).toBe('cooling');
+ expect(status.coolingUntil).toBeUndefined();
+ });
+
+ it('falls back for missing/failed data and releases old quota blocks after reset', async () => {
+ const h = harness();
+ h.usage.set('local', snapshot(100, 10));
+ const remote = h.config.members[1].key;
+ expect(await h.pick()).toMatchObject({ kind: 'member', member: { key: remote } });
+ h.advance(2_000_000);
+ expect(await h.pick()).toMatchObject({ kind: 'member', member: { key: 'local' } });
+ h.readUsage.mockRejectedValue(new Error('unreachable'));
+ expect(await h.pick()).toMatchObject({ kind: 'member', member: { key: 'local' } });
+ });
+});
diff --cc apps/desktop/src/main/provider-group/directory.ts
index 72dcd301c5,c3bc8581c5..d3eb41aef7
--- a/apps/desktop/src/main/provider-group/directory.ts
+++ b/apps/desktop/src/main/provider-group/directory.ts
@@@ -271,9 -259,8 +273,9 @@@ export function createProviderGroupDire
clearTimeout(timer);
}
const enough = options.enough;
- if (!enough || (!settled.some((value) => value !== undefined && enough(value))
- && !partial.some((value) => value !== undefined && enough(value)))) return all;
- return members.map((member, index) => settled[index] ?? partial[index] ?? pendingMember(member));
- if (!enough || !settled.some((value) => value !== undefined && enough(value))) return all;
- return members.map((member, index) => settled[index] ?? pendingMember(member));
++ const resolved = members.map((member, index) => settled[index] ?? partial[index] ?? pendingMember(member));
++ if (!enough || !resolved.some(enough)) return all;
++ return resolved;
}
return {
@@@ -289,22 -275,13 +291,21 @@@
// 无响应时选电脑会等它的完整网络超时,而不是三秒后继续(chatgpt-codex-connector P2,
// PR #5792 review)。
const deviceListPromise = needsDevices ? readDevices().catch(() => null) : Promise.resolve(null);
- const partialReads = config.members.map(async (member) => {
- const resolved = member.kind === 'local' ? await resolveLocal(member)
- : member.kind === 'share' ? await resolveShare(member)
- : await resolveDevice(member, await deviceListPromise);
- return resolved;
- const reads = config.members.map((member) => {
++ const partialReads = config.members.map((member) => {
+ if (member.kind === 'local') return resolveLocal(member, options?.includeLocalRunning);
+ if (member.kind === 'share') return resolveShare(member);
+ return deviceListPromise.then((deviceList) => resolveDevice(member, deviceList));
});
+ const reads = partialReads.map(async (read, index) => {
+ const member = config.members[index]!;
+ const resolved = await read;
+ if (member.kind === 'share' || resolved.state !== 'ok' || !resolved.view?.auth
+ || providerWeeklyQuotaSource(resolved.view) !== 'claude' || !deps.readClaudeUsage) return resolved;
+ const claudeUsage = await deps.readClaudeUsage(member).catch(() => null);
+ return { ...resolved, claudeUsage };
+ });
if (options?.quickMs === undefined) return Promise.all(reads);
- return settleQuickly(config.members, reads, options);
+ return settleQuickly(config.members, reads, partialReads, options);
},
async offlineForMs(agentDeviceId) {
diff --cc apps/desktop/src/main/provider-group/router.ts
index 45dfd9956f,d606c18650..2f7bd7cb88
--- a/apps/desktop/src/main/provider-group/router.ts
+++ b/apps/desktop/src/main/provider-group/router.ts
@@@ -198,16 -202,30 +203,31 @@@ export function createProviderGroupRout
const config = deps.readGroup(input.providerId);
if (!config) return { kind: 'none' };
const usable = (r: ResolvedProviderGroupMember) =>
- offersModel(r, input.agentKind, input.model) && coolingUntil(input.providerId, r.member.key) === null;
+ offersModel(r, input.agentKind, input.model) && coolingUntil(input.providerId, r.member.key) === null
+ && !providerGroupUsageState(r.claudeUsage, input.model, deps.now()).limited;
- const resolved = await deps.directory.resolveMembers(input.providerId, config, {
- quickMs: PROVIDER_GROUP_PICK_QUICK_MS,
- // 已经有一台能用、可以分的电脑(满载仍可接):不再等慢的那几台。未满优先由调度器决定。
- enough: (r) => usable(r)
- && !r.member.paused
- && !input.exclude?.has(r.member.key),
- ...(input.fresh ? { fresh: true } : {}),
- });
+ 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),
@@@ -215,9 -233,9 +235,10 @@@
running: memberRunning(input.providerId, r),
limit: r.member.limit,
weight: r.member.weight,
+ usagePercent: providerGroupUsageState(r.claudeUsage, input.model, deps.now()).usagePercent,
}));
- const key = pickProviderGroupMember(schedulable, config.strategy, {
+ const preferred = resolved.find((r) => ownLocal(r) && usable(r) && !input.exclude?.has(r.member.key));
+ const key = preferred?.member.key ?? pickProviderGroupMember(schedulable, config.strategy, {
exclude: input.exclude,
lastPicked: lastPicked.get(input.providerId) ?? null,
random: deps.random,
diff --cc apps/desktop/src/main/provider-group/service.ts
index 6d5b85c2ee,76339f97c8..9dac72e6b8
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@@ -1639,9 -1662,10 +1665,10 @@@ export function createProviderGroupServ
const row = await deps.readSessionRow(sessionId);
if (!row?.model || row.remoteHostId) return;
const current = await verifyBinding(sessionId, source, binding, config, row);
- // 暂停分配只影响新任务,已在那台的任务不挪走。
- if (!current || current.paused) return;
+ // 本机的暂停只限制接外部新任务,本机自用仍照常检查故障并恢复。
+ // 其他组员的暂停继续保持既有任务位置。
+ if (!current || (current.paused && !(source.ownerDeviceId === null && current.kind === 'local'))) return;
- const cached = await source.shouldMoveAway(binding.providerId, config, current.key);
+ const cached = await source.shouldMoveAway(binding.providerId, config, current.key, row.model);
if (cached === null) return;
let reason = cached ? cached.reason : null;
const currentRoute = source.routeOf(current, row.providerId);
diff --cc docs/product-rules/provider-groups.md
index ea658dd0e2,d887b15f96..036b1748c1
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@@ -132,8 -137,13 +137,14 @@@
## 5. 组策略
+ - **本机自用优先(2026-10-12 用户裁决)**:只要本机供应商与所选模型可用、不在冷却中且本轮没失败过,
+ 本机自己的新任务就先在本机运行,即使组里别的电脑更空闲、本机已到并发上限或暂停对外分配。
++ 下述订阅额度预筛选同样适用:可信快照显示所需额度耗尽时本机不可用,未知用量不阻塞本机优先。
+ 本机任务已分到远端、远端发生启动失败、运行中故障或发送前故障,需要重选时,本机若已恢复可用,仍优先本机
+ (2026-10-12 用户再次确认);本机不可用时才按下述策略选其他电脑。正常运行的任务不会仅因本机恢复而自动迁回。
+ 本机优先由主进程的本机任务入口决定,远程请求与分享中转不能自报“本机任务”来绕过暂停。
- **选择方式**:最少占用(默认,选正在运行任务最少的那台)、轮询、按顺序(排在前面的优先,前面的不可用才用后面的)、
- 按权重。
+ 按权重、用量均衡(Claude Code 订阅组)。已有组与新组的默认仍为最少占用。
- **并发上限**:每台组内电脑单独设置,默认 4,最多 16(远程 Agent 对每个控制端的上限);只统计经本组分到这台的任务,
包括同账号其他电脑经本组直连过去的任务:它们由任务所在的电脑在每一轮开始、结束时报告,运行期间每分钟再报一次,
组所在电脑 150 秒收不到就不再计入;刚选中、还没报告的任务先按占用记 30 秒,同时开的几个任务不会全落到同一台。
@@@ -149,26 -159,8 +160,26 @@@
刷新时间与分享来的电脑相同;那台是旧版本时不报,照旧只算经本组的。因为算的是全部任务,那台的主人自己在用时
也会占它的并发上限。
- **只分给可用的电脑**:在线;对方仍允许远程控制,且仍对这个供应商允许被远程调用;分享未暂停、未删除;
- 不在冷却中;提供所选模型;未被设为「暂停分配」。优先分给未达到并发上限的;都满了时分给相对最空的一台,
+ 不在冷却中;提供所选模型;未被设为「暂停分配」(本机自己的任务使用本机除外)。按组策略分配时优先分给未达到并发上限的;都满了时分给相对最空的一台,
并发上限只用来分摊,不因满载拒绝消息。
+- **先排除额度耗尽,再比较用量**(2026-10-12 用户确认):所有组策略都复用上面的可用性筛选;本机与同账号电脑上的
+ Claude Code 订阅另读已有的订阅用量快照,5 小时、总周额度或当前模型专属周额度任一用完,就不再分给它,
+ 不必先运行失败一次。重置时刻与 [用量上限自动继续](usage-limit-auto-continue.md) 共用判定;已过重置时刻的旧窗口不再阻塞。
+ 组状态把总窗口耗尽显示为冷却中;模型专属周额度只影响对应模型,不能把其他模型一起封住。快照判断不写入持久冷却,
+ 原来由实际错误产生的冷却照旧保留。
+ - **用量均衡**:先做上述排除,再从未达到并发上限的候选中比较 5 小时、总周与当前模型专属周窗口的
+ **最高已用百分比**,越低越优先;与最低值相差不超过 5 个百分点时,选正在运行任务少的那台。
+ 两个总窗口都有效且已知才参与比较;有对应模型的专属窗口时,它也必须有效。缺失值不当成 0%;
+ 有可信用量的候选优先,没有时回退最少占用。全部达到并发上限时也回退最少占用。
+ - **取数与兜底**:复用原生 CLI 的订阅用量读取,不读凭证、不新增订阅 API 请求;每台按自己的供应商账号读取。
+ 同账号远端快照短缓存 15 秒,同账号同一请求在途去重;单次最多等待 1.5 秒,超时或旧端不支持时按未知用量继续,
+ 后台晚到结果供后续分配使用。快照超过 10 分钟或时间异常时不用于排除与排序;已重置但还没刷新的窗口也不当成零用量。
+ 重试选电脑时清掉短缓存。账号切换后丢弃旧账号的读取结果。
+ - **分享边界**:不读取别人分享来的电脑的订阅配额,按未知用量处理,仍复用现有可用性与失败后换电脑;
+ 组所在电脑为受邀者选电脑时可以使用自己组内的同账号配额,但不向受邀者返回配额。
+ - 正常运行的任务不因用量差距而迁移;新任务和需要换电脑时才按此策略分配。
+ - 已经绑定的任务在发送前由组所在电脑按本次模型重新核对额度;总窗口或该模型专属周窗口耗尽时换电脑,
+ 快照未知时不因额度判断阻塞发送。
- **冷却**:组内电脑上的任务报用量上限时,这台电脑进入冷却,不再接新任务。重置时刻按
[用量上限自动继续](usage-limit-auto-continue.md) 的口径取(不采用不带时区的钟点);取不到时默认冷却 30 分钟。
冷却不主动迁移这台电脑上正在运行的其他任务;它们自己撞到上限时再按 §6.1 换电脑。
@@@ -530,9 -529,9 +549,11 @@@
## 13. 验收
1. 链接的供应商与组不是同一个(§3 口径)、链接属于自己账号、链接失效时不发送申请,并给出对应提示。
- 2. 组所在电脑、同账号其他电脑、分享的人三种使用都按组策略分配;离线、冷却、暂停分配、不提供所选模型,或可信快照显示
- 所需 Claude 订阅额度已耗尽的电脑不会被选中。优先未满载的,全部满载时仍选运行任务最少的。用量均衡遵守 §5 的
- 两步筛选、5 个百分点内按占用分摊与未知用量兜底,重置后的旧窗口不再阻塞。
+ 2. 组所在电脑自己的新任务优先本机,不受本机对外暂停、负载与组策略影响;本机不可用时才按组策略回退。
+ 已分到远端的本机任务在启动、运行中或发送前故障后重新选择时仍优先已恢复的本机;正常运行的任务留在原电脑。
- 同账号其他电脑、分享的人的任务按组策略分配并尊重暂停;离线、冷却或不提供模型的电脑不选,满载按 §5 分摊。
++ 同账号其他电脑、分享的人的任务按组策略分配并尊重暂停;离线、冷却、不提供模型或可信快照显示所需 Claude 订阅额度
++ 已耗尽的电脑不选(额度预筛选也适用于本机自用优先)。按组策略分配时优先未满载的,全部满载时仍选运行任务最少的。
++ 用量均衡遵守 §5 的两步筛选、5 个百分点内按占用分摊与未知用量兜底,重置后的旧窗口不再阻塞。
3. 正常运行的任务固定在原电脑;原电脑因 §6.1 列出的原因失败时,自动交接到组内另一台继续这一轮,消息流显示换电脑的
活动记录;同一轮每台最多试一次,全部失败才报错并逐台列出原因;其中有撞上限的,等最早恢复的一台自动继续。
4. 用户停止、权限被拒、上下文超限、请求无效、内容被拒、工具出错时不换电脑;其余失败都换(含认不出的)。「故障 × 阶段」的判定表