@fitlab-ai/agent-infra 0.9.2 → 0.9.4

package/lib/internal/task-lifecycle.ts

@@ -1,5 +1,8 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.ts';
 import type { TaskLifecycleRequest } from '../task/lifecycle.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 
 const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\n`;
 const FLAGS: Record<string, string> = {
@@ -33,7 +36,29 @@ function taskLifecycle(args: string[] = []): void {
     seen.add(flag);
     values[key] = key === 'alertNumber' || key === 'issueNumber' ? Number(value) : value;
   }
-  const result = applyTaskLifecycle(values as TaskLifecycleRequest);
+  const agent = normalizeAgentToken(String(values.agent ?? ''));
+  if (!agent) { usageFailure(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`); return; }
+  values.agent = agent;
+  const resolved = resolveTaskRef(String(values.taskRef));
+  if (!resolved.ok) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: resolved.code, message: resolved.message } })}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  let result: ReturnType<typeof applyTaskLifecycle>;
+  try {
+    result = withTaskExecutionLock(
+      resolved.repoRoot,
+      resolved.taskId,
+      `task-lifecycle.${String(values.intent)}`,
+      () => applyTaskLifecycle(values as TaskLifecycleRequest)
+    );
+  } catch (error) {
+    if (!(error instanceof TaskExecutionLockError)) throw error;
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
+    process.exitCode = 1;
+    return;
+  }
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

package/lib/internal/task-orchestration.ts

@@ -1,19 +1,26 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import {
+  abortCommitIntent,
   activateMatchingOrchestrationDelegation,
   activateOrchestrationDelegation,
   advanceOrchestration,
+  beginCommitIntent,
   beginOrResumeOrchestration,
-  completeCommitOrchestrationStage,
+  checkpointCommitIntent,
+  completeCommitIntent,
   pauseOrchestration,
   prepareOrchestrationDelegation,
+  recoverCommitIntent,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
   sealOrchestrationDelegation,
+  statusCommitIntent,
   statusOrchestration
 } from '../task/orchestration.ts';
+import { isAgentClientId } from '../agent-clients/types.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
 
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|stage-completed|hook-stop|advance|pause|status> [options]\n';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|hook-stop|advance|pause|status|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-status> [options]\n';
 
 function usageFailure(message: string): void {
   process.stdout.write(`${JSON.stringify({
@@ -34,18 +41,32 @@ function taskOrchestration(args: string[] = []): void {
     return;
   }
   const [taskRef, intent] = args;
-  if (!['begin-or-resume', 'route', 'prepare', 'hook-start', 'stage-completed', 'hook-stop', 'advance', 'pause', 'status'].includes(intent!)) {
+  if (![
+    'begin-or-resume', 'route', 'prepare', 'hook-start', 'hook-stop', 'advance', 'pause', 'status',
+    'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-status'
+  ].includes(intent!)) {
     usageFailure(`unknown intent '${intent}'`);
     return;
   }
   const values: Record<string, string> = {};
   const seen = new Set<string>();
+  let orchestrated = false;
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
+    if (flag === '--orchestrated') {
+      if (seen.has(flag)) { usageFailure(`duplicate option '${flag}'`); return; }
+      seen.add(flag);
+      orchestrated = true;
+      continue;
+    }
     if (![
-      '--max-steps', '--client', '--requested-model', '--parent-id', '--before-fingerprint',
-      '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--fallback-reason',
-      '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent'
+      '--max-steps', '--executor-model', '--executor-reasoning-effort',
+      '--reviewer-model', '--reviewer-reasoning-effort',
+      '--client', '--requested-model', '--requested-reasoning-effort', '--parent-id', '--before-fingerprint',
+      '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
+      '--model-fallback-reason', '--reasoning-effort-fallback-reason',
+      '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent',
+      '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
     ].includes(flag)) {
       usageFailure(`unknown option '${flag}'`);
       return;
@@ -62,14 +83,102 @@ function taskOrchestration(args: string[] = []): void {
     }
     values[flag] = value;
   }
+  const commitIntentFlags: Record<string, readonly string[]> = {
+    'commit-begin': ['--agent', '--baseline-head', '--orchestrated'],
+    'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref'],
+    'commit-complete': ['--token', '--agent'],
+    'commit-recover': ['--agent'],
+    'commit-abort': ['--token', '--expected-head'],
+    'commit-status': []
+  };
+  if (intent! in commitIntentFlags) {
+    const allowed = commitIntentFlags[intent!]!;
+    const invalid = [...seen].find((flag) => !allowed.includes(flag));
+    if (invalid) { usageFailure(`intent '${intent}' does not accept '${invalid}'`); return; }
+  } else {
+    const commitOnly = [...seen].find((flag) => [
+      '--orchestrated', '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
+    ].includes(flag));
+    if (commitOnly) { usageFailure(`intent '${intent}' does not accept '${commitOnly}'`); return; }
+  }
   const requireValues = (flags: string[]) => flags.find((flag) => values[flag] === undefined);
+  if (values['--client'] !== undefined && !isAgentClientId(values['--client'])) {
+    usageFailure(`unknown client '${values['--client']}'`);
+    return;
+  }
   let result;
-  if (intent === 'begin-or-resume') {
+  if (intent === 'commit-begin') {
+    const missing = requireValues(['--agent', '--baseline-head']);
+    if (missing) { usageFailure(`intent 'commit-begin' requires '${missing}'`); return; }
+    const agent = normalizeAgentToken(values['--agent']!);
+    if (!agent) { usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`); return; }
+    result = beginCommitIntent(taskRef!, {
+      agent, orchestrated, baselineHead: values['--baseline-head']!
+    });
+  } else if (intent === 'commit-checkpoint') {
+    const missing = requireValues(['--token', '--kind', '--head']);
+    if (missing) { usageFailure(`intent 'commit-checkpoint' requires '${missing}'`); return; }
+    if (!['committed', 'pushed'].includes(values['--kind']!)) {
+      usageFailure('--kind must be committed or pushed'); return;
+    }
+    if (values['--kind'] === 'pushed') {
+      const pushedMissing = requireValues(['--remote', '--ref']);
+      if (pushedMissing) { usageFailure(`pushed checkpoint requires '${pushedMissing}'`); return; }
+    } else if (values['--remote'] !== undefined || values['--ref'] !== undefined) {
+      usageFailure('committed checkpoint does not accept --remote or --ref'); return;
+    }
+    result = checkpointCommitIntent(taskRef!, {
+      token: values['--token']!, kind: values['--kind'] as 'committed' | 'pushed',
+      head: values['--head']!, remote: values['--remote'], ref: values['--ref']
+    });
+  } else if (intent === 'commit-complete') {
+    const missing = requireValues(['--token', '--agent']);
+    if (missing) { usageFailure(`intent 'commit-complete' requires '${missing}'`); return; }
+    const agent = normalizeAgentToken(values['--agent']!);
+    if (!agent) { usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`); return; }
+    result = completeCommitIntent(taskRef!, { token: values['--token']!, agent });
+  } else if (intent === 'commit-recover') {
+    const missing = requireValues(['--agent']);
+    if (missing) { usageFailure(`intent 'commit-recover' requires '${missing}'`); return; }
+    const agent = normalizeAgentToken(values['--agent']!);
+    if (!agent) { usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`); return; }
+    result = recoverCommitIntent(taskRef!, { agent });
+  } else if (intent === 'commit-abort') {
+    const missing = requireValues(['--token', '--expected-head']);
+    if (missing) { usageFailure(`intent 'commit-abort' requires '${missing}'`); return; }
+    result = abortCommitIntent(taskRef!, { token: values['--token']!, expectedHead: values['--expected-head']! });
+  } else if (intent === 'commit-status') {
+    result = statusCommitIntent(taskRef!);
+  } else if (intent === 'begin-or-resume') {
+    const missing = requireValues(['--client']);
+    if (missing) { usageFailure(`intent 'begin-or-resume' requires '${missing}'`); return; }
     const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
     if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
       usageFailure('--max-steps must be a positive integer'); return;
     }
-    result = beginOrResumeOrchestration(taskRef!, { maxSteps });
+    const policyFlags = [
+      '--executor-model', '--executor-reasoning-effort',
+      '--reviewer-model', '--reviewer-reasoning-effort'
+    ];
+    const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
+    if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
+      usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
+      return;
+    }
+    result = beginOrResumeOrchestration(taskRef!, {
+      maxSteps,
+      client: values['--client'] as AgentClientId,
+      modelPolicy: hasAnyPolicy ? {
+        executor: {
+          model: values['--executor-model']!,
+          reasoningEffort: values['--executor-reasoning-effort']!
+        },
+        reviewer: {
+          model: values['--reviewer-model']!,
+          reasoningEffort: values['--reviewer-reasoning-effort']!
+        }
+      } : undefined
+    });
   } else if (intent === 'route') {
     result = routeOrchestration(taskRef!);
   } else if (intent === 'status') {
@@ -79,7 +188,8 @@ function taskOrchestration(args: string[] = []): void {
     if (missing) { usageFailure(`intent 'prepare' requires '${missing}'`); return; }
     result = prepareOrchestrationDelegation(taskRef!, {
       client: values['--client'] as AgentClientId,
-      requestedModel: values['--requested-model']
+      requestedModel: values['--requested-model'],
+      requestedReasoningEffort: values['--requested-reasoning-effort']
     });
   } else if (intent === 'hook-start') {
     const missing = requireValues([
@@ -90,7 +200,10 @@ function taskOrchestration(args: string[] = []): void {
     const event = {
       nativeAgent: values['--native-agent']!, childId: values['--child-id']!,
       parentId: values['--parent-id']!, spawnMode: values['--spawn-mode']!,
-      actualModel: values['--actual-model'], modelFallbackReason: values['--fallback-reason']
+      actualModel: values['--actual-model'],
+      actualReasoningEffort: values['--actual-reasoning-effort'],
+      modelFallbackReason: values['--model-fallback-reason'],
+      reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
     };
     result = taskRef === 'auto'
       ? activateMatchingOrchestrationDelegation(values['--client'] as AgentClientId, event)
@@ -113,10 +226,6 @@ function taskOrchestration(args: string[] = []): void {
         changedPaths: values['--changed-paths'] ? values['--changed-paths']!.split(',').filter(Boolean) : []
       });
     }
-  } else if (intent === 'stage-completed') {
-    const missing = requireValues(['--agent']);
-    if (missing) { usageFailure(`intent 'stage-completed' requires '${missing}'`); return; }
-    result = completeCommitOrchestrationStage(taskRef!, values['--agent']!);
   } else if (intent === 'advance') {
     result = advanceOrchestration(taskRef!);
   } else {

package/lib/internal/task-review.ts

@@ -1,6 +1,6 @@
 import { finalizeReviewSummary } from '../task/review-finalization.ts';
 
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--dry-run]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
 
 function failUsage(message: string): void {
   process.stdout.write(`${JSON.stringify({
@@ -29,10 +29,11 @@ function taskReview(args: string[] = []): void {
   let stage = '';
   let artifact = '';
   let dryRun = false;
+  let orchestrated = false;
   const seen = new Set<string>();
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
-    if (!['--stage', '--artifact', '--dry-run'].includes(flag)) {
+    if (!['--stage', '--artifact', '--orchestrated', '--dry-run'].includes(flag)) {
       failUsage(`unknown option '${flag}'`);
       return;
     }
@@ -45,6 +46,10 @@ function taskReview(args: string[] = []): void {
       dryRun = true;
       continue;
     }
+    if (flag === '--orchestrated') {
+      orchestrated = true;
+      continue;
+    }
     const value = args[++index];
     if (!value || value.startsWith('--')) {
       failUsage(`option '${flag}' requires a value`);
@@ -57,7 +62,7 @@ function taskReview(args: string[] = []): void {
     failUsage("options '--stage' and '--artifact' are required");
     return;
   }
-  const result = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, dryRun });
+  const result = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun });
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

package/lib/platform/adapters.ts

@@ -6,6 +6,11 @@ type PlatformAdapterContext = {
   client?: unknown;
 };
 
+type PlatformMergeability = {
+  state: 'mergeable' | 'conflicting' | 'unknown';
+  detail: string | null;
+};
+
 type PlatformChangeRequestSnapshot = {
   repository: string;
   number: number;
@@ -22,6 +27,7 @@ type PlatformChangeRequestSnapshot = {
   labels: string[];
   assignees: string[];
   milestone: string | null;
+  mergeability?: PlatformMergeability;
 };
 
 type PlatformCheckSnapshot = {
@@ -45,6 +51,11 @@ type ChangeRequestInspectionContext = PlatformAdapterContext & {
   number: number;
 };
 
+type IssueClosingChangeRequestsContext = PlatformAdapterContext & {
+  repository: string;
+  issueNumber: number;
+};
+
 type RequiredChecksInspectionContext = ChangeRequestInspectionContext & {
   headSha: string;
 };
@@ -65,6 +76,9 @@ type PlatformAdapter = {
   inspectChangeRequest?(
     context: ChangeRequestInspectionContext
   ): PlatformInspectionResult<PlatformChangeRequestSnapshot>;
+  inspectIssueClosingChangeRequests?(
+    context: IssueClosingChangeRequestsContext
+  ): PlatformInspectionResult<PlatformChangeRequestSnapshot[]>;
   inspectRequiredChecks?(
     context: RequiredChecksInspectionContext
   ): PlatformInspectionResult<PlatformCheckSnapshot[]>;
@@ -88,7 +102,7 @@ function registerPlatformCapabilities(
   type: string,
   capabilities: Pick<
     PlatformAdapter,
-    'inspectChangeRequest' | 'inspectRequiredChecks' | 'resolveChangeRequestGitEvidence'
+    'inspectChangeRequest' | 'inspectIssueClosingChangeRequests' | 'inspectRequiredChecks' | 'resolveChangeRequestGitEvidence'
   >
 ): void {
   const adapter = adapters.get(type);
@@ -98,14 +112,24 @@ function registerPlatformCapabilities(
 
 function hasPlatformCapability(
   type: string | null,
-  capability: 'change-request' | 'required-checks' | 'change-request-git-evidence'
+  capability: 'change-request' | 'issue-closing-change-requests' | 'required-checks' | 'change-request-git-evidence'
 ): boolean {
   const adapter = getPlatformAdapter(type);
   if (capability === 'change-request') return typeof adapter?.inspectChangeRequest === 'function';
+  if (capability === 'issue-closing-change-requests') return typeof adapter?.inspectIssueClosingChangeRequests === 'function';
   if (capability === 'required-checks') return typeof adapter?.inspectRequiredChecks === 'function';
   return typeof adapter?.resolveChangeRequestGitEvidence === 'function';
 }
 
+function inspectPlatformIssueClosingChangeRequests(
+  type: string | null,
+  context: IssueClosingChangeRequestsContext
+): PlatformInspectionResult<PlatformChangeRequestSnapshot[]> {
+  const adapter = getPlatformAdapter(type);
+  return adapter?.inspectIssueClosingChangeRequests?.(context) ??
+    unsupported(type, 'issue closing change-request inspection');
+}
+
 function unsupported<T>(type: string | null, capability: string): PlatformInspectionResult<T> {
   return {
     ok: false,
@@ -150,6 +174,7 @@ export {
   getPlatformAdapter,
   hasPlatformCapability,
   inspectPlatformChangeRequest,
+  inspectPlatformIssueClosingChangeRequests,
   inspectPlatformRequiredChecks,
   listPlatformAdapters,
   registerPlatformAdapter,
@@ -159,11 +184,13 @@ export {
 export type {
   ChangeRequestGitEvidenceContext,
   ChangeRequestInspectionContext,
+  IssueClosingChangeRequestsContext,
   PlatformAdapter,
   PlatformAdapterContext,
   PlatformChangeRequestGitEvidenceSpec,
   PlatformChangeRequestSnapshot,
   PlatformCheckSnapshot,
   PlatformInspectionResult,
+  PlatformMergeability,
   RequiredChecksInspectionContext
 };

package/lib/platform/completion-backfill.ts

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { COMPLETION_BACKFILL_FAMILIES, inspectCompletionArtifacts } from '../task/finalization-artifacts.ts';
+import { parseArtifactName } from '../task/artifact-lifecycle.ts';
+import { parseTaskFrontmatter } from '../task/frontmatter.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { getOpenWorkflowWarnings } from '../task/workflow-warnings.ts';
+import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.ts';
+import { captureTaskWriteMetadata } from '../task/write.ts';
+import { syncPlatformComment } from './issue-comments.ts';
+import type { GitHubClient } from './github-client.ts';
+import { platformResult } from './types.ts';
+import type { PlatformOperation, PlatformResult } from './types.ts';
+
+type CompletionBackfillOptions = { agent: string; cwd?: string; client?: GitHubClient };
+type CompletionBackfillResult = PlatformResult & {
+  artifacts: Array<{ artifact: string; status: PlatformResult['status'] }>;
+  warnings: Array<{ id: string; status: string }>;
+};
+
+function result(
+  base: PlatformResult,
+  artifacts: CompletionBackfillResult['artifacts'],
+  warnings: CompletionBackfillResult['warnings']
+): CompletionBackfillResult {
+  return { ...base, artifacts, warnings };
+}
+
+function excludedPrReview(taskDir: string, message: string): string | null {
+  const names = [...message.matchAll(/(?:^|[^A-Za-z0-9_-])(pr-review(?:-r[1-9]\d*)?\.md)(?=$|[^A-Za-z0-9_.-])/g)]
+    .map((match) => match[1]!);
+  if (names.length !== 1) return null;
+  const parsed = parseArtifactName(names[0]!);
+  if (!parsed || parsed.family !== 'pr-review') return null;
+  const artifactPath = path.join(taskDir, parsed.name);
+  try {
+    const stat = fs.lstatSync(artifactPath);
+    return stat.isFile() && !stat.isSymbolicLink() ? parsed.name : null;
+  } catch {
+    return null;
+  }
+}
+
+function backfillCompletionComments(
+  taskRef: string,
+  options: CompletionBackfillOptions
+): CompletionBackfillResult {
+  const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+  if (!resolved.ok) return result(platformResult('failed', {
+    error: { code: resolved.code, message: resolved.message, retryable: false }
+  }), [], []);
+  const inventory = inspectCompletionArtifacts(resolved.taskId, { repoRoot: resolved.repoRoot });
+  if (inventory.status === 'failed') return result(platformResult('failed', {
+    error: {
+      code: inventory.error?.code || 'ARTIFACT_TOPOLOGY_CONFLICT',
+      message: inventory.error?.message || 'Completion artifact inventory failed',
+      retryable: false
+    }
+  }), [], []);
+  const initialContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  const issueNumber = Number(parseTaskFrontmatter(initialContent).issue_number);
+  if (!Number.isInteger(issueNumber) || issueNumber <= 0) return result(platformResult('no-op', {
+    error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+  }), [], []);
+
+  const artifacts: CompletionBackfillResult['artifacts'] = [];
+  const operations: PlatformOperation[] = [];
+  let latest = platformResult('no-op', { error: null });
+  for (const artifact of inventory.artifacts) {
+    latest = syncPlatformComment(resolved.taskId, {
+      kind: 'artifact',
+      artifact: artifact.name,
+      agent: options.agent,
+      backfill: true,
+      cwd: resolved.repoRoot,
+      client: options.client
+    });
+    operations.push(...latest.operations.map((operation) => ({
+      ...operation,
+      name: `${artifact.name}:${operation.name}`
+    })));
+    artifacts.push({ artifact: artifact.name, status: latest.status });
+    if (latest.status === 'failed' || latest.status === 'blocked') return result({ ...latest, operations }, artifacts, []);
+    if (latest.error) return result(platformResult(latest.error.retryable ? 'blocked' : 'failed', {
+      platform: latest.platform,
+      resource: latest.resource,
+      capabilities: latest.capabilities,
+      operations,
+      error: latest.error
+    }), artifacts, []);
+  }
+
+  const matching = getOpenWorkflowWarnings(initialContent).flatMap((warning) => {
+    if (warning.step !== 'complete-task' || warning.code !== 'COMMENT_SYNC_FAILED' || warning.target !== 'artifact') return [];
+    const excluded = excludedPrReview(resolved.taskDir, warning.message);
+    return excluded ? [{ warning, excluded }] : [];
+  });
+  const warnings: CompletionBackfillResult['warnings'] = [];
+  let metadata: ReturnType<typeof captureTaskWriteMetadata> | null = null;
+  for (const { warning, excluded } of matching) {
+    metadata ??= captureTaskWriteMetadata();
+    const resolution = [
+      `excluded=${excluded}`,
+      `completionFamilies=${COMPLETION_BACKFILL_FAMILIES.join(',')}`,
+      `synchronized=${inventory.artifacts.map((artifact) => artifact.name).join(',') || 'none'}`,
+      `completedAt=${metadata.timestamp}`
+    ].join('; ');
+    const updated = applyWorkflowWarningIntent({
+      kind: 'set-status', taskRef: resolved.taskId, id: warning.id, status: 'resolved', resolution
+    }, { repoRoot: resolved.repoRoot, metadataProvider: () => metadata! });
+    if (updated.status === 'failed') return result(platformResult('failed', {
+      platform: latest.platform,
+      resource: latest.resource,
+      capabilities: latest.capabilities,
+      operations,
+      changed: artifacts.some((item) => item.status === 'applied'),
+      error: { code: updated.error?.code || 'WARNING_UPDATE_FAILED', message: updated.error?.message || 'Unable to resolve workflow warning', retryable: false }
+    }), artifacts, warnings);
+    warnings.push({ id: warning.id, status: updated.status });
+  }
+  const changed = artifacts.some((item) => item.status === 'applied') || warnings.some((item) => item.status === 'applied');
+  return result(platformResult(changed ? 'applied' : 'no-op', {
+    platform: latest.platform,
+    resource: latest.resource,
+    capabilities: latest.capabilities,
+    changed,
+    operations,
+    error: null
+  }), artifacts, warnings);
+}
+
+export { backfillCompletionComments };
+export type { CompletionBackfillOptions, CompletionBackfillResult };

package/lib/platform/github-client.ts

@@ -24,6 +24,15 @@ type ClientOptions = {
 };
 
 const MINIMUM_GITHUB_CLI_VERSION = '2.16.0';
+const GITHUB_CLI_MAX_BUFFER = 64 * 1024 * 1024;
+const ERROR_DETAIL_LIMIT = 4096;
+
+function boundedFailureDetail(result: RunResult): string {
+  const diagnostic = `${result.stderr}\n${result.error?.message || ''}`.trim() || result.stdout.trim();
+  return diagnostic.length <= ERROR_DETAIL_LIMIT
+    ? diagnostic
+    : `${diagnostic.slice(0, ERROR_DETAIL_LIMIT)}… [truncated]`;
+}
 
 function defaultRunner(args: string[], options: RunOptions): RunResult {
   const command = process.env.AGENT_INFRA_GH_BIN || 'gh';
@@ -38,6 +47,7 @@ function defaultRunner(args: string[], options: RunOptions): RunResult {
     encoding: 'utf8',
     env: process.env,
     input: options.input,
+    maxBuffer: GITHUB_CLI_MAX_BUFFER,
     shell: false
   });
   return {
@@ -60,7 +70,15 @@ function defaultSleep(delayMs: number): void {
 }
 
 function classifyGitHubFailure(result: RunResult): PlatformError {
-  const detail = `${result.stderr}\n${result.stdout}\n${result.error?.message || ''}`.trim();
+  const errorCode = result.error && 'code' in result.error ? (result.error as NodeJS.ErrnoException).code : undefined;
+  if (errorCode === 'ENOBUFS') {
+    return {
+      code: 'PLATFORM_OUTPUT_TOO_LARGE',
+      message: 'GitHub CLI output exceeded the configured limit',
+      retryable: false
+    };
+  }
+  const detail = boundedFailureDetail(result);
   const lower = detail.toLowerCase();
   if (/\b401\b|bad credentials|authentication required|not logged into/.test(lower)) {
     return { code: 'AUTH_REQUIRED', message: detail || 'GitHub authentication is required', retryable: false };
@@ -77,7 +95,7 @@ function classifyGitHubFailure(result: RunResult): PlatformError {
   if (/\b422\b|validation failed/.test(lower)) {
     return { code: 'PLATFORM_REQUEST_INVALID', message: detail || 'GitHub rejected the request', retryable: false };
   }
-  if (result.error && 'code' in result.error && (result.error as NodeJS.ErrnoException).code === 'ENOENT') {
+  if (errorCode === 'ENOENT') {
     return { code: 'PLATFORM_DEPENDENCY_MISSING', message: detail || 'GitHub CLI is unavailable', retryable: false };
   }
   return { code: 'PLATFORM_REQUEST_FAILED', message: detail || 'GitHub request failed', retryable: false };

package/lib/platform/issue-comments.ts

@@ -38,7 +38,8 @@ const ARTIFACT_TITLES: Record<string, string> = {
   'review-plan': '技术方案审查',
   code: '实现报告',
   'review-code': '代码审查',
-  'manual-validation': '人工验证报告'
+  'manual-validation': '人工验证报告',
+  'pr-review': 'PR 审查报告'
 };
 
 function normalizeCommentContent(content: string): string {
@@ -74,7 +75,7 @@ function renderTaskComment(content: string, taskId: string, agent: string): stri
 
 function artifactIdentity(artifact: string): { stem: string; title: string } {
   const stem = path.basename(artifact, '.md');
-  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation)(?:-r(\d+))?$/);
+  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|pr-review)(?:-r(\d+))?$/);
   if (!match) throw new Error(`unsupported artifact '${artifact}'`);
   const base = ARTIFACT_TITLES[match[1]!]!;
   const round = match[2] ? Number(match[2]) : 1;