xuym-codex-collab 0.4.2 → 0.4.4

package/packages/peer/inbox.mjs

@@ -1,5 +1,6 @@
 import { digest, verifyEvent } from './config.mjs';
 import { Denied } from './protocol.mjs';
+import { validReviewContext, assertReviewIntent } from './natural-review.mjs';
 
 export const inboxIdPattern = /^N-[A-F0-9]{32}$/;
 export const inboxTaskId = (id) => `T-${id.slice(2)}`;
@@ -7,7 +8,8 @@ export const inboxMessageKey = (agentId, chatId, messageId) => `inbox-message:${
 const text = (value, max) => typeof value === 'string' && !!value.trim() && value.length <= max;
 const fields = (value, allowed) => value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).every((key) => allowed.includes(key));
 export function validateInboxSpec(spec, team) {
-  if (!fields(spec, ['schema_version', 'id', 'repo', 'target_agent', 'chat_id', 'sender_id', 'content', 'message_key', 'admin_dispatch']) || spec.schema_version !== 1 || !inboxIdPattern.test(spec.id || '') || spec.repo !== team.repo || !text(spec.target_agent, 64) || !/^[a-zA-Z0-9_-]+$/.test(spec.target_agent) || !Object.hasOwn(team.agents, spec.target_agent) || !text(spec.chat_id, 200) || !text(spec.sender_id, 200) || !text(spec.content, 4000) || !text(spec.message_key, 300) || typeof spec.admin_dispatch !== 'boolean' || spec.id !== `N-${digest([spec.target_agent, spec.message_key]).slice(0, 32).toUpperCase()}`) throw new Error('invalid natural-language inbox specification');
+  if (!fields(spec, ['schema_version', 'id', 'repo', 'target_agent', 'chat_id', 'sender_id', 'content', 'message_key', 'admin_dispatch', 'review_context']) || spec.schema_version !== 1 || !inboxIdPattern.test(spec.id || '') || spec.repo !== team.repo || !text(spec.target_agent, 64) || !/^[a-zA-Z0-9_-]+$/.test(spec.target_agent) || !Object.hasOwn(team.agents, spec.target_agent) || !text(spec.chat_id, 200) || !text(spec.sender_id, 200) || !text(spec.content, 4000) || !text(spec.message_key, 300) || typeof spec.admin_dispatch !== 'boolean' || spec.id !== `N-${digest([spec.target_agent, spec.message_key]).slice(0, 32).toUpperCase()}`) throw new Error('invalid natural-language inbox specification');
+  if (spec.review_context !== undefined && (!validReviewContext(spec.review_context) || team.agents[spec.target_agent].wecom_userid !== spec.sender_id)) throw new Denied('invalid human review context');
   const owner = team.agents[spec.target_agent].wecom_userid === spec.sender_id;
   const senders = Object.values(team.agents).filter((agent) => agent.wecom_userid === spec.sender_id);
   const member = senders.some((agent) => agent.role === 'member');
@@ -22,11 +24,11 @@ export function reduceInbox(spec, events, team) {
   const keys = new Set(); const ids = new Set(); let previousTime = -Infinity;
   for (const event of events) {
     verifyEvent(team, event);
-    if (!fields(event, ['schema_version', 'request_id', 'seq', 'event_id', 'actor_id', 'occurred_at', 'idempotency_key', 'team_hash', 'signature', 'type', 'spec_hash', 'content', 'message_key', 'response', 'task_id', 'task_hash'])) throw new Error('unsupported inbox event fields');
+    if (!fields(event, ['schema_version', 'request_id', 'seq', 'event_id', 'actor_id', 'occurred_at', 'idempotency_key', 'team_hash', 'signature', 'type', 'spec_hash', 'content', 'message_key', 'response', 'task_id', 'task_hash', 'review_seq', 'decision', 'summary', 'task_event_hash'])) throw new Error('unsupported inbox event fields');
     const time = Date.parse(event.occurred_at);
     if (event.schema_version !== 1 || event.request_id !== spec.id || event.actor_id !== spec.target_agent || event.seq !== state.seq + 1 || !Number.isFinite(time) || !event.occurred_at.endsWith('Z') || time < previousTime || !/^[a-f0-9-]{36}$/.test(event.event_id || '') || !text(event.idempotency_key, 300) || keys.has(event.idempotency_key) || ids.has(event.event_id)) throw new Error('invalid inbox sequence, actor or duplicate event');
-    const allowed = { received: ['spec_hash'], clarified: ['response'], replied: ['content', 'message_key'], task_created: ['task_id', 'task_hash', 'response'], answered: ['response'] }[event.type];
-    if (!allowed || ['spec_hash', 'content', 'message_key', 'response', 'task_id', 'task_hash'].some((key) => event[key] !== undefined && !allowed.includes(key))) throw new Error('invalid inbox event payload');
+    const allowed = { received: ['spec_hash'], clarified: ['response'], replied: ['content', 'message_key'], task_created: ['task_id', 'task_hash', 'response'], answered: ['response'], reviewed: ['task_id', 'review_seq', 'decision', 'summary', 'task_event_hash', 'response'] }[event.type];
+    if (!allowed || ['spec_hash', 'content', 'message_key', 'response', 'task_id', 'task_hash', 'review_seq', 'decision', 'summary', 'task_event_hash'].some((key) => event[key] !== undefined && !allowed.includes(key))) throw new Error('invalid inbox event payload');
     switch (event.type) {
       case 'received':
         if (state.seq || event.spec_hash !== digest(spec) || event.idempotency_key !== spec.message_key) throw new Error('invalid inbox reception');
@@ -38,6 +40,11 @@ export function reduceInbox(spec, events, team) {
       case 'replied':
         if (state.status !== 'clarification' || !text(event.content, 4000) || !text(event.message_key, 300) || event.idempotency_key !== event.message_key) throw new Error('invalid clarification reply');
         state.status = 'pending'; break;
+      case 'reviewed': {
+        if (state.status !== 'pending' || !Number.isSafeInteger(event.review_seq) || event.review_seq < 2 || !text(event.response, 2000) || !/^[a-f0-9]{64}$/.test(event.task_event_hash || '')) throw new Error('invalid inbox human review');
+        assertReviewIntent({ spec, events: events.slice(0, event.seq - 1) }, { task_id: event.task_id, expected_seq: event.review_seq - 1, decision: event.decision, ...(event.summary !== undefined ? { summary: event.summary } : {}) }, spec.target_agent, team);
+        state.status = 'reviewed'; state.review_task_id = event.task_id; break;
+      }
       case 'task_created':
         if (state.status !== 'pending' || event.task_id !== inboxTaskId(spec.id) || !/^[a-f0-9]{64}$/.test(event.task_hash || '') || !text(event.response, 2000)) throw new Error('invalid inbox task resolution');
         state.status = 'task_created'; state.task_id = event.task_id; break;

package/packages/peer/natural-review.mjs

@@ -0,0 +1,105 @@
+import { Conflict, Denied } from './protocol.mjs';
+
+export const reviewTaskPattern = /^T-[A-Z0-9-]{1,62}$/;
+const fields = (value, allowed) => value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).every((key) => allowed.includes(key));
+
+// Freeze the human's review scope when their authenticated group message arrives.
+// Model interpretation must never silently substitute a newer task revision.
+export function reviewContext(tasks, agentId, senderId, chatId, team) {
+  if (team.agents[agentId]?.wecom_userid !== senderId) return [];
+  return tasks.filter((task) => task.spec.source?.channel === 'wecom' && task.spec.source.chat_id === chatId
+    && ['stage_review', 'review'].includes(task.state.status) && task.state.assignee === agentId
+    && (task.team || team).agents[agentId]?.wecom_userid === senderId)
+    .map((task) => ({ task_id: task.spec.id, expected_seq: task.state.seq, title: task.spec.title,
+      commit: task.state.checkpoint.commit, stage: task.state.stage }))
+    .sort((a, b) => a.task_id.localeCompare(b.task_id));
+}
+
+export function validReviewContext(value) {
+  return Array.isArray(value) && value.length <= 100 && new Set(value.map((item) => item?.task_id)).size === value.length
+    && value.every((item) => fields(item, ['task_id', 'expected_seq', 'title', 'commit', 'stage'])
+      && reviewTaskPattern.test(item.task_id || '') && Number.isSafeInteger(item.expected_seq) && item.expected_seq > 0
+      && typeof item.title === 'string' && !!item.title.trim() && item.title.length <= 200
+      && /^[a-f0-9]{40}$/.test(item.commit || '') && Number.isSafeInteger(item.stage) && item.stage >= 0);
+}
+
+export function assertReviewIntent(request, review, agentId, team) {
+  if (!fields(review, ['task_id', 'expected_seq', 'decision', 'summary']) || !reviewTaskPattern.test(review.task_id || '')
+    || !Number.isSafeInteger(review.expected_seq) || review.expected_seq < 1
+    || !['approved', 'changes_requested'].includes(review.decision)
+    || review.summary !== undefined && (typeof review.summary !== 'string' || !review.summary.trim() || review.summary.length > 2000)
+    || review.decision === 'changes_requested' && !review.summary) throw new Conflict('invalid human review interpretation; rejection requires feedback');
+  if (request.spec.sender_id !== team.agents[agentId]?.wecom_userid) throw new Denied('only the authenticated bot owner may review');
+  const candidates = request.spec.review_context || [];
+  const target = candidates.find((item) => item.task_id === review.task_id && item.expected_seq === review.expected_seq);
+  if (!target) throw new Conflict('review target/version was not pending when this human message arrived; ask for a new review message');
+  const humanMessages = [request.spec.content, ...request.events.filter((event) => event.type === 'replied').map((event) => event.content)];
+  // Keep a person's task selection across clarification turns. Never use the
+  // model's question/answer text as evidence of which task the person selected.
+  let selected = false; let revisionSelected = false;
+  for (let i = humanMessages.length - 1; i >= 0; i--) {
+    const selection = reviewSelection(humanMessages[i], candidates, i > 0);
+    if (!selected && selection.ids.length) {
+      if (selection.ids.length !== 1 || selection.ids[0] !== target.task_id) throw new Conflict('explicit task selection does not match the selected review; clarify conflicting choices');
+      selected = true;
+    }
+    if (!revisionSelected && selection.revisions.length) {
+      if (selection.revisions.length !== 1 || selection.revisions[0] !== target.expected_seq) throw new Conflict('explicit task or revision does not match the selected review');
+      revisionSelected = true;
+    }
+  }
+  if (candidates.length > 1 && !selected) throw new Conflict('multiple pending reviews; clarify the task first using its title, list number or ID');
+  const decisionText = (value) => {
+    for (const item of candidates.toSorted((a, b) => b.title.length - a.title.length)) value = value.replaceAll(item.title, '').replaceAll(item.task_id, '');
+    return value.replace(/\bN-[A-F0-9]{32}\b|\bR-[1-9][0-9]*\b/g, '').trim();
+  };
+  const selectionOnly = (value) => /^(?:(?:我选|选择|选|是)\s*)?(?:第\s*(?:[1-9][0-9]*|[一二三四五六七八九十百]+)\s*[个项条])?(?:这个|那个|任务|这条|那条)?[。！!\s]*$/.test(value);
+  let latestIntent = null;
+  for (const human of humanMessages.toReversed()) {
+    const value = decisionText(human);
+    if (selectionOnly(value)) continue;
+    latestIntent = explicitReviewDecision(value); break;
+  }
+  if (review.summary && !humanMessages.some((message) => message.includes(review.summary))) throw new Conflict('review feedback must quote actual human instructions');
+  if (review.decision === 'changes_requested') {
+    const feedback = review.summary.replace(/先别通过|不要通过|不通过|退回|需要修改|审核|通过|同意|批准/g, '').replace(/[\s，,。！!；;：:]/g, '');
+    if (feedback.length < 2) throw new Conflict('rejection feedback must quote concrete human instructions; ask for missing feedback');
+  }
+  if (latestIntent !== review.decision) throw new Conflict('no matching explicit human review decision; clarify instead of guessing');
+  return target;
+}
+
+// A conservative consent check supplements model interpretation. Unclear or
+// conditional prose becomes a clarification, never an inferred approval.
+export function explicitReviewDecision(content) {
+  const value = content.trim().replace(/^@[^\s@]{1,40}\s+/, '');
+  if (/[？?]/.test(value) || /(?:如果|假如|若是|等.+(?:通过|完成)|通过(?:以后|之后|后)再|不要退回|别退回|不退回)/.test(value)) return null;
+  if (/(?:退回|不通过|不批准|不同意|先别通过|不要通过|还不行|需要修改|再改|再补|补充|补一下|改成|改为)/.test(value)) return 'changes_requested';
+  if (/(?:先等等|先等一下|等一下|稍等|暂缓|暂不|先不|先别|别急|待确认)/.test(value)) return null;
+  if (/(?:^|[，,。！!；;\n])\s*(?:我(?:确认|同意)\s*)?(?:审核|验收)?(?:通过|同意|批准|没问题|可以了|可以继续|就这样|OK|ok)(?=$|[，,。！!；;\s]|了|吧)/.test(value)) return 'approved';
+  return null;
+}
+
+function reviewSelection(value, candidates, afterClarification) {
+  const ids = new Set(value.match(/\bT-[A-Z0-9-]{1,62}\b/g) || []);
+  const revisions = [...new Set((value.match(/\bR-[1-9][0-9]*\b/g) || []).map((item) => Number(item.slice(2))))];
+  // Match longer titles first so a title prefix isn't a second selection.
+  for (const candidate of candidates.toSorted((a, b) => b.title.length - a.title.length)) {
+    if (value.includes(candidate.title)) {
+      for (const sameTitle of candidates.filter((item) => item.title === candidate.title)) ids.add(sameTitle.task_id);
+      value = value.replaceAll(candidate.title, '');
+    }
+  }
+  for (const match of value.matchAll(/第\s*([1-9][0-9]*|[一二三四五六七八九十百]+)\s*(?:个|项|条)/g)) {
+    ids.add(afterClarification ? candidates[reviewIndex(match[1]) - 1]?.task_id || 'invalid-list-selection' : 'unconfirmed-list-selection');
+  }
+  return { ids: [...ids], revisions };
+}
+
+function reviewIndex(token) {
+  if (/^[0-9]+$/.test(token)) return Number(token);
+  if (token === '一百') return 100;
+  const digits = '零一二三四五六七八九';
+  if (token.includes('十')) { const [tens, ones] = token.split('十'); return (tens ? digits.indexOf(tens) : 1) * 10 + (ones ? digits.indexOf(ones) : 0); }
+  return digits.indexOf(token);
+}

package/packages/peer/registry.mjs

@@ -22,19 +22,19 @@ export function verifyRecord(record, publicKey) {
   return body;
 }
 export function recordHash(record) { const { signature, ...body } = record; return digest(body); }
-export function policyVersion(team, previous, actorId, privateKey, enrollment) {
+export function policyVersion(team, previous, actorId, privateKey, enrollment, invitationReplacement) {
   validateTeam(team);
   const value = { schema_version: 1, version: previous ? previous.version + 1 : 1,
     parent_hash: previous ? recordHash(previous) : null, team_hash: digest(team), team, actor_id: actorId,
-    ...(enrollment ? { enrollment } : {}) };
+    ...(enrollment ? { enrollment } : {}), ...(invitationReplacement ? { invitation_replacement: invitationReplacement } : {}) };
   return signRecord(value, privateKey);
 }
 export function validateHistory(records, rootHash) {
   if (!Array.isArray(records) || !records.length || !hashPattern.test(rootHash || '') || recordHash(records[0]) !== rootHash) fail();
-  const teams = new Map();
+  const teams = new Map(), revokedInvites = new Set(), replacementTargets = new Set(), consumedInvites = new Set();
   let previous;
   for (const record of records) {
-    fields(record, ['schema_version', 'version', 'parent_hash', 'team_hash', 'team', 'actor_id', 'enrollment', 'signature']);
+    fields(record, ['schema_version', 'version', 'parent_hash', 'team_hash', 'team', 'actor_id', 'enrollment', 'invitation_replacement', 'signature']);
     if (record.schema_version !== 1 || record.version !== (previous?.version || 0) + 1 || record.parent_hash !== (previous ? recordHash(previous) : null)) fail();
     const team = validateTeam(record.team);
     const authority = previous?.team || team;
@@ -45,13 +45,25 @@ export function validateHistory(records, rootHash) {
     if (previous) for (const [id, agent] of Object.entries(authority.agents)) {
       if (!team.agents[id] || team.agents[id].public_key !== agent.public_key || team.agents[id].role !== agent.role || team.agents[id].wecom_userid !== agent.wecom_userid) fail();
     }
+    if (record.invitation_replacement) {
+      const replacement = record.invitation_replacement;
+      fields(replacement, ['old_invite_id', 'new_invite_id']);
+      const { old_invite_id: oldId, new_invite_id: newId } = replacement;
+      if (!previous || record.enrollment || record.team_hash !== previous.team_hash ||
+        !uuidPattern.test(oldId || '') || !uuidPattern.test(newId || '') || oldId === newId ||
+        revokedInvites.has(oldId) || revokedInvites.has(newId) || replacementTargets.has(newId) ||
+        consumedInvites.has(oldId) || consumedInvites.has(newId)) fail();
+      revokedInvites.add(oldId); replacementTargets.add(newId);
+    }
     if (record.enrollment) {
+      if (revokedInvites.has(record.enrollment.invite_id)) fail();
+      consumedInvites.add(record.enrollment.invite_id);
       fields(record.enrollment, ['invite_id', 'request_id']);
       if (!uuidPattern.test(record.enrollment.invite_id || '') || !uuidPattern.test(record.enrollment.request_id || '')) fail();
     }
     teams.set(record.team_hash, team); previous = record;
   }
-  return { records, teams, latest: previous, root_hash: rootHash };
+  return { records, teams, latest: previous, root_hash: rootHash, revoked_invites: revokedInvites };
 }
 export async function readRegistry(checkout, rootHash) {
   const dir = join(checkout, registryPath, 'versions');
@@ -76,6 +88,7 @@ export function invitationRecord(input, record, actorId, privateKey) {
   return signed;
 }
 export function validateInvitation(invite, history) {
+  if (history.revoked_invites?.has(invite?.invite_id)) fail();
   fields(invite, ['schema_version', 'invite_id', 'agent_id', 'capabilities', 'bot_id', 'chat_ids', 'commands_enabled', 'prefer', 'claim_public_key', 'expires_at', 'team_hash', 'actor_id', 'signature', 'owner_userid']);
   const team = history.teams.get(invite.team_hash);
   if (invite.schema_version !== 1 || !uuidPattern.test(invite.invite_id || '') || !idPattern.test(invite.agent_id || '') || !team || team.agents[invite.actor_id]?.role !== 'admin' ||

package/packages/peer/service.mjs

@@ -1,4 +1,5 @@
 import { stageReviewRule } from './review.mjs';
+import { reviewContext, assertReviewIntent } from './natural-review.mjs';
 import { randomUUID } from 'node:crypto';
 import { digest } from './config.mjs';
 import { canClaimDesktop, Conflict, Denied, eligible, leaseToken, validRefs } from './protocol.mjs';
@@ -22,7 +23,7 @@ export class PeerService {
     const { chatId, messageId, senderId, content, allowAdmin = false } = input || {};
     if (!plainFields(input, ['chatId', 'messageId', 'senderId', 'content', 'allowAdmin']) || !validText(chatId, 200) || !validText(messageId, 200) || !validText(senderId, 200) || !validText(content, 4000) || typeof allowAdmin !== 'boolean') throw new Conflict('invalid group request');
     const key = inboxMessageKey(this.agentId, chatId, messageId);
-    return this.store.transactInbox(key, (requests) => {
+    return this.store.transactInbox(key, async (requests) => {
       const owner = this.team.agents[this.agentId]?.wecom_userid === senderId;
       const senderAgents = Object.values(this.team.agents).filter((agent) => agent.wecom_userid === senderId);
       const member = senderAgents.some((agent) => agent.role === 'member');
@@ -36,8 +37,9 @@ export class PeerService {
       if (!referencedId && waiting.length > 1) throw Object.assign(new Conflict('multiple requests await clarification; include the N-request ID in your reply'), { code: 'AMBIGUOUS_INBOX_REPLY' });
       if (parent) return { id: parent.spec.id, event: { type: 'replied', content, message_key: key } };
       const id = `N-${digest([this.agentId, key]).slice(0, 32).toUpperCase()}`;
+      const context = reviewContext(await this.store.listLocal(), this.agentId, senderId, chatId, this.team);
       return { id, spec: { schema_version: 1, id, repo: this.team.repo, target_agent: this.agentId, chat_id: chatId,
-        sender_id: senderId, content, message_key: key, admin_dispatch: !!admin }, event: { type: 'received' } };
+        sender_id: senderId, content, message_key: key, admin_dispatch: !!admin, ...(context.length ? { review_context: context } : {}) }, event: { type: 'received' } };
     }, { replay: (request) => {
       const event = request.events.find((item) => item.idempotency_key === key);
       const original = event.type === 'received' ? request.spec.content : event.content;
@@ -50,18 +52,33 @@ export class PeerService {
     } });
   }
   async resolveRequest(id, expectedSeq, resolution, { defaultWorkflow } = {}) {
-    const { action, response, task: input } = resolution || {};
-    if (!plainFields(resolution, ['action', 'response', 'task']) || response !== undefined && !validText(response, 2000)) throw new Conflict('invalid request resolution');
+    const { action, response, task: input, review } = resolution || {};
+    if (action === 'review' && response !== undefined) throw new Conflict('review confirmation is generated from the committed decision');
+    if (!plainFields(resolution, ['action', 'response', 'task', 'review']) || response !== undefined && !validText(response, 2000)) throw new Conflict('invalid request resolution');
     if (!inboxIdPattern.test(id || '') || !Number.isSafeInteger(expectedSeq) || expectedSeq < 1) throw new Conflict('provide request ID and latest expected_seq');
-    if (!['create_task', 'clarify', 'answer'].includes(action)) throw new Conflict('unsupported request resolution');
+    if (!['create_task', 'clarify', 'answer', 'review'].includes(action)) throw new Conflict('unsupported request resolution');
+    if (action !== 'review' && review !== undefined) throw new Conflict('review payload requires review action');
+    if (action === 'review' && (input !== undefined || !review)) throw new Conflict('review requires a human interpretation without a new task');
     if (action === 'create_task') {
       if (!plainFields(input, ['title', 'description', 'acceptance', 'workflow']) || !validText(input.title, 200) || input.description !== undefined && (typeof input.description !== 'string' || input.description.length > 4000) || !validList(input.acceptance, 32, 1000) || input.workflow !== undefined && !validList(input.workflow, 16, 64)) throw new Conflict('invalid structured task');
-    } else if (input !== undefined || !validText(response, 2000)) throw new Conflict('answer and clarification require a response without a task');
+    } else if (action !== 'review' && (input !== undefined || !validText(response, 2000))) throw new Conflict('answer and clarification require a response without a task');
     const key = `inbox-resolve:${id}:${expectedSeq}`;
-    const result = await this.store.transactInbox(key, (requests) => {
+    const result = await this.store.transactInbox(key, async (requests) => {
       const request = requests.find((item) => item.spec.id === id);
       if (!request || request.spec.target_agent !== this.agentId) throw new Denied('only the receiving bot identity may interpret this request');
       if (request.state.status !== 'pending' || request.state.seq !== expectedSeq) throw new Conflict('request changed or is no longer pending');
+      if (action === 'review') {
+        assertReviewIntent(request, review, this.agentId, this.team);
+        const task = await this.store.readLocal(review.task_id);
+        const frozen = request.spec.review_context.find((item) => item.task_id === review.task_id);
+        if (task.state.seq !== review.expected_seq || task.state.checkpoint?.commit !== frozen.commit
+          || !['stage_review', 'review'].includes(task.state.status) || task.state.assignee !== this.agentId
+          || task.spec.source?.channel !== 'wecom' || task.spec.source.chat_id !== request.spec.chat_id) throw new Conflict('review changed; ask the human to review the latest result in a new message');
+        if ((task.team || this.team).agents[this.agentId]?.wecom_userid !== request.spec.sender_id) throw new Denied('sender is not the pinned human reviewer');
+        return { id, taskReview: review, event: { type: 'reviewed', task_id: review.task_id, review_seq: review.expected_seq + 1,
+          decision: review.decision, ...(review.summary ? { summary: review.summary } : {}),
+          response: `任务「${task.spec.title}」${review.decision === 'approved' ? '审核通过。' : `已退回修改：${review.summary}`}（${review.task_id}）` } };
+      }
       if (action !== 'create_task') return { id, event: { type: action === 'clarify' ? 'clarified' : 'answered', response } };
       if (!input) throw new Conflict('a structured task is required');
       const taskSpec = { schema_version: 2, id: inboxTaskId(id), repo: this.team.repo, title: input.title,
@@ -70,8 +87,12 @@ export class PeerService {
       return { id, taskSpec, event: { type: 'task_created', task_id: taskSpec.id, task_hash: digest(taskSpec), response: response || `已创建任务 ${taskSpec.id}：${taskSpec.title}。分工：${taskSpec.workflow.join(' → ')}；等待绑定对话认领。` } };
     }, { replay: async (request) => {
       const event = request.events.find((item) => item.idempotency_key === key);
-      const expectedType = { create_task: 'task_created', clarify: 'clarified', answer: 'answered' }[action];
+      const expectedType = { create_task: 'task_created', clarify: 'clarified', answer: 'answered', review: 'reviewed' }[action];
       if (event.type !== expectedType || response !== undefined && event.response !== response) throw new Conflict('request already resolved with different content');
+      if (action === 'review') {
+        assertReviewIntent(request, review, this.agentId, this.team);
+        if (event.task_id !== review.task_id || event.review_seq !== review.expected_seq + 1 || event.decision !== review.decision || event.summary !== review.summary) throw new Conflict('request already resolved with a different review');
+      }
       if (action === 'create_task') {
         const accepted = await this.store.readLocal(event.task_id);
         const taskSpec = { schema_version: 2, id: inboxTaskId(id), repo: this.team.repo, title: input.title, description: input.description ?? '', base_branch: 'main', acceptance: input.acceptance, workflow: input.workflow || accepted.spec.workflow, execution_mode: 'desktop_poll', source: { channel: 'wecom', chat_id: request.spec.chat_id } };
@@ -80,7 +101,8 @@ export class PeerService {
     } });
     if (result.state.task_id) await this.publish(await this.read(result.state.task_id), 'created');
     else await this.publish(result, 'inbox_response');
-    return { request: result, ...(result.state.task_id ? { task: await this.read(result.state.task_id) } : {}) };
+    const taskId = result.state.task_id || result.state.review_task_id;
+    return { request: result, ...(taskId ? { task: await this.read(taskId) } : {}) };
   }
   async create(input, idempotencyKey = randomUUID()) {
     const id = input.id || `T-${digest(`${this.agentId}:${idempotencyKey}`).slice(0, 32).toUpperCase()}`;

package/packages/peer/store.mjs

@@ -132,6 +132,16 @@ export class PeerGitStore {
       const task = await this.readLocal(state.task_id); const resolution = events.at(-1);
       if (digest(task.spec) !== resolution.task_hash || task.events[0].actor_id !== spec.target_agent || task.spec.execution_mode !== 'desktop_poll' || task.spec.source?.chat_id !== spec.chat_id || task.events[0].idempotency_key !== `inbox-task:${id}`) throw new Error('inbox resolution does not match its signed task');
     }
+    if (state.review_task_id) {
+      const resolution = events.at(-1); const task = await this.readLocal(state.review_task_id);
+      const reviewed = task.events[resolution.review_seq - 1];
+      const before = reducePeerTask(task.spec, task.events.slice(0, resolution.review_seq - 1), task.team || this.team);
+      const frozen = spec.review_context.find((item) => item.task_id === resolution.task_id);
+      if (!reviewed || reviewed.type !== 'reviewed' || reviewed.actor_id !== spec.target_agent || reviewed.decision !== resolution.decision
+        || reviewed.summary !== resolution.summary || reviewed.idempotency_key !== `inbox-review:${id}:${resolution.seq - 1}`
+        || digest(reviewed) !== resolution.task_event_hash || task.spec.source?.channel !== 'wecom' || task.spec.source.chat_id !== spec.chat_id
+        || before.checkpoint?.commit !== frozen.commit || before.stage !== frozen.stage || task.spec.title !== frozen.title || (task.team || this.team).agents[spec.target_agent]?.wecom_userid !== spec.sender_id) throw new Error('inbox review does not match its signed task decision');
+    }
     return { spec, events, state, team };
   }
   async listInboxLocal() {
@@ -142,8 +152,8 @@ export class PeerGitStore {
     return Promise.all(entries.sort().map((id) => this.readInboxLocal(id)));
   }
   async listInbox() { return this.locked(async () => { await this.sync(); return this.listInboxLocal(); }); }
-  // One remote Git CAS publishes BOTH the interpreted task and its resolution.
-  // Retries cannot leave a task created with a still-pending request.
+  // One remote Git CAS publishes the task creation/review and its inbox resolution.
+  // Retries cannot leave a task mutation with a still-pending request.
   async transactInbox(idempotencyKey, build, { replay = () => {} } = {}) {
     if (this.enrollmentOnly) throw new Error('enrollment client cannot write inbox requests');
     if (typeof idempotencyKey !== 'string' || !idempotencyKey || idempotencyKey.length > 300) throw new Error('invalid inbox idempotency key');
@@ -162,12 +172,27 @@ export class PeerGitStore {
         if (!spec || spec.id !== built.id || spec.target_agent !== this.agentId) throw new Error('inbox transaction identity mismatch');
         const now = new Date(this.clock()).toISOString();
         const team = current?.team || this.team;
+        let reviewedTask; let taskEvent;
+        if (built.taskReview) {
+          const review = built.taskReview; reviewedTask = await this.readLocal(review.task_id);
+          if (reviewedTask.state.seq !== review.expected_seq) throw new Error('review version changed');
+          taskEvent = makeSigner(reviewedTask.team || this.team, this.agentId, this.privateKey)({ schema_version: 2, task_id: review.task_id,
+            seq: review.expected_seq + 1, event_id: randomUUID(), actor_id: this.agentId, occurred_at: now,
+            idempotency_key: `inbox-review:${spec.id}:${current.state.seq}`, type: 'reviewed', decision: review.decision,
+            ...(review.summary ? { summary: review.summary } : {}) });
+          reducePeerTask(reviewedTask.spec, [...reviewedTask.events, taskEvent], reviewedTask.team || this.team);
+        }
         const event = makeSigner(team, this.agentId, this.privateKey)({ schema_version: 1, request_id: spec.id,
           seq: (current?.state.seq || 0) + 1, event_id: randomUUID(), actor_id: this.agentId, occurred_at: now,
-          idempotency_key: idempotencyKey, ...built.event, ...(current ? {} : { spec_hash: digest(spec) }) });
+          idempotency_key: idempotencyKey, ...built.event, ...(taskEvent ? { task_event_hash: digest(taskEvent) } : {}), ...(current ? {} : { spec_hash: digest(spec) }) });
         reduceInbox(spec, [...(current?.events || []), event], team);
         if ((event.type === 'task_created') !== !!built.taskSpec) throw new Error('inbox task must be published with its resolution');
+        if ((event.type === 'reviewed') !== !!built.taskReview) throw new Error('inbox review must be published with its task decision');
         const paths = [this.inboxRoot(spec.id)];
+        if (reviewedTask) {
+          const taskRoot = this.root(reviewedTask.spec.id); paths.push(taskRoot);
+          await writeFile(join(taskRoot, 'events', `${String(taskEvent.seq).padStart(6, '0')}-${taskEvent.event_id}.json`), JSON.stringify(taskEvent, null, 2) + '\n', { flag: 'wx' });
+        }
         if (built.taskSpec) {
           const taskSpec = built.taskSpec;
           const taskEvent = this.sign({ schema_version: 2, task_id: taskSpec.id, seq: 1, event_id: randomUUID(), actor_id: this.agentId,

package/schemas/peer-inbox-event.schema.json

@@ -61,7 +61,8 @@
         "clarified",
         "replied",
         "task_created",
-        "answered"
+        "answered",
+        "reviewed"
       ]
     },
     "spec_hash": {
@@ -88,11 +89,31 @@
     },
     "task_id": {
       "type": "string",
-      "pattern": "^T-[A-F0-9]{32}$"
+      "pattern": "^T-[A-Z0-9-]{1,62}$"
     },
     "task_hash": {
       "type": "string",
       "pattern": "^[a-f0-9]{64}$"
+    },
+    "review_seq": {
+      "type": "integer",
+      "minimum": 2
+    },
+    "decision": {
+      "enum": [
+        "approved",
+        "changes_requested"
+      ]
+    },
+    "summary": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 2000,
+      "pattern": "\\S"
+    },
+    "task_event_hash": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
     }
   },
   "oneOf": [
@@ -131,6 +152,26 @@
             "required": [
               "task_id"
             ]
+          },
+          {
+            "required": [
+              "review_seq"
+            ]
+          },
+          {
+            "required": [
+              "decision"
+            ]
+          },
+          {
+            "required": [
+              "summary"
+            ]
+          },
+          {
+            "required": [
+              "task_event_hash"
+            ]
           }
         ]
       }
@@ -170,6 +211,26 @@
             "required": [
               "task_id"
             ]
+          },
+          {
+            "required": [
+              "review_seq"
+            ]
+          },
+          {
+            "required": [
+              "decision"
+            ]
+          },
+          {
+            "required": [
+              "summary"
+            ]
+          },
+          {
+            "required": [
+              "task_event_hash"
+            ]
           }
         ]
       }
@@ -205,6 +266,26 @@
             "required": [
               "task_id"
             ]
+          },
+          {
+            "required": [
+              "review_seq"
+            ]
+          },
+          {
+            "required": [
+              "decision"
+            ]
+          },
+          {
+            "required": [
+              "summary"
+            ]
+          },
+          {
+            "required": [
+              "task_event_hash"
+            ]
           }
         ]
       }
@@ -213,6 +294,9 @@
       "properties": {
         "type": {
           "const": "task_created"
+        },
+        "task_id": {
+          "pattern": "^T-[A-F0-9]{32}$"
         }
       },
       "required": [
@@ -236,6 +320,26 @@
             "required": [
               "spec_hash"
             ]
+          },
+          {
+            "required": [
+              "review_seq"
+            ]
+          },
+          {
+            "required": [
+              "decision"
+            ]
+          },
+          {
+            "required": [
+              "summary"
+            ]
+          },
+          {
+            "required": [
+              "task_event_hash"
+            ]
           }
         ]
       }
@@ -275,10 +379,84 @@
             "required": [
               "task_id"
             ]
+          },
+          {
+            "required": [
+              "review_seq"
+            ]
+          },
+          {
+            "required": [
+              "decision"
+            ]
+          },
+          {
+            "required": [
+              "summary"
+            ]
+          },
+          {
+            "required": [
+              "task_event_hash"
+            ]
           }
         ]
       }
+    },
+    {
+      "properties": {
+        "type": {
+          "const": "reviewed"
+        }
+      },
+      "required": [
+        "task_id",
+        "review_seq",
+        "decision",
+        "task_event_hash",
+        "response"
+      ],
+      "not": {
+        "anyOf": [
+          {
+            "required": [
+              "content"
+            ]
+          },
+          {
+            "required": [
+              "message_key"
+            ]
+          },
+          {
+            "required": [
+              "spec_hash"
+            ]
+          },
+          {
+            "required": [
+              "task_hash"
+            ]
+          }
+        ]
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "decision": {
+                "const": "changes_requested"
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "summary"
+            ]
+          }
+        }
+      ]
     }
   ],
-  "$comment": "Runtime also verifies Ed25519 signatures and historical team hash, receiving-agent authorship, exact sequence, unique IDs and idempotency keys, nondecreasing UTC timestamps, signed spec digest and allowed transitions. received opens pending; clarified waits for a reply; replied returns to pending; task_created and answered resolve pending. A task_created event and its desktop_poll task commit atomically; runtime validates the exact task digest, deterministic task ID, original group, creator and creation key. Replies are scoped to the same bot, group and sender."
+  "$comment": "Runtime also verifies Ed25519 signatures and historical team hash, receiving-agent authorship, exact sequence, unique IDs and idempotency keys, nondecreasing UTC timestamps, signed spec digest and allowed transitions. received opens pending; clarified waits for a reply; replied returns to pending; task_created and answered resolve pending. A task_created event and its desktop_poll task commit atomically; runtime validates the exact task digest, deterministic task ID, original group, creator and creation key. Replies are scoped to the same bot, group and sender. reviewed resolves a pending request and atomically appends the matching task reviewed event. Runtime verifies frozen context, explicit owner consent, pinned reviewer, unchanged code revision and the signed task-event digest; task_created keeps the deterministic inbox-derived task ID constraint."
 }