@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/dist/lib/platform/github-release-notes.js

@@ -0,0 +1,96 @@
+import { createGitHubClient } from './github-client.js';
+function normalizeGitHubActor(actor) {
+    const name = String(actor.name || '').trim();
+    const email = actor.email ? String(actor.email).trim() : null;
+    const platformLogin = actor.user?.login?.trim().toLowerCase() || null;
+    const noReplyLogin = email
+        ? /^(?:\d+\+)?([^@]+)@users\.noreply\.github\.com$/i.exec(email)?.[1]?.toLowerCase() || null
+        : null;
+    const login = platformLogin || noReplyLogin;
+    return {
+        name,
+        email,
+        login,
+        bot: Boolean(login?.endsWith('[bot]')),
+        resolution: platformLogin ? 'platform-user' : noReplyLogin ? 'platform-noreply' : 'unresolved'
+    };
+}
+function failure(error) {
+    return {
+        status: error.retryable ? 'blocked' : 'failed',
+        changed: false,
+        operation: null,
+        url: null,
+        error
+    };
+}
+function publishGitHubReleaseNotes(input, options = {}) {
+    const client = options.client ?? createGitHubClient();
+    const inspected = client.json(['release', 'view', input.tag, '--repo', input.repository, '--json', 'url'], { cwd: options.cwd });
+    if (!inspected.ok && inspected.error.code !== 'RESOURCE_NOT_FOUND')
+        return failure(inspected.error);
+    const exists = inspected.ok;
+    const operation = exists ? 'release:update-notes' : 'release:create';
+    if (input.dryRun) {
+        return {
+            status: 'planned',
+            changed: false,
+            operation,
+            url: inspected.ok ? inspected.value.url || null : null,
+            error: null
+        };
+    }
+    const args = exists
+        ? ['release', 'edit', input.tag, '--repo', input.repository, '--notes-file', input.notesFile]
+        : ['release', 'create', input.tag, '--repo', input.repository, '--title', input.title, '--notes-file', input.notesFile];
+    const written = client.text(args, { cwd: options.cwd, method: exists ? 'PATCH' : 'POST' });
+    if (!written.ok)
+        return failure(written.error);
+    return {
+        status: 'applied',
+        changed: true,
+        operation,
+        url: written.value || (inspected.ok ? inspected.value.url || null : null),
+        error: null
+    };
+}
+function fetchGitHubReleaseNoteData(input, options = {}) {
+    const client = options.client ?? createGitHubClient();
+    const releases = client.json(['release', 'list', '--repo', input.repository, '--limit', String(input.historyLimit + 10), '--json', 'tagName,isDraft,isPrerelease'], { cwd: options.cwd });
+    if (!releases.ok)
+        return failure(releases.error);
+    const history = [];
+    for (const item of releases.value.filter((entry) => !entry.isDraft && !entry.isPrerelease).slice(0, input.historyLimit)) {
+        const viewed = client.json(['release', 'view', String(item.tagName), '--repo', input.repository, '--json', 'body,url'], { cwd: options.cwd });
+        if (!viewed.ok)
+            return failure(viewed.error);
+        history.push({ tag: String(item.tagName), body: String(viewed.value.body || ''), url: viewed.value.url || null });
+    }
+    const prs = client.json(['pr', 'list', '--repo', input.repository, '--state', 'merged', '--base', input.branch, '--limit', '1000', '--json', 'number,title,body,url,mergedAt,labels,author,closingIssuesReferences'], { cwd: options.cwd });
+    if (!prs.ok)
+        return failure(prs.error);
+    const authors = new Map();
+    for (const oid of input.commitOids) {
+        const query = `query($owner:String!,$name:String!,$oid:GitObjectID!){repository(owner:$owner,name:$name){object(oid:$oid){... on Commit{authors(first:100){nodes{name email user{login}} pageInfo{hasNextPage}}}}}}`;
+        const [owner, name] = input.repository.split('/');
+        const result = client.json([
+            'api', 'graphql', '-f', `query=${query}`, '-F', `owner=${owner}`, '-F', `name=${name}`, '-F', `oid=${oid}`
+        ], { cwd: options.cwd });
+        if (!result.ok)
+            return failure(result.error);
+        const connection = result.value.data?.repository?.object?.authors;
+        if (connection?.pageInfo?.hasNextPage) {
+            return failure({ code: 'RELEASE_NOTES_AUTHORS_TRUNCATED', message: `Commit authors exceeded the supported page size for ${oid}`, retryable: false });
+        }
+        authors.set(oid, (connection?.nodes || []).map(normalizeGitHubActor));
+    }
+    const fromTime = Date.parse(input.fromTime);
+    const toTime = Date.parse(input.toTime);
+    const pullRequests = prs.value.filter((item) => {
+        const mergedAt = Date.parse(String(item.mergedAt || ''));
+        return Number.isFinite(mergedAt) && mergedAt > fromTime && mergedAt <= toTime;
+    });
+    return { status: 'no-op', changed: false, history, pullRequests, authors, error: null };
+}
+export { fetchGitHubReleaseNoteData, normalizeGitHubActor, publishGitHubReleaseNotes };
+//# sourceMappingURL=github-release-notes.js.map

package/dist/lib/platform/issues.js

@@ -5,7 +5,7 @@ import { buildDefaultBody } from '../task/commands/issue-body.js';
 import { extractTitle, parseTaskFrontmatter } from '../task/frontmatter.js';
 import { requirementFieldLabels, renderTemplateBody } from '../task/issue-form.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
-import { extractSection } from '../task/sections.js';
+import { extractSection, findSectionHeading } from '../task/sections.js';
 import { writeTask } from '../task/write.js';
 import { resolvePlatformContext } from './context.js';
 import { createGitHubClient } from './github-client.js';
@@ -228,7 +228,9 @@ function deterministicIssueBody(repoRoot, content, taskType) {
             return renderTemplateBody(fs.readFileSync(selected, 'utf8'), {
                 title: taskTitle(content),
                 description: extractSection(content, ['描述', 'Description']),
-                requirements: extractSection(content, ['需求', 'Requirements'])
+                requirements: extractSection(content, ['需求', 'Requirements']),
+                taskInput: extractSection(content, ['任务输入', 'Task Input']),
+                taskInputHeading: findSectionHeading(content, ['任务输入', 'Task Input'])
             });
         }
         catch {

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

@@ -0,0 +1,84 @@
+import { execFileSync, spawnSync } from "node:child_process";
+const SHA_PATTERN = /^[0-9a-f]{40}$/i;
+function git(cwd, args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        maxBuffer: 32 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+}
+function commitExists(gitRoot, sha) {
+    try {
+        git(gitRoot, ["cat-file", "-e", `${sha}^{commit}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isAncestor(gitRoot, ancestor, descendant) {
+    const result = spawnSync("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+        cwd: gitRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.status === 0)
+        return { status: "yes" };
+    if (result.status === 1)
+        return { status: "no" };
+    return { status: "error" };
+}
+export function resolveReviewedHeadRelation(input) {
+    const { gitRoot, comparisonHead, lastReviewedCommit, pullRequest } = input;
+    if (comparisonHead === lastReviewedCommit &&
+        lastReviewedCommit === pullRequest.head.sha &&
+        !(pullRequest.state === "closed" && pullRequest.mergedAt && pullRequest.mergeCommitSha)) {
+        return { status: "strict", reviewedHead: lastReviewedCommit };
+    }
+    if (pullRequest.state !== "closed" || !pullRequest.mergedAt || !pullRequest.mergeCommitSha ||
+        lastReviewedCommit !== pullRequest.head.sha) {
+        return { status: "failed", code: "PR_MERGE_IDENTITY_INVALID", message: "PR merge identity does not match the reviewed head" };
+    }
+    const shas = [pullRequest.base.sha, pullRequest.head.sha, pullRequest.mergeCommitSha, comparisonHead];
+    if (shas.some((sha) => !SHA_PATTERN.test(sha) || !commitExists(gitRoot, sha))) {
+        return { status: "blocked", code: "PR_MERGE_OBJECT_MISSING", message: "Required PR merge Git objects are unavailable" };
+    }
+    const ancestry = isAncestor(gitRoot, pullRequest.mergeCommitSha, comparisonHead);
+    if (ancestry.status === "no") {
+        return {
+            status: "failed",
+            code: "PR_MERGE_TARGET_MISMATCH",
+            message: "PR merge commit is not in the authoritative target history"
+        };
+    }
+    if (ancestry.status === "error") {
+        return {
+            status: "blocked",
+            code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE",
+            message: "Unable to verify PR merge ancestry"
+        };
+    }
+    try {
+        const parents = git(gitRoot, ["rev-list", "--parents", "-n", "1", pullRequest.mergeCommitSha]).trim().split(/\s+/);
+        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" };
+        }
+    }
+    catch {
+        return { status: "blocked", code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", message: "Unable to verify PR merge topology or content" };
+    }
+    return {
+        status: "merged-equivalent",
+        reviewedHead: lastReviewedCommit,
+        mergeCommit: pullRequest.mergeCommitSha,
+        comparisonHead
+    };
+}
+//# sourceMappingURL=merged-pr-equivalence.js.map

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

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { parseTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
+import { inspectPlatformRequiredChecks, registerPlatformCapabilities } from './adapters.js';
 import { resolvePlatformContext } from './context.js';
 import { createGitHubClient } from './github-client.js';
 import { inspectPlatformPullRequest } from './pull-requests.js';
@@ -87,6 +88,18 @@ function normalizeChecks(value) {
             }] : [];
     });
 }
+registerPlatformCapabilities('github', {
+    inspectRequiredChecks({ client, repository, number, cwd }) {
+        const github = client || createGitHubClient();
+        const inspected = github.json([
+            'pr', 'checks', String(number), '--repo', repository, '--required',
+            '--json', 'name,state,bucket,link,workflow,startedAt,completedAt'
+        ], { cwd });
+        return inspected.ok
+            ? { ok: true, value: normalizeChecks(inspected.value) }
+            : { ok: false, error: inspected.error };
+    }
+});
 function resolvedTask(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
@@ -110,25 +123,33 @@ function inspectRequiredChecks(taskRef, options = {}) {
     if (!base.ok)
         return base.output;
     const repository = base.context.platform.repository;
-    const inspected = base.client.json([
-        'pr', 'checks', String(base.prNumber), '--repo', repository, '--required',
-        '--json', 'name,state,bucket,link,workflow,startedAt,completedAt'
-    ], { cwd: base.resolved.repoRoot });
-    if (!inspected.ok) {
-        return checksResult(inspected.error.retryable ? 'blocked' : 'failed', {
+    const inspected = inspectPlatformRequiredChecks(base.context.platform.type, {
+        cwd: base.resolved.repoRoot,
+        repository,
+        number: base.prNumber,
+        headSha: base.pullRequest.head.sha,
+        client: options.client || base.client
+    });
+    if (!inspected.ok || !inspected.value) {
+        const error = inspected.error || {
+            code: 'REQUIRED_CHECKS_INSPECTION_INVALID',
+            message: 'Platform adapter returned no required-checks snapshot',
+            retryable: false
+        };
+        return checksResult(error.retryable ? 'blocked' : 'failed', {
             platform: base.context.platform, capabilities: base.context.capabilities,
             resource: { kind: 'pull-request', number: base.prNumber },
-            pullRequest: { number: base.prNumber, headSha: base.pullRequest.head.sha }, error: inspected.error
+            pullRequest: base.pullRequest, error
         });
     }
-    const classified = classifyRequiredChecks(normalizeChecks(inspected.value));
+    const classified = classifyRequiredChecks(inspected.value);
     const status = classified.state === 'passed' || classified.state === 'no-required'
         ? 'no-op'
         : classified.state === 'failed' || classified.state === 'cancelled' ? 'failed' : 'blocked';
     return checksResult(status, {
         platform: base.context.platform, capabilities: base.context.capabilities,
         resource: { kind: 'pull-request', number: base.prNumber },
-        pullRequest: { number: base.prNumber, headSha: base.pullRequest.head.sha }, checks: classified,
+        pullRequest: base.pullRequest, checks: classified,
         error: status === 'no-op' ? null : {
             code: classified.state === 'pending' ? 'REQUIRED_CHECKS_PENDING' : `REQUIRED_CHECKS_${classified.state.toUpperCase()}`,
             message: `Required checks are ${classified.state}`,
@@ -172,10 +193,10 @@ function resolvePlatformCheckRun(taskRef, options) {
     if (direct) {
         const run = base.client.json(['api', `repos/${base.context.platform.repository}/actions/runs/${direct.runId}`], { cwd: base.resolved.repoRoot });
         if (!run.ok)
-            return checksResult(run.error.retryable ? 'blocked' : 'failed', { platform: base.context.platform, capabilities: base.context.capabilities, pullRequest: { number: base.prNumber, headSha: base.pullRequest.head.sha }, error: run.error });
+            return checksResult(run.error.retryable ? 'blocked' : 'failed', { platform: base.context.platform, capabilities: base.context.capabilities, pullRequest: base.pullRequest, error: run.error });
         if (run.value.head_sha !== base.pullRequest.head.sha)
             return checksResult('failed', { error: { code: 'CHECK_RUN_HEAD_MISMATCH', message: 'Resolved run does not belong to the PR head SHA', retryable: false } });
-        return checksResult('no-op', { platform: base.context.platform, capabilities: base.context.capabilities, resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: { number: base.prNumber, headSha: base.pullRequest.head.sha }, resolution: { status: 'resolved', ...direct }, error: null });
+        return checksResult('no-op', { platform: base.context.platform, capabilities: base.context.capabilities, resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: base.pullRequest, resolution: { status: 'resolved', ...direct }, error: null });
     }
     const listed = base.client.json(['api', `repos/${base.context.platform.repository}/commits/${base.pullRequest.head.sha}/check-runs`], { cwd: base.resolved.repoRoot });
     if (!listed.ok)
@@ -189,11 +210,18 @@ function resolvePlatformCheckRun(taskRef, options) {
     const resolution = resolveRunCandidate(candidates, base.pullRequest.head.sha, options.checkName);
     return checksResult(resolution.status === 'resolved' ? 'no-op' : 'failed', {
         platform: base.context.platform, capabilities: base.context.capabilities,
-        resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: { number: base.prNumber, headSha: base.pullRequest.head.sha },
+        resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: base.pullRequest,
         resolution,
         error: resolution.status === 'resolved' ? null : { code: resolution.status === 'ambiguous' ? 'CHECK_RUN_AMBIGUOUS' : 'CHECK_RUN_NOT_FOUND', message: `Check run is ${resolution.status}`, retryable: false }
     });
 }
+function fetchCheckLogText(client, args, cwd) {
+    const fetched = client.text(args, { cwd });
+    if (fetched.ok || args[0] !== 'api' || !/response contains terminal escape sequences/i.test(fetched.error.message)) {
+        return fetched;
+    }
+    return client.text([...args, '--allow-escape-sequences'], { cwd });
+}
 function fetchPlatformCheckLogs(taskRef, options) {
     const base = resolvedTask(taskRef, options);
     if (!base.ok)
@@ -201,16 +229,16 @@ function fetchPlatformCheckLogs(taskRef, options) {
     const args = options.job
         ? ['api', `repos/${base.context.platform.repository}/actions/jobs/${options.job}/logs`]
         : ['run', 'view', String(options.run), '--repo', base.context.platform.repository, '--log-failed'];
-    const fetched = base.client.text(args, { cwd: base.resolved.repoRoot });
+    const fetched = fetchCheckLogText(base.client, args, base.resolved.repoRoot);
     if (!fetched.ok)
         return checksResult(fetched.error.retryable ? 'blocked' : 'failed', { platform: base.context.platform, capabilities: base.context.capabilities, error: fetched.error });
     if (!fetched.value)
         return checksResult('failed', { error: { code: 'CHECK_LOGS_MISSING', message: 'No failed logs are available', retryable: false } });
     return checksResult('no-op', {
         platform: base.context.platform, capabilities: base.context.capabilities,
-        resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: { number: base.prNumber, headSha: base.pullRequest.head.sha },
+        resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: base.pullRequest,
         logs: { runId: options.run, ...(options.job ? { jobId: options.job } : {}), text: fetched.value }, error: null
     });
 }
-export { classifyRequiredChecks, fetchPlatformCheckLogs, inspectRequiredChecks, parseRunJobIdentity, resolvePlatformCheckRun, resolveRunCandidate, watchPlatformChecks, watchRequiredChecks };
+export { classifyRequiredChecks, fetchCheckLogText, fetchPlatformCheckLogs, inspectRequiredChecks, parseRunJobIdentity, resolvePlatformCheckRun, resolveRunCandidate, watchPlatformChecks, watchRequiredChecks };
 //# sourceMappingURL=pr-checks.js.map

package/dist/lib/platform/pull-requests.js

@@ -1,9 +1,11 @@
 import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { parseTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { extractSection } from '../task/sections.js';
 import { captureTaskWriteMetadata, writeTask } from '../task/write.js';
-import { resolvePlatformContext } from './context.js';
+import { inspectPlatformChangeRequest, registerPlatformCapabilities } from './adapters.js';
+import { parseGitHubRemote, resolvePlatformContext } from './context.js';
 import { createGitHubClient } from './github-client.js';
 import { inspectPlatformIssue } from './issues.js';
 import { planPullRequestMetadata } from './pull-request-metadata.js';
@@ -33,7 +35,9 @@ function normalizePullRequest(remote, repository) {
         body: remote.body || '',
         draft: Boolean(remote.draft),
         head: { repository: headRepository, ref: remote.head.ref, sha: remote.head.sha },
-        base: { repository: baseRepository, ref: remote.base.ref },
+        base: { repository: baseRepository, ref: remote.base.ref, sha: remote.base.sha || '' },
+        mergedAt: remote.merged_at || null,
+        mergeCommitSha: remote.merge_commit_sha || null,
         labels: (remote.labels || []).map((label) => typeof label === 'string' ? label : label.name || '').filter(Boolean).sort(),
         assignees: (remote.assignees || []).map((assignee) => assignee.login || '').filter(Boolean).sort(),
         milestone: remote.milestone?.title || null
@@ -88,6 +92,97 @@ function inspectGitHubPullRequest(client, repository, number, cwd) {
         ? { ok: true, value: pullRequest }
         : { ok: false, error: { code: 'PR_IDENTITY_INVALID', message: 'Remote resource is not a valid pull request', retryable: false } };
 }
+function configuredGitRemotes(cwd) {
+    try {
+        return execFileSync('git', ['remote'], {
+            cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']
+        }).split(/\r?\n/).filter(Boolean).flatMap((name) => {
+            try {
+                const url = execFileSync('git', ['config', '--get', `remote.${name}.url`], {
+                    cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']
+                }).trim();
+                const repository = parseGitHubRemote(url);
+                return repository ? [{ name, url, repository }] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function rewriteGitHubRemote(remote, repository) {
+    const match = remote.trim().match(/^(https?:\/\/github\.com\/|ssh:\/\/(?:git@)?github\.com\/|git@github\.com:)[^/\s]+\/[^/\s]+(?:\.git)?$/i);
+    return match ? `${match[1]}${repository}.git` : null;
+}
+function resolveGitHubChangeRequestGitEvidence({ cwd, repository, pullRequest }) {
+    if (pullRequest.repository !== repository ||
+        pullRequest.base.repository !== repository ||
+        pullRequest.number <= 0) {
+        return {
+            ok: false,
+            error: {
+                code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+                message: 'Pull request repository identity is inconsistent',
+                retryable: false
+            }
+        };
+    }
+    const reviewedHeadRef = `refs/pull/${pullRequest.number}/head`;
+    const targetHeadRef = `refs/heads/${pullRequest.base.ref}`;
+    const refValid = (ref) => {
+        try {
+            execFileSync('git', ['check-ref-format', ref], {
+                cwd, encoding: 'utf8', stdio: ['ignore', 'ignore', 'ignore']
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!refValid(reviewedHeadRef) || !refValid(targetHeadRef)) {
+        return {
+            ok: false,
+            error: {
+                code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+                message: 'Pull request Git refs are invalid',
+                retryable: false
+            }
+        };
+    }
+    const remotes = configuredGitRemotes(cwd);
+    const exact = remotes
+        .filter((remote) => remote.repository === repository)
+        .sort((left, right) => Number(right.name === 'origin') - Number(left.name === 'origin') ||
+        left.name.localeCompare(right.name))[0];
+    const origin = remotes.find((remote) => remote.name === 'origin');
+    const remoteUrl = exact?.url || (origin ? rewriteGitHubRemote(origin.url, repository) : null);
+    if (!remoteUrl) {
+        return {
+            ok: false,
+            error: {
+                code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+                message: `No GitHub remote can provide evidence for ${repository}`,
+                retryable: false
+            }
+        };
+    }
+    return {
+        ok: true,
+        value: { remoteUrl, reviewedHeadRef, targetHeadRef }
+    };
+}
+registerPlatformCapabilities('github', {
+    inspectChangeRequest({ client, repository, number, cwd }) {
+        return inspectGitHubPullRequest(client || createGitHubClient(), repository, number, cwd);
+    },
+    resolveChangeRequestGitEvidence(context) {
+        return resolveGitHubChangeRequestGitEvidence(context);
+    }
+});
 function locatePullRequest(base, head, target) {
     const repository = base.context.platform.repository;
     const listed = base.client.json([
@@ -113,12 +208,23 @@ function inspectPlatformPullRequest(taskRef, options = {}) {
             platform: base.context.platform, capabilities: base.context.capabilities,
             error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false }
         });
-    const fetched = inspectGitHubPullRequest(base.client, base.context.platform.repository, base.prNumber, base.resolved.repoRoot);
-    if (!fetched.ok)
-        return result(fetched.error.retryable ? 'blocked' : 'failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
+    const fetched = inspectPlatformChangeRequest(base.context.platform.type, {
+        cwd: base.resolved.repoRoot,
+        repository: base.context.platform.repository,
+        number: base.prNumber,
+        client: options.client || base.client
+    });
+    if (!fetched.ok || !fetched.value) {
+        const error = fetched.error || {
+            code: 'PR_INSPECTION_INVALID',
+            message: 'Platform adapter returned no change-request snapshot',
+            retryable: false
+        };
+        return result(error.retryable ? 'blocked' : 'failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
             platform: base.context.platform, capabilities: base.context.capabilities,
-            resource: { kind: 'pull-request', number: base.prNumber }, error: fetched.error
+            resource: { kind: 'pull-request', number: base.prNumber }, error
         });
+    }
     return result('no-op', base.resolved.taskId, base.issueNumber, base.prNumber, {
         platform: base.context.platform, capabilities: base.context.capabilities,
         resource: { kind: 'pull-request', number: base.prNumber }, pullRequest: fetched.value, error: null
@@ -334,5 +440,5 @@ function syncPlatformPullRequest(taskRef, options) {
         operations: operations.map((operation) => operation.status === 'planned' ? { ...operation, status: 'applied' } : operation), error: null
     });
 }
-export { bindPlatformPullRequest, createPlatformPullRequest, inspectGitHubPullRequest, inspectPlatformPullRequest, normalizePullRequest, selectPullRequest, syncPlatformPullRequest };
+export { bindPlatformPullRequest, createPlatformPullRequest, inspectGitHubPullRequest, inspectPlatformPullRequest, normalizePullRequest, resolveGitHubChangeRequestGitEvidence, selectPullRequest, syncPlatformPullRequest };
 //# sourceMappingURL=pull-requests.js.map

package/dist/lib/platform/release-notes.js

@@ -0,0 +1,143 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { resolvePlatformContext } from './context.js';
+import { fetchGitHubReleaseNoteData, publishGitHubReleaseNotes } from './github-release-notes.js';
+const unsupportedError = {
+    code: 'PLATFORM_RELEASE_NOTES_UNSUPPORTED',
+    message: 'Release notes are not supported for the configured platform',
+    retryable: false
+};
+function baseResult(status) {
+    return {
+        status,
+        changed: false,
+        range: null,
+        history: [],
+        pullRequests: [],
+        commits: [],
+        error: status === 'no-op' ? unsupportedError : null
+    };
+}
+function git(cwd, args) {
+    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+function configuredPlatform(cwd) {
+    try {
+        const value = JSON.parse(fs.readFileSync(path.join(cwd, '.agents', '.airc.json'), 'utf8'));
+        return typeof value?.platform?.type === 'string' ? value.platform.type : null;
+    }
+    catch {
+        return null;
+    }
+}
+function releaseNoteContext(input, options = {}) {
+    const historyLimit = input.historyLimit ?? 3;
+    if (!input.fromTag || !input.toTag || !input.branch || !Number.isInteger(historyLimit) || historyLimit < 1 || historyLimit > 20) {
+        return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'from-tag, to-tag, branch, and a history limit from 1 to 20 are required', retryable: false } };
+    }
+    const cwd = path.resolve(options.cwd || process.cwd());
+    const platformType = options.platformType ?? configuredPlatform(cwd);
+    if (platformType !== 'github')
+        return baseResult('no-op');
+    let fromOid;
+    let toOid;
+    let fromTime;
+    let toTime;
+    let commitFacts;
+    try {
+        fromOid = git(cwd, ['rev-parse', '--verify', `${input.fromTag}^{commit}`]);
+        toOid = git(cwd, ['rev-parse', '--verify', `${input.toTag}^{commit}`]);
+        git(cwd, ['merge-base', '--is-ancestor', fromOid, toOid]);
+        fromTime = git(cwd, ['show', '-s', '--format=%cI', fromOid]);
+        toTime = git(cwd, ['show', '-s', '--format=%cI', toOid]);
+        const raw = git(cwd, ['log', '--reverse', '--no-merges', '--format=%H%x00%s', `${fromOid}..${toOid}`]);
+        commitFacts = raw ? raw.split('\n').map((line) => {
+            const [oid = '', title = ''] = line.split('\0');
+            return { oid, title };
+        }) : [];
+    }
+    catch {
+        return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_RANGE_INVALID', message: 'The release tag range is missing or is not ancestral', retryable: false } };
+    }
+    const context = resolvePlatformContext({ cwd, platformType, client: options.client });
+    if (!context.platform.repository) {
+        return {
+            ...baseResult(context.status === 'blocked' ? 'blocked' : 'failed'),
+            error: context.error || { code: 'PLATFORM_CONTEXT_UNAVAILABLE', message: 'Platform repository is unavailable', retryable: context.status === 'blocked' }
+        };
+    }
+    const platform = fetchGitHubReleaseNoteData({
+        repository: context.platform.repository,
+        commitOids: commitFacts.map((item) => item.oid),
+        branch: input.branch,
+        historyLimit,
+        fromTime,
+        toTime
+    }, { cwd, client: options.client });
+    if (platform.status === 'blocked' || platform.status === 'failed' || !('authors' in platform)) {
+        return { ...baseResult(platform.status), error: platform.error };
+    }
+    const commits = commitFacts.map((commit) => {
+        const seen = new Set();
+        const authors = (platform.authors.get(commit.oid) || []).filter((actor) => {
+            const key = actor.login || actor.email?.toLowerCase() || actor.name.toLowerCase();
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        return { ...commit, authors };
+    });
+    const pullRequests = platform.pullRequests
+        .map((item) => ({
+        number: Number(item.number),
+        title: String(item.title || ''),
+        body: String(item.body || ''),
+        url: String(item.url || ''),
+        mergedAt: String(item.mergedAt || ''),
+        labels: Array.isArray(item.labels) ? item.labels.map((label) => String(label.name || label)) : [],
+        author: item.author && typeof item.author === 'object'
+            ? { login: String(item.author.login || '').toLowerCase(), bot: String(item.author.login || '').endsWith('[bot]') }
+            : null,
+        closingIssues: Array.isArray(item.closingIssuesReferences)
+            ? item.closingIssuesReferences.map((issue) => {
+                const value = issue;
+                return {
+                    number: Number(value.number),
+                    title: String(value.title || ''),
+                    url: String(value.url || ''),
+                    labels: Array.isArray(value.labels) ? value.labels.map((label) => String(label.name || label)) : [],
+                    author: value.author && typeof value.author === 'object'
+                        ? { login: String(value.author.login || '').toLowerCase(), bot: String(value.author.login || '').endsWith('[bot]') }
+                        : null
+                };
+            }) : []
+    }))
+        .sort((left, right) => left.number - right.number);
+    return {
+        status: 'no-op',
+        changed: false,
+        range: { fromTag: input.fromTag, toTag: input.toTag, fromOid, toOid },
+        history: platform.history,
+        pullRequests,
+        commits,
+        error: null
+    };
+}
+function publishReleaseNotes(input, options = {}) {
+    if (!input.tag || !input.title || !input.notesFile) {
+        return { status: 'failed', changed: false, operation: null, url: null, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'tag, title, and notes-file are required', retryable: false } };
+    }
+    const cwd = path.resolve(options.cwd || process.cwd());
+    const platformType = options.platformType ?? configuredPlatform(cwd);
+    if (platformType !== 'github')
+        return { status: 'no-op', changed: false, operation: null, url: null, error: unsupportedError };
+    const context = resolvePlatformContext({ cwd, platformType, client: options.client });
+    if (!context.platform.repository) {
+        return { status: context.status === 'blocked' ? 'blocked' : 'failed', changed: false, operation: null, url: null, error: context.error };
+    }
+    return publishGitHubReleaseNotes({ ...input, repository: context.platform.repository }, { cwd, client: options.client });
+}
+export { publishReleaseNotes, releaseNoteContext };
+//# sourceMappingURL=release-notes.js.map

package/dist/lib/platform/releases.js

@@ -18,7 +18,7 @@ function inspectPlatformRelease(tag, options = {}) {
         return { ...platformResult(result.error.retryable ? 'blocked' : 'failed'), platform: context.platform, release: null, workflows: [], error: result.error };
     }
     const release = { tag: String(result.value.tagName || tag), published: !Boolean(result.value.isDraft), draft: Boolean(result.value.isDraft), url: result.value.url ? String(result.value.url) : null };
-    const runs = client.json(['run', 'list', '--repo', context.platform.repository, '--limit', '100', '--json', 'name,headBranch,status,conclusion,url'], { cwd: options.cwd });
+    const runs = client.json(['run', 'list', '--repo', context.platform.repository, '--limit', '100', '--json', 'name,workflowName,displayTitle,event,headBranch,headSha,status,conclusion,createdAt,databaseId,attempt,url'], { cwd: options.cwd });
     return { ...platformResult(runs.ok ? 'no-op' : runs.error.retryable ? 'blocked' : 'degraded'), platform: context.platform, release, workflows: runs.ok ? runs.value : [], error: runs.ok ? null : runs.error };
 }
 function upsertPlatformRelease(input, options = {}) {