@fitlab-ai/agent-infra 0.9.13 → 0.9.14

package/lib/platform/github-provider.ts

@@ -16,8 +16,11 @@ import type {
   CheckRunSnapshot,
   GitEvidenceSnapshot,
   IssueSnapshot,
+  LabelReconciliation,
   MutationReceipt,
+  MilestoneInitialization,
   PlatformContextSnapshot,
+  PlatformError,
   ProviderOperationContext,
   PlatformProvider,
   PlatformProviderFactoryInput,
@@ -29,14 +32,17 @@ import type {
   RemoteCommentSnapshot,
   RequiredCheckSnapshot,
   ReviewSnapshot,
+  SecurityAlertKind,
+  SecurityAlertSnapshot,
   VerificationRemoteFacts
 } from './provider-contract.ts';
 import { resourceIdentityNumber, resourceIdentityString } from './resource-identity.ts';
-import { syncLabelDelta } from './in-label-sync.ts';
+import { extractPullRequestFileNames, syncLabelDelta } from './in-label-sync.ts';
 
 const CURRENT_USER_QUERY = 'query { viewer { login } }';
 const ISSUE_TYPES_QUERY = `query($owner:String!){organization(login:$owner){issueTypes(first:20){nodes{id name pinnedFields{__typename ... on IssueFieldSingleSelect{id name options{id name}} ... on IssueFieldDate{id name} ... on IssueFieldText{id name} ... on IssueFieldNumber{id name}}}}}}`;
 const ISSUE_FIELDS_QUERY = `query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){issue(number:$number){id issueType{id name pinnedFields{__typename ... on IssueFieldSingleSelect{id name options{id name}} ... on IssueFieldDate{id name} ... on IssueFieldText{id name} ... on IssueFieldNumber{id name}}} issueFieldValues(first:50){nodes{__typename ... on IssueFieldSingleSelectValue{name optionId field{... on IssueFieldSingleSelect{id name}}} ... on IssueFieldDateValue{value field{... on IssueFieldDate{id name}}} ... on IssueFieldTextValue{value field{... on IssueFieldText{id name}}} ... on IssueFieldNumberValue{value field{... on IssueFieldNumber{id name}}}}}}}}`;
+const CLOSING_ISSUES_QUERY = 'query($owner:String!,$name:String!,$number:Int!,$cursor:String){repository(owner:$owner,name:$name){pullRequest(number:$number){closingIssuesReferences(first:100,after:$cursor){nodes{number} pageInfo{hasNextPage endCursor}}}}}';
 
 function parseGitHubRemote(remote: string): string | null {
   const trimmed = remote.trim().replace(/\.git$/, '');
@@ -340,6 +346,29 @@ function createReceipt(remoteId: string): ProviderResult<MutationReceipt> {
   return { ok: true, value: { changed: true, remoteId } };
 }
 
+function partialFailure<T>(response: { ok: false; error: PlatformError }, value: T): ProviderResult<T> {
+  return { ok: false, error: response.error, value };
+}
+
+function labelReconciliation(
+  created: string[],
+  updated: string[],
+  removed: string[],
+  skipped: string[]
+): LabelReconciliation {
+  return {
+    changed: created.length > 0 || updated.length > 0 || removed.length > 0,
+    created,
+    updated,
+    removed,
+    skipped
+  };
+}
+
+function milestoneInitialization(created: string[], skipped: string[]): MilestoneInitialization {
+  return { changed: created.length > 0, created, skipped };
+}
+
 function githubResourceToken(identity: ResourceIdentity | null | undefined): string | null {
   return resourceIdentityString(identity) || (identity?.kind === 'number' ? String(identity.value) : null);
 }
@@ -371,7 +400,7 @@ function syncLabels(
   return { status: changed ? 'applied' as const : 'no-op' as const, changed, error: null };
 }
 
-function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'issues' | 'comments' | 'changeRequests' | 'checks' | 'reviews' | 'releases' | 'verification'> {
+function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'issues' | 'comments' | 'changeRequests' | 'checks' | 'reviews' | 'releases' | 'securityAlerts' | 'repositoryMetadata' | 'verification'> {
   const issues: NonNullable<PlatformProvider['issues']> = {
     async listLabels({ context }) {
       const response = client.json<any>(['api', '--paginate', '--slurp', `repos/${repository(context)}/labels?per_page=100`], { cwd: context.workingDirectory });
@@ -443,6 +472,19 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
       return { ok: true, value: issueSnapshot(fetched.value, graph || undefined) };
     },
     async create({ context, desired }) {
+      let milestone: number | null = null;
+      if (desired.milestone) {
+        const milestones = client.json<any>(['api', '--paginate', '--slurp', `repos/${repository(context)}/milestones?state=open&per_page=100`], { cwd: context.workingDirectory });
+        if (!milestones.ok) return milestones;
+        const values = Array.isArray(milestones.value)
+          ? milestones.value.flatMap((entry: any) => Array.isArray(entry) ? entry : [entry])
+          : [];
+        const selected = values.find((item: any) => item?.title === desired.milestone);
+        if (!Number.isSafeInteger(selected?.number) || selected.number <= 0) {
+          return invalid('MILESTONE_IDENTITY_INVALID', 'Milestone title does not resolve to a positive number');
+        }
+        milestone = selected.number;
+      }
       const response = client.json<any>(['api', `repos/${repository(context)}/issues`, '-X', 'POST', '--input', '-'], {
         cwd: context.workingDirectory,
         method: 'POST',
@@ -451,7 +493,7 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
           body: desired.body,
           labels: desired.labels,
           assignees: desired.assignees,
-          ...(desired.milestone ? { milestone: desired.milestone } : {})
+          ...(milestone ? { milestone } : {})
         })
       });
       if (!response.ok) return response;
@@ -611,6 +653,58 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
       if (!fetched.ok) return fetched;
       return { ok: true, value: changeRequestSnapshot(fetched.value) };
     },
+    async listFiles({ context, target }) {
+      const number = resourceIdentityNumber(target);
+      if (!number) return invalid('PR_NUMBER_INVALID', 'Pull request number must be positive');
+      const response = client.json<unknown>(['api', '--paginate', '--slurp', `repos/${repository(context)}/pulls/${number}/files?per_page=100`], { cwd: context.workingDirectory });
+      if (!response.ok) return response;
+      const files = extractPullRequestFileNames(response.value);
+      return files
+        ? { ok: true, value: files }
+        : invalid('IN_LABEL_SYNC_FILES_INVALID', 'Pull request files response is incomplete');
+    },
+    async listClosingIssues({ context, target }) {
+      const number = resourceIdentityNumber(target);
+      if (!number) return invalid('PR_NUMBER_INVALID', 'Pull request number must be positive');
+      const [owner, name] = repository(context).split('/');
+      if (!owner || !name) return invalid('IN_LABEL_SYNC_REPOSITORY_INVALID', 'Repository identity is invalid');
+      const identities: ResourceIdentity[] = [];
+      let cursor: string | null = null;
+      for (;;) {
+        const args = ['api', 'graphql', '-f', `query=${CLOSING_ISSUES_QUERY}`, '-F', `owner=${owner}`, '-F', `name=${name}`, '-F', `number=${number}`];
+        if (cursor) args.push('-F', `cursor=${cursor}`);
+        const response = client.json<unknown>(args, { cwd: context.workingDirectory });
+        if (!response.ok) return response;
+        const connection = (response.value as {
+          data?: { repository?: { pullRequest?: { closingIssuesReferences?: {
+            nodes?: unknown[]; pageInfo?: { hasNextPage?: boolean; endCursor?: string | null };
+          } } } };
+        })?.data?.repository?.pullRequest?.closingIssuesReferences;
+        if (!connection || !Array.isArray(connection.nodes) || !connection.pageInfo) {
+          return invalid('IN_LABEL_SYNC_ASSOCIATION_INVALID', 'Closing Issue response is incomplete');
+        }
+        for (const node of connection.nodes) {
+          const issue = Number((node as { number?: unknown })?.number);
+          if (!Number.isSafeInteger(issue) || issue <= 0) {
+            return invalid('IN_LABEL_SYNC_ASSOCIATION_INVALID', 'Closing Issue identity is invalid');
+          }
+          identities.push({ kind: 'number', value: issue });
+        }
+        if (!connection.pageInfo.hasNextPage) {
+          const seen = new Set<string>();
+          return { ok: true, value: identities.filter((identity) => {
+            const key = `${identity.kind}:${identity.value}`;
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+          }) };
+        }
+        if (!connection.pageInfo.endCursor || connection.pageInfo.endCursor === cursor) {
+          return invalid('IN_LABEL_SYNC_ASSOCIATION_INVALID', 'Closing Issue pagination cursor is invalid');
+        }
+        cursor = connection.pageInfo.endCursor;
+      }
+    },
     async listClosing({ context, issue }) {
       const number = resourceIdentityNumber(issue);
       if (!number) return invalid('ISSUE_NUMBER_INVALID', 'Issue number must be positive');
@@ -854,20 +948,148 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
     }
   };
 
+  const securityAlerts: NonNullable<PlatformProvider['securityAlerts']> = {
+    async inspect({ context, kind, number }): Promise<ProviderResult<SecurityAlertSnapshot>> {
+      if (!Number.isSafeInteger(number) || number <= 0) return invalid('SECURITY_NUMBER_INVALID', 'Alert number must be a positive integer');
+      const suffix = kind === 'dependabot' ? 'dependabot' : kind === 'code-scanning' ? 'code-scanning' : null;
+      if (!suffix) return invalid('SECURITY_KIND_INVALID', 'Alert kind is invalid');
+      const response = client.json<any>(['api', `repos/${repository(context)}/${suffix}/alerts/${number}`], { cwd: context.workingDirectory });
+      if (!response.ok) return response;
+      const data = response.value;
+      if (!data || typeof data !== 'object' || Array.isArray(data)) return invalid('SECURITY_RESPONSE_INVALID', 'The platform returned an invalid security alert');
+      const value: SecurityAlertSnapshot = {
+        kind,
+        number,
+        state: typeof data.state === 'string' ? data.state : 'invalid',
+        data
+      };
+      return { ok: true, value };
+    },
+    async dismiss({ context, kind, number, reason, comment }): Promise<ProviderResult<MutationReceipt>> {
+      const suffix = kind === 'dependabot' ? 'dependabot' : kind === 'code-scanning' ? 'code-scanning' : null;
+      if (!suffix) return invalid('SECURITY_KIND_INVALID', 'Alert kind is invalid');
+      if (!Number.isSafeInteger(number) || number <= 0) return invalid('SECURITY_NUMBER_INVALID', 'Alert number must be a positive integer');
+      const response = client.json<any>(['api', `repos/${repository(context)}/${suffix}/alerts/${number}`, '-X', 'PATCH', '--input', '-'], {
+        cwd: context.workingDirectory,
+        method: 'PATCH',
+        input: JSON.stringify({ state: 'dismissed', dismissed_reason: reason, dismissed_comment: comment })
+      });
+      if (!response.ok) return response;
+      return createReceipt(String(response.value?.id || `${kind}:${number}`));
+    }
+  };
+
+  const repositoryMetadata: NonNullable<PlatformProvider['repositoryMetadata']> = {
+    async reconcileLabels({ context, desired, cleanupStaleIn }): Promise<ProviderResult<LabelReconciliation>> {
+      const endpoint = `repos/${repository(context)}/labels?per_page=100`;
+      const listed = client.json<any>(['api', '--paginate', '--slurp', endpoint], { cwd: context.workingDirectory });
+      if (!listed.ok) return listed;
+      if (!Array.isArray(listed.value)) return invalid('LABEL_RESPONSE_INVALID', 'The platform returned an invalid label list');
+      const values = Array.isArray(listed.value)
+        ? listed.value.flatMap((entry: any) => Array.isArray(entry) ? entry : [entry])
+        : [];
+      if (values.some((entry: any) => !entry || typeof entry.name !== 'string' || !entry.name)) {
+        return invalid('LABEL_RESPONSE_INVALID', 'The platform returned a label without a valid name');
+      }
+      const current = new Map<string, any>(values.map((entry: any) => [String(entry.name), entry]));
+      const created: string[] = [];
+      const updated: string[] = [];
+      const skipped: string[] = [];
+      const removed: string[] = [];
+      for (const label of desired) {
+        const existing = current.get(label.name);
+        if (!existing) {
+          const response = client.json(['api', `repos/${repository(context)}/labels`, '-X', 'POST', '--input', '-'], {
+            cwd: context.workingDirectory,
+            method: 'POST',
+            input: JSON.stringify({ name: label.name, color: label.color, description: label.description })
+          });
+          if (!response.ok) return partialFailure(response, labelReconciliation(created, updated, removed, skipped));
+          created.push(label.name);
+          continue;
+        }
+        const sameColor = typeof existing.color === 'string' && existing.color.toUpperCase() === label.color.toUpperCase();
+        const sameDescription = String(existing.description || '') === label.description;
+        if (sameColor && sameDescription) {
+          skipped.push(label.name);
+          continue;
+        }
+        const response = client.json(['api', `repos/${repository(context)}/labels/${encodeURIComponent(label.name)}`, '-X', 'PATCH', '--input', '-'], {
+          cwd: context.workingDirectory,
+          method: 'PATCH',
+          input: JSON.stringify({ new_name: label.name, color: label.color, description: label.description })
+        });
+        if (!response.ok) return partialFailure(response, labelReconciliation(created, updated, removed, skipped));
+        updated.push(label.name);
+      }
+      const desiredNames = new Set(desired.map((label) => label.name));
+      if (cleanupStaleIn) {
+        for (const name of current.keys()) {
+          if (!name.startsWith('in:') || desiredNames.has(name)) continue;
+          const response = client.text(['api', `repos/${repository(context)}/labels/${encodeURIComponent(name)}`, '-X', 'DELETE'], {
+            cwd: context.workingDirectory,
+            method: 'DELETE'
+          });
+          if (!response.ok) return partialFailure(response, labelReconciliation(created, updated, removed, skipped));
+          removed.push(name);
+        }
+      }
+      return {
+        ok: true,
+        value: {
+          changed: created.length > 0 || updated.length > 0 || removed.length > 0,
+          created,
+          updated,
+          removed,
+          skipped
+        }
+      };
+    },
+    async reconcileMilestones({ context, desired }): Promise<ProviderResult<MilestoneInitialization>> {
+      const listed = client.json<any>(['api', '--paginate', '--slurp', `repos/${repository(context)}/milestones?state=all&per_page=100`], { cwd: context.workingDirectory });
+      if (!listed.ok) return listed;
+      if (!Array.isArray(listed.value)) return invalid('MILESTONE_RESPONSE_INVALID', 'The platform returned an invalid milestone list');
+      const values = Array.isArray(listed.value)
+        ? listed.value.flatMap((entry: any) => Array.isArray(entry) ? entry : [entry])
+        : [];
+      if (values.some((entry: any) => !entry || typeof entry.title !== 'string' || !entry.title)) {
+        return invalid('MILESTONE_RESPONSE_INVALID', 'The platform returned a milestone without a valid title');
+      }
+      const existing = new Set(values.map((entry: any) => String(entry.title)));
+      const created: string[] = [];
+      const skipped: string[] = [];
+      for (const milestone of desired) {
+        if (existing.has(milestone.title)) {
+          skipped.push(milestone.title);
+          continue;
+        }
+        const response = client.json(['api', `repos/${repository(context)}/milestones`, '-X', 'POST', '--input', '-'], {
+          cwd: context.workingDirectory,
+          method: 'POST',
+          input: JSON.stringify({ title: milestone.title, description: milestone.description, state: milestone.state })
+        });
+        if (!response.ok) return partialFailure(response, milestoneInitialization(created, skipped));
+        existing.add(milestone.title);
+        created.push(milestone.title);
+      }
+      return { ok: true, value: { changed: created.length > 0, created, skipped } };
+    }
+  };
+
   const verification: NonNullable<PlatformProvider['verification']> = {
     async fetchRemoteFacts(input) {
       const issue = input.issue && issues.inspect
         ? await issues.inspect({ context: input.context, target: input.issue })
         : { ok: true as const, value: null };
-      if (!issue.ok) return issue;
+      if (!issue.ok) return { ok: false, error: issue.error };
       const commentFacts = input.includeComments && input.issue && comments.list
         ? await comments.list({ context: input.context, parent: input.issue })
         : { ok: true as const, value: [] as RemoteCommentSnapshot[] };
-      if (!commentFacts.ok) return commentFacts;
+      if (!commentFacts.ok) return { ok: false, error: commentFacts.error };
       const changeRequest = input.changeRequest && changeRequests.inspect
         ? await changeRequests.inspect({ context: input.context, target: input.changeRequest })
         : { ok: true as const, value: null };
-      if (!changeRequest.ok) return changeRequest;
+      if (!changeRequest.ok) return { ok: false, error: changeRequest.error };
       return {
         ok: true,
         value: {
@@ -881,7 +1103,7 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
     }
   };
 
-  return { issues, comments, changeRequests, checks, reviews, releases, verification };
+  return { issues, comments, changeRequests, checks, reviews, releases, securityAlerts, repositoryMetadata, verification };
 }
 
 function createGitHubProvider(

package/lib/platform/issue-comments.ts

@@ -16,6 +16,14 @@ import {
 } from './provider-bridge.ts';
 import { resourceIdentityNumber } from './resource-identity.ts';
 import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.ts';
+import {
+  CONTROL_MARKER_PATTERN,
+  escapeHtmlText,
+  fenceRanges,
+  renderSafeCodeFence,
+  sanitizeMarkdownDocument
+} from './comment-safety.ts';
+import type { FenceRange } from './comment-safety.ts';
 
 type RemoteComment = { id: number | string; body: string; user?: { login?: string } };
 type RenderedChunk = { marker: string; body: string; content: string; part: number; total: number };
@@ -66,15 +74,22 @@ function splitFrontmatter(content: string): { frontmatter: string | null; body:
   return { frontmatter: match[1]!, body: content.slice(match[0].length).replace(/^\r?\n/, '') };
 }
 
+function sanitizeCommentBody(value: string, label: string): string {
+  const result = sanitizeMarkdownDocument(value, { reservedMarkers: [CONTROL_MARKER_PATTERN] });
+  if (!result.ok) throw new Error(`${result.error.code}: ${label}: ${result.error.message} at offset ${result.error.offset}`);
+  return result.value;
+}
+
 function footer(agent: string, taskId: string): string {
   return `---\n*由 ${agent} 自动生成 · 内部追踪：${taskId}*`;
 }
 
 function renderTaskComment(content: string, taskId: string, agent: string): string {
   const split = splitFrontmatter(content);
+  const safeBody = sanitizeCommentBody(split.body, 'task body');
   const taskBody = split.frontmatter === null
-    ? split.body
-    : `<details><summary>元数据 (frontmatter)</summary>\n\n\`\`\`yaml\n---\n${split.frontmatter}\n---\n\`\`\`\n\n</details>\n\n${split.body}`;
+    ? safeBody
+    : `<details><summary>元数据 (frontmatter)</summary>\n\n${renderSafeCodeFence(`---\n${split.frontmatter}\n---`, 'yaml')}\n\n</details>\n\n${safeBody}`;
   return normalizeCommentContent([
     MARKERS.task(taskId),
     '## 任务文件',
@@ -96,13 +111,16 @@ function artifactIdentity(artifact: string): { stem: string; title: string } {
   return { stem, title: `${base}（Round ${round}）` };
 }
 
-function chunkByUtf8(content: string, maxBytes: number): string[] {
+type SourceChunk = { content: string; start: number; end: number };
+
+function chunkByUtf8(content: string, maxBytes: number): SourceChunk[] {
   if (maxBytes <= 0) throw new Error('comment byte limit is too small');
-  const chunks: string[] = [];
-  let remaining = content;
-  while (remaining) {
+  const chunks: SourceChunk[] = [];
+  let start = 0;
+  while (start < content.length) {
+    const remaining = content.slice(start);
     if (Buffer.byteLength(remaining, 'utf8') <= maxBytes) {
-      chunks.push(remaining);
+      chunks.push({ content: remaining, start, end: content.length });
       break;
     }
     let bytes = 0;
@@ -117,10 +135,102 @@ function chunkByUtf8(content: string, maxBytes: number): string[] {
     }
     const cut = newlineIndex > 0 ? newlineIndex : index;
     if (cut === 0) throw new Error('comment byte limit cannot fit one Unicode code point');
-    chunks.push(remaining.slice(0, cut));
-    remaining = remaining.slice(cut);
+    chunks.push({ content: remaining.slice(0, cut), start, end: start + cut });
+    start += cut;
   }
-  return chunks.length > 0 ? chunks : [''];
+  return chunks.length > 0 ? chunks : [{ content: '', start: 0, end: 0 }];
+}
+
+function longestFenceLineRun(content: string, character: '`' | '~'): number {
+  const pattern = new RegExp(`^ {0,3}(${character}+)[ \\t]*(?:\\n|$)`, 'gm');
+  let longest = 0;
+  for (const match of content.matchAll(pattern)) longest = Math.max(longest, match[1]!.length);
+  return longest;
+}
+
+function boundedFence(content: string, sourceCharacter: '`' | '~', maxBytes: number): { opening: string; closing: string } | null {
+  const candidates: Array<'`' | '~'> = sourceCharacter === '`' ? ['~', '`'] : ['`', '~'];
+  for (const character of candidates) {
+    const length = Math.max(3, longestFenceLineRun(content, character) + 1);
+    const delimiter = character.repeat(length);
+    if (Buffer.byteLength(delimiter, 'utf8') * 2 + 2 <= maxBytes) return { opening: `${delimiter}\n`, closing: `${delimiter}\n` };
+  }
+  return null;
+}
+
+function sourceSlice(piece: SourceChunk, start: number, end: number): string {
+  return piece.content.slice(Math.max(0, start - piece.start), Math.max(0, end - piece.start));
+}
+
+function renderOversizedFenceChunk(piece: SourceChunk, fences: readonly FenceRange[], maxBytes: number): string {
+  const insertions = new Map<number, Array<{ value: string; ensureLineStart: boolean }>>();
+  const omitted: Array<{ start: number; end: number }> = [];
+  const insert = (position: number, value: string, ensureLineStart = false) => {
+    const values = insertions.get(position) || [];
+    values.push({ value, ensureLineStart });
+    insertions.set(position, values);
+  };
+
+  for (const fence of fences) {
+    if (piece.end <= fence.start || piece.start >= fence.end) continue;
+    const oversized = Buffer.byteLength(fence.opening, 'utf8') > maxBytes
+      || Buffer.byteLength(fence.closing, 'utf8') > maxBytes;
+    if (!oversized) {
+      if (piece.start > fence.start && piece.start < fence.end) insert(piece.start, fence.opening);
+      if (piece.end > fence.start && piece.end < fence.end) insert(piece.end, fence.closing, true);
+      continue;
+    }
+
+    const code = sourceSlice(piece, Math.max(piece.start, fence.openingEnd), Math.min(piece.end, fence.closingStart));
+    const delimiter = boundedFence(code, fence.character, maxBytes);
+    if (!delimiter) return escapeHtmlText(piece.content);
+    insert(Math.max(piece.start, fence.start), delimiter.opening);
+    insert(Math.min(piece.end, fence.end), delimiter.closing, true);
+    const openingStart = Math.max(piece.start, fence.start);
+    const openingEnd = Math.min(piece.end, fence.openingEnd);
+    if (openingStart < openingEnd) omitted.push({ start: openingStart, end: openingEnd });
+    const closingStart = Math.max(piece.start, fence.closingStart);
+    const closingEnd = Math.min(piece.end, fence.end);
+    if (closingStart < closingEnd) omitted.push({ start: closingStart, end: closingEnd });
+  }
+
+  const boundaries = new Set<number>([piece.start, piece.end]);
+  for (const position of insertions.keys()) boundaries.add(position);
+  for (const range of omitted) {
+    boundaries.add(range.start);
+    boundaries.add(range.end);
+  }
+  const points = [...boundaries].sort((left, right) => left - right);
+  let content = '';
+  for (let index = 0; index < points.length; index += 1) {
+    const point = points[index]!;
+    for (const insertion of insertions.get(point) || []) {
+      if (insertion.ensureLineStart && content.length > 0 && !content.endsWith('\n')) content += '\n';
+      content += insertion.value;
+    }
+    const next = points[index + 1];
+    if (next === undefined) continue;
+    const skipped = omitted.some((range) => range.start <= point && next <= range.end);
+    if (!skipped) content += sourceSlice(piece, point, next);
+  }
+  return content;
+}
+
+function independentChunkContent(piece: SourceChunk, fences: readonly FenceRange[], maxBytes: number): string {
+  const oversizedFence = fences.some((fence) =>
+    piece.end > fence.start && piece.start < fence.end
+    && (Buffer.byteLength(fence.opening, 'utf8') > maxBytes || Buffer.byteLength(fence.closing, 'utf8') > maxBytes)
+  );
+  if (oversizedFence) return renderOversizedFenceChunk(piece, fences, maxBytes);
+  const openingFence = fences.find((fence) => piece.start > fence.start && piece.start < fence.end);
+  const closingFence = fences.find((fence) => piece.end > fence.start && piece.end < fence.end);
+  let content = piece.content;
+  if (openingFence) content = openingFence.opening + content;
+  if (closingFence) {
+    if (!content.endsWith('\n')) content += '\n';
+    content += closingFence.closing;
+  }
+  return content;
 }
 
 function buildArtifactChunk(
@@ -132,7 +242,8 @@ function buildArtifactChunk(
   part: number,
   total: number,
   chunked: boolean,
-  backfill: boolean
+  backfill: boolean,
+  renderedContent = content
 ): RenderedChunk {
   const marker = chunked ? MARKERS.artifactChunk(taskId, stem, part, total) : MARKERS.artifact(taskId, stem);
   const heading = chunked ? `## ${title}（${part}/${total}）` : `## ${title}`;
@@ -144,7 +255,7 @@ function buildArtifactChunk(
     '',
     `> **${agent}** · ${taskId}`,
     '',
-    content,
+    renderedContent,
     '',
     footer(agent, taskId)
   ].join('\n'));
@@ -161,29 +272,44 @@ function chunkArtifactComment(input: {
 }): RenderedChunk[] {
   const byteLimit = input.byteLimit || 60_000;
   const identity = artifactIdentity(input.artifact);
+  const safeBody = sanitizeCommentBody(input.body, 'artifact body');
   const single = buildArtifactChunk(
-    input.taskId, identity.stem, identity.title, input.agent, input.body, 1, 1, false, Boolean(input.backfill)
+    input.taskId, identity.stem, identity.title, input.agent, safeBody, 1, 1, false, Boolean(input.backfill)
   );
   if (Buffer.byteLength(single.body, 'utf8') <= byteLimit) return [single];
 
   let total = 2;
-  let pieces: string[] = [];
+  let payloadLimit = Number.POSITIVE_INFINITY;
+  const ranges = fenceRanges(safeBody);
+  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 available = byteLimit - Buffer.byteLength(probe.body, 'utf8');
-    pieces = chunkByUtf8(input.body, available);
-    if (pieces.length === total) break;
-    total = pieces.length;
+    const sourceLimit = Math.min(available, payloadLimit);
+    if (sourceLimit <= 0) throw new Error('comment byte limit is too small for an artifact chunk');
+    const pieces = chunkByUtf8(safeBody, sourceLimit);
+    if (pieces.length !== total) {
+      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 overflow = Math.max(...chunks.map((chunk) => Buffer.byteLength(chunk.body, 'utf8') - byteLimit));
+    if (overflow <= 0) return chunks;
+    payloadLimit = sourceLimit - overflow;
   }
-  return pieces.map((content, index) => {
-    const chunk = buildArtifactChunk(
-      input.taskId, identity.stem, identity.title, input.agent, content, index + 1, total, true, Boolean(input.backfill)
-    );
-    if (Buffer.byteLength(chunk.body, 'utf8') > byteLimit) throw new Error('rendered comment exceeds byte limit');
-    return chunk;
-  });
 }
 
 function findMarkerComments(comments: RemoteComment[], marker: string): RemoteComment[] {
@@ -224,7 +350,7 @@ function hasResolvedPlatformContext(context: PlatformResult): boolean {
 
 function bodyEnvelope(marker: string, title: string, taskId: string, agent: string, body: string): string {
   return normalizeCommentContent([
-    marker, `## ${title}`, '', `> **${agent}** · ${taskId}`, '', body.replace(/\n+$/, ''), '', footer(agent, taskId)
+    marker, `## ${title}`, '', `> **${agent}** · ${taskId}`, '', sanitizeCommentBody(body, `${title} body`).replace(/\n+$/, ''), '', footer(agent, taskId)
   ].join('\n'));
 }
 
@@ -334,6 +460,15 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
       error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
     });
   }
+  let desired: RenderedChunk[];
+  try {
+    desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, 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 }
+    });
+  }
   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;
@@ -356,16 +491,6 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
     });
   }
 
-  let desired: RenderedChunk[];
-  try {
-    desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, options);
-  } catch (error) {
-    return platformResult('failed', {
-      ...contextFields(context),
-      resource: { kind: 'issue', number: issue },
-      error: { code: 'COMMENT_PAYLOAD_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false }
-    });
-  }
   const existing = relatedComments(listed.value, markerPrefix(resolved.taskId, options));
   if (!validateRelatedMarkerSet(existing, markerPrefix(resolved.taskId, options)).ok) {
     return platformResult('failed', {

package/lib/platform/pr-change-report.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { escapeHtmlText } from './comment-safety.ts';
 
 const REPORT_FILE_NAME = 'pr-change-report.json';
 const REPORT_VERSION = 1 as const;
@@ -483,22 +484,15 @@ function representativePath(file: ChangeFile): string {
   return file.newPath || file.oldPath || '';
 }
 
-function escapeHtml(value: string): string {
-  return value
-    .replaceAll('&', '&')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;')
-    .replaceAll('"', '&quot;')
-    .replaceAll("'", '&#39;')
-    .replaceAll('\r', '\\r')
-    .replaceAll('\n', '\\n');
+function escapeReportText(value: string): string {
+  return escapeHtmlText(value).replaceAll('\r', '\\r').replaceAll('\n', '\\n');
 }
 
 function renderRepresentativePath(file: ChangeFile): string {
   const paths = file.oldPath && file.newPath && file.oldPath !== file.newPath
     ? [file.oldPath, file.newPath]
     : [representativePath(file)];
-  return paths.map((filePath) => `<code>${escapeHtml(filePath)}</code>`).join(' → ');
+  return paths.map((filePath) => `<code>${escapeReportText(filePath)}</code>`).join(' → ');
 }
 
 function representativeScore(file: ChangeFile, metric: 'lines' | 'bytes'): number {
@@ -551,12 +545,12 @@ function renderEvidence(evidence: Evidence): string {
         ? `:${evidence.startLine}`
         : `:${evidence.startLine}-${evidence.endLine}`
       : `:${evidence.startLine ?? evidence.endLine}`;
-  return `  - 证据：<code>${escapeHtml(evidence.path)}</code>${location}：${escapeHtml(evidence.detail)}`;
+  return `  - 证据：<code>${escapeReportText(evidence.path)}</code>${location}：${escapeReportText(evidence.detail)}`;
 }
 
 function renderPrechecks(checks: Precheck[]): string[] {
   return checks.flatMap((check) => [
-    `- **${PRECHECK_LABELS[check.id]}（${check.id}）**：${check.verdict === 'pass' ? '通过' : '需复核'}。${escapeHtml(check.rationale)}`,
+    `- **${PRECHECK_LABELS[check.id]}（${check.id}）**：${check.verdict === 'pass' ? '通过' : '需复核'}。${escapeReportText(check.rationale)}`,
     ...check.evidence.slice(0, 1).map(renderEvidence)
   ]);
 }