@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/lib/platform/issue-comments.ts

@@ -3,13 +3,29 @@ import path from 'node:path';
 
 import { parseTaskFrontmatter } from '../task/frontmatter.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { createGitHubClient } from './github-client.ts';
-import type { GitHubClient } from './github-client.ts';
-import { resolvePlatformContext } from './context.ts';
+import { resolvePlatformProviderContext } from './context.ts';
+import type { PlatformClient } from './context.ts';
 import { platformResult } from './types.ts';
 import type { PlatformOperation, PlatformResult } from './types.ts';
-
-type RemoteComment = { id: number; body: string; user?: { login?: string } };
+import {
+  providerError,
+  providerOperationContext,
+  providerStatus,
+  providerResourceToken,
+  unsupportedProviderOperation
+} 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 };
 type CommentKind = 'task' | 'artifact' | 'summary' | 'cancel';
 type SyncOptions = {
@@ -19,9 +35,14 @@ type SyncOptions = {
   body?: string;
   cwd?: string;
   backfill?: boolean;
-  client?: GitHubClient;
+  client?: PlatformClient;
+  runtimeVersion?: string;
 };
 
+function providerCommentId(id: string, provider: { identity?: { comment?: string } }): number | string {
+  return provider.identity?.comment === 'number' && /^\d+$/.test(id) ? Number(id) : id;
+}
+
 const MARKERS = {
   task: (taskId: string) => `<!-- sync-issue:${taskId}:task -->`,
   artifact: (taskId: string, stem: string) => `<!-- sync-issue:${taskId}:${stem} -->`,
@@ -53,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),
     '## 任务文件',
@@ -83,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;
@@ -104,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 : [{ 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);
   }
-  return chunks.length > 0 ? chunks : [''];
+  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(
@@ -119,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}`;
@@ -131,7 +255,7 @@ function buildArtifactChunk(
     '',
     `> **${agent}** · ${taskId}`,
     '',
-    content,
+    renderedContent,
     '',
     footer(agent, taskId)
   ].join('\n'));
@@ -148,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[] {
@@ -181,7 +320,7 @@ function flattenComments(value: unknown): RemoteComment[] {
   if (!Array.isArray(value)) return [];
   const flattened = value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]);
   return flattened.filter((entry): entry is RemoteComment =>
-    Boolean(entry && typeof entry === 'object' && typeof entry.id === 'number' && typeof entry.body === 'string')
+    Boolean(entry && typeof entry === 'object' && (typeof entry.id === 'number' || typeof entry.id === 'string') && typeof entry.body === 'string')
   );
 }
 
@@ -191,7 +330,7 @@ function issueNumberFromTask(content: string): number | null {
   return Number.isInteger(number) && number > 0 ? number : null;
 }
 
-function listRemoteComments(client: GitHubClient, repo: string, issue: number, cwd: string) {
+function listRemoteComments(client: PlatformClient, repo: string, issue: number, cwd: string) {
   const result = client.json<unknown>([
     'api', '--paginate', '--slurp', `repos/${repo}/issues/${issue}/comments?per_page=100`
   ], { cwd });
@@ -211,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'));
 }
 
@@ -291,7 +430,7 @@ function validateRelatedMarkerSet(comments: RemoteComment[], prefix: string): {
 }
 
 function writeComment(
-  client: GitHubClient,
+  client: PlatformClient,
   repo: string,
   issue: number,
   cwd: string,
@@ -305,7 +444,7 @@ function writeComment(
   );
 }
 
-function syncPlatformComment(taskRef: string, options: SyncOptions): PlatformResult {
+async function syncPlatformComment(taskRef: string, options: SyncOptions): Promise<PlatformResult> {
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
   if (!resolved.ok) {
     return platformResult('failed', {
@@ -313,32 +452,45 @@ function syncPlatformComment(taskRef: string, options: SyncOptions): PlatformRes
     });
   }
   const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
-  const issue = issueNumberFromTask(taskContent);
-  if (!issue) {
+  let issueIdentityFromTask: ReturnType<typeof taskIssueIdentity>;
+  try { issueIdentityFromTask = taskIssueIdentity(parseTaskFrontmatter(taskContent), undefined, options.runtimeVersion); }
+  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 }
     });
   }
-  const context = resolvePlatformContext({ cwd: resolved.repoRoot, client: options.client });
-  if (!hasResolvedPlatformContext(context)) return context;
-  const client = options.client || createGitHubClient();
-  const listed = listRemoteComments(client, context.platform.repository!, issue, resolved.repoRoot);
-  if (!listed.ok) {
-    return platformResult(listed.error.retryable ? 'blocked' : 'failed', {
-      ...contextFields(context), resource: { kind: 'issue', number: issue }, error: listed.error
-    });
-  }
-
   let desired: RenderedChunk[];
   try {
     desired = expectedComments(resolved.taskId, taskContent, resolved.taskDir, options);
   } catch (error) {
     return platformResult('failed', {
-      ...contextFields(context),
-      resource: { kind: 'issue', number: issue },
+      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;
+  const issue = resourceIdentityNumber(issueIdentityFromTask);
+  const listed = loaded.value.provider.comments?.list
+      ? await loaded.value.provider.comments.list({
+        context: providerOperationContext(loaded.value),
+        parent: issueIdentityFromTask
+      }).then((response) => response.ok
+        ? { ok: true as const, value: response.value.map((comment) => ({
+          id: providerCommentId(comment.id, loaded.value.provider),
+          body: comment.body,
+          user: comment.author?.name ? { login: comment.author.name } : undefined
+        })) }
+        : response)
+      : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
+  if (!listed.ok) {
+    return platformResult(listed.error.retryable ? 'blocked' : 'failed', {
+      ...contextFields(context), resource: { kind: 'issue', number: issue }, error: listed.error
+    });
+  }
+
   const existing = relatedComments(listed.value, markerPrefix(resolved.taskId, options));
   if (!validateRelatedMarkerSet(existing, markerPrefix(resolved.taskId, options)).ok) {
     return platformResult('failed', {
@@ -370,9 +522,8 @@ function syncPlatformComment(taskRef: string, options: SyncOptions): PlatformRes
     });
   }
 
-  const repo = context.platform.repository!;
   const operations: PlatformOperation[] = [];
-  const ids: number[] = [];
+  const ids: Array<number | string> = [];
   for (const item of desired) {
     const current = existing.find((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] === item.marker);
     if (current && normalizeCommentContent(current.body) === normalizeCommentContent(item.body)) {
@@ -380,16 +531,18 @@ function syncPlatformComment(taskRef: string, options: SyncOptions): PlatformRes
       operations.push({ name: `comment:${item.marker}`, status: 'no-op', reasonCode: null });
       continue;
     }
-    const written = writeComment(client, repo, issue, resolved.repoRoot, item.body, current?.id);
+    const written = loaded.value.provider.comments?.write
+        ? await loaded.value.provider.comments.write({
+          context: providerOperationContext(loaded.value),
+          parent: issueIdentityFromTask,
+          body: item.body,
+          ...(current ? { existingComment: { kind: 'id' as const, value: String(current.id) } } : {}),
+          mutation: { idempotencyKey: `comment:${resolved.taskId}:${item.marker}` }
+        })
+        : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
     if (!written.ok) {
       if (!current && written.error.retryable) {
-        const reconciled = listRemoteComments(client, repo, issue, resolved.repoRoot);
-        const found = reconciled.ok ? findMarkerComments(reconciled.value, item.marker) : [];
-        if (found.length === 1) {
-          ids.push(found[0]!.id);
-          operations.push({ name: `comment:${item.marker}`, status: 'applied', reasonCode: 'CREATE_RECONCILED' });
-          continue;
-        }
+        // A provider owns reconciliation because only it knows how to address the resource.
       }
       return platformResult(written.error.retryable ? 'blocked' : 'failed', {
         ...contextFields(context),
@@ -398,16 +551,21 @@ function syncPlatformComment(taskRef: string, options: SyncOptions): PlatformRes
         error: written.error
       });
     }
-    ids.push(current?.id || written.value.id || 0);
+    ids.push(providerCommentId((written.value as { remoteId: string }).remoteId, loaded.value.provider));
     operations.push({ name: `comment:${item.marker}`, status: 'applied', reasonCode: null });
   }
 
   const desiredMarkers = new Set(desired.map((item) => item.marker));
   const stale = existing.filter((comment) => !desiredMarkers.has(normalizeCommentContent(comment.body).split('\n', 1)[0]!));
   for (const comment of stale) {
-    const deleted = client.text(['api', `repos/${repo}/issues/comments/${comment.id}`, '-X', 'DELETE'], {
-      cwd: resolved.repoRoot, method: 'DELETE'
-    });
+    const deleted = loaded.value.provider.comments?.delete
+        ? await loaded.value.provider.comments.delete({
+          context: providerOperationContext(loaded.value),
+          parent: issueIdentityFromTask,
+          comment: { kind: 'id', value: String(comment.id) },
+          mutation: { idempotencyKey: `comment-delete:${resolved.taskId}:${comment.id}` }
+        })
+        : unsupportedProviderOperation(loaded.value.provider, 'comments.delete');
     if (!deleted.ok) {
       return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
         ...contextFields(context),
@@ -429,28 +587,45 @@ function syncPlatformComment(taskRef: string, options: SyncOptions): PlatformRes
   });
 }
 
-function listPlatformComments(issue: number, cwd = process.cwd(), client: GitHubClient = createGitHubClient()): PlatformResult & { comments?: RemoteComment[] } {
-  const context = resolvePlatformContext({ cwd, client });
-  if (!hasResolvedPlatformContext(context)) return context;
-  const result = listRemoteComments(client, context.platform.repository!, issue, cwd);
-  if (!result.ok) {
-    return platformResult(result.error.retryable ? 'blocked' : 'failed', {
-      ...contextFields(context), resource: { kind: 'issue', number: issue }, error: result.error
+async function listPlatformComments(issue: string | number, cwd = process.cwd(), client?: PlatformClient): Promise<PlatformResult & { comments?: RemoteComment[] }> {
+  const loaded = await resolvePlatformProviderContext({ cwd, client });
+  const context = loaded.ok ? loaded.value.context : loaded.context;
+  if (!hasResolvedPlatformContext(context) || !loaded.ok) return context;
+  let identity;
+  try { identity = loaded.ok ? providerResourceToken(loaded.value.provider, 'issue', String(issue)) : null; }
+  catch (error) {
+    return platformResult('failed', { ...contextFields(context), error: { code: 'PLATFORM_IDENTITY_TOKEN_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } });
+  }
+  if (!loaded.ok || !identity) return context;
+  const listed = loaded.value.provider.comments?.list
+      ? await loaded.value.provider.comments.list({ context: providerOperationContext(loaded.value), parent: identity }).then((response) => response.ok
+        ? { ok: true as const, value: response.value.map((comment) => ({ id: comment.id, body: comment.body, user: comment.author?.name ? { login: comment.author.name } : undefined })) }
+        : response)
+      : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
+  if (!listed.ok) {
+    return platformResult(providerStatus(listed.error), {
+      ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(identity), identity }, error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED')
     });
   }
-  return { ...platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: issue }, error: null }), comments: result.value };
+  return { ...platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(identity), identity }, error: null }), comments: listed.value };
 }
 
-function checkPlatformCommentOwner(taskRef: string, options: { cwd?: string; client?: GitHubClient } = {}): PlatformResult {
+async function checkPlatformCommentOwner(taskRef: string, options: { cwd?: string; client?: PlatformClient; runtimeVersion?: string } = {}): Promise<PlatformResult> {
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
   if (!resolved.ok) return platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } });
   const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-  const issue = issueNumberFromTask(content);
-  if (!issue) return platformResult('no-op', { error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false } });
-  const client = options.client || createGitHubClient();
-  const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
-  if (!hasResolvedPlatformContext(context)) return context;
-  const listed = listRemoteComments(client, context.platform.repository!, issue, resolved.repoRoot);
+  let issueIdentity: ReturnType<typeof taskIssueIdentity>;
+  try { issueIdentity = taskIssueIdentity(parseTaskFrontmatter(content), undefined, options.runtimeVersion); }
+  catch (error) { return platformResult('failed', { error: { ...taskIssueIdentityError(error), retryable: false } }); }
+  if (!issueIdentity) return platformResult('no-op', { error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', 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;
+  const listed = loaded.value.provider.comments?.list
+      ? await loaded.value.provider.comments.list({ context: providerOperationContext(loaded.value), parent: issueIdentity }).then((response) => response.ok
+        ? { ok: true as const, value: response.value.map((comment) => ({ id: comment.id, body: comment.body, user: comment.author?.name ? { login: comment.author.name } : undefined })) }
+        : response)
+      : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
   if (!listed.ok) return platformResult(listed.error.retryable ? 'blocked' : 'failed', { ...contextFields(context), error: listed.error });
   const matches = findMarkerComments(listed.value, MARKERS.task(resolved.taskId));
   if (matches.length > 1) return platformResult('failed', { ...contextFields(context), error: { code: 'COMMENT_MARKER_CONFLICT', message: 'Multiple task comments use the registered marker', retryable: false } });
@@ -458,11 +633,11 @@ function checkPlatformCommentOwner(taskRef: string, options: { cwd?: string; cli
   if (owner && owner !== context.platform.currentUser && !context.capabilities.triage) {
     return platformResult('blocked', {
       ...contextFields(context),
-      resource: { kind: 'issue', number: issue },
+      resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentity), identity: issueIdentity },
       error: { code: 'COMMENT_OWNER_CONFLICT', message: `Task comment is owned by '${owner}'`, retryable: false }
     });
   }
-  return platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: issue }, error: null });
+  return platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentity), identity: issueIdentity }, error: null });
 }
 
 export {