@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/lib/platform/in-label-sync.js

@@ -0,0 +1,143 @@
+import { computeInLabels } from './metadata-labels.js';
+function inLabels(labels) {
+    return [...new Set(labels.filter((label) => label.startsWith('in:')))].sort();
+}
+function mergeInLabels(labels, target) {
+    return [...new Set([
+            ...labels.filter((label) => !label.startsWith('in:')),
+            ...target
+        ])].sort();
+}
+function invalidInLabelInput(code, message) {
+    return { ok: false, error: { code, message, retryable: false } };
+}
+function validateInLabelMapping(value) {
+    if (value === undefined)
+        return { ok: true, value: {} };
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return invalidInLabelInput('IN_LABEL_SYNC_MAPPING_INVALID', 'labels.in must be an object of non-empty string arrays');
+    }
+    const normalized = {};
+    for (const [name, rawPrefixes] of Object.entries(value)) {
+        if (!name.trim() || !Array.isArray(rawPrefixes) || rawPrefixes.length === 0 || rawPrefixes.some((prefix) => typeof prefix !== 'string' || !prefix.trim())) {
+            return invalidInLabelInput('IN_LABEL_SYNC_MAPPING_INVALID', `labels.in entry '${name}' must be a non-empty string array`);
+        }
+        normalized[name] = rawPrefixes.map((prefix) => prefix.trim());
+    }
+    return { ok: true, value: normalized };
+}
+function repositoryLabelPages(value) {
+    if (!Array.isArray(value))
+        return null;
+    if (value.length === 0)
+        return [];
+    if (value.every((page) => Array.isArray(page)))
+        return value;
+    if (value.every((entry) => entry && typeof entry === 'object' && !Array.isArray(entry)))
+        return [value];
+    return null;
+}
+function validateRepositoryLabelPayload(value) {
+    const pages = repositoryLabelPages(value);
+    if (!pages)
+        return invalidInLabelInput('IN_LABEL_SYNC_LABELS_INVALID', 'Repository labels response must be an array of pages');
+    const names = [];
+    for (const page of pages) {
+        for (const entry of page) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry) || typeof entry.name !== 'string' || !entry.name.trim()) {
+                return invalidInLabelInput('IN_LABEL_SYNC_LABELS_INVALID', 'Repository labels response contains an entry without a valid name');
+            }
+            names.push(entry.name);
+        }
+    }
+    return { ok: true, value: [...new Set(names)].sort() };
+}
+function validateRepositoryLabelSet(value) {
+    if (!(value instanceof Set) || [...value].some((label) => typeof label !== 'string' || !label.trim())) {
+        return invalidInLabelInput('IN_LABEL_SYNC_LABELS_INVALID', 'Repository labels must be a set of non-empty names');
+    }
+    return { ok: true, value: new Set([...value]) };
+}
+function planInLabelUpdate(input) {
+    const current = inLabels(input.currentLabels);
+    const mapping = validateInLabelMapping(input.mapping);
+    const repositoryLabels = validateRepositoryLabelSet(input.repositoryLabels);
+    if (!mapping.ok)
+        return { current, target: [...current], labels: [...input.currentLabels].sort(), changed: false, error: mapping.error };
+    if (!repositoryLabels.ok)
+        return { current, target: [...current], labels: [...input.currentLabels].sort(), changed: false, error: repositoryLabels.error };
+    const target = computeInLabels([...input.changedFiles], mapping.value, repositoryLabels.value);
+    const labels = mergeInLabels(input.currentLabels, target);
+    return { current, target, labels, changed: labels.join('\0') !== [...input.currentLabels].sort().join('\0'), error: null };
+}
+function startsWithPrefix(label, prefix) {
+    return (Array.isArray(prefix) ? prefix : [prefix]).some((value) => label.startsWith(value));
+}
+function labelDelta(current, target, prefix = 'in:') {
+    const currentLabels = [...new Set(current)].sort();
+    const targetLabels = [...new Set(target.filter((label) => startsWithPrefix(label, prefix)))].sort();
+    return {
+        add: targetLabels.filter((label) => !currentLabels.includes(label)),
+        remove: currentLabels.filter((label) => startsWithPrefix(label, prefix) && !targetLabels.includes(label))
+    };
+}
+function syncLabelDelta(client, repository, number, cwd, current, target, prefix = 'in:') {
+    const delta = labelDelta(current, target, prefix);
+    let changed = false;
+    const failure = (error) => {
+        if (changed || error.retryable) {
+            return {
+                status: 'blocked',
+                changed,
+                error: { ...error, code: 'IN_LABEL_SYNC_PARTIAL', message: `In-label synchronization is partial or unknown: ${error.message}` }
+            };
+        }
+        return { status: 'failed', changed: false, error };
+    };
+    for (const label of delta.remove) {
+        const removed = client.json([
+            'api', `repos/${repository}/issues/${number}/labels/${encodeURIComponent(label)}`, '-X', 'DELETE'
+        ], { cwd, method: 'DELETE' });
+        if (!removed.ok)
+            return failure(removed.error);
+        changed = true;
+    }
+    for (const label of delta.add) {
+        const added = client.json([
+            'api', `repos/${repository}/issues/${number}/labels`, '-X', 'POST', '--input', '-'
+        ], { cwd, method: 'POST', input: JSON.stringify({ labels: [label] }) });
+        if (!added.ok)
+            return failure(added.error);
+        changed = true;
+    }
+    return { status: changed ? 'applied' : 'no-op', changed, error: null };
+}
+function flattenPages(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((page) => Array.isArray(page) ? page : [page]);
+}
+function extractRepositoryLabelNames(value) {
+    return flattenPages(value).flatMap((entry) => {
+        if (typeof entry === 'string')
+            return [entry];
+        if (entry && typeof entry === 'object' && typeof entry.name === 'string') {
+            return [entry.name];
+        }
+        return [];
+    }).filter(Boolean).sort();
+}
+function extractPullRequestFileNames(value) {
+    const entries = flattenPages(value);
+    if (!Array.isArray(value) || entries.some((entry) => !entry || typeof entry !== 'object'))
+        return null;
+    const names = entries.map((entry) => entry.filename);
+    if (names.some((name) => typeof name !== 'string' || !name.trim()))
+        return null;
+    return [...new Set(names)].sort();
+}
+function resourceSnapshot(kind, number, labels) {
+    return { kind, number, labels: [...labels].sort() };
+}
+export { extractPullRequestFileNames, extractRepositoryLabelNames, flattenPages, inLabels, labelDelta, mergeInLabels, planInLabelUpdate, resourceSnapshot, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
+//# sourceMappingURL=in-label-sync.js.map

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

@@ -2,9 +2,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parseTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
-import { createGitHubClient } from './github-client.js';
-import { resolvePlatformContext } from './context.js';
+import { resolvePlatformProviderContext } from './context.js';
 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 { CONTROL_MARKER_PATTERN, escapeHtmlText, fenceRanges, renderSafeCodeFence, sanitizeMarkdownDocument } from './comment-safety.js';
+function providerCommentId(id, provider) {
+    return provider.identity?.comment === 'number' && /^\d+$/.test(id) ? Number(id) : id;
+}
 const MARKERS = {
     task: (taskId) => `<!-- sync-issue:${taskId}:task -->`,
     artifact: (taskId, stem) => `<!-- sync-issue:${taskId}:${stem} -->`,
@@ -32,14 +38,21 @@ function splitFrontmatter(content) {
         return { frontmatter: null, body: content };
     return { frontmatter: match[1], body: content.slice(match[0].length).replace(/^\r?\n/, '') };
 }
+function sanitizeCommentBody(value, label) {
+    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, taskId) {
     return `---\n*由 ${agent} 自动生成 · 内部追踪：${taskId}*`;
 }
 function renderTaskComment(content, taskId, agent) {
     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),
         '## 任务文件',
@@ -64,10 +77,11 @@ function chunkByUtf8(content, maxBytes) {
     if (maxBytes <= 0)
         throw new Error('comment byte limit is too small');
     const chunks = [];
-    let remaining = content;
-    while (remaining) {
+    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;
@@ -85,12 +99,109 @@ function chunkByUtf8(content, maxBytes) {
         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, character) {
+    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, sourceCharacter, maxBytes) {
+    const candidates = 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, start, end) {
+    return piece.content.slice(Math.max(0, start - piece.start), Math.max(0, end - piece.start));
+}
+function renderOversizedFenceChunk(piece, fences, maxBytes) {
+    const insertions = new Map();
+    const omitted = [];
+    const insert = (position, value, 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([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 buildArtifactChunk(taskId, stem, title, agent, content, part, total, chunked, backfill) {
+function independentChunkContent(piece, fences, maxBytes) {
+    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(taskId, stem, title, agent, content, part, total, chunked, backfill, renderedContent = content) {
     const marker = chunked ? MARKERS.artifactChunk(taskId, stem, part, total) : MARKERS.artifact(taskId, stem);
     const heading = chunked ? `## ${title}（${part}/${total}）` : `## ${title}`;
     const timelineHint = backfill ? '> 历史产物补发' : null;
@@ -101,7 +212,7 @@ function buildArtifactChunk(taskId, stem, title, agent, content, part, total, ch
         '',
         `> **${agent}** · ${taskId}`,
         '',
-        content,
+        renderedContent,
         '',
         footer(agent, taskId)
     ].join('\n'));
@@ -110,25 +221,32 @@ function buildArtifactChunk(taskId, stem, title, agent, content, part, total, ch
 function chunkArtifactComment(input) {
     const byteLimit = input.byteLimit || 60_000;
     const identity = artifactIdentity(input.artifact);
-    const single = buildArtifactChunk(input.taskId, identity.stem, identity.title, input.agent, input.body, 1, 1, false, Boolean(input.backfill));
+    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));
     if (Buffer.byteLength(single.body, 'utf8') <= byteLimit)
         return [single];
     let total = 2;
-    let pieces = [];
+    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, marker) {
     return comments.filter((comment) => normalizeCommentContent(String(comment.body || '')).split('\n', 1)[0] === marker);
@@ -137,7 +255,7 @@ function flattenComments(value) {
     if (!Array.isArray(value))
         return [];
     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.body === 'string'));
+    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;
@@ -161,7 +279,7 @@ function hasResolvedPlatformContext(context) {
 }
 function bodyEnvelope(marker, title, taskId, agent, body) {
     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'));
 }
 function resolveArtifactBody(taskDir, artifact) {
@@ -246,7 +364,7 @@ function writeComment(client, repo, issue, cwd, body, id) {
     const endpoint = id ? `repos/${repo}/issues/comments/${id}` : `repos/${repo}/issues/${issue}/comments`;
     return client.json(['api', endpoint, '-X', id ? 'PATCH' : 'POST', '--input', '-'], { cwd, method: id ? 'PATCH' : 'POST', input: JSON.stringify({ body }) });
 }
-function syncPlatformComment(taskRef, options) {
+async function syncPlatformComment(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok) {
         return platformResult('failed', {
@@ -254,33 +372,50 @@ function syncPlatformComment(taskRef, options) {
         });
     }
     const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    const issue = issueNumberFromTask(taskContent);
-    if (!issue) {
+    let issueIdentityFromTask;
+    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;
     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, 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', {
@@ -310,7 +445,6 @@ function syncPlatformComment(taskRef, options) {
             error: null
         });
     }
-    const repo = context.platform.repository;
     const operations = [];
     const ids = [];
     for (const item of desired) {
@@ -320,16 +454,18 @@ function syncPlatformComment(taskRef, options) {
             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', 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),
@@ -338,15 +474,20 @@ function syncPlatformComment(taskRef, options) {
                 error: written.error
             });
         }
-        ids.push(current?.id || written.value.id || 0);
+        ids.push(providerCommentId(written.value.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),
@@ -367,31 +508,55 @@ function syncPlatformComment(taskRef, options) {
         error: null
     });
 }
-function listPlatformComments(issue, cwd = process.cwd(), client = createGitHubClient()) {
-    const context = resolvePlatformContext({ cwd, client });
-    if (!hasResolvedPlatformContext(context))
+async function listPlatformComments(issue, cwd = process.cwd(), client) {
+    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 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
+    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, 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, options = {}) {
+async function checkPlatformCommentOwner(taskRef, options = {}) {
     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))
+    let issueIdentity;
+    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 = listRemoteComments(client, context.platform.repository, issue, resolved.repoRoot);
+    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, 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));
@@ -401,11 +566,11 @@ function checkPlatformCommentOwner(taskRef, options = {}) {
     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 { MARKERS, chunkArtifactComment, findMarkerComments, listRemoteComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, syncPlatformComment, validateRelatedMarkerSet, writeComment };
 //# sourceMappingURL=issue-comments.js.map