@fitlab-ai/agent-infra 0.9.15 → 0.10.0

package/lib/internal/task-lifecycle.ts

@@ -7,9 +7,10 @@ import {
 import { lifecycleIntentCatalog } from '../task/lifecycle.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import type { TaskLifecycleResult } from '../task/lifecycle.ts';
+import type { LifecycleRecoveryResult } from '../task/lifecycle-recovery.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --stage <stage> --round <round> --artifact <artifact> --reason <reason>\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
 
 function usageFailure(message: string): void {
   process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
@@ -61,9 +62,9 @@ async function taskLifecycle(args: string[] = []): Promise<void> {
   const result = await dispatchTaskControlOperation(
     createDirectHostExecutionContext({ repoRoot }),
     operation
-  ) as TaskLifecycleResult & { humanOverride?: unknown };
+  ) as (TaskLifecycleResult | LifecycleRecoveryResult) & { humanOverride?: unknown };
   process.stdout.write(`${JSON.stringify(result)}\n`);
-  if (result.status === 'failed') process.exitCode = 1;
+  if (result.status === 'failed' || result.status === 'owner-unknown' || result.status === 'conflict') process.exitCode = 1;
 }
 
 export { taskLifecycle };

package/lib/internal/task-operation-registry.ts

@@ -136,7 +136,6 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'task-activity', 'pr-review-terminate', 'task-bound', 'progress'),
     descriptor('internal', 'task-artifact', 'inspect', 'task-bound', 'diagnostic'),
     descriptor('internal', 'task-artifact', 'init', 'task-bound', 'artifact-write'),
-    descriptor('internal', 'task-artifact', 'repair', 'task-bound', 'artifact-write'),
     descriptor('internal', 'task-artifact', 'finalize-local', 'task-bound', 'artifact-write'),
     descriptor('internal', 'task-orchestration', 'status', 'task-bound', 'diagnostic'),
     descriptor('internal', 'task-orchestration', 'progress', 'task-bound', 'progress'),

package/lib/internal/task-review.ts

@@ -5,7 +5,7 @@ import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--recovery-id <id>] [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 
 function failUsage(message: string): void {
   process.stdout.write(`${JSON.stringify({
@@ -27,7 +27,7 @@ async function taskReview(args: string[] = []): Promise<void> {
   let request;
   try { request = parseReviewCommand(args); }
   catch (error) { failUsage(error instanceof Error ? error.message : String(error)); return; }
-  const { stage, artifact, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
+  const { stage, artifact, recoveryId, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
   const dryRunConflict = overrideDryRunConflict({ dryRun, overrideTicket, overrideTarget, overrideScope });
   if (dryRunConflict) { failUsage(dryRunConflict.message); return; }
   const resolved = resolveTaskRef(args[0]!);
@@ -36,7 +36,7 @@ async function taskReview(args: string[] = []): Promise<void> {
   let humanOverride: unknown = null;
   try {
     result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', async () => {
-      let current = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
+      let current = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true });
       if (current.status !== 'failed' || !overrideTicket) return current;
       if (!overrideTarget || !overrideScope) { failUsage('override ticket requires target and scope'); return current; }
       const consumed = await consumeHumanOverride({
@@ -45,7 +45,7 @@ async function taskReview(args: string[] = []): Promise<void> {
         target: overrideTarget, scope: overrideScope
       }, {
         effectExecutor: (capability) => {
-          const retried = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true, manualOverride: capability });
+          const retried = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true, manualOverride: capability });
           current = retried;
           return retried.status === 'failed' || retried.status === 'planned'
             ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no review effect was committed' : `${retried.error?.code ?? 'REVIEW_FAILED'}: ${retried.error?.message ?? 'manual review effect failed'}` }

package/lib/platform/issue-comments.ts

@@ -50,6 +50,7 @@ const MARKERS = {
   summary: (taskId: string) => `<!-- sync-issue:${taskId}:summary -->`,
   cancel: (taskId: string) => `<!-- sync-issue:${taskId}:cancel -->`
 };
+const COMMENT_BYTE_LIMIT = 60_000;
 
 const ARTIFACT_TITLES: Record<string, string> = {
   analysis: '需求分析',
@@ -67,6 +68,10 @@ function normalizeCommentContent(content: string): string {
   return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
 }
 
+function isTaskCommentTooLarge(content: string): boolean {
+  return Buffer.byteLength(content, 'utf8') > COMMENT_BYTE_LIMIT;
+}
+
 function splitFrontmatter(content: string): { frontmatter: string | null; body: string } {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
   if (!match) return { frontmatter: null, body: content };
@@ -269,7 +274,7 @@ function chunkArtifactComment(input: {
   byteLimit?: number;
   backfill?: boolean;
 }): RenderedChunk[] {
-  const byteLimit = input.byteLimit || 60_000;
+  const byteLimit = input.byteLimit || COMMENT_BYTE_LIMIT;
   const identity = artifactIdentity(input.artifact);
   const safeBody = sanitizeCommentBody(input.body, 'artifact body');
   const single = buildArtifactChunk(
@@ -323,12 +328,6 @@ function flattenComments(value: unknown): RemoteComment[] {
   );
 }
 
-function issueNumberFromTask(content: string): number | null {
-  const value = parseTaskFrontmatter(content).issue_number;
-  const number = Number(value);
-  return Number.isInteger(number) && number > 0 ? number : null;
-}
-
 function listRemoteComments(client: PlatformClient, repo: string, issue: number, cwd: string) {
   const result = client.json<unknown>([
     'api', '--paginate', '--slurp', `repos/${repo}/issues/${issue}/comments?per_page=100`
@@ -452,11 +451,18 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
   }
   const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
   let issueIdentityFromTask: ReturnType<typeof taskIssueIdentity>;
-  try { issueIdentityFromTask = taskIssueIdentity(parseTaskFrontmatter(taskContent), undefined, options.runtimeVersion); }
+  try { issueIdentityFromTask = taskIssueIdentity(parseTaskFrontmatter(taskContent)); }
   catch (error) { return platformResult('failed', { error: { ...taskIssueIdentityError(error), retryable: false } }); }
   if (!issueIdentityFromTask) {
     return platformResult('no-op', {
-      error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+      error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false }
+    });
+  }
+  if (options.kind === 'task' && isTaskCommentTooLarge(taskContent)) {
+    return platformResult('no-op', {
+      resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentityFromTask), identity: issueIdentityFromTask },
+      operations: [{ name: `comment:${MARKERS.task(resolved.taskId)}`, status: 'skipped', reasonCode: 'COMMENT_PAYLOAD_TOO_LARGE' }],
+      error: null
     });
   }
   let desired: RenderedChunk[];
@@ -614,7 +620,7 @@ async function checkPlatformCommentOwner(taskRef: string, options: { cwd?: strin
   if (!resolved.ok) return platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } });
   const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
   let issueIdentity: ReturnType<typeof taskIssueIdentity>;
-  try { issueIdentity = taskIssueIdentity(parseTaskFrontmatter(content), undefined, options.runtimeVersion); }
+  try { issueIdentity = taskIssueIdentity(parseTaskFrontmatter(content)); }
   catch (error) { return platformResult('failed', { error: { ...taskIssueIdentityError(error), retryable: false } }); }
   if (!issueIdentity) return platformResult('no-op', { error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false } });
   const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
@@ -640,6 +646,7 @@ async function checkPlatformCommentOwner(taskRef: string, options: { cwd?: strin
 }
 
 export {
+  COMMENT_BYTE_LIMIT,
   MARKERS,
   chunkArtifactComment,
   findMarkerComments,
@@ -648,6 +655,7 @@ export {
   listPlatformComments,
   normalizeCommentContent,
   renderTaskComment,
+  isTaskCommentTooLarge,
   syncPlatformComment,
   validateRelatedMarkerSet,
   writeComment

package/lib/platform/issues.ts

@@ -85,7 +85,7 @@ async function resolvedContext(taskRef: string, options: SharedOptions) {
   const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
   const frontmatter = parseTaskFrontmatter(content);
   let issueIdentity: ResourceIdentity | null;
-  try { issueIdentity = taskIssueIdentity(frontmatter, undefined, options.runtimeVersion); }
+  try { issueIdentity = taskIssueIdentity(frontmatter); }
   catch (error) {
     return { ok: false as const, output: result('failed', resolved.taskId, null, { error: { ...taskIssueIdentityError(error), retryable: false } }) };
   }

package/lib/platform/pr-change-report.ts

@@ -3,9 +3,11 @@ import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { escapeHtmlText } from './comment-safety.ts';
+import { isResourceIdentity } from './resource-identity.ts';
+import type { ResourceIdentity } from './resource-identity.ts';
 
 const REPORT_FILE_NAME = 'pr-change-report.json';
-const REPORT_VERSION = 1 as const;
+const REPORT_VERSION = 2 as const;
 const CANONICAL_REPORT_PLACEHOLDER = '<!-- canonical-pr-change-report -->';
 const CANONICAL_REPORT_HEADING = '### PR 代码增减';
 const PRECHECK_IDS = [
@@ -83,7 +85,7 @@ type PrecheckCandidate = {
 
 type PullRequestIdentity = {
   repository: string;
-  number: number;
+  resource: ResourceIdentity;
   base: { repository: string; ref: string; sha: string };
   head: { repository: string; ref: string; sha: string };
 };
@@ -279,8 +281,8 @@ function validatePrChangeReport(value: unknown): ValidationResult<PrChangeReport
   }
   const identity = value.identity;
   const identityRepository = identity.repository;
-  const identityNumber = identity.number;
-  if (!isNonEmptyString(identityRepository) || typeof identityNumber !== 'number' || !Number.isSafeInteger(identityNumber) || identityNumber <= 0) return invalid('change report identity is invalid');
+  const identityResource = identity.resource;
+  if (!isNonEmptyString(identityRepository) || !isResourceIdentity(identityResource)) return invalid('change report identity is invalid');
   const parseIdentityPart = (part: unknown, name: string): ValidationResult<{ repository: string; ref: string; sha: string }> => {
     if (!isRecord(part) || !isNonEmptyString(part.repository) || !isNonEmptyString(part.ref) || !isSha(part.sha)) return invalid(`change report identity.${name} is invalid`);
     return { ok: true, value: { repository: part.repository, ref: part.ref, sha: part.sha } };
@@ -315,7 +317,7 @@ function validatePrChangeReport(value: unknown): ValidationResult<PrChangeReport
       version: REPORT_VERSION,
       identity: {
         repository: identityRepository,
-        number: identityNumber,
+        resource: identityResource,
         base: base.value,
         head: head.value
       },

package/lib/platform/pr-summary.ts

@@ -16,6 +16,8 @@ import { platformResult } from './types.ts';
 import type { PlatformResult } from './types.ts';
 import type { OperationWarning } from '../task/operation-outcome.ts';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, resourceIdentityNumber, unsupportedProviderOperation } from './provider-bridge.ts';
+import { resourceIdentityEquals } from './resource-identity.ts';
+import type { ResourceIdentity } from './resource-identity.ts';
 import type { PlatformChangeRequestSnapshot } from './snapshots.ts';
 import type { ChangeRequestSnapshot } from './provider-contract.ts';
 import {
@@ -102,12 +104,17 @@ function taskReportPath(taskDir: string): string {
   return path.join(taskDir, 'pr-change-report.json');
 }
 
-function readBoundTaskSnapshot(taskMdPath: string): { taskContent: string; boundFact: Extract<PrDeliveryFact, { state: 'bound' }> | null } {
+function readBoundTaskSnapshot(taskMdPath: string): {
+  taskContent: string;
+  boundFact: Extract<PrDeliveryFact, { state: 'bound' }> | null;
+  factError: { code: string; message: string } | null;
+} {
   const taskContent = fs.readFileSync(taskMdPath, 'utf8');
   const frontmatter = parseTypedTaskFrontmatter(taskContent);
   const fact = readPrDeliveryFact(frontmatter);
   const boundFact = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact : null;
-  return { taskContent, boundFact };
+  const factError = fact.status === 'invalid' ? { code: fact.error.code, message: fact.error.message } : null;
+  return { taskContent, boundFact, factError };
 }
 
 function boundPrNumberForWarning(taskMdPath: string): number | null {
@@ -189,7 +196,7 @@ function inspectionError(error: { code: string; message: string; retryable: bool
 async function inspectBoundPullRequest(
   context: PlatformResult,
   repoRoot: string,
-  prNumber: number,
+  prIdentity: ResourceIdentity,
   loadedContext?: LoadedContext
 ): Promise<{ ok: true; value: PlatformChangeRequestSnapshot } | { ok: false; error: PlatformResult['error']; status: PlatformResult['status'] }> {
   if (!context.platform.repository) {
@@ -199,16 +206,15 @@ async function inspectBoundPullRequest(
     ? { ok: true as const, value: loadedContext }
     : await resolvePlatformProviderContext({ cwd: repoRoot });
   if (!loaded.ok) return { ok: false, status: loaded.context.status, error: loaded.context.error };
-  const target = providerResourceToken(loaded.value.provider, 'pull-request', String(prNumber));
   const inspected = loaded.value.provider.changeRequests?.inspect
-    ? await loaded.value.provider.changeRequests.inspect({ context: providerOperationContext(loaded.value), target })
+    ? await loaded.value.provider.changeRequests.inspect({ context: providerOperationContext(loaded.value), target: prIdentity })
     : unsupportedProviderOperation(loaded.value.provider, 'changeRequests.inspect');
   if (!inspected.ok) {
     const error = providerError(inspected.error, 'PLATFORM_PROVIDER_OPERATION_FAILED');
     return { ok: false, status: inspectionError(error), error };
   }
   const remote: ChangeRequestSnapshot = inspected.value;
-  const number = remote.number ?? resourceIdentityNumber(remote.identity) ?? prNumber;
+  const number = remote.number ?? resourceIdentityNumber(remote.identity) ?? resourceIdentityNumber(prIdentity) ?? 0;
   const head = remote.head || { repository: context.platform.repository, ref: '', sha: remote.headSha || '' };
   const base = remote.base || { repository: context.platform.repository, ref: '', sha: remote.baseSha || '' };
   return {
@@ -216,6 +222,7 @@ async function inspectBoundPullRequest(
     value: {
       repository: context.platform.repository,
       number,
+      identity: remote.identity ?? prIdentity,
       nodeId: remote.id,
       url: remote.displayUrl || '',
       state: remote.state === 'closed' ? 'closed' : 'open',
@@ -237,21 +244,22 @@ async function inspectBoundPullRequest(
 function sameIdentity(left: PlatformChangeRequestSnapshot, right: PlatformChangeRequestSnapshot): boolean {
   return JSON.stringify({
     repository: left.repository,
-    number: left.number,
+    identity: left.identity ?? null,
     base: left.base,
     head: left.head
   }) === JSON.stringify({
     repository: right.repository,
-    number: right.number,
+    identity: right.identity ?? null,
     base: right.base,
     head: right.head
   });
 }
 
 function identityFromSnapshot(snapshot: PlatformChangeRequestSnapshot) {
+  if (!snapshot.identity) throw new Error('pull-request snapshot has no canonical identity');
   return {
     repository: snapshot.repository,
-    number: snapshot.number,
+    resource: snapshot.identity,
     base: { ...snapshot.base },
     head: { ...snapshot.head }
   };
@@ -286,7 +294,7 @@ function currentReportCheck(
   const digest = taskIntentDigest(taskContent);
   if (!digest.ok) return { ok: false, error: platformError(digest.error) };
   const reportIdentity = report.identity;
-  if (reportIdentity.repository !== snapshot.repository || reportIdentity.number !== snapshot.number ||
+  if (reportIdentity.repository !== snapshot.repository || !resourceIdentityEquals(reportIdentity.resource, snapshot.identity) ||
       JSON.stringify(reportIdentity.base) !== JSON.stringify(snapshot.base) || JSON.stringify(reportIdentity.head) !== JSON.stringify(snapshot.head)) return {
     ok: false,
     error: { code: 'PR_CHANGE_REPORT_STALE', message: 'Change report identity does not match the authoritative pull request snapshot', retryable: false }
@@ -343,14 +351,22 @@ async function summaryContext(taskRef: string, options: SummaryOptions = {}): Pr
   };
   const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
   const frontmatter = parseTypedTaskFrontmatter(taskContent);
-  const fact = readPrDeliveryFact(frontmatter, options.runtimeVersion);
-  const prNumber = fact.status === 'valid' && fact.fact.state === 'bound' ? resourceIdentityNumber(fact.fact.identity.resource) : null;
   const reportPath = taskReportPath(resolved.taskDir);
+  const fact = readPrDeliveryFact(frontmatter, options.runtimeVersion);
+  if (fact.status === 'invalid') return {
+    ...platformResult('failed', { error: { code: fact.error.code, message: fact.error.message, retryable: false } }),
+    task: { id: resolved.taskId, prNumber: null },
+    pullRequest: null,
+    changeReport: { status: 'invalid', path: reportPath, taskIntentSha256: null, reason: fact.error.message },
+    artifacts: []
+  };
+  const prIdentity = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.resource : null;
+  const prNumber = resourceIdentityNumber(prIdentity);
   const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
   const context = loaded.ok ? loaded.value.context : loaded.context;
   let pullRequest: PlatformChangeRequestSnapshot | null = null;
-  if (loaded.ok && prNumber && context.platform.repository && ['no-op', 'degraded'].includes(context.status)) {
-    const inspected = await inspectBoundPullRequest(context, resolved.repoRoot, prNumber, loaded.value);
+  if (loaded.ok && prIdentity && context.platform.repository && ['no-op', 'degraded'].includes(context.status)) {
+    const inspected = await inspectBoundPullRequest(context, resolved.repoRoot, prIdentity, loaded.value);
     if (inspected.ok) pullRequest = inspected.value;
   }
   const report = summaryReportStatus(reportPath, pullRequest, taskContent, resolved.repoRoot);
@@ -370,12 +386,13 @@ async function summaryContext(taskRef: string, options: SummaryOptions = {}): Pr
 
 async function summaryCommentState(taskRef: string, options: SummaryOptions = {}): Promise<SummaryCommentStateResult> {
   const context = await summaryContext(taskRef, options);
-  if (!context.task.prNumber || !context.pullRequest) return { ...context, comment: null };
+  const prIdentity = context.pullRequest?.identity;
+  if (!prIdentity) return { ...context, comment: null };
   const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
   if (!loaded.ok || !loaded.value.provider.comments?.list) return { ...context, comment: null };
   const listed = await loaded.value.provider.comments.list({
     context: providerOperationContext(loaded.value),
-    parent: providerResourceToken(loaded.value.provider, 'pull-request', String(context.task.prNumber))
+    parent: prIdentity
   });
   if (!listed.ok) return { ...context, comment: null };
   const matches = listed.value.filter((comment) => comment.body.includes(summaryMarker(context.task.id!)));
@@ -397,24 +414,38 @@ type ReportWriteOptions = {
 async function reportWrite(taskRef: string, options: ReportWriteOptions): Promise<ReportWriteResult> {
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
   if (!resolved.ok) return { ...platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } }), report: null };
+  let preflight: ReturnType<typeof readBoundTaskSnapshot>;
+  try {
+    preflight = readBoundTaskSnapshot(resolved.taskMdPath);
+  } catch (error) {
+    return {
+      ...platformResult('failed', { error: { code: 'PR_CHANGE_REPORT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false } }),
+      report: null
+    };
+  }
+  if (preflight.factError) return {
+    ...platformResult('failed', { error: { code: preflight.factError.code, message: preflight.factError.message, retryable: false } }),
+    report: null
+  };
   const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
   const context = loaded.ok ? loaded.value.context : loaded.context;
   if (!loaded.ok || !context.platform.repository || !['no-op', 'degraded'].includes(context.status)) return { ...context, report: null };
   let knownPrNumber: number | null = null;
   try {
     return await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, options.agent, async () => {
-      const { taskContent, boundFact } = readBoundTaskSnapshot(resolved.taskMdPath);
-      if (!boundFact) return {
-        ...basePlatformResult('failed', context, resolved.taskId, null, { code: 'PR_NOT_LINKED', message: 'Task has no verified bound pull request', retryable: false }),
+      const { taskContent, boundFact, factError } = readBoundTaskSnapshot(resolved.taskMdPath);
+      if (factError) return {
+        ...basePlatformResult('failed', context, resolved.taskId, null, { code: factError.code, message: factError.message, retryable: false }),
         report: null
       };
-      const boundPrNumber = resourceIdentityNumber(boundFact.identity.resource);
-      if (!boundPrNumber) return {
-        ...basePlatformResult('failed', context, resolved.taskId, null, { code: 'PR_NUMBER_INVALID', message: 'Bound pull request has no numeric identifier', retryable: false }),
+      if (!boundFact) return {
+        ...basePlatformResult('failed', context, resolved.taskId, null, { code: 'PR_NOT_LINKED', message: 'Task has no verified bound pull request', retryable: false }),
         report: null
       };
+      const boundPrIdentity = boundFact.identity.resource;
+      const boundPrNumber = resourceIdentityNumber(boundPrIdentity);
       knownPrNumber = boundPrNumber;
-      const initial = await inspectBoundPullRequest(context, resolved.repoRoot, boundPrNumber, loaded.value);
+      const initial = await inspectBoundPullRequest(context, resolved.repoRoot, boundPrIdentity, loaded.value);
       if (!initial.ok) return { ...basePlatformResult(initial.status, context, resolved.taskId, boundPrNumber, initial.error), report: null };
       const digest = taskIntentDigest(taskContent);
       if (!digest.ok) return { ...basePlatformResult('failed', context, resolved.taskId, boundPrNumber, platformError(digest.error)), report: null };
@@ -438,7 +469,7 @@ async function reportWrite(taskRef: string, options: ReportWriteOptions): Promis
       };
       const built = buildPrChangeReport(identityFromSnapshot(initial.value), digest.value.sha256, mechanical.value, candidate.value);
       if (!built.ok) return { ...basePlatformResult('failed', context, resolved.taskId, boundPrNumber, platformError(built.error)), report: null };
-      const final = await inspectBoundPullRequest(context, resolved.repoRoot, boundPrNumber, loaded.value);
+      const final = await inspectBoundPullRequest(context, resolved.repoRoot, boundPrIdentity, loaded.value);
       if (!final.ok) return { ...basePlatformResult(final.status, context, resolved.taskId, boundPrNumber, final.error), report: null };
       if (!sameIdentity(initial.value, final.value)) return {
         ...basePlatformResult('blocked', context, resolved.taskId, boundPrNumber, { code: 'PR_CHANGE_REPORT_HEAD_RACE', message: 'Pull request identity changed while generating the change report', retryable: true }),
@@ -535,26 +566,27 @@ async function syncPullRequestSummary(
   }
   try {
     const execute = async (): Promise<PullRequestSummaryResult> => {
-      const { taskContent, boundFact } = readBoundTaskSnapshot(resolved.taskMdPath);
+      const { taskContent, boundFact, factError } = readBoundTaskSnapshot(resolved.taskMdPath);
+      if (factError) return {
+        ...platformResult('failed', { resource: { kind: 'pull-request', number: null }, error: { code: factError.code, message: factError.message, retryable: false } }),
+        result: null, warnings: []
+      };
       if (!boundFact) return {
         ...platformResult('failed', { resource: { kind: 'pull-request', number: null }, error: { code: 'PR_NOT_LINKED', message: 'Task has no verified bound pull request', retryable: false } }),
         result: null, warnings: []
       };
       const prIdentity = boundFact.identity.resource;
       const boundPrNumber = resourceIdentityNumber(prIdentity);
-      if (!boundPrNumber) return {
-        ...platformResult('failed', { resource: { kind: 'pull-request', number: null }, error: { code: 'PR_NUMBER_INVALID', message: 'Bound pull request has no numeric identifier', retryable: false } }),
-        result: null, warnings: []
-      };
       knownPrNumber = boundPrNumber;
       const prNumber = boundPrNumber;
-      const initial = await inspectBoundPullRequest(context, resolved.repoRoot, boundPrNumber, loaded.value);
+      const initial = await inspectBoundPullRequest(context, resolved.repoRoot, prIdentity, loaded.value);
       if (!initial.ok) return fail(initial.status, context, initial.error);
       const manual = options.manualValidation;
       const hasFinalManualValidation = /###\s+✅\s+(?:Manual Validation Passed|人工验证已通过)/u.test(options.body);
       if (hasFinalManualValidation && (!manual || manual.phase !== 'final')) return fail('failed', context, { code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'final manual-validation summary requires the transaction coordinator', retryable: false }, prNumber);
       if (manual && (manual.phase === 'pending' ? hasFinalManualValidation : !hasFinalManualValidation)) return fail('failed', context, { code: 'MANUAL_VALIDATION_SUMMARY_PHASE_INVALID', message: 'manual-validation summary phase does not match the requested writer phase', retryable: false }, prNumber);
       if (manual) {
+        if (prNumber === null) return fail('failed', context, { code: 'MANUAL_VALIDATION_PR_NUMBER_REQUIRED', message: 'manual-validation summary requires a numeric pull-request identity', retryable: false }, prNumber);
         if (manual.phase === 'final' && (!manual.transactionId || !manual.receiptDigest || !manual.prHeadSha || manual.prHeadSha !== initial.value.head.sha)) return fail('failed', context, { code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'final manual-validation summary requires transaction, receipt, and current head identity', retryable: false }, prNumber);
         if (manual.phase === 'final') {
           if (manual.authority !== 'coordinator') return fail('failed', context, { code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'final manual-validation summary requires coordinator authority', retryable: false }, prNumber);
@@ -621,7 +653,7 @@ async function syncPullRequestSummary(
         ? listed.value.find((comment) => comment.id === reconciliation.commentId)?.body ?? null
         : null;
       const info = { precheckVerdict: report.value.precheck.verdict, nextAction: report.value.precheck.route } as const;
-      const beforeWrite = await inspectBoundPullRequest(context, resolved.repoRoot, boundPrNumber, loaded.value);
+      const beforeWrite = await inspectBoundPullRequest(context, resolved.repoRoot, prIdentity, loaded.value);
       if (!beforeWrite.ok) return fail(beforeWrite.status, context, beforeWrite.error, prNumber);
       if (!sameIdentity(initial.value, beforeWrite.value)) return fail('blocked', context, {
         code: 'PR_SUMMARY_HEAD_RACE',
@@ -651,7 +683,7 @@ async function syncPullRequestSummary(
         })
         : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
       if (!written.ok) return fail(providerStatus(written.error) === 'blocked' ? 'blocked' : 'failed', context, providerError(written.error, 'PLATFORM_PROVIDER_OPERATION_FAILED'), prNumber);
-      const after = await inspectBoundPullRequest(context, resolved.repoRoot, prNumber, loaded.value);
+      const after = await inspectBoundPullRequest(context, resolved.repoRoot, prIdentity, loaded.value);
       const id = /^\d+$/.test(written.value.remoteId) ? Number(written.value.remoteId) : written.value.remoteId;
       const compensateWrittenSummary = async () => reconciliation.action === 'create'
         ? written.value.remoteId && loaded.value.provider.comments?.delete

package/lib/platform/pull-requests.ts

@@ -376,7 +376,7 @@ async function resolvedContext(taskRef: string, options: InspectionOptions) {
   }) };
   const fact = factRead.status === 'valid' ? factRead.fact : null;
   let issueIdentity: ResourceIdentity | null;
-  try { issueIdentity = taskIssueIdentity(frontmatter, undefined, options.runtimeVersion); }
+  try { issueIdentity = taskIssueIdentity(frontmatter); }
   catch (error) { return { ok: false as const, output: result('failed', resolved.taskId, null, null, { error: { ...taskIssueIdentityError(error), retryable: false } }) }; }
   const issueNumber = resourceIdentityNumber(issueIdentity);
   const prIdentity = fact?.state === 'bound' ? fact.identity.resource : null;
@@ -941,7 +941,7 @@ async function resolveExternalPullRequest(taskRef: string, options: ResolveExter
   if (!base.issueIdentity) return externalResult(result('failed', base.resolved.taskId, null, base.prNumber, {
     platform: base.context.platform,
     capabilities: base.context.capabilities,
-    error: { code: 'EXTERNAL_DELIVERY_ISSUE_REQUIRED', message: 'External delivery requires a valid issue_number', retryable: false }
+    error: { code: 'EXTERNAL_DELIVERY_ISSUE_REQUIRED', message: 'External delivery requires a valid platform issue identity', retryable: false }
   }));
   const inspected = base.provider.changeRequests?.listClosing
     ? await base.provider.changeRequests.listClosing({
@@ -1430,7 +1430,7 @@ function skipPlatformPullRequestFactUnlocked(
     });
   }
   let issueIdentity: ResourceIdentity | null;
-  try { issueIdentity = taskIssueIdentity(frontmatter, undefined, options.runtimeVersion); }
+  try { issueIdentity = taskIssueIdentity(frontmatter); }
   catch (error) { return result('failed', resolved.taskId, null, null, { error: { ...taskIssueIdentityError(error), retryable: false } }); }
   const issueNumber = resourceIdentityNumber(issueIdentity);
   const existing = readPrDeliveryFact(frontmatter, options.runtimeVersion);

package/lib/platform/task-identities.ts

@@ -1,13 +1,8 @@
-import type { ProviderIdentityDeclaration, ResourceIdentity } from './resource-identity.ts';
+import type { ResourceIdentity } from './resource-identity.ts';
 import { parseResourceIdentity } from './resource-identity.ts';
-import { isLegacyCompatibilityEnabled, legacyCompatibilityError, VERSION } from '../version.ts';
 import { parse as parseYaml } from 'yaml';
 
-function taskIssueIdentity(
-  frontmatter: Record<string, string | number | boolean | null>,
-  _declaration?: ProviderIdentityDeclaration,
-  runtimeVersion = VERSION
-): ResourceIdentity | null {
+function taskIssueIdentity(frontmatter: Record<string, string | number | boolean | null>): ResourceIdentity | null {
   const serialized = frontmatter.platform_issue_identity;
   if (typeof serialized === 'string' && serialized.trim()) {
     try {
@@ -20,13 +15,7 @@ function taskIssueIdentity(
       return null;
     }
   }
-  const legacy = frontmatter.issue_number;
-  const number = typeof legacy === 'number' ? legacy : typeof legacy === 'string' && /^[1-9]\d*$/u.test(legacy) ? Number(legacy) : NaN;
-  // TODO(compat): Remove the numeric issue_number fallback before the first stable v1.0.0 release.
-  if (Number.isSafeInteger(number) && number > 0 && !isLegacyCompatibilityEnabled(runtimeVersion)) {
-    throw legacyCompatibilityError('issue_number', runtimeVersion);
-  }
-  return Number.isSafeInteger(number) && number > 0 ? { kind: 'number', value: number } : null;
+  return null;
 }
 
 function taskIssueIdentityError(error: unknown): { code: string; message: string } {

package/lib/platform/verification-sync.ts

@@ -12,6 +12,7 @@ import { planInLabelUpdate, validateInLabelMapping } from "./in-label-sync.ts";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.ts";
 import { providerError, providerOperationContext, resourceIdentityNumber, unsupportedProviderOperation } from "./provider-bridge.ts";
 import { taskIssueIdentity } from "./task-identities.ts";
+import { isTaskCommentTooLarge } from "./issue-comments.ts";
 import {
   CONTROL_MARKER_PATTERN,
   canonicalizeCommentBody,
@@ -113,8 +114,8 @@ async function buildSyncContext({ taskDir, config, artifactFile }: any, shared:
   }
   const prIdentity = fact.status === "valid" && fact.fact.state === "bound" ? fact.fact.identity.resource : null;
   const prNumber = resourceIdentityNumber(prIdentity);
-  if (config.when === "issue_number_exists" && !issueIdentity) {
-    return { earlyReturn: shared.passResult(CHECK_TYPE, "Skipped: task has no issue_number") };
+  if (config.when === "platform_issue_identity_exists" && !issueIdentity) {
+    return { earlyReturn: shared.passResult(CHECK_TYPE, "Skipped: task has no platform_issue_identity") };
   }
   if (config.when === "pr_fact_bound" && !prIdentity) {
     return { earlyReturn: shared.passResult(CHECK_TYPE, "Skipped: task has no verified bound pull request") };
@@ -541,6 +542,9 @@ function checkTaskCommentContent(context: any, remoteData: any, shared: Verifica
   if (!context.config.verify_task_comment_content) {
     return null;
   }
+  if (isTaskCommentTooLarge(context.task.content)) {
+    return null;
+  }
 
   const taskMarker = `<!-- sync-issue:${context.task.metadata.id}:task -->`;
   const comment = findCommentByMarker(remoteData.comments, taskMarker);

package/lib/pr-review/evidence-grading.ts

@@ -37,11 +37,6 @@ export class HostResolutionError extends Error {
   }
 }
 
-function toPositiveNumber(value: unknown): number | null {
-  const n = Number(value);
-  return Number.isInteger(n) && n > 0 ? n : null;
-}
-
 /**
  * Parse the PR body for closing-issue references. Handles the conventional
  * `Closes #1` / `Fixes: #2, #3` shapes (case-insensitive, comma/space
@@ -68,7 +63,7 @@ export function extractClosingIssueNumbers(body: string): number[] {
 /**
  * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
  * PR number or to one of the PR's closing issues. A task is emitted at most once;
- * a verified fact identity hit takes priority over the issue-number reverse lookup.
+ * a verified fact identity hit takes priority over the issue-identity reverse lookup.
  */
 export function collectHostCandidates(input: {
   prNumber?: number;
@@ -97,7 +92,7 @@ export function collectHostCandidates(input: {
     let frontmatter: ReturnType<typeof parseTypedTaskFrontmatter>;
     try { frontmatter = parseTypedTaskFrontmatter(content); } catch { continue; }
     const issueIdentity = taskIssueIdentity(frontmatter);
-    const issueNumber = resourceIdentityNumber(issueIdentity) ?? toPositiveNumber(frontmatter.issue_number);
+    const issueNumber = resourceIdentityNumber(issueIdentity);
     const fact = readPrDeliveryFact(frontmatter);
     const prIdentity = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.resource : null;
     const prNumber = resourceIdentityNumber(prIdentity);
@@ -209,8 +204,8 @@ function isTrusted(head: HeadState): boolean {
 /**
  * Derive the S1(a) trust factor `taskIssueMatches` (PL-3) mechanically from
  * resolved data: a unique host is trusted on the issue dimension only when the
- * task's bound issue_number is among the PR's closing issues. Ambiguous/none
- * hosts and tasks without a positive issue_number cannot be confirmed -> false
+ * task's bound issue identity is among the PR's closing issues. Ambiguous/none
+ * hosts and tasks without a numeric issue identity cannot be confirmed -> false
  * (fail closed to S2/audit). `resolve-host` emits this value so the prompt layer
  * does not derive the trust factor ad hoc (CD-2).
  */