@fitlab-ai/agent-infra 0.10.0 → 0.11.0

package/dist/lib/platform/activity-recovery.js

@@ -0,0 +1,159 @@
+import { createHash } from 'node:crypto';
+import { locateActivityLog } from '../task/activity-log.js';
+const METADATA_PREFIX = '<!-- activity-recovery:v1:';
+const METADATA_SUFFIX = ' -->';
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+}
+function sha256(value) {
+    return createHash('sha256').update(canonicalJson(value), 'utf8').digest('hex');
+}
+function baseStep(step) {
+    return step.replace(/\s*\[(?:started|aborted)\]\s*$/, '');
+}
+function entriesForArtifact(taskContent, artifact) {
+    const log = locateActivityLog(taskContent);
+    if (!log)
+        return [];
+    const selected = new Set();
+    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, entries, artifact) {
+    if (entries.length === 0)
+        return null;
+    const base = { version: 1, taskId, ...(artifact ? { artifact } : {}), entries: [...entries] };
+    return { ...base, sha256: sha256(base) };
+}
+function recordForArtifact(taskId, taskContent, artifact) {
+    return recordForEntries(taskId, entriesForArtifact(taskContent, artifact), artifact);
+}
+function entriesForTask(taskContent) {
+    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) {
+    const log = locateActivityLog(taskContent);
+    return log?.entries.filter((entry) => ['Create PR', 'Complete Task'].includes(baseStep(entry.step))) ?? [];
+}
+function entriesForCancel(taskContent) {
+    const log = locateActivityLog(taskContent);
+    return log?.entries.filter((entry) => baseStep(entry.step) === 'Cancel Task') ?? [];
+}
+function recordForTask(taskId, taskContent) {
+    return recordForEntries(taskId, entriesForTask(taskContent));
+}
+function recordForSummary(taskId, taskContent) {
+    return recordForEntries(taskId, entriesForSummary(taskContent));
+}
+function recordForCancel(taskId, taskContent) {
+    return recordForEntries(taskId, entriesForCancel(taskContent));
+}
+function entriesForArtifactNames(entries) {
+    const selected = new Set();
+    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) {
+    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) {
+    const match = body.match(/<!-- activity-recovery:v1:([A-Za-z0-9_-]+) -->/);
+    if (!match)
+        return null;
+    let value;
+    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;
+    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, taskId: record.taskId, ...(record.artifact ? { artifact: record.artifact } : {}), entries: record.entries };
+    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 };
+//# sourceMappingURL=activity-recovery.js.map

package/dist/lib/platform/issue-comments.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { parseTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { resolvePlatformProviderContext } from './context.js';
@@ -7,6 +8,8 @@ import { platformResult } from './types.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, unsupportedProviderOperation } from './provider-bridge.js';
 import { resourceIdentityNumber } from './resource-identity.js';
 import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.js';
+import { recordForArtifact, recordForCancel, recordForSummary, recordForTask, renderActivityRecoveryMetadata } from './activity-recovery.js';
+import { projectTaskComment } from './task-comment-projection.js';
 import { canonicalizeCommentBody, escapeHtmlText, fenceRanges, renderSafeCodeFence } from './comment-safety.js';
 function providerCommentId(id, provider) {
     return provider.identity?.comment === 'number' && /^\d+$/.test(id) ? Number(id) : id;
@@ -16,7 +19,7 @@ const MARKERS = {
     artifact: (taskId, stem) => `<!-- sync-issue:${taskId}:${stem} -->`,
     artifactChunk: (taskId, stem, part, total) => `<!-- sync-issue:${taskId}:${stem}:${part}/${total} -->`,
     summary: (taskId) => `<!-- sync-issue:${taskId}:summary -->`,
-    cancel: (taskId) => `<!-- sync-issue:${taskId}:cancel -->`
+    cancel: (taskId) => `<!-- sync-issue:${taskId}:cancel -->`,
 };
 const COMMENT_BYTE_LIMIT = 60_000;
 const ARTIFACT_TITLES = {
@@ -33,9 +36,6 @@ const ARTIFACT_TITLES = {
 function normalizeCommentContent(content) {
     return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
 }
-function isTaskCommentTooLarge(content) {
-    return Buffer.byteLength(content, 'utf8') > COMMENT_BYTE_LIMIT;
-}
 function splitFrontmatter(content) {
     const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
     if (!match)
@@ -51,22 +51,52 @@ function sanitizeCommentBody(value, label) {
 function footer(agent, taskId) {
     return `---\n*由 ${agent} 自动生成 · 内部追踪：${taskId}*`;
 }
-function renderTaskComment(content, taskId, agent) {
+function taskFrontmatterSummary(language = '') {
+    return language === 'en' || language === 'en-US'
+        ? 'Metadata (frontmatter)'
+        : '元数据 (frontmatter)';
+}
+function renderTaskCommentResult(content, taskId, language = '') {
     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, taskId, _agent, language = '') {
+    return renderTaskCommentResult(content, taskId, language).body;
+}
+function isTaskCommentTooLarge(content, taskId = 'TASK-UNKNOWN', _agent = 'codex') {
+    return renderTaskCommentResult(content, taskId).byteLength > COMMENT_BYTE_LIMIT;
+}
+function taskCommentLanguage(repoRoot) {
+    try {
+        const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+        return typeof config.language === 'string' ? config.language.trim() : '';
+    }
+    catch {
+        return '';
+    }
 }
 function artifactIdentity(artifact) {
     const stem = path.basename(artifact, '.md');
@@ -205,7 +235,7 @@ function independentChunkContent(piece, fences, maxBytes) {
     }
     return content;
 }
-function buildArtifactChunk(taskId, stem, title, agent, content, part, total, chunked, backfill, renderedContent = content) {
+function buildArtifactChunk(taskId, stem, title, agent, content, part, total, chunked, backfill, renderedContent = content, recoveryMetadata = '') {
     const marker = chunked ? MARKERS.artifactChunk(taskId, stem, part, total) : MARKERS.artifact(taskId, stem);
     const heading = chunked ? `## ${title}（${part}/${total}）` : `## ${title}`;
     const timelineHint = backfill ? '> 历史产物补发' : null;
@@ -216,6 +246,7 @@ function buildArtifactChunk(taskId, stem, title, agent, content, part, total, ch
         '',
         `> **${agent}** · ${taskId}`,
         '',
+        ...(recoveryMetadata ? [recoveryMetadata] : []),
         renderedContent,
         '',
         footer(agent, taskId)
@@ -226,7 +257,7 @@ function chunkArtifactComment(input) {
     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));
+    const single = buildArtifactChunk(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];
     let total = 2;
@@ -235,7 +266,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));
+        const probe = buildArtifactChunk(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);
         if (sourceLimit <= 0)
@@ -245,7 +276,7 @@ function chunkArtifactComment(input) {
             total = pieces.length;
             continue;
         }
-        const chunks = pieces.map((piece, index) => buildArtifactChunk(input.taskId, identity.stem, identity.title, input.agent, piece.content, index + 1, total, true, Boolean(input.backfill), independentChunkContent(piece, ranges.value, sourceLimit)));
+        const chunks = pieces.map((piece, index) => buildArtifactChunk(input.taskId, identity.stem, identity.title, input.agent, piece.content, index + 1, total, true, Boolean(input.backfill), 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;
@@ -276,9 +307,11 @@ function contextFields(context) {
 function hasResolvedPlatformContext(context) {
     return context.status === 'degraded' || (context.status === 'no-op' && context.error === null);
 }
-function bodyEnvelope(marker, title, taskId, agent, body) {
+function bodyEnvelope(marker, title, taskId, agent, body, recoveryMetadata = '') {
     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'));
 }
 function resolveArtifactBody(taskDir, artifact) {
@@ -295,9 +328,9 @@ function resolveArtifactBody(taskDir, artifact) {
         throw new Error('artifact must stay inside the task directory');
     return fs.readFileSync(realArtifact, 'utf8');
 }
-function expectedComments(taskId, taskContent, taskDir, options) {
+function expectedComments(taskId, taskContent, taskDir, repoRoot, options) {
     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') {
@@ -308,14 +341,18 @@ function expectedComments(taskId, taskContent, taskDir, options) {
             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 }];
 }
 function markerPrefix(taskId, options) {
@@ -383,16 +420,9 @@ async function syncPlatformComment(taskRef, options) {
             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;
     try {
-        desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, options);
+        desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, resolved.repoRoot, options);
     }
     catch (error) {
         return platformResult('failed', {
@@ -400,6 +430,13 @@ async function syncPlatformComment(taskRef, options) {
             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)
@@ -430,6 +467,20 @@ async function syncPlatformComment(taskRef, options) {
             error: { code: 'COMMENT_MARKER_CONFLICT', message: 'Multiple comments use the same registered marker', retryable: false }
         });
     }
+    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) => ({
@@ -505,14 +556,15 @@ async function syncPlatformComment(taskRef, options) {
         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, cwd = process.cwd(), client) {
     const loaded = await resolvePlatformProviderContext({ cwd, client });
@@ -578,5 +630,5 @@ async function checkPlatformCommentOwner(taskRef, options = {}) {
     }
     return platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentity), identity: issueIdentity }, error: null });
 }
-export { COMMENT_BYTE_LIMIT, MARKERS, chunkArtifactComment, findMarkerComments, listRemoteComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, isTaskCommentTooLarge, syncPlatformComment, validateRelatedMarkerSet, writeComment };
+export { COMMENT_BYTE_LIMIT, MARKERS, chunkArtifactComment, findMarkerComments, listRemoteComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, renderTaskCommentResult, isTaskCommentTooLarge, syncPlatformComment, validateRelatedMarkerSet, writeComment };
 //# sourceMappingURL=issue-comments.js.map

package/dist/lib/platform/task-comment-projection.js

@@ -0,0 +1,70 @@
+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'
+]);
+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) {
+    return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+function splitFrontmatter(content) {
+    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) {
+    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) {
+    const lines = body.replace(/\r\n/g, '\n').split('\n');
+    const kept = [];
+    let excludedLevel = 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) {
+    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 };
+//# sourceMappingURL=task-comment-projection.js.map

package/dist/lib/platform/task-recovery.js

@@ -0,0 +1,55 @@
+import { parseActivityRecoveryMetadata } from './activity-recovery.js';
+function normalized(body) {
+    return body.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+function decodeRenderedText(value) {
+    return value
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function taskSnapshot(taskId, body) {
+    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) {
+    return `- ${entry.time} — **${entry.step}** by ${entry.agent} — ${entry.note}`;
+}
+function recoverTaskFromComments(input) {
+    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();
+    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 };
+//# sourceMappingURL=task-recovery.js.map

package/dist/lib/platform/verification-sync.js

@@ -10,7 +10,7 @@ import { planInLabelUpdate, validateInLabelMapping } from "./in-label-sync.js";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
 import { providerError, providerOperationContext, resourceIdentityNumber, unsupportedProviderOperation } from "./provider-bridge.js";
 import { taskIssueIdentity } from "./task-identities.js";
-import { isTaskCommentTooLarge } from "./issue-comments.js";
+import { renderTaskCommentResult } from "./issue-comments.js";
 import { CONTROL_MARKER_PATTERN, canonicalizeCommentBody, renderSafeCodeFence, sanitizeMarkdownDocument } from "./comment-safety.js";
 const CHECK_TYPE = "platform-sync";
 const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
@@ -428,19 +428,22 @@ function checkTaskCommentContent(context, remoteData, shared) {
     if (!context.config.verify_task_comment_content) {
         return null;
     }
-    if (isTaskCommentTooLarge(context.task.content)) {
-        return null;
-    }
     const taskMarker = `<!-- sync-issue:${context.task.metadata.id}:task -->`;
     const comment = findCommentByMarker(remoteData.comments, taskMarker);
     if (!comment) {
         return shared.failResult(CHECK_TYPE, `Expected comment marker '${taskMarker}' not found on Issue #${context.issueNumber}`, "check_failed");
     }
-    const expectedTaskBody = buildExpectedTaskBody(context.task.content, shared);
-    if (expectedTaskBody === null) {
+    let renderedTask;
+    try {
+        renderedTask = renderTaskCommentResult(context.task.content, context.task.metadata.id, loadProjectLanguage(shared));
+    }
+    catch {
         return shared.failResult(CHECK_TYPE, "Task content cannot be rendered safely for comment verification", "check_failed");
     }
-    const expectedBody = shared.normalizeContent(expectedTaskBody);
+    if (renderedTask.byteLength > 60_000) {
+        return shared.failResult(CHECK_TYPE, "Task comment exceeds the platform byte limit", "check_failed");
+    }
+    const expectedBody = shared.normalizeContent(extractCommentBody(renderedTask.body));
     const commentBody = shared.normalizeContent(extractCommentBody(comment.body || ""));
     if (expectedBody === commentBody) {
         return null;
@@ -612,12 +615,21 @@ function extractCommentBody(commentBody) {
     while (start < lines.length && lines[start].trim() === "") {
         start += 1;
     }
-    if (start < lines.length && /^> \*\*.+\*\* · .+$/.test(lines[start].trim())) {
+    if (start < lines.length && (/^> \*\*.+\*\* · .+$/.test(lines[start].trim()) || /^> 任务同步 · .+$/.test(lines[start].trim()))) {
         start += 1;
     }
     while (start < lines.length && lines[start].trim() === "") {
         start += 1;
     }
+    if (lines[start]?.trim() === "<details><summary>恢复元数据</summary>") {
+        const metadataEnd = lines.indexOf("</details>", start + 1);
+        if (metadataEnd >= 0) {
+            start = metadataEnd + 1;
+            while (start < lines.length && lines[start].trim() === "") {
+                start += 1;
+            }
+        }
+    }
     let end = lines.length;
     for (let index = lines.length - 1; index >= start; index -= 1) {
         const trimmed = lines[index].trim();
@@ -789,7 +801,9 @@ function computeExpectedInLabels(taskDir, repositoryLabels, mappingOverride, sha
     if (!baseRef) {
         return { ok: false, type: "check_failed", message: "Task has no delivery_base_ref for in-label evidence" };
     }
-    const changedFilesResult = gitText(["diff", `${baseRef}...HEAD`, "--name-only"], taskDir);
+    const branch = typeof task.metadata?.branch === "string" ? task.metadata.branch.trim() : "";
+    const gitCwd = branch ? worktreeForBranch(shared.repoRoot, branch) ?? taskDir : taskDir;
+    const changedFilesResult = gitText(["diff", `${baseRef}...HEAD`, "--name-only"], gitCwd);
     if (!changedFilesResult.ok) {
         return { ...changedFilesResult, type: "network_error" };
     }
@@ -812,6 +826,26 @@ function computeExpectedInLabels(taskDir, repositoryLabels, mappingOverride, sha
     }
     return { ok: true, labels: planned.target, mode: "mapped" };
 }
+function worktreeForBranch(repositoryRoot, branch) {
+    try {
+        const records = execFileSync("git", ["worktree", "list", "--porcelain"], {
+            cwd: repositoryRoot,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"]
+        }).trim().split(/\r?\n\r?\n/);
+        const expectedRef = `refs/heads/${branch}`;
+        for (const record of records) {
+            const worktree = /^worktree (.+)$/m.exec(record)?.[1];
+            const branchRef = /^branch (.+)$/m.exec(record)?.[1];
+            if (worktree && branchRef === expectedRef)
+                return worktree;
+        }
+    }
+    catch {
+        // Fall back to taskDir so ordinary in-repository task workspaces retain their behavior.
+    }
+    return null;
+}
 function loadInLabelMapping(shared) {
     const configPath = path.join(shared.repoRoot, ".agents", ".airc.json");
     if (!fs.existsSync(configPath)) {