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): 恢复明确委托的定时派发授权

DavidShen4df37f92ed8d
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/taskActionAuthorization.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/taskActionAuthorization.test.ts
index a1d1e253f8..0acb5d3784 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/taskActionAuthorization.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/taskActionAuthorization.test.ts
@@ -6,6 +6,7 @@
* Tier: unit. This file isolates the process-local authorization lifetime from SQLite/IPC.
*/
import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { AutoReviewDecision, PermissionMode, SendOrigin } from '@cindy/maker-core';
import { withToolCallAuthority } from '../../../../../../packages/lizi-mcps/src/tool-call-authority.js';
import { createOrcaMcpServer } from '../../../../../../packages/lizi-mcps/src/orca/server.js';
import type { AgentInputQueuedMessage } from '../../../shared/agentInputQueue.js';
@@ -269,8 +270,17 @@ function desktopFixture(kind: 'private' | 'group' | 'automatic' = 'group') {
boundary: 'runtime-1',
};
const confirm = vi.fn(async () => true);
- const authorize = createDesktopTaskActionAuthorizer({ input: () => ({ ...activeInput }), confirm });
- return { authorize, confirm, activeInput, caller, rows };
+ const runtime = {
+ stablePermissionModeState: { mode: 'auto' as PermissionMode, generation: 1 },
+ stablePlanModeState: { enabled: false, generation: 1 },
+ getCurrentTurnOrigin: (): SendOrigin | null => null,
+ reviewHostPermissionAction: vi.fn(async (): Promise<AutoReviewDecision> => ({ verdict: 'allow' })),
+ };
+ const getSession = vi.fn((): typeof runtime | undefined => runtime);
+ const authorize = createDesktopTaskActionAuthorizer({
+ input: () => ({ ...activeInput }), confirm, getSession,
+ });
+ return { authorize, confirm, activeInput, caller, rows, runtime, getSession };
}
const ownerWrites = [
['cindy_helper', 'start_session_task'],
@@ -283,6 +293,125 @@ const ownerWrites = [
['cindy_orca', 'switch_focus'],
] as const;
+// Regression #6399 / maker-core-and-agent-behavior.md "同范围自动跟进":
+// production Desktop admission must deliver a user-scheduled send after normal
+// permission review. Existing Bot-only automatic fixtures miss ordinary schedules.
+// Minimum: ordinary scheduled turn + approved send_to_session; unit, in-memory IO.
+// Standalone Vitest run: 2.72s (4.4s command wall time on Windows).
+describe('Owner-delegated scheduled task actions', () => {
+ function scheduledFixture() {
+ const h = desktopFixture('automatic');
+ h.caller.botId = null;
+ h.caller.source = 'scheduler';
+ const origin: SendOrigin = { kind: 'scheduler', runId: 'run-1' };
+ h.runtime.getCurrentTurnOrigin = () => origin;
+ return h;
+ }
+ const scheduledSend = () => ({
+ ...call('send_to_session'),
+ args: { target_session_id: 'target', message: 'Dispatch the new PR feedback' },
+ });
+
+ it.each(['direct', 'queued', 'bound'] as const)('delivers an approved %s scheduled dispatch without another confirmation', async route => {
+ const h = scheduledFixture();
+ if (route === 'bound') h.caller.source = 'desktop';
+ h.activeInput.automatic = route === 'queued';
+ const request = scheduledSend();
+ const queued = input();
+ const result = await withToolCallAuthority(h.authorize, request, async () => {
+ bindTaskActionInput('target', queued);
+ return 'sent';
+ });
+ expect(result).toBe('sent');
+ // The admitted message can wait behind busy work after its source turn ends.
+ h.runtime.getCurrentTurnOrigin = () => null;
+ await expect(taskActionInputGuard('target', queued)!()).resolves.toBeUndefined();
+ expect(h.runtime.reviewHostPermissionAction).toHaveBeenCalledWith({
+ kind: 'other',
+ description: JSON.stringify({
+ toolName: 'mcp__cindy_helper__send_to_session',
+ input: request.args,
+ context: { source: 'scheduler', phase: 'triggered-continuation' },
+ }),
+ });
+ expect(h.confirm).not.toHaveBeenCalled();
+ });
+
+ it.each(['bot', 'forwarded', 'missing-runtime', 'plan'] as const)('does not infer consent from %s scheduled metadata', async source => {
+ const h = scheduledFixture();
+ if (source === 'bot') h.caller.botId = 'bot';
+ if (source === 'forwarded') h.runtime.getCurrentTurnOrigin = () => null;
+ if (source === 'missing-runtime') h.getSession.mockReturnValue(undefined);
+ if (source === 'plan') h.runtime.stablePlanModeState.enabled = true;
+ const effect = vi.fn(async () => 'sent');
+ expect(await withToolCallAuthority(h.authorize, scheduledSend(), effect)).toMatchObject({ isError: true });
+ expect(effect).not.toHaveBeenCalled();
+ expect(h.runtime.reviewHostPermissionAction).not.toHaveBeenCalled();
+ expect(h.confirm).not.toHaveBeenCalled();
+ });
+
+ it.each(['block', 'ask', 'cancel'] as const)('respects a normal %s permission decision', async verdict => {
+ const h = scheduledFixture();
+ h.runtime.reviewHostPermissionAction.mockResolvedValue({ verdict: verdict === 'cancel' ? 'ask' : verdict });
+ h.confirm.mockResolvedValue(verdict !== 'cancel');
+ const effect = vi.fn(async () => 'sent');
+ const result = await withToolCallAuthority(h.authorize, scheduledSend(), effect);
+ if (verdict === 'ask') expect(result).toBe('sent');
+ else expect(result).toMatchObject({ isError: true });
+ expect(effect).toHaveBeenCalledTimes(verdict === 'ask' ? 1 : 0);
+ expect(h.confirm).toHaveBeenCalledTimes(verdict === 'block' ? 0 : 1);
+ });
+
+ it.each(['message', 'target_session_id'] as const)('rejects %s rewritten while the permission review is pending', async key => {
+ const h = scheduledFixture();
+ const request = scheduledSend();
+ h.runtime.reviewHostPermissionAction.mockImplementation(async () => {
+ request.args[key] = 'unreviewed';
+ return { verdict: 'allow' };
+ });
+ const effect = vi.fn(async () => 'sent');
+ const result = await withToolCallAuthority(h.authorize, request, effect);
+ expect(result).toMatchObject({ isError: true });
+ expect(JSON.stringify(result)).toContain('TASK_ACTION_AUTHORIZATION_EXPIRED');
+ expect(effect).not.toHaveBeenCalled();
+ });
+
+ it.each(['permission', 'plan', 'instance', 'account', 'input'] as const)('invalidates admission and delayed delivery after %s changes', async changed => {
+ const h = scheduledFixture();
+ const queued = input();
+ const guard = await withToolCallAuthority(h.authorize, scheduledSend(), async () => {
+ bindTaskActionInput('target', queued);
+ return captureTaskActionSyncGuard()!;
+ });
+ if (typeof guard !== 'function') throw new Error('Expected an admitted delivery guard');
+ await expect(taskActionInputGuard('target', queued)!()).resolves.toBeUndefined();
+ expect(() => guard()).not.toThrow();
+ if (changed === 'permission') h.runtime.stablePermissionModeState.generation++;
+ if (changed === 'plan') h.runtime.stablePlanModeState.generation++;
+ if (changed === 'instance') h.getSession.mockReturnValue({ ...h.runtime });
+ if (changed === 'account') hostFacts.boundaryPending.mockReturnValue(true);
+ if (changed === 'input') h.activeInput.boundary = 'replacement-runtime';
+ expect(() => guard()).toThrow('AUTHORIZATION_EXPIRED');
+ await expect(taskActionInputGuard('target', queued)!()).rejects.toThrow('AUTHORIZATION_EXPIRED');
+ });
+
+ it.each(['permission', 'account', 'turn'] as const)('does not act or prompt if %s changes during review', async changed => {
+ const h = scheduledFixture();
+ h.runtime.reviewHostPermissionAction.mockImplementation(async () => {
+ if (changed === 'permission') h.runtime.stablePermissionModeState.generation++;
+ if (changed === 'account') hostFacts.boundaryPending.mockReturnValue(true);
+ if (changed === 'turn') h.runtime.getCurrentTurnOrigin = () => ({ kind: 'scheduler', runId: 'run-2' });
+ return { verdict: 'ask' };
+ });
+ const effect = vi.fn(async () => 'sent');
+ const result = await withToolCallAuthority(h.authorize, scheduledSend(), effect);
+ expect(result).toMatchObject({ isError: true });
+ expect(JSON.stringify(result)).toContain('TASK_ACTION_AUTHORIZATION_EXPIRED');
+ expect(effect).not.toHaveBeenCalled();
+ expect(h.confirm).not.toHaveBeenCalled();
+ });
+});
+
describe('Desktop owner input task actions', () => {
// #6399, unit: the action-set loop cannot detect a missing tool. Invoke the
// registered DirectToolSink handler: an automatic focus request must not reach
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index bb6ff84e34..c83b94104e 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -4476,6 +4476,11 @@ export function getTaskActionInputState(sessionId: string) {
};
}
+/** Live permission authority for Host task actions; never reconstructed from DB defaults. */
+export function getTaskActionSession(sessionId: string) {
+ return getMakerIfReady()?.getSession(sessionId);
+}
+
/** Owner-authored active input (see AgentInputCoordinator.isActiveInputOwnerAuthored). */
export function isActiveInputOwnerAuthored(sessionId: string): boolean {
return agentInputCoordinatorHolder?.isActiveInputOwnerAuthored(sessionId) ?? false;
diff --git a/apps/desktop/src/main/maker-ipc/taskActionHost.ts b/apps/desktop/src/main/maker-ipc/taskActionHost.ts
index ebfc5fd3f9..bfc5081cfa 100644
--- a/apps/desktop/src/main/maker-ipc/taskActionHost.ts
+++ b/apps/desktop/src/main/maker-ipc/taskActionHost.ts
@@ -1,5 +1,6 @@
import { and, eq } from 'drizzle-orm';
import type { ToolCallAuthorizer } from '@cindy/mcps';
+import type { Session } from '@cindy/maker-core';
import {
botDelegations,
botProfiles,
@@ -15,9 +16,50 @@ import {
admitTaskAction,
createTaskActionAuthorizer,
DELEGATED_TASK_ACTIONS,
+ taskActionFingerprint,
type TaskActionScope,
} from './taskActionAuthorization.js';
+type TaskActionSession = Pick<Session,
+ 'stablePermissionModeState' | 'stablePlanModeState' |
+ 'getCurrentTurnOrigin' | 'reviewHostPermissionAction'>;
+
+/** The live turn identifies a continuation, not consent. Only its existing
+ * permission reviewer may approve the exact action against restored user intent. */
+function captureScheduledRuntime(
+ sessionId: string,
+ getSession: (id: string) => TaskActionSession | undefined,
+) {
+ const session = getSession(sessionId);
+ const origin = session?.getCurrentTurnOrigin();
+ if (!session || origin?.kind !== 'scheduler') return null;
+ const permissionState = session.stablePermissionModeState;
+ const planState = session.stablePlanModeState;
+ if (!permissionState || !planState || planState.enabled || permissionState.mode === 'plan') return null;
+ const permission = { ...permissionState };
+ const plan = { ...planState };
+ const assertCurrent = () => {
+ const currentPermission = session.stablePermissionModeState;
+ const currentPlan = session.stablePlanModeState;
+ if (getSession(sessionId) !== session || !currentPermission || !currentPlan ||
+ currentPermission.generation !== permission.generation ||
+ currentPermission.mode !== permission.mode || currentPlan.enabled ||
+ currentPlan.generation !== plan.generation) {
+ throw new Error('TASK_ACTION_AUTHORIZATION_EXPIRED');
+ }
+ };
+ return {
+ session,
+ assertCurrent,
+ assertInputCurrent() {
+ assertCurrent();
+ if (session.getCurrentTurnOrigin() !== origin) {
+ throw new Error('TASK_ACTION_AUTHORIZATION_EXPIRED');
+ }
+ },
+ };
+}
+
/** Adapt the shared gate to Host facts. No transcript parsing or Agent-supplied approval fields. */
export function createDesktopTaskActionAuthorizer(deps: {
input(sessionId: string): {
@@ -27,11 +69,14 @@ export function createDesktopTaskActionAuthorizer(deps: {
orcaSenderSessionId?: string;
boundary: string;
};
+ getSession(sessionId: string): TaskActionSession | undefined;
confirm(sessionId: string, tool: string, args: unknown): Promise<boolean>;
}): ToolCallAuthorizer {
return async (call) => {
// Per invocation: a concurrent automatic call must never inherit owner evidence.
- let ownerScope: TaskActionScope | null = null;
+ let admittedScope: TaskActionScope | null = null;
+ let rejectedDecision: Awaited<ReturnType<ToolCallAuthorizer>> | null = null;
+ const fingerprint = taskActionFingerprint(call);
const decision = await createTaskActionAuthorizer({
confirm: deps.confirm,
capture: async (call) => {
@@ -55,12 +100,14 @@ export function createDesktopTaskActionAuthorizer(deps: {
.limit(1);
if (!caller) throw new Error('TASK_UNAVAILABLE');
const input = deps.input(sessionId);
+ const scheduled = !caller.botId && caller.source !== 'bot' &&
+ deps.getSession(sessionId)?.getCurrentTurnOrigin()?.kind === 'scheduler';
// User-authored ordinary work retains the existing Agent permission flow.
if (
!caller.botId &&
caller.source !== 'bot' &&
caller.source !== 'scheduler' &&
- !input.automatic
+ !input.automatic && !scheduled
)
return null;
if (caller.botId && (caller.botStatus !== 'active' || caller.archivedAt !== null))
@@ -72,6 +119,11 @@ export function createDesktopTaskActionAuthorizer(deps: {
? await authorizeGroupTool(sessionId, caller.botId, 'owner-action')
: null;
const ownerInput = group !== null || input.ownerInput;
+ // Ordinary owner-delegated schedules retain the normal permission flow.
+ // Neither a persisted scheduler source nor a Bot's automatic wake qualifies.
+ const runtime = !ownerInput && scheduled
+ ? captureScheduledRuntime(sessionId, deps.getSession)
+ : null;
const args =
call.args && typeof call.args === 'object' && !Array.isArray(call.args)
? (call.args as Record<string, unknown>)
@@ -139,6 +191,7 @@ export function createDesktopTaskActionAuthorizer(deps: {
};
const orcaTeam = ownerInput ? null : await readOrcaTeam();
const assertDeliveryCurrent = async () => {
+ runtime?.assertCurrent();
await group?.refresh();
if (
isAppSessionBoundaryPending() ||
@@ -177,8 +230,10 @@ export function createDesktopTaskActionAuthorizer(deps: {
group?.assertCurrent();
if (db !== tryGetDbClient() || isAppSessionBoundaryPending())
throw new Error('OWNER_SCOPE_CHANGED');
+ runtime?.assertCurrent();
};
const assertCurrentSync = () => {
+ runtime?.assertInputCurrent();
group?.assertCurrent();
const current = deps.input(sessionId);
if (
@@ -193,6 +248,8 @@ export function createDesktopTaskActionAuthorizer(deps: {
assertDeliveryCurrent,
assertCurrentSync,
assertCurrent: async () => {
+ if (fingerprint !== taskActionFingerprint(call))
+ throw new Error('TASK_ACTION_AUTHORIZATION_EXPIRED');
await assertDeliveryCurrent();
assertCurrentSync();
},
@@ -200,12 +257,38 @@ export function createDesktopTaskActionAuthorizer(deps: {
if (ownerInput) {
// Owner requests use the normal Agent permission flow, without a second card.
// Retain delivery evidence so workbench, queues and new delegations work too.
- ownerScope = scope;
+ admittedScope = scope;
return null;
}
+ if (runtime && !scope.delegated) {
+ // Session reuses Full Access / Auto / Ask and the owning task's restored
+ // user intent. Do not turn scheduled text into a fresh owner request.
+ const review = await runtime.session.reviewHostPermissionAction({
+ kind: 'other',
+ description: JSON.stringify({
+ toolName: `mcp__${call.server}__${call.tool}`,
+ input: structuredClone(call.args),
+ // Host timing fact, not a grant: setup may have asked to wait
+ // for a trigger which has now occurred. Owner scope still applies.
+ context: { source: 'scheduler', phase: 'triggered-continuation' },
+ }),
+ });
+ // A stale review must not open a confirmation for a newer task/input.
+ const admission = await admitTaskAction(call, scope, fingerprint);
+ if (!admission.ok) {
+ rejectedDecision = admission;
+ return null;
+ }
+ if (review.verdict === 'allow' || (review.verdict === 'ask' &&
+ await deps.confirm(sessionId, call.tool, structuredClone(call.args)))) {
+ admittedScope = scope;
+ return null;
+ }
+ }
return scope;
},
})(call);
- return decision.ok && ownerScope ? admitTaskAction(call, ownerScope) : decision;
+ return rejectedDecision ?? (decision.ok && admittedScope
+ ? admitTaskAction(call, admittedScope, fingerprint) : decision);
};
}
diff --git a/apps/desktop/src/main/mcp-integrations/mcp-providers.ts b/apps/desktop/src/main/mcp-integrations/mcp-providers.ts
index b505bdaf84..9c20b14dff 100644
--- a/apps/desktop/src/main/mcp-integrations/mcp-providers.ts
+++ b/apps/desktop/src/main/mcp-integrations/mcp-providers.ts
@@ -63,6 +63,7 @@ import {
isSessionInTurn,
getSessionInputProvenance,
getTaskActionInputState,
+ getTaskActionSession,
confirmTaskAction,
} from '../maker-ipc/register.js';
import { createBotProfile } from '../localDb/ipc/bots.js';
@@ -303,7 +304,9 @@ export function createDesktopMcpProviders(deps: DesktopMcpProvidersDeps): LiziMc
const authorizeTaskToolCall = createTaskToolCallAuthorizer({
getDb: () => (isAppSessionBoundaryPending() ? null : tryGetDbClient()),
isScopeCurrent: (db) => !isAppSessionBoundaryPending() && db === tryGetDbClient(),
- authorizeAction: createDesktopTaskActionAuthorizer({ input: getTaskActionInputState, confirm: confirmTaskAction }),
+ authorizeAction: createDesktopTaskActionAuthorizer({
+ input: getTaskActionInputState, getSession: getTaskActionSession, confirm: confirmTaskAction,
+ }),
});
// Companion history uses the same account scope as ordinary task history.
const botReadsAccountHistory = async (sessionId: string | undefined): Promise<boolean> => {
diff --git a/apps/desktop/src/main/scheduler-host/__tests__/runnerQueuedDispatch.test.ts b/apps/desktop/src/main/scheduler-host/__tests__/runnerQueuedDispatch.test.ts
index 2395feacbd..c6e5c6c471 100644
--- a/apps/desktop/src/main/scheduler-host/__tests__/runnerQueuedDispatch.test.ts
+++ b/apps/desktop/src/main/scheduler-host/__tests__/runnerQueuedDispatch.test.ts
@@ -58,6 +58,10 @@ const mocks = vi.hoisted(() => ({
executePreRunHook: vi.fn(),
}));
+const sharedProduction = vi.hoisted(() => ({
+ backfill: undefined as typeof import('../runners/_shared').backfillSessionMeta | undefined,
+}));
+
// 只有声明了 preRunHook 的用例会走到这里;其它用例不调用。
vi.mock('../pre-run-hook', async (importOriginal) => ({
...(await importOriginal<typeof import('../pre-run-hook')>()),
@@ -100,9 +104,11 @@ vi.mock('../workdir-resolver', () => ({
resolveWorkingDir: mocks.resolveWorkingDir,
}));
-vi.mock('../runners/_shared', () => ({
- backfillSessionMeta: mocks.backfillSessionMeta,
-}));
+vi.mock('../runners/_shared', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('../runners/_shared')>();
+ sharedProduction.backfill = actual.backfillSessionMeta;
+ return { backfillSessionMeta: mocks.backfillSessionMeta };
+});
import {
MakerScheduleRunner,
@@ -472,6 +478,7 @@ function latestNotifiedRun(notifier: Notifier & { notify: ReturnType<typeof vi.f
beforeEach(() => {
setCodexAppliedCustomProviderRoutes([]);
vi.clearAllMocks();
+ mocks.backfillSessionMeta.mockReset();
mocks.getSessionRowSnapshot.mockResolvedValue({
status: 'active',
userSendAt: null,
@@ -2747,6 +2754,35 @@ describe('queued heartbeat for a Bot Session task (persisted Auto)', () => {
mocks.getSessionFsSnapshot.mockResolvedValue(persisted);
});
+ // Local QA 2026-10-21: an explicit model on an ordinary bound schedule caused
+ // routing backfill to overwrite Auto with Full Access, then cancel dispatch.
+ // Existing queue tests stubbed the backfill and missed its persisted result.
+ // Unit tier: real runner.fire + production backfill, minimal in-memory DB sink.
+ it('preserves saved Auto when applying a queued scheduled model', async () => {
+ const harness = createSessionHarness(async () => ({ accepted: true }));
+ const runtime = withRuntimePermission(harness, 'auto');
+ const saved = { permissionMode: 'auto', planModeEnabled: false };
+ mocks.getSessionFsSnapshot.mockImplementation(async () => ({ ...saved }));
+ const db = {
+ update: () => ({ set: (patch: Record<string, unknown>) => ({
+ where: async () => { Object.assign(saved, patch); },
+ }) }),
+ };
+ mocks.backfillSessionMeta.mockImplementation(async (_db, id, patch, logger) => {
+ await sharedProduction.backfill!(db as never, id, patch, logger);
+ });
+ const queue = createQueueHarness({ busy: false });
+ const { runner, notifier } = createRunnerHarness(harness.session, queue.deps);
+ const fire = runner.fire(heartbeatSchedule({ model: 'claude-opus-4-8' }), createFireContext());
+ await vi.waitFor(() => expect(queue.enqueueCalls).toHaveLength(1));
+ await queue.accept(queuedFromRow);
+ harness.emit({ type: 'done', data: {}, source: 'claude-code' });
+ await expect(fire).resolves.toMatchObject({ sessionId: SESSION_ID });
+ expect(saved.permissionMode).toBe('auto');
+ expect(latestNotifiedRun(notifier).status).toBe('success');
+ await runtime.close();
+ });
+
/** 触发一次排队心跳并按落库值受理;返回 fire 的结局(resolve 值或 reject 原因)。 */
async function fireAndAccept(
runner: MakerScheduleRunner,
diff --git a/apps/desktop/src/main/scheduler-host/runner.ts b/apps/desktop/src/main/scheduler-host/runner.ts
index 9e9e17761f..b89faf22f3 100644
--- a/apps/desktop/src/main/scheduler-host/runner.ts
+++ b/apps/desktop/src/main/scheduler-host/runner.ts
@@ -3210,6 +3210,8 @@ export class MakerScheduleRunner implements ScheduleRunner {
this.deps.getDb(),
live.id,
{
+ // Model routing never owns a bound task's permission choice.
+ permissionMode: null,
model: modelChanged && modelApplied ? targetModel : undefined,
effort: effortChanged && effortApplied ? reconciledEffort : undefined,
fastMode: resolvedSelection?.fastMode,
diff --git a/docs/product-rules/agent-user-parity.md b/docs/product-rules/agent-user-parity.md
index 597446e088..8905bc96fd 100644
--- a/docs/product-rules/agent-user-parity.md
+++ b/docs/product-rules/agent-user-parity.md
@@ -102,7 +102,15 @@ Session 委托写操作,以及 `cindy_orca` 的协作写操作,共用 Host
2026-10-20 修订:主人私聊输入及经 Chat Server 实时核验的群内主人请求,沿用普通任务原有权限流程,
不再额外弹行动确认卡;helper 与 Orca、直接与渐进调用保持一致。群专线必须通过
`authorizeGroupTool(sessionId, botId, 'owner-action')`,仅有 role 或持久来源不算主人输入;
-访客、其他伙伴/任务转入、定时跟进仍受自动行动门约束,核验暂不可用不得放行。
+访客、其他伙伴/任务转入及伙伴自主定时跟进仍受自动行动门约束,核验暂不可用不得放行。
+2026-10-21 修订:普通任务中,用户已委托的定时工作沿用当前任务的权限审核,不能在正常审核前
+一律拒绝。Host 从活跃 Session 识别定时轮次,并对准确工具、目标和正文调用
+`Session.reviewHostPermissionAction`:Full Access 放行,Auto 使用原任务已恢复的用户意图,
+审核同时携带宿主确认的「定时触发已经发生」上下文,区分先前的设置阶段与当前续跑,
+该事实不构成新授权。排队时应用模型设置不得改写绑定任务的权限档。
+Ask 或审核要求确认时复用现有确认入口;Plan 不允许副作用。来源标签本身不提供授权,伙伴的
+自动观察不进入此路径。审核到执行及延迟投递均保留账号、实例、权限/Plan 代次与输入边界校验,
+不得借定时工作扩大原授权范围。
自动轮次没有有效委托只准备建议;已有委托的执行权不依赖自动观察规则的开关。
普通 Orca Lead 的当前 team 回报只延续原 team 范围,不能据此控制其它任务。跨电脑任务互发要求双方支持
行动回执,旧端明确提示不支持;未增加观察数据权限。实机多端验收仍待完成。