@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/platform/pull-requests.js

@@ -1,11 +1,10 @@
-import { normalizePullRequest } from './github-data.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
-import { extractSection } from '../task/sections.js';
+import { activityWarnings, locateActivityLog } from '../task/activity-log.js';
 import { captureTaskWriteMetadata, writeTask } from '../task/write.js';
 import { resolvePlatformProviderContext } from './context.js';
 import { inspectPlatformIssue } from './issues.js';
@@ -162,39 +161,6 @@ function expectedHead(repository, head) {
     const repoName = repository.split('/')[1] || '';
     return { repository: `${head.slice(0, colon)}/${repoName}`, ref: head.slice(colon + 1) };
 }
-function selectPullRequest(remotes, repository, head, base, expectedSha) {
-    const wanted = expectedHead(repository, head);
-    const matches = remotes.flatMap((remote) => {
-        const normalized = normalizePullRequest(remote, repository);
-        return normalized && normalized.state === 'open' && normalized.head.repository === wanted.repository &&
-            normalized.head.ref === wanted.ref && normalized.base.repository === repository && normalized.base.ref === base
-            ? [normalized] : [];
-    });
-    if (expectedSha && matches.some((match) => match.head.sha !== expectedSha)) {
-        return { status: 'head-mismatch', pullRequest: null };
-    }
-    if (matches.length === 1)
-        return { status: 'resolved', pullRequest: matches[0] };
-    return { status: matches.length === 0 ? 'missing' : 'ambiguous', pullRequest: null };
-}
-function validateBoundPullRequest(base, pullRequest, head, baseRef, expectedSha) {
-    if (!pullRequest)
-        return {
-            ok: false,
-            error: { code: 'PR_BIND_RECHECK_FAILED', message: 'Bound pull request identity is unavailable', retryable: false }
-        };
-    const wanted = expectedHead(base.context.platform.repository, head);
-    if (pullRequest.head.repository !== wanted.repository
-        || pullRequest.head.ref !== wanted.ref
-        || pullRequest.head.sha !== expectedSha
-        || pullRequest.base.repository !== base.context.platform.repository
-        || pullRequest.base.ref !== baseRef)
-        return {
-            ok: false,
-            error: { code: 'PR_BIND_IDENTITY_MISMATCH', message: 'Bound pull request identity does not match the current expected head/base', retryable: false }
-        };
-    return { ok: true };
-}
 function resolveTaskDeliveryTarget(repoRoot, frontmatter) {
     const existing = {
         ...(typeof frontmatter.delivery_remote === 'string' && frontmatter.delivery_remote
@@ -682,9 +648,12 @@ async function syncPlatformPullRequestInLabels(prToken, options = {}) {
         resources: resourcesState, evidence: { kind: 'pull-request-files', pullRequestFiles: files.value, closingIssues: closingIssueIdentities }, error: null
     });
 }
-function appendActivity(content, line) {
-    const body = extractSection(content, ['活动日志', 'Activity Log']);
-    return `${body.replace(/\s+$/, '')}${body.trim() ? '\n' : ''}${line}`;
+function activityMutation(content, line) {
+    const section = locateActivityLog(content);
+    if (!section)
+        return [];
+    return [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading,
+            body: `${section.body}${section.body ? '\n' : ''}${line}` }];
 }
 function deliveryIdentity(pullRequest) {
     return {
@@ -710,15 +679,11 @@ function boundFactFor(pullRequest, source, issue, verifiedAt) {
     });
 }
 function writeCreateStarted(base, agent) {
-    const starts = (base.content.match(/\*\*Create PR \[started\]\*\*/g) || []).length;
-    const dones = (base.content.match(/\*\*Create PR\*\*/g) || []).length;
-    if (starts > dones)
-        return { status: 'no-op' };
     const metadata = captureTaskWriteMetadata();
     return writeTask({
         taskRef: base.resolved.taskId,
         expectedState: 'active',
-        mutations: [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: '活动日志', body: appendActivity(base.content, `- ${metadata.timestamp} — **Create PR [started]** by ${agent} — started`) }]
+        mutations: activityMutation(base.content, `- ${metadata.timestamp} — **Create PR [started]** by ${agent} — started`)
     }, { repoRoot: base.resolved.repoRoot, metadataProvider: () => metadata });
 }
 function bindIdentity(base, pullRequest, agent, source, dryRun = false, expectedHead, expectedHeadSha) {
@@ -750,7 +715,7 @@ function bindIdentity(base, pullRequest, agent, source, dryRun = false, expected
         dryRun,
         mutations: [
             { kind: 'frontmatter', set: { ...factMutation.set, assigned_to: agent } },
-            { kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: '活动日志', body: appendActivity(current, `- ${metadata.timestamp} — **Create PR** by ${agent} — PR #${pullRequest.number} created → ${pullRequest.url}`) }
+            ...activityMutation(current, `- ${metadata.timestamp} — **Create PR** by ${agent} — PR #${pullRequest.number} created → ${pullRequest.url}`)
         ]
     }, { repoRoot: base.resolved.repoRoot, metadataProvider: () => metadata });
 }
@@ -779,13 +744,14 @@ async function bindPlatformPullRequestImpl(taskRef, options) {
         return inspected;
     const initialIdentity = validateWriterIdentity(base, inspected.pullRequest, {
         expectedHead: String(base.frontmatter.branch || ''),
+        expectedHeadSha: options.expectedHeadSha,
         errorCode: 'PR_BIND_IDENTITY_MISMATCH'
     });
     if (!initialIdentity.ok)
         return result('failed', base.resolved.taskId, base.issueNumber, requestedNumber, {
             pullRequest: inspected.pullRequest, error: initialIdentity.error
         });
-    const written = bindIdentity(base, inspected.pullRequest, options.agent, 'explicit-bind', options.dryRun);
+    const written = bindIdentity(base, inspected.pullRequest, options.agent, 'explicit-bind', options.dryRun, undefined, options.expectedHeadSha);
     if (written.status === 'failed')
         return result('failed', base.resolved.taskId, base.issueNumber, requestedNumber, {
             pullRequest: inspected.pullRequest, error: { code: written.error.code, message: written.error.message, retryable: false }
@@ -796,7 +762,7 @@ async function bindPlatformPullRequestImpl(taskRef, options) {
         operations: [{ name: 'task:bind-pr', status: options.dryRun ? 'planned' : written.status === 'no-op' ? 'no-op' : 'applied', reasonCode: null }], error: null
     });
 }
-async function bindPlatformPullRequest(taskRef, options) {
+async function bindPlatformPullRequestWithProjection(taskRef, options) {
     const intent = { action: 'bind', prToken: String(options.pr) };
     return journalPullRequestOperation(taskRef, options, intent, `pr:${options.pr}`, { pr: String(options.pr) }, () => bindPlatformPullRequestImpl(taskRef, options));
 }
@@ -940,32 +906,16 @@ async function resolveExternalPullRequest(taskRef, options) {
         }), { candidates: selected.candidates, eligible: selected.eligible, selected: rechecked.value });
     const selectedPullRequest = rechecked.value;
     const note = externalEvidenceNote(base.issueIdentity, selected.source, selectedPullRequest);
-    const identityNote = externalIdentityEvidenceNote(base.issueIdentity, selectedPullRequest);
     const activityEntry = `**Bind External PR** by ${options.agent} — ${note}`;
-    const auditLines = base.content.split(/\r?\n/).filter((line) => line.includes('**Bind External PR**'));
-    const alreadyAudited = auditLines.some((line) => line.endsWith(identityNote));
-    if (auditLines.length > 0 && !alreadyAudited)
+    if (base.prIdentity && !resourceIdentityEquals(base.prIdentity, pullRequestIdentity(selectedPullRequest)))
         return externalResult(result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
-            platform: base.context.platform,
-            capabilities: base.context.capabilities,
-            pullRequest: selectedPullRequest,
-            error: { code: 'PR_BIND_CONFLICT', message: 'Existing external PR audit evidence conflicts with the selected identity', retryable: false }
+            platform: base.context.platform, capabilities: base.context.capabilities, pullRequest: selectedPullRequest,
+            error: { code: 'PR_BIND_CONFLICT', message: 'Selected identity does not match the task binding', retryable: false }
         }), { candidates: selected.candidates, eligible: selected.eligible, selected: selectedPullRequest });
-    if (alreadyAudited && base.prIdentity && !resourceIdentityEquals(base.prIdentity, pullRequestIdentity(selectedPullRequest)))
-        return externalResult(result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
-            platform: base.context.platform,
-            capabilities: base.context.capabilities,
-            pullRequest: selectedPullRequest,
-            error: { code: 'PR_BIND_CONFLICT', message: 'External PR audit evidence does not match the task binding', retryable: false }
-        }), { candidates: selected.candidates, eligible: selected.eligible, selected: selectedPullRequest });
-    if (base.prIdentity && resourceIdentityEquals(base.prIdentity, pullRequestIdentity(selectedPullRequest)) && alreadyAudited) {
+    if (base.prIdentity && resourceIdentityEquals(base.prIdentity, pullRequestIdentity(selectedPullRequest)) && base.fact?.state === 'bound') {
         return externalResult(result('no-op', base.resolved.taskId, base.issueNumber, base.prNumber, {
-            platform: base.context.platform,
-            capabilities: base.context.capabilities,
-            resource: { kind: 'pull-request', number: selectedPullRequest.number },
-            pullRequest: selectedPullRequest,
-            operations: [{ name: 'task:bind-external-pr', status: 'no-op', reasonCode: 'EVIDENCE_ALREADY_RECORDED' }],
-            error: null
+            platform: base.context.platform, capabilities: base.context.capabilities, pullRequest: selectedPullRequest,
+            operations: [{ name: 'task:bind-external-pr', status: 'no-op', reasonCode: 'EVIDENCE_ALREADY_RECORDED' }], error: null
         }), { mode: 'external', authorization: selected.source, candidates: selected.candidates, eligible: selected.eligible, selected: selectedPullRequest });
     }
     const metadata = captureTaskWriteMetadata();
@@ -975,7 +925,7 @@ async function resolveExternalPullRequest(taskRef, options) {
         dryRun: options.dryRun,
         mutations: [
             { kind: 'frontmatter', set: { ...factFrontmatterMutation(boundFactFor(selectedPullRequest, selected.source === 'unique' ? 'external-unique' : 'external-explicit', base.issueNumber, metadata.timestamp)).set, assigned_to: options.agent } },
-            { kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: '活动日志', body: appendActivity(base.content, `- ${metadata.timestamp} — ${activityEntry}`) }
+            ...activityMutation(base.content, `- ${metadata.timestamp} — ${activityEntry}`)
         ]
     }, { repoRoot: base.resolved.repoRoot, metadataProvider: () => metadata });
     if (write.status === 'failed')
@@ -1006,7 +956,7 @@ async function createPlatformPullRequestImpl(taskRef, options) {
         }), PRECONDITION_NOT_CREATED);
     }
     try {
-        return await createExternalPullRequest(taskRef, options, base);
+        return await createExternalPullRequest(options, base);
     }
     catch (error) {
         return withCreation(result('failed', base.resolved.taskId, base.issueNumber, null, {
@@ -1028,17 +978,26 @@ async function recoverCreatedPullRequest(taskRef, options) {
         return result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
             error: { code: 'PLATFORM_OPERATION_ISSUE_REQUIRED', message: 'Pull-request recovery requires a bound Issue identity', retryable: false }
         });
-    const head = base.provider.changeRequests?.verifyHead
-        ? await base.provider.changeRequests.verifyHead({ context: providerOperationContext(base.loadedContext), head: options.head })
-        : unsupportedProviderOperation(base.provider, 'changeRequests.verifyHead');
-    if (!head.ok)
-        return providerPullRequestError(base, head.error, base.prNumber);
+    let headSha;
+    if (base.provider.changeRequests?.verifyHead) {
+        const head = await base.provider.changeRequests.verifyHead({ context: providerOperationContext(base.loadedContext), head: options.head });
+        if (!head.ok)
+            return providerPullRequestError(base, head.error, base.prNumber);
+        headSha = head.value.sha;
+    }
+    else {
+        headSha = typeof base.frontmatter.delivery_remote_head === 'string' ? base.frontmatter.delivery_remote_head.trim() : '';
+        if (!headSha)
+            return result('blocked', base.resolved.taskId, base.issueNumber, base.prNumber, {
+                error: { code: 'PR_HEAD_UNVERIFIED', message: 'Verify and record the delivered remote head before retrying pull-request recovery', retryable: true }
+            });
+    }
     if (base.prIdentity) {
         const inspected = await inspectExternalPullRequest(base, base.prIdentity);
         if (!inspected.pullRequest || inspected.status === 'failed' || inspected.status === 'blocked'
             || inspected.pullRequest.base.repository !== base.context.platform.repository
             || inspected.pullRequest.base.ref !== options.base || inspected.pullRequest.head.ref !== options.head
-            || inspected.pullRequest.head.sha !== head.value.sha) {
+            || inspected.pullRequest.head.sha !== headSha) {
             return result('blocked', base.resolved.taskId, base.issueNumber, base.prNumber, {
                 error: inspected.error ?? { code: 'PLATFORM_OPERATION_PR_NOT_CONFIRMED', message: 'Bound pull request does not match the pending create intent', retryable: true }
             });
@@ -1055,24 +1014,24 @@ async function recoverCreatedPullRequest(taskRef, options) {
         && candidate.base.ref === options.base
         && candidate.head.repository === base.context.platform.repository
         && candidate.head.ref === options.head
-        && candidate.head.sha === head.value.sha);
+        && candidate.head.sha === headSha);
     if (matches.length !== 1 || !matches[0]?.number)
         return result('blocked', base.resolved.taskId, base.issueNumber, null, {
             error: { code: matches.length > 1 ? 'PLATFORM_OPERATION_PR_AMBIGUOUS' : 'PLATFORM_OPERATION_PR_NOT_CONFIRMED',
                 message: 'Pending pull-request creation does not resolve to one exact repository/base/head identity', retryable: true }
         });
-    const bound = await bindPlatformPullRequest(base.resolved.taskId, { agent: options.agent, cwd: base.resolved.repoRoot, pr: matches[0].number });
+    const bound = await bindPlatformPullRequest(base.resolved.taskId, { agent: options.agent, cwd: base.resolved.repoRoot, client: options.client, pr: matches[0].number, skipQueue: true, expectedHeadSha: headSha });
     if (!bound.pullRequest || (bound.status !== 'applied' && bound.status !== 'no-op') || bound.error)
         return bound;
     if (bound.pullRequest.base.repository !== base.context.platform.repository || bound.pullRequest.base.ref !== options.base
         || bound.pullRequest.head.repository !== base.context.platform.repository || bound.pullRequest.head.ref !== options.head
-        || bound.pullRequest.head.sha !== head.value.sha)
+        || bound.pullRequest.head.sha !== headSha)
         return result('blocked', base.resolved.taskId, base.issueNumber, bound.task.prNumber, {
             error: { code: 'PLATFORM_OPERATION_PR_NOT_CONFIRMED', message: 'Bound pull request changed while recovering the create intent', retryable: true }
         });
     return bound;
 }
-async function createPlatformPullRequest(taskRef, options) {
+async function createPlatformPullRequestWithProjection(taskRef, options) {
     const intent = { action: 'create', baseRef: options.base, headRef: options.head };
     const identityInput = {
         title: createHash('sha256').update(options.title).digest('hex'),
@@ -1081,7 +1040,7 @@ async function createPlatformPullRequest(taskRef, options) {
     };
     return journalPullRequestOperation(taskRef, options, intent, `head:${options.head}:base:${options.base}`, identityInput, () => createPlatformPullRequestImpl(taskRef, options));
 }
-async function createExternalPullRequest(taskRef, options, base) {
+async function createExternalPullRequest(options, base) {
     if (!base.fact)
         return withCreation(result('failed', base.resolved.taskId, base.issueNumber, null, {
             error: { code: 'PR_DELIVERY_FACT_MISSING', message: 'Task has no pr_delivery_fact; repair the task metadata or create a new task', retryable: false }
@@ -1500,7 +1459,7 @@ function applySkippedPullRequestFact(resolved, options) {
         dryRun: options.dryRun,
         mutations: [
             { kind: 'frontmatter', set: { ...factFrontmatterMutation(fact).set, assigned_to: options.agent } },
-            { kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: '活动日志', body: appendActivity(content, `- ${metadata.timestamp} — **Skip PR** by ${options.agent} — PR delivery explicitly skipped`) }
+            ...activityMutation(content, `- ${metadata.timestamp} — **Skip PR** by ${options.agent} — PR delivery explicitly skipped`)
         ]
     }, { repoRoot: resolved.repoRoot, metadataProvider: () => metadata });
     if (write.status === 'failed')
@@ -1514,7 +1473,7 @@ function applySkippedPullRequestFact(resolved, options) {
         error: null
     });
 }
-async function skipPlatformPullRequestFact(taskRef, options) {
+async function skipPlatformPullRequestFactWithProjection(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return result('failed', resolved.taskId, null, null, {
@@ -1533,6 +1492,36 @@ async function skipPlatformPullRequestFact(taskRef, options) {
         });
     }
 }
-export { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, inspectPlatformPullRequestByNumber, recoverCreatedPullRequest, resolveExternalPullRequest, skipPlatformPullRequestFact, selectExternalPullRequest, selectPullRequest, syncPlatformPullRequest, syncPlatformPullRequestInLabels };
+function withActivityWarnings(taskRef, cwd, output) {
+    if (output.status === 'failed' || output.status === 'blocked')
+        return output;
+    const resolved = resolveTaskRef(taskRef, cwd ? { repoRoot: cwd } : {});
+    if (!resolved.ok)
+        return output;
+    let logWarnings;
+    try {
+        logWarnings = activityWarnings(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+    }
+    catch {
+        return output;
+    }
+    if (!logWarnings.length)
+        return output;
+    const warnings = logWarnings.map((item) => ({ ...item, retryable: true, step: 'pr', target: resolved.taskId, severity: 'IMPORTANT' }));
+    return { ...output, warnings: mergeOperationWarnings(output.warnings, warnings) };
+}
+async function bindPlatformPullRequest(taskRef, options) {
+    return withActivityWarnings(taskRef, options.cwd, await bindPlatformPullRequestWithProjection(taskRef, options));
+}
+async function createPlatformPullRequest(taskRef, options) {
+    return withActivityWarnings(taskRef, options.cwd, await createPlatformPullRequestWithProjection(taskRef, options));
+}
+async function resolveExternalPullRequestWithWarnings(taskRef, options) {
+    return withActivityWarnings(taskRef, options.cwd, await resolveExternalPullRequest(taskRef, options));
+}
+async function skipPlatformPullRequestFact(taskRef, options) {
+    return withActivityWarnings(taskRef, options.cwd, await skipPlatformPullRequestFactWithProjection(taskRef, options));
+}
+export { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, inspectPlatformPullRequestByNumber, recoverCreatedPullRequest, resolveExternalPullRequestWithWarnings as resolveExternalPullRequest, skipPlatformPullRequestFact, selectExternalPullRequest, syncPlatformPullRequest, syncPlatformPullRequestInLabels };
 export { warningResultForPrimary };
 //# sourceMappingURL=pull-requests.js.map

package/dist/lib/platform/releases.js

@@ -1,13 +1,6 @@
-import fs from 'node:fs';
-import crypto from 'node:crypto';
 import { resolvePlatformProviderContext } from './context.js';
 import { platformResult } from './types.js';
 import { providerError, providerOperationContext, providerStatus, unsupportedProviderOperation } from './provider-bridge.js';
-function flattenPages(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]).filter((entry) => Boolean(entry) && typeof entry === 'object');
-}
 async function inspectPlatformRelease(tag, options = {}) {
     const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
     const context = loaded.ok ? loaded.value.context : loaded.context;
@@ -32,41 +25,6 @@ async function inspectPlatformRelease(tag, options = {}) {
     }
     return { ...platformResult('failed'), platform: context.platform, release: null, workflows: [], error: context.error };
 }
-async function upsertPlatformRelease(input, options = {}) {
-    const inspected = await inspectPlatformRelease(input.tag, options);
-    if (inspected.release?.published)
-        return { ...inspected, status: 'no-op', changed: false, operations: [] };
-    if (inspected.status === 'blocked' || inspected.status === 'failed')
-        return { ...inspected, changed: false, operations: [] };
-    if (!inspected.platform.repository)
-        return { ...inspected, status: 'no-op', changed: false, operations: [] };
-    const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
-    if (loaded.ok) {
-        let notes;
-        if (input.notesFile) {
-            try {
-                const bytes = fs.readFileSync(input.notesFile);
-                notes = { text: bytes.toString('utf8'), sha256: `sha256:${crypto.createHash('sha256').update(bytes).digest('hex')}`, byteLength: bytes.byteLength };
-            }
-            catch {
-                return { ...inspected, status: 'failed', changed: false, operations: [{ name: 'create-release', status: 'failed' }], error: { code: 'RELEASE_NOTES_FILE_UNREADABLE', message: 'notes-file could not be read', retryable: false } };
-            }
-        }
-        const created = loaded.value.provider.releases?.create
-            ? await loaded.value.provider.releases.create({
-                context: providerOperationContext(loaded.value),
-                tag: input.tag,
-                title: input.title ?? input.tag,
-                ...(notes ? { notes } : {}),
-                mutation: { idempotencyKey: `release:create:${input.tag}` }
-            })
-            : unsupportedProviderOperation(loaded.value.provider, 'releases.create');
-        if (!created.ok)
-            return { ...inspected, status: providerStatus(created.error), changed: false, operations: [{ name: 'create-release', status: 'failed' }], error: providerError(created.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
-        return { ...inspected, status: 'applied', changed: created.value.changed, operations: [{ name: 'create-release', status: 'applied' }], error: null };
-    }
-    return { ...inspected, status: 'failed', changed: false, operations: [{ name: 'create-release', status: 'failed' }], error: { code: 'PLATFORM_PROVIDER_LOAD_FAILED', message: 'Selected provider failed to load', retryable: false } };
-}
 async function reconcileReleaseMilestones(version, options = {}) {
     const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
     if (!match)
@@ -115,5 +73,5 @@ async function reconcileReleaseMilestones(version, options = {}) {
     }
     return { status: 'failed', changed: false, operations: [], error: { code: 'PLATFORM_CAPABILITY_UNSUPPORTED', message: 'Release milestone reconciliation is unavailable', retryable: false } };
 }
-export { inspectPlatformRelease, reconcileReleaseMilestones, upsertPlatformRelease };
+export { inspectPlatformRelease, reconcileReleaseMilestones };
 //# sourceMappingURL=releases.js.map

package/dist/lib/platform/verification-required.js

@@ -5,7 +5,6 @@ import { inspectRequiredChecks } from "./pr-checks.js";
 import { resolvePlatformProviderContext } from "./context.js";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.js";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
-import { resourceIdentityNumber } from "./resource-identity.js";
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
 function readPrFlow(repoRoot) {
@@ -33,7 +32,6 @@ export function evaluateRequiredChecks(context, shared) {
     }
     const fact = factRead.status === "valid" ? factRead.fact : null;
     const prIdentity = fact?.state === "bound" ? fact.identity.resource : null;
-    const prNumber = resourceIdentityNumber(prIdentity);
     if (prFlow === "disabled" || fact?.state === "skipped" || !prIdentity) {
         return shared.passResult(CHECK_TYPE, "Skipped: required checks are not applicable to this task");
     }

package/dist/lib/platform/verification-sync.js

@@ -13,7 +13,7 @@ import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
 import { providerError, providerOperationContext, resourceIdentityNumber, unsupportedProviderOperation } from "./provider-bridge.js";
 import { taskIssueIdentity } from "./task-identities.js";
 import { MARKERS, renderTaskCommentResult } from "./issue-comments.js";
-import { CONTROL_MARKER_PATTERN, canonicalizeCommentBody, renderSafeCodeFence, sanitizeMarkdownDocument } from "./comment-safety.js";
+import { canonicalizeCommentBody, } from "./comment-safety.js";
 const CHECK_TYPE = "platform-sync";
 const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
 const FRONTMATTER_FIELD_MAP = {
@@ -47,10 +47,6 @@ export function getDefaults() {
         }
     };
 }
-function sanitizeCommentContent(content) {
-    const result = sanitizeMarkdownDocument(content, { reservedMarkers: [CONTROL_MARKER_PATTERN] });
-    return result.ok ? result.value : null;
-}
 function infoResult(message) {
     return {
         type: CHECK_TYPE,
@@ -655,32 +651,6 @@ function extractCommentBody(commentBody) {
     }
     return lines.slice(start, end).join("\n");
 }
-function buildExpectedTaskBody(taskContent, shared) {
-    const frontmatterMatch = taskContent.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-    if (!frontmatterMatch) {
-        return sanitizeCommentContent(taskContent.trim());
-    }
-    const body = sanitizeCommentContent(taskContent.slice(frontmatterMatch[0].length).trim());
-    if (body === null) {
-        return null;
-    }
-    return [
-        buildTaskFrontmatterSummary(shared),
-        "",
-        renderSafeCodeFence(frontmatterMatch[0].trim(), "yaml"),
-        "",
-        "</details>",
-        "",
-        body
-    ].join("\n").trim();
-}
-function buildTaskFrontmatterSummary(shared) {
-    const language = loadProjectLanguage(shared);
-    if (language === "en" || language === "en-US") {
-        return "<details><summary>Metadata (frontmatter)</summary>";
-    }
-    return "<details><summary>元数据 (frontmatter)</summary>";
-}
 function loadProjectLanguage(shared) {
     const override = process.env.VALIDATE_ARTIFACT_LANGUAGE;
     if (!shared.isBlank(override)) {
@@ -741,38 +711,6 @@ function mapTaskTypeToIssueType(taskType) {
     };
     return mapping[taskType] || "Task";
 }
-function normalizeIssueFields(payload) {
-    const issue = payload?.data?.repository?.issue;
-    const pinnedFields = Array.isArray(issue?.issueType?.pinnedFields)
-        ? issue.issueType.pinnedFields
-        : [];
-    const values = Array.isArray(issue?.issueFieldValues?.nodes)
-        ? issue.issueFieldValues.nodes
-        : [];
-    const pinnedNames = new Set(pinnedFields
-        .map((field) => typeof field?.name === "string" ? field.name : "")
-        .filter(Boolean));
-    const normalizedValues = new Map();
-    for (const value of values) {
-        const fieldName = value?.field?.name;
-        if (!fieldName) {
-            continue;
-        }
-        if (value.__typename === "IssueFieldSingleSelectValue") {
-            normalizedValues.set(fieldName, {
-                kind: "single-select",
-                value: normalizeOptionName(value.name)
-            });
-        }
-        else if (value.__typename === "IssueFieldDateValue") {
-            normalizedValues.set(fieldName, {
-                kind: "date",
-                value: normalizeDateValue(value.value)
-            });
-        }
-    }
-    return { pinnedNames, values: normalizedValues };
-}
 function normalizeExpectedIssueField(metadataKey, rawValue) {
     const value = String(rawValue || "").trim();
     if (!value) {
@@ -869,22 +807,6 @@ function gitText(args, cwd) {
         };
     }
 }
-function resolvePrHeadSha(context) {
-    const fallback = () => gitText(["rev-parse", "HEAD"], context.taskDir);
-    const branch = String(context.task?.metadata?.branch || "").trim();
-    if (!branch) {
-        return fallback();
-    }
-    const matchedWorktree = resolveBranchWorktree(context.taskDir, branch);
-    if (!matchedWorktree) {
-        return {
-            ok: false,
-            type: "check_failed",
-            message: `Task branch '${branch}' is not checked out in a usable worktree`
-        };
-    }
-    return gitText(["rev-parse", "HEAD"], matchedWorktree);
-}
 function interpolate(template, taskDir, artifactFile) {
     const artifactStem = artifactFile ? path.basename(artifactFile, path.extname(artifactFile)) : "";
     return template