weaver-work-cli 0.1.32 → 0.1.36

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

@@ -0,0 +1,277 @@
+import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
+import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, coworkSuccess, schemaOf, } from './types.js';
+import { assertEnum, assertString, compact, normalizeList, requireConfirm, toBase64Html, toId, toPositiveInt, unwrapData, verifyLease, } from './shared.js';
+function isNetworkError(error) {
+    return error instanceof CoworkCliError && error.type === 'network';
+}
+/** 从协作详情取版块 id：发布讨论必须带 sectionId，页面是从当前协作上下文带出的。 */
+async function resolveSectionId(host, coworkId) {
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/cowork/view/viewCowork',
+        form: { id: coworkId },
+        operation: 'cowork.discuss.publish.prepare',
+    });
+    const detail = (unwrapData(response) ?? {});
+    if (!detail || Object.keys(detail).length === 0) {
+        throw coworkNotFoundError('item_not_found', `协作 ${coworkId} 不存在或无权查看`);
+    }
+    const sectionId = detail.sectionId ? String(detail.sectionId) : '';
+    if (!sectionId) {
+        throw coworkValidationError('section_unresolved', '无法从协作详情解析版块 id，请显式传 sectionId');
+    }
+    return sectionId;
+}
+const discussPublishPrepare = {
+    name: 'cowork.discuss.publish.prepare',
+    resource: 'cowork',
+    method: 'discuss.publish.prepare',
+    action: 'cowork.discuss.publish.prepare',
+    summary: '发布/回复讨论的确认摘要：先读协作详情确认存在并解析版块 id，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID, description: '协作 id' },
+        content: { type: 'string', maxLength: 20000, description: '讨论内容（纯文本）' },
+        sectionId: { ...SCHEMA_ID, description: '版块 id；不传则从协作详情自动解析' },
+    }, { required: ['coworkId', 'content'] }),
+    handler: async (args, env) => {
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const content = assertString(args.content, 'content', 20000);
+        const sectionId = args.sectionId !== undefined
+            ? toId(args.sectionId, 'sectionId')
+            : await resolveSectionId(env.host, coworkId);
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.discuss.publish.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            coworkId,
+            sectionId,
+            contentLength: content.length,
+            contentHash: hashText(content),
+        });
+        return coworkSuccess('cowork.discuss.publish.prepare', {
+            summary: {
+                coworkId,
+                sectionId,
+                sectionIdSource: args.sectionId !== undefined ? 'explicit' : 'resolved-from-view',
+                contentPreview: content.length > 120 ? `${content.slice(0, 120)}…` : content,
+                contentLength: content.length,
+            },
+            onApply: '将调用 publishCoworkDiscuss 发布一条讨论（replyType=discuss，client=pc）',
+            continuation,
+        });
+    },
+};
+function hashText(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++)
+        hash = (hash * 31 + text.charCodeAt(i)) | 0;
+    return String(hash >>> 0);
+}
+const discussPublishApply = {
+    name: 'cowork.discuss.publish.apply',
+    resource: 'cowork',
+    method: 'discuss.publish.apply',
+    action: 'cowork.discuss.publish.apply',
+    summary: '执行发布/回复讨论（需 confirm=true 与 continuation）',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID },
+        content: { type: 'string', maxLength: 20000 },
+        sectionId: { ...SCHEMA_ID },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['coworkId', 'content', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.discuss.publish.apply');
+        const lease = await verifyLease(args, 'cowork.discuss.publish.apply', env);
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const content = assertString(args.content, 'content', 20000);
+        if (lease.coworkId !== coworkId || lease.contentHash !== hashText(content)) {
+            throw coworkValidationError('target_changed', '协作 id 或讨论内容与 prepare 时不一致，请重新执行 prepare');
+        }
+        const sectionId = args.sectionId !== undefined
+            ? toId(args.sectionId, 'sectionId')
+            : String(lease.sectionId);
+        const body = {
+            attachments: '',
+            relevanceList: [],
+            atLinkList: [],
+            desensitization: 0,
+            secondAuth: 0,
+            clobContent: toBase64Html(content),
+            client: 'pc',
+            relatedFile: '',
+            replyType: 'discuss',
+            cwItemsId: coworkId,
+            sectionId,
+            anonymous: 0,
+            approvalStatus: 1,
+        };
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/cowork/main/publishCoworkDiscuss',
+                body,
+                operation: 'cowork.discuss.publish.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('讨论发布请求已发出但未收到确定结果，禁止自动重试：请用 cowork.discuss.list 核对该协作最新讨论', { coworkId });
+            }
+            throw error;
+        }
+        const data = (unwrapData(response) ?? {});
+        const root = response;
+        return coworkSuccess('cowork.discuss.publish.apply', {
+            coworkId,
+            sectionId,
+            status: data.status ?? root?.status ?? null,
+        });
+    },
+};
+const DISCUSS_ACTIONS = ['top', 'untop', 'delete', 'approve'];
+const DISCUSS_ACTION_PATHS = {
+    top: { path: '/api/cowork/view/topCoworkDiscuss', form: (id) => ({ id }) },
+    untop: { path: '/api/cowork/view/cancelTopCoworkDiscuss', form: (id) => ({ id }) },
+    delete: { path: '/api/cowork/view/deleteCoworkDiscuss', form: (id, all) => ({ id, isDeleteAll: all ? 1 : 0 }) },
+    approve: { path: '/api/cowork/view/approveCoworkDiscuss', form: (id) => ({ id }) },
+};
+/**
+ * 在协作的讨论记录里定位某条讨论（用于 prepare 的只读回查）。
+ * 讨论没有「按讨论 id 查详情」的接口，只能翻页匹配；翻页上限防失控。
+ */
+async function locateDiscuss(env, coworkId, discussId, maxPages = 5, pageSize = 50) {
+    for (let page = 1; page <= maxPages; page++) {
+        const response = await env.host.request({
+            method: 'POST',
+            path: '/api/cowork/view/discussRecord',
+            body: { coworkId, current: page, pageSize, orders: [{ column: 'lastReply', asc: false }] },
+            operation: 'cowork.discuss.action.prepare',
+        });
+        const { data } = normalizeList(response);
+        const rows = data;
+        if (!Array.isArray(rows) || rows.length === 0)
+            return null;
+        const hit = rows.find((row) => String(row.id ?? row.discussId ?? '') === discussId);
+        if (hit)
+            return hit;
+        if (rows.length < pageSize)
+            return null;
+    }
+    return null;
+}
+const discussActionPrepare = {
+    name: 'cowork.discuss.action.prepare',
+    resource: 'cowork',
+    method: 'discuss.action.prepare',
+    action: 'cowork.discuss.action.prepare',
+    summary: '讨论动作摘要（top 置顶 / untop 取消置顶 / delete 删除 / approve 审批通过）：在协作讨论中定位该讨论并回显内容，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...DISCUSS_ACTIONS], description: 'top / untop / delete / approve' },
+        coworkId: { ...SCHEMA_ID, description: '所属协作 id（用于定位讨论）' },
+        discussId: { ...SCHEMA_ID, description: '讨论 id' },
+        isDeleteAll: { type: 'boolean', description: 'action=delete 时是否删除全部回复，默认 true（与页面一致）' },
+        maxPages: { type: 'integer', minimum: 1, maximum: 20, description: '定位讨论的翻页上限，默认 5' },
+        pageSize: { type: 'integer', minimum: 1, maximum: 100, description: '每页条数，默认 50' },
+    }, { required: ['action', 'coworkId', 'discussId'] }),
+    handler: async (args, env) => {
+        const action = assertEnum(args.action, DISCUSS_ACTIONS, 'action');
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const discussId = toId(args.discussId, 'discussId');
+        const hit = await locateDiscuss(env, coworkId, discussId, toPositiveInt(args.maxPages, 'maxPages') ?? 5, toPositiveInt(args.pageSize, 'pageSize') ?? 50);
+        if (!hit) {
+            throw coworkNotFoundError('discuss_not_found', `在前 ${toPositiveInt(args.maxPages, 'maxPages') ?? 5} 页讨论中未找到讨论 ${discussId}：请确认 coworkId 与讨论 id 是否匹配（禁止对未确认的讨论执行动作）`);
+        }
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.discuss.action.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            action,
+            coworkId,
+            discussId,
+            isDeleteAll: args.isDeleteAll === false ? false : true,
+        });
+        return coworkSuccess('cowork.discuss.action.prepare', {
+            summary: {
+                action,
+                coworkId,
+                discussId,
+                contentPreview: previewOf(hit),
+                author: hit.creatorName ?? hit.username ?? hit.creator ?? null,
+                createdTime: hit.createTime ?? hit.createShowTime ?? null,
+                isDeleteAll: action === 'delete' ? (args.isDeleteAll === false ? false : true) : undefined,
+            },
+            continuation,
+        });
+    },
+};
+function previewOf(row) {
+    const raw = row.clobContent ?? row.content ?? row.summary ?? '';
+    const text = String(raw).replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    return text.length > 120 ? `${text.slice(0, 120)}…` : text;
+}
+const discussActionApply = {
+    name: 'cowork.discuss.action.apply',
+    resource: 'cowork',
+    method: 'discuss.action.apply',
+    action: 'cowork.discuss.action.apply',
+    summary: '执行讨论动作（top / untop / delete / approve），需 confirm=true 与 continuation',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...DISCUSS_ACTIONS] },
+        coworkId: { ...SCHEMA_ID },
+        discussId: { ...SCHEMA_ID },
+        isDeleteAll: { type: 'boolean' },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['action', 'coworkId', 'discussId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.discuss.action.apply');
+        const lease = await verifyLease(args, 'cowork.discuss.action.apply', env);
+        const action = assertEnum(args.action, DISCUSS_ACTIONS, 'action');
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const discussId = toId(args.discussId, 'discussId');
+        if (lease.action !== action || lease.discussId !== discussId) {
+            throw coworkValidationError('target_changed', '与 prepare 时的目标不一致，请重新执行 prepare');
+        }
+        const isDeleteAll = lease.isDeleteAll !== false;
+        const spec = DISCUSS_ACTION_PATHS[action];
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: spec.path,
+                form: compact(spec.form(discussId, isDeleteAll)),
+                operation: 'cowork.discuss.action.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('讨论动作请求已发出但未收到确定结果，禁止自动重试：请重新拉取讨论列表核对', { action, discussId });
+            }
+            throw error;
+        }
+        return coworkSuccess('cowork.discuss.action.apply', {
+            action,
+            coworkId,
+            discussId,
+            result: unwrapData(response) ?? null,
+        });
+    },
+};
+export const coworkDiscussWriteOperations = [
+    discussPublishPrepare,
+    discussPublishApply,
+    discussActionPrepare,
+    discussActionApply,
+];

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

@@ -0,0 +1,380 @@
+import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
+import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, SCHEMA_DATETIME, coworkSuccess, schemaOf, } from './types.js';
+import { assertEnum, assertString, requireConfirm, toBase64Html, toId, unwrapData, verifyLease, } from './shared.js';
+function isNetworkError(error) {
+    return error instanceof CoworkCliError && error.type === 'network';
+}
+/** 版块合法性校验：从新建表单的 items.sectionId.options 取真实版块 id（脚本实测结构）。 */
+async function resolveSectionOptions(host) {
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/cowork/main/getCoworkAddItemForm',
+        form: { id: '', type: 'new' },
+        operation: 'cowork.item.create.prepare',
+    });
+    const data = unwrapData(response);
+    const options = data?.items?.sectionId?.options;
+    if (!Array.isArray(options))
+        return [];
+    return options.map((o) => ({ id: String(o.id), name: String(o.content ?? o.name ?? '') }));
+}
+const SWITCH_FIELDS = [
+    'enableDiscussElog',
+    'enableViewLog',
+    'expandDetail',
+    'allowInvite',
+    'allowQuit',
+    'allowApply',
+    'allowHideDelelted',
+];
+function buildSwitches(args) {
+    const switches = {};
+    for (const field of SWITCH_FIELDS) {
+        const value = args[field];
+        switches[field] = value === undefined ? 1 : (value === true || value === 1 || value === '1' ? 1 : 0);
+    }
+    return switches;
+}
+const itemCreatePrepare = {
+    name: 'cowork.item.create.prepare',
+    resource: 'cowork',
+    method: 'item.create.prepare',
+    action: 'cowork.item.create.prepare',
+    summary: '新建协作的确认摘要：校验版块 id 是否在本环境真实存在、负责人默认为当前用户、开关默认全开；不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        itemName: { type: 'string', maxLength: 200, description: '协作主题' },
+        itemContent: { type: 'string', maxLength: 20000, description: '详细说明（纯文本或 HTML，CLI 内部按接口要求做 Base64 编码）' },
+        sectionId: { ...SCHEMA_ID, description: '所属版块 id（用 cowork.form 的 sectionId 选项确定）' },
+        principal: { ...SCHEMA_ID, description: '负责人人员 id，默认当前登录用户' },
+        endTime: { ...SCHEMA_DATETIME, description: '截止时间 YYYY-MM-DD HH:mm，默认 7 天后' },
+        enableDiscussElog: { type: 'boolean', description: '启用讨论日志，默认 true' },
+        enableViewLog: { type: 'boolean', description: '启用查看日志，默认 true' },
+        expandDetail: { type: 'boolean', description: '展开详情，默认 true' },
+        allowInvite: { type: 'boolean', description: '允许邀请，默认 true' },
+        allowQuit: { type: 'boolean', description: '允许退出，默认 true' },
+        allowApply: { type: 'boolean', description: '允许申请，默认 true' },
+        allowHideDelelted: { type: 'boolean', description: '允许隐藏删除，默认 true' },
+    }, { required: ['itemName', 'sectionId'] }),
+    handler: async (args, env) => {
+        const itemName = assertString(args.itemName, 'itemName', 200);
+        const sectionId = toId(args.sectionId, 'sectionId');
+        const options = await resolveSectionOptions(env.host);
+        let sectionName;
+        if (options.length > 0) {
+            const hit = options.find((o) => o.id === sectionId);
+            if (!hit) {
+                throw coworkNotFoundError('section_not_found', `版块 id ${sectionId} 不在本环境的可选版块中，请用 cowork.form 重新获取`, { availableSections: options });
+            }
+            sectionName = hit.name;
+        }
+        const session = await env.host.getSession();
+        const principal = toId(args.principal, 'principal') || session.userId;
+        if (!principal) {
+            throw coworkValidationError('principal_required', '无法确定负责人：请显式传 principal（人员 id）');
+        }
+        const endTime = args.endTime
+            ? assertString(args.endTime, 'endTime', 32)
+            : defaultEndTime();
+        const switches = buildSwitches(args);
+        const itemContent = typeof args.itemContent === 'string' ? args.itemContent : '';
+        const summary = {
+            itemName,
+            sectionId,
+            sectionName: sectionName ?? '(未取到版块名，仅校验了表单结构)',
+            principal,
+            principalIsCurrentUser: principal === session.userId,
+            endTime,
+            switches,
+            contentLength: itemContent.length,
+        };
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.item.create.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            itemName,
+            sectionId,
+            principal,
+            endTime,
+            switches,
+            contentHash: hashCode(itemContent),
+        });
+        return coworkSuccess('cowork.item.create.prepare', {
+            summary,
+            onApply: '将调用 saveItemsInfo 新建协作（主表 + 开关参数），成功后返回新协作 id',
+            continuation,
+        });
+    },
+};
+function hashCode(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+        hash = (hash * 31 + text.charCodeAt(i)) | 0;
+    }
+    return String(hash >>> 0);
+}
+function defaultEndTime() {
+    const target = new Date(Date.now() + 7 * 24 * 3600 * 1000);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${target.getFullYear()}-${pad(target.getMonth() + 1)}-${pad(target.getDate())} ${pad(target.getHours())}:${pad(target.getMinutes())}`;
+}
+const itemCreateApply = {
+    name: 'cowork.item.create.apply',
+    resource: 'cowork',
+    method: 'item.create.apply',
+    action: 'cowork.item.create.apply',
+    summary: '执行新建协作（需 confirm=true 与 prepare 的 continuation）',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        itemName: { type: 'string', maxLength: 200, description: '协作主题（须与 prepare 一致）' },
+        itemContent: { type: 'string', maxLength: 20000, description: '详细说明（须与 prepare 一致）' },
+        sectionId: { ...SCHEMA_ID, description: '所属版块 id' },
+        principal: { ...SCHEMA_ID, description: '负责人人员 id' },
+        endTime: { ...SCHEMA_DATETIME, description: '截止时间' },
+        enableDiscussElog: { type: 'boolean' },
+        enableViewLog: { type: 'boolean' },
+        expandDetail: { type: 'boolean' },
+        allowInvite: { type: 'boolean' },
+        allowQuit: { type: 'boolean' },
+        allowApply: { type: 'boolean' },
+        allowHideDelelted: { type: 'boolean' },
+        confirm: { type: 'boolean', description: '用户明确确认后传 true' },
+        continuation: { type: 'string', description: 'prepare 返回的 continuation' },
+    }, { required: ['itemName', 'sectionId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.item.create.apply');
+        const lease = await verifyLease(args, 'cowork.item.create.apply', env);
+        const itemName = assertString(args.itemName, 'itemName', 200);
+        const sectionId = toId(args.sectionId, 'sectionId');
+        const principal = args.principal !== undefined
+            ? toId(args.principal, 'principal')
+            : String(lease.principal || '');
+        const endTime = assertString(args.endTime || lease.endTime, 'endTime', 32);
+        const itemContent = typeof args.itemContent === 'string' ? args.itemContent : '';
+        const switches = buildSwitches(args);
+        // 快照一致性：prepare 与 apply 的目标/内容指纹必须一致，避免用户确认后被替换。
+        if (lease.itemName !== itemName || lease.sectionId !== sectionId || lease.principal !== principal) {
+            throw coworkValidationError('target_changed', '与 prepare 时的目标不一致（主题/版块/负责人已变化），请重新执行 prepare');
+        }
+        if (lease.contentHash !== hashCode(itemContent)) {
+            throw coworkValidationError('content_changed', '说明内容与 prepare 时不一致，请重新执行 prepare');
+        }
+        const body = {
+            itemName,
+            itemContent: toBase64Html(itemContent),
+            sectionId,
+            principal,
+            endTime,
+            ...switches,
+            relatedFile: '',
+            params: {
+                ...switches,
+                itemName,
+                relatedFile: [],
+                principal: principal ? [{ id: principal, name: '' }] : [],
+            },
+        };
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/cowork/main/saveItemsInfo',
+                body,
+                operation: 'cowork.item.create.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('新建协作请求已发出但未收到确定结果，禁止自动重试：请先用 cowork.list 核对是否已创建', { itemName, sectionId });
+            }
+            throw error;
+        }
+        const data = (unwrapData(response) ?? {});
+        const root = response;
+        const ok = !!(data.status ?? root?.status);
+        if (!ok) {
+            throw coworkPartialError('新建协作返回未确认成功，请用 cowork.list 核对后再决定是否重试', { itemName, raw: data });
+        }
+        return coworkSuccess('cowork.item.create.apply', {
+            id: data.id ? String(data.id) : null,
+            itemName,
+            sectionId,
+            principal,
+            endTime,
+        });
+    },
+};
+const ITEM_ACTIONS = ['end'];
+const itemActionPrepare = {
+    name: 'cowork.item.action.prepare',
+    resource: 'cowork',
+    method: 'item.action.prepare',
+    action: 'cowork.item.action.prepare',
+    summary: '协作级动作的确认摘要（当前支持 end 结束协作）：先读详情校验存在与 canEnd，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...ITEM_ACTIONS], description: 'end=结束协作（不可逆）' },
+        id: { ...SCHEMA_ID, description: '协作 id' },
+    }, { required: ['action', 'id'] }),
+    handler: async (args, env) => {
+        const action = assertEnum(args.action, ITEM_ACTIONS, 'action');
+        const id = toId(args.id, 'id');
+        const detailResponse = await env.host.request({
+            method: 'POST',
+            path: '/api/cowork/view/viewCowork',
+            form: { id },
+            operation: 'cowork.item.action.prepare',
+        });
+        const detail = (unwrapData(detailResponse) ?? {});
+        if (!detail || Object.keys(detail).length === 0) {
+            throw coworkNotFoundError('item_not_found', `协作 ${id} 不存在或无权查看`);
+        }
+        const canEnd = String(detail.canEnd) === '1';
+        if (!canEnd) {
+            throw coworkValidationError('not_permitted', `当前用户不可结束该协作（canEnd=${String(detail.canEnd)}）`);
+        }
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.item.action.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            action,
+            id,
+            itemName: detail.itemName ?? '',
+        });
+        return coworkSuccess('cowork.item.action.prepare', {
+            summary: {
+                action,
+                id,
+                itemName: detail.itemName ?? '',
+                status: detail.itemStatus,
+                canEnd,
+                warning: action === 'end' ? '结束协作后参与者不可再回复，且页面不提供撤销' : undefined,
+            },
+            continuation,
+        });
+    },
+};
+const itemActionApply = {
+    name: 'cowork.item.action.apply',
+    resource: 'cowork',
+    method: 'item.action.apply',
+    action: 'cowork.item.action.apply',
+    summary: '执行协作级动作（end 结束协作），需 confirm=true 与 continuation',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...ITEM_ACTIONS] },
+        id: { ...SCHEMA_ID },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['action', 'id', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.item.action.apply');
+        const lease = await verifyLease(args, 'cowork.item.action.apply', env);
+        const action = assertEnum(args.action, ITEM_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: '/api/cowork/view/endCoworkItem',
+                form: { id },
+                operation: 'cowork.item.action.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('结束协作请求已发出但未收到确定结果，禁止自动重试：请先用 cowork.view 核对状态', { id });
+            }
+            throw error;
+        }
+        return coworkSuccess('cowork.item.action.apply', { action, id, result: unwrapData(response) ?? null });
+    },
+};
+const ITEM_FLAGS = ['hide', 'vote'];
+const itemFlagPrepare = {
+    name: 'cowork.item.flag.prepare',
+    resource: 'cowork',
+    method: 'item.flag.prepare',
+    action: 'cowork.item.flag.prepare',
+    summary: '协作标记动作摘要：hide=从我的列表隐藏 / vote=标记投票；先读详情确认协作存在，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...ITEM_FLAGS], description: 'hide 隐藏 / vote 标记投票' },
+        id: { ...SCHEMA_ID, description: '协作 id' },
+    }, { required: ['action', 'id'] }),
+    handler: async (args, env) => {
+        const action = assertEnum(args.action, ITEM_FLAGS, 'action');
+        const id = toId(args.id, 'id');
+        const detailResponse = await env.host.request({
+            method: 'POST',
+            path: '/api/cowork/view/viewCowork',
+            form: { id },
+            operation: 'cowork.item.flag.prepare',
+        });
+        const detail = (unwrapData(detailResponse) ?? {});
+        if (!detail || Object.keys(detail).length === 0) {
+            throw coworkNotFoundError('item_not_found', `协作 ${id} 不存在或无权查看`);
+        }
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.item.flag.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            action,
+            id,
+        });
+        return coworkSuccess('cowork.item.flag.prepare', {
+            summary: { action, id, itemName: detail.itemName ?? '' },
+            continuation,
+        });
+    },
+};
+const itemFlagApply = {
+    name: 'cowork.item.flag.apply',
+    resource: 'cowork',
+    method: 'item.flag.apply',
+    action: 'cowork.item.flag.apply',
+    summary: '执行协作标记动作（hide / vote），需 confirm=true 与 continuation',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...ITEM_FLAGS] },
+        id: { ...SCHEMA_ID },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['action', 'id', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.item.flag.apply');
+        const lease = await verifyLease(args, 'cowork.item.flag.apply', env);
+        const action = assertEnum(args.action, ITEM_FLAGS, 'action');
+        const id = toId(args.id, 'id');
+        if (lease.action !== action || lease.id !== id) {
+            throw coworkValidationError('target_changed', '与 prepare 时的目标不一致，请重新执行 prepare');
+        }
+        const form = action === 'hide' ? { hidden: 1, ids: id } : { vote: 1, ids: id };
+        const response = await env.host.request({
+            method: 'POST',
+            path: action === 'hide' ? '/api/cowork/behavior/markAsHidden' : '/api/cowork/behavior/markAsVote',
+            form,
+            operation: 'cowork.item.flag.apply',
+        });
+        return coworkSuccess('cowork.item.flag.apply', { action, id, result: unwrapData(response) ?? null });
+    },
+};
+export const coworkItemWriteOperations = [
+    itemCreatePrepare,
+    itemCreateApply,
+    itemActionPrepare,
+    itemActionApply,
+    itemFlagPrepare,
+    itemFlagApply,
+];