@fitlab-ai/agent-infra 0.9.15 → 0.11.0

package/dist/lib/internal/task-review.js

@@ -1,15 +1,15 @@
 import { parseReviewCommand } from '../task/review-command.js';
-import { finalizeReviewSummary } from '../task/review-finalization.js';
+import { finalizeReviewSummary, preflightReviewSummary } from '../task/review-finalization.js';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--recovery-id <id>] [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
         changed: false,
-        intent: 'finalize-summary',
+        intent: 'review-operation',
         error: { code: 'REVIEW_PAYLOAD_INVALID', message }
     })}\n`);
     process.stderr.write(USAGE);
@@ -30,7 +30,8 @@ async function taskReview(args = []) {
         failUsage(error instanceof Error ? error.message : String(error));
         return;
     }
-    const { stage, artifact, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
+    const { stage, artifact, recoveryId, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
+    const operation = args[1];
     const dryRunConflict = overrideDryRunConflict({ dryRun, overrideTicket, overrideTarget, overrideScope });
     if (dryRunConflict) {
         failUsage(dryRunConflict.message);
@@ -44,8 +45,12 @@ async function taskReview(args = []) {
     let result;
     let humanOverride = null;
     try {
-        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', async () => {
-            let current = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
+        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-review.${operation}`, async () => {
+            let current = operation === 'preflight'
+                ? preflightReviewSummary({ taskRef: args[0], stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true })
+                : finalizeReviewSummary({ taskRef: args[0], stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true });
+            if (operation === 'preflight')
+                return current;
             if (current.status !== 'failed' || !overrideTicket)
                 return current;
             if (!overrideTarget || !overrideScope) {
@@ -58,7 +63,7 @@ async function taskReview(args = []) {
                 target: overrideTarget, scope: overrideScope
             }, {
                 effectExecutor: (capability) => {
-                    const retried = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true, manualOverride: capability });
+                    const retried = finalizeReviewSummary({ taskRef: args[0], stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true, manualOverride: capability });
                     current = retried;
                     return retried.status === 'failed' || retried.status === 'planned'
                         ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no review effect was committed' : `${retried.error?.code ?? 'REVIEW_FAILED'}: ${retried.error?.message ?? 'manual review effect failed'}` }

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,8 +19,9 @@ 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 = {
     analysis: '需求分析',
     'review-analysis': '需求分析审查',
@@ -47,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');
@@ -201,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;
@@ -212,6 +246,7 @@ function buildArtifactChunk(taskId, stem, title, agent, content, part, total, ch
         '',
         `> **${agent}** · ${taskId}`,
         '',
+        ...(recoveryMetadata ? [recoveryMetadata] : []),
         renderedContent,
         '',
         footer(agent, taskId)
@@ -219,10 +254,10 @@ function buildArtifactChunk(taskId, stem, title, agent, content, part, total, ch
     return { marker, body, content, part, total };
 }
 function chunkArtifactComment(input) {
-    const byteLimit = input.byteLimit || 60_000;
+    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;
@@ -231,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)
@@ -241,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;
@@ -257,11 +292,6 @@ function flattenComments(value) {
     const flattened = value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]);
     return flattened.filter((entry) => Boolean(entry && typeof entry === 'object' && (typeof entry.id === 'number' || typeof entry.id === 'string') && typeof entry.body === 'string'));
 }
-function issueNumberFromTask(content) {
-    const value = parseTaskFrontmatter(content).issue_number;
-    const number = Number(value);
-    return Number.isInteger(number) && number > 0 ? number : null;
-}
 function listRemoteComments(client, repo, issue, cwd) {
     const result = client.json([
         'api', '--paginate', '--slurp', `repos/${repo}/issues/${issue}/comments?per_page=100`
@@ -277,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) {
@@ -296,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') {
@@ -309,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) {
@@ -374,19 +410,19 @@ async function syncPlatformComment(taskRef, options) {
     const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
     let issueIdentityFromTask;
     try {
-        issueIdentityFromTask = taskIssueIdentity(parseTaskFrontmatter(taskContent), undefined, options.runtimeVersion);
+        issueIdentityFromTask = taskIssueIdentity(parseTaskFrontmatter(taskContent));
     }
     catch (error) {
         return platformResult('failed', { error: { ...taskIssueIdentityError(error), retryable: false } });
     }
     if (!issueIdentityFromTask) {
         return platformResult('no-op', {
-            error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+            error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false }
         });
     }
     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', {
@@ -394,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)
@@ -424,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) => ({
@@ -499,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 });
@@ -541,7 +599,7 @@ async function checkPlatformCommentOwner(taskRef, options = {}) {
     const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
     let issueIdentity;
     try {
-        issueIdentity = taskIssueIdentity(parseTaskFrontmatter(content), undefined, options.runtimeVersion);
+        issueIdentity = taskIssueIdentity(parseTaskFrontmatter(content));
     }
     catch (error) {
         return platformResult('failed', { error: { ...taskIssueIdentityError(error), retryable: false } });
@@ -572,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 { MARKERS, chunkArtifactComment, findMarkerComments, listRemoteComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, 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/issues.js

@@ -32,7 +32,7 @@ async function resolvedContext(taskRef, options) {
     const frontmatter = parseTaskFrontmatter(content);
     let issueIdentity;
     try {
-        issueIdentity = taskIssueIdentity(frontmatter, undefined, options.runtimeVersion);
+        issueIdentity = taskIssueIdentity(frontmatter);
     }
     catch (error) {
         return { ok: false, output: result('failed', resolved.taskId, null, { error: { ...taskIssueIdentityError(error), retryable: false } }) };

package/dist/lib/platform/pr-change-report.js

@@ -3,8 +3,9 @@ import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { escapeHtmlText } from './comment-safety.js';
+import { isResourceIdentity } from './resource-identity.js';
 const REPORT_FILE_NAME = 'pr-change-report.json';
-const REPORT_VERSION = 1;
+const REPORT_VERSION = 2;
 const CANONICAL_REPORT_PLACEHOLDER = '<!-- canonical-pr-change-report -->';
 const CANONICAL_REPORT_HEADING = '### PR 代码增减';
 const PRECHECK_IDS = [
@@ -211,8 +212,8 @@ function validatePrChangeReport(value) {
     }
     const identity = value.identity;
     const identityRepository = identity.repository;
-    const identityNumber = identity.number;
-    if (!isNonEmptyString(identityRepository) || typeof identityNumber !== 'number' || !Number.isSafeInteger(identityNumber) || identityNumber <= 0)
+    const identityResource = identity.resource;
+    if (!isNonEmptyString(identityRepository) || !isResourceIdentity(identityResource))
         return invalid('change report identity is invalid');
     const parseIdentityPart = (part, name) => {
         if (!isRecord(part) || !isNonEmptyString(part.repository) || !isNonEmptyString(part.ref) || !isSha(part.sha))
@@ -259,7 +260,7 @@ function validatePrChangeReport(value) {
             version: REPORT_VERSION,
             identity: {
                 repository: identityRepository,
-                number: identityNumber,
+                resource: identityResource,
                 base: base.value,
                 head: head.value
             },