@fitlab-ai/agent-infra 0.9.2 → 0.9.3

package/lib/internal/release-workflow.ts

@@ -150,9 +150,10 @@ function runOptionalDemo(cwd: string, run: CommandRunner = command): DemoResult
   return { status: 'recorded', reasonCode: null, message: null, outputPath };
 }
 
-function git(cwd: string, args: string[], run: CommandRunner = command): string | null {
+function git(cwd: string, args: string[], run: CommandRunner = command, trim = true): string | null {
   const result = run(cwd, 'git', args);
-  return result.status === 0 ? String(result.stdout).trim() : null;
+  const stdout = String(result.stdout);
+  return result.status === 0 ? (trim ? stdout.trim() : stdout) : null;
 }
 
 function inspectLocalReleaseFacts(cwd: string, version: string, run: CommandRunner = command) {
@@ -228,9 +229,15 @@ async function inspectFacts(cwd: string, version: string): Promise<ReleaseFacts>
   };
 }
 
-function changedPaths(cwd: string): string[] {
-  const output = git(cwd, ['status', '--porcelain=v1']) || '';
-  return output.split('\n').filter(Boolean).map((line) => line.slice(3)).filter((value, index, all) => all.indexOf(value) === index);
+function parsePorcelainPath(record: string): string {
+  const match = /^.. (.+)$/.exec(record);
+  if (!match) throw new Error('Invalid git status --porcelain=v1 record');
+  return match[1]!;
+}
+
+function changedPaths(cwd: string, run: CommandRunner = command): string[] {
+  const output = git(cwd, ['status', '--porcelain=v1'], run, false) || '';
+  return output.split(/\r?\n/).filter(Boolean).map(parsePorcelainPath).filter((value, index, all) => all.indexOf(value) === index);
 }
 
 function updateReleaseMetadata(cwd: string, version: string): void {
@@ -336,5 +343,5 @@ async function releaseWorkflow(args: string[] = []): Promise<void> {
   process.stdout.write(`${JSON.stringify({ ...pushed, demo, snapshot: releaseSnapshot(version, await inspectFacts(cwd, version)) })}\n`); process.exitCode = pushed.status === 'failed' ? 1 : pushed.status === 'degraded' ? 2 : 0;
 }
 
-export { computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
+export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
 export type { CommandRunner, DemoResult };

package/lib/internal/task-activity.ts

@@ -0,0 +1,55 @@
+import { applyActivityAppendIntent } from '../task/activity-intent.ts';
+import type { ActivityAppendIntent } from '../task/activity-intent.ts';
+
+const USAGE = `Usage: agent-infra-internal task-activity <task-ref> append --step <step> --agent <agent> --note <note> [--artifact <canonical.md>] [--dry-run]
+`;
+const FLAGS: Record<string, string> = {
+  '--step': 'step',
+  '--agent': 'agent',
+  '--note': 'note',
+  '--artifact': 'artifact'
+};
+
+function usageFailure(message: string): void {
+  process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ACTIVITY_PAYLOAD_INVALID', message } })}\n`);
+  process.stderr.write(USAGE);
+  process.exitCode = 1;
+}
+
+function taskActivity(args: string[] = []): void {
+  if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
+  const [taskRef, kind] = args;
+  if (!taskRef || taskRef.startsWith('--') || !kind || kind !== 'append') {
+    usageFailure('task ref and the append intent are required');
+    return;
+  }
+  const values: Record<string, unknown> = { kind, taskRef };
+  const seen = new Set<string>();
+  for (let index = 2; index < args.length; index += 1) {
+    const flag = args[index]!;
+    if (flag === '--dry-run') {
+      if (seen.has(flag)) { usageFailure(`duplicate option '${flag}'`); return; }
+      seen.add(flag);
+      values.dryRun = true;
+      continue;
+    }
+    const key = FLAGS[flag];
+    if (!key) { usageFailure(`unknown option '${flag}'`); return; }
+    if (seen.has(flag)) { usageFailure(`duplicate option '${flag}'`); return; }
+    const value = args[++index];
+    if (value === undefined || value.startsWith('--')) { usageFailure(`option '${flag}' requires a value`); return; }
+    seen.add(flag);
+    values[key] = value;
+  }
+  const allowed = new Set(['kind', 'taskRef', 'dryRun', 'step', 'agent', 'note', 'artifact']);
+  const unexpected = Object.keys(values).find((key) => !allowed.has(key));
+  if (unexpected) { usageFailure(`append does not accept '${unexpected}'`); return; }
+  for (const key of ['step', 'agent', 'note']) {
+    if (values[key] === undefined) { usageFailure(`append requires '${key}'`); return; }
+  }
+  const result = applyActivityAppendIntent(values as ActivityAppendIntent);
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (result.status === 'failed') process.exitCode = 1;
+}
+
+export { taskActivity };

package/lib/internal/task-event.ts

@@ -1,7 +1,8 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import { applyTaskEvent, eventCatalog } from '../task/events.ts';
 import type { TaskEventRequest, Verdict } from '../task/events.ts';
 
-const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--dry-run]
+const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--orchestrated] [--dry-run]
 
 Apply one closed-set task lifecycle event and print a structured JSON result.
 Events: ${eventCatalog.join(', ')}
@@ -29,6 +30,10 @@ function taskEvent(args: string[] = []): void {
   const seen = new Set<string>();
   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); request.orchestrated = true; continue;
+    }
     if (flag === '--dry-run') {
       if (seen.has(flag)) { usageFailure(`duplicate option '${flag}'`); return; }
       seen.add(flag); request.dryRun = true; continue;
@@ -43,6 +48,9 @@ function taskEvent(args: string[] = []): void {
     else if (key === 'verdict') request.verdict = value as Verdict;
     else (request as Record<string, unknown>)[key] = value;
   }
+  const agent = normalizeAgentToken(String(request.agent ?? ''));
+  if (!agent) { usageFailure(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`); return; }
+  request.agent = agent;
   const result = applyTaskEvent(request);
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;

package/lib/internal/task-lifecycle.ts

@@ -1,3 +1,4 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.ts';
 import type { TaskLifecycleRequest } from '../task/lifecycle.ts';
 
@@ -33,6 +34,9 @@ function taskLifecycle(args: string[] = []): void {
     seen.add(flag);
     values[key] = key === 'alertNumber' || key === 'issueNumber' ? Number(value) : value;
   }
+  const agent = normalizeAgentToken(String(values.agent ?? ''));
+  if (!agent) { usageFailure(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`); return; }
+  values.agent = agent;
   const result = applyTaskLifecycle(values as TaskLifecycleRequest);
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;

package/lib/internal/task-orchestration.ts

@@ -1,3 +1,4 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import {
   activateMatchingOrchestrationDelegation,
   activateOrchestrationDelegation,
@@ -11,6 +12,7 @@ import {
   sealOrchestrationDelegation,
   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';
@@ -43,8 +45,11 @@ function taskOrchestration(args: string[] = []): void {
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
     if (![
-      '--max-steps', '--client', '--requested-model', '--parent-id', '--before-fingerprint',
-      '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--fallback-reason',
+      '--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'
     ].includes(flag)) {
       usageFailure(`unknown option '${flag}'`);
@@ -63,13 +68,41 @@ function taskOrchestration(args: string[] = []): void {
     values[flag] = value;
   }
   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') {
+    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 +112,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 +124,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)
@@ -116,7 +153,9 @@ function taskOrchestration(args: string[] = []): void {
   } else if (intent === 'stage-completed') {
     const missing = requireValues(['--agent']);
     if (missing) { usageFailure(`intent 'stage-completed' requires '${missing}'`); return; }
-    result = completeCommitOrchestrationStage(taskRef!, values['--agent']!);
+    const agent = normalizeAgentToken(values['--agent']!);
+    if (!agent) { usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`); return; }
+    result = completeCommitOrchestrationStage(taskRef!, 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/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;