@fitlab-ai/agent-infra 0.11.5 → 0.11.6

package/dist/lib/merge.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { removeDirRecursive } from './remove-dir.js';
 import { validateCurrentTaskContract } from './task/current-contract.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
@@ -44,7 +45,7 @@ function extractTitle(content) {
         .replace(/\|/g, '\\|') || null;
 }
 function normalizeTaskRecord(taskDir, taskFile, dateParts) {
-    const taskId = path.basename(taskDir);
+    const taskId = path.basename(taskDir) === 'local' ? path.basename(path.dirname(taskDir)) : path.basename(taskDir);
     const content = fs.readFileSync(taskFile, 'utf8');
     const completedAt = extractField(content, 'completed_at');
     const updatedAt = extractField(content, 'updated_at');
@@ -85,7 +86,7 @@ function scanSourceTasks(sourceDir) {
                     if (!taskEntry.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
                         continue;
                     }
-                    const taskDir = path.join(dayDir, taskEntry.name);
+                    const taskDir = path.join(dayDir, taskEntry.name, 'local');
                     const taskFile = path.join(taskDir, 'task.md');
                     if (!fs.existsSync(taskFile)) {
                         continue;
@@ -165,7 +166,7 @@ function collectArchiveEntries(archiveDir) {
                         continue;
                     }
                     const taskDir = path.join(dayDir, taskEntry.name);
-                    const taskFile = path.join(taskDir, 'task.md');
+                    const taskFile = path.join(taskDir, 'local', 'task.md');
                     const relativePath = `${yearEntry.name}/${monthEntry.name}/${dayEntry.name}/${taskEntry.name}/`;
                     let title = taskEntry.name;
                     let type = 'unknown';
@@ -471,9 +472,10 @@ function validateSourceRoot(sourceRoot) {
         invalidSource('source path must be a real directory');
     }
 }
-function validateTaskDirectory(sourceRoot, taskDir, seenTaskIds) {
+function validateTaskDirectory(sourceRoot, taskDir, seenTaskIds, archived = false) {
     const taskId = path.basename(taskDir);
-    const taskFile = path.join(taskDir, 'task.md');
+    const contentDir = archived ? path.join(taskDir, 'local') : taskDir;
+    const taskFile = path.join(contentDir, 'task.md');
     const taskDirStat = sourcePathStat(sourceRoot, taskDir);
     if (!taskDirStat || !taskDirStat.isDirectory()) {
         invalidSource(`${sourceRelativePath(sourceRoot, taskDir)} must be a directory`);
@@ -491,12 +493,63 @@ function validateTaskDirectory(sourceRoot, taskDir, seenTaskIds) {
         invalidSource(`${sourceRelativePath(sourceRoot, taskFile)} id '${String(contract.metadata.id ?? 'missing')}' does not match directory '${taskId}'`);
     }
     validateTaskTree(sourceRoot, taskDir);
+    if (archived) {
+        for (const entry of fs.readdirSync(taskDir, { withFileTypes: true })) {
+            if (!['local', 'github', 'derived'].includes(entry.name) || !entry.isDirectory()) {
+                invalidSource(`${sourceRelativePath(sourceRoot, path.join(taskDir, entry.name))} is not an allowed archive source directory`);
+            }
+        }
+        validateArchiveSource(sourceRoot, contentDir);
+        const githubDir = path.join(taskDir, 'github');
+        if (fs.existsSync(githubDir)) {
+            for (const capture of fs.readdirSync(githubDir, { withFileTypes: true })) {
+                const captureDir = path.join(githubDir, capture.name);
+                if (!capture.isDirectory() || !/^capture-[A-Za-z0-9._-]+$/.test(capture.name) || !fs.existsSync(path.join(captureDir, 'capture.md'))) {
+                    invalidSource(`${sourceRelativePath(sourceRoot, captureDir)} is not a valid GitHub capture`);
+                }
+                validateArchiveSource(sourceRoot, captureDir);
+            }
+        }
+        const derivedDir = path.join(taskDir, 'derived');
+        if (fs.existsSync(derivedDir)) {
+            for (const view of fs.readdirSync(derivedDir, { withFileTypes: true })) {
+                const viewDir = path.join(derivedDir, view.name);
+                if (!view.isDirectory() || !fs.existsSync(path.join(viewDir, 'inputs.md'))) {
+                    invalidSource(`${sourceRelativePath(sourceRoot, viewDir)} requires inputs.md`);
+                }
+            }
+        }
+    }
     const previousPath = seenTaskIds.get(taskId);
     if (previousPath) {
         invalidSource(`duplicate task ID ${taskId} at ${previousPath} and ${sourceRelativePath(sourceRoot, taskDir)}`);
     }
     seenTaskIds.set(taskId, sourceRelativePath(sourceRoot, taskDir));
 }
+function validateArchiveSource(sourceRoot, sourceDir) {
+    const hashFile = path.join(sourceDir, 'contents.sha256');
+    const hashStat = sourcePathStat(sourceRoot, hashFile);
+    if (!hashStat?.isFile())
+        invalidSource(`${sourceRelativePath(sourceRoot, sourceDir)} requires contents.sha256`);
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const target = path.join(dir, entry.name);
+            if (entry.name === 'manifest.md')
+                invalidSource(`${sourceRelativePath(sourceRoot, target)} is forbidden inside a TASK`);
+            if (entry.isDirectory())
+                walk(target);
+            else if (entry.isFile() && target !== hashFile)
+                files.push(target);
+        }
+    };
+    walk(sourceDir);
+    const expected = files.sort((a, b) => Buffer.compare(Buffer.from(path.relative(sourceDir, a).split(path.sep).join('/')), Buffer.from(path.relative(sourceDir, b).split(path.sep).join('/'))))
+        .map((file) => `${crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')}  ${path.relative(sourceDir, file).split(path.sep).join('/')}`);
+    const actual = fs.readFileSync(hashFile, 'utf8').trimEnd().split(/\r?\n/).filter(Boolean);
+    if (JSON.stringify(expected) !== JSON.stringify(actual))
+        invalidSource(`${sourceRelativePath(sourceRoot, hashFile)} does not match local files`);
+}
 function validateMutableSection(sourceRoot, section, seenTaskIds) {
     const sectionDir = path.join(sourceRoot, section);
     const sectionStat = sourcePathStat(sourceRoot, sectionDir);
@@ -561,9 +614,6 @@ function validateArchiveSection(sourceRoot, seenTaskIds) {
             const monthDir = monthPath;
             for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
                 const dayPath = path.join(monthDir, dayEntry.name);
-                if (allowManifest(monthDir, dayEntry)) {
-                    continue;
-                }
                 const dayStat = sourcePathStat(sourceRoot, dayPath);
                 if (!dayStat?.isDirectory() || !/^\d{2}$/.test(dayEntry.name)) {
                     invalidSource(`${sourceRelativePath(sourceRoot, dayPath)} is not a DD directory or manifest.md`);
@@ -575,7 +625,7 @@ function validateArchiveSection(sourceRoot, seenTaskIds) {
                     if (!taskStat?.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
                         invalidSource(`${sourceRelativePath(sourceRoot, taskPath)} is not a TASK-YYYYMMDD-HHMMSS directory`);
                     }
-                    validateTaskDirectory(sourceRoot, taskPath, seenTaskIds);
+                    validateTaskDirectory(sourceRoot, taskPath, seenTaskIds, true);
                 }
             }
         }
@@ -716,9 +766,10 @@ function mergeArchiveSection(sourceArchive, localArchive, report) {
             });
             continue;
         }
+        const sourceTaskDir = path.dirname(task.taskDir);
         const destinationDir = path.join(localArchive, task.relativePath);
         fs.mkdirSync(path.dirname(destinationDir), { recursive: true });
-        fs.cpSync(task.taskDir, destinationDir, { recursive: true });
+        fs.cpSync(sourceTaskDir, destinationDir, { recursive: true });
         recordArchive(report, 'copied', {
             action: 'copied',
             symbol: '✓',
@@ -829,6 +880,7 @@ async function cmdMerge(args) {
     const report = createReport(resolvedSource, backupRootRelative);
     detectSourceMode(resolvedSource);
     validateSourceWorkspace(resolvedSource);
+    validateArchiveSection(workspaceDir, new Map());
     for (const section of ALL_SECTIONS) {
         fs.mkdirSync(path.join(workspaceDir, section), { recursive: true });
     }

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

@@ -921,26 +921,21 @@ function createGitHubOperations(client) {
             }
             const mergedPullRequests = collected.pullRequests.map((item) => ({
                 id: String(item.number), identity: { kind: 'number', value: Number(item.number) }, number: Number(item.number),
-                state: 'closed', title: String(item.title || ''), body: String(item.body || ''),
+                title: String(item.title || ''), body: String(item.body || ''),
                 mergedAt: new Date(String(item.mergedAt)).toISOString(), displayUrl: String(item.url || ''),
                 labels: Array.isArray(item.labels) ? item.labels.map((label) => String(label.name || label)) : [],
-                assignees: [], mergeCommitSha: null
+                author: item.author,
+                closingIssues: item.closingIssues.map((issue) => ({
+                    id: String(issue.number), identity: { kind: 'number', value: Number(issue.number) }, number: Number(issue.number),
+                    title: String(issue.title || ''), displayUrl: String(issue.url || ''), author: issue.author
+                }))
             }));
-            const closingIssues = collected.pullRequests.flatMap((item) => Array.isArray(item.closingIssuesReferences) ? item.closingIssuesReferences.map((issue) => ({
-                id: String(issue.number), identity: { kind: 'number', value: Number(issue.number) }, number: Number(issue.number),
-                state: 'closed', title: String(issue.title || ''), body: '', labels: Array.isArray(issue.labels) ? issue.labels.map((label) => String(label.name || label)) : [],
-                assignees: [], milestone: null, fields: {}, displayUrl: String(issue.url || '')
-            })) : []);
-            const actors = [...collected.authors.values()].flatMap((items) => items.map((item) => ({
-                ...(item.login ? { id: String(item.login) } : {}), ...(item.name ? { name: String(item.name) } : {})
-            })));
             return {
                 ok: true,
                 value: {
-                    history: commitOids.map((sha) => ({ sha, message: '', authoredAt: toTime, author: actors.find((actor) => actor.id) || null })),
+                    history: collected.history,
+                    commits: collected.commits,
                     mergedPullRequests,
-                    closingIssues,
-                    actors
                 }
             };
         }
@@ -1121,7 +1116,7 @@ function createGitHubOperations(client) {
 function createGitHubProvider(input, client = createGitHubClient()) {
     return {
         type: input.providerType,
-        contractVersion: 1,
+        contractVersion: 2,
         identity: { issue: 'number', 'pull-request': 'number', comment: 'number', release: 'key' },
         ...createGitHubOperations(client),
         context: {

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

@@ -9,12 +9,22 @@ function normalizeGitHubActor(actor) {
     const login = platformLogin || noReplyLogin;
     return {
         name,
-        email,
         login,
         bot: Boolean(login?.endsWith('[bot]')),
         resolution: platformLogin ? 'platform-user' : noReplyLogin ? 'platform-noreply' : 'unresolved'
     };
 }
+function normalizePlatformAuthor(author) {
+    if (!author)
+        return null;
+    const login = author.login?.trim().toLowerCase() || null;
+    return {
+        name: login || '',
+        login,
+        bot: Boolean(login?.endsWith('[bot]')),
+        resolution: login ? 'platform-user' : 'unresolved'
+    };
+}
 function failure(error) {
     return {
         status: error.retryable ? 'blocked' : 'failed',
@@ -66,31 +76,90 @@ function fetchGitHubReleaseNoteData(input, options = {}) {
             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 });
+    const prs = client.json(['pr', 'list', '--repo', input.repository, '--state', 'merged', '--base', input.branch, '--limit', '1000', '--json', 'number,title,body,url,mergedAt,labels,author'], { cwd: options.cwd });
     if (!prs.ok)
         return failure(prs.error);
     const authors = new Map();
+    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;
+    });
+    const eligiblePullRequestNumbers = new Set(pullRequests.map((item) => Number(item.number)));
+    const pullRequestNumbersByCommit = 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 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}} associatedPullRequests(first:100){nodes{number} 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;
+        const object = result.value.data?.repository?.object;
+        const connection = 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 associatedPullRequests = object?.associatedPullRequests;
+        if (!associatedPullRequests || !Array.isArray(associatedPullRequests.nodes) || !associatedPullRequests.pageInfo || typeof associatedPullRequests.pageInfo.hasNextPage !== 'boolean') {
+            return failure({ code: 'INVALID_PLATFORM_RESPONSE', message: `Associated pull request data is incomplete for commit ${oid}`, retryable: false });
+        }
+        if (associatedPullRequests.pageInfo.hasNextPage) {
+            return failure({ code: 'RELEASE_NOTES_ASSOCIATED_PULL_REQUESTS_TRUNCATED', message: `Associated pull requests exceeded the supported page size for ${oid}`, retryable: false });
+        }
+        const numbers = [];
+        for (const association of associatedPullRequests.nodes) {
+            if (typeof association?.number !== 'number' || !Number.isSafeInteger(association.number)) {
+                return failure({ code: 'INVALID_PLATFORM_RESPONSE', message: `Associated pull request identity is incomplete for commit ${oid}`, retryable: false });
+            }
+            if (eligiblePullRequestNumbers.has(association.number))
+                numbers.push(association.number);
+        }
+        pullRequestNumbersByCommit.set(oid, [...new Set(numbers)]);
     }
-    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 };
+    const resolvedPullRequests = [];
+    const [owner, name] = input.repository.split('/');
+    const closingIssuesQuery = 'query($owner:String!,$name:String!,$number:Int!,$cursor:String){repository(owner:$owner,name:$name){pullRequest(number:$number){closingIssuesReferences(first:100,after:$cursor){nodes{number title url author{login}} pageInfo{hasNextPage endCursor}}}}}';
+    for (const item of pullRequests) {
+        const closingIssues = [];
+        let cursor = null;
+        for (;;) {
+            const args = ['api', 'graphql', '-f', `query=${closingIssuesQuery}`, '-F', `owner=${owner}`, '-F', `name=${name}`, '-F', `number=${String(item.number)}`];
+            if (cursor)
+                args.push('-F', `cursor=${cursor}`);
+            const response = client.json(args, { cwd: options.cwd });
+            if (!response.ok)
+                return failure(response.error);
+            const connection = response.value.data?.repository?.pullRequest?.closingIssuesReferences;
+            if (!connection || !Array.isArray(connection.nodes) || !connection.pageInfo || typeof connection.pageInfo.hasNextPage !== 'boolean') {
+                return failure({ code: 'INVALID_PLATFORM_RESPONSE', message: `Closing Issue data is incomplete for pull request ${String(item.number)}`, retryable: false });
+            }
+            closingIssues.push(...connection.nodes.map((issue) => ({
+                number: Number(issue.number), title: String(issue.title || ''), url: String(issue.url || ''),
+                author: normalizePlatformAuthor(issue.author)
+            })));
+            if (!connection.pageInfo.hasNextPage)
+                break;
+            if (!connection.pageInfo.endCursor || connection.pageInfo.endCursor === cursor) {
+                return failure({ code: 'PAGINATION_INVALID', message: `Closing Issue pagination is incomplete for pull request ${String(item.number)}`, retryable: false });
+            }
+            cursor = connection.pageInfo.endCursor;
+        }
+        resolvedPullRequests.push({
+            ...item,
+            author: normalizePlatformAuthor(item.author || null),
+            closingIssues
+        });
+    }
+    const commits = input.commitOids.map((sha) => ({
+        sha,
+        url: `https://github.com/${input.repository}/commit/${sha}`,
+        pullRequestNumbers: pullRequestNumbersByCommit.get(sha) || [],
+        authors: authors.get(sha) || []
+    }));
+    return { status: 'no-op', changed: false, history, pullRequests: resolvedPullRequests, commits, error: null };
 }
 export { fetchGitHubReleaseNoteData, normalizeGitHubActor, publishGitHubReleaseNotes };
 //# sourceMappingURL=github-release-notes.js.map

package/dist/lib/platform/none-provider.js

@@ -1,7 +1,7 @@
 function createNoneProvider(input) {
     return {
         type: input.providerType,
-        contractVersion: 1,
+        contractVersion: 2,
         context: {
             async resolve() {
                 return {

package/dist/lib/platform/provider-contract.d.ts

@@ -242,22 +242,45 @@ type RepositoryMetadataSnapshot = {
         }>;
     }>;
 };
+type ReleaseNoteAuthor = {
+    name: string;
+    login: string | null;
+    bot: boolean;
+    resolution: 'platform-user' | 'platform-noreply' | 'unresolved';
+};
+type ReleaseNoteIssue = {
+    id: string;
+    identity: ResourceIdentity;
+    number: number;
+    title: string;
+    displayUrl: string;
+    author: ReleaseNoteAuthor | null;
+};
+type ReleaseNotePullRequest = {
+    id: string;
+    identity: ResourceIdentity;
+    number: number;
+    title: string;
+    body: string;
+    mergedAt: string;
+    displayUrl: string;
+    labels: string[];
+    author: ReleaseNoteAuthor | null;
+    closingIssues: ReleaseNoteIssue[];
+};
 type ReleaseNotesFacts = {
     history: Array<{
-        sha: string;
-        message: string;
-        authoredAt: string;
-        author: {
-            id?: string;
-            name?: string;
-        } | null;
+        tag: string;
+        body: string;
+        url: string | null;
     }>;
-    mergedPullRequests: Array<ChangeRequestSnapshot>;
-    closingIssues: Array<IssueSnapshot>;
-    actors: Array<{
-        id?: string;
-        name?: string;
+    commits: Array<{
+        sha: string;
+        url: string | null;
+        pullRequestNumbers: number[];
+        authors: ReleaseNoteAuthor[];
     }>;
+    mergedPullRequests: ReleaseNotePullRequest[];
 };
 type MilestoneReconciliation = {
     changed: boolean;
@@ -276,13 +299,13 @@ type VerificationRemoteFacts = {
 };
 type PlatformProviderFactoryInput = {
     providerType: string;
-    contractVersion: 1;
+    contractVersion: 2;
     repositoryRoot: string;
     config: Readonly<Record<string, JsonValue>>;
 };
 type PlatformProvider = {
     type: string;
-    contractVersion: 1;
+    contractVersion: 2;
     identity?: ProviderIdentityDeclaration;
     context: {
         resolve(input: {
@@ -548,8 +571,8 @@ type PlatformProvider = {
     };
 };
 type PlatformProviderFactory = (input: PlatformProviderFactoryInput) => Promise<PlatformProvider>;
-declare const PLATFORM_PROVIDER_CONTRACT_VERSION: 1;
+declare const PLATFORM_PROVIDER_CONTRACT_VERSION: 2;
 declare function isPlatformProviderFactory(value: unknown): value is PlatformProviderFactory;
 declare function validatePlatformProvider(value: unknown, providerType: string): ProviderResult<PlatformProvider>;
 export { PLATFORM_PROVIDER_CONTRACT_VERSION, isPlatformProviderFactory, validatePlatformProvider };
-export type { ChangeRequestSnapshot, CheckLogSnapshot, CheckRunSnapshot, GitEvidenceSnapshot, IssueSnapshot, JsonValue, MilestoneReconciliation, MilestoneDefinition, MilestoneInitialization, LabelDefinition, LabelReconciliation, MutationIdentity, MutationReceipt, PlatformCapabilities, PlatformContextSnapshot, PlatformError, PlatformProvider, PlatformProviderFactory, PlatformProviderFactoryInput, ProviderOperationContext, ProviderResult, ReleaseSnapshot, RemoteCommentSnapshot, RequiredCheckSnapshot, RepositoryMetadataSnapshot, ReleaseNotesFacts, ResourceIdentity, SecurityAlertKind, SecurityAlertSnapshot, ReviewSnapshot, VerificationRemoteFacts };
+export type { ChangeRequestSnapshot, CheckLogSnapshot, CheckRunSnapshot, GitEvidenceSnapshot, IssueSnapshot, JsonValue, MilestoneReconciliation, MilestoneDefinition, MilestoneInitialization, LabelDefinition, LabelReconciliation, MutationIdentity, MutationReceipt, PlatformCapabilities, PlatformContextSnapshot, PlatformError, PlatformProvider, PlatformProviderFactory, PlatformProviderFactoryInput, ProviderOperationContext, ProviderResult, ReleaseSnapshot, RemoteCommentSnapshot, RequiredCheckSnapshot, RepositoryMetadataSnapshot, ReleaseNotesFacts, ReleaseNoteAuthor, ReleaseNoteIssue, ReleaseNotePullRequest, ResourceIdentity, SecurityAlertKind, SecurityAlertSnapshot, ReviewSnapshot, VerificationRemoteFacts };

package/dist/lib/platform/provider-contract.js

@@ -1,4 +1,4 @@
-const PLATFORM_PROVIDER_CONTRACT_VERSION = 1;
+const PLATFORM_PROVIDER_CONTRACT_VERSION = 2;
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/lib/platform/provider-validation.js

@@ -78,6 +78,14 @@ function arrayValue(value, label) {
         throw new Error(`${label} must be an array`);
     return value;
 }
+function positiveNumberValue(value, label) {
+    if (!Number.isSafeInteger(value) || Number(value) <= 0)
+        throw new Error(`${label} must be a positive integer`);
+    return Number(value);
+}
+function stringArray(value, label) {
+    return arrayValue(value, label).map((entry, index) => stringValue(entry, `${label}[${index}]`));
+}
 function stableUnique(values, key, label) {
     const seen = new Set();
     for (const value of values) {
@@ -88,6 +96,16 @@ function stableUnique(values, key, label) {
     }
     return [...values].sort((left, right) => key(left).localeCompare(key(right)));
 }
+function uniqueInOrder(values, key, label) {
+    const seen = new Set();
+    for (const value of values) {
+        const identityKey = key(value);
+        if (seen.has(identityKey))
+            throw new Error(`${label} contains duplicate identities`);
+        seen.add(identityKey);
+    }
+    return values;
+}
 function declaredIdentityKind(declaration, resourceKind) {
     const kind = declaration?.[resourceKind];
     return kind === 'id' || kind === 'number' || kind === 'key' ? kind : undefined;
@@ -358,21 +376,73 @@ function validateMetadata(value) {
 }
 function validateReleaseNotes(value, declaration) {
     const item = record(value, 'release notes');
-    exactKeys(item, ['history', 'mergedPullRequests', 'closingIssues', 'actors'], 'release notes');
+    exactKeys(item, ['history', 'commits', 'mergedPullRequests'], 'release notes');
+    const releaseAuthor = (raw, label) => {
+        if (raw === null)
+            return null;
+        const entry = record(raw, label);
+        exactKeys(entry, ['name', 'login', 'bot', 'resolution'], label);
+        if (typeof entry.bot !== 'boolean')
+            throw new Error(`${label}.bot must be boolean`);
+        if (!['platform-user', 'platform-noreply', 'unresolved'].includes(String(entry.resolution))) {
+            throw new Error(`${label}.resolution is invalid`);
+        }
+        return {
+            name: stringValue(entry.name, `${label}.name`, true),
+            login: nullableString(entry.login, `${label}.login`),
+            bot: entry.bot,
+            resolution: entry.resolution
+        };
+    };
+    const issue = (raw, label) => {
+        const entry = record(raw, label);
+        exactKeys(entry, ['id', 'identity', 'number', 'title', 'displayUrl', 'author'], label);
+        return {
+            id: stringValue(entry.id, `${label}.id`),
+            identity: identity(entry.identity, `${label}.identity`, declaredIdentityKind(declaration, 'issue')),
+            number: positiveNumberValue(entry.number, `${label}.number`),
+            title: stringValue(entry.title, `${label}.title`, true),
+            displayUrl: stringValue(entry.displayUrl, `${label}.displayUrl`, true),
+            author: releaseAuthor(entry.author, `${label}.author`)
+        };
+    };
     return {
-        history: stableUnique(arrayValue(item.history, 'release notes.history').map((raw) => {
+        history: uniqueInOrder(arrayValue(item.history, 'release notes.history').map((raw) => {
             const entry = record(raw, 'release notes.history[]');
-            exactKeys(entry, ['sha', 'message', 'authoredAt', 'author'], 'release notes.history[]');
-            return { sha: stringValue(entry.sha, 'history.sha'), message: stringValue(entry.message, 'history.message', true), authoredAt: utcTimestamp(entry.authoredAt, 'history.authoredAt'), author: author(entry.author, 'history.author') };
-        }), (entry) => entry.sha, 'release notes.history'),
-        mergedPullRequests: stableUnique(arrayValue(item.mergedPullRequests, 'release notes.mergedPullRequests').map((entry) => validateChangeRequest(entry, declaredIdentityKind(declaration, 'pull-request'), true)), (entry) => serializeResourceIdentity(entry.identity), 'release notes.mergedPullRequests'),
-        closingIssues: stableUnique(arrayValue(item.closingIssues, 'release notes.closingIssues').map((entry) => validateIssue(entry, declaredIdentityKind(declaration, 'issue'), true)), (entry) => serializeResourceIdentity(entry.identity), 'release notes.closingIssues'),
-        actors: stableUnique(arrayValue(item.actors, 'release notes.actors').map((entry) => {
-            const actor = author(entry, 'release notes.actor');
-            if (!actor)
-                throw new Error('release notes.actor must identify an actor');
-            return actor;
-        }), (entry) => entry.id || entry.name || '', 'release notes.actors')
+            exactKeys(entry, ['tag', 'body', 'url'], 'release notes.history[]');
+            return { tag: stringValue(entry.tag, 'history.tag'), body: stringValue(entry.body, 'history.body', true), url: nullableString(entry.url, 'history.url') };
+        }), (entry) => entry.tag, 'release notes.history'),
+        commits: stableUnique(arrayValue(item.commits, 'release notes.commits').map((raw) => {
+            const entry = record(raw, 'release notes.commits[]');
+            exactKeys(entry, ['sha', 'url', 'pullRequestNumbers', 'authors'], 'release notes.commits[]');
+            return {
+                sha: stringValue(entry.sha, 'commits.sha'),
+                url: nullableString(entry.url, 'commits.url'),
+                pullRequestNumbers: stableUnique(arrayValue(entry.pullRequestNumbers, 'commits.pullRequestNumbers').map((number) => positiveNumberValue(number, 'commits.pullRequestNumbers[]')), (number) => String(number), 'commits.pullRequestNumbers'),
+                authors: arrayValue(entry.authors, 'commits.authors').map((rawAuthor) => {
+                    const normalized = releaseAuthor(rawAuthor, 'commits.author');
+                    if (!normalized)
+                        throw new Error('commits.author must identify an author');
+                    return normalized;
+                })
+            };
+        }), (entry) => entry.sha, 'release notes.commits'),
+        mergedPullRequests: stableUnique(arrayValue(item.mergedPullRequests, 'release notes.mergedPullRequests').map((raw) => {
+            const entry = record(raw, 'release notes.mergedPullRequests[]');
+            exactKeys(entry, ['id', 'identity', 'number', 'title', 'body', 'mergedAt', 'displayUrl', 'labels', 'author', 'closingIssues'], 'release notes.mergedPullRequests[]');
+            return {
+                id: stringValue(entry.id, 'pullRequest.id'),
+                identity: identity(entry.identity, 'pullRequest.identity', declaredIdentityKind(declaration, 'pull-request')),
+                number: positiveNumberValue(entry.number, 'pullRequest.number'),
+                title: stringValue(entry.title, 'pullRequest.title', true),
+                body: stringValue(entry.body, 'pullRequest.body', true),
+                mergedAt: utcTimestamp(entry.mergedAt, 'pullRequest.mergedAt'),
+                displayUrl: stringValue(entry.displayUrl, 'pullRequest.displayUrl', true),
+                labels: stringArray(entry.labels, 'pullRequest.labels'),
+                author: releaseAuthor(entry.author, 'pullRequest.author'),
+                closingIssues: stableUnique(arrayValue(entry.closingIssues, 'pullRequest.closingIssues').map((entry) => issue(entry, 'pullRequest.closingIssues[]')), (entry) => serializeResourceIdentity(entry.identity), 'pullRequest.closingIssues')
+            };
+        }), (entry) => serializeResourceIdentity(entry.identity), 'release notes.mergedPullRequests')
     };
 }
 function utcTimestamp(value, label) {

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

@@ -154,16 +154,16 @@ async function releaseNoteContext(input, options = {}) {
         return { ...baseResult(platform.error.retryable ? 'blocked' : 'failed'), error: providerError(platform.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
     const commits = commitFacts.map((commit) => {
         const seen = new Set();
-        const authors = platform.value.history.filter((item) => item.sha === commit.oid).flatMap((item) => item.author ? [item.author] : [])
-            .concat(platform.value.actors)
+        const facts = platform.value.commits.find((item) => item.sha === commit.oid);
+        const authors = (facts?.authors || [])
             .filter((actor) => {
-            const key = actor.id || actor.name || '';
+            const key = actor.login || actor.name;
             if (seen.has(key))
                 return false;
             seen.add(key);
             return true;
         });
-        return { ...commit, authors };
+        return { ...commit, url: facts?.url || null, pullRequestNumbers: facts?.pullRequestNumbers || [], authors };
     });
     const pullRequests = platform.value.mergedPullRequests
         .map((item) => ({
@@ -174,14 +174,13 @@ async function releaseNoteContext(input, options = {}) {
         url: item.displayUrl || '',
         mergedAt: item.mergedAt || '',
         labels: item.labels || [],
-        author: item.author ? { login: item.author.name || item.author.id || '', bot: false } : null,
-        closingIssues: platform.value.closingIssues.filter((issue) => issue.id === item.id).map((issue) => ({
+        author: item.author,
+        closingIssues: item.closingIssues.map((issue) => ({
             number: issue.number || resourceIdentityNumber(issue.identity) || 0,
             ...(issue.identity ? { identity: issue.identity } : {}),
             title: issue.title,
             url: issue.displayUrl || '',
-            labels: issue.labels || [],
-            author: issue.author ? { login: issue.author.name || issue.author.id || '', bot: false } : null
+            author: issue.author
         }))
     }))
         .sort((left, right) => left.number - right.number);

package/dist/lib/sandbox/capture.js

@@ -154,7 +154,7 @@ export async function runInSandbox(request, options = {}) {
             allowRecreate: request.recreate,
             recreate: async () => {
                 const { create } = await import('./commands/create.js');
-                await create([request.taskRef, '--no-refresh']);
+                await create([request.taskRef, '--no-refresh'], { runProjectInitCommand: false });
             }
         })).container;
     }