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。

fix(desktop): 供应商组本机自用优先且不受对外暂停影响 (#5864)

DavidShenXDd46dd4b108ef
diff --git a/apps/desktop/src/main/cindy-media/__tests__/taskImageDelivery.test.ts b/apps/desktop/src/main/cindy-media/__tests__/taskImageDelivery.test.ts
index 22dae78c1c..d639e079d0 100644
--- a/apps/desktop/src/main/cindy-media/__tests__/taskImageDelivery.test.ts
+++ b/apps/desktop/src/main/cindy-media/__tests__/taskImageDelivery.test.ts
@@ -433,13 +433,16 @@ describe('task image delivery', () => {
if (kind === 'symlink') {
const outside = path.join(state.root, 'private.png');
await fs.writeFile(outside, PNG);
+ // Windows 目录 junction 无需文件软链权限,仍验证真实图片经链接逃出任务目录。
if (process.platform === 'win32') {
- // Junctions preserve the real path escape without requiring file-symlink privileges.
const link = path.join(work, 'linked');
await fs.symlink(state.root, link, 'junction');
source = path.join(link, 'private.png');
- } else await fs.symlink(outside, source);
+ } else {
+ await fs.symlink(outside, source, 'file');
+ }
expect(await fs.realpath(source)).toBe(await fs.realpath(outside));
+ await expect(readTaskImage(source, [await fs.realpath(work)])).rejects.toThrow('task-image: outside task');
} else await fs.writeFile(source, kind === 'not-image' ? Buffer.from('not png') : PNG);
const row = insert(`![image](${source})`);
expect(await restoreTaskImageRows(client, [row])).toEqual([row]);
diff --git a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
index 7163e60032..069f88102d 100644
--- a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
@@ -127,6 +127,7 @@ describe('provider group guest relay planner', () => {
it('reads the latest state when choosing again after a computer did not work', async () => {
const env = setup([MINI, FRIEND]);
await env.relay.plan(PLAN);
+ expect(env.router.pick.mock.calls[0][0].localTask).toBeUndefined();
expect(env.router.pick.mock.calls[0][0].fresh).toBeUndefined();
await env.relay.plan({ ...PLAN, exclude: new Set([MINI.key]) });
expect(env.router.pick.mock.calls[1][0]).toMatchObject({ fresh: true });
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
index 432e14e7ab..690dc484b7 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -91,6 +91,12 @@ function deps(overrides: Partial<ProviderGroupRemoteHandlerDeps> = {}) {
const PICK = { action: 'pick', sessionId: 's1', providerId: 'anthropic', agentKind: 'claude-code', model: 'opus', exclude: ['local'] };
describe('provider-group:remote', () => {
+ it('does not let a remote request claim the local-task preference', async () => {
+ const d = deps();
+ await handleProviderGroupRemote(d, 'laptop', { ...PICK, localTask: true });
+ expect(d.router.pick.mock.calls[0][0].localTask).toBeUndefined();
+ });
+
it('picks a computer, honouring what the caller already tried, and holds it briefly', async () => {
const d = deps();
const result = await handleProviderGroupRemote(d, 'laptop', PICK);
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 d3d8cb3493..61031aaab4 100644
--- a/apps/desktop/src/main/provider-group/__tests__/router.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/router.test.ts
@@ -32,8 +32,12 @@ const LOCAL = member('local', 'local', null);
const SHARE_A = member('share:a:anthropic', 'share', 'share:a', 2);
const SHARE_B = member('share:b:anthropic', 'share', 'share:b');
-function harness(reported: Record<string, number>, bindings: Record<string, ProviderGroupBinding> = {}, running: string[] = []) {
- const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [SHARE_A, SHARE_B, LOCAL] };
+function harness(
+ reported: Record<string, number>,
+ bindings: Record<string, ProviderGroupBinding> = {},
+ running: string[] = [],
+ config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [SHARE_A, SHARE_B, LOCAL] },
+) {
const directory: ProviderGroupDirectory = {
async resolveMembers(_providerId, current) {
return current.members.map((m): ResolvedProviderGroupMember => ({
@@ -66,6 +70,35 @@ function harness(reported: Record<string, number>, bindings: Record<string, Prov
});
}
+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);
+ 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);
+ });
+
+ it('does not reset incoming round-robin allocation when an own task stays local', 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 } });
+ });
+
+ it.each(['cooling', 'excluded'] as const)('falls back to the group when this computer is %s', async (reason) => {
+ const router = harness({ [LOCAL.key]: 0, [SHARE_A.key]: 1 });
+ if (reason === 'cooling') router.markCooling('anthropic', LOCAL.key, 100_000);
+ expect(await router.pick({
+ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL, localTask: true,
+ ...(reason === 'excluded' ? { exclude: new Set([LOCAL.key]) } : {}),
+ })).toMatchObject({ kind: 'member', member: { key: SHARE_B.key } });
+ });
+});
+
describe('provider group running count', () => {
it('shows what a shared computer reports for this account, including tasks that did not go through the group', async () => {
const router = harness({ [SHARE_A.key]: 2, [SHARE_B.key]: 1 });
@@ -116,20 +149,22 @@ 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, fastLoad: number | null) {
+ function quickRouter(localLoad: number | Promise<number | null>, fastLoad: number | null, localView = view('anthropic')) {
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,
online: true, busy: false, remoteControlEnabled: true, controlEnabled: true, isSelf: false,
}));
+ const localRunning = vi.fn(async () => localLoad);
+ const readDeviceProviders = vi.fn((deviceId: string) => deviceId === 'fast' && fastLoad !== null
+ ? Promise.resolve([view('anthropic')])
+ : new Promise<ProviderView[]>(() => undefined));
const directory = createProviderGroupDirectory({
- listLocalProviders: async () => [view('anthropic')],
+ listLocalProviders: async () => [localView],
localDeviceName: () => 'local',
- localRunning: async () => localLoad,
+ localRunning,
listDevices: async () => devices,
- readDeviceProviders: (deviceId) => deviceId === 'fast' && fastLoad !== null
- ? Promise.resolve([view('anthropic')])
- : new Promise<ProviderView[]>(() => undefined),
+ readDeviceProviders,
listReceivedShares: () => [],
isMobilePlatform: () => false,
now: () => 1_000,
@@ -139,9 +174,60 @@ describe('provider group quick picks with busy usable computers', () => {
externalRunning: (_providerId, key) => key === FAST.key ? fastLoad ?? 0 : 0,
now: () => 1_000, random: () => 0,
});
- return { router, config };
+ 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(['disconnected', 'wrong-model'] as const)('falls back within the quick window without reading local load 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 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 },
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 0ef1d4786b..eddb164229 100644
--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
@@ -152,7 +152,73 @@ async function flush() {
for (let i = 0; i < 60; i++) await Promise.resolve();
}
+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 }) => {
+ const h = harness({ members: [MINI, STUDIO, { ...LOCAL, paused }], offline: [LOCAL.key] });
+ // 数据库读取返回快照,后续保存路由不会修改已经读出的行。
+ h.deps.readSessionRow.mockImplementation(async () => ({ ...h.row }));
+ const context = await h.service.assignBeforeStart({ sessionId: 's1', agentKind: 'claude-code', model: MODEL });
+ expect(context?.member.key).toBe(MINI.key);
+ h.offline.delete(LOCAL.key);
+
+ 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);
+ } else if (phase === 'turn') {
+ await h.service.onTurnError('s1', { sdkError: 'rate_limit' }, 1);
+ expect(h.deps.continueSession).toHaveBeenCalledTimes(1);
+ } else {
+ if (phase === 'before-send') h.router.markCooling('anthropic', MINI.key, 2_000_000);
+ await h.service.beforeSend('s1');
+ }
+
+ if (phase === 'healthy') {
+ expect(h.row.agentDeviceId).toBe('mini');
+ expect(h.bindings.get('s1')?.memberKey).toBe(MINI.key);
+ 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);
+ if (phase !== 'start') expect(h.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+ }
+ expect(h.config.members[2].paused).toBe(paused);
+ });
+});
+
describe('assignBeforeStart', () => {
+ it('keeps an own task local when this computer is paused for incoming tasks', async () => {
+ const h = harness({ members: [{ ...LOCAL, paused: true }, MINI] });
+ const context = await h.service.assignBeforeStart({ sessionId: 's1', agentKind: 'claude-code', model: MODEL });
+ expect(context?.member.key).toBe('local');
+ expect(context?.route).toEqual({ agentDeviceId: null, providerId: 'anthropic' });
+ expect(h.deps.persistRoute).not.toHaveBeenCalled();
+ expect(h.bindings.get('s1')?.memberKey).toBe('local');
+ expect(h.config.members[0].paused).toBe(true);
+
+ const incoming = await h.router.pick({ providerId: 'anthropic', agentKind: 'claude-code', model: MODEL });
+ expect(incoming.kind === 'member' && incoming.member.key).toBe(MINI.key);
+ });
+
+ it('prefers this computer for own tasks regardless of the group order', 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();
+ });
+
+ it('falls back through the group when a paused local member cannot start its own task', async () => {
+ const h = harness({ members: [{ ...LOCAL, paused: true }, MINI] });
+ const context = await h.service.assignBeforeStart({ sessionId: 's1', agentKind: 'claude-code', model: MODEL });
+ expect(context?.member.key).toBe('local');
+ const next = await h.service.nextAfterStartFailure(context!, new Error('[REMOTE_AGENT_UNAVAILABLE] failed to start'));
+ expect(next?.member.key).toBe(MINI.key);
+ expect(h.row.agentDeviceId).toBe('mini');
+ });
+
it('assigns a fresh task to the first available computer and writes the route back', async () => {
const h = harness({ offline: ['local'] });
const context = await h.service.assignBeforeStart({ sessionId: 's1', agentKind: 'claude-code', model: MODEL });
@@ -1095,7 +1161,7 @@ describe('beforeSend', () => {
await fine.service.beforeSend('s1');
expect(fine.deps.switchAgentLocation).not.toHaveBeenCalled();
- const paused = harness({ members: [{ ...LOCAL, paused: true }, MINI], offline: ['local'] });
+ const paused = harness({ members: [{ ...LOCAL, paused: true }, MINI] });
paused.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
await paused.service.beforeSend('s1');
expect(paused.deps.switchAgentLocation).not.toHaveBeenCalled();
@@ -1111,6 +1177,15 @@ describe('beforeSend', () => {
expect(loose.deps.readSessionRow).not.toHaveBeenCalled();
});
+ it('still recovers an own task when the local member is paused for incoming tasks', async () => {
+ const h = harness({ members: [{ ...LOCAL, paused: true }, MINI], row: { sdkSessionId: 'native' } });
+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
+ h.router.markCooling('anthropic', 'local', 2_000_000);
+ await h.service.beforeSend('s1');
+ expect(h.bindings.get('s1')?.memberKey).toBe(MINI.key);
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+ });
+
it('keeps the binding when the move fails for a reason that is not about the target, so the send reports it', async () => {
const h = harness({ offline: ['local'] });
h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });
@@ -1403,11 +1478,12 @@ describe('using the state the group keeps (2026-10-11)', () => {
});
it('reads the latest group state before trying the next computer, and does not record this computer\'s own problems', async () => {
- const h = harness({ members: [MINI, LOCAL] });
+ const h = harness({ members: [MINI, LOCAL], offline: ['local'] });
const resolve = vi.spyOn(h.deps.directory, 'resolveMembers');
const first = await h.service.assignBeforeStart({ sessionId: 's1', agentKind: 'claude-code', model: MODEL });
expect(first?.member.key).toBe(MINI.key);
expect(resolve.mock.calls.at(-1)?.[2]?.fresh).toBeUndefined();
+ h.offline.delete('local');
const next = await h.service.nextAfterStartFailure(first!, new Error('[REMOTE_AGENT_DEVICE_UNREACHABLE] gone'));
expect(next?.member.key).toBe('local');
expect(resolve.mock.calls.at(-1)?.[2]).toMatchObject({ fresh: true });
diff --git a/apps/desktop/src/main/provider-group/directory.ts b/apps/desktop/src/main/provider-group/directory.ts
index 79caf140f7..c3bc8581c5 100644
--- a/apps/desktop/src/main/provider-group/directory.ts
+++ b/apps/desktop/src/main/provider-group/directory.ts
@@ -68,6 +68,8 @@ export interface ResolveMembersOptions {
enough?(resolved: ResolvedProviderGroupMember): boolean;
/** 不用短时缓存,现读设备列表与每台的目录(试过不行之后拉最新状态)。 */
fresh?: boolean;
+ /** 本机自用不按负载分配,可不读本机运行数,避免等待任务数据库;默认仍读取。 */
+ includeLocalRunning?: boolean;
}
const CATALOG_TTL_MS = 15_000;
@@ -151,11 +153,11 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
return views.find((view) => view.id === providerId) ?? null;
}
- async function resolveLocal(member: ProviderGroupMember): Promise<ResolvedProviderGroupMember> {
+ async function resolveLocal(member: ProviderGroupMember, includeRunning = true): Promise<ResolvedProviderGroupMember> {
const label = deps.localDeviceName();
const view = await localGroupProvider(member.providerId);
if (!view || !view.connected || view.suspended) return { member, label, state: 'unavailable', reason: 'disconnected' };
- const reportedRunning = await deps.localRunning?.(member.providerId).catch(() => null);
+ const reportedRunning = includeRunning ? await deps.localRunning?.(member.providerId).catch(() => null) : undefined;
return { member, label, state: 'ok', view, ...(typeof reportedRunning === 'number' ? { reportedRunning } : {}) };
}
@@ -274,7 +276,7 @@ export function createProviderGroupDirectory(deps: ProviderGroupDirectoryDeps):
// PR #5792 review)。
const deviceListPromise = needsDevices ? readDevices().catch(() => null) : Promise.resolve(null);
const reads = config.members.map((member) => {
- if (member.kind === 'local') return resolveLocal(member);
+ if (member.kind === 'local') return resolveLocal(member, options?.includeLocalRunning);
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 165e498f39..d606c18650 100644
--- a/apps/desktop/src/main/provider-group/router.ts
+++ b/apps/desktop/src/main/provider-group/router.ts
@@ -61,6 +61,11 @@ export interface ProviderGroupPickInput {
providerId: string;
agentKind: AgentKind;
model: string;
+ /**
+ * 仅本机任务入口设置:初次分配与故障重选时,本机可用就优先本机,不受对外暂停分配或负载影响。
+ * 远程请求与分享中转不传,也不从请求载荷读取。
+ */
+ localTask?: true;
exclude?: ReadonlySet<string>;
/** 现读组内电脑的最新状态,不用短时缓存(试过不行、带着这一轮试过的来选时)。 */
fresh?: boolean;
@@ -198,29 +203,46 @@ export function createProviderGroupRouter(deps: ProviderGroupRouterDeps): Provid
if (!config) return { kind: 'none' };
const usable = (r: ResolvedProviderGroupMember) =>
offersModel(r, input.agentKind, input.model) && coolingUntil(input.providerId, r.member.key) === null;
- 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),
- paused: r.member.paused,
+ paused: paused(r),
running: memberRunning(input.providerId, r),
limit: r.member.limit,
weight: r.member.weight,
}));
- 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,
});
if (!key) return { kind: 'unavailable', resolved };
- lastPicked.set(input.providerId, key);
+ // 本机优先不参与组策略轮询,避免本机自用打断外部任务的分配顺序。
+ if (!preferred) lastPicked.set(input.providerId, key);
if (input.reserveFor) {
provisional.set(input.reserveFor, {
providerId: input.providerId,
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index 13eedca26a..86b0275dad 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. **自动换电脑**:运行中因那台电脑的原因失败(终态错误)时,交接到组里下一台并继续这一轮;
* 同一轮每台最多试一次,全部失败才交回原有的报错 / 等额度重置流程。那台是连不上(离线、断线)时先等它
@@ -655,6 +655,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
providerId,
agentKind,
model,
+ // 本机自用每次需要选电脑时都优先本机,含故障重选;正常运行的已有绑定不走 pick。
+ localTask: true,
exclude,
reserveFor: sessionId,
...(exclude.size > 0 ? { fresh: true } : {}),
@@ -1636,8 +1638,9 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
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);
if (cached === null) return;
let reason = cached ? cached.reason : null;
diff --git a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
index 96fbbdc5cf..ba8189cd54 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
@@ -148,6 +148,15 @@ async function waitFor(condition: () => boolean, ms = 3_000): Promise<void> {
}
}
+function readOwnerGuestIndex(): Record<string, { controller: string; forgetPending?: string[]; nativeIds: string[] }> {
+ return JSON.parse(fs.readFileSync(path.join(root, 'owner', 'guest-sessions.json'), 'utf8'));
+}
+
+async function waitForGuestPurge(controller: string): Promise<void> {
+ // 远端删目录后还会写索引;等组所在电脑确认远端完成并落盘,避免 teardown 与后台写入竞争。
+ await waitFor(() => Object.values(readOwnerGuestIndex()).every((record) => record.controller !== controller));
+}
+
const MEMBER_MINI: GroupRelayMember = { memberKey: 'device:mini:anthropic-2', agentDeviceId: 'mini', providerId: 'anthropic-2', sameAccount: true };
const MEMBER_STUDIO: GroupRelayMember = { memberKey: 'device:studio:anthropic', agentDeviceId: 'studio', providerId: 'anthropic', sameAccount: true };
@@ -390,7 +399,8 @@ describe('provider group relay for shared users', () => {
const homeB = env.memberStarted.mini[1].input.guestHome!;
expect(fs.existsSync(homeA) && fs.existsSync(homeB)).toBe(true);
await env.owner.purgeControllers((controller) => controller === GUEST_A);
- await waitFor(() => !fs.existsSync(homeA));
+ await waitForGuestPurge(GUEST_A);
+ expect(fs.existsSync(homeA)).toBe(false);
expect(env.relay.forget).toHaveBeenCalledWith('mini', relayKeyFor(GUEST_A));
expect(fs.existsSync(homeB)).toBe(true);
// 另一个控制端拿着同一个 relay 键也清不掉别人的。
@@ -468,7 +478,7 @@ describe('provider group relay: starting, load and cleanup', () => {
expect(env.memberStarted.studio).toHaveLength(1);
await client.close('close', 'navigation');
await env.owner.purgeControllers((controller) => controller === GUEST_A);
- await waitFor(() => env.relay.forget.mock.calls.length >= 2);
+ await waitForGuestPurge(GUEST_A);
expect(env.relay.forget).toHaveBeenCalledWith('mini', relayKeyFor(GUEST_A));
expect(env.relay.forget).toHaveBeenCalledWith('studio', relayKeyFor(GUEST_A));
});
@@ -477,23 +487,17 @@ describe('provider group relay: starting, load and cleanup', () => {
const env = setup();
const { client } = await openAsGuest(env, GUEST_A, openPayload(SESSION));
await client.close('close', 'navigation');
- const index = (): Record<string, { forgetPending?: string[]; nativeIds: string[] }> => {
- try {
- return JSON.parse(fs.readFileSync(path.join(root, 'owner', 'guest-sessions.json'), 'utf8'));
- } catch {
- return {};
- }
- };
env.relay.forget.mockRejectedValueOnce(new Error('DEVICE_OFFLINE'));
await env.owner.purgeControllers((controller) => controller === GUEST_A);
await waitFor(() => env.relay.forget.mock.calls.length === 1);
- await waitFor(() => Object.values(index()).some((record) => record.forgetPending?.includes('mini')));
+ await waitFor(() => Object.values(readOwnerGuestIndex()).some((record) => record.forgetPending?.includes('mini')));
// 本机这边已经清掉,只留下还要通知的那台。
- expect(Object.values(index()).every((record) => record.nativeIds.length === 0)).toBe(true);
+ expect(Object.values(readOwnerGuestIndex()).every((record) => record.nativeIds.length === 0)).toBe(true);
await env.owner.purgeControllers((controller) => controller === GUEST_A);
await waitFor(() => env.relay.forget.mock.calls.length === 2);
- await waitFor(() => Object.keys(index()).length === 0);
+ await waitForGuestPurge(GUEST_A);
+ expect(Object.keys(readOwnerGuestIndex())).toHaveLength(0);
});
it('does not let a shared user get more tasks by filling in its own relay key', async () => {
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
index 2ad4435aae..b868c1b201 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
@@ -300,7 +300,9 @@ function MemberRow({
style={{ background: ready ? 'var(--remote-status-ready)' : 'var(--remote-status-disconnected)' }}
/>
{/* 运行数是状态,上限是设置:各说一次,不再出现「0 / 10」与下拉里重复同一个上限。 */}
- <span>{memberStatusText(t, status, i18n.language)}</span>
+ <span>{member.kind === 'local' && status?.state === 'paused'
+ ? t('providerGroup.member.status.pausedLocal')
+ : memberStatusText(t, status, i18n.language)}</span>
{appendRunning && (
<>
<span aria-hidden="true">·</span>
@@ -335,7 +337,9 @@ function MemberRow({
<Switch
checked={!member.paused}
disabled={disabled}
- aria-label={t('providerGroup.member.assignAria', { name: label })}
+ aria-label={t(member.kind === 'local'
+ ? 'providerGroup.member.assignLocalAria'
+ : 'providerGroup.member.assignAria', { name: label })}
onCheckedChange={(on) => onChange({ paused: !on })}
/>
{member.kind === 'local' ? (
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 bf6314ba55..f7b8e6e8fe 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
@@ -174,12 +174,23 @@ describe('ProviderGroupSection', () => {
expect(rows[1].getAttribute('data-member-state')).toBe('cooling');
expect(within(rows[1]).getByText(/providerGroup\.member\.status\.coolingUntil/)).toBeTruthy();
// 本机与远程共用同一个开关;本机不能移出组。
- expect(within(rows[0]).getByRole('switch')).toBeTruthy();
+ const localSwitch = within(rows[0]).getByRole('switch', {
+ name: 'providerGroup.member.assignLocalAria:{"name":"providerGroup.member.local"}',
+ });
+ expect(localSwitch).toBeTruthy();
expect(within(rows[0]).queryByRole('button', { name: 'providerGroup.member.remove' })).toBeNull();
fireEvent.click(
within(rows[1]).getByRole('switch', { name: 'providerGroup.member.assignAria:{"name":"Mac mini"}' }),
);
await waitFor(() => expect(stored?.members[1].paused).toBe(true));
+ expect(await within(rows[1]).findByText('providerGroup.member.status.paused')).toBeTruthy();
+ fireEvent.click(localSwitch);
+ await waitFor(() => expect(stored?.members[0].paused).toBe(true));
+ expect(await within(rows[0]).findByText('providerGroup.member.status.pausedLocal')).toBeTruthy();
+ expect(within(rows[0]).getByText('providerGroup.member.runningCount:{"count":1}')).toBeTruthy();
+ fireEvent.click(localSwitch);
+ await waitFor(() => expect(stored?.members[0].paused).toBe(false));
+ await waitFor(() => expect(within(rows[0]).queryByText('providerGroup.member.status.pausedLocal')).toBeNull());
});
it('says idle instead of staying silent when a computer is available with nothing running', async () => {
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index 9d8276ce04..193b50876c 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -473,6 +473,7 @@
"weightAria": "Weight for {{name}}",
"weightOption": "Weight {{weight}}",
"assignAria": "Assign tasks to {{name}}",
+ "assignLocalAria": "Allow {{name}} to accept new tasks from other computers",
"moreAria": "More actions for {{name}}",
"remove": "Remove from Group",
"status": {
@@ -480,6 +481,7 @@
"idle": "Idle",
"full": "Full",
"paused": "Assignments paused",
+ "pausedLocal": "Not accepting new tasks from other computers",
"cooling": "Cooling down",
"coolingUntil": "Cooling down · back around {{time}}",
"offline": "Offline",
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 34007f38f7..df4254f22b 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -468,6 +468,7 @@
"weightAria": "{{name}} の重み",
"weightOption": "重み {{weight}}",
"assignAria": "{{name}} に割り当てる",
+ "assignLocalAria": "{{name}} で他のパソコンからの新しいタスクを受け付ける",
"moreAria": "{{name}} の他の操作",
"remove": "グループから外す",
"status": {
@@ -475,6 +476,7 @@
"idle": "待機中",
"full": "上限に到達",
"paused": "割り当て停止中",
+ "pausedLocal": "他のパソコンからの新しいタスクは受付停止中",
"cooling": "クールダウン中",
"coolingUntil": "クールダウン中 · {{time}} ごろ回復",
"offline": "オフライン",
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index be6eac0efe..c7cad0e968 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -468,6 +468,7 @@
"weightAria": "{{name}}의 가중치",
"weightOption": "가중치 {{weight}}",
"assignAria": "{{name}}에 배정",
+ "assignLocalAria": "{{name}}에서 다른 컴퓨터의 새 작업 수신 허용",
"moreAria": "{{name}} 추가 작업",
"remove": "그룹에서 제외",
"status": {
@@ -475,6 +476,7 @@
"idle": "대기 중",
"full": "한도 도달",
"paused": "배정 일시 중지됨",
+ "pausedLocal": "다른 컴퓨터의 새 작업 수신 중지",
"cooling": "대기 중",
"coolingUntil": "대기 중 · {{time}}쯤 복구",
"offline": "오프라인",
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 6a93aede2f..41eb6067b7 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -468,6 +468,7 @@
"weightAria": "{{name}} 的权重",
"weightOption": "权重 {{weight}}",
"assignAria": "给 {{name}} 分配任务",
+ "assignLocalAria": "允许 {{name}} 接收外部新任务",
"moreAria": "{{name}} 的更多操作",
"remove": "移出组",
"status": {
@@ -475,6 +476,7 @@
"idle": "空闲",
"full": "已满",
"paused": "已暂停分配",
+ "pausedLocal": "已暂停接收外部新任务",
"cooling": "冷却中",
"coolingUntil": "冷却中 · 约 {{time}} 恢复",
"offline": "不在线",
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 5afadec9dd..913f193204 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -468,6 +468,7 @@
"weightAria": "{{name}} 的權重",
"weightOption": "權重 {{weight}}",
"assignAria": "給 {{name}} 分配任務",
+ "assignLocalAria": "允許 {{name}} 接收外部新任務",
"moreAria": "{{name}} 的更多操作",
"remove": "移出組",
"status": {
@@ -475,6 +476,7 @@
"idle": "空閒",
"full": "已滿",
"paused": "已暫停分配",
+ "pausedLocal": "已暫停接收外部新任務",
"cooling": "冷卻中",
"coolingUntil": "冷卻中 · 約 {{time}} 恢復",
"offline": "離線",
diff --git a/apps/desktop/src/shared/providerGroup.ts b/apps/desktop/src/shared/providerGroup.ts
index a2fa3a53a2..69eb0deb73 100644
--- a/apps/desktop/src/shared/providerGroup.ts
+++ b/apps/desktop/src/shared/providerGroup.ts
@@ -45,7 +45,7 @@ export interface ProviderGroupMember {
/** 并发上限:只统计经本组分到这台的任务。 */
limit: number;
weight: number;
- /** 暂停分配(本机即「关掉本机」):不再给它分新任务,正在运行的不受影响。 */
+ /** 暂停组内新任务分配;本机成员只暂停接收外部新任务,不影响本机自用或已有任务。 */
paused: boolean;
}
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index d48282bd22..d887b15f96 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -39,7 +39,8 @@
不用自己挑电脑,哪台忙、离线或撞到用量上限时自动换一台,并且能把这个入口分享给别人。
做法是在某台电脑(下称**组所在电脑**)的某个供应商下建一个**供应商组**,把其他电脑上的同一个
-供应商加进来。之后这个供应商在组所在电脑上的所有使用都按**组策略**选一台**组内电脑**运行:
+供应商加进来。本机自己的新任务优先本机,本机不可用时才按**组策略**选其他**组内电脑**;
+其他电脑与分享的人的新任务按组策略分配(2026-10-12 用户裁决)。组管理以下使用:
- 组所在电脑自己的任务;
- 同账号的其他电脑把组所在电脑的这个供应商当远程供应商使用(组所在电脑选电脑,那台电脑直接连过去);
@@ -66,7 +67,8 @@
- 每个供应商最多一个组。组跟着供应商连接(连接 ID)走:删除这个供应商连接即删除组。
- **组内电脑就是这台电脑已经能用的同一个供应商**,与模型列表里远程供应商区域是同一个来源。自己的电脑和
别人的电脑走同一套规则,与现有「自己用和被分享走同一套」一致(供应商分享 §3、§5):
- 1. **本机**:默认在组里,可以关掉。关掉后组所在电脑只负责选电脑与转发,不在本机运行这个供应商的 Agent。
+ 1. **本机**:默认在组里,可以暂停对外分配。暂停只限制接收本机以外的新任务,不影响本机自用;
+ 本机自己的新任务仍优先在本机运行,只有本机不可用时才选其他组内电脑。
2. **已经能用的远程供应商**:同账号电脑上已打开「允许被远程调用」的,和别人分享给这个账号的,在同一个列表里
勾选加入,不需要再申请。
3. **还不能用的别人的电脑**:粘贴对方的分享链接,流程与加入分享相同:预览 → 发送申请 → 双方核对配对码
@@ -99,7 +101,10 @@
## 4. 哪些使用走组
-- 判断依据是任务实际使用的供应商连接,不看发起方:§1 列出的三种使用走同一套组策略与绑定规则。
+- 判断是否归组依据任务实际使用的供应商连接。§1 的三种使用共用绑定与故障恢复规则,初次分配与故障重选均区分来源:
+ 组所在电脑自己的任务优先本机,不受本机的对外暂停、并发上限与组策略影响;本机不可用时才按组策略回退。
+ 同账号其他电脑与分享的人的任务仍按组策略,尊重本机暂停对外分配。
+ 任务归属以任务所在电脑为准,手机或远控操作该电脑上的任务不把它变成外部新任务。
- 组内电脑是本机时,Agent 直接在本机运行,与现在一致。
- **组所在电脑自己的任务**:组内电脑是其他电脑时,组所在电脑作为控制端连过去:对「我的其他电脑」是同账号远程 Agent;
对分享来的电脑,组所在电脑的账号是那台电脑的受邀者。
@@ -132,6 +137,11 @@
## 5. 组策略
+- **本机自用优先(2026-10-12 用户裁决)**:只要本机供应商与所选模型可用、不在冷却中且本轮没失败过,
+ 本机自己的新任务就先在本机运行,即使组里别的电脑更空闲、本机已到并发上限或暂停对外分配。
+ 本机任务已分到远端、远端发生启动失败、运行中故障或发送前故障,需要重选时,本机若已恢复可用,仍优先本机
+ (2026-10-12 用户再次确认);本机不可用时才按下述策略选其他电脑。正常运行的任务不会仅因本机恢复而自动迁回。
+ 本机优先由主进程的本机任务入口决定,远程请求与分享中转不能自报“本机任务”来绕过暂停。
- **选择方式**:最少占用(默认,选正在运行任务最少的那台)、轮询、按顺序(排在前面的优先,前面的不可用才用后面的)、
按权重。
- **并发上限**:每台组内电脑单独设置,默认 4,最多 16(远程 Agent 对每个控制端的上限);只统计经本组分到这台的任务,
@@ -149,7 +159,7 @@
刷新时间与分享来的电脑相同;那台是旧版本时不报,照旧只算经本组的。因为算的是全部任务,那台的主人自己在用时
也会占它的并发上限。
- **只分给可用的电脑**:在线;对方仍允许远程控制,且仍对这个供应商允许被远程调用;分享未暂停、未删除;
- 不在冷却中;提供所选模型;未被设为「暂停分配」。优先分给未达到并发上限的;都满了时分给相对最空的一台,
+ 不在冷却中;提供所选模型;未被设为「暂停分配」(本机自己的任务使用本机除外)。按组策略分配时优先分给未达到并发上限的;都满了时分给相对最空的一台,
并发上限只用来分摊,不因满载拒绝消息。
- **冷却**:组内电脑上的任务报用量上限时,这台电脑进入冷却,不再接新任务。重置时刻按
[用量上限自动继续](usage-limit-auto-continue.md) 的口径取(不采用不带时区的钟点);取不到时默认冷却 30 分钟。
@@ -174,10 +184,10 @@
## 6. 任务与组内电脑的绑定
-- 任务第一次在组里运行时选定一台组内电脑,之后固定在这台:对话记录保存在那台电脑上。只有正常运行时才保持
+- 任务第一次在组里运行时按 §5(本机任务优先本机,其余按组策略)选定一台组内电脑,之后固定在这台:对话记录保存在那台电脑上。只有正常运行时才保持
固定;那台电脑出问题时按下面的规则**自动换电脑**,不需要用户操作。
- 正在正常运行的任务不会因为组策略变化或其他电脑空闲而迁移。
-- 只给从没运行过的任务按策略选电脑。已经运行过、正用着组那一项的任务不按策略挪走:留在原处并纳入组,之后出问题时
+- 只给从没运行过的任务按 §5 选电脑。已经运行过、正用着组那一项的任务不按策略挪走:留在原处并纳入组,之后出问题时
照常自动换电脑(2026-10-10 用户要求:老任务也要生效)。包括:
- 建组前就在用这个供应商的任务、回退或清空后原生会话被清掉的任务;
- 运行过之后才在模型选择里换到组那一项、但 Agent 本来就在组那一项上(组所在电脑的这个供应商)的任务;
@@ -223,8 +233,10 @@
控制操作,不会因为 Agent 所在那台暂时连不上就把正在跑的一轮杀掉:没有要改的不去碰运行中的会话;要改而那台回不来时,这一轮结束后
再按已保存的设置重建。本机主动关掉会话不是那台电脑的问题,不触发换电脑。
- **怎么换**:
+ - **重新选哪台**:沿用 §5 的来源规则,本机自己的任务仍优先可用本机,本机不可用才按组策略选择;
+ 同账号其他电脑与分享的人的任务继续按组策略分配。连不上时先等原电脑恢复的规则不变。
- **还没开始运行**(打开任务、Agent 启动阶段)失败:直接换下一台,没有可感知的中断。
- - **运行中失败**:把这台标为不可用(用量上限进入冷却,§5),复用现有的跨电脑交接,把任务交接到组策略选出的
+ - **运行中失败**:把这台标为不可用(用量上限进入冷却,§5),复用现有的跨电脑交接,把任务交接到按上述规则选出的
下一台:新建会话并带上交接上下文,然后继续这一轮——这一轮还没有产出就重发原消息,已经有产出就发续跑指令,
与 [用量上限自动继续](usage-limit-auto-continue.md) 的续跑口径一致。消息流里显示一行活动记录
「{原电脑} {原因},已换到 {新电脑} 继续」(受邀者那边写「已自动换一台电脑继续」,§8),不计为用户发送。
@@ -432,6 +444,7 @@
并发上限(按权重时多一个权重)→ 参与分配开关 → 行内 `···` 菜单。三条由此固定:
- **参与分配只有一种控件。** `paused` 是同一个布尔值,本机与远程都用开关表达,不按来源分叉成
「开关 / 暂停分配按钮」两套;暂停后的含义由状态行文字说明,不另弹 toast。
+ 本机这一行的暂停只限制接收外部新任务,本机自用优先与故障恢复不受影响(§5)。
- **运行数是状态,上限是设置。** 运行数只出现在状态行,上限只出现在下拉里,同一个数字不在一行里说两遍。
**能用时状态词本身报负载**:跑 0 个说「空闲」,跑了就说「{N} 个任务运行中」,不写「可用」——
否则组里都空着时整列没有数字,看不出每台在跑几个。「已满」等于跑满上限,不再重复报数。
@@ -516,7 +529,9 @@
## 13. 验收
1. 链接的供应商与组不是同一个(§3 口径)、链接属于自己账号、链接失效时不发送申请,并给出对应提示。
-2. 组所在电脑、同账号其他电脑、分享的人三种使用都按组策略分配,组内电脑离线、冷却、暂停分配、满载或不提供所选模型时不会被选中。
+2. 组所在电脑自己的新任务优先本机,不受本机对外暂停、负载与组策略影响;本机不可用时才按组策略回退。
+ 已分到远端的本机任务在启动、运行中或发送前故障后重新选择时仍优先已恢复的本机;正常运行的任务留在原电脑。
+ 同账号其他电脑、分享的人的任务按组策略分配并尊重暂停;离线、冷却或不提供模型的电脑不选,满载按 §5 分摊。
3. 正常运行的任务固定在原电脑;原电脑因 §6.1 列出的原因失败时,自动交接到组内另一台继续这一轮,消息流显示换电脑的
活动记录;同一轮每台最多试一次,全部失败才报错并逐台列出原因;其中有撞上限的,等最早恢复的一台自动继续。
4. 用户停止、权限被拒、上下文超限、请求无效、内容被拒、工具出错时不换电脑;其余失败都换(含认不出的)。「故障 × 阶段」的判定表