@fitlab-ai/agent-infra 0.11.4 → 0.11.6

package/dist/lib/internal/task-warning.js

@@ -1,13 +1,11 @@
 import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.js';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-warning <task-ref> <add|set-status|list> [intent flags] [--dry-run]\n`;
 const FLAGS = {
     '--step': 'step', '--severity': 'severity', '--code': 'code', '--target': 'target',
-    '--message': 'message', '--action': 'action', '--id': 'id', '--status': 'status', '--resolution': 'resolution',
-    '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+    '--message': 'message', '--action': 'action', '--id': 'id', '--status': 'status', '--resolution': 'resolution'
 };
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'WARNING_PAYLOAD_INVALID', message } })}\n`);
@@ -66,9 +64,6 @@ async function taskWarning(args = []) {
     };
     const optional = kind === 'list' ? ['status'] : [];
     const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind], ...optional]);
-    allowed.add('overrideTicket');
-    allowed.add('overrideTarget');
-    allowed.add('overrideScope');
     const unexpected = Object.keys(values).find((key) => !allowed.has(key));
     const missing = required[kind].find((key) => values[key] === undefined);
     if (unexpected) {
@@ -79,43 +74,14 @@ async function taskWarning(args = []) {
         usageFailure(`${kind} requires '${missing}'`);
         return;
     }
-    const dryRunConflict = overrideDryRunConflict(values);
-    if (dryRunConflict) {
-        usageFailure(dryRunConflict.message);
-        return;
-    }
     const resolved = resolveTaskRef(taskRef);
     if (!resolved.ok) {
         usageFailure(resolved.message);
         return;
     }
     let result;
-    let humanOverride = null;
     try {
-        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, async () => {
-            let current = applyWorkflowWarningIntent(values);
-            if (current.status !== 'failed' || !values.overrideTicket)
-                return current;
-            if (!values.overrideTarget || !values.overrideScope) {
-                usageFailure('override ticket requires target and scope');
-                return current;
-            }
-            const consumed = await consumeHumanOverride({
-                taskRef, ticketId: String(values.overrideTicket),
-                failureId: failureId('workflow-warning', current.error?.code ?? 'TASK_STATE_MISMATCH'),
-                target: String(values.overrideTarget), scope: String(values.overrideScope)
-            }, {
-                effectExecutor: (capability) => {
-                    const retried = applyWorkflowWarningIntent(values, { manualOverride: capability });
-                    current = retried;
-                    return retried.status === 'failed' || retried.status === 'planned'
-                        ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no workflow warning effect was committed' : `${retried.error?.code ?? 'WARNING_FAILED'}: ${retried.error?.message ?? 'manual warning effect failed'}` }
-                        : null;
-                }
-            });
-            humanOverride = consumed;
-            return current;
-        });
+        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, async () => applyWorkflowWarningIntent(values));
     }
     catch (error) {
         if (!(error instanceof TaskExecutionLockError))
@@ -124,10 +90,8 @@ async function taskWarning(args = []) {
         process.exitCode = 1;
         return;
     }
-    process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-    const overrideFailed = Boolean(humanOverride && typeof humanOverride === 'object' &&
-        humanOverride.status === 'failed');
-    if (result.status === 'failed' || overrideFailed)
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
         process.exitCode = 1;
 }
 export { taskWarning };

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/pr-summary.js

@@ -2,13 +2,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { enumerateArtifacts } from '../task/artifacts.js';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
-import { renderHumanOverrideAudit } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { readPrDeliveryFact } from '../task/pr-delivery-fact.js';
 import { resolvePlatformProviderContext } from './context.js';
 import { normalizeCommentContent } from './issue-comments.js';
-import { CONTROL_MARKER_PATTERN, escapeHtmlText, sanitizeMarkdownDocument, splitDocumentPlaceholder } from './comment-safety.js';
+import { CONTROL_MARKER_PATTERN, sanitizeMarkdownDocument, splitDocumentPlaceholder } from './comment-safety.js';
 import { platformResult } from './types.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, resourceIdentityNumber, unsupportedProviderOperation } from './provider-bridge.js';
 import { resourceIdentityEquals } from './resource-identity.js';
@@ -18,23 +17,6 @@ import { readManualValidationCompletion } from '../task/manual-validation-comple
 function summaryMarker(taskId) {
     return `<!-- sync-pr:${taskId}:summary -->`;
 }
-function escapeSummaryAuditText(value) {
-    return escapeHtmlText(value).replace(/\r\n?/g, '\n');
-}
-function renderSummaryAuditLine(value) {
-    const safe = escapeSummaryAuditText(value);
-    const longestRun = Math.max(0, ...(safe.match(/`+/g) || []).map((run) => run.length));
-    const delimiter = '`'.repeat(longestRun + 1);
-    return `${delimiter} ${safe} ${delimiter}`;
-}
-function renderSafeHumanOverrideAudit(value) {
-    const normalized = value.trim().replace(/\r\n?/g, '\n');
-    if (!normalized)
-        return '';
-    const [heading, ...rows] = normalized.split('\n');
-    const safeHeading = heading === '## Human Override Audit' ? heading : renderSummaryAuditLine(heading || '');
-    return [safeHeading, ...rows.map((row) => row ? renderSummaryAuditLine(row) : '')].join('\n');
-}
 function isSafeSummaryEnvelope(value, taskId) {
     return value.includes(summaryMarker(taskId))
         && (value.match(/<!--\s*sync-pr:/gi) || []).length === 1
@@ -71,9 +53,8 @@ function warningResultForPrimary(primaryResult) {
 function platformError(error) {
     return { code: error.code, message: error.message, retryable: error.retryable ?? false };
 }
-function buildPullRequestSummary(taskId, body, headSha, humanOverrideAudit = '') {
-    const sections = [body.replace(/\s+$/, ''), renderSafeHumanOverrideAudit(humanOverrideAudit)].filter(Boolean).join('\n\n');
-    return normalizeCommentContent(`${summaryMarker(taskId)}\n<!-- last-commit: ${headSha} -->\n\n${sections}\n`);
+function buildPullRequestSummary(taskId, body, headSha) {
+    return normalizeCommentContent(`${summaryMarker(taskId)}\n<!-- last-commit: ${headSha} -->\n\n${body.replace(/\s+$/, '')}\n`);
 }
 function reconcileSummaryComment(comments, taskId, desired) {
     const marker = summaryMarker(taskId);
@@ -586,7 +567,7 @@ async function syncPullRequestSummary(taskRef, options) {
             const renderedBody = manual?.phase === 'final'
                 ? replaced.value.replace(MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, `<!-- manual-validation-receipt: transaction=${manual.transactionId}; receipt=${manual.receiptDigest}; evidence=${manualEvidenceDigest}; head=${manual.prHeadSha} -->`)
                 : replaced.value;
-            const desired = buildPullRequestSummary(resolved.taskId, renderedBody, initial.value.head.sha, renderHumanOverrideAudit(taskContent));
+            const desired = buildPullRequestSummary(resolved.taskId, renderedBody, initial.value.head.sha);
             if (!isSafeSummaryEnvelope(desired, resolved.taskId))
                 return fail('failed', context, {
                     code: 'PR_SUMMARY_RENDER_INVALID',

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);
 }