@fitlab-ai/agent-infra 0.11.5 → 0.11.6

package/lib/platform/github-provider.ts

@@ -923,30 +923,23 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
       if (collected.status === 'failed' || collected.status === 'blocked' || !('pullRequests' in collected)) {
         return { ok: false, error: collected.error || { code: 'RELEASE_NOTES_COLLECTION_FAILED', message: 'Release notes could not be collected', retryable: false } };
       }
-      const mergedPullRequests = collected.pullRequests.map((item: any): ChangeRequestSnapshot => ({
-        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 || ''),
+      const mergedPullRequests = collected.pullRequests.map((item: any) => ({
+        id: String(item.number), identity: { kind: 'number' as const, value: Number(item.number) }, number: Number(item.number),
+        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: any) => String(label.name || label)) : [],
-        assignees: [], mergeCommitSha: null
-      }));
-      const closingIssues: IssueSnapshot[] = collected.pullRequests.flatMap((item: any) =>
-        Array.isArray(item.closingIssuesReferences) ? item.closingIssuesReferences.map((issue: any) => ({
+        author: item.author,
+        closingIssues: item.closingIssues.map((issue: any) => ({
           id: String(issue.number), identity: { kind: 'number', value: Number(issue.number) }, number: Number(issue.number),
-          state: 'closed' as const, title: String(issue.title || ''), body: '', labels: Array.isArray(issue.labels) ? issue.labels.map((label: any) => String(label.name || label)) : [],
-          assignees: [], milestone: null, fields: {}, displayUrl: String(issue.url || '')
-        })) : []
-      );
-      const actors = [...collected.authors.values()].flatMap((items) => items.map((item: any) => ({
-        ...(item.login ? { id: String(item.login) } : {}), ...(item.name ? { name: String(item.name) } : {})
-      })));
+          title: String(issue.title || ''), displayUrl: String(issue.url || ''), author: issue.author
+        }))
+      }));
       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
         }
       };
     }
@@ -1116,7 +1109,7 @@ function createGitHubProvider(
 ): PlatformProvider {
   return {
     type: input.providerType,
-    contractVersion: 1,
+    contractVersion: 2,
     identity: { issue: 'number', 'pull-request': 'number', comment: 'number', release: 'key' },
     ...createGitHubOperations(client),
     context: {

package/lib/platform/github-release-notes.ts

@@ -9,7 +9,6 @@ type GitHubActorInput = {
 
 type ReleaseNoteActor = {
   name: string;
-  email: string | null;
   login: string | null;
   bot: boolean;
   resolution: 'platform-user' | 'platform-noreply' | 'unresolved';
@@ -27,13 +26,23 @@ function normalizeGitHubActor(actor: GitHubActorInput): ReleaseNoteActor {
   const login = platformLogin || noReplyLogin;
   return {
     name,
-    email,
     login,
     bot: Boolean(login?.endsWith('[bot]')),
     resolution: platformLogin ? 'platform-user' : noReplyLogin ? 'platform-noreply' : 'unresolved'
   };
 }
 
+function normalizePlatformAuthor(author: { login?: string | null } | null | undefined): ReleaseNoteActor | null {
+  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: { code: string; message: string; retryable: boolean }) {
   return {
     status: error.retryable ? 'blocked' as const : 'failed' as const,
@@ -89,7 +98,7 @@ function fetchGitHubReleaseNoteData(
     { cwd: options.cwd }
   );
   if (!releases.ok) return failure(releases.error);
-  const history = [];
+  const history: Array<{ tag: string; body: string; url: string | null }> = [];
   for (const item of releases.value.filter((entry) => !entry.isDraft && !entry.isPrerelease).slice(0, input.historyLimit)) {
     const viewed = client.json<{ body?: string; url?: string }>(
       ['release', 'view', String(item.tagName), '--repo', input.repository, '--json', 'body,url'],
@@ -99,33 +108,99 @@ function fetchGitHubReleaseNoteData(
     history.push({ tag: String(item.tagName), body: String(viewed.value.body || ''), url: viewed.value.url || null });
   }
   const prs = client.json<Array<Record<string, unknown>>>(
-    ['pr', 'list', '--repo', input.repository, '--state', 'merged', '--base', input.branch, '--limit', '1000', '--json', 'number,title,body,url,mergedAt,labels,author,closingIssuesReferences'],
+    ['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<string, ReleaseNoteActor[]>();
+  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<string, number[]>();
   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<{
-      data?: { repository?: { object?: { authors?: { nodes?: GitHubActorInput[]; pageInfo?: { hasNextPage?: boolean } } } } };
+      data?: { repository?: { object?: {
+        authors?: { nodes?: GitHubActorInput[]; pageInfo?: { hasNextPage?: boolean } };
+        associatedPullRequests?: {
+          nodes?: Array<{ number?: number | null }>;
+          pageInfo?: { hasNextPage?: boolean };
+        };
+      } } };
     }>([
       '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: number[] = [];
+    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' as const, 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: string | null = 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<{
+        data?: { repository?: { pullRequest?: { closingIssuesReferences?: {
+          nodes?: Array<{ number?: number; title?: string; url?: string; author?: { login?: string | null } | null }>;
+          pageInfo?: { hasNextPage?: boolean; endCursor?: string | null };
+        } } } };
+      }>(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 as { login?: string | null } | null) || 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' as const, changed: false, history, pullRequests: resolvedPullRequests, commits, error: null };
 }
 
 export { fetchGitHubReleaseNoteData, normalizeGitHubActor, publishGitHubReleaseNotes };

package/lib/platform/none-provider.ts

@@ -8,7 +8,7 @@ import type {
 function createNoneProvider(input: PlatformProviderFactoryInput): PlatformProvider {
   return {
     type: input.providerType,
-    contractVersion: 1,
+    contractVersion: 2,
     context: {
       async resolve(): Promise<ProviderResult<PlatformContextSnapshot>> {
         return {

package/lib/platform/provider-contract.ts

@@ -221,16 +221,39 @@ 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;
-  }>;
-  mergedPullRequests: Array<ChangeRequestSnapshot>;
-  closingIssues: Array<IssueSnapshot>;
-  actors: Array<{ id?: string; name?: string }>;
+  history: Array<{ tag: string; body: string; url: string | null }>;
+  commits: Array<{ sha: string; url: string | null; pullRequestNumbers: number[]; authors: ReleaseNoteAuthor[] }>;
+  mergedPullRequests: ReleaseNotePullRequest[];
 };
 
 type MilestoneReconciliation = {
@@ -249,14 +272,14 @@ 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: {
@@ -466,7 +489,7 @@ type PlatformProviderFactory = (
   input: PlatformProviderFactoryInput
 ) => Promise<PlatformProvider>;
 
-const PLATFORM_PROVIDER_CONTRACT_VERSION = 1 as const;
+const PLATFORM_PROVIDER_CONTRACT_VERSION = 2 as const;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -605,6 +628,9 @@ export type {
   RequiredCheckSnapshot,
   RepositoryMetadataSnapshot,
   ReleaseNotesFacts,
+  ReleaseNoteAuthor,
+  ReleaseNoteIssue,
+  ReleaseNotePullRequest,
   ResourceIdentity,
   SecurityAlertKind,
   SecurityAlertSnapshot,

package/lib/platform/provider-validation.ts

@@ -16,6 +16,8 @@ import type {
   PlatformError,
   PlatformProvider,
   ProviderResult,
+  ReleaseNoteAuthor,
+  ReleaseNoteIssue,
   ReleaseNotesFacts,
   ReleaseSnapshot,
   RemoteCommentSnapshot,
@@ -109,6 +111,15 @@ function arrayValue(value: unknown, label: string): unknown[] {
   return value;
 }
 
+function positiveNumberValue(value: unknown, label: string): number {
+  if (!Number.isSafeInteger(value) || Number(value) <= 0) throw new Error(`${label} must be a positive integer`);
+  return Number(value);
+}
+
+function stringArray(value: unknown, label: string): string[] {
+  return arrayValue(value, label).map((entry, index) => stringValue(entry, `${label}[${index}]`));
+}
+
 function stableUnique<T>(values: T[], key: (value: T) => string, label: string): T[] {
   const seen = new Set<string>();
   for (const value of values) {
@@ -119,6 +130,16 @@ function stableUnique<T>(values: T[], key: (value: T) => string, label: string):
   return [...values].sort((left, right) => key(left).localeCompare(key(right)));
 }
 
+function uniqueInOrder<T>(values: T[], key: (value: T) => string, label: string): T[] {
+  const seen = new Set<string>();
+  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: ProviderIdentityDeclaration | undefined,
   resourceKind: 'issue' | 'pull-request' | 'comment' | 'release'
@@ -389,20 +410,70 @@ function validateMetadata(value: unknown): RepositoryMetadataSnapshot {
 
 function validateReleaseNotes(value: unknown, declaration?: ProviderIdentityDeclaration): ReleaseNotesFacts {
   const item = record(value, 'release notes');
-  exactKeys(item, ['history', 'mergedPullRequests', 'closingIssues', 'actors'], 'release notes');
+  exactKeys(item, ['history', 'commits', 'mergedPullRequests'], 'release notes');
+  const releaseAuthor = (raw: unknown, label: string): ReleaseNoteAuthor | null => {
+    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 as ReleaseNoteAuthor['resolution']
+    };
+  };
+  const issue = (raw: unknown, label: string): ReleaseNoteIssue => {
+    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')
   };
 }
 

package/lib/platform/release-notes.ts

@@ -7,6 +7,7 @@ import { resolvePlatformProviderContext } from './context.ts';
 import type { PlatformClient } from './context.ts';
 import { providerError, providerOperationContext, providerStatus, unsupportedProviderOperation } from './provider-bridge.ts';
 import { resourceIdentityNumber } from './resource-identity.ts';
+import type { ReleaseNoteAuthor } from './provider-contract.ts';
 import type { ResourceIdentity } from './resource-identity.ts';
 
 type ReleaseNoteOptions = {
@@ -15,10 +16,9 @@ type ReleaseNoteOptions = {
   client?: PlatformClient;
 };
 
-type ReleaseNoteActor = { id?: string; name?: string };
-type ReleaseNoteCommit = { oid: string; title: string; authors: ReleaseNoteActor[] };
-type ReleaseNoteIssue = { number: number; identity?: ResourceIdentity; title: string; url: string; labels: string[]; author: { login: string; bot: boolean } | null };
-type ReleaseNotePullRequest = { number: number; identity?: ResourceIdentity; title: string; body: string; url: string; mergedAt: string; labels: string[]; author: { login: string; bot: boolean } | null; closingIssues: ReleaseNoteIssue[] };
+type ReleaseNoteCommit = { oid: string; title: string; url: string | null; pullRequestNumbers: number[]; authors: ReleaseNoteAuthor[] };
+type ReleaseNoteIssue = { number: number; identity?: ResourceIdentity; title: string; url: string; author: ReleaseNoteAuthor | null };
+type ReleaseNotePullRequest = { number: number; identity?: ResourceIdentity; title: string; body: string; url: string; mergedAt: string; labels: string[]; author: ReleaseNoteAuthor | null; closingIssues: ReleaseNoteIssue[] };
 
 const unsupportedError = {
   code: 'PLATFORM_RELEASE_NOTES_UNSUPPORTED',
@@ -180,15 +180,15 @@ async function releaseNoteContext(
   if (!platform.ok) return { ...baseResult(platform.error.retryable ? 'blocked' : 'failed'), error: providerError(platform.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
   const commits = commitFacts.map((commit) => {
     const seen = new Set<string>();
-    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: ReleaseNotePullRequest[] = platform.value.mergedPullRequests
     .map((item) => ({
@@ -199,14 +199,13 @@ async function releaseNoteContext(
       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/lib/sandbox/capture.ts

@@ -219,7 +219,7 @@ export async function runInSandbox(
       allowRecreate: request.recreate,
       recreate: async () => {
         const { create } = await import('./commands/create.ts');
-        await create([request.taskRef, '--no-refresh']);
+        await create([request.taskRef, '--no-refresh'], { runProjectInitCommand: false });
       }
     })).container;
   } else if (!found.running) {

package/lib/sandbox/commands/create.ts

@@ -79,6 +79,7 @@ import {
   recoverSandboxControlReplacement,
   readSandboxControlManifest
 } from '../control/lifecycle.ts';
+import { atomicWriteJson } from '../control/state.ts';
 import { inspectSandboxControlContainer } from '../control/container-identity.ts';
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.ts';
 import { sandboxCoreBindMounts } from '../mounts.ts';
@@ -1008,7 +1009,27 @@ function readImageLabels(config: Pick<SandboxCreateConfig, 'imageName'> & Pick<S
   ]));
 }
 
-export async function create(args: string[]): Promise<void> {
+function readProjectInitCommandDigest(controlRoot: string): string | null {
+  const markerPath = path.join(controlRoot, 'project-init.json');
+  if (!fs.existsSync(markerPath)) return null;
+  try {
+    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8')) as { version?: unknown; commandSha256?: unknown };
+    return marker.version === 1 && typeof marker.commandSha256 === 'string' && /^[a-f0-9]{64}$/.test(marker.commandSha256)
+      ? marker.commandSha256
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeProjectInitCommandDigest(controlRoot: string, commandSha256: string): void {
+  atomicWriteJson(path.join(controlRoot, 'project-init.json'), { version: 1, commandSha256 });
+}
+
+export async function create(
+  args: string[],
+  { runProjectInitCommand = true }: { runProjectInitCommand?: boolean } = {}
+): Promise<void> {
   const { values, positionals } = parseArgs({
     args,
     allowPositionals: true,
@@ -1079,6 +1100,7 @@ export async function create(args: string[]): Promise<void> {
     identity: target.workspace
   });
   const worktree = worktreeCandidates.find((candidate) => fs.existsSync(candidate)) ?? worktreeCandidates[0] ?? '';
+  let worktreeCreated = false;
   const shareCommon = shareCommonDir(effectiveConfig);
   const shareBranch = shareBranchDir(effectiveConfig, branch);
   const preparedDockerfile = prepareDockerfile(effectiveConfig, capabilityPlan.image);
@@ -1203,6 +1225,7 @@ export async function create(args: string[]): Promise<void> {
               toEnginePath(engine, worktree),
               branch
             ]);
+            worktreeCreated = true;
           } else {
             message(`Creating branch '${branch}' from '${baseBranch}'...`);
             runEngineTaskCommand(engine, 'git', [
@@ -1215,6 +1238,7 @@ export async function create(args: string[]): Promise<void> {
               toEnginePath(engine, worktree),
               baseBranch
             ]);
+            worktreeCreated = true;
           }
 
           return `Worktree ready at ${worktree}`;
@@ -1272,6 +1296,7 @@ export async function create(args: string[]): Promise<void> {
           let replacementCutover: ReturnType<typeof beginSandboxControlReplacement> | null = null;
           try {
             const recoveryResult = await recoverSandboxControlReplacement(controlPaths.root, replacementLease);
+            const previousProjectInitCommandDigest = readProjectInitCommandDigest(controlPaths.root);
             const hadExistingControlRoot = hadControlRootBeforeAcquire || recoveryResult === 'restored';
             const previousManifest = fs.existsSync(controlPaths.manifestPath)
               ? readSandboxControlManifest(controlPaths.manifestPath)
@@ -1728,6 +1753,32 @@ export async function create(args: string[]): Promise<void> {
             );
           }
 
+          const initCommand = effectiveConfig.initCommand;
+          const initCommandDigest = initCommand === null ? null : createHash('sha256').update(initCommand).digest('hex');
+          const shouldRunProjectInitCommand = runProjectInitCommand
+            && initCommand !== null
+            && initCommandDigest !== null
+            && (worktreeCreated || previousProjectInitCommandDigest !== initCommandDigest);
+          let projectInitCompleted = !worktreeCreated
+            && initCommandDigest !== null
+            && previousProjectInitCommandDigest === initCommandDigest;
+
+          if (shouldRunProjectInitCommand && initCommand !== null) {
+            try {
+              runVerboseEngine(engine, 'docker', [
+                'exec', '--workdir', '/workspace', container, 'bash', '-lc', initCommand
+              ]);
+              projectInitCompleted = true;
+            } catch (error) {
+              throw new Error(
+                `Project initialization failed for '${branch}': ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+          if (projectInitCompleted && initCommandDigest !== null) {
+            writeProjectInitCommandDigest(controlPaths.root, initCommandDigest);
+          }
+
           replacementLease.release();
           replacementLeaseHeld = false;
           return 'Container started';

package/lib/sandbox/commands/enter.ts

@@ -169,7 +169,7 @@ export async function enter(args: string[]): Promise<number> {
     allowRecreate: parsed.recreate,
     recreate: async () => {
       const { create } = await import('./create.ts');
-      await create([target.requestedRef, '--no-refresh']);
+      await create([target.requestedRef, '--no-refresh'], { runProjectInitCommand: false });
     }
   });
   const container = ready.container;

package/lib/sandbox/commands/start.ts

@@ -86,7 +86,7 @@ export async function start(args: string[]): Promise<void> {
     forceRecreate: parsed.recreate,
     recreate: async () => {
       const { create } = await import('./create.ts');
-      await create([target.requestedRef, '--no-refresh']);
+      await create([target.requestedRef, '--no-refresh'], { runProjectInitCommand: false });
     }
   });
   const message = ready.path === 'healthy'