termdock 1.4.306 → 1.4.308

package/dist/server/agent/collaborationTaskStore.js

@@ -2,6 +2,7 @@ import { randomBytes, createHash } from 'node:crypto';
 import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { collaborationResultPresentation } from './collaborationResultPresentation.js';
+import { taskExecution, taskPurpose } from './collaborationTaskPurpose.js';
 import { CollaborationError } from './collaborationProtocol.js';
 import { taskMemberKey } from './collaborationTaskTypes.js';
 const id = () => randomBytes(16).toString('hex');
@@ -50,6 +51,9 @@ function validateSnapshot(task) {
     text(task.spec, '任务内容', 32_000, true);
     text(task.constraints, '约束');
     text(task.acceptance, '完成标准');
+    taskPurpose(task.purpose);
+    if (task.purpose === 'automation' && (task.workflow || task.parentTaskId || task.dependsOn.length || task.coordinator))
+        invalid();
     member({ serviceId: task.ownerServiceId, sessionId: 'validation' });
     if (task.coordinator !== null)
         member(task.coordinator);
@@ -83,6 +87,8 @@ function validateSnapshot(task) {
             invalid();
         if (event.deliveryId !== undefined && !validId(event.deliveryId))
             invalid();
+        if (event.purpose !== undefined)
+            taskPurpose(event.purpose);
         if (event.source !== undefined && !['system', 'user', 'integration'].includes(event.source))
             invalid();
         if (event.actor !== null)
@@ -183,7 +189,7 @@ export class CollaborationTaskStore {
             const reportSummary = current?.report?.content.split(/\n\s*\n/).map(paragraph => paragraph.split('\n').filter(line => !/^#{1,6}\s/.test(line)).join('\n').trim()).find(Boolean)?.slice(0, 512);
             const automationIssueSource = task.automationIssue ? current?.report && ['blocked', 'failed'].includes(current.report.status)
                 && task.automationIssue === current.report.content.slice(0, 1000) ? 'member-report' : 'system' : undefined;
-            return { ...task, automationIssueSource, spec: task.spec.slice(0, 512), constraints: '', acceptance: '',
+            return { ...task, ...(task.purpose === 'automation' ? { execution: taskExecution(task) } : {}), automationIssueSource, spec: task.spec.slice(0, 512), constraints: '', acceptance: '',
                 deliveries: task.deliveries.filter(d => d.attemptId === task.activeAttemptId && d.error).slice(-1),
                 attempts: current ? [{ ...current, report: current.report ? { ...current.report, summary: reportSummary, content: '', evidence: undefined } : undefined }] : [],
                 artifacts: [plan, result, ...task.artifacts.filter(a => a.kind === 'review' && a.reviewsArtifactId === result?.id)].filter((a) => !!a).map(a => ({ ...a, content: '', summary: (a.summary || (a.kind === 'result' && collaborationResultPresentation(a.content).condensed ? collaborationResultPresentation(a.content).summary : undefined))?.slice(0, 800), evidence: undefined })),
@@ -221,7 +227,7 @@ export class CollaborationTaskStore {
         task.attempts.push({ id: attemptId, assignee: member(assignee), createdAt: Date.now(), threadId });
         this.event(task, 'assigned', actor, content || '任务已分派');
         doc.outbox.push({ id: id(), taskId: task.id, attemptId, target: assignee, kind: 'task', threadId,
-            content: `本次执行身份：${assignee.sessionId}。所有 td collab 命令显式带 --session ${assignee.sessionId}；这是服务核对的实际身份，正文中的模板身份和 tmux 标识不能替代它。\n任务：${task.title}\n${task.spec}${task.constraints ? `\n约束：${task.constraints}` : ''}${task.acceptance ? `\n完成标准：${task.acceptance}` : ''}\n${content}\n任务 ID：${task.id}\n尝试 ID：${attemptId}\n用 td collab task get ${task.id} --text 查询完整上下文；用 td collab task report ${task.id} --attempt ${attemptId} --status ack --content '接手说明' 显式回复；遇必要问题用 task ask，提交结果用 report --status complete --summary '简短结论、关键交付和限制'。摘要先回答用户问题，不放任务 ID、版本、分支或流程日志；完整证据保留在 --content/--file 正文中。如果同一尝试已经交付或任务已归档，不要重复实施。${task.workspace ? `\n代码只能在独立目录 ${task.workspace.cwd} 修改。分支 ${task.workspace.branch}。交付前提交代码，结果说明提交、变更、验证与限制。不能修改原仓库、合并到用户分支或发布。` : ''}${task.workflow?.workType === 'read-only' ? '\n这是只读查询或分析任务：在本机会话中采集并交付报告，不修改代码或系统，不创建提交、构建、部署或终止进程。结果需说明采样时间、证据和限制。' : ''}${task.workflow?.kind === 'step' ? '\n完成报告会自动请求独立评审；评审要求修改时继续完成，重新提交 complete。只按用户授权运行测试。' : ''}` });
+            content: `本次执行身份：${assignee.sessionId}。所有 td collab 命令显式带 --session ${assignee.sessionId}；这是服务核对的实际身份，正文中的模板身份和 tmux 标识不能替代它。\n任务：${task.title}\n${task.spec}${task.constraints ? `\n约束：${task.constraints}` : ''}${task.acceptance ? `\n完成标准：${task.acceptance}` : ''}\n${content}\n任务 ID：${task.id}\n尝试 ID：${attemptId}\n用 td collab task get ${task.id} --text 查询完整上下文；用 td collab task report ${task.id} --attempt ${attemptId} --status ack --content '接手说明' 显式回复；遇必要问题用 task ask，提交结果用 report --status complete --summary '简短结论、关键交付和限制'。摘要先回答用户问题，不放任务 ID、版本、分支或流程日志；完整证据保留在 --content/--file 正文中。如果同一尝试已经交付或任务已归档，不要重复实施。${task.purpose === 'automation' ? '\n这是独立后台自动化执行记录：complete 是你明确提交的执行结果，无需等待用户 accepted。机械校验和外部发布由接入系统处理；纯咨询用 respond 关联原 comment，不重复提交 complete。必要问题用 ask 保留原文，由接入系统联系用户并回答。' : ''}${task.workspace ? `\n代码只能在独立目录 ${task.workspace.cwd} 修改。分支 ${task.workspace.branch}。交付前提交代码，结果说明提交、变更、验证与限制。不能修改原仓库、合并到用户分支或发布。` : ''}${task.workflow?.workType === 'read-only' ? '\n这是只读查询或分析任务：在本机会话中采集并交付报告，不修改代码或系统，不创建提交、构建、部署或终止进程。结果需说明采样时间、证据和限制。' : ''}${task.workflow?.kind === 'step' ? '\n完成报告会自动请求独立评审；评审要求修改时继续完成，重新提交 complete。只按用户授权运行测试。' : ''}` });
     }
     goalInstructions(task) {
         return `${this.baseGoalInstructions(task)}\n启动 Agent 前，读取 task get 返回的 launchProfiles、defaultLaunchProfileId 和 roster.launchProfile。根据用户填写的 notes 判断适用任务；这些是选用建议，不是能力或性能保证。需要另一种模型或参数时，用 td collab spawn ${task.groupId} <agentSlug> --launch-profile <方案id> --cwd <项目目录> --session ${task.coordinator?.sessionId} 创建对应执行成员，再把子任务分派给它。已有成员及其代码执行会话保留创建时的启动方案，不因默认方案变更而更换模型。`;
@@ -248,6 +254,9 @@ export class CollaborationTaskStore {
             content: `你被指定为任务「${task.title}」的协调者。\n目标：${task.spec}\n约束：${task.constraints || '未补充'}\n验收标准：${task.acceptance || '由用户决定'}\n任务 ID：${task.id}\n用 td collab task get ${task.id} --text 查看原始记录；用 task list --group ${task.groupId} 查看工作组。需要拆分时用 task create --group ${task.groupId} --parent ${task.id} --title '子任务标题' --content '任务内容'。分派前查询 revision，再用 task assign --revision；把必要的人类决策交给 task ask，不推断成员忙闲，不停止其他成员终端。` });
     }
     create(owner, input, actor, origin) {
+        const purpose = taskPurpose(input.purpose);
+        if (purpose === 'automation' && (input.managed || input.parentTaskId || input.dependsOn?.length || input.coordinator || input.reviewers?.length || input.integration))
+            throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '后台自动化记录不加入人工目标、依赖或评审流程');
         const title = text(input.title, '标题', 640, true), spec = text(input.spec, '任务内容', 32_000, true);
         const constraints = text(input.constraints, '约束'), acceptance = text(input.acceptance, '完成标准');
         if (input.dependsOn !== undefined && (!Array.isArray(input.dependsOn) || input.dependsOn.length > 32 || input.dependsOn.some(v => typeof v !== 'string')))
@@ -276,6 +285,8 @@ export class CollaborationTaskStore {
             for (const dependency of [...dependsOn, ...(input.parentTaskId ? [input.parentTaskId] : [])]) {
                 if (!doc.tasks.some(t => t.id === dependency && t.groupId === input.groupId))
                     throw new CollaborationError('TASK_DEPENDENCY_NOT_FOUND', '父任务或依赖任务不在当前协作组', 404);
+                if (doc.tasks.find(t => t.id === dependency)?.purpose === 'automation')
+                    throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '后台自动化记录不能作为人工任务父级或验收依赖');
             }
             const now = Date.now();
             const parent = doc.tasks.find(t => t.id === input.parentTaskId);
@@ -307,11 +318,11 @@ export class CollaborationTaskStore {
                 if (!required.length || required.some(t => !dependsOn.includes(t.id)))
                     throw new CollaborationError('INTEGRATION_DEPENDENCIES_REQUIRED', '集成任务必须依赖目标下全部实施子任务');
             }
-            const task = { id: id(), ownerServiceId: owner, groupId: input.groupId, title, spec, constraints, acceptance,
+            const task = { id: id(), ownerServiceId: owner, groupId: input.groupId, title, spec, constraints, acceptance, purpose,
                 coordinator: parent?.workflow ? parent.coordinator : input.coordinator !== undefined ? input.coordinator : input.parentTaskId ? doc.tasks.find(t => t.id === input.parentTaskId)?.coordinator ?? actor : null,
                 parentTaskId: input.parentTaskId ?? null, dependsOn, createdAt: now, updatedAt: now, revision: 1,
                 ...(origin ? { origin: structuredClone(origin) } : {}), status: 'open', activeAttemptId: null, attempts: [], decisions: [], artifacts: [], events: [], deliveries: [], ...(workflow ? { workflow } : {}) };
-            this.event(task, 'created', actor, spec);
+            this.event(task, 'created', actor, spec).purpose = purpose;
             if (parent?.constraints)
                 task.constraints = text([parent.constraints, constraints].filter(Boolean).join('\n'), '继承约束');
             if (workflow?.kind === 'goal') {
@@ -335,6 +346,12 @@ export class CollaborationTaskStore {
         }, origin);
     }
     apply(taskId, input, actor, origin) {
+        if (input.purpose !== undefined && input.kind !== 'configure')
+            throw new CollaborationError('INVALID_TASK_PURPOSE', 'purpose can only be changed through configure');
+        if (input.kind === 'configure' && input.purpose === undefined)
+            throw new CollaborationError('INVALID_TASK_PURPOSE', 'configure requires purpose');
+        if (input.kind === 'configure')
+            taskPurpose(input.purpose);
         const content = text(input.content, '内容');
         const summary = text(input.summary, '结果摘要', 2400);
         if (summary && (input.kind !== 'report' || input.status !== 'complete'))
@@ -353,6 +370,8 @@ export class CollaborationTaskStore {
             if (origin && ['accept', 'approve-plan', 'report', 'ask', 'submit-plan', 'review', 'respond'].includes(input.kind))
                 throw new CollaborationError('INTEGRATION_OPERATION_DENIED', '此操作需要用户或原执行成员身份', 403);
             const coordination = actor === null || sameMember(actor, task.coordinator);
+            if (input.kind === 'configure' && actor !== null)
+                throw new CollaborationError('USER_DECISION_REQUIRED', '用途配置需要用户管理身份或授权的集成身份', 403);
             if (['assign', 'coordinator', 'close', 'reopen', 'revise', 'request-review', 'coordinate', 'pause', 'resume', 'retry'].includes(input.kind) && !coordination)
                 throw new CollaborationError('TASK_PERMISSION_DENIED', '此操作需要用户或当前协调者', 403);
             if (['answer', 'accept', 'approve-plan'].includes(input.kind) && actor !== null)
@@ -360,7 +379,7 @@ export class CollaborationTaskStore {
             if (!['report', 'ask', 'submit-plan', 'review', 'comment', 'respond', 'answer'].includes(input.kind) && input.expectedRevision !== task.revision)
                 throw new CollaborationError('TASK_CHANGED', '任务已更新，请查看最新记录后重试', 409);
             const userFollowup = actor === null && input.kind === 'revise' && !!content;
-            if (task.status !== 'open' && !['reopen', 'report'].includes(input.kind) && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
+            if (task.status !== 'open' && !['configure', 'reopen', 'report'].includes(input.kind) && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
                 throw new CollaborationError('TASK_ARCHIVED', '任务已归档；需要继续时请重新打开', 409);
             if (task.workflow && task.status !== 'open' && input.kind !== 'reopen' && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
                 throw new CollaborationError('TASK_ARCHIVED', '自动协作的已完成版本不能追加执行报告，请先重新打开', 409);
@@ -390,7 +409,15 @@ export class CollaborationTaskStore {
                 throw new CollaborationError('ATTEMPT_SUPERSEDED', '这轮分派已被替换，不能再请求用户决定', 409);
             if (task.workflow && ['report', 'ask', 'submit-plan'].includes(input.kind) && attempt?.id !== task.activeAttemptId)
                 throw new CollaborationError('ATTEMPT_SUPERSEDED', '自动协作只能推进当前分派', 409);
-            if (input.kind === 'assign') {
+            if (input.kind === 'configure') {
+                const purpose = taskPurpose(input.purpose);
+                if (purpose === 'automation' && (task.workflow || task.parentTaskId || task.dependsOn.length || task.coordinator
+                    || doc.tasks.some(t => t.parentTaskId === task.id || t.workflow?.rootTaskId === task.id || t.dependsOn.includes(task.id))))
+                    throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '只能把独立记录改为后台自动化用途');
+                task.purpose = purpose;
+                this.event(task, 'configured', actor, content || `任务用途已配置为 ${purpose}`).purpose = purpose;
+            }
+            else if (input.kind === 'assign') {
                 if (task.workflow?.kind === 'goal' && !sameMember(input.assignee ?? null, task.coordinator))
                     throw new CollaborationError('GOAL_COORDINATOR_REQUIRED', '目标由协调者负责，请在子任务中分派实施');
                 if (task.dependsOn.some(dep => doc.tasks.find(t => t.id === dep)?.status !== 'accepted'))
@@ -407,6 +434,8 @@ export class CollaborationTaskStore {
                 this.notifyCoordinator(doc, task);
             }
             else if (input.kind === 'coordinator') {
+                if (task.purpose === 'automation' && input.coordinator)
+                    throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '后台自动化记录不加入人工协调流程');
                 if (task.workflow && !input.coordinator)
                     throw new CollaborationError('GOAL_COORDINATOR_REQUIRED', '自动协作需要协调者');
                 const previousCoordinator = task.coordinator;

package/dist/server/agent/integrationCli.js

@@ -4,7 +4,7 @@ import http from 'node:http';
 import { INTEGRATION_PROTOCOL } from './integrationStore.js';
 import { integrationSocketPath } from './integrationServer.js';
 import { CollaborationError } from './collaborationProtocol.js';
-import { executeCollaborationCommand, duration } from './collaborationCli.js';
+import { COLLAB_HELP, executeCollaborationCommand, duration } from './collaborationCli.js';
 import { getTermdockVersion } from '../utils/version.js';
 export const INTEGRATION_HELP = `td integration — local scoped integration administration
   groups | list
@@ -14,6 +14,9 @@ export const INTEGRATION_HELP = `td integration — local scoped integration adm
   revoke <principal-id>
 Credentials are saved as a private file and never printed. Workers set
 TERMDOCK_INTEGRATION_CREDENTIAL_FILE, then use td collab --principal <id> …
+Ordinary messages: permissions message.send, message.read, events.read;
+td collab --principal <id> --help lists send/reply/history and event examples.
+No task or user acceptance is required for a message-driven integration.
 Only the local administrator can provision/revoke grants. See docs/integrations.md.`;
 export function readIntegrationCredential(file, principalId) {
     const info = fs.lstatSync(file);
@@ -55,7 +58,7 @@ export async function runIntegrationAdmin(argv, port, adminToken, write) {
     let reserved;
     try {
         const action = argv[0] ?? 'help', options = {};
-        if (action === 'help' || action === '--help') {
+        if (action === 'help' || argv.includes('--help')) {
             write(INTEGRATION_HELP);
             return 0;
         }
@@ -131,6 +134,10 @@ export async function revokeIntegration(id, port, adminToken, write) {
 }
 export async function runIntegrationCollab(command, port, io) {
     try {
+        if (command.action === 'help') {
+            io.write(COLLAB_HELP);
+            return 0;
+        }
         const principalId = String(command.options.principal), file = process.env.TERMDOCK_INTEGRATION_CREDENTIAL_FILE;
         if (!file)
             throw new CollaborationError('INTEGRATION_CREDENTIAL_REQUIRED', 'Set TERMDOCK_INTEGRATION_CREDENTIAL_FILE to a private credential file', 401);
@@ -160,8 +167,12 @@ export async function runIntegrationCollab(command, port, io) {
             io.write(JSON.stringify(parsed(await request(socketPath, command.operation === 'get' ? 'GET' : 'POST', route, body, headers(credential)))));
             return 0;
         }
-        if (!['task', 'message', 'help'].includes(command.action) || command.action === 'message' && command.operation !== 'get')
-            throw new CollaborationError('INTEGRATION_OPERATION_DENIED', 'Command is not exposed to integration identities', 403);
+        const messageCapability = command.action === 'send' ? 'integration_message_send' : command.action === 'reply' ? 'integration_message_reply'
+            : command.action === 'message' && command.operation === 'list' ? 'integration_message_history' : null;
+        if (messageCapability && capability[messageCapability] !== true)
+            throw new CollaborationError('INTEGRATION_MESSAGING_UNSUPPORTED', 'CLI and running service must support integration messaging (minimum 1.4.308); upgrade both and read capabilities', 409);
+        if (!['task', 'message', 'send', 'reply'].includes(command.action) || command.action === 'message' && !['get', 'list'].includes(command.operation))
+            throw new CollaborationError('INTEGRATION_OPERATION_DENIED', 'Command is not exposed to integration identities; see td collab --principal <id> --help', 403);
         return executeCollaborationCommand(command, {}, { ...io, request: async (method, endpoint, body, timeout) => {
                 const origin = { source: command.options.source, externalActor: command.options['external-actor'] ? JSON.parse(String(command.options['external-actor'])) : undefined,
                     externalMessageId: command.options['external-message-id'], metadata: command.options.metadata ? JSON.parse(String(command.options.metadata)) : undefined };

package/dist/server/agent/integrationServer.js

@@ -4,12 +4,20 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
 import { timingSafeEqual } from 'node:crypto';
-import { CollaborationError } from './collaborationProtocol.js';
+import { CollaborationError, resolveIdPrefix } from './collaborationProtocol.js';
 import { terminalMessage } from './collaborationStore.js';
-import { IntegrationStore, INTEGRATION_PROTOCOL, integrationError } from './integrationStore.js';
+import { IntegrationStore, INTEGRATION_PROTOCOL, INTEGRATION_OPERATIONS, integrationError } from './integrationStore.js';
 import { IntegrationSessions, publicIntegrationSession } from './integrationSessions.js';
 import { getTermdockVersion } from '../utils/version.js';
 export function integrationSocketPath(port) { return path.join(homedir(), '.termdock', `integration-${port}.sock`); }
+function scopedId(input, ids, type) {
+    if (typeof input !== 'string')
+        integrationError(`INVALID_${type}_ID`, 'A message or member id is required');
+    const result = resolveIdPrefix([...new Set(ids)], input);
+    if (result.status !== 'ok')
+        integrationError(`${type}_${result.status === 'ambiguous' ? 'ID_AMBIGUOUS' : 'NOT_FOUND'}`, `No unique ${type.toLowerCase()} in this integration group`, result.status === 'ambiguous' ? 409 : 404);
+    return result.id;
+}
 /** A local authenticated API and push stream. It is never mounted on the
  * public HTTP application and does not reuse an integration's admin token. */
 export class IntegrationRuntime {
@@ -35,7 +43,7 @@ export class IntegrationRuntime {
         } };
         this.stops.push(options.messages.subscribe(changed), options.taskStore.subscribe(changed), this.sessions.subscribe(changed));
         const app = express();
-        app.use(express.json({ limit: '1mb' }));
+        app.use(express.json({ limit: '2mb' }));
         app.use((req, res, next) => {
             if (req.headers['x-termdock-integration-protocol'] !== String(INTEGRATION_PROTOCOL)) {
                 res.status(409).json({ ...this.error(new CollaborationError('INCOMPATIBLE_INTEGRATION_PROTOCOL', 'Unsupported integration protocol', 409)), protocol: INTEGRATION_PROTOCOL });
@@ -73,7 +81,7 @@ export class IntegrationRuntime {
             integrationError('INVALID_INTEGRATION_POLICY', 'Policy identity must match the requested identity'); this.group(req.body?.groupId); this.store.update(req.body); return { ok: true, id: req.params.id }; }));
         app.post('/admin/principals/:id/revoke', run(req => { admin(req); this.store.revoke(req.params.id); return { ok: true }; }));
         app.get('/capabilities', run(req => { const p = principal(req); return { ...this.capabilities(), principal: { id: p.id, group_id: p.groupId, permissions: p.permissions, launch_profiles: p.launchProfiles.map(profile => ({ id: profile.id, agent_slug: profile.agentSlug, cwd_roots: profile.cwdRoots, startup_input_condition: !!profile.startupInput })) } }; }));
-        app.get('/tasks', run(req => { const p = principal(req); this.authorize(p, 'task.read', req.query.group); return { tasks: options.tasks.list(p.groupId, null) }; }));
+        app.get('/tasks', run(req => { const p = principal(req); this.authorize(p, 'task.read', req.query.group); return { tasks: options.tasks.list(p.groupId, null, req.query.purpose) }; }));
         app.get('/tasks/:id', run(async (req) => { const p = principal(req); this.taskPermission(p, req.params.id, 'task.read'); return { task: await options.tasks.get(req.params.id, null) }; }));
         app.post('/tasks', run(async (req) => {
             const p = principal(req), raw = req.body?.input ?? {};
@@ -81,7 +89,7 @@ export class IntegrationRuntime {
             if (raw.managed || raw.parentTaskId || raw.dependsOn?.length || raw.coordinatorSessionId || raw.reviewerSessionIds?.length || raw.integration)
                 integrationError('INTEGRATION_OPERATION_DENIED', 'Integration creates ordinary standalone tasks only', 403);
             const input = { idempotencyKey: raw.idempotencyKey, groupId: p.groupId, title: raw.title, spec: raw.spec,
-                constraints: raw.constraints, acceptance: raw.acceptance, assignee: raw.assigneeSessionId ? options.peers.taskMember(String(raw.assigneeSessionId)) : undefined };
+                purpose: raw.purpose, constraints: raw.constraints, acceptance: raw.acceptance, assignee: raw.assigneeSessionId ? options.peers.taskMember(String(raw.assigneeSessionId)) : undefined };
             if (input.assignee)
                 this.authorize(p, 'task.assign');
             const task = await options.tasks.create(input, null, this.origin(p, req.body?.origin));
@@ -90,24 +98,75 @@ export class IntegrationRuntime {
         }));
         app.post('/tasks/:id', run(async (req) => {
             const p = principal(req), raw = req.body?.input ?? {};
-            const permissions = { assign: 'task.assign', comment: 'task.comment', revise: 'task.revise', answer: 'task.answer' };
+            const permissions = { configure: 'task.configure', assign: 'task.assign', comment: 'task.comment', revise: 'task.revise', answer: 'task.answer' };
             const permission = permissions[raw.kind];
             if (!permission)
                 integrationError('INTEGRATION_OPERATION_DENIED', 'Operation requires a user or terminal member', 403);
             this.taskPermission(p, req.params.id, permission);
             const input = { kind: raw.kind, idempotencyKey: raw.idempotencyKey, content: raw.content,
-                expectedRevision: raw.expectedRevision, decisionId: raw.decisionId,
+                purpose: raw.purpose, expectedRevision: raw.expectedRevision, decisionId: raw.decisionId,
                 assignee: raw.assigneeSessionId ? options.peers.taskMember(String(raw.assigneeSessionId)) : undefined };
             const task = await options.tasks.apply(req.params.id, input, null, this.origin(p, req.body?.origin));
             this.sync();
             const event = options.taskStore.integrationRequestEvent(p.id, input.idempotencyKey, task.id);
             return { task, event_id: event?.id ?? null, attempt_id: event?.attemptId ?? null, delivery_id: event?.deliveryId ?? null };
         }));
+        app.post('/send', run(req => {
+            const p = principal(req);
+            this.authorize(p, 'message.send', req.body?.group_id);
+            const group = this.group(p.groupId), raw = req.body ?? {};
+            if (raw.kind && raw.kind !== 'message')
+                integrationError('INTEGRATION_OPERATION_DENIED', 'Integration send uses ordinary messages only', 403);
+            const targets = Array.isArray(raw.toSessionIds) ? raw.toSessionIds : [raw.targetSessionId];
+            if (!targets.length || targets.some((id) => typeof id !== 'string'))
+                integrationError('INVALID_MESSAGE_TARGET', 'Specify a local group member');
+            const recipients = targets.map((id) => scopedId(id, group.sessionIds, 'SESSION'));
+            let thread;
+            if (raw.thread_id)
+                thread = scopedId(raw.thread_id, options.messages.snapshotMessages().filter(m => m.groupId === p.groupId).map(m => m.threadId), 'THREAD');
+            const messages = options.messages.send({ ...this.messageExtras(raw), groupId: p.groupId, fromSessionId: null,
+                integrationOrigin: this.origin(p, raw.origin), toSessionIds: recipients, kind: 'message', content: raw.message, threadId: thread });
+            this.sync();
+            return { ok: true, message_ids: messages.map(m => m.id), receipts: messages.map(m => options.messages.receipt(m.id)), ...options.messages.receipt(messages[0].id) };
+        }));
+        app.post('/reply', run(req => {
+            const p = principal(req);
+            this.authorize(p, 'message.send', req.body?.group_id);
+            const raw = req.body ?? {}, original = this.message(p, raw.messageId);
+            const target = original.toPrincipalId === p.id ? original.fromSessionId
+                : original.integrationOrigin?.integrationId === p.id ? original.toSessionId : null;
+            if (!target || !this.group(p.groupId).sessionIds.includes(target))
+                integrationError('NO_REPLY_TARGET', 'Reply requires your own message and its original live group member', 409);
+            const messages = options.messages.send({ ...this.messageExtras(raw), groupId: p.groupId, fromSessionId: null,
+                integrationOrigin: this.origin(p, raw.origin), toSessionIds: [target], kind: 'reply', content: raw.content, threadId: original.threadId, replyTo: original.id });
+            this.sync();
+            return { ok: true, ...options.messages.receipt(messages[0].id) };
+        }));
+        app.get('/message', run(req => {
+            const p = principal(req);
+            this.authorize(p, 'message.read', req.query.group);
+            const messages = options.messages.snapshotMessages().filter(m => m.groupId === p.groupId).sort((a, b) => a.sequence - b.sequence);
+            const after = req.query['after-id'] ? this.message(p, String(req.query['after-id'])) : null;
+            const limit = req.query.limit === undefined ? 50 : Number(req.query.limit);
+            if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+                integrationError('INVALID_MESSAGE_LIMIT', 'limit must be 1..200');
+            const thread = req.query.thread ? scopedId(String(req.query.thread), messages.map(m => m.threadId), 'THREAD') : null;
+            const filtered = messages.filter(m => (!after || m.sequence > after.sequence) && (!thread || m.threadId === thread));
+            const page = [];
+            let bytes = 0;
+            for (const message of filtered.slice(0, limit)) {
+                const size = Buffer.byteLength(JSON.stringify(message));
+                if (page.length && bytes + size > 2 * 1024 * 1024)
+                    break;
+                page.push(message);
+                bytes += size;
+            }
+            return { messages: page.map(m => terminalMessage(m)), next_after_id: page.at(-1)?.id ?? after?.id ?? null, has_more: filtered.length > page.length, retention: 'retained_messages_only' };
+        }));
         app.get('/message/:id', run(req => {
-            const p = principal(req), message = options.messages.getMessage(req.params.id);
-            if (!message)
-                integrationError('MESSAGE_NOT_FOUND', 'Message does not exist', 404);
-            this.authorize(p, 'task.read', message.groupId);
+            const p = principal(req);
+            this.authorize(p, p.permissions.includes('message.read') ? 'message.read' : 'task.read');
+            const message = this.message(p, req.params.id);
             const receipt = options.messages.receipt(message.id);
             const { snapshot: _, ...diagnostic } = receipt;
             return { ok: true, ...diagnostic, ...(req.query.receipt_only === 'true' ? {} : { message: terminalMessage(message) }) };
@@ -148,7 +207,9 @@ export class IntegrationRuntime {
             integration_policy_update: true,
             session_restore_diagnostics: true,
             native_identity_linux_flock_owner: process.platform === 'linux',
-            permissions: ['task.read', 'task.create', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'] };
+            background_task_records: true, task_purpose_configuration: true, explicit_execution_state: true,
+            integration_message_send: true, integration_message_reply: true, integration_message_history: true,
+            permissions: INTEGRATION_OPERATIONS };
     }
     error(error) {
         return { type: 'error', ok: false, code: error instanceof CollaborationError ? error.code : 'INTEGRATION_INTERNAL_ERROR',
@@ -169,6 +230,18 @@ export class IntegrationRuntime {
             integrationError('TASK_NOT_FOUND', 'Task does not exist within this integration grant', 404);
         this.authorize(p, operation, task.groupId);
     }
+    message(p, id) {
+        const scoped = this.options.messages.snapshotMessages().filter(m => m.groupId === p.groupId);
+        const resolved = scopedId(id, scoped.map(m => m.id), 'MESSAGE');
+        return this.options.messages.getMessage(resolved);
+    }
+    messageExtras(raw) {
+        if (typeof raw.idempotency_key !== 'string' || !raw.idempotency_key.trim())
+            integrationError('IDEMPOTENCY_KEY_REQUIRED', 'Integration message mutations require an explicit idempotency key');
+        if (raw.task || raw.task_envelope || raw.metadata?.termdockTask)
+            integrationError('INTEGRATION_OPERATION_DENIED', 'Ordinary messages cannot forge task envelopes', 403);
+        return { idempotencyKey: raw.idempotency_key, responseKind: raw.response_kind, metadata: raw.metadata, expiresAt: raw.expires_at };
+    }
     origin(p, input) {
         const value = input && typeof input === 'object' ? input : {};
         if (Buffer.byteLength(JSON.stringify(value)) > 16384)
@@ -214,11 +287,16 @@ export class IntegrationRuntime {
                 if (groups.has(message.groupId)) {
                     const link = message.metadata?.termdockTask;
                     const context = { group_id: message.groupId, task_id: link?.taskId ?? null, attempt_id: link?.attemptId ?? null,
-                        reply_to_event_id: link?.replyToEventId ?? null, message_id: message.id, source: message.fromSessionId ? 'member' : 'system' };
+                        reply_to_event_id: link?.replyToEventId ?? null, message_id: message.id, source: message.integrationOrigin ? 'integration' : message.fromSessionId ? 'member' : 'system',
+                        actor: message.integrationOrigin ? { integration_id: message.integrationOrigin.integrationId } : message.fromSessionId ? { session_id: message.fromSessionId } : null,
+                        external_actor: message.integrationOrigin?.externalActor ?? null };
                     updates.push({ sourceKey: `message:${message.id}`, sourceVersion: '1', event: { ...context,
                             kind: message.kind === 'reply' ? 'message.reply' : 'message.queued', created_at: message.createdAt,
                             payload: { message_id: message.id, thread_id: message.threadId, reply_to: message.replyTo ?? null,
-                                from_session_id: message.fromSessionId, to_session_id: message.toSessionId, content: message.content, metadata: message.metadata ?? null } } });
+                                from_session_id: message.fromSessionId, to_session_id: message.toPrincipalId ? null : message.toSessionId,
+                                to_principal_id: message.toPrincipalId ?? null, integration_origin: message.integrationOrigin ?? null,
+                                response_kind: message.responseKind ?? null, stored_at: message.storedAt ?? null,
+                                content: message.content, metadata: message.metadata ?? null } } });
                     const { snapshot: _, ...receipt } = this.options.messages.receipt(message.id);
                     updates.push({ sourceKey: `message-status:${message.id}`, sourceVersion: JSON.stringify(receipt), event: {
                             ...context, kind: 'message.delivery', created_at: message.deliveredAt ?? message.createdAt, payload: { receipt }

package/dist/server/agent/integrationStore.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { CollaborationError } from './collaborationProtocol.js';
 export const INTEGRATION_PROTOCOL = 1;
-export const INTEGRATION_OPERATIONS = ['task.read', 'task.create', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'];
+export const INTEGRATION_OPERATIONS = ['message.send', 'message.read', 'task.read', 'task.create', 'task.configure', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'];
 export function integrationError(code, message, status = 400) { throw new CollaborationError(code, message, status); }
 export function atomicJson(file, value) {
     fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });

package/dist/server/cli.js

@@ -3489,7 +3489,7 @@ async function main() {
     }
     if (options.integration) {
         const argv = options.integration;
-        if (!argv.length || ['help', '--help'].includes(argv[0])) {
+        if (!argv.length || argv.includes('--help') || argv[0] === 'help') {
             console.log(INTEGRATION_HELP);
             return;
         }