@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/platform/pull-requests.ts

@@ -1,4 +1,3 @@
-import { normalizePullRequest, type RemotePullRequest } from './github-data.ts';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
@@ -6,7 +5,8 @@ import { execFileSync } from 'node:child_process';
 
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { extractSection } from '../task/sections.ts';
+import { activityWarnings, locateActivityLog } from '../task/activity-log.ts';
+import type { TaskMutation } from '../task/write.ts';
 import { captureTaskWriteMetadata, writeTask } from '../task/write.ts';
 import type { PlatformChangeRequestSnapshot } from './snapshots.ts';
 import { resolvePlatformProviderContext } from './context.ts';
@@ -77,7 +77,7 @@ type CreateOptions = SharedOptions & {
   dryRun?: boolean;
   phase?: { value: CreatePhase };
 };
-type BindOptions = SharedOptions & { agent: string; pr: string | number; dryRun?: boolean };
+type BindOptions = SharedOptions & { agent: string; pr: string | number; dryRun?: boolean; expectedHeadSha?: string };
 type PullRequestPrimaryResult = 'pr_created' | 'pr_reused' | 'no_op';
 type SyncOptions = SharedOptions & { agent: string; metadata?: boolean; closingIssue?: boolean; dryRun?: boolean; primaryResult: PullRequestPrimaryResult };
 type ResolveExternalOptions = SharedOptions & { agent: string; pr?: string | number; dryRun?: boolean };
@@ -264,48 +264,6 @@ function expectedHead(repository: string, head: string): { repository: string; r
   return { repository: `${head.slice(0, colon)}/${repoName}`, ref: head.slice(colon + 1) };
 }
 
-function selectPullRequest(remotes: RemotePullRequest[], repository: string, head: string, base: string, expectedSha?: string):
-  | { status: 'resolved'; pullRequest: PullRequestSnapshot }
-  | { status: 'missing' | 'ambiguous' | 'head-mismatch'; pullRequest: null } {
-  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: Awaited<ReturnType<typeof resolvedContext>> & { ok: true },
-  pullRequest: PullRequestSnapshot | null,
-  head: string,
-  baseRef: string,
-  expectedSha: string
-): { ok: true } | { ok: false; error: { code: string; message: string; retryable: boolean } } {
-  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 };
-}
-
 type BindingIdentityOptions = {
   expectedHead?: string;
   expectedHeadSha?: string;
@@ -838,9 +796,11 @@ async function syncPlatformPullRequestInLabels(prToken: string | number, options
   });
 }
 
-function appendActivity(content: string, line: string): string {
-  const body = extractSection(content, ['活动日志', 'Activity Log']);
-  return `${body.replace(/\s+$/, '')}${body.trim() ? '\n' : ''}${line}`;
+function activityMutation(content: string, line: string): TaskMutation[] {
+  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: PullRequestSnapshot) {
@@ -875,16 +835,11 @@ function boundFactFor(
 }
 
 function writeCreateStarted(base: Awaited<ReturnType<typeof resolvedContext>> & { ok: true }, agent: string) {
-  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' as const };
   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 });
 }
 
@@ -922,9 +877,7 @@ function bindIdentity(
     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 });
 }
@@ -946,12 +899,13 @@ async function bindPlatformPullRequestImpl(taskRef: string, options: BindOptions
   if (inspected.status === 'failed' || inspected.status === 'blocked' || !inspected.pullRequest) 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 }
   });
@@ -962,7 +916,7 @@ async function bindPlatformPullRequestImpl(taskRef: string, options: BindOptions
   });
 }
 
-async function bindPlatformPullRequest(taskRef: string, options: BindOptions): Promise<PullRequestResult> {
+async function bindPlatformPullRequestWithProjection(taskRef: string, options: BindOptions): Promise<PullRequestResult> {
   const intent: PlatformPullRequestIntent = { action: 'bind', prToken: String(options.pr) };
   return journalPullRequestOperation(taskRef, options, intent, `pr:${options.pr}`, { pr: String(options.pr) },
     () => bindPlatformPullRequestImpl(taskRef, options));
@@ -1108,30 +1062,15 @@ async function resolveExternalPullRequest(taskRef: string, options: ResolveExter
   }), { 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) 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 }
-  }), { 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 }
+  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: 'Selected identity 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();
@@ -1141,9 +1080,7 @@ async function resolveExternalPullRequest(taskRef: string, options: ResolveExter
     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') return externalResult(result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
@@ -1173,7 +1110,7 @@ async function createPlatformPullRequestImpl(taskRef: string, options: CreateOpt
     }), 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, {
       platform: base.context.platform,
@@ -1196,16 +1133,23 @@ async function recoverCreatedPullRequest(
   if (!base.issueIdentity) 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: string;
+  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 }
       });
@@ -1221,22 +1165,22 @@ async function recoverCreatedPullRequest(
       && 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) return result('blocked', base.resolved.taskId, base.issueNumber, bound.task.prNumber, {
+    || 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: string, options: CreateOptions): Promise<PullRequestResult> {
+async function createPlatformPullRequestWithProjection(taskRef: string, options: CreateOptions): Promise<PullRequestResult> {
   const intent: PlatformPullRequestIntent = { action: 'create', baseRef: options.base, headRef: options.head };
   const identityInput = {
     title: createHash('sha256').update(options.title).digest('hex'),
@@ -1248,7 +1192,6 @@ async function createPlatformPullRequest(taskRef: string, options: CreateOptions
 }
 
 async function createExternalPullRequest(
-  taskRef: string,
   options: CreateOptions,
   base: Extract<Awaited<ReturnType<typeof resolvedContext>>, { ok: true }>
 ): Promise<PullRequestResult> {
@@ -1636,9 +1579,7 @@ function applySkippedPullRequestFact(
     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') return result('failed', resolved.taskId, issueNumber, null, {
@@ -1652,7 +1593,7 @@ function applySkippedPullRequestFact(
   });
 }
 
-async function skipPlatformPullRequestFact(taskRef: string, options: SkipFactOptions): Promise<PullRequestResult> {
+async function skipPlatformPullRequestFactWithProjection(taskRef: string, options: SkipFactOptions): Promise<PullRequestResult> {
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
   if (!resolved.ok) return result('failed', resolved.taskId, null, null, {
     error: { code: resolved.code, message: resolved.message, retryable: false }
@@ -1669,6 +1610,30 @@ async function skipPlatformPullRequestFact(taskRef: string, options: SkipFactOpt
   }
 }
 
-export { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, inspectPlatformPullRequestByNumber, recoverCreatedPullRequest, resolveExternalPullRequest, skipPlatformPullRequestFact, selectExternalPullRequest, selectPullRequest, syncPlatformPullRequest, syncPlatformPullRequestInLabels };
+function withActivityWarnings<T extends PullRequestResult>(taskRef: string, cwd: string | undefined, output: T): T {
+  if (output.status === 'failed' || output.status === 'blocked') return output;
+  const resolved = resolveTaskRef(taskRef, cwd ? { repoRoot: cwd } : {});
+  if (!resolved.ok) return output;
+  let logWarnings: ReturnType<typeof activityWarnings>;
+  try { logWarnings = activityWarnings(fs.readFileSync(resolved.taskMdPath, 'utf8')); }
+  catch { return output; }
+  if (!logWarnings.length) return output;
+  const warnings: OperationWarning[] = logWarnings.map((item) => ({ ...item, retryable: true, step: 'pr', target: resolved.taskId, severity: 'IMPORTANT' }));
+  return { ...output, warnings: mergeOperationWarnings(output.warnings, warnings) };
+}
+async function bindPlatformPullRequest(taskRef: string, options: BindOptions): Promise<PullRequestResult> {
+  return withActivityWarnings(taskRef, options.cwd, await bindPlatformPullRequestWithProjection(taskRef, options));
+}
+async function createPlatformPullRequest(taskRef: string, options: CreateOptions): Promise<PullRequestResult> {
+  return withActivityWarnings(taskRef, options.cwd, await createPlatformPullRequestWithProjection(taskRef, options));
+}
+async function resolveExternalPullRequestWithWarnings(taskRef: string, options: ResolveExternalOptions): Promise<ExternalPullRequestResult> {
+  return withActivityWarnings(taskRef, options.cwd, await resolveExternalPullRequest(taskRef, options));
+}
+async function skipPlatformPullRequestFact(taskRef: string, options: SkipFactOptions): Promise<PullRequestResult> {
+  return withActivityWarnings(taskRef, options.cwd, await skipPlatformPullRequestFactWithProjection(taskRef, options));
+}
+
+export { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, inspectPlatformPullRequestByNumber, recoverCreatedPullRequest, resolveExternalPullRequestWithWarnings as resolveExternalPullRequest, skipPlatformPullRequestFact, selectExternalPullRequest, syncPlatformPullRequest, syncPlatformPullRequestInLabels };
 export type { BindOptions, CreateOptions, ExternalPullRequestResult, ExternalPullRequestSelection, PullRequestPrimaryResult, PullRequestResult, PullRequestSnapshot, ResolveExternalOptions, SkipFactOptions, SyncOptions };
 export { warningResultForPrimary };

package/lib/platform/releases.ts

@@ -1,18 +1,10 @@
-import fs from 'node:fs';
-import crypto from 'node:crypto';
 import { resolvePlatformProviderContext } from './context.ts';
 import type { PlatformClient } from './context.ts';
 import { platformResult } from './types.ts';
 import { providerError, providerOperationContext, providerStatus, unsupportedProviderOperation } from './provider-bridge.ts';
 
-type ReleaseSnapshot = { tag: string; published: boolean; draft: boolean; url: string | null };
 type ReleaseOptions = { cwd?: string; client?: PlatformClient };
 
-function flattenPages(value: unknown): Array<Record<string, unknown>> {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]).filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === 'object');
-}
-
 async function inspectPlatformRelease(tag: string, options: ReleaseOptions = {}) {
   const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
   const context = loaded.ok ? loaded.value.context : loaded.context;
@@ -36,37 +28,6 @@ async function inspectPlatformRelease(tag: string, options: ReleaseOptions = {})
   return { ...platformResult('failed'), platform: context.platform, release: null, workflows: [], error: context.error };
 }
 
-async function upsertPlatformRelease(input: { tag: string; title?: string; notesFile?: string }, options: ReleaseOptions = {}) {
-  const inspected = await inspectPlatformRelease(input.tag, options);
-  if (inspected.release?.published) return { ...inspected, status: 'no-op' as const, changed: false, operations: [] };
-  if (inspected.status === 'blocked' || inspected.status === 'failed') return { ...inspected, changed: false, operations: [] };
-  if (!inspected.platform.repository) return { ...inspected, status: 'no-op' as const, changed: false, operations: [] };
-  const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
-  if (loaded.ok) {
-    let notes: { text: string; sha256: string; byteLength: number } | undefined;
-    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' as const, 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' as const, changed: created.value.changed, operations: [{ name: 'create-release', status: 'applied' }], error: null };
-  }
-  return { ...inspected, status: 'failed' as const, 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: string, options: ReleaseOptions = {}) {
   const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
   if (!match) return { status: 'failed' as const, changed: false, operations: [], error: { code: 'RELEASE_VERSION_INVALID', message: `Invalid version '${version}'` } };
@@ -114,4 +75,4 @@ async function reconcileReleaseMilestones(version: string, options: ReleaseOptio
   return { status: 'failed' as const, changed: false, operations: [], error: { code: 'PLATFORM_CAPABILITY_UNSUPPORTED', message: 'Release milestone reconciliation is unavailable', retryable: false } };
 }
 
-export { inspectPlatformRelease, reconcileReleaseMilestones, upsertPlatformRelease };
+export { inspectPlatformRelease, reconcileReleaseMilestones };

package/lib/platform/verification-required.ts

@@ -6,7 +6,6 @@ import { inspectRequiredChecks } from "./pr-checks.ts";
 import { resolvePlatformProviderContext } from "./context.ts";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.ts";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.ts";
-import { resourceIdentityNumber } from "./resource-identity.ts";
 
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
@@ -36,7 +35,6 @@ export function evaluateRequiredChecks(context: any, shared: any): any {
   }
   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/lib/platform/verification-sync.ts

@@ -17,10 +17,7 @@ import { providerError, providerOperationContext, resourceIdentityNumber, unsupp
 import { taskIssueIdentity } from "./task-identities.ts";
 import { MARKERS, renderTaskCommentResult } from "./issue-comments.ts";
 import {
-  CONTROL_MARKER_PATTERN,
   canonicalizeCommentBody,
-  renderSafeCodeFence,
-  sanitizeMarkdownDocument
 } from "./comment-safety.ts";
 
 const CHECK_TYPE = "platform-sync";
@@ -58,11 +55,6 @@ export function getDefaults(): any {
   };
 }
 
-function sanitizeCommentContent(content: string): string | null {
-  const result = sanitizeMarkdownDocument(content, { reservedMarkers: [CONTROL_MARKER_PATTERN] });
-  return result.ok ? result.value : null;
-}
-
 function infoResult(message: string): any {
   return {
     type: CHECK_TYPE,
@@ -877,36 +869,6 @@ function extractCommentBody(commentBody: any): any {
   return lines.slice(start, end).join("\n");
 }
 
-function buildExpectedTaskBody(taskContent: any, shared: VerificationShared): any {
-  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: VerificationShared): any {
-  const language = loadProjectLanguage(shared);
-  if (language === "en" || language === "en-US") {
-    return "<details><summary>Metadata (frontmatter)</summary>";
-  }
-
-  return "<details><summary>元数据 (frontmatter)</summary>";
-}
-
 function loadProjectLanguage(shared: VerificationShared): any {
   const override = process.env.VALIDATE_ARTIFACT_LANGUAGE;
   if (!shared.isBlank(override)) {
@@ -977,43 +939,6 @@ function mapTaskTypeToIssueType(taskType: any): any {
   return mapping[taskType] || "Task";
 }
 
-function normalizeIssueFields(payload: any): any {
-  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: any) => 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: any, rawValue: any): any {
   const value = String(rawValue || "").trim();
   if (!value) {
@@ -1124,25 +1049,6 @@ function gitText(args: any, cwd: any): any {
   }
 }
 
-function resolvePrHeadSha(context: any): any {
-  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: any, taskDir: any, artifactFile: any): any {
   const artifactStem = artifactFile ? path.basename(artifactFile, path.extname(artifactFile)) : "";
   return template