@fitlab-ai/agent-infra 0.9.13 → 0.9.15

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

@@ -7,6 +7,7 @@ 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 { canonicalizeCommentBody, escapeHtmlText, fenceRanges, renderSafeCodeFence } from './comment-safety.js';
 function providerCommentId(id, provider) {
     return provider.identity?.comment === 'number' && /^\d+$/.test(id) ? Number(id) : id;
 }
@@ -37,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 = canonicalizeCommentBody(value);
+    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),
         '## 任务文件',
@@ -69,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;
@@ -90,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 chunks.length > 0 ? chunks : [''];
+    return null;
+}
+function sourceSlice(piece, start, end) {
+    return piece.content.slice(Math.max(0, start - piece.start), Math.max(0, end - piece.start));
 }
-function buildArtifactChunk(taskId, stem, title, agent, content, part, total, chunked, backfill) {
+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);
+    }
+    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, 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;
@@ -106,7 +212,7 @@ function buildArtifactChunk(taskId, stem, title, agent, content, part, total, ch
         '',
         `> **${agent}** · ${taskId}`,
         '',
-        content,
+        renderedContent,
         '',
         footer(agent, taskId)
     ].join('\n'));
@@ -115,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);
@@ -166,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) {
@@ -271,6 +384,16 @@ async function syncPlatformComment(taskRef, options) {
             error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
         });
     }
+    let desired;
+    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)
@@ -293,17 +416,6 @@ async function syncPlatformComment(taskRef, options) {
             ...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 },
-            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/dist/lib/platform/issues.js

@@ -14,8 +14,6 @@ import { labelDelta, planInLabelUpdate, syncLabelDelta, validateInLabelMapping,
 import { providerError, providerOperationContext, providerStatus, providerResourceIdentity, providerResourceToken, unsupportedProviderOperation } from './provider-bridge.js';
 import { resourceIdentityEquals, resourceIdentityNumber, resourceIdentityString, serializeResourceIdentity } from './resource-identity.js';
 import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.js';
-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}}}}}}}}`;
 function result(status, taskId, issueNumber, overrides = {}) {
     return {
         ...platformResult(status),
@@ -133,115 +131,6 @@ async function inspectExternalIssue(base, issueIdentity) {
         error: null
     });
 }
-function normalizeIssue(remote, repository, fallbackNumber) {
-    const number = Number.isInteger(remote.number) && Number(remote.number) > 0
-        ? Number(remote.number)
-        : fallbackNumber;
-    if (!number || !Number.isSafeInteger(number) || remote.pull_request)
-        return null;
-    return {
-        repository,
-        number,
-        databaseId: Number.isInteger(remote.id) ? Number(remote.id) : null,
-        nodeId: remote.node_id || `issue-${number}`,
-        url: remote.html_url || `https://github.com/${repository}/issues/${number}`,
-        state: String(remote.state || '').toLowerCase() === 'closed' ? 'closed' : 'open',
-        title: remote.title || '',
-        body: remote.body || '',
-        labels: (remote.labels || []).map((label) => typeof label === 'string' ? label : label.name || '').filter(Boolean).sort(),
-        assignees: (remote.assignees || []).map((assignee) => assignee.login || '').filter(Boolean).sort(),
-        milestone: remote.milestone?.title || null,
-        issueType: remote.type?.name || null,
-        fields: {}
-    };
-}
-function fieldKind(value) {
-    if (value.__typename === 'IssueFieldSingleSelect' || value.__typename === 'IssueFieldSingleSelectValue')
-        return 'single-select';
-    if (value.__typename === 'IssueFieldDate' || value.__typename === 'IssueFieldDateValue')
-        return 'date';
-    if (value.__typename === 'IssueFieldText' || value.__typename === 'IssueFieldTextValue')
-        return 'text';
-    if (value.__typename === 'IssueFieldNumber' || value.__typename === 'IssueFieldNumberValue')
-        return 'number';
-    return null;
-}
-function normalizeFieldSchemas(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.flatMap((raw) => {
-        const item = raw;
-        const kind = fieldKind(item);
-        return item.id && item.name && kind ? [{
-                id: item.id,
-                name: item.name,
-                kind,
-                options: (item.options || []).flatMap((option) => option.id && option.name ? [{ id: option.id, name: option.name }] : [])
-            }] : [];
-    });
-}
-function normalizeIssueTypes(value) {
-    const nodes = value?.data?.organization?.issueTypes?.nodes;
-    return (nodes || []).flatMap((raw) => {
-        const item = raw;
-        return item.id && item.name ? [{ id: item.id, name: item.name, fields: normalizeFieldSchemas(item.pinnedFields) }] : [];
-    });
-}
-function normalizeCurrentFields(value) {
-    const issue = value?.data?.repository?.issue;
-    const type = issue?.issueType?.name ? {
-        id: issue.issueType.id || issue.issueType.name,
-        name: issue.issueType.name,
-        fields: normalizeFieldSchemas(issue.issueType.pinnedFields)
-    } : null;
-    const values = (issue?.issueFieldValues?.nodes || []).flatMap((raw) => {
-        const item = raw;
-        const kind = fieldKind(item);
-        const value = kind === 'single-select' ? item.name : item.value;
-        return item.field?.name && kind && value !== undefined
-            ? [{ id: item.field.id || item.field.name, name: item.field.name, kind, value: value ?? null }]
-            : [];
-    });
-    return { issueId: issue?.id || null, type, values };
-}
-function graphState(client, repository, issue, cwd) {
-    const [owner, name] = repository.split('/');
-    if (!owner || !name)
-        return null;
-    const current = client.json([
-        'api', 'graphql', '-f', `query=${ISSUE_FIELDS_QUERY}`, '-F', `owner=${owner}`, '-F', `name=${name}`, '-F', `number=${issue}`
-    ], { cwd });
-    if (!current.ok)
-        return null;
-    return normalizeCurrentFields(current.value);
-}
-function fetchIssue(client, repository, issue, cwd) {
-    return client.json(['api', `repos/${repository}/issues/${issue}`], { cwd });
-}
-function inspectGitHubIssue(client, repository, issue, cwd) {
-    const fetched = fetchIssue(client, repository, issue, cwd);
-    if (!fetched.ok)
-        return fetched;
-    const snapshot = normalizeIssue(fetched.value, repository, issue);
-    return snapshot
-        ? { ok: true, value: snapshot }
-        : { ok: false, error: { code: 'ISSUE_IDENTITY_INVALID', message: 'Remote resource is not a valid Issue', retryable: false } };
-}
-function inspectGitHubIssueMetadata(client, repository, issue, cwd) {
-    const fetched = fetchIssue(client, repository, issue, cwd);
-    if (!fetched.ok)
-        return fetched;
-    const remote = fetched.value;
-    return {
-        ok: true,
-        value: {
-            state: String(remote.state || '').toLowerCase() === 'closed' ? 'closed' : 'open',
-            labels: (remote.labels || []).map((label) => typeof label === 'string' ? label : label.name || '').filter(Boolean).sort(),
-            body: remote.body || '',
-            milestone: remote.milestone?.title || null
-        }
-    };
-}
 async function inspectPlatformIssue(taskRef, options = {}) {
     const base = await resolvedContext(taskRef, options);
     if (!base.ok)
@@ -450,12 +339,6 @@ function requirementsFromTask(content) {
         checked: match[1].toLowerCase() === 'x', text: match[2]
     }));
 }
-function flattenPages(value) {
-    return Array.isArray(value) ? value.flatMap((item) => Array.isArray(item) ? item : [item]) : [];
-}
-function listNames(value) {
-    return flattenPages(value).map((item) => typeof item === 'string' ? item : String(item.name || '')).filter(Boolean);
-}
 function milestoneBasis(repoRoot, current) {
     if (!current || !/^\d+\.\d+\.x$/.test(current))
         return current;
@@ -552,67 +435,6 @@ function desiredFieldValues(frontmatter, fields) {
     }
     return desired;
 }
-function planGraphMetadata(client, repository, issue, cwd, frontmatter, options, capabilities) {
-    if (!options.issueType && !options.fields)
-        return { operations: [], issueId: null };
-    if (!capabilities.push)
-        return {
-            operations: [
-                ...(options.issueType ? [{ name: 'issue-type', status: 'skipped', reasonCode: 'PUSH_REQUIRED' }] : []),
-                ...(options.fields ? [{ name: 'fields', status: 'skipped', reasonCode: 'PUSH_REQUIRED' }] : [])
-            ], issueId: null
-        };
-    const [owner] = repository.split('/');
-    const typesResult = client.json(['api', 'graphql', '-f', `query=${ISSUE_TYPES_QUERY}`, '-F', `owner=${owner}`], { cwd });
-    if (!typesResult.ok)
-        return { operations: [{ name: 'issue-schema', status: 'failed', reasonCode: typesResult.error.code }], issueId: null };
-    const types = normalizeIssueTypes(typesResult.value);
-    if (types.length === 0)
-        return {
-            operations: [
-                ...(options.issueType ? [{ name: 'issue-type', status: 'skipped', reasonCode: 'ISSUE_TYPES_UNSUPPORTED' }] : []),
-                ...(options.fields ? [{ name: 'fields', status: 'skipped', reasonCode: 'ISSUE_TYPES_UNSUPPORTED' }] : [])
-            ], issueId: null
-        };
-    const current = graphState(client, repository, issue, cwd);
-    if (!current?.issueId)
-        return { operations: [{ name: 'issue-schema', status: 'failed', reasonCode: 'ISSUE_GRAPH_IDENTITY_INVALID' }], issueId: null };
-    const target = types.find((type) => type.name === desiredIssueType(frontmatter.type || ''));
-    if (!target)
-        return { operations: [{ name: 'issue-type', status: 'failed', reasonCode: 'ISSUE_TYPE_NOT_FOUND' }], issueId: current.issueId };
-    const operations = [];
-    if (options.issueType)
-        operations.push(current.type?.id === target.id
-            ? { name: 'issue-type', status: 'no-op', reasonCode: null }
-            : { name: 'issue-type', status: 'planned', reasonCode: null, value: { issueTypeId: target.id } });
-    if (options.fields) {
-        const desired = desiredFieldValues(frontmatter, target.fields);
-        const inputs = desired.filter((field) => current.values.find((value) => value.name === field.name)?.value !== field.value).map((field) => field.input);
-        if (current.type?.id !== target.id) {
-            const targetNames = new Set(target.fields.map((field) => field.name));
-            for (const old of current.values)
-                if (!targetNames.has(old.name))
-                    inputs.push({ fieldId: old.id, delete: true });
-        }
-        operations.push(inputs.length === 0
-            ? { name: 'fields', status: 'no-op', reasonCode: null }
-            : { name: 'fields', status: 'planned', reasonCode: null, value: inputs });
-    }
-    return { operations, issueId: current.issueId };
-}
-function executeGraphOperation(client, cwd, issueId, operation) {
-    if (operation.name === 'issue-type') {
-        const query = 'mutation($issueId:ID!,$issueTypeId:ID){updateIssueIssueType(input:{issueId:$issueId,issueTypeId:$issueTypeId}){issue{id}}}';
-        const typeId = operation.value.issueTypeId;
-        return client.json(['api', 'graphql', '--input', '-'], {
-            cwd, method: 'POST', input: JSON.stringify({ query, variables: { issueId, issueTypeId: typeId } })
-        });
-    }
-    const query = 'mutation($issueId:ID!,$issueFields:[IssueFieldCreateOrUpdateInput!]!){setIssueFieldValue(input:{issueId:$issueId,issueFields:$issueFields}){issue{id}}}';
-    return client.json(['api', 'graphql', '--input', '-'], {
-        cwd, method: 'POST', input: JSON.stringify({ query, variables: { issueId, issueFields: operation.value } })
-    });
-}
 async function syncPlatformIssue(taskRef, options) {
     const base = await resolvedContext(taskRef, options);
     if (!base.ok)
@@ -761,5 +583,5 @@ async function syncPlatformIssue(taskRef, options) {
         operations: plan.operations.map((operation) => operation.status === 'planned' ? { ...operation, status: 'applied' } : operation), error: null
     });
 }
-export { bindPlatformIssue, createPlatformIssue, graphState, inspectGitHubIssue, inspectGitHubIssueMetadata, inspectPlatformIssue, normalizeIssue, requirementSectionAnchors, syncPlatformIssue };
+export { bindPlatformIssue, createPlatformIssue, inspectPlatformIssue, requirementSectionAnchors, syncPlatformIssue };
 //# sourceMappingURL=issues.js.map

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

@@ -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.js';
 const REPORT_FILE_NAME = 'pr-change-report.json';
 const REPORT_VERSION = 1;
 const CANONICAL_REPORT_PLACEHOLDER = '<!-- canonical-pr-change-report -->';
@@ -429,21 +430,14 @@ const MAX_REPRESENTATIVE_FILES = 3;
 function representativePath(file) {
     return file.newPath || file.oldPath || '';
 }
-function escapeHtml(value) {
-    return value
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;')
-        .replaceAll("'", '&#39;')
-        .replaceAll('\r', '\\r')
-        .replaceAll('\n', '\\n');
+function escapeReportText(value) {
+    return escapeHtmlText(value).replaceAll('\r', '\\r').replaceAll('\n', '\\n');
 }
 function renderRepresentativePath(file) {
     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, metric) {
     return metric === 'lines' ? file.additions + file.deletions : Math.abs(file.netBytes);
@@ -492,11 +486,11 @@ function renderEvidence(evidence) {
                 ? `:${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) {
     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)
     ]);
 }

package/dist/lib/platform/pr-checks.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
+import { checkStatusBucket } from './check-status.js';
 import { resolvePlatformProviderContext } from './context.js';
 import { inspectPlatformPullRequest } from './pull-requests.js';
 import { platformResult } from './types.js';
@@ -26,20 +27,6 @@ function classifyPullRequestReadiness(input) {
         return { state: 'pending', headSha: input.headSha };
     return { state: 'ready', headSha: input.headSha };
 }
-function parseRunJobIdentity(detailsUrl) {
-    try {
-        const url = new URL(detailsUrl);
-        if (url.hostname !== 'github.com')
-            return null;
-        const match = url.pathname.match(/\/actions\/runs\/(\d+)(?:\/job\/(\d+))?/);
-        if (!match)
-            return null;
-        return { runId: Number(match[1]), jobId: match[2] ? Number(match[2]) : null };
-    }
-    catch {
-        return null;
-    }
-}
 function resolveRunCandidate(candidates, headSha, checkName) {
     const matches = candidates.filter((candidate) => candidate.headSha === headSha && candidate.name === checkName);
     if (matches.length === 1)
@@ -54,42 +41,6 @@ function checksResult(status, overrides = {}) {
         ...overrides
     };
 }
-function normalizeBucket(value) {
-    const raw = String(value.bucket || value.status || value.conclusion || value.state || '').toLowerCase();
-    if (['pass', 'success', 'successful', 'neutral'].includes(raw))
-        return 'pass';
-    if (['fail', 'failure', 'failed', 'error', 'timed_out', 'action_required'].includes(raw))
-        return 'fail';
-    if (['cancel', 'cancelled', 'canceled', 'skipped', 'stale'].includes(raw))
-        return 'cancel';
-    return 'pending';
-}
-function normalizeChecks(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.flatMap((raw) => {
-        const item = raw;
-        const name = String(item.name || item.context || '');
-        return name ? [{
-                name,
-                bucket: normalizeBucket(item),
-                workflow: item.workflow ? String(item.workflow) : null,
-                conclusion: item.conclusion ? String(item.conclusion) : item.state ? String(item.state) : null,
-                detailsUrl: item.link ? String(item.link) : item.detailsUrl ? String(item.detailsUrl) : null,
-                startedAt: item.startedAt ? String(item.startedAt) : null,
-                completedAt: item.completedAt ? String(item.completedAt) : null
-            }] : [];
-    });
-}
-function inspectGitHubRequiredChecks(client, repository, number, cwd) {
-    const inspected = client.json([
-        'pr', 'checks', String(number), '--repo', repository,
-        '--json', 'name,state,bucket,link,workflow,startedAt,completedAt'
-    ], { cwd });
-    return inspected.ok
-        ? { ok: true, value: normalizeChecks(inspected.value) }
-        : { ok: false, error: inspected.error };
-}
 async function resolvedTask(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
@@ -117,10 +68,9 @@ async function inspectRequiredChecks(taskRef, options = {}) {
     const base = await resolvedTask(taskRef, options);
     if (!base.ok)
         return base.output;
-    return inspectChecksForResolvedTask(base, options);
+    return inspectChecksForResolvedTask(base);
 }
-async function inspectChecksForResolvedTask(base, options) {
-    const repository = base.context.platform.repository;
+async function inspectChecksForResolvedTask(base) {
     {
         const inspected = base.provider.checks?.inspectRequired
             ? await base.provider.checks.inspectRequired({
@@ -137,7 +87,13 @@ async function inspectChecksForResolvedTask(base, options) {
                 pullRequest: base.pullRequest,
                 error: providerError(inspected.error, 'PLATFORM_PROVIDER_OPERATION_FAILED')
             });
-        const required = normalizeChecks(inspected.value);
+        const required = inspected.value.map((check) => ({
+            name: check.name,
+            bucket: checkStatusBucket(check.status),
+            conclusion: check.conclusion || null,
+            detailsUrl: check.detailsUrl || null,
+            workflow: null, startedAt: null, completedAt: null
+        }));
         const classified = classifyRequiredChecks(required);
         const status = classified.state === 'passed' || classified.state === 'no-required'
             ? 'no-op'
@@ -157,7 +113,7 @@ async function inspectPullRequestReadiness(taskRef, options = {}) {
     const base = await resolvedTask(taskRef, options);
     if (!base.ok)
         return base.output;
-    const checked = await inspectChecksForResolvedTask(base, options);
+    const checked = await inspectChecksForResolvedTask(base);
     const classifiedCodes = new Set(['REQUIRED_CHECKS_PENDING', 'REQUIRED_CHECKS_FAILED', 'REQUIRED_CHECKS_CANCELLED']);
     if (checked.error && !classifiedCodes.has(checked.error.code))
         return checked;
@@ -242,15 +198,6 @@ async function resolvePlatformCheckRun(taskRef, options) {
         });
     }
 }
-function fetchCheckLogText(client, args, cwd) {
-    if (!client.text)
-        return { ok: false, error: { code: 'PLATFORM_CLIENT_TEXT_UNAVAILABLE', message: 'Platform client does not support text responses', retryable: false } };
-    const fetched = client.text(args, { cwd });
-    if (fetched.ok || args[0] !== 'api' || !/response contains terminal escape sequences/i.test(fetched.error.message)) {
-        return fetched;
-    }
-    return client.text([...args, '--allow-escape-sequences'], { cwd });
-}
 async function fetchPlatformCheckLogs(taskRef, options) {
     const base = await resolvedTask(taskRef, options);
     if (!base.ok)
@@ -281,5 +228,5 @@ async function fetchPlatformCheckLogs(taskRef, options) {
         });
     }
 }
-export { classifyPullRequestReadiness, classifyRequiredChecks, fetchCheckLogText, fetchPlatformCheckLogs, inspectGitHubRequiredChecks, inspectRequiredChecks, inspectPullRequestReadiness, parseRunJobIdentity, resolvePlatformCheckRun, resolveRunCandidate, watchPullRequestReadiness };
+export { classifyPullRequestReadiness, classifyRequiredChecks, fetchPlatformCheckLogs, inspectRequiredChecks, inspectPullRequestReadiness, resolvePlatformCheckRun, resolveRunCandidate, watchPullRequestReadiness };
 //# sourceMappingURL=pr-checks.js.map