weaver-work-cli 0.1.32 → 0.1.33

package/dist/shortcuts/cowork/operations/read.js

@@ -0,0 +1,423 @@
+import { READ, SCHEMA_ID, SCHEMA_PAGE_CURRENT, SCHEMA_PAGE_SIZE, coworkSuccess, schemaOf, } from './types.js';
+import { assertEnum, buildListBody, compact, normalizeList, toId, toPositiveInt, unwrapData, } from './shared.js';
+/**
+ * 列表 scope → 接口路径。11 个列表结构一致（JSON + 标准列表 envelope），
+ * 因此收敛为单个 `cowork.list`：同一业务动作（查协作/事项/申请），用 scope 区分数据集，
+ * 避免 11 个几乎同参的 operation 让 Agent 选择困难。
+ */
+const LIST_PATHS = {
+    main: '/api/cowork/main/getCoworkMainItemList',
+    attention: '/api/cowork/attention/getCoworkAttentionItemList',
+    collect: '/api/cowork/collect/getCoworkCollectList',
+    mineDiscuss: '/api/cowork/mine/getCoworkMineDiscussList',
+    mineComment: '/api/cowork/mine/getCoworkMineCommentList',
+    mineItem: '/api/cowork/mineItem/getCoworkMineItemList',
+    related: '/api/cowork/related/relatedRecord',
+    apply: '/api/cowork/apply/getCoworkApplyList',
+    approve: '/api/cowork/apply/getCoworkApplyApproveList',
+    log: '/api/cowork/apply/getCoworkApplyLogList',
+    quit: '/api/cowork/apply/getCoworkQuitList',
+    // 审批台列表（脚本实测；接口文档未收录，但真机验证可用）
+    itemApprove: '/api/cowork/itemApprove/getCoworkItemApproveList',
+    discussApprove: '/api/cowork/discussApprove/getCoworkDiscussApproveList',
+};
+/** 条件元数据 scope → 接口路径。列表筛选字段以这些接口返回为准。 */
+const CONDITION_PATHS = {
+    main: '/api/cowork/main/getCoworkMainItemSearchCondition',
+    attention: '/api/cowork/attention/getCoworkAttentionItemSearchCondition',
+    collect: '/api/cowork/collect/getCoworkDiscussCollectSearchCondition',
+    mine: '/api/cowork/mine/getCoworkMineSearchCondition',
+    mineItem: '/api/cowork/mineItem/getCoworkMineItemSearchCondition',
+    related: '/api/cowork/related/getCoworkRelatedSearchCondition',
+    apply: '/api/cowork/apply/getCoworkItemApplySearchCondition',
+    approve: '/api/cowork/apply/getCoworkApplyApproveSearchCondition',
+    log: '/api/cowork/apply/getCoworkApplyLogSearchCondition',
+    quit: '/api/cowork/apply/getCoworkQuitSearchCondition',
+    discuss: '/api/cowork/view/getCoworkDiscussSearchCondition',
+};
+const LIST_SCOPES = Object.keys(LIST_PATHS);
+const CONDITION_SCOPES = Object.keys(CONDITION_PATHS);
+const conditionField = (description) => ({
+    type: 'string',
+    enum: ['in', 'bl'],
+    description: `${description}匹配模式：in 精确 / bl 模糊`,
+});
+const listSchema = schemaOf({
+    scope: {
+        type: 'string',
+        enum: LIST_SCOPES,
+        description: [
+            'main=协作列表',
+            'attention=我关注的',
+            'collect=我收藏的',
+            'mineDiscuss=我的讨论',
+            'mineComment=我的评论',
+            'mineItem=我的事项（tabKey 区分我创建的/我负责的）',
+            'related=相关我',
+            'apply=申请加入列表',
+            'approve=待审批列表（加入申请）',
+            'log=审批日志',
+            'quit=退出列表',
+            'itemApprove=事项审批台列表',
+            'discussApprove=交流审批台列表',
+        ].join('；'),
+    },
+    current: SCHEMA_PAGE_CURRENT,
+    pageSize: SCHEMA_PAGE_SIZE,
+    type: { type: 'string', enum: ['and', 'or'], description: '条件组合方式，默认 and' },
+    itemName: { type: 'string', description: '协作主题' },
+    itemNameCondition: conditionField('协作主题'),
+    sectionId: SCHEMA_ID,
+    sectionCondition: conditionField('版块'),
+    principal: SCHEMA_ID,
+    principalCondition: conditionField('负责人'),
+    creator: SCHEMA_ID,
+    creatorCondition: conditionField('创建人'),
+    creatorSearch: { type: 'string', description: '创建人关键字（仅 scope=main）' },
+    tagId: SCHEMA_ID,
+    tagCondition: conditionField('标签'),
+    tagCommonId: SCHEMA_ID,
+    tagCommonCondition: conditionField('公共标签'),
+    itemStatus: { type: 'string', description: '协作状态：1 进行中（默认 1）' },
+    hidden: { type: 'string', description: '是否含隐藏：0 否（默认 0）/ 1 是' },
+    tabKey: { type: 'string', description: 'mineItem 默认 mineItemCreate；mineDiscuss/mineComment 可省略' },
+    orderBy: { type: 'string', enum: ['collectTime'], description: '排序字段（仅 scope=collect）' },
+    sortOrder: { type: 'string', enum: ['asc', 'desc'], description: '排序方向（仅 scope=collect）' },
+    quickSearchDatas: { type: 'object', description: '快速搜索条件（仅 scope=collect）' },
+    discussFrom: { type: 'string', description: '来源标识，scope=related 默认 relatedMenu' },
+    applyer: SCHEMA_ID,
+    applyerCondition: conditionField('申请人（scope=approve）'),
+    applyerDept: SCHEMA_ID,
+    applyerDeptCondition: conditionField('申请人部门（scope=approve）'),
+    approver: SCHEMA_ID,
+    approverCondition: conditionField('审批人（scope=log）'),
+    applyStatus: { type: 'string', description: '申请状态（scope=log）' },
+    applyStatusCondition: conditionField('申请状态（scope=log）'),
+    dateType: { type: 'string', description: '日期类型（scope=discussApprove，默认空）' },
+}, { required: ['scope'] });
+const coworkList = {
+    name: 'cowork.list',
+    resource: 'cowork',
+    method: 'list',
+    action: 'cowork.list',
+    summary: '按 scope 查询协作/关注/收藏/我的事项/申请/待审批/审批日志/退出等列表（分页；筛选字段以 cowork.conditions 返回为准）',
+    risk: READ,
+    inputSchema: listSchema,
+    handler: async (args, { host }) => {
+        const scope = assertEnum(args.scope, LIST_SCOPES, 'scope');
+        const body = buildListBody(args, scope);
+        const response = await host.request({
+            method: 'POST',
+            path: LIST_PATHS[scope],
+            body,
+            operation: 'cowork.list',
+        });
+        const { data, page } = normalizeList(response);
+        return coworkSuccess('cowork.list', data, { scope, ...page });
+    },
+};
+const coworkConditions = {
+    name: 'cowork.conditions',
+    resource: 'cowork',
+    method: 'conditions',
+    action: 'cowork.conditions',
+    summary: '取对应列表的高级搜索条件元数据（groups/layout），是构造 cowork.list 筛选参数的唯一依据',
+    risk: READ,
+    inputSchema: schemaOf({ scope: { type: 'string', enum: CONDITION_SCOPES, description: '与 cowork.list 的 scope 对应；discuss 用于讨论列表' } }, { required: ['scope'] }),
+    handler: async (args, { host }) => {
+        const scope = assertEnum(args.scope, CONDITION_SCOPES, 'scope');
+        const response = await host.request({
+            method: 'POST',
+            path: CONDITION_PATHS[scope],
+            body: {},
+            operation: 'cowork.conditions',
+        });
+        return coworkSuccess('cowork.conditions', unwrapData(response) ?? null, { scope });
+    },
+};
+const coworkCount = {
+    name: 'cowork.count',
+    resource: 'cowork',
+    method: 'count',
+    action: 'cowork.count',
+    summary: '统计进行中协作总数（与 scope=main 列表口径一致）',
+    risk: READ,
+    inputSchema: schemaOf({
+        hidden: { type: 'string', description: '是否含隐藏：0 否（默认）/ 1 是' },
+        itemStatus: { type: 'string', description: '协作状态，默认 1 进行中' },
+    }),
+    handler: async (args, { host }) => {
+        const body = compact({
+            hidden: args.hidden === undefined ? '0' : String(args.hidden),
+            itemStatus: args.itemStatus === undefined ? '1' : String(args.itemStatus),
+        });
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/main/countCoworkMainItem',
+            body,
+            operation: 'cowork.count',
+        });
+        return coworkSuccess('cowork.count', unwrapData(response) ?? null);
+    },
+};
+const coworkView = {
+    name: 'cowork.view',
+    resource: 'cowork',
+    method: 'view',
+    action: 'cowork.view',
+    summary: '查协作详情（状态/版块/权限标记 canEdit、canEnd、canReply 等）',
+    risk: READ,
+    inputSchema: schemaOf({ id: { ...SCHEMA_ID, description: '协作 id' } }, { required: ['id'] }),
+    handler: async (args, { host }) => {
+        const id = toId(args.id, 'id');
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/view/viewCowork',
+            form: { id },
+            operation: 'cowork.view',
+        });
+        return coworkSuccess('cowork.view', unwrapData(response) ?? null);
+    },
+};
+const coworkDiscussList = {
+    name: 'cowork.discuss.list',
+    resource: 'cowork',
+    method: 'discuss.list',
+    action: 'cowork.discuss.list',
+    summary: '查某协作下的讨论/回复记录（默认按最后回复倒序）',
+    risk: READ,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID, description: '协作 id' },
+        current: SCHEMA_PAGE_CURRENT,
+        pageSize: SCHEMA_PAGE_SIZE,
+        orderColumn: { type: 'string', description: '排序字段，默认 lastReply' },
+        orderAsc: { type: 'boolean', description: '是否升序，默认 false（倒序）' },
+    }, { required: ['coworkId'] }),
+    handler: async (args, { host }) => {
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const body = compact({
+            coworkId,
+            current: toPositiveInt(args.current, 'current') ?? 1,
+            pageSize: toPositiveInt(args.pageSize, 'pageSize'),
+            orders: [{
+                    column: typeof args.orderColumn === 'string' && args.orderColumn ? args.orderColumn : 'lastReply',
+                    asc: args.orderAsc === true,
+                }],
+        });
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/view/discussRecord',
+            body,
+            operation: 'cowork.discuss.list',
+        });
+        const { data, page } = normalizeList(response);
+        return coworkSuccess('cowork.discuss.list', data, page);
+    },
+};
+const PARTICIPANT_SCOPES = ['all', 'share', 'quit'];
+const coworkParticipantList = {
+    name: 'cowork.participant.list',
+    resource: 'cowork',
+    method: 'participant.list',
+    action: 'cowork.participant.list',
+    summary: '查协作参与人：all=全部参与人 / share=共享参与人（含邮箱手机） / quit=退出记录',
+    risk: READ,
+    inputSchema: schemaOf({
+        scope: { type: 'string', enum: [...PARTICIPANT_SCOPES], description: 'all / share / quit' },
+        id: { ...SCHEMA_ID, description: '协作 id' },
+        participationFrom: { type: 'string', description: 'scope=all 时的来源标识，默认 participant' },
+        current: SCHEMA_PAGE_CURRENT,
+        pageSize: SCHEMA_PAGE_SIZE,
+    }, { required: ['scope', 'id'] }),
+    handler: async (args, { host }) => {
+        const scope = assertEnum(args.scope, PARTICIPANT_SCOPES, 'scope');
+        const id = toId(args.id, 'id');
+        if (scope === 'share') {
+            const response = await host.request({
+                method: 'POST',
+                path: '/api/cowork/view/shareParticipation',
+                form: { id },
+                operation: 'cowork.participant.list',
+            });
+            return coworkSuccess('cowork.participant.list', unwrapData(response) ?? null, { scope });
+        }
+        if (scope === 'quit') {
+            const body = compact({
+                coworkId: id,
+                current: toPositiveInt(args.current, 'current') ?? 1,
+                pageSize: toPositiveInt(args.pageSize, 'pageSize') ?? 10,
+            });
+            const response = await host.request({
+                method: 'POST',
+                path: '/api/cowork/main/getCoworkQuitList',
+                body,
+                operation: 'cowork.participant.list',
+            });
+            const { data, page } = normalizeList(response);
+            return coworkSuccess('cowork.participant.list', data, { scope, ...page });
+        }
+        const body = compact({
+            id,
+            participationFrom: typeof args.participationFrom === 'string' && args.participationFrom
+                ? args.participationFrom
+                : 'participant',
+            current: toPositiveInt(args.current, 'current') ?? 1,
+            pageSize: toPositiveInt(args.pageSize, 'pageSize') ?? 10,
+        });
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/view/participationAllList',
+            body,
+            operation: 'cowork.participant.list',
+        });
+        const { data, page } = normalizeList(response);
+        return coworkSuccess('cowork.participant.list', data, { scope, ...page });
+    },
+};
+const coworkResource = {
+    name: 'cowork.resource',
+    resource: 'cowork',
+    method: 'resource',
+    action: 'cowork.resource',
+    summary: '查协作关联资源数据（为空时返回 {}）',
+    risk: READ,
+    inputSchema: schemaOf({ id: { ...SCHEMA_ID, description: '协作 id' } }, { required: ['id'] }),
+    handler: async (args, { host }) => {
+        const id = toId(args.id, 'id');
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/view/resourceData',
+            form: { id },
+            operation: 'cowork.resource',
+        });
+        return coworkSuccess('cowork.resource', unwrapData(response) ?? null);
+    },
+};
+const coworkVoteLog = {
+    name: 'cowork.vote.log',
+    resource: 'cowork',
+    method: 'vote.log',
+    action: 'cowork.vote.log',
+    summary: '查协作投票日志（无投票时 total 为 0）',
+    risk: READ,
+    inputSchema: schemaOf({
+        id: { ...SCHEMA_ID, description: '协作 id' },
+        current: SCHEMA_PAGE_CURRENT,
+        pageSize: SCHEMA_PAGE_SIZE,
+    }, { required: ['id'] }),
+    handler: async (args, { host }) => {
+        const id = toId(args.id, 'id');
+        const body = compact({
+            id,
+            current: toPositiveInt(args.current, 'current') ?? 1,
+            pageSize: toPositiveInt(args.pageSize, 'pageSize') ?? 10,
+        });
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/view/voteLog',
+            body,
+            operation: 'cowork.vote.log',
+        });
+        const { data, page } = normalizeList(response);
+        return coworkSuccess('cowork.vote.log', data, page);
+    },
+};
+const coworkForm = {
+    name: 'cowork.form',
+    resource: 'cowork',
+    method: 'form',
+    action: 'cowork.form',
+    summary: '取新建协作的表单元数据（groups/layout），用于确定版块 sectionId 与可选开关字段；建协作前必须先调用',
+    risk: READ,
+    inputSchema: schemaOf({ id: { ...SCHEMA_ID, description: '编辑已有协作文时传其 id；新建留空' } }),
+    handler: async (args, { host }) => {
+        const id = toId(args.id, 'id');
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/main/getCoworkAddItemForm',
+            form: { id: id ?? '', type: 'new' },
+            operation: 'cowork.form',
+        });
+        return coworkSuccess('cowork.form', unwrapData(response) ?? null);
+    },
+};
+const META_SCOPES = ['operateAuth', 'layout'];
+const coworkMeta = {
+    name: 'cowork.meta',
+    resource: 'cowork',
+    method: 'meta',
+    action: 'cowork.meta',
+    summary: '取协作模块的界面元数据：operateAuth=当前用户在列表可执行的操作（如批量删除）/ layout=行为布局标识',
+    risk: READ,
+    inputSchema: schemaOf({ scope: { type: 'string', enum: [...META_SCOPES], description: 'operateAuth 或 layout' } }, { required: ['scope'] }),
+    handler: async (args, { host }) => {
+        const scope = assertEnum(args.scope, META_SCOPES, 'scope');
+        if (scope === 'layout') {
+            const response = await host.request({
+                method: 'GET',
+                path: '/api/cowork/behavior/getLayout',
+                operation: 'cowork.meta',
+            });
+            return coworkSuccess('cowork.meta', unwrapData(response) ?? null, { scope });
+        }
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/main/getListOperateAuth',
+            body: {},
+            operation: 'cowork.meta',
+        });
+        return coworkSuccess('cowork.meta', unwrapData(response) ?? null, { scope });
+    },
+};
+const coworkPermissionList = {
+    name: 'cowork.permission.list',
+    resource: 'cowork',
+    method: 'permission.list',
+    action: 'cowork.permission.list',
+    summary: '查协作的共享权限对象列表（删除共享对象前用它取得真实记录 id）',
+    risk: READ,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID, description: '协作 id' },
+        permissionId: { ...SCHEMA_ID, description: '权限类型 id，默认 5（协作默认参与权限）' },
+        current: SCHEMA_PAGE_CURRENT,
+        pageSize: SCHEMA_PAGE_SIZE,
+    }, { required: ['coworkId'] }),
+    handler: async (args, { host }) => {
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const permissionId = toId(args.permissionId, 'permissionId') ?? '5';
+        const body = {
+            sourceId: coworkId,
+            permissionId,
+            sourceType: 1,
+            current: toPositiveInt(args.current, 'current') ?? 1,
+            pageSize: toPositiveInt(args.pageSize, 'pageSize') ?? 50,
+            id: coworkId,
+            permissionFrom: permissionId,
+        };
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/cowork/permission/getCoworkSharePermissionList',
+            body,
+            operation: 'cowork.permission.list',
+        });
+        const { data, page } = normalizeList(response);
+        return coworkSuccess('cowork.permission.list', data, { coworkId, permissionId, ...page });
+    },
+};
+export const coworkReadOperations = [
+    coworkList,
+    coworkConditions,
+    coworkCount,
+    coworkView,
+    coworkDiscussList,
+    coworkParticipantList,
+    coworkResource,
+    coworkVoteLog,
+    coworkForm,
+    coworkMeta,
+    coworkPermissionList,
+];
+/** 供测试与 manifest 复用的路径映射（避免测试硬编码路径与实现漂移）。 */
+export const COWORK_LIST_PATHS = LIST_PATHS;
+export const COWORK_CONDITION_PATHS = CONDITION_PATHS;
+export { LIST_SCOPES, CONDITION_SCOPES };

package/dist/shortcuts/cowork/operations/registry.js

@@ -0,0 +1,39 @@
+import { coworkValidationError } from '../errors.js';
+import { coworkReadOperations } from './read.js';
+import { coworkItemWriteOperations } from './item-write.js';
+import { coworkDiscussWriteOperations } from './discuss-write.js';
+import { coworkMemberWriteOperations } from './member-write.js';
+import { coworkReviewOperations } from './review-write.js';
+import { coworkPermissionWriteOperations } from './permission-write.js';
+function buildRegistry() {
+    const registry = new Map();
+    const definitions = [
+        ...coworkReadOperations,
+        ...coworkItemWriteOperations,
+        ...coworkDiscussWriteOperations,
+        ...coworkMemberWriteOperations,
+        ...coworkReviewOperations,
+        ...coworkPermissionWriteOperations,
+    ];
+    for (const definition of definitions) {
+        if (registry.has(definition.name)) {
+            throw new Error(`duplicate cowork operation: ${definition.name}`);
+        }
+        registry.set(definition.name, definition);
+    }
+    return registry;
+}
+const coworkOperationRegistry = buildRegistry();
+export function coworkOperationDefinitions() {
+    return [...coworkOperationRegistry.values()];
+}
+export function getCoworkOperation(operation) {
+    const definition = coworkOperationRegistry.get(operation);
+    if (!definition) {
+        throw coworkValidationError('operation_unknown', `协作区不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasCoworkOperation(operation) {
+    return coworkOperationRegistry.has(operation);
+}

package/dist/shortcuts/cowork/operations/review-write.js

@@ -0,0 +1,157 @@
+import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
+import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, coworkSuccess, schemaOf, } from './types.js';
+import { assertEnum, compact, normalizeList, requireConfirm, toId, toPositiveInt, unwrapData, verifyLease, } from './shared.js';
+function isNetworkError(error) {
+    return error instanceof CoworkCliError && error.type === 'network';
+}
+const REVIEW_ACTIONS = ['approve', 'delete'];
+const REVIEW_SPECS = {
+    item: {
+        label: '事项审批',
+        listPath: '/api/cowork/itemApprove/getCoworkItemApproveList',
+        listBody: (page) => ({
+            current: page,
+            itemNameCondition: 'in',
+            sectionCondition: 'bl',
+            itemStatus: '1',
+            principalCondition: 'bl',
+            principal: '',
+            creatorCondition: 'bl',
+            creator: '',
+            type: 'and',
+        }),
+        actionPath: {
+            approve: '/api/cowork/itemApprove/approveCoworkItem',
+            delete: '/api/cowork/itemApprove/deleteCoworkItem',
+        },
+        actionForm: (_action, id) => ({ ids: id }),
+    },
+    discuss: {
+        label: '交流审批',
+        listPath: '/api/cowork/discussApprove/getCoworkDiscussApproveList',
+        listBody: (page) => ({ current: page, type: 'and', dateType: '' }),
+        actionPath: {
+            approve: '/api/cowork/discussApprove/approveCoworkDiscuss',
+            delete: '/api/cowork/discussApprove/deleteCoworkDiscuss',
+        },
+        actionForm: (action, id) => (action === 'delete' ? { id, isDeleteAll: 1 } : { id }),
+    },
+};
+async function locateReviewRecord(env, domain, recordId, maxPages, pageSize) {
+    const spec = REVIEW_SPECS[domain];
+    for (let page = 1; page <= maxPages; page++) {
+        const response = await env.host.request({
+            method: 'POST',
+            path: spec.listPath,
+            body: spec.listBody(page),
+            operation: `cowork.review.${domain}.prepare`,
+        });
+        const { data } = normalizeList(response);
+        const rows = Array.isArray(data) ? data : [];
+        if (rows.length === 0)
+            return null;
+        const hit = rows.find((row) => String(row.id ?? '') === recordId);
+        if (hit)
+            return hit;
+        if (rows.length < pageSize)
+            return null;
+    }
+    return null;
+}
+function buildReviewOperations(domain) {
+    const spec = REVIEW_SPECS[domain];
+    const prepareName = `cowork.review.${domain}.prepare`;
+    const applyName = `cowork.review.${domain}.apply`;
+    const prepare = {
+        name: prepareName,
+        resource: 'cowork',
+        method: `review.${domain}.prepare`,
+        action: prepareName,
+        summary: `${spec.label}台的动作摘要（approve 通过 / delete 删除）：先在待审列表中定位记录并回显主题，不写入`,
+        risk: READ_BEFORE_WRITE,
+        inputSchema: schemaOf({
+            action: { type: 'string', enum: [...REVIEW_ACTIONS], description: 'approve 通过 / delete 删除' },
+            id: { ...SCHEMA_ID, description: `记录 id（来自 cowork.list 的 ${domain === 'item' ? 'itemApprove' : 'discussApprove'} 列表）` },
+            maxPages: { type: 'integer', minimum: 1, maximum: 20, description: '定位记录的翻页上限，默认 5' },
+        }, { required: ['action', 'id'] }),
+        handler: async (args, env) => {
+            const action = assertEnum(args.action, REVIEW_ACTIONS, 'action');
+            const id = toId(args.id, 'id');
+            const maxPages = toPositiveInt(args.maxPages, 'maxPages') ?? 5;
+            const hit = await locateReviewRecord(env, domain, id, maxPages, 50);
+            if (!hit) {
+                throw coworkNotFoundError('record_not_found', `在前 ${maxPages} 页${spec.label}列表中未找到记录 ${id}：请先用 cowork.list 拉取对应待审列表确认，禁止对未确认的记录执行动作`);
+            }
+            const session = await env.host.getSession();
+            const continuation = await env.continuation.issue({
+                operation: applyName,
+                baseUrl: session.baseUrl,
+                profile: session.profile,
+                userId: session.userId,
+                action,
+                id,
+            });
+            return coworkSuccess(prepareName, {
+                summary: {
+                    domain,
+                    action,
+                    id,
+                    itemName: hit.itemName ?? null,
+                    applyer: hit.applyerName ?? hit.creatorName ?? hit.username ?? null,
+                    status: hit.applyStatus ?? hit.approvalStatus ?? null,
+                },
+                continuation,
+            });
+        },
+    };
+    const apply = {
+        name: applyName,
+        resource: 'cowork',
+        method: `review.${domain}.apply`,
+        action: applyName,
+        summary: `执行${spec.label}动作（approve / delete），需 confirm=true 与 continuation`,
+        risk: WRITE,
+        requiresConfirmation: true,
+        inputSchema: schemaOf({
+            action: { type: 'string', enum: [...REVIEW_ACTIONS] },
+            id: { ...SCHEMA_ID },
+            confirm: { type: 'boolean' },
+            continuation: { type: 'string' },
+        }, { required: ['action', 'id', 'confirm', 'continuation'] }),
+        handler: async (args, env) => {
+            requireConfirm(args, applyName);
+            const lease = await verifyLease(args, applyName, env);
+            const action = assertEnum(args.action, REVIEW_ACTIONS, 'action');
+            const id = toId(args.id, 'id');
+            if (lease.action !== action || lease.id !== id) {
+                throw coworkValidationError('target_changed', '与 prepare 时的目标不一致，请重新执行 prepare');
+            }
+            let response;
+            try {
+                response = await env.host.request({
+                    method: 'POST',
+                    path: spec.actionPath[action],
+                    form: compact(spec.actionForm(action, id)),
+                    operation: applyName,
+                });
+            }
+            catch (error) {
+                if (isNetworkError(error)) {
+                    throw coworkPartialError(`${spec.label}动作请求已发出但未收到确定结果，禁止自动重试：请重新拉取待审列表核对`, { domain, action, id });
+                }
+                throw error;
+            }
+            return coworkSuccess(applyName, {
+                domain,
+                action,
+                id,
+                result: unwrapData(response) ?? null,
+            });
+        },
+    };
+    return [prepare, apply];
+}
+export const coworkReviewOperations = [
+    ...buildReviewOperations('item'),
+    ...buildReviewOperations('discuss'),
+];