@fitlab-ai/agent-infra 0.9.2 → 0.9.4

package/dist/lib/platform/github-client.js

@@ -2,6 +2,14 @@ import process from 'node:process';
 import spawn from 'cross-spawn';
 import semver from 'semver';
 const MINIMUM_GITHUB_CLI_VERSION = '2.16.0';
+const GITHUB_CLI_MAX_BUFFER = 64 * 1024 * 1024;
+const ERROR_DETAIL_LIMIT = 4096;
+function boundedFailureDetail(result) {
+    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, options) {
     const command = process.env.AGENT_INFRA_GH_BIN || 'gh';
     let prefix = [];
@@ -16,6 +24,7 @@ function defaultRunner(args, options) {
         encoding: 'utf8',
         env: process.env,
         input: options.input,
+        maxBuffer: GITHUB_CLI_MAX_BUFFER,
         shell: false
     });
     return {
@@ -37,7 +46,15 @@ function defaultSleep(delayMs) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs);
 }
 function classifyGitHubFailure(result) {
-    const detail = `${result.stderr}\n${result.stdout}\n${result.error?.message || ''}`.trim();
+    const errorCode = result.error && 'code' in result.error ? result.error.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 };
@@ -54,7 +71,7 @@ function classifyGitHubFailure(result) {
     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.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/dist/lib/platform/issue-comments.js

@@ -19,7 +19,8 @@ const ARTIFACT_TITLES = {
     'review-plan': '技术方案审查',
     code: '实现报告',
     'review-code': '代码审查',
-    'manual-validation': '人工验证报告'
+    'manual-validation': '人工验证报告',
+    'pr-review': 'PR 审查报告'
 };
 function normalizeCommentContent(content) {
     return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
@@ -51,7 +52,7 @@ function renderTaskComment(content, taskId, agent) {
 }
 function artifactIdentity(artifact) {
     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]];

package/dist/lib/platform/merged-pr-equivalence.js

@@ -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";
 const SHA_PATTERN = /^[0-9a-f]{40}$/i;
 function git(cwd, args) {
     return execFileSync("git", args, {
@@ -29,6 +32,103 @@ function isAncestor(gitRoot, ancestor, descendant) {
         return { status: "no" };
     return { status: "error" };
 }
+function blocked(message) {
+    return { status: "blocked", code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", message };
+}
+function resolveUniqueMergeBase(gitRoot, reviewedHead, squashParent) {
+    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) {
+    const { gitRoot, mergeBase, reviewedHead, squashParent, squashCommit } = input;
+    let tempDir;
+    let relation = 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) {
     const { gitRoot, comparisonHead, lastReviewedCommit, pullRequest } = input;
     if (comparisonHead === lastReviewedCommit &&
@@ -64,12 +164,22 @@ 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/dist/lib/platform/pr-checks.js

@@ -17,21 +17,14 @@ function classifyRequiredChecks(required) {
         return { state: 'pending', required };
     return { state: 'passed', required };
 }
-async function watchRequiredChecks(options) {
-    const now = options.now || (() => performance.now());
-    const sleep = options.sleep || ((delay) => new Promise((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) {
+    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) {
     try {
@@ -92,7 +85,7 @@ registerPlatformCapabilities('github', {
     inspectRequiredChecks({ client, repository, number, cwd }) {
         const github = client || createGitHubClient();
         const inspected = github.json([
-            'pr', 'checks', String(number), '--repo', repository, '--required',
+            'pr', 'checks', String(number), '--repo', repository,
             '--json', 'name,state,bucket,link,workflow,startedAt,completedAt'
         ], { cwd });
         return inspected.ok
@@ -122,6 +115,9 @@ function inspectRequiredChecks(taskRef, options = {}) {
     const base = resolvedTask(taskRef, options);
     if (!base.ok)
         return base.output;
+    return inspectChecksForResolvedTask(base, options);
+}
+function inspectChecksForResolvedTask(base, options) {
     const repository = base.context.platform.repository;
     const inspected = inspectPlatformRequiredChecks(base.context.platform.type, {
         cwd: base.resolved.repoRoot,
@@ -157,33 +153,60 @@ function inspectRequiredChecks(taskRef, options = {}) {
         }
     });
 }
-async function watchPlatformChecks(taskRef, options) {
-    let last = 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;
-            return last.checks;
+function inspectPullRequestReadiness(taskRef, options = {}) {
+    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
+    });
+    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'
         }
     });
-    if (!last)
-        return checksResult('blocked', { checks: watched, error: { code: 'REQUIRED_CHECKS_UNAVAILABLE', message: 'No checks snapshot was produced', retryable: true } });
-    const snapshot = last;
-    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 };
+}
+async function watchPullRequestReadiness(taskRef, options) {
+    const now = options.now || (() => performance.now());
+    const sleep = options.sleep || ((delay) => new Promise((resolve) => setTimeout(resolve, delay)));
+    const started = now();
+    let last = null;
+    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, options) {
     const base = resolvedTask(taskRef, options);
@@ -240,5 +263,5 @@ function fetchPlatformCheckLogs(taskRef, options) {
         logs: { runId: options.run, ...(options.job ? { jobId: options.job } : {}), text: fetched.value }, error: null
     });
 }
-export { classifyRequiredChecks, fetchCheckLogText, fetchPlatformCheckLogs, inspectRequiredChecks, parseRunJobIdentity, resolvePlatformCheckRun, resolveRunCandidate, watchPlatformChecks, watchRequiredChecks };
+export { classifyPullRequestReadiness, classifyRequiredChecks, fetchCheckLogText, fetchPlatformCheckLogs, inspectRequiredChecks, inspectPullRequestReadiness, parseRunJobIdentity, resolvePlatformCheckRun, resolveRunCandidate, watchPullRequestReadiness };
 //# sourceMappingURL=pr-checks.js.map

package/dist/lib/platform/pr-review.js

@@ -0,0 +1,166 @@
+import { createGitHubClient } from './github-client.js';
+import { resolvePlatformContext } from './context.js';
+import { platformResult } from './types.js';
+const REVIEW_EVENTS = ['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) {
+    return `<!-- review-pr:${identity.scope}:r${identity.round} -->`;
+}
+export function reviewedCommitMarker(sha) {
+    return `<!-- reviewed-commit: ${sha} -->`;
+}
+function normalizeBody(body) {
+    return String(body || '').replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+function firstLine(body) {
+    return normalizeBody(String(body || '')).split('\n', 1)[0] || '';
+}
+function hasUsableContext(context) {
+    return (context.status === 'no-op' || context.status === 'degraded') && context.platform.repository !== null;
+}
+function invalidPrNumber(prNumber) {
+    return !Number.isInteger(prNumber) || prNumber <= 0;
+}
+export function listPrReviews(prNumber, options = {}) {
+    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(['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 = 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) {
+    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(['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
+    });
+}
+//# sourceMappingURL=pr-review.js.map