@fitlab-ai/agent-infra 0.9.0 → 0.9.1

package/README.md

@@ -35,9 +35,14 @@ agent-infra standardizes that shared infrastructure. It gives every supported AI
 ## See it in Action
 
 <p align="center">
-  <img src="./assets/demo-init.gif" alt="CLI install and initialize demo" width="100%" style="max-width: 720px;">
+  <img src="./assets/demo-init.gif" alt="CLI install and initialize demo" width="720">
 </p>
 
+> The demo is stored with Git LFS. Install Git LFS and run `git lfs install`
+> before cloning, or run `git lfs pull` in an existing checkout. If the image
+> is a small text pointer or is missing, verify `git lfs ls-files`, then retry
+> `git lfs pull`.
+
 Once initialized, open the project in your AI TUI and install the latest skills:
 
 ```bash

package/README.zh-CN.md

@@ -35,9 +35,13 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 ## 实战演示
 
 <p align="center">
-  <img src="./assets/demo-init.gif" alt="CLI 安装初始化演示" width="100%" style="max-width: 720px;">
+  <img src="./assets/demo-init.gif" alt="CLI 安装初始化演示" width="720">
 </p>
 
+> 演示动画通过 Git LFS 存储。克隆前请安装 Git LFS 并运行 `git lfs install`；
+> 已有检出可运行 `git lfs pull`。如果图片变成很小的文本指针或缺失，请先用
+> `git lfs ls-files` 核对跟踪状态，再重试 `git lfs pull`。
+
 完成初始化后，在你的 AI TUI 中打开项目并安装最新 skills：
 
 ```bash

package/dist/bin/internal-cli.js

@@ -16,6 +16,11 @@ switch (command) {
         await releaseWorkflow(process.argv.slice(3));
         break;
     }
+    case 'platform-release-notes': {
+        const { platformReleaseNotes } = await import('../lib/internal/platform-release-notes.js');
+        platformReleaseNotes(process.argv.slice(3));
+        break;
+    }
     case 'platform-context': {
         const { platformContext } = await import('../lib/internal/platform-context.js');
         platformContext(process.argv.slice(3));

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

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { publishReleaseNotes, releaseNoteContext } from '../platform/release-notes.js';
+function option(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 && args[index + 1] ? args[index + 1] : null;
+}
+function finish(result) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0;
+}
+function platformReleaseNotes(args = []) {
+    const [action, ...rest] = args;
+    const cwd = path.resolve(option(rest, '--cwd') || process.cwd());
+    if (action === 'context') {
+        const historyRaw = option(rest, '--history-limit');
+        finish(releaseNoteContext({
+            fromTag: option(rest, '--from-tag') || '',
+            toTag: option(rest, '--to-tag') || '',
+            branch: option(rest, '--branch') || '',
+            historyLimit: historyRaw === null ? undefined : Number(historyRaw)
+        }, { cwd }));
+        return;
+    }
+    if (action === 'publish') {
+        const notesPath = option(rest, '--notes-file');
+        if (!notesPath) {
+            finish({ status: 'failed', changed: false, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'notes-file is required', retryable: false } });
+            return;
+        }
+        let resolvedNotesPath = notesPath;
+        if (notesPath === '-') {
+            resolvedNotesPath = path.join(process.env.TMPDIR || '/tmp', `agent-infra-release-notes-${process.pid}.md`);
+            fs.writeFileSync(resolvedNotesPath, fs.readFileSync(0));
+        }
+        try {
+            finish(publishReleaseNotes({
+                tag: option(rest, '--tag') || '',
+                title: option(rest, '--title') || option(rest, '--tag') || '',
+                notesFile: resolvedNotesPath,
+                dryRun: rest.includes('--dry-run')
+            }, { cwd }));
+        }
+        finally {
+            if (notesPath === '-')
+                fs.rmSync(resolvedNotesPath, { force: true });
+        }
+        return;
+    }
+    finish({ status: 'failed', changed: false, error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'Usage: platform-release-notes context|publish', retryable: false } });
+}
+export { platformReleaseNotes };
+//# sourceMappingURL=platform-release-notes.js.map

package/dist/lib/internal/release-workflow.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import semver from 'semver';
 import { commitExplicitPaths, inspectGitWorkflow, pushGitRefs } from '../git/workflow.js';
@@ -9,7 +10,97 @@ import { releaseSnapshot } from '../release/workflow.js';
 function command(cwd, executable, args) {
     return spawnSync(executable, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
 }
+const DEMO_INPUT_PATHS = [
+    'assets/demo-init.tape',
+    'scripts/demo-regen.sh',
+    'scripts/normalize-gif-duration.py',
+    'bin/cli.ts',
+    'lib/init.ts',
+    'lib/log.ts',
+    'lib/prompt.ts',
+    'lib/paths.ts',
+    'lib/render.ts',
+    'lib/builtin-tuis.ts',
+    'lib/sandbox/engines/',
+    'src/sync-templates.js',
+    'templates/'
+];
+const DEMO_DIGEST_PATH = 'assets/demo-init.inputs.sha256';
+const DEMO_OUTPUT_PATH = 'assets/demo-init.gif';
+const DEMO_MAX_BYTES = 4 * 1024 * 1024;
+function demoInputFiles(cwd) {
+    const files = new Set();
+    for (const input of DEMO_INPUT_PATHS) {
+        if (input.endsWith('/')) {
+            const listed = command(cwd, 'git', ['ls-files', '--', input]);
+            if (listed.status !== 0)
+                throw new Error(String(listed.stderr || `Unable to list ${input}`));
+            const directoryFiles = String(listed.stdout).split('\n').filter(Boolean);
+            if (!directoryFiles.length)
+                throw new Error(`Canonical demo input directory is empty: ${input}`);
+            for (const file of directoryFiles)
+                files.add(file.replaceAll('\\', '/'));
+        }
+        else {
+            files.add(input);
+        }
+    }
+    const sorted = [...files].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
+    if (!sorted.length)
+        throw new Error('Canonical demo input set is empty');
+    for (const file of sorted) {
+        const absolute = path.join(cwd, file);
+        if (!fs.statSync(absolute).isFile())
+            throw new Error(`Canonical demo input is not a file: ${file}`);
+    }
+    return sorted;
+}
+function computeDemoInputDigest(cwd) {
+    const hash = crypto.createHash('sha256');
+    for (const file of demoInputFiles(cwd)) {
+        const bytes = fs.readFileSync(path.join(cwd, file));
+        hash.update(file);
+        hash.update('\0');
+        hash.update(String(bytes.byteLength));
+        hash.update('\0');
+        hash.update(bytes);
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function validGif(filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const header = fs.readFileSync(filePath).subarray(0, 6).toString('ascii');
+    return header === 'GIF87a' || header === 'GIF89a';
+}
+function writeDigestAtomically(cwd, digest) {
+    const target = path.join(cwd, DEMO_DIGEST_PATH);
+    const temporary = `${target}.tmp-${process.pid}`;
+    fs.writeFileSync(temporary, `${digest}\n`);
+    fs.renameSync(temporary, target);
+}
 function runOptionalDemo(cwd, run = command) {
+    let digest;
+    try {
+        digest = computeDemoInputDigest(cwd);
+    }
+    catch (error) {
+        return { status: 'failed', reasonCode: 'DEMO_DIGEST_FAILED', message: String(error), outputPath: null };
+    }
+    const digestPath = path.join(cwd, DEMO_DIGEST_PATH);
+    const priorDigest = fs.existsSync(digestPath) ? fs.readFileSync(digestPath, 'utf8').trim() : '';
+    if (/^[0-9a-f]{64}$/.test(priorDigest) && priorDigest === digest) {
+        return { status: 'skipped', reasonCode: 'DEMO_INPUTS_UNCHANGED', message: null, outputPath: null };
+    }
+    const lfs = run(cwd, 'git', ['lfs', 'version']);
+    if (lfs.status !== 0) {
+        return { status: 'failed', reasonCode: 'GIT_LFS_MISSING', message: String(lfs.stderr || lfs.stdout), outputPath: null };
+    }
+    const lfsAttribute = run(cwd, 'git', ['check-attr', 'filter', '--', DEMO_OUTPUT_PATH]);
+    if (lfsAttribute.status !== 0 || !String(lfsAttribute.stdout).trim().endsWith(': lfs')) {
+        return { status: 'failed', reasonCode: 'GIT_LFS_MISSING', message: `${DEMO_OUTPUT_PATH} is not tracked by Git LFS`, outputPath: null };
+    }
     const vhs = run(cwd, 'vhs', ['--version']);
     if (vhs.status !== 0)
         return { status: 'skipped', reasonCode: 'VHS_MISSING', message: null, outputPath: null };
@@ -25,7 +116,7 @@ function runOptionalDemo(cwd, run = command) {
             outputPath: null
         };
     }
-    const outputPath = 'assets/demo-init.gif';
+    const outputPath = DEMO_OUTPUT_PATH;
     if (!fs.existsSync(path.join(cwd, outputPath))) {
         return {
             status: 'failed',
@@ -34,6 +125,18 @@ function runOptionalDemo(cwd, run = command) {
             outputPath: null
         };
     }
+    const absoluteOutput = path.join(cwd, outputPath);
+    if (!validGif(absoluteOutput)) {
+        return { status: 'failed', reasonCode: 'DEMO_OUTPUT_INVALID', message: `${outputPath} is not a GIF`, outputPath: null };
+    }
+    if (fs.statSync(absoluteOutput).size > DEMO_MAX_BYTES) {
+        return { status: 'failed', reasonCode: 'DEMO_OUTPUT_TOO_LARGE', message: `${outputPath} exceeds 4 MiB`, outputPath: null };
+    }
+    const pointer = run(cwd, 'git', ['lfs', 'pointer', `--file=${outputPath}`]);
+    if (pointer.status !== 0 || !String(pointer.stdout).includes(`size ${fs.statSync(absoluteOutput).size}`)) {
+        return { status: 'failed', reasonCode: 'DEMO_OUTPUT_INVALID', message: 'Git LFS could not produce a matching pointer', outputPath: null };
+    }
+    writeDigestAtomically(cwd, digest);
     return { status: 'recorded', reasonCode: null, message: null, outputPath };
 }
 function git(cwd, args) {
@@ -213,5 +316,5 @@ async function releaseWorkflow(args = []) {
     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 { inspectFacts, releaseWorkflow, runOptionalDemo };
+export { computeDemoInputDigest, inspectFacts, releaseWorkflow, runOptionalDemo };
 //# sourceMappingURL=release-workflow.js.map

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,54 @@
+import { execFileSync } 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 });
+}
+function commitExists(gitRoot, sha) {
+    try {
+        git(gitRoot, ["cat-file", "-e", `${sha}^{commit}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveReviewedHeadRelation(input) {
+    const { gitRoot, localHead, lastReviewedCommit, pullRequest, pathspecs } = input;
+    if (localHead === lastReviewedCommit && lastReviewedCommit === pullRequest.head.sha) {
+        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, localHead];
+    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" };
+    }
+    try {
+        git(gitRoot, ["merge-base", "--is-ancestor", pullRequest.mergeCommitSha, localHead]);
+        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" };
+        }
+        const postMerge = git(gitRoot, ["rev-list", `${pullRequest.mergeCommitSha}..${localHead}`, "--", ...pathspecs]).trim();
+        if (postMerge) {
+            return { status: "failed", code: "POST_MERGE_CHANGES", message: "Protected paths changed after the squash merge" };
+        }
+    }
+    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
+    };
+}
+//# sourceMappingURL=merged-pr-equivalence.js.map

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

@@ -118,7 +118,7 @@ function inspectRequiredChecks(taskRef, options = {}) {
         return checksResult(inspected.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: inspected.error
         });
     }
     const classified = classifyRequiredChecks(normalizeChecks(inspected.value));
@@ -128,7 +128,7 @@ function inspectRequiredChecks(taskRef, options = {}) {
     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 +172,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,7 +189,7 @@ 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 }
     });
@@ -208,7 +208,7 @@ function fetchPlatformCheckLogs(taskRef, options) {
         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
     });
 }

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

@@ -33,7 +33,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

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