@fitlab-ai/agent-infra 0.9.2 → 0.9.3

package/lib/platform/merged-pr-equivalence.ts

@@ -1,4 +1,7 @@
 import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
 import type { PullRequestSnapshot } from "./pull-requests.ts";
 
@@ -45,6 +48,117 @@ function isAncestor(gitRoot: string, ancestor: string, descendant: string):
   return { status: "error" };
 }
 
+function blocked(message: string): ReviewedHeadRelation {
+  return { status: "blocked", code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", message };
+}
+
+function resolveUniqueMergeBase(
+  gitRoot: string,
+  reviewedHead: string,
+  squashParent: string
+): { status: "ok"; mergeBase: string } | { status: "failed" | "blocked"; relation: ReviewedHeadRelation } {
+  const result = spawnSync("git", ["merge-base", "--all", reviewedHead, squashParent], {
+    cwd: gitRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error || result.status === null || result.status > 1) {
+    return { status: "blocked", relation: blocked("Unable to compute the reviewed PR merge base") };
+  }
+  const candidates = result.stdout.trim() === "" ? [] : result.stdout.trim().split(/\s+/);
+  if (result.status === 1 || candidates.length !== 1) {
+    return {
+      status: "failed",
+      relation: {
+        status: "failed",
+        code: "PR_MERGE_TOPOLOGY_INVALID",
+        message: "Reviewed head and squash parent do not have a unique merge base"
+      }
+    };
+  }
+  const [candidate] = candidates;
+  if (!candidate || !SHA_PATTERN.test(candidate)) {
+    return { status: "blocked", relation: blocked("Git returned an invalid reviewed PR merge base") };
+  }
+  return { status: "ok", mergeBase: candidate };
+}
+
+function compareReplayedTree(input: {
+  gitRoot: string;
+  mergeBase: string;
+  reviewedHead: string;
+  squashParent: string;
+  squashCommit: string;
+}): ReviewedHeadRelation | null {
+  const { gitRoot, mergeBase, reviewedHead, squashParent, squashCommit } = input;
+  let tempDir: string | undefined;
+  let relation: ReviewedHeadRelation | null = null;
+  try {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-infra-merge-equivalence-"));
+    const env = { ...process.env, GIT_INDEX_FILE: path.join(tempDir, "index") };
+    const readTree = spawnSync("git", ["read-tree", squashParent], {
+      cwd: gitRoot, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (readTree.error || readTree.status !== 0) {
+      relation = blocked("Unable to initialize isolated squash merge evidence");
+    } else {
+      const patchResult = spawnSync(
+        "git",
+        ["diff", "--no-renames", "--binary", "--full-index", mergeBase, reviewedHead],
+        { cwd: gitRoot, env, encoding: "utf8", maxBuffer: 32 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] }
+      );
+      if (patchResult.error || patchResult.status !== 0) {
+        relation = blocked("Unable to generate the reviewed PR patch");
+      } else if (patchResult.stdout !== "") {
+        const applyResult = spawnSync("git", ["apply", "--cached", "--3way", "--binary", "-q"], {
+          cwd: gitRoot,
+          env,
+          encoding: "utf8",
+          input: patchResult.stdout,
+          maxBuffer: 32 * 1024 * 1024,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        if (applyResult.status === 1) {
+          relation = {
+            status: "failed",
+            code: "PR_MERGE_CONTENT_MISMATCH",
+            message: "Reviewed PR patch cannot be replayed without conflicts, so content equivalence cannot be established"
+          };
+        } else if (applyResult.error || applyResult.status !== 0) {
+          relation = blocked("Unable to replay the reviewed PR patch");
+        }
+      }
+      if (relation === null) {
+        const compareResult = spawnSync(
+          "git",
+          ["diff", "--cached", "--quiet", "--no-ext-diff", squashCommit, "--"],
+          { cwd: gitRoot, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
+        );
+        if (compareResult.status === 1) {
+          relation = {
+            status: "failed",
+            code: "PR_MERGE_CONTENT_MISMATCH",
+            message: "Replayed reviewed PR content differs from the squash merge tree"
+          };
+        } else if (compareResult.error || compareResult.status !== 0) {
+          relation = blocked("Unable to compare replayed PR content with the squash merge tree");
+        }
+      }
+    }
+  } catch {
+    relation = blocked("Unable to create isolated squash merge evidence");
+  } finally {
+    if (tempDir) {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch {
+        relation = blocked("Unable to clean up isolated squash merge evidence");
+      }
+    }
+  }
+  return relation;
+}
+
 export function resolveReviewedHeadRelation(input: {
   gitRoot: string;
   comparisonHead: string;
@@ -87,12 +201,20 @@ export function resolveReviewedHeadRelation(input: {
     if (parents.length !== 2) {
       return { status: "failed", code: "PR_MERGE_TOPOLOGY_INVALID", message: "PR merge commit is not a single-parent squash commit" };
     }
-    const diffArgs = ["diff", "--no-renames", "--binary", "--full-index"];
-    const reviewedDiff = git(gitRoot, [...diffArgs, pullRequest.base.sha, pullRequest.head.sha]);
-    const mergedDiff = git(gitRoot, [...diffArgs, `${pullRequest.mergeCommitSha}^`, pullRequest.mergeCommitSha]);
-    if (reviewedDiff !== mergedDiff) {
-      return { status: "failed", code: "PR_MERGE_CONTENT_MISMATCH", message: "Squash merge content differs from the reviewed PR changes" };
+    const squashParent = parents[1];
+    if (!squashParent) {
+      return { status: "failed", code: "PR_MERGE_TOPOLOGY_INVALID", message: "PR merge commit is not a single-parent squash commit" };
     }
+    const mergeBase = resolveUniqueMergeBase(gitRoot, pullRequest.head.sha, squashParent);
+    if (mergeBase.status !== "ok") return mergeBase.relation;
+    const replayFailure = compareReplayedTree({
+      gitRoot,
+      mergeBase: mergeBase.mergeBase,
+      reviewedHead: pullRequest.head.sha,
+      squashParent,
+      squashCommit: pullRequest.mergeCommitSha
+    });
+    if (replayFailure) return replayFailure;
   } catch {
     return { status: "blocked", code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", message: "Unable to verify PR merge topology or content" };
   }

package/lib/platform/pr-checks.ts

@@ -19,10 +19,13 @@ type CheckBucket = 'pass' | 'fail' | 'pending' | 'cancel';
 type CheckState = 'passed' | 'failed' | 'pending' | 'timed-out' | 'cancelled' | 'no-required';
 type CheckSnapshot = PlatformCheckSnapshot;
 type ChecksSnapshot = { state: Exclude<CheckState, 'timed-out'>; required: CheckSnapshot[] };
+type ReadinessState = 'ready' | 'conflicting' | 'checks-failed' | 'pending' | 'timed-out' | 'cancelled';
+type ReadinessSnapshot = { state: ReadinessState; headSha: string };
 type RunCandidate = { id: number; name: string; headSha: string; jobId?: number | null };
 type ChecksResult = PlatformResult & {
   pullRequest: PullRequestSnapshot | null;
   checks: { state: CheckState; required: CheckSnapshot[] };
+  readiness?: ReadinessSnapshot;
   resolution?: { status: 'resolved' | 'missing' | 'ambiguous'; runId: number | null; jobId: number | null };
   logs?: { runId: number; jobId?: number; text: string };
 };
@@ -37,25 +40,15 @@ function classifyRequiredChecks(required: CheckSnapshot[]): ChecksSnapshot {
   return { state: 'passed', required };
 }
 
-async function watchRequiredChecks(options: {
-  inspect: () => Promise<ChecksSnapshot>;
-  intervalMs: number;
-  deadlineMs: number;
-  now?: () => number;
-  sleep?: (delayMs: number) => Promise<void>;
-  signal?: AbortSignal;
-}): Promise<{ state: CheckState; required: CheckSnapshot[] }> {
-  const now = options.now || (() => performance.now());
-  const sleep = options.sleep || ((delay) => new Promise<void>((resolve) => setTimeout(resolve, delay)));
-  const started = now();
-  while (true) {
-    if (options.signal?.aborted) return { state: 'cancelled', required: [] };
-    const snapshot = await options.inspect();
-    if (snapshot.state !== 'pending') return snapshot;
-    const elapsed = now() - started;
-    if (elapsed >= options.deadlineMs) return { state: 'timed-out', required: snapshot.required };
-    await sleep(Math.min(options.intervalMs, options.deadlineMs - elapsed));
-  }
+function classifyPullRequestReadiness(input: {
+  headSha: string;
+  mergeability: 'mergeable' | 'conflicting' | 'unknown';
+  checks: ChecksSnapshot;
+}): ReadinessSnapshot {
+  if (input.mergeability === 'conflicting') return { state: 'conflicting', headSha: input.headSha };
+  if (input.checks.state === 'failed' || input.checks.state === 'cancelled') return { state: 'checks-failed', headSha: input.headSha };
+  if (input.mergeability === 'unknown' || input.checks.state === 'pending') return { state: 'pending', headSha: input.headSha };
+  return { state: 'ready', headSha: input.headSha };
 }
 
 function parseRunJobIdentity(detailsUrl: string): { runId: number; jobId: number | null } | null {
@@ -143,6 +136,13 @@ function resolvedTask(taskRef: string, options: InspectionOptions) {
 function inspectRequiredChecks(taskRef: string, options: InspectionOptions = {}): ChecksResult {
   const base = resolvedTask(taskRef, options);
   if (!base.ok) return base.output;
+  return inspectChecksForResolvedTask(base, options);
+}
+
+function inspectChecksForResolvedTask(
+  base: Extract<ReturnType<typeof resolvedTask>, { ok: true }>,
+  options: InspectionOptions
+): ChecksResult {
   const repository = base.context.platform.repository!;
   const inspected = inspectPlatformRequiredChecks(base.context.platform.type, {
     cwd: base.resolved.repoRoot,
@@ -179,36 +179,62 @@ function inspectRequiredChecks(taskRef: string, options: InspectionOptions = {})
   });
 }
 
-async function watchPlatformChecks(taskRef: string, options: InspectionOptions & {
+function inspectPullRequestReadiness(taskRef: string, options: InspectionOptions = {}): ChecksResult {
+  const base = resolvedTask(taskRef, options);
+  if (!base.ok) return base.output;
+  const checked = inspectChecksForResolvedTask(base, options);
+  const classifiedCodes = new Set(['REQUIRED_CHECKS_PENDING', 'REQUIRED_CHECKS_FAILED', 'REQUIRED_CHECKS_CANCELLED']);
+  if (checked.error && !classifiedCodes.has(checked.error.code)) return checked;
+  const readiness = classifyPullRequestReadiness({
+    headSha: base.pullRequest.head.sha,
+    mergeability: base.pullRequest.mergeability?.state ?? 'unknown',
+    checks: checked.checks as ChecksSnapshot
+  });
+  const status = readiness.state === 'ready' ? 'no-op'
+    : readiness.state === 'conflicting' || readiness.state === 'checks-failed' ? 'failed' : 'blocked';
+  return checksResult(status, {
+    ...checked,
+    status,
+    changed: false,
+    readiness,
+    error: status === 'no-op' ? null : {
+      code: readiness.state === 'conflicting' ? 'PR_MERGE_CONFLICT'
+        : readiness.state === 'checks-failed' ? 'REQUIRED_CHECKS_FAILED' : 'PR_READINESS_PENDING',
+      message: `Pull request readiness is ${readiness.state}`,
+      retryable: readiness.state === 'pending'
+    }
+  });
+}
+
+async function watchPullRequestReadiness(taskRef: string, options: InspectionOptions & {
   intervalSeconds: number;
   deadlineSeconds: number;
   signal?: AbortSignal;
   now?: () => number;
   sleep?: (delayMs: number) => Promise<void>;
 }): Promise<ChecksResult> {
+  const now = options.now || (() => performance.now());
+  const sleep = options.sleep || ((delay: number) => new Promise<void>((resolve) => setTimeout(resolve, delay)));
+  const started = now();
   let last: ChecksResult | null = null;
-  const watched = await watchRequiredChecks({
-    intervalMs: options.intervalSeconds * 1000,
-    deadlineMs: options.deadlineSeconds * 1000,
-    signal: options.signal,
-    now: options.now,
-    sleep: options.sleep,
-    inspect: async () => {
-      last = inspectRequiredChecks(taskRef, options);
-      if (last.checks.state === 'pending' && last.error?.code === 'REQUIRED_CHECKS_PENDING') return last.checks as ChecksSnapshot;
-      return last.checks as ChecksSnapshot;
-    }
-  });
-  if (!last) return checksResult('blocked', { checks: watched, error: { code: 'REQUIRED_CHECKS_UNAVAILABLE', message: 'No checks snapshot was produced', retryable: true } });
-  const snapshot = last as ChecksResult;
-  if (watched.state === 'timed-out' || watched.state === 'cancelled') return checksResult('blocked', {
-    ...snapshot,
-    status: 'blocked',
-    changed: false,
-    checks: watched,
-    error: { code: watched.state === 'timed-out' ? 'REQUIRED_CHECKS_TIMEOUT' : 'REQUIRED_CHECKS_CANCELLED', message: `Required checks ${watched.state}`, retryable: watched.state === 'timed-out' }
-  });
-  return { ...snapshot, checks: watched };
+  while (true) {
+    if (options.signal?.aborted) return checksResult('blocked', {
+      ...last,
+      status: 'blocked', changed: false,
+      readiness: { state: 'cancelled', headSha: last?.pullRequest?.head.sha ?? '' },
+      error: { code: 'PR_READINESS_CANCELLED', message: 'Pull request readiness watch was cancelled', retryable: false }
+    });
+    last = inspectPullRequestReadiness(taskRef, options);
+    if (last.readiness?.state !== 'pending' || last.error?.code !== 'PR_READINESS_PENDING') return last;
+    const elapsed = now() - started;
+    if (elapsed >= options.deadlineSeconds * 1000) return checksResult('blocked', {
+      ...last,
+      status: 'blocked', changed: false,
+      readiness: { state: 'timed-out', headSha: last.pullRequest?.head.sha ?? '' },
+      error: { code: 'PR_READINESS_TIMEOUT', message: 'Pull request readiness watch timed out', retryable: true }
+    });
+    await sleep(Math.min(options.intervalSeconds * 1000, options.deadlineSeconds * 1000 - elapsed));
+  }
 }
 
 function resolvePlatformCheckRun(taskRef: string, options: SharedOptions & { checkName: string; detailsUrl?: string }): ChecksResult {
@@ -262,14 +288,15 @@ function fetchPlatformCheckLogs(taskRef: string, options: SharedOptions & { run:
 }
 
 export {
+  classifyPullRequestReadiness,
   classifyRequiredChecks,
   fetchCheckLogText,
   fetchPlatformCheckLogs,
   inspectRequiredChecks,
+  inspectPullRequestReadiness,
   parseRunJobIdentity,
   resolvePlatformCheckRun,
   resolveRunCandidate,
-  watchPlatformChecks,
-  watchRequiredChecks
+  watchPullRequestReadiness
 };
-export type { CheckBucket, CheckSnapshot, ChecksResult, ChecksSnapshot, CheckState, RunCandidate };
+export type { CheckBucket, CheckSnapshot, ChecksResult, ChecksSnapshot, CheckState, ReadinessSnapshot, ReadinessState, RunCandidate };

package/lib/platform/pr-review.ts

@@ -0,0 +1,201 @@
+import { createGitHubClient } from './github-client.ts';
+import type { GitHubClient } from './github-client.ts';
+import { resolvePlatformContext } from './context.ts';
+import { platformResult } from './types.ts';
+import type { PlatformOperation, PlatformResult } from './types.ts';
+
+export type PrReviewEvent = 'COMMENT' | 'APPROVE' | 'REQUEST_CHANGES';
+export type PrReviewIdentity = { scope: string; round: number; commitSha: string };
+export type PrReviewListEntry = { id: number; commitId: string; body: string; url: string };
+export type PrReviewListResult = PlatformResult & { reviews: PrReviewListEntry[] };
+
+type RemoteReview = {
+  id?: number;
+  node_id?: string;
+  commit_id?: string;
+  body?: string | null;
+  state?: string;
+  html_url?: string;
+};
+
+const REVIEW_EVENTS: readonly PrReviewEvent[] = ['COMMENT', 'APPROVE', 'REQUEST_CHANGES'];
+// Marker-safe scope: a task id (`TASK-YYYYMMDD-HHMMSS`) or a bare PR number
+// (`pr{N}`). Any other value (e.g. one containing `\r\n` or `-->`) would break
+// the first-line marker idempotency contract of `reviewMarker` (PL-6).
+const REVIEW_SCOPE_PATTERN = /^(?:pr\d+|TASK-\d{8}-\d{6})$/;
+
+export function reviewMarker(identity: PrReviewIdentity): string {
+  return `<!-- review-pr:${identity.scope}:r${identity.round} -->`;
+}
+
+export function reviewedCommitMarker(sha: string): string {
+  return `<!-- reviewed-commit: ${sha} -->`;
+}
+
+function normalizeBody(body: string): string {
+  return String(body || '').replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+
+function firstLine(body: string): string {
+  return normalizeBody(String(body || '')).split('\n', 1)[0] || '';
+}
+
+function hasUsableContext(context: PlatformResult): boolean {
+  return (context.status === 'no-op' || context.status === 'degraded') && context.platform.repository !== null;
+}
+
+function invalidPrNumber(prNumber: number): boolean {
+  return !Number.isInteger(prNumber) || prNumber <= 0;
+}
+
+export function listPrReviews(prNumber: number, options: { cwd?: string; client?: GitHubClient } = {}): PrReviewListResult {
+  const client = options.client || createGitHubClient();
+  const context = resolvePlatformContext({ cwd: options.cwd || process.cwd(), client });
+  if (!hasUsableContext(context)) {
+    return { ...platformResult(context.status, { platform: context.platform, capabilities: context.capabilities, error: context.error }), reviews: [] };
+  }
+  const repository = context.platform.repository!;
+  if (invalidPrNumber(prNumber)) {
+    return {
+      ...platformResult('failed', {
+        platform: context.platform, capabilities: context.capabilities,
+        error: { code: 'PR_NUMBER_INVALID', message: 'PR number must be positive', retryable: false }
+      }),
+      reviews: []
+    };
+  }
+  const fetched = client.json<RemoteReview[]>(['api', '--paginate', '--slurp', `repos/${repository}/pulls/${prNumber}/reviews?per_page=100`], { cwd: options.cwd || process.cwd() });
+  if (!fetched.ok) {
+    return {
+      ...platformResult(fetched.error.retryable ? 'blocked' : 'failed', {
+        platform: context.platform, capabilities: context.capabilities,
+        resource: { kind: 'pull-request', number: prNumber }, error: fetched.error
+      }),
+      reviews: []
+    };
+  }
+  const flat = (fetched.value || []).flatMap((entry) => Array.isArray(entry) ? entry : [entry]);
+  const reviews: PrReviewListEntry[] = flat
+    .map((review) => ({
+      id: review.id ?? 0,
+      commitId: review.commit_id ?? '',
+      body: review.body ?? '',
+      url: review.html_url ?? ''
+    }))
+    .filter((review) => review.body !== '');
+  return {
+    ...platformResult('no-op', {
+      platform: context.platform, capabilities: context.capabilities,
+      resource: { kind: 'pull-request', number: prNumber }, error: null
+    }),
+    reviews
+  };
+}
+
+export function publishPrReview(options: {
+  cwd?: string;
+  client?: GitHubClient;
+  dryRun?: boolean;
+  prNumber: number;
+  identity: PrReviewIdentity;
+  event: PrReviewEvent;
+  body: string;
+}): PlatformResult {
+  const client = options.client || createGitHubClient();
+  const context = resolvePlatformContext({ cwd: options.cwd || process.cwd(), client });
+  if (!hasUsableContext(context)) {
+    return platformResult(context.status, { platform: context.platform, capabilities: context.capabilities, error: context.error });
+  }
+  const repository = context.platform.repository!;
+  if (invalidPrNumber(options.prNumber)) {
+    return platformResult('failed', {
+      platform: context.platform, capabilities: context.capabilities,
+      error: { code: 'PR_NUMBER_INVALID', message: 'PR number must be positive', retryable: false }
+    });
+  }
+  if (!REVIEW_EVENTS.includes(options.event)) {
+    return platformResult('failed', {
+      platform: context.platform, capabilities: context.capabilities,
+      resource: { kind: 'pull-request', number: options.prNumber },
+      error: { code: 'REVIEW_EVENT_INVALID', message: `review event must be one of ${REVIEW_EVENTS.join('|')}`, retryable: false }
+    });
+  }
+  if (!REVIEW_SCOPE_PATTERN.test(options.identity.scope) || !/^[0-9a-f]{7,40}$/i.test(options.identity.commitSha)) {
+    return platformResult('failed', {
+      platform: context.platform, capabilities: context.capabilities,
+      resource: { kind: 'pull-request', number: options.prNumber },
+      error: { code: 'REVIEW_IDENTITY_INVALID', message: 'review scope must be a task id or pr{N}; commitSha is required', retryable: false }
+    });
+  }
+
+  const marker = reviewMarker(options.identity);
+  const listed = listPrReviews(options.prNumber, { cwd: options.cwd, client });
+  if (listed.status === 'failed' || listed.status === 'blocked') return listed;
+  const existing = listed.reviews.find((review) => firstLine(review.body) === marker) ?? null;
+  if (existing) {
+    if (existing.commitId === options.identity.commitSha) {
+      return platformResult('no-op', {
+        platform: context.platform, capabilities: context.capabilities,
+        resource: { kind: 'pull-request', number: options.prNumber },
+        operations: [{ name: 'review:publish', status: 'no-op', reasonCode: null }], error: null
+      });
+    }
+    return platformResult('failed', {
+      platform: context.platform, capabilities: context.capabilities,
+      resource: { kind: 'pull-request', number: options.prNumber },
+      operations: [{ name: 'review:publish', status: 'failed', reasonCode: 'REVIEW_MARKER_CONFLICT' }],
+      error: { code: 'REVIEW_MARKER_CONFLICT', message: 'A review with the same marker targets a different commit; start a new round', retryable: false }
+    });
+  }
+
+  const wrappedBody = [
+    marker,
+    reviewedCommitMarker(options.identity.commitSha),
+    '',
+    String(options.body || '').replace(/\r?\n/g, '\n').replace(/\n+$/, ''),
+    ''
+  ].join('\n');
+
+  if (options.dryRun) {
+    return platformResult('planned', {
+      platform: context.platform, capabilities: context.capabilities,
+      resource: { kind: 'pull-request', number: options.prNumber },
+      operations: [{ name: 'review:publish', status: 'planned', reasonCode: null }], error: null
+    });
+  }
+
+  const posted = client.json<RemoteReview>(['api', `repos/${repository}/pulls/${options.prNumber}/reviews`, '-X', 'POST', '--input', '-'], {
+    cwd: options.cwd || process.cwd(),
+    method: 'POST',
+    input: JSON.stringify({ commit_id: options.identity.commitSha, body: wrappedBody, event: options.event })
+  });
+  if (!posted.ok) {
+    if (posted.error.retryable) {
+      const reconciled = listPrReviews(options.prNumber, { cwd: options.cwd, client });
+      const found = reconciled.reviews.find((review) => firstLine(review.body) === marker);
+      if (found) {
+        return platformResult('applied', {
+          changed: true, platform: context.platform, capabilities: context.capabilities,
+          resource: { kind: 'pull-request', number: options.prNumber },
+          operations: [{ name: 'review:publish', status: 'applied', reasonCode: 'CREATE_RECONCILED' }], error: null
+        });
+      }
+      return platformResult('blocked', {
+        platform: context.platform, capabilities: context.capabilities,
+        resource: { kind: 'pull-request', number: options.prNumber },
+        operations: [{ name: 'review:publish', status: 'failed', reasonCode: 'REVIEW_CREATE_OUTCOME_UNKNOWN' }],
+        error: { code: 'REVIEW_CREATE_OUTCOME_UNKNOWN', message: posted.error.message, retryable: true }
+      });
+    }
+    return platformResult('failed', {
+      platform: context.platform, capabilities: context.capabilities,
+      resource: { kind: 'pull-request', number: options.prNumber },
+      operations: [{ name: 'review:publish', status: 'failed', reasonCode: posted.error.code }], error: posted.error
+    });
+  }
+  return platformResult('applied', {
+    changed: true, platform: context.platform, capabilities: context.capabilities,
+    resource: { kind: 'pull-request', number: options.prNumber },
+    operations: [{ name: 'review:publish', status: 'applied', reasonCode: null }], error: null
+  });
+}