@fitlab-ai/agent-infra 0.11.8 → 0.11.10

package/lib/platform/github-provider.ts

@@ -21,7 +21,7 @@ import type {
   MutationReceipt,
   MilestoneInitialization,
   PlatformContextSnapshot,
-  PlatformError,
+  ProviderError,
   ProviderOperationContext,
   PlatformProvider,
   PlatformProviderFactoryInput,
@@ -38,6 +38,33 @@ import type {
 } from './provider-contract.ts';
 import { resourceIdentityNumber, resourceIdentityString } from './resource-identity.ts';
 import { extractPullRequestFileNames, syncLabelDelta } from './in-label-sync.ts';
+import type { PlatformError } from './types.ts';
+
+function providerError(error: PlatformError | ProviderError): ProviderError {
+  return { code: error.code, message: error.message };
+}
+
+function publicProviderErrors(provider: PlatformProvider): PlatformProvider {
+  const sanitize = async (call: () => Promise<unknown>): Promise<unknown> => {
+    const result = await call();
+    if (!result || typeof result !== 'object' || (result as { ok?: unknown }).ok !== false) return result;
+    const envelope = result as { error?: PlatformError | ProviderError };
+    return envelope.error ? { ...(result as Record<string, unknown>), error: providerError(envelope.error) } : result;
+  };
+  const wrapped: PlatformProvider = { ...provider, context: { ...provider.context } };
+  wrapped.context.resolve = (input) => sanitize(() => provider.context.resolve(input)) as ReturnType<PlatformProvider['context']['resolve']>;
+  for (const groupName of ['issues', 'comments', 'changeRequests', 'checks', 'reviews', 'releases', 'securityAlerts', 'repositoryMetadata', 'verification'] as const) {
+    const group = provider[groupName];
+    if (!group) continue;
+    const target: Record<string, unknown> = { ...group };
+    for (const method of Object.keys(group)) {
+      const original = group[method as keyof typeof group] as (...args: never[]) => Promise<unknown>;
+      target[method] = (input: unknown) => sanitize(() => original(input as never));
+    }
+    (wrapped as unknown as Record<string, unknown>)[groupName] = target;
+  }
+  return wrapped;
+}
 
 const CURRENT_USER_QUERY = 'query { viewer { login } }';
 const ISSUE_TYPES_QUERY = `query($owner:String!){organization(login:$owner){issueTypes(first:20){nodes{id name pinnedFields{__typename ... on IssueFieldSingleSelect{id name options{id name}} ... on IssueFieldDate{id name} ... on IssueFieldText{id name} ... on IssueFieldNumber{id name}}}}}}`;
@@ -105,7 +132,6 @@ function resolveGitHubChangeRequestGitEvidence({
       error: {
         code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
         message: 'Pull request repository identity is inconsistent',
-        retryable: false
       }
     };
   }
@@ -127,7 +153,6 @@ function resolveGitHubChangeRequestGitEvidence({
       error: {
         code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
         message: 'Pull request Git refs are invalid',
-        retryable: false
       }
     };
   }
@@ -145,7 +170,6 @@ function resolveGitHubChangeRequestGitEvidence({
       error: {
         code: 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
         message: `No GitHub remote can provide evidence for ${repository}`,
-        retryable: false
       }
     };
   }
@@ -155,8 +179,8 @@ function resolveGitHubChangeRequestGitEvidence({
   };
 }
 
-function failure(error: { code: string; message: string; retryable: boolean }): ProviderResult<PlatformContextSnapshot> {
-  return { ok: false, error };
+function failure(error: PlatformError | ProviderError): ProviderResult<PlatformContextSnapshot> {
+  return { ok: false, error: providerError(error) };
 }
 
 function resolveContext(
@@ -170,19 +194,17 @@ function resolveContext(
     return failure({
       code: 'GH_CLI_VERSION_UNSUPPORTED',
       message: 'GitHub CLI ' + version.value + ' is unsupported; install gh >= ' + MINIMUM_GITHUB_CLI_VERSION,
-      retryable: false
     });
   }
   const remote = input.gitRemote || defaultGitRemote(cwd);
   if (!remote) {
-    return failure({ code: 'REMOTE_MISSING', message: 'Git origin remote is not configured', retryable: false });
+    return failure({ code: 'REMOTE_MISSING', message: 'Git origin remote is not configured' });
   }
   const ownerRepo = parseGitHubRemote(remote);
   if (!ownerRepo) {
     return failure({
       code: /github\.com/i.test(remote) ? 'REMOTE_INVALID' : 'PLATFORM_UNSUPPORTED',
       message: 'Unable to parse GitHub owner/repo from configured remote',
-      retryable: false
     });
   }
   const repository = client.json(['api', 'repos/' + ownerRepo], { cwd });
@@ -192,7 +214,6 @@ function resolveContext(
   if (!upstream) return failure({
     code: 'UPSTREAM_UNRESOLVED',
     message: 'Unable to resolve the upstream repository',
-    retryable: false
   });
   const user = client.json(['api', 'graphql', '-f', 'query=' + CURRENT_USER_QUERY], { cwd });
   if (!user.ok) return failure(user.error);
@@ -241,18 +262,18 @@ function repositoryHead(cwd: string): string {
 
 function verifyRemoteBranch(cwd: string, repositoryName: string, head: string):
   | { ok: true; value: string }
-  | { ok: false; error: { code: string; message: string; retryable: boolean } } {
+  | { ok: false; error: ProviderError } {
   const wanted = expectedHeadRepository(repositoryName, head);
   if (!wanted.ref || !/^[A-Za-z0-9._/-]+$/.test(wanted.ref)) return {
     ok: false,
-    error: { code: 'PR_HEAD_INVALID', message: 'Pull request head ref is invalid', retryable: false }
+    error: { code: 'PR_HEAD_INVALID', message: 'Pull request head ref is invalid' }
   };
   const remotes = configuredGitRemotes(cwd);
   const remote = remotes.find((item) => item.repository.toLowerCase() === wanted.repository.toLowerCase())
     ?? remotes.find((item) => item.name === 'origin');
   if (!remote) return {
     ok: false,
-    error: { code: 'PR_REMOTE_BRANCH_MISSING', message: `No configured remote can verify ${wanted.repository}:${wanted.ref}`, retryable: false }
+    error: { code: 'PR_REMOTE_BRANCH_MISSING', message: `No configured remote can verify ${wanted.repository}:${wanted.ref}` }
   };
   try {
     const output = execFileSync('git', ['ls-remote', '--refs', remote.name, `refs/heads/${wanted.ref}`], {
@@ -262,19 +283,19 @@ function verifyRemoteBranch(cwd: string, repositoryName: string, head: string):
     const sha = match?.split(/\s+/)[0] || null;
     if (!sha || !/^[a-f0-9]{40}$/i.test(sha)) return {
       ok: false,
-      error: { code: 'PR_REMOTE_BRANCH_MISSING', message: `Remote branch ${wanted.repository}:${wanted.ref} does not exist`, retryable: false }
+      error: { code: 'PR_REMOTE_BRANCH_MISSING', message: `Remote branch ${wanted.repository}:${wanted.ref} does not exist` }
     };
     return { ok: true, value: sha };
   } catch (error) {
     return {
       ok: false,
-      error: { code: 'PR_REMOTE_BRANCH_UNAVAILABLE', message: error instanceof Error ? error.message : String(error), retryable: true }
+      error: { code: 'PR_REMOTE_BRANCH_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) }
     };
   }
 }
 
 function invalid(code: string, message: string): ProviderResult<never> {
-  return { ok: false, error: { code, message, retryable: false } };
+  return { ok: false, error: { code, message } };
 }
 
 function changeRequestSnapshot(value: any): ChangeRequestSnapshot {
@@ -346,8 +367,8 @@ function createReceipt(remoteId: string): ProviderResult<MutationReceipt> {
   return { ok: true, value: { changed: true, remoteId } };
 }
 
-function partialFailure<T>(response: { ok: false; error: PlatformError }, value: T): ProviderResult<T> {
-  return { ok: false, error: response.error, value };
+function partialFailure<T>(response: { ok: false; error: PlatformError | ProviderError }, value: T): ProviderResult<T> {
+  return { ok: false, error: providerError(response.error), value };
 }
 
 function labelReconciliation(
@@ -390,8 +411,8 @@ function syncLabels(
         status: 'blocked' as const,
         changed: true,
         error: synced.error
-          ? { ...synced.error, code: 'IN_LABEL_SYNC_PARTIAL', message: `In-label synchronization is partial or unknown: ${synced.error.message}` }
-          : { code: 'IN_LABEL_SYNC_PARTIAL', message: 'In-label synchronization is partial or unknown', retryable: true }
+          ? { ...providerError(synced.error), code: 'IN_LABEL_SYNC_PARTIAL', message: `In-label synchronization is partial or unknown: ${synced.error.message}` }
+          : { code: 'IN_LABEL_SYNC_PARTIAL', message: 'In-label synchronization is partial or unknown' }
       };
       return synced;
     }
@@ -642,13 +663,13 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
       try {
         localHead = repositoryHead(context.workingDirectory);
       } catch (error) {
-        return { ok: false, error: { code: 'PR_LOCAL_HEAD_UNAVAILABLE', message: error instanceof Error ? error.message : String(error), retryable: false } };
+        return { ok: false, error: { code: 'PR_LOCAL_HEAD_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) } };
       }
       const remote = verifyRemoteBranch(context.workingDirectory, repository(context), head);
       if (!remote.ok) return remote;
       if (remote.value !== localHead) return {
         ok: false,
-        error: { code: 'PR_REMOTE_HEAD_MISMATCH', message: `Remote head ${remote.value} does not match local HEAD ${localHead}`, retryable: false }
+        error: { code: 'PR_REMOTE_HEAD_MISMATCH', message: `Remote head ${remote.value} does not match local HEAD ${localHead}` }
       };
       return { ok: true, value: { sha: localHead } };
     },
@@ -909,7 +930,7 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
       try {
         const tag = resourceIdentityString(release) || '';
         const result = module.publishGitHubReleaseNotes({ repository: repository(context), tag, title, notesFile }, { cwd: context.workingDirectory, client });
-        if (result.status === 'failed' || result.status === 'blocked') return { ok: false, error: result.error || { code: 'RELEASE_NOTES_PUBLISH_FAILED', message: 'Release notes publish failed', retryable: false } };
+        if (result.status === 'failed' || result.status === 'blocked') return { ok: false, error: result.error ? providerError(result.error) : { code: 'RELEASE_NOTES_PUBLISH_FAILED', message: 'Release notes publish failed' } };
         return { ok: true, value: { changed: result.changed, remoteId: tag } };
       } finally {
         fs.rmSync(temporaryRoot, { recursive: true, force: true });
@@ -921,7 +942,7 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
         repository: repository(context), commitOids, branch, historyLimit, fromTime, toTime
       }, { cwd: context.workingDirectory, client });
       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 } };
+        return { ok: false, error: collected.error ? providerError(collected.error) : { code: 'RELEASE_NOTES_COLLECTION_FAILED', message: 'Release notes could not be collected' } };
       }
       const mergedPullRequests = collected.pullRequests.map((item: any) => ({
         id: String(item.number), identity: { kind: 'number' as const, value: Number(item.number) }, number: Number(item.number),
@@ -1107,7 +1128,7 @@ function createGitHubProvider(
   input: PlatformProviderFactoryInput,
   client: GitHubClient = createGitHubClient()
 ): PlatformProvider {
-  return {
+  return publicProviderErrors({
     type: input.providerType,
     contractVersion: 2,
     identity: { issue: 'number', 'pull-request': 'number', comment: 'number', release: 'key' },
@@ -1117,7 +1138,7 @@ function createGitHubProvider(
         return resolveContext(client, contextInput);
       }
     }
-  };
+  });
 }
 
 export {

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

@@ -1,5 +1,6 @@
 import type { GitHubClient } from './github-client.ts';
 import { createGitHubClient } from './github-client.ts';
+import { providerErrorRetryable } from './provider-validation.ts';
 
 type GitHubActorInput = {
   name?: string | null;
@@ -43,13 +44,14 @@ function normalizePlatformAuthor(author: { login?: string | null } | null | unde
   };
 }
 
-function failure(error: { code: string; message: string; retryable: boolean }) {
+function failure(error: { code: string; message: string; retryable?: boolean }) {
+  const retryable = error.retryable ?? providerErrorRetryable(error.code);
   return {
-    status: error.retryable ? 'blocked' as const : 'failed' as const,
+    status: retryable ? 'blocked' as const : 'failed' as const,
     changed: false,
     operation: null,
     url: null,
-    error
+    error: { code: error.code, message: error.message }
   };
 }
 

package/lib/platform/in-label-sync.ts

@@ -1,5 +1,6 @@
 import { computeInLabels } from './metadata-labels.ts';
 import { createHash } from 'node:crypto';
+import { providerErrorRetryable } from './provider-validation.ts';
 import type { PlatformError } from './types.ts';
 
 type InLabelPlan = {
@@ -150,7 +151,7 @@ function syncLabelDelta(
   const delta = labelDelta(current, target, prefix);
   let changed = false;
   const failure = (error: PlatformError): LabelDeltaResult => {
-    if (changed || error.retryable) {
+    if (changed || error.retryable || providerErrorRetryable(error.code)) {
       return {
         status: 'blocked',
         changed,

package/lib/platform/issue-comments.ts

@@ -7,6 +7,7 @@ import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { coordinatePlatformWrite } from './operation-coordinator.ts';
 import { resolvePlatformProviderContext } from './context.ts';
 import type { PlatformClient } from './context.ts';
+import { providerErrorRetryable } from './provider-validation.ts';
 import { platformResult } from './types.ts';
 import type { PlatformOperation, PlatformResult } from './types.ts';
 import {
@@ -34,6 +35,10 @@ import {
 } from './comment-safety.ts';
 import type { FenceRange } from './comment-safety.ts';
 
+function isRetryable(error: { code: string; retryable?: boolean }): boolean {
+  return error.retryable ?? providerErrorRetryable(error.code);
+}
+
 type RemoteComment = {
   id: number | string;
   body: string;
@@ -578,7 +583,7 @@ async function syncPlatformCommentImpl(taskRef: string, options: SyncOptions): P
   const issue = resourceIdentityNumber(issueIdentityFromTask);
   const listed = await listedComments(loaded.value.provider, loaded.value, issueIdentityFromTask);
   if (!listed.ok) {
-    return platformResult(listed.error.retryable ? 'blocked' : 'failed', {
+    return platformResult(isRetryable(listed.error) ? 'blocked' : 'failed', {
       ...contextFields(context), resource: { kind: 'issue', number: issue }, error: listed.error
     });
   }
@@ -648,10 +653,10 @@ async function syncPlatformCommentImpl(taskRef: string, options: SyncOptions): P
         })
         : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
     if (!written.ok) {
-      if (!current && written.error.retryable) {
+      if (!current && isRetryable(written.error)) {
         // A provider owns reconciliation because only it knows how to address the resource.
       }
-      return platformResult(written.error.retryable ? 'blocked' : 'failed', {
+      return platformResult(isRetryable(written.error) ? 'blocked' : 'failed', {
         ...contextFields(context),
         resource: { kind: 'issue', number: issue },
         operations,
@@ -674,7 +679,7 @@ async function syncPlatformCommentImpl(taskRef: string, options: SyncOptions): P
         })
         : unsupportedProviderOperation(loaded.value.provider, 'comments.delete');
     if (!deleted.ok) {
-      return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
+      return platformResult(isRetryable(deleted.error) ? 'blocked' : 'failed', {
         ...contextFields(context),
         resource: { kind: 'issue', number: issue },
         operations,
@@ -686,7 +691,7 @@ async function syncPlatformCommentImpl(taskRef: string, options: SyncOptions): P
   if (options.kind === 'summary') {
     const refreshed = await listedComments(loaded.value.provider, loaded.value, issueIdentityFromTask);
     if (!refreshed.ok) {
-      return platformResult(refreshed.error.retryable ? 'blocked' : 'failed', {
+      return platformResult(isRetryable(refreshed.error) ? 'blocked' : 'failed', {
         ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: refreshed.error
       });
     }
@@ -714,7 +719,7 @@ async function syncPlatformCommentImpl(taskRef: string, options: SyncOptions): P
         })
         : unsupportedProviderOperation(loaded.value.provider, 'comments.delete');
       if (!deleted.ok) {
-        return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
+        return platformResult(isRetryable(deleted.error) ? 'blocked' : 'failed', {
           ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: deleted.error
         });
       }
@@ -725,7 +730,7 @@ async function syncPlatformCommentImpl(taskRef: string, options: SyncOptions): P
         })
         : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
       if (!written.ok) {
-        return platformResult(written.error.retryable ? 'blocked' : 'failed', {
+        return platformResult(isRetryable(written.error) ? 'blocked' : 'failed', {
           ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: written.error
         });
       }
@@ -736,7 +741,7 @@ async function syncPlatformCommentImpl(taskRef: string, options: SyncOptions): P
         const error = reconciled.ok
           ? { code: 'SUMMARY_POSITION_UNVERIFIED', message: 'Summary comment is not provably last among task-managed comments', retryable: true }
           : reconciled.error;
-        return platformResult(error.retryable ? 'blocked' : 'failed', {
+        return platformResult(isRetryable(error) ? 'blocked' : 'failed', {
           ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error
         });
       }
@@ -837,7 +842,7 @@ async function checkPlatformCommentOwner(taskRef: string, options: { cwd?: strin
         ? { ok: true as const, value: response.value.map((comment) => ({ id: comment.id, body: comment.body, user: comment.author?.name ? { login: comment.author.name } : undefined })) }
         : response)
       : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
-  if (!listed.ok) return platformResult(listed.error.retryable ? 'blocked' : 'failed', { ...contextFields(context), error: listed.error });
+  if (!listed.ok) return platformResult(isRetryable(listed.error) ? 'blocked' : 'failed', { ...contextFields(context), error: listed.error });
   const matches = findMarkerComments(listed.value, MARKERS.task(resolved.taskId));
   if (matches.length > 1) return platformResult('failed', { ...contextFields(context), error: { code: 'COMMENT_MARKER_CONFLICT', message: 'Multiple task comments use the registered marker', retryable: false } });
   const owner = matches[0]?.user?.login;

package/lib/platform/operation-coordinator.ts

@@ -48,7 +48,7 @@ async function coordinatePlatformWrite<T extends OperationResult>(input: Coordin
       excludeId: operationId
     });
   if (drained.status !== 'applied' && drained.status !== 'no-op') {
-    return input.block(drained.error ?? {
+    return input.block(drained.error ? { ...drained.error, retryable: true } : {
       code: 'PLATFORM_OPERATION_QUEUE_BLOCKED',
       message: 'A previous platform operation is still unresolved; the current write remains queued',
       retryable: true

package/lib/platform/pr-review.ts

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { coordinatePlatformWrite } from './operation-coordinator.ts';
 import { resolvePlatformProviderContext } from './context.ts';
 import type { PlatformClient } from './context.ts';
+import { providerErrorRetryable } from './provider-validation.ts';
 import { platformResult } from './types.ts';
 import type { PlatformOperation, PlatformResult } from './types.ts';
 import {
@@ -283,7 +284,7 @@ export async function publishPrReview(options: {
       })
       : unsupportedProviderOperation(loaded.value.provider, 'reviews.publish');
     if (!published.ok) {
-      if (published.error.retryable) {
+      if (published.error.retryable || providerErrorRetryable(published.error.code)) {
         const reconciled = await listPrReviews(options.prNumber, { cwd: options.cwd, client: options.client });
         const found = reconciled.reviews.find((review) => firstLine(review.body) === marker);
         if (found) return platformResult('applied', {

package/lib/platform/provider-bridge.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
 
 import type {
-  PlatformError,
+  ProviderError,
   ProviderOperationContext,
   PlatformProvider,
   ProviderResult,
@@ -15,6 +15,9 @@ import {
 } from './resource-identity.ts';
 import type { LoadedContext } from './context.ts';
 import type { PlatformResult } from './types.ts';
+import type { PlatformError } from './types.ts';
+import { providerErrorRetryable } from './provider-validation.ts';
+import type { NormalizedProviderResult } from './provider-validation.ts';
 
 function providerOperationContext(
   loaded: LoadedContext,
@@ -29,30 +32,28 @@ function providerOperationContext(
   };
 }
 
-function providerError(error: PlatformError, fallbackCode: string): PlatformError {
+function providerError(error: ProviderError | PlatformError, fallbackCode: string): PlatformError {
   return {
     code: error.code || fallbackCode,
     message: error.message || 'Platform provider operation failed',
-    retryable: error.retryable
+    retryable: 'retryable' in error ? error.retryable : providerErrorRetryable(error.code)
   };
 }
 
-function providerStatus(error: PlatformError): PlatformResult['status'] {
-  return error.retryable ? 'blocked' : 'failed';
+function providerStatus(error: ProviderError | PlatformError): PlatformResult['status'] {
+  return ('retryable' in error ? error.retryable : providerErrorRetryable(error.code)) ? 'blocked' : 'failed';
 }
 
 function unsupportedProviderOperation(
   provider: PlatformProvider,
   operation: string
-): ProviderResult<never> {
+): NormalizedProviderResult<never> {
   return {
     ok: false,
     error: {
       code: 'PLATFORM_CAPABILITY_UNSUPPORTED',
       message: `Platform '${provider.type}' does not provide ${operation}`,
-      retryable: false,
-      providerType: provider.type,
-      phase: 'operation'
+      retryable: false
     }
   };
 }

package/lib/platform/provider-contract.ts

@@ -12,17 +12,14 @@ type JsonValue =
   | JsonValue[]
   | { [key: string]: JsonValue };
 
-type PlatformError = {
+type ProviderError = {
   code: string;
   message: string;
-  retryable: boolean;
-  providerType?: string;
-  phase?: string;
 };
 
 type ProviderResult<T> =
   | { ok: true; value: T }
-  | { ok: false; error: PlatformError; value?: T };
+  | { ok: false; error: ProviderError; value?: T };
 
 type ProviderOperationContext = {
   repositoryRoot: string;
@@ -534,10 +531,7 @@ function validatePlatformProvider(
       ok: false,
       error: {
         code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
-        message: 'Provider must expose matching type, contractVersion, and context.resolve',
-        retryable: false,
-        providerType,
-        phase: 'provider-validation'
+        message: 'Provider must expose matching type, contractVersion, and context.resolve'
       }
     };
   }
@@ -550,10 +544,7 @@ function validatePlatformProvider(
         ok: false,
         error: {
           code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
-          message: 'Provider identity declaration is invalid',
-          retryable: false,
-          providerType,
-          phase: 'provider-validation'
+          message: 'Provider identity declaration is invalid'
         }
       };
     }
@@ -567,10 +558,7 @@ function validatePlatformProvider(
         ok: false,
         error: {
           code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
-          message: `Provider operation group ${groupName} is incomplete`,
-          retryable: false,
-          providerType,
-          phase: 'provider-validation'
+          message: `Provider operation group ${groupName} is incomplete`
         }
       };
     }
@@ -583,9 +571,6 @@ function validatePlatformProvider(
             error: {
               code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
               message: `Provider operation group ${groupName} requires an identity declaration for ${resourceKind}`,
-              retryable: false,
-              providerType,
-              phase: 'provider-validation'
             }
           };
         }
@@ -617,7 +602,7 @@ export type {
   MutationReceipt,
   PlatformCapabilities,
   PlatformContextSnapshot,
-  PlatformError,
+  ProviderError,
   PlatformProvider,
   PlatformProviderFactory,
   PlatformProviderFactoryInput,

package/lib/platform/provider-loader.ts

@@ -12,13 +12,14 @@ import {
 } from './provider-contract.ts';
 import type {
   JsonValue,
-  PlatformError,
   PlatformProvider,
   PlatformProviderFactoryInput
 } from './provider-contract.ts';
 import { createGitHubProvider } from './github-provider.ts';
 import { createNoneProvider } from './none-provider.ts';
 import { wrapProviderOperations } from './provider-validation.ts';
+import type { LoadedRuntimeProvider, RuntimePlatformProvider } from './provider-validation.ts';
+import type { PlatformError } from './types.ts';
 import type { PlatformClient } from './context.ts';
 
 type ProviderLoaderOptions = {
@@ -28,7 +29,7 @@ type ProviderLoaderOptions = {
 };
 
 type LoadedPlatformProvider = {
-  provider: PlatformProvider;
+  provider: LoadedRuntimeProvider;
   providerType: string;
   repositoryRoot: string;
   workingDirectory: string;
@@ -44,7 +45,7 @@ type ResolvedExternalSource = {
   importUrl: string;
 };
 
-const sessions = new Map<string, Promise<PlatformProvider>>();
+const sessions = new Map<string, Promise<LoadedRuntimeProvider>>();
 
 function findRepositoryRoot(cwd: string): string {
   try {
@@ -151,15 +152,15 @@ async function instantiateProvider(
   importUrl: string | null,
   config: Readonly<Record<string, JsonValue>>,
   client?: PlatformClient
-): Promise<PlatformProvider> {
+): Promise<LoadedRuntimeProvider> {
   const input: PlatformProviderFactoryInput = {
     providerType,
     contractVersion: PLATFORM_PROVIDER_CONTRACT_VERSION,
     repositoryRoot,
     config
   };
-  if (providerType === 'github') return createGitHubProvider(input, client as never);
-  if (providerType === 'none') return createNoneProvider(input);
+  if (providerType === 'github') return createGitHubProvider(input, client as never) as unknown as RuntimePlatformProvider;
+  if (providerType === 'none') return createNoneProvider(input) as unknown as RuntimePlatformProvider;
 
   let moduleValue: Record<string, unknown>;
   try {