@fitlab-ai/agent-infra 0.10.0 → 0.11.1

package/lib/platform/activity-recovery.ts

@@ -0,0 +1,179 @@
+import { createHash } from 'node:crypto';
+
+import { locateActivityLog } from '../task/activity-log.ts';
+import type { LogEntry } from '../task/activity-log.ts';
+
+const METADATA_PREFIX = '<!-- activity-recovery:v1:';
+const METADATA_SUFFIX = ' -->';
+
+type ActivityRecoveryRecord = {
+  version: 1;
+  taskId: string;
+  artifact?: string;
+  entries: LogEntry[];
+  sha256: string;
+};
+
+function canonicalJson(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  const record = value as Record<string, unknown>;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+}
+
+function sha256(value: unknown): string {
+  return createHash('sha256').update(canonicalJson(value), 'utf8').digest('hex');
+}
+
+function baseStep(step: string): string {
+  return step.replace(/\s*\[(?:started|aborted)\]\s*$/, '');
+}
+
+function entriesForArtifact(taskContent: string, artifact: string): LogEntry[] {
+  const log = locateActivityLog(taskContent);
+  if (!log) return [];
+  const selected = new Set<number>();
+  for (let index = 0; index < log.entries.length; index += 1) {
+    const entry = log.entries[index]!;
+    if (!entry.note.includes(`→ ${artifact}`)) continue;
+    selected.add(index);
+    const step = baseStep(entry.step);
+    let startedAt = index;
+    for (let prior = index - 1; prior >= 0; prior -= 1) {
+      const candidate = log.entries[prior]!;
+      if (baseStep(candidate.step) !== step) continue;
+      if (/\[started\]\s*$/.test(candidate.step)) {
+        selected.add(prior);
+        startedAt = prior;
+      }
+      break;
+    }
+    if (/^code(?:-r\d+)?\.md$/.test(artifact)) {
+      for (let between = startedAt + 1; between < index; between += 1) {
+        if (baseStep(log.entries[between]!.step) === 'Commit') selected.add(between);
+      }
+    }
+  }
+  return log.entries.filter((_entry, index) => selected.has(index));
+}
+
+function recordForEntries(taskId: string, entries: readonly LogEntry[], artifact?: string): ActivityRecoveryRecord | null {
+  if (entries.length === 0) return null;
+  const base = { version: 1 as const, taskId, ...(artifact ? { artifact } : {}), entries: [...entries] };
+  return { ...base, sha256: sha256(base) };
+}
+
+function recordForArtifact(taskId: string, taskContent: string, artifact: string): ActivityRecoveryRecord | null {
+  return recordForEntries(taskId, entriesForArtifact(taskContent, artifact), artifact);
+}
+
+function entriesForTask(taskContent: string): LogEntry[] {
+  const log = locateActivityLog(taskContent);
+  if (!log) return [];
+  const linked = new Set(entriesForArtifactNames(log.entries));
+  return log.entries.filter((entry, index) => !linked.has(index)
+    && !['Create PR', 'Complete Task', 'Cancel Task'].includes(baseStep(entry.step)));
+}
+
+function entriesForSummary(taskContent: string): LogEntry[] {
+  const log = locateActivityLog(taskContent);
+  return log?.entries.filter((entry) => ['Create PR', 'Complete Task'].includes(baseStep(entry.step))) ?? [];
+}
+
+function entriesForCancel(taskContent: string): LogEntry[] {
+  const log = locateActivityLog(taskContent);
+  return log?.entries.filter((entry) => baseStep(entry.step) === 'Cancel Task') ?? [];
+}
+
+function recordForTask(taskId: string, taskContent: string): ActivityRecoveryRecord | null {
+  return recordForEntries(taskId, entriesForTask(taskContent));
+}
+
+function recordForSummary(taskId: string, taskContent: string): ActivityRecoveryRecord | null {
+  return recordForEntries(taskId, entriesForSummary(taskContent));
+}
+
+function recordForCancel(taskId: string, taskContent: string): ActivityRecoveryRecord | null {
+  return recordForEntries(taskId, entriesForCancel(taskContent));
+}
+
+function entriesForArtifactNames(entries: readonly LogEntry[]): number[] {
+  const selected = new Set<number>();
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]!;
+    const artifact = /→ ([A-Za-z0-9][A-Za-z0-9._-]*\.md)(?:\s|$)/.exec(entry.note)?.[1];
+    if (!artifact) continue;
+    selected.add(index);
+    const step = baseStep(entry.step);
+    let startedAt = index;
+    for (let prior = index - 1; prior >= 0; prior -= 1) {
+      const candidate = entries[prior]!;
+      if (baseStep(candidate.step) !== step) continue;
+      if (/\[started\]\s*$/.test(candidate.step)) {
+        selected.add(prior);
+        startedAt = prior;
+      }
+      break;
+    }
+    if (/^code(?:-r\d+)?\.md$/.test(artifact)) {
+      for (let between = startedAt + 1; between < index; between += 1) {
+        if (baseStep(entries[between]!.step) === 'Commit') selected.add(between);
+      }
+    }
+  }
+  return [...selected];
+}
+
+function renderActivityRecoveryMetadata(record: ActivityRecoveryRecord | null): string {
+  if (!record) return '';
+  const encoded = Buffer.from(canonicalJson(record), 'utf8').toString('base64url');
+  const first = record.entries[0]!;
+  const last = record.entries.at(-1)!;
+  return [
+    '<details><summary>恢复元数据</summary>',
+    '',
+    `- 动作：${baseStep(last.step)}`,
+    `- 记录：${record.entries.length} 条（${first.time} 至 ${last.time}）`,
+    ...(record.artifact ? [`- 产物：${record.artifact}`] : []),
+    `- 校验：\`${record.sha256}\``,
+    '',
+    `${METADATA_PREFIX}${encoded}${METADATA_SUFFIX}`,
+    '</details>',
+    ''
+  ].join('\n');
+}
+
+function parseActivityRecoveryMetadata(body: string): ActivityRecoveryRecord | null {
+  const match = body.match(/<!-- activity-recovery:v1:([A-Za-z0-9_-]+) -->/);
+  if (!match) return null;
+  let value: unknown;
+  try { value = JSON.parse(Buffer.from(match[1]!, 'base64url').toString('utf8')); }
+  catch { throw new Error('RECOVERY_EVIDENCE_MISSING: activity metadata is not valid'); }
+  if (!value || typeof value !== 'object') throw new Error('RECOVERY_EVIDENCE_MISSING: activity metadata is invalid');
+  const record = value as Partial<ActivityRecoveryRecord>;
+  if (record.version !== 1 || typeof record.taskId !== 'string' || (record.artifact !== undefined && typeof record.artifact !== 'string')
+    || !Array.isArray(record.entries) || typeof record.sha256 !== 'string') {
+    throw new Error('RECOVERY_EVIDENCE_MISSING: activity metadata shape is invalid');
+  }
+  if (record.entries.some((entry) => !entry || typeof entry.time !== 'string' || typeof entry.step !== 'string' || typeof entry.agent !== 'string' || typeof entry.note !== 'string')) {
+    throw new Error('RECOVERY_EVIDENCE_MISSING: activity metadata entries are invalid');
+  }
+  const base = { version: 1 as const, taskId: record.taskId, ...(record.artifact ? { artifact: record.artifact } : {}), entries: record.entries as LogEntry[] };
+  if (sha256(base) !== record.sha256) throw new Error('RECOVERY_EVIDENCE_MISSING: activity metadata checksum does not match');
+  return { ...base, sha256: record.sha256 };
+}
+
+export {
+  entriesForArtifact,
+  entriesForCancel,
+  entriesForSummary,
+  entriesForTask,
+  parseActivityRecoveryMetadata,
+  recordForArtifact,
+  recordForCancel,
+  recordForEntries,
+  recordForSummary,
+  recordForTask,
+  renderActivityRecoveryMetadata
+};
+export type { ActivityRecoveryRecord };

package/lib/platform/issue-comments.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 
 import { parseTaskFrontmatter } from '../task/frontmatter.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
@@ -16,6 +17,14 @@ import {
 } from './provider-bridge.ts';
 import { resourceIdentityNumber } from './resource-identity.ts';
 import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.ts';
+import {
+  recordForArtifact,
+  recordForCancel,
+  recordForSummary,
+  recordForTask,
+  renderActivityRecoveryMetadata
+} from './activity-recovery.ts';
+import { projectTaskComment } from './task-comment-projection.ts';
 import {
   canonicalizeCommentBody,
   escapeHtmlText,
@@ -48,7 +57,7 @@ const MARKERS = {
   artifactChunk: (taskId: string, stem: string, part: number, total: number) =>
     `<!-- sync-issue:${taskId}:${stem}:${part}/${total} -->`,
   summary: (taskId: string) => `<!-- sync-issue:${taskId}:summary -->`,
-  cancel: (taskId: string) => `<!-- sync-issue:${taskId}:cancel -->`
+  cancel: (taskId: string) => `<!-- sync-issue:${taskId}:cancel -->`,
 };
 const COMMENT_BYTE_LIMIT = 60_000;
 
@@ -68,10 +77,6 @@ function normalizeCommentContent(content: string): string {
   return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
 }
 
-function isTaskCommentTooLarge(content: string): boolean {
-  return Buffer.byteLength(content, 'utf8') > COMMENT_BYTE_LIMIT;
-}
-
 function splitFrontmatter(content: string): { frontmatter: string | null; body: string } {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
   if (!match) return { frontmatter: null, body: content };
@@ -88,22 +93,55 @@ function footer(agent: string, taskId: string): string {
   return `---\n*由 ${agent} 自动生成 · 内部追踪：${taskId}*`;
 }
 
-function renderTaskComment(content: string, taskId: string, agent: string): string {
+function taskFrontmatterSummary(language = ''): string {
+  return language === 'en' || language === 'en-US'
+    ? 'Metadata (frontmatter)'
+    : '元数据 (frontmatter)';
+}
+
+function renderTaskCommentResult(content: string, taskId: string, language = ''): { body: string; byteLength: number; sha256: string } {
   const split = splitFrontmatter(content);
-  const safeBody = sanitizeCommentBody(split.body, 'task body');
-  const taskBody = split.frontmatter === null
+  const projectedContent = split.frontmatter === null ? content : projectTaskComment(content).content;
+  const projected = splitFrontmatter(projectedContent);
+  const safeBody = sanitizeCommentBody(projected.body, 'task body');
+  const taskBody = projected.frontmatter === null
     ? safeBody
-    : `<details><summary>元数据 (frontmatter)</summary>\n\n${renderSafeCodeFence(`---\n${split.frontmatter}\n---`, 'yaml')}\n\n</details>\n\n${safeBody}`;
-  return normalizeCommentContent([
+    : `<details><summary>${taskFrontmatterSummary(language)}</summary>\n\n${renderSafeCodeFence(`---\n${projected.frontmatter}\n---`, 'yaml')}\n\n</details>\n\n${safeBody}`;
+  const recoveryMetadata = renderActivityRecoveryMetadata(recordForTask(taskId, content));
+  const body = normalizeCommentContent([
     MARKERS.task(taskId),
     '## 任务文件',
     '',
-    `> **${agent}** · ${taskId}`,
+    `> 任务同步 · ${taskId}`,
     '',
+    ...(recoveryMetadata ? [recoveryMetadata.replace(/\n+$/, ''), ''] : []),
     taskBody.replace(/\n+$/, ''),
     '',
-    footer(agent, taskId)
+    '---',
+    `*由 agent-infra 自动生成 · 内部追踪：${taskId}*`
   ].join('\n'));
+  return {
+    body,
+    byteLength: Buffer.byteLength(body, 'utf8'),
+    sha256: createHash('sha256').update(body, 'utf8').digest('hex')
+  };
+}
+
+function renderTaskComment(content: string, taskId: string, _agent: string, language = ''): string {
+  return renderTaskCommentResult(content, taskId, language).body;
+}
+
+function isTaskCommentTooLarge(content: string, taskId = 'TASK-UNKNOWN', _agent = 'codex'): boolean {
+  return renderTaskCommentResult(content, taskId).byteLength > COMMENT_BYTE_LIMIT;
+}
+
+function taskCommentLanguage(repoRoot: string): string {
+  try {
+    const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8')) as { language?: unknown };
+    return typeof config.language === 'string' ? config.language.trim() : '';
+  } catch {
+    return '';
+  }
 }
 
 function artifactIdentity(artifact: string): { stem: string; title: string } {
@@ -247,7 +285,8 @@ function buildArtifactChunk(
   total: number,
   chunked: boolean,
   backfill: boolean,
-  renderedContent = content
+  renderedContent = content,
+  recoveryMetadata = ''
 ): RenderedChunk {
   const marker = chunked ? MARKERS.artifactChunk(taskId, stem, part, total) : MARKERS.artifact(taskId, stem);
   const heading = chunked ? `## ${title}（${part}/${total}）` : `## ${title}`;
@@ -259,6 +298,7 @@ function buildArtifactChunk(
     '',
     `> **${agent}** · ${taskId}`,
     '',
+    ...(recoveryMetadata ? [recoveryMetadata] : []),
     renderedContent,
     '',
     footer(agent, taskId)
@@ -273,12 +313,13 @@ function chunkArtifactComment(input: {
   body: string;
   byteLimit?: number;
   backfill?: boolean;
+  recoveryMetadata?: string;
 }): RenderedChunk[] {
   const byteLimit = input.byteLimit || COMMENT_BYTE_LIMIT;
   const identity = artifactIdentity(input.artifact);
   const safeBody = sanitizeCommentBody(input.body, 'artifact body');
   const single = buildArtifactChunk(
-    input.taskId, identity.stem, identity.title, input.agent, safeBody, 1, 1, false, Boolean(input.backfill)
+    input.taskId, identity.stem, identity.title, input.agent, safeBody, 1, 1, false, Boolean(input.backfill), safeBody, input.recoveryMetadata
   );
   if (Buffer.byteLength(single.body, 'utf8') <= byteLimit) return [single];
 
@@ -288,7 +329,7 @@ function chunkArtifactComment(input: {
   if (!ranges.ok) throw new Error(`${ranges.error.code}: artifact body: ${ranges.error.message} at offset ${ranges.error.offset}`);
   for (;;) {
     const probe = buildArtifactChunk(
-      input.taskId, identity.stem, identity.title, input.agent, '', total, total, true, Boolean(input.backfill)
+      input.taskId, identity.stem, identity.title, input.agent, '', 1, total, true, Boolean(input.backfill), '', input.recoveryMetadata
     );
     const available = byteLimit - Buffer.byteLength(probe.body, 'utf8');
     const sourceLimit = Math.min(available, payloadLimit);
@@ -308,7 +349,8 @@ function chunkArtifactComment(input: {
       total,
       true,
       Boolean(input.backfill),
-      independentChunkContent(piece, ranges.value, sourceLimit)
+      independentChunkContent(piece, ranges.value, sourceLimit),
+      index === 0 ? input.recoveryMetadata : ''
     ));
     const overflow = Math.max(...chunks.map((chunk) => Buffer.byteLength(chunk.body, 'utf8') - byteLimit));
     if (overflow <= 0) return chunks;
@@ -346,9 +388,11 @@ function hasResolvedPlatformContext(context: PlatformResult): boolean {
   return context.status === 'degraded' || (context.status === 'no-op' && context.error === null);
 }
 
-function bodyEnvelope(marker: string, title: string, taskId: string, agent: string, body: string): string {
+function bodyEnvelope(marker: string, title: string, taskId: string, agent: string, body: string, recoveryMetadata = ''): string {
   return normalizeCommentContent([
-    marker, `## ${title}`, '', `> **${agent}** · ${taskId}`, '', sanitizeCommentBody(body, `${title} body`).replace(/\n+$/, ''), '', footer(agent, taskId)
+    marker, `## ${title}`, '', `> **${agent}** · ${taskId}`, '',
+    ...(recoveryMetadata ? [recoveryMetadata.replace(/\n+$/, ''), ''] : []),
+    sanitizeCommentBody(body, `${title} body`).replace(/\n+$/, ''), '', footer(agent, taskId)
   ].join('\n'));
 }
 
@@ -368,10 +412,11 @@ function expectedComments(
   taskId: string,
   taskContent: string,
   taskDir: string,
+  repoRoot: string,
   options: SyncOptions
 ): RenderedChunk[] {
   if (options.kind === 'task') {
-    const body = renderTaskComment(taskContent, taskId, options.agent);
+    const body = renderTaskComment(taskContent, taskId, options.agent, taskCommentLanguage(repoRoot));
     return [{ marker: MARKERS.task(taskId), body, content: taskContent, part: 1, total: 1 }];
   }
   if (options.kind === 'artifact') {
@@ -381,13 +426,17 @@ function expectedComments(
       artifact: options.artifact,
       agent: options.agent,
       body: resolveArtifactBody(taskDir, options.artifact),
-      backfill: options.backfill
+      backfill: options.backfill,
+      recoveryMetadata: renderActivityRecoveryMetadata(recordForArtifact(taskId, taskContent, options.artifact))
     });
   }
   if (options.body === undefined) throw new Error(`${options.kind} sync requires a body`);
   const marker = options.kind === 'summary' ? MARKERS.summary(taskId) : MARKERS.cancel(taskId);
   const title = options.kind === 'summary' ? '交付摘要' : '任务取消';
-  const body = bodyEnvelope(marker, title, taskId, options.agent, options.body);
+  const recoveryMetadata = options.kind === 'summary'
+    ? renderActivityRecoveryMetadata(recordForSummary(taskId, taskContent))
+    : renderActivityRecoveryMetadata(recordForCancel(taskId, taskContent));
+  const body = bodyEnvelope(marker, title, taskId, options.agent, options.body, recoveryMetadata);
   return [{ marker, body, content: options.body, part: 1, total: 1 }];
 }
 
@@ -458,22 +507,22 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
       error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false }
     });
   }
-  if (options.kind === 'task' && isTaskCommentTooLarge(taskContent)) {
-    return platformResult('no-op', {
-      resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentityFromTask), identity: issueIdentityFromTask },
-      operations: [{ name: `comment:${MARKERS.task(resolved.taskId)}`, status: 'skipped', reasonCode: 'COMMENT_PAYLOAD_TOO_LARGE' }],
-      error: null
-    });
-  }
   let desired: RenderedChunk[];
   try {
-    desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, options);
+    desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, resolved.repoRoot, options);
   } catch (error) {
     return platformResult('failed', {
       resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentityFromTask) },
       error: { code: 'COMMENT_PAYLOAD_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false }
     });
   }
+  if (options.kind === 'task' && Buffer.byteLength(desired[0]!.body, 'utf8') > COMMENT_BYTE_LIMIT) {
+    return platformResult('failed', {
+      resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentityFromTask), identity: issueIdentityFromTask },
+      operations: [{ name: `comment:${MARKERS.task(resolved.taskId)}`, status: 'skipped', reasonCode: 'COMMENT_PAYLOAD_TOO_LARGE' }],
+      error: { code: 'COMMENT_PAYLOAD_TOO_LARGE', message: 'Projected task comment exceeds the platform byte limit', retryable: false }
+    });
+  }
   const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
   const context = loaded.ok ? loaded.value.context : loaded.context;
   if (!hasResolvedPlatformContext(context) || !loaded.ok) return context;
@@ -505,6 +554,22 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
     });
   }
 
+  if (options.kind === 'task' && existing.length === 1) {
+    const owner = existing[0]!.user?.login;
+    if (!owner || !context.platform.currentUser || owner !== context.platform.currentUser) {
+      return platformResult('blocked', {
+        ...contextFields(context),
+        resource: { kind: 'issue', number: issue, identity: issueIdentityFromTask },
+        error: {
+          code: 'COMMENT_OWNER_CONFLICT',
+          message: owner ? `Task comment is owned by '${owner}'` : 'Task comment owner is unavailable',
+          retryable: false
+        }
+      });
+    }
+  }
+
+
   // Backfill only supplies missing artifact comments; valid existing marker sets stay untouched.
   if (options.kind === 'artifact' && options.backfill && existing.length > 0) {
     const operations = existing.map((comment): PlatformOperation => ({
@@ -582,14 +647,15 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
     operations.push({ name: `comment:${comment.id}`, status: 'applied', reasonCode: 'STALE_CHUNK_DELETED' });
   }
   const changed = operations.some((operation) => operation.status === 'applied');
-  return platformResult(changed ? 'applied' : 'no-op', {
+  const result = platformResult(changed ? 'applied' : 'no-op', {
     ...contextFields(context),
     changed,
     resource: { kind: 'issue', number: issue },
     operations,
-    comment: { kind: options.kind, marker: desired[0]!.marker, ids, parts: desired.length },
+    comment: { kind: options.kind, marker: desired[0]?.marker ?? markerPrefix(resolved.taskId, options), ids, parts: desired.length },
     error: null
   });
+  return result;
 }
 
 async function listPlatformComments(issue: string | number, cwd = process.cwd(), client?: PlatformClient): Promise<PlatformResult & { comments?: RemoteComment[] }> {
@@ -655,6 +721,7 @@ export {
   listPlatformComments,
   normalizeCommentContent,
   renderTaskComment,
+  renderTaskCommentResult,
   isTaskCommentTooLarge,
   syncPlatformComment,
   validateRelatedMarkerSet,

package/lib/platform/issues.ts

@@ -574,9 +574,8 @@ async function syncPlatformIssue(taskRef: string, options: SyncOptions): Promise
   const failure = plan.operations.find((operation) => operation.status === 'failed');
   if (failure) return result('failed', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: { code: failure.reasonCode || 'ISSUE_SYNC_FAILED', message: `Operation ${failure.name} failed`, retryable: false } });
   const planned = plan.operations.filter((operation) => operation.status === 'planned');
-  const skipped = plan.operations.some((operation) => operation.status === 'skipped');
-  if (options.dryRun) return result(planned.length ? 'planned' : skipped ? 'degraded' : 'no-op', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: null });
-  if (planned.length === 0) return result(skipped ? 'degraded' : 'no-op', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: null });
+  if (options.dryRun) return result(planned.length ? 'planned' : 'no-op', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: null });
+  if (planned.length === 0) return result('no-op', base.resolved.taskId, base.issueNumber, { issue: snapshot, operations: plan.operations, error: null });
   const payload = applyRestOperations(snapshot, planned) as Partial<{
     title: string; body: string; labels: string[]; assignees: string[];
     milestone: string | null; state: 'open' | 'closed'; fields: Record<string, string | number | null>;
@@ -611,7 +610,7 @@ async function syncPlatformIssue(taskRef: string, options: SyncOptions): Promise
       error: { code: 'IN_LABEL_SYNC_PARTIAL', message: 'Issue labels did not converge after update', retryable: true }
     });
   }
-  return result(skipped ? 'degraded' : 'applied', base.resolved.taskId, base.issueNumber, {
+  return result('applied', base.resolved.taskId, base.issueNumber, {
     changed: updated.value.changed, platform: base.context.platform, capabilities: base.context.capabilities,
     resource: { kind: 'issue', number: base.issueNumber, identity: base.issueIdentity }, issue: finalIssue,
     operations: plan.operations.map((operation) => operation.status === 'planned' ? { ...operation, status: 'applied' } : operation), error: null

package/lib/platform/task-comment-projection.ts

@@ -0,0 +1,79 @@
+import { createHash } from 'node:crypto';
+
+const SNAPSHOT_FRONTMATTER = new Set([
+  'id', 'type', 'branch', 'workflow', 'status', 'created_at', 'updated_at',
+  'priority', 'effort', 'start_date', 'target_date', 'current_step', 'assigned_to',
+  'platform_issue_identity', 'delivery_remote', 'delivery_base_ref', 'pr_delivery_fact'
+]);
+
+type TaskCommentProjection = {
+  content: string;
+  byteLength: number;
+  sha256: string;
+};
+
+const PROCESS_SECTION_ALIASES = new Set([
+  '活动日志', 'activity log',
+  '产物生命周期收据', 'artifact lifecycle receipts',
+  '审查分歧账本', 'review dispute ledger', 'review disagreement ledger',
+  '人工裁决', '人工裁决待办', 'human decisions', 'human decision pending', 'human decisions pending',
+  '实现输入', 'implementation input', 'implementation inputs',
+  '工作流告警', 'workflow warning', 'workflow warnings', 'warnings',
+  '返工意图', 'rework intent', 'rework intents',
+  '产物失效记录', 'artifact invalidation', 'artifact invalidation records',
+  '实现备注', 'implementation notes',
+  '审查反馈', 'review feedback'
+]);
+
+function normalize(content: string): string {
+  return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+
+function splitFrontmatter(content: string): { frontmatter: string; body: string } {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) throw new Error('task comment projection requires task frontmatter');
+  return { frontmatter: match[1]!, body: content.slice(match[0].length) };
+}
+
+function projectFrontmatter(frontmatter: string): string {
+  const lines = frontmatter.replace(/\r\n/g, '\n').split('\n');
+  const selected = lines.filter((line) => {
+    if (!line.trim() || line.trimStart().startsWith('#')) return false;
+    const match = /^([^:\s][^:]*):/.exec(line);
+    return Boolean(match && SNAPSHOT_FRONTMATTER.has(match[1]!.trim()));
+  });
+  if (!selected.some((line) => /^id:/.test(line))) throw new Error('task comment projection requires frontmatter id');
+  return selected.join('\n');
+}
+
+function projectBody(body: string): string {
+  const lines = body.replace(/\r\n/g, '\n').split('\n');
+  const kept: string[] = [];
+  let excludedLevel: number | null = null;
+  for (const line of lines) {
+    const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+    if (heading) {
+      const level = heading[1]!.length;
+      if (excludedLevel !== null && level <= excludedLevel) excludedLevel = null;
+      if (PROCESS_SECTION_ALIASES.has(heading[2]!.trim().toLowerCase())) {
+        excludedLevel = level;
+        continue;
+      }
+    }
+    if (excludedLevel === null) kept.push(line);
+  }
+  return kept.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+
+function projectTaskComment(content: string): TaskCommentProjection {
+  const split = splitFrontmatter(content);
+  const projected = normalize(`---\n${projectFrontmatter(split.frontmatter)}\n---\n\n${projectBody(split.body)}`);
+  return {
+    content: projected,
+    byteLength: Buffer.byteLength(projected, 'utf8'),
+    sha256: createHash('sha256').update(projected, 'utf8').digest('hex')
+  };
+}
+
+export { projectTaskComment };
+export type { TaskCommentProjection };

package/lib/platform/task-recovery.ts

@@ -0,0 +1,54 @@
+import { parseActivityRecoveryMetadata } from './activity-recovery.ts';
+
+type RecoveryRemoteComment = { body: string; user?: { login?: string } };
+
+function normalized(body: string): string {
+  return body.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+
+function decodeRenderedText(value: string): string {
+  return value
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&amp;/g, '&');
+}
+
+function taskSnapshot(taskId: string, body: string): string {
+  const marker = `<!-- sync-issue:${taskId}:task -->`;
+  if (normalized(body).split('\n', 1)[0] !== marker) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot marker is invalid');
+  const frontmatter = body.match(/<details><summary>[^<]*<\/summary>\n\n```yaml\n---\n([\s\S]*?)\n---\n```\n\n<\/details>/);
+  if (!frontmatter) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot frontmatter is invalid');
+  const afterDetails = (frontmatter.index ?? 0) + frontmatter[0].length;
+  const footer = body.lastIndexOf('\n\n---\n*由 ');
+  if (footer <= afterDetails) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot envelope is invalid');
+  const projectedBody = body.slice(afterDetails, footer).replace(/^\n+|\n+$/g, '');
+  return `---\n${decodeRenderedText(frontmatter[1]!)}\n---\n\n${decodeRenderedText(projectedBody)}\n`;
+}
+
+function activityLine(entry: { time: string; step: string; agent: string; note: string }): string {
+  return `- ${entry.time} — **${entry.step}** by ${entry.agent} — ${entry.note}`;
+}
+
+function recoverTaskFromComments(input: { taskId: string; comments: readonly RecoveryRemoteComment[] }): string {
+  const marker = `<!-- sync-issue:${input.taskId}:task -->`;
+  const snapshots = input.comments.filter((comment) => normalized(comment.body).split('\n', 1)[0] === marker);
+  if (snapshots.length !== 1) throw new Error('RECOVERY_EVIDENCE_MISSING: exactly one task snapshot comment is required');
+  const author = snapshots[0]!.user?.login;
+  if (!author) throw new Error('RECOVERY_EVIDENCE_MISSING: task snapshot author is unavailable');
+  const content = taskSnapshot(input.taskId, normalized(snapshots[0]!.body));
+  const entries = new Map<string, { time: string; step: string; agent: string; note: string }>();
+  for (const comment of input.comments) {
+    if (comment.user?.login !== author) continue;
+    const record = parseActivityRecoveryMetadata(comment.body);
+    if (!record) continue;
+    if (record.taskId !== input.taskId) throw new Error('RECOVERY_EVIDENCE_MISSING: activity metadata task identity is invalid');
+    for (const entry of record.entries) entries.set(JSON.stringify(entry), entry);
+  }
+  const restored = [...entries.values()].sort((left, right) => left.time.localeCompare(right.time));
+  return `${content.replace(/\n+$/, '')}\n\n## 活动日志\n\n${restored.map(activityLine).join('\n')}\n`;
+}
+
+export { recoverTaskFromComments };
+export type { RecoveryRemoteComment };