termdock 1.4.305 → 1.4.307

package/dist/server/agent/collaborationTaskService.js

@@ -1,6 +1,7 @@
 import { CollaborationError } from './collaborationProtocol.js';
 import { captureTaskCommit } from './collaborationTaskWorkspace.js';
 import { taskBundleChunk } from './collaborationTaskBundles.js';
+import { taskExecution, taskPurpose, taskPurposeFilter } from './collaborationTaskPurpose.js';
 import { taskMemberKey } from './collaborationTaskTypes.js';
 /** One authority per task; replicas are records, never competing decision writers. */
 export class CollaborationTaskService {
@@ -56,12 +57,13 @@ export class CollaborationTaskService {
             const template = task.workflow?.reviewers.some(m => taskMemberKey(m) === taskMemberKey(member));
             return { member, sessionId, launchProfile: group.memberLaunchProfiles?.[sessionId], role: `${template ? '此目标的执行成员模板；' : ''}${group.roles?.[sessionId] ?? ''}` };
         });
-        return { ...task, children, roster, launchProfiles: summary ? undefined : group?.launchProfiles, defaultLaunchProfileId: summary ? undefined : group?.defaultLaunchProfileId, memberSessions, replica: task.ownerServiceId !== this.self, summaryOnly: summary, outbox: (summary ? [] : this.tasks.pending(task.id))
+        return { ...task, purpose: taskPurpose(task.purpose), ...(task.purpose === 'automation' ? { execution: task.execution ?? taskExecution(task) } : {}), children, roster, launchProfiles: summary ? undefined : group?.launchProfiles, defaultLaunchProfileId: summary ? undefined : group?.defaultLaunchProfileId, memberSessions, replica: task.ownerServiceId !== this.self, summaryOnly: summary, outbox: (summary ? [] : this.tasks.pending(task.id))
                 .map(({ id, attemptId, messageId, lastError }) => ({ id, attemptId, messageId, lastError })) };
     }
-    list(groupId, actor) {
+    list(groupId, actor, purpose = 'all') {
         this.group(groupId, actor);
-        return this.tasks.list([groupId], true).map(task => this.view(task, true));
+        const filter = taskPurposeFilter(purpose);
+        return this.tasks.list([groupId], true).filter(task => filter === 'all' || taskPurpose(task.purpose) === filter).map(task => this.view(task, true));
     }
     async get(taskId, actor) {
         const task = this.tasks.get(taskId);
@@ -71,8 +73,10 @@ export class CollaborationTaskService {
         return this.view(task);
     }
     async create(input, actor, origin) {
-        this.group(input.groupId, actor);
+        const group = this.group(input.groupId, actor);
         this.validateMembers(input.groupId, input);
+        if (input.purpose === 'automation' && group.federated)
+            throw new CollaborationError('BACKGROUND_TASK_LOCAL_ONLY', '首版后台自动化记录使用本机协作组', 409);
         const dependencies = [...(input.dependsOn ?? []), ...(input.parentTaskId ? [input.parentTaskId] : [])];
         const authority = dependencies.length ? this.tasks.get(dependencies[0])?.ownerServiceId : this.self;
         if (!authority)
@@ -97,8 +101,10 @@ export class CollaborationTaskService {
         const task = this.tasks.get(taskId);
         if (!task)
             throw new CollaborationError('TASK_NOT_FOUND', '任务不存在', 404);
-        this.group(task.groupId, actor);
+        const group = this.group(task.groupId, actor);
         this.validateMembers(task.groupId, input);
+        if (input.kind === 'configure' && input.purpose === 'automation' && group.federated)
+            throw new CollaborationError('BACKGROUND_TASK_LOCAL_ONLY', '首版后台自动化记录使用本机协作组', 409);
         if (origin && task.ownerServiceId !== this.self)
             throw new CollaborationError('INTEGRATION_LOCAL_ONLY', '首版集成任务须由本机服务保存', 409);
         if (task.ownerServiceId !== this.self) {
@@ -131,7 +137,8 @@ export class CollaborationTaskService {
                         commit: child.artifacts.find(a => a.id === child.acceptedArtifactId)?.evidence?.commit })) } };
         }
         const updated = this.tasks.apply(taskId, input, actor, origin);
-        void this.flush();
+        if (input.kind !== 'configure')
+            void this.flush();
         return this.view(updated);
     }
     heads(groupIds) { return this.tasks.heads(groupIds, this.self); }

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/integrationServer.js

@@ -6,7 +6,7 @@ import { homedir } from 'node:os';
 import { timingSafeEqual } from 'node:crypto';
 import { CollaborationError } 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`); }
@@ -73,7 +73,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 +81,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,13 +90,13 @@ 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();
@@ -147,7 +147,9 @@ export class IntegrationRuntime {
             startup_input_conditions: true,
             integration_policy_update: true,
             session_restore_diagnostics: true,
-            permissions: ['task.read', 'task.create', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'] };
+            native_identity_linux_flock_owner: process.platform === 'linux',
+            background_task_records: true, task_purpose_configuration: true, explicit_execution_state: true,
+            permissions: INTEGRATION_OPERATIONS };
     }
     error(error) {
         return { type: 'error', ok: false, code: error instanceof CollaborationError ? error.code : 'INTEGRATION_INTERNAL_ERROR',

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 = ['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/agent/nativeProcessIdentity.js

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export function nativeIdentityDirectory(config) {
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        return null;
+    const c = config;
+    if (c.kind !== 'linux-flock-owner' || Object.keys(c).some(k => !['kind', 'directory'].includes(k))
+        || typeof c.directory !== 'string' || c.directory.length > 1024 || /[\x00-\x1f\x7f]/.test(c.directory))
+        return null;
+    const expanded = c.directory.startsWith('~/') ? path.join(os.homedir(), c.directory.slice(2)) : c.directory;
+    if (!path.isAbsolute(expanded))
+        return null;
+    const directory = path.resolve(expanded), relative = path.relative(os.homedir(), directory);
+    return relative && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative) ? directory : null;
+}
+const unavailable = { nativeId: null, outcome: 'unavailable' };
+function processStat(text, pid) {
+    const close = text.lastIndexOf(')'), open = text.indexOf('(');
+    if (open < 0 || close <= open || Number(text.slice(0, open).trim()) !== pid)
+        return null;
+    const fields = text.slice(close + 1).trim().split(/\s+/);
+    const pgid = Number(fields[2]), tpgid = Number(fields[5]), start = fields[19];
+    return fields[0] !== 'Z' && pgid > 0 && pgid === tpgid && /^\d+$/.test(start ?? '') ? { pgid, tpgid, start, comm: text.slice(open + 1, close) } : null;
+}
+function safeFile(stat, uid) {
+    return stat.isFile() && stat.uid === BigInt(uid) && (stat.mode & 18n) === 0n;
+}
+function sameFile(a, b) { return a.dev === b.dev && a.ino === b.ino; }
+function kernelWriter(locks, pid, stat) {
+    // Linux dev_t encoding, matched against /proc/locks major:minor:inode.
+    const major = (stat.dev >> 8n & 0xfffn) | (stat.dev >> 32n & 0xfffff000n);
+    const minor = (stat.dev & 0xffn) | (stat.dev >> 12n & 0xffffff00n);
+    return locks.split('\n').some(line => {
+        const m = line.match(/^\d+:\s+FLOCK\s+ADVISORY\s+WRITE\s+(\d+)\s+([0-9a-f]+):([0-9a-f]+):(\d+)\s+0\s+EOF\s*$/i);
+        return !!m && Number(m[1]) === pid && BigInt(`0x${m[2]}`) === major && BigInt(`0x${m[3]}`) === minor && BigInt(m[4]) === stat.ino;
+    });
+}
+async function readOwner(file, uid) {
+    const handle = await fs.promises.open(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    try {
+        const stat = await handle.stat({ bigint: true });
+        if (!safeFile(stat, uid) || stat.size > 4096n)
+            return null;
+        const buffer = Buffer.alloc(4097), { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead > 4096)
+            return null;
+        const value = JSON.parse(buffer.subarray(0, bytesRead).toString('utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Confirm exactly one UUID using a current foreground PID, owner starttime,
+ * its real open FD/inode, and the kernel's exclusive whole-file flock. */
+export async function readNativeProcessIdentity(pid, config, expectedComm, expectedArgs) {
+    if (process.platform !== 'linux' || !Number.isSafeInteger(pid) || pid <= 1 || !process.getuid)
+        return unavailable;
+    const directory = nativeIdentityDirectory(config), uid = process.getuid();
+    if (!directory)
+        return unavailable;
+    let hadNativeDescriptor = false;
+    try {
+        const root = await fs.promises.lstat(directory, { bigint: true });
+        if (!root.isDirectory() || root.uid !== BigInt(uid) || (root.mode & 18n) !== 0n)
+            return unavailable;
+        const canonical = await fs.promises.realpath(directory), canonicalHome = await fs.promises.realpath(os.homedir());
+        if (!canonical.startsWith(`${canonicalHome}${path.sep}`))
+            return unavailable;
+        const proc = `/proc/${pid}`, initial = processStat(await fs.promises.readFile(`${proc}/stat`, 'utf8'), pid);
+        if (!initial || expectedComm && initial.comm !== expectedComm || (await fs.promises.stat(proc)).uid !== uid)
+            return { nativeId: null, outcome: 'process_changed' };
+        const argsMatch = async () => {
+            if (expectedArgs === undefined)
+                return true;
+            const handle = await fs.promises.open(`${proc}/cmdline`, fs.constants.O_RDONLY);
+            try {
+                const buffer = Buffer.alloc(16385), { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+                return bytesRead < buffer.length && buffer.subarray(0, bytesRead).toString('utf8').replace(/\0$/, '').split('\0').join(' ').trim() === expectedArgs.trim();
+            }
+            finally {
+                await handle.close();
+            }
+        };
+        if (!await argsMatch())
+            return { nativeId: null, outcome: 'process_changed' };
+        const lockDescriptors = async () => {
+            const descriptors = await fs.promises.readdir(`${proc}/fd`);
+            if (descriptors.length > 4096)
+                throw new Error('descriptor bound');
+            const files = [];
+            for (const descriptor of descriptors) {
+                if (!/^\d+$/.test(descriptor))
+                    continue;
+                const fd = `${proc}/fd/${descriptor}`;
+                let target;
+                try {
+                    target = await fs.promises.readlink(fd);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        continue;
+                    throw error;
+                }
+                if (path.dirname(target) === canonical && /\.lock(?: \(deleted\))?$/.test(target))
+                    files.push({ fd, target });
+            }
+            return files.sort((a, b) => a.fd.localeCompare(b.fd));
+        };
+        const descriptors = await lockDescriptors();
+        hadNativeDescriptor = descriptors.length > 0;
+        const locks = await fs.promises.readFile('/proc/locks', 'utf8');
+        const verified = new Map();
+        let unproved = false;
+        for (const { fd, target } of descriptors) {
+            if (!target.endsWith('.lock')) {
+                unproved = true;
+                continue;
+            }
+            const nativeId = path.basename(target).slice(0, -5);
+            if (!/^[A-Za-z0-9._-]{1,256}$/.test(nativeId) || nativeId === '.' || nativeId === '..') {
+                unproved = true;
+                continue;
+            }
+            try {
+                const lock = await fs.promises.lstat(target, { bigint: true }), held = await fs.promises.stat(fd, { bigint: true });
+                const ownerFile = path.join(canonical, `${nativeId}.owner.json`), owner = await readOwner(ownerFile, uid);
+                if (!safeFile(lock, uid) || !sameFile(lock, held) || !kernelWriter(locks, pid, lock)
+                    || owner?.pid !== pid || owner.process_start_id !== `linux:${initial.start}`) {
+                    unproved = true;
+                    continue;
+                }
+                verified.set(nativeId, { fd, stat: lock, owner: ownerFile });
+            }
+            catch {
+                unproved = true;
+            }
+        }
+        if (verified.size > 1)
+            return { nativeId: null, outcome: 'ambiguous' };
+        if (unproved)
+            return { nativeId: null, outcome: 'unconfirmed' };
+        if (verified.size !== 1)
+            return unavailable;
+        const final = processStat(await fs.promises.readFile(`${proc}/stat`, 'utf8'), pid);
+        const currentLocks = await fs.promises.readFile('/proc/locks', 'utf8');
+        const [nativeId, evidence] = [...verified][0];
+        const current = await fs.promises.lstat(path.join(canonical, `${nativeId}.lock`), { bigint: true });
+        const held = await fs.promises.stat(evidence.fd, { bigint: true }), owner = await readOwner(evidence.owner, uid);
+        if (!final || final.start !== initial.start || final.comm !== initial.comm || final.pgid !== initial.pgid || final.tpgid !== initial.tpgid
+            || !await argsMatch()
+            || JSON.stringify(await lockDescriptors()) !== JSON.stringify(descriptors)
+            || !safeFile(current, uid) || !sameFile(current, evidence.stat) || !sameFile(current, held)
+            || !kernelWriter(currentLocks, pid, current) || owner?.pid !== pid || owner.process_start_id !== `linux:${final.start}`)
+            return { nativeId: null, outcome: 'process_changed' };
+        return { nativeId, outcome: 'verified' };
+    }
+    catch {
+        return hadNativeDescriptor ? { nativeId: null, outcome: 'unconfirmed' } : unavailable;
+    }
+}

package/dist/server/agent/nativeResumeOwner.js

@@ -46,6 +46,8 @@ function diagnostic(candidate, process, reason) {
     return { session_id: text(candidate.sessionId), backend_session_id: candidate.backendSessionId.startsWith('inventory:') ? null : text(candidate.backendSessionId),
         backend_attached: candidate.backendAttached ?? null, tmux_session_name: text(candidate.tmuxSessionName),
         tmux_session_id: text(process?.tmuxSessionId), pane_id: text(process?.paneId), pane_pid: pid(process?.panePid),
+        process_pid: pid(process?.processPid), native_identity_source: process?.nativeIdentitySource === 'argv'
+            || process?.nativeIdentitySource === 'linux-flock-owner' ? process.nativeIdentitySource : null,
         program: text(process?.program), process_source: text(process?.processSource), arguments_observed: process?.argumentsObserved === true,
         agent_slug: text(process?.agentSlug), last_known_native_id: text(candidate.cachedNativeId), observed_native_id: text(process?.nativeId),
         pgid: Number.isInteger(process?.pgid) ? process.pgid : null,
@@ -72,7 +74,7 @@ export async function assertNativeResumeAvailable(target, excludedBackendSession
                 throw new NativeResumeOwnerError('NATIVE_SESSION_ALREADY_RUNNING', blockers);
             }
             if (!process.confirmed)
-                blockers.push(diagnostic(candidate, process, process.shellFailure
+                blockers.push(diagnostic(candidate, process, process.nativeIdentityFailure ?? process.shellFailure
                     ?? (process.argumentsObserved === false ? 'PROCESS_ARGUMENTS_UNAVAILABLE' : 'FOREGROUND_PROCESS_UNCONFIRMED')));
             else if (process.agentSlug === target.slug && !process.nativeId)
                 blockers.push(diagnostic(candidate, process, 'NATIVE_SESSION_ID_MISSING'));

package/dist/server/agent/plugins.js

@@ -13,6 +13,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { nativeIdentityDirectory } from './nativeProcessIdentity.js';
 export const PLUGINS_DIR = path.join(os.homedir(), '.termdock', 'agent-plugins');
 export const MANIFEST_FILE = 'manifest.json';
 export const ICON_FILE = 'icon.svg';
@@ -323,6 +324,13 @@ export function validateManifest(raw, dir) {
             };
         }
     }
+    let nativeIdentity;
+    if (m.nativeIdentity !== undefined) {
+        if (!nativeIdentityDirectory(m.nativeIdentity))
+            errors.push('nativeIdentity must declare linux-flock-owner with a directory under home');
+        else
+            nativeIdentity = { kind: 'linux-flock-owner', directory: m.nativeIdentity.directory };
+    }
     // Optional automatic-title provider. Commands are argv arrays rather than
     // shell snippets so a UI-installed manifest cannot gain accidental shell
     // interpolation beyond the executable it explicitly declares.
@@ -411,6 +419,7 @@ export function validateManifest(raw, dir) {
             statuses,
             hooks,
             resume: resumeConfig,
+            nativeIdentity,
             titleNamer,
         },
     };

package/dist/server/agent/registry.js

@@ -315,6 +315,7 @@ export function buildResumeCommand(agent, sessionId, launchArgv) {
 // ---------------------------------------------------------------------------
 /** Plugin-defined resume configs, keyed by slug. */
 const pluginResumeConfigs = new Map();
+const pluginNativeIdentityConfigs = new Map();
 /**
  * Register plugin agents into the lookup maps. Plugins whose slug or aliases
  * collide with built-in agents are skipped. Call `clearPluginAgents()` first
@@ -362,6 +363,8 @@ export function registerPluginAgents(plugins) {
                 staleFlags: manifest.resume.staleFlags ?? [],
             });
         }
+        if (manifest.nativeIdentity)
+            pluginNativeIdentityConfigs.set(manifest.slug, { ...manifest.nativeIdentity });
         registered++;
     }
     return { registered, skipped };
@@ -376,6 +379,11 @@ export function clearPluginAgents() {
             BY_ALIAS.delete(alias);
     }
     pluginResumeConfigs.clear();
+    pluginNativeIdentityConfigs.clear();
+}
+export function getPluginNativeIdentityConfig(slug) {
+    const config = pluginNativeIdentityConfigs.get(slug);
+    return config ? { ...config } : undefined;
 }
 export function getPluginResumeConfig(slug) {
     return pluginResumeConfigs.get(slug);

package/dist/server/routes/terminal.js

@@ -1,6 +1,7 @@
 import { collaborationSessionDisplayName } from '../utils/sessionDisplayName.js';
 import { integrationError } from '../agent/integrationStore.js';
 import { assertNativeResumeAvailable, collectNativeResumeOwnerCandidates } from '../agent/nativeResumeOwner.js';
+import { readNativeProcessIdentity } from '../agent/nativeProcessIdentity.js';
 import { integrationLaunchCommand } from '../agent/integrationSessions.js';
 import { ensureTeam } from '../agent/collaborationTeam.js';
 import { androidRecordings } from '../android/recording.js';
@@ -38,7 +39,7 @@ import { inspectLinuxInotifyUsage, isWatchResourceExhaustion } from '../utils/fi
 import { writeResponseChunk } from '../utils/httpResponse.js';
 import { getFocusSequence, removeClientFocusState, scanFocusTrackingMode, setClientFocusState, } from '../utils/tmuxFocus.js';
 import { extractProgramLabelFromArgs, normalizeProgramName, normalizeTmuxMetadataProgram, selectTmuxForegroundProgram, } from '../utils/tmuxProgramDetection.js';
-import { agentBySlug, buildResumeCommand, detectAgentFromCommand, inferResumeSessionId, listAgents, } from '../agent/registry.js';
+import { agentBySlug, buildResumeCommand, detectAgentFromCommand, inferResumeSessionId, getPluginNativeIdentityConfig, listAgents, } from '../agent/registry.js';
 import { applyAgentEvent, agentEventMatchesCurrentAgent, defaultAgentSessionState, parseAgentEvent, } from '../agent/session.js';
 import { canRestoreDeadAgentShell, isConfirmedAgentResumeProcess, normalizePersistedAgentResumeInfo, } from '../agent/resumePersistence.js';
 import { AgentResumeHistoryStore } from '../agent/resumeHistory.js';
@@ -1577,7 +1578,7 @@ function formatLocalCollaborationMessages(frontendSessionId, messages) {
  *  agent-keyed selector can never reach it. Delivery still needs an agent (the
  *  confirm gate and prompt formatting assume a TUI); driving a terminal —
  *  run/capture — is a shell operation and works on any pane. */
-async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane = false) {
+async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane = false, nativeProcessIdentity = false) {
     if (!binding.tmuxSessionName)
         return { state: 'offline', reason: 'TMUX_BINDING_MISSING' };
     const name = `=${binding.tmuxSessionName}`;
@@ -1596,12 +1597,19 @@ async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane =
     const serverPid = Number((await runTmux(['display-message', '-p', '#{pid}'])).trim());
     if (!Number.isInteger(serverPid) || serverPid <= 0)
         throw new Error('TMUX_SERVER_IDENTITY_UNAVAILABLE');
+    if (nativeProcessIdentity && process.platform === 'linux')
+        await getProcessSnapshot(true);
     const panes = await Promise.all(layout.windows.flatMap((window) => window.panes).map(async (pane) => {
         // Native identity needs the foreground argv even for a named binary;
         // pane_current_command alone cannot prove an exact resumed conversation.
         const program = await resolveTmuxPaneProgram(pane, true);
         const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
-        const nativeSessionId = agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null;
+        const identity = nativeProcessIdentity ? await observeProgramNativeIdentity(agent, program)
+            : { nativeId: agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null, failure: null };
+        if (identity.failure)
+            integrationError(identity.failure === 'NATIVE_SESSION_IDENTITY_CONFLICT'
+                ? 'NATIVE_SESSION_ID_MISMATCH' : 'NATIVE_SESSION_OWNER_UNCONFIRMED', 'Current process native identity evidence conflicts or cannot be uniquely verified', 409);
+        const nativeSessionId = identity.nativeId;
         return { serverPid, sessionId: layout.sessionId, paneId: pane.id, panePid: pane.pid,
             agentSlug: agent?.slug ?? '', nativeSessionId, cwd: pane.currentPath,
             isShell: shellNamesBackend.has(normalizeProgramName(program?.command ?? '')?.toLowerCase() ?? '') };
@@ -1872,7 +1880,7 @@ export const integrationSessionAdapter = {
         const binding = { sessionId: record.session_id, backendSessionId: terminal.backendSessionId,
             mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: record.agent_slug,
             nativeSessionId: record.agent_native_session_id, pane: record.terminal_binding ?? null };
-        const inspected = await inspectCollaborationTmux(binding);
+        const inspected = await inspectCollaborationTmux(binding, undefined, false, true);
         if (inspected.state === 'offline')
             return { exists: false, running: false, shell: false, agentSlug: null, nativeId: null };
         if (inspected.state !== 'ready' || !inspected.pane)
@@ -1938,11 +1946,13 @@ async function assertIntegrationNativeResumeAvailable(record) {
             return Promise.all(layout.windows.flatMap(window => window.panes).map(async (pane) => {
                 const program = await resolveTmuxPaneProgram(pane, true, true);
                 const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
+                const identity = await observeProgramNativeIdentity(agent, program);
                 const shell = await inspectIntegrationShell({ panePid: pane.pid,
                     isShell: !agent && shellNamesBackend.has(normalizeProgramName(program?.command ?? '')?.toLowerCase() ?? '') });
-                return { confirmed: shell.confirmed || program?.source === 'tmux-tty' && Boolean(program.rawArgs),
+                return { confirmed: !identity.failure && (shell.confirmed || program?.source === 'tmux-tty' && Boolean(program.rawArgs)),
                     agentSlug: agent?.slug ?? null,
-                    nativeId: agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null,
+                    nativeId: identity.nativeId, nativeIdentityFailure: identity.failure, nativeIdentitySource: identity.source,
+                    processPid: program?.processPid,
                     paneId: pane.id, panePid: pane.pid, tmuxSessionId: layout.sessionId, program: program?.command ?? null,
                     processSource: program?.source, argumentsObserved: !!program?.rawArgs,
                     shellFailure: shell.failure, pgid: shell.pgid, tpgid: shell.tpgid };
@@ -3948,13 +3958,15 @@ async function resolveTmuxPaneProgram(pane, requireArgs = false, refreshTty = fa
         }
         const selected = selectTmuxForegroundProgram({
             panePid: pane.pid,
+            includePaneProcess: requireArgs,
             rows,
             shellNames: shellNamesBackend,
             genericProgramNames,
             extractProgramLabel,
         });
         if (selected) {
-            return { command: selected.command, source: 'tmux-tty', rawArgs: selected.rawArgs };
+            return { command: selected.command, source: 'tmux-tty', rawArgs: selected.rawArgs,
+                ...(selected.processPid ? { processPid: selected.processPid, processComm: selected.processComm } : {}) };
         }
     }
     catch {
@@ -3962,6 +3974,23 @@ async function resolveTmuxPaneProgram(pane, requireArgs = false, refreshTty = fa
     }
     return { command, source: 'tmux-pane', rawArgs: null };
 }
+async function observeProgramNativeIdentity(agent, program) {
+    const fromArgs = agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null;
+    const config = agent ? getPluginNativeIdentityConfig(agent.slug) : undefined;
+    if (config && program?.processPid) {
+        const proof = await readNativeProcessIdentity(program.processPid, config, program.processComm, program.rawArgs ?? undefined);
+        if (proof.outcome === 'ambiguous' || proof.outcome === 'process_changed' || proof.outcome === 'unconfirmed')
+            return { nativeId: null, source: null,
+                failure: proof.outcome === 'ambiguous' ? 'NATIVE_SESSION_IDENTITY_AMBIGUOUS'
+                    : proof.outcome === 'unconfirmed' ? 'NATIVE_SESSION_OWNERSHIP_UNCONFIRMED' : 'NATIVE_SESSION_PROCESS_CHANGED' };
+        if (proof.nativeId) {
+            if (fromArgs && fromArgs !== proof.nativeId)
+                return { nativeId: null, source: null, failure: 'NATIVE_SESSION_IDENTITY_CONFLICT' };
+            return { nativeId: proof.nativeId, source: 'linux-flock-owner', failure: null };
+        }
+    }
+    return { nativeId: fromArgs, source: fromArgs ? 'argv' : null, failure: null };
+}
 /**
  * Extract a human-readable program label from a full command line.
  *