@fitlab-ai/agent-infra 0.9.12 → 0.9.13

package/lib/internal/task-ledger.ts

@@ -7,12 +7,14 @@ import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewSt
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 
-const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, stage-status\n`;
+const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, rework-intent-upsert, stage-status\n`;
 const FLAGS: Record<string, string> = {
   '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
   '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
-  '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation'
-  , '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+  '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation',
+  '--intent-id': 'intentId', '--finding-id': 'findingId', '--source-artifact': 'sourceArtifact',
+  '--source-sha256': 'sourceSha256', '--target': 'target',
+  '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 const NUMERIC = new Set(['ordinal', 'round']);
 const BOOLEAN = new Set(['needsImplementation']);
@@ -23,11 +25,11 @@ function usageFailure(message: string): void {
   process.exitCode = 1;
 }
 
-function taskLedger(args: string[] = []): void {
+async function taskLedger(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   const [taskRef, kind] = args;
   if (!taskRef || !kind) { usageFailure('task ref and intent are required'); return; }
-  if (!['finding-upsert', 'finding-respond', 'finding-review', 'decision-next-id', 'decision-upsert', 'stage-status'].includes(kind)) {
+  if (!['finding-upsert', 'finding-respond', 'finding-review', 'decision-next-id', 'decision-upsert', 'rework-intent-upsert', 'stage-status'].includes(kind)) {
     usageFailure(`unknown ledger intent '${kind}'`); return;
   }
   const values: Record<string, unknown> = { kind, taskRef };
@@ -55,13 +57,14 @@ function taskLedger(args: string[] = []): void {
     'finding-review': ['id', 'status', 'evidence'],
     'decision-next-id': [],
     'decision-upsert': ['id', 'stage', 'artifact'],
+    'rework-intent-upsert': ['intentId', 'findingId', 'sourceArtifact', 'sourceSha256', 'target'],
     'stage-status': ['stage']
   };
   const optional: Record<string, string[]> = {
     'finding-review': ['needsImplementation'],
     'decision-upsert': ['needsImplementation']
   };
-  const overrideFields = kind === 'stage-status' || kind === 'decision-next-id'
+  const overrideFields = kind === 'stage-status' || kind === 'decision-next-id' || kind === 'rework-intent-upsert'
     ? []
     : ['overrideTicket', 'overrideTarget', 'overrideScope'];
   const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind]!, ...(optional[kind] ?? []), ...overrideFields]);
@@ -106,11 +109,11 @@ function taskLedger(args: string[] = []): void {
   let result;
   let humanOverride: unknown = null;
   try {
-    result = withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, () => {
+    result = await withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, async () => {
       let current = applyLedgerIntent(values as LedgerIntent);
       if (current.status !== 'failed' || !values.overrideTicket) return current;
       if (!values.overrideTarget || !values.overrideScope) { usageFailure('override ticket requires target and scope'); return current; }
-      const consumed = consumeHumanOverride({
+      const consumed = await consumeHumanOverride({
         taskRef,
         ticketId: String(values.overrideTicket),
         failureId: failureId('ledger-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),

package/lib/internal/task-lifecycle.ts

@@ -21,7 +21,7 @@ function parseFailure(error: unknown): string {
   return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
 }
 
-function taskLifecycle(args: string[] = []): void {
+async function taskLifecycle(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
 
   let operation;
@@ -56,7 +56,7 @@ function taskLifecycle(args: string[] = []): void {
     repoRoot = resolved.repoRoot;
   }
 
-  const result = dispatchTaskControlOperation(
+  const result = await dispatchTaskControlOperation(
     createDirectHostExecutionContext({ repoRoot }),
     operation
   ) as TaskLifecycleResult & { humanOverride?: unknown };

package/lib/internal/task-override.ts

@@ -37,7 +37,7 @@ function usageFailure(message: string): void {
   process.exitCode = 1;
 }
 
-function taskOverride(args: string[] = []): void {
+async function taskOverride(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   const [taskRef, operation] = args;
   if (!taskRef || !operation || !['diagnose', 'issue', 'consume'].includes(operation)) {
@@ -76,17 +76,17 @@ function taskOverride(args: string[] = []): void {
   let result;
   try {
     if (operation === 'diagnose') {
-      result = diagnoseHumanOverrideForTask(
+      result = await diagnoseHumanOverrideForTask(
         taskRef,
         values.failureId ? String(values.failureId) : undefined,
         values.target ? String(values.target) : undefined
       );
     } else if (operation === 'issue') {
-      result = withTaskExecutionLock(
+      result = await withTaskExecutionLock(
         resolved.repoRoot,
         resolved.taskId,
         'task-override.issue',
-        () => issueHumanOverride({
+        async () => issueHumanOverride({
           taskRef,
           failureId: String(values.failureId),
           target: String(values.target),
@@ -103,11 +103,11 @@ function taskOverride(args: string[] = []): void {
         } satisfies HumanOverrideRequest)
       );
     } else {
-        result = withTaskExecutionLock(
+        result = await withTaskExecutionLock(
         resolved.repoRoot,
         resolved.taskId,
         'task-override.consume',
-        () => consumeHumanOverride({
+        async () => consumeHumanOverride({
           taskRef,
           ticketId: String(values.ticketId),
           failureId: String(values.failureId),

package/lib/internal/task-review.ts

@@ -16,7 +16,7 @@ function failUsage(message: string): void {
   process.exitCode = 2;
 }
 
-function taskReview(args: string[] = []): void {
+async function taskReview(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') {
     process.stdout.write(USAGE);
     return;
@@ -78,11 +78,11 @@ function taskReview(args: string[] = []): void {
   let result;
   let humanOverride: unknown = null;
   try {
-    result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', () => {
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', async () => {
       let current = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
       if (current.status !== 'failed' || !overrideTicket) return current;
       if (!overrideTarget || !overrideScope) { failUsage('override ticket requires target and scope'); return current; }
-      const consumed = consumeHumanOverride({
+      const consumed = await consumeHumanOverride({
         taskRef: args[0]!, ticketId: overrideTicket,
         failureId: failureId('review-finalization', current.error?.code ?? 'TASK_STATE_MISMATCH'),
         target: overrideTarget, scope: overrideScope

package/lib/internal/task-verify.ts

@@ -11,7 +11,7 @@ function fail(message: string): void {
   process.exitCode = 1;
 }
 
-function taskVerify(args: string[] = []): void {
+async function taskVerify(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   if (!args[0] || !args[1] || args[0].startsWith('--') || args[1].startsWith('--')) { fail('task ref and verification event are required'); return; }
   const taskRef = args[0];
@@ -41,8 +41,8 @@ function taskVerify(args: string[] = []): void {
   let result;
   let humanOverride: unknown = null;
   try {
-    result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-verify.${event}`, () => {
-      let current = verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) });
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-verify.${event}`, async () => {
+      let current = await verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) });
       if (current.status === 'pass' || !overrideTicket) return current;
       if (!overrideTarget || !overrideScope) { fail('override ticket requires target and scope'); return current; }
       const failureProducer = current.status === 'blocked' || current.status === 'fail'
@@ -53,13 +53,13 @@ function taskVerify(args: string[] = []): void {
         : current.status === 'fail'
           ? 'CHECK_FAILED'
           : current.error?.code ?? 'VERIFY_TASK_STATE_MISMATCH';
-      const consumed = consumeHumanOverride({
+      const consumed = await consumeHumanOverride({
         taskRef, ticketId: overrideTicket,
         failureId: failureId(failureProducer, failureCode),
         target: overrideTarget, scope: overrideScope
       }, {
-        effectExecutor: (capability) => {
-          const retried = verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) }, { manualOverride: capability });
+        effectExecutor: async (capability) => {
+          const retried = await verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) }, { manualOverride: capability });
           current = retried;
           return retried.status !== 'pass'
             ? { code: 'OVERRIDE_EFFECT_FAILED', message: `${retried.error?.code ?? 'VERIFY_FAILED'}: ${retried.error?.message ?? 'manual verification effect failed'}` }

package/lib/internal/task-warning.ts

@@ -17,7 +17,7 @@ function usageFailure(message: string): void {
   process.exitCode = 1;
 }
 
-function taskWarning(args: string[] = []): void {
+async function taskWarning(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   const [taskRef, kind] = args;
   if (!taskRef || !kind || !['add', 'set-status', 'list'].includes(kind)) { usageFailure('task ref and a valid intent are required'); return; }
@@ -54,11 +54,11 @@ function taskWarning(args: string[] = []): void {
   let result;
   let humanOverride: unknown = null;
   try {
-    result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, () => {
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, async () => {
       let current = applyWorkflowWarningIntent(values as WorkflowWarningIntent);
       if (current.status !== 'failed' || !values.overrideTicket) return current;
       if (!values.overrideTarget || !values.overrideScope) { usageFailure('override ticket requires target and scope'); return current; }
-      const consumed = consumeHumanOverride({
+      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)

package/lib/platform/adapters.ts

@@ -1,4 +1,5 @@
 import type { PlatformError, PlatformResult } from './types.ts';
+import type { ResourceIdentity } from './resource-identity.ts';
 
 type PlatformAdapterContext = {
   cwd: string;
@@ -28,6 +29,7 @@ type PlatformChangeRequestSnapshot = {
   assignees: string[];
   milestone: string | null;
   mergeability?: PlatformMergeability;
+  identity?: ResourceIdentity;
 };
 
 type PlatformCheckSnapshot = {
@@ -105,8 +107,7 @@ function registerPlatformCapabilities(
     'inspectChangeRequest' | 'inspectIssueClosingChangeRequests' | 'inspectRequiredChecks' | 'resolveChangeRequestGitEvidence'
   >
 ): void {
-  const adapter = adapters.get(type);
-  if (!adapter) throw new Error(`Platform adapter '${type}' must be registered before its capabilities`);
+  const adapter = adapters.get(type) ?? { type } as PlatformAdapter;
   adapters.set(type, { ...adapter, ...capabilities });
 }
 

package/lib/platform/change-request-git-evidence.ts

@@ -3,7 +3,13 @@ import os from "node:os";
 import path from "node:path";
 import { execFileSync, spawnSync } from "node:child_process";
 
-import { resolvePlatformChangeRequestGitEvidence } from "./adapters.ts";
+import { resolvePlatformProviderContext } from './context.ts';
+import {
+  providerError,
+  providerOperationContext,
+  unsupportedProviderOperation
+} from './provider-bridge.ts';
+import { isResourceIdentity } from './resource-identity.ts';
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.ts";
 import type { ReviewedHeadRelation } from "./merged-pr-equivalence.ts";
 import type { PullRequestSnapshot } from "./pull-requests.ts";
@@ -53,25 +59,46 @@ function validMergeIdentity(lastReviewedCommit: string, pullRequest: PullRequest
   return null;
 }
 
-function resolveMaterializedReviewedHeadRelation(input: {
+async function resolveMaterializedReviewedHeadRelation(input: {
   cwd: string;
   platformType: string | null;
   lastReviewedCommit: string;
   pullRequest: PullRequestSnapshot;
-}): ReviewedHeadRelation {
+}): Promise<ReviewedHeadRelation> {
   const identityFailure = validMergeIdentity(input.lastReviewedCommit, input.pullRequest);
   if (identityFailure) return identityFailure;
 
-  const source = resolvePlatformChangeRequestGitEvidence(input.platformType, {
+  const loaded = await resolvePlatformProviderContext({
     cwd: input.cwd,
-    repository: input.pullRequest.repository,
-    number: input.pullRequest.number,
-    pullRequest: input.pullRequest
+    platformType: input.platformType || undefined
   });
+  if (!loaded.ok) {
+    return blocked(
+      loaded.context.error?.code || 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE',
+      loaded.context.error?.message || 'Unable to resolve the configured platform provider'
+    );
+  }
+  const target = isResourceIdentity(input.pullRequest.identity)
+    ? input.pullRequest.identity
+    : { kind: 'number' as const, value: input.pullRequest.number };
+  const operation = loaded.value.provider.changeRequests?.resolveGitEvidence
+    ? await loaded.value.provider.changeRequests.resolveGitEvidence({
+      context: providerOperationContext(loaded.value),
+      target,
+      expected: {
+        baseSha: input.pullRequest.base.sha,
+        headSha: input.pullRequest.head.sha,
+        targetBranch: input.pullRequest.base.ref
+      }
+    })
+    : unsupportedProviderOperation(loaded.value.provider, 'changeRequests.resolveGitEvidence');
+  const source = operation.ok
+    ? operation
+    : { ok: false as const, error: providerError(operation.error, 'PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE') };
   if (!source.ok || !source.value) {
     return blocked(
-      source.error?.code || "PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE",
-      source.error?.message || "Unable to resolve authoritative PR Git evidence"
+      ('error' in source && source.error?.code) || "PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE",
+      ('error' in source && source.error?.message) || "Unable to resolve authoritative PR Git evidence"
     );
   }
   if (

package/lib/platform/completion-backfill.ts

@@ -9,11 +9,12 @@ import { getOpenWorkflowWarnings } from '../task/workflow-warnings.ts';
 import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.ts';
 import { captureTaskWriteMetadata } from '../task/write.ts';
 import { syncPlatformComment } from './issue-comments.ts';
-import type { GitHubClient } from './github-client.ts';
+import type { PlatformClient } from './context.ts';
 import { platformResult } from './types.ts';
 import type { PlatformOperation, PlatformResult } from './types.ts';
+import { taskIssueIdentity } from './task-identities.ts';
 
-type CompletionBackfillOptions = { agent: string; cwd?: string; client?: GitHubClient };
+type CompletionBackfillOptions = { agent: string; cwd?: string; client?: PlatformClient };
 type CompletionBackfillResult = PlatformResult & {
   artifacts: Array<{ artifact: string; status: PlatformResult['status'] }>;
   warnings: Array<{ id: string; status: string }>;
@@ -42,10 +43,10 @@ function excludedPrReview(taskDir: string, message: string): string | null {
   }
 }
 
-function backfillCompletionComments(
+async function backfillCompletionComments(
   taskRef: string,
   options: CompletionBackfillOptions
-): CompletionBackfillResult {
+): Promise<CompletionBackfillResult> {
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
   if (!resolved.ok) return result(platformResult('failed', {
     error: { code: resolved.code, message: resolved.message, retryable: false }
@@ -59,16 +60,16 @@ function backfillCompletionComments(
     }
   }), [], []);
   const initialContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
-  const issueNumber = Number(parseTaskFrontmatter(initialContent).issue_number);
-  if (!Number.isInteger(issueNumber) || issueNumber <= 0) return result(platformResult('no-op', {
-    error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+  const issueIdentity = taskIssueIdentity(parseTaskFrontmatter(initialContent));
+  if (!issueIdentity) return result(platformResult('no-op', {
+    error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false }
   }), [], []);
 
   const artifacts: CompletionBackfillResult['artifacts'] = [];
   const operations: PlatformOperation[] = [];
   let latest = platformResult('no-op', { error: null });
   for (const artifact of inventory.artifacts) {
-    latest = syncPlatformComment(resolved.taskId, {
+    latest = await syncPlatformComment(resolved.taskId, {
       kind: 'artifact',
       artifact: artifact.name,
       agent: options.agent,

package/lib/platform/context.ts

@@ -1,167 +1,130 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { execFileSync } from 'node:child_process';
 
-import semver from 'semver';
-
-import { getPlatformAdapter, registerPlatformAdapter } from './adapters.ts';
-import { createGitHubClient, MINIMUM_GITHUB_CLI_VERSION } from './github-client.ts';
-import type { GitHubClient } from './github-client.ts';
+import { loadPlatformProvider } from './provider-loader.ts';
+import { defaultGitRemote, parseGitHubRemote } from './github-provider.ts';
 import { platformResult } from './types.ts';
 import type { PlatformResult } from './types.ts';
+import type { PlatformProvider, PlatformContextSnapshot, PlatformError } from './provider-contract.ts';
+
+type PlatformClientResult<T> =
+  | { ok: true; value: T }
+  | { ok: false; error: { code: string; message: string; retryable: boolean } };
+type PlatformClient = {
+  version(options?: { cwd?: string }): unknown;
+  json<T = unknown>(args: string[], options?: { cwd?: string; method?: string; input?: string }): any;
+  text?<T = string>(args: string[], options?: { cwd?: string; method?: string; input?: string }): any;
+};
 
 type ContextOptions = {
   cwd?: string;
   gitRemote?: (cwd: string) => string | null;
-  client?: {
-    version(options?: Parameters<GitHubClient['version']>[0]): ReturnType<GitHubClient['version']>;
-    json(args: string[], options?: Parameters<GitHubClient['json']>[1]): ReturnType<GitHubClient['json']>;
-  };
+  client?: PlatformClient;
   platformType?: string;
 };
 
-const CURRENT_USER_QUERY = 'query { viewer { login } }';
-
-function findRepoRoot(cwd: string): string {
-  try {
-    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
-      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-  } catch {
-    return cwd;
-  }
-}
-
-function parseGitHubRemote(remote: string): string | null {
-  const trimmed = remote.trim().replace(/\.git$/, '');
-  const match = trimmed.match(/^(?:https?:\/\/github\.com\/|ssh:\/\/(?:git@)?github\.com\/|git@github\.com:)([^/\s]+\/[^/\s]+)$/i);
-  return match?.[1] || null;
-}
-
-function defaultGitRemote(cwd: string): string | null {
-  try {
-    return execFileSync('git', ['remote', 'get-url', 'origin'], {
-      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-  } catch {
-    return null;
-  }
-}
+type LoadedContext = {
+  provider: PlatformProvider;
+  providerType: string;
+  repositoryRoot: string;
+  workingDirectory: string;
+  sourceIdentity: string;
+  snapshot: PlatformContextSnapshot;
+  context: PlatformResult;
+};
 
-function readPlatformType(repoRoot: string): string | null {
-  try {
-    const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
-    return typeof config?.platform?.type === 'string' ? config.platform.type : null;
-  } catch {
-    return null;
-  }
+function errorStatus(error: PlatformError): PlatformResult['status'] {
+  if (error.retryable || error.code === 'AUTH_REQUIRED' || error.code === 'PLATFORM_DEPENDENCY_MISSING') return 'blocked';
+  if (error.code === 'REMOTE_MISSING' || error.code === 'PLATFORM_UNSUPPORTED') return 'no-op';
+  return 'failed';
 }
 
-function failure(error: { code: string; message: string; retryable: boolean }, repo: string | null): PlatformResult {
-  const blocked = error.retryable || error.code === 'AUTH_REQUIRED' || error.code === 'PLATFORM_DEPENDENCY_MISSING';
-  return platformResult(blocked ? 'blocked' : 'failed', {
-    platform: { type: 'github', repository: repo, currentUser: null }, error
+function contextError(
+  providerType: string,
+  error: PlatformError,
+  repository: string | null = null
+): PlatformResult {
+  return platformResult(errorStatus(error), {
+    platform: { type: providerType || null, repository, currentUser: null },
+    error: { code: error.code, message: error.message, retryable: error.retryable }
   });
 }
 
-function resolveGitHubContext(options: ContextOptions & { cwd: string }): PlatformResult {
-  const { cwd } = options;
-  const platform = 'github';
-  const client = options.client || createGitHubClient();
-  const version = client.version({ cwd });
-  if (!version.ok) return failure(version.error, null);
-  if (!semver.gte(version.value, MINIMUM_GITHUB_CLI_VERSION)) {
-    return failure({
-      code: 'GH_CLI_VERSION_UNSUPPORTED',
-      message: `GitHub CLI ${version.value} is unsupported; install gh >= ${MINIMUM_GITHUB_CLI_VERSION}`,
-      retryable: false
-    }, null);
-  }
-  const remote = (options.gitRemote || defaultGitRemote)(cwd);
-  if (!remote) {
+function contextFromSnapshot(
+  providerType: string,
+  snapshot: PlatformContextSnapshot
+): PlatformResult {
+  if (providerType === 'none') {
     return platformResult('no-op', {
-      platform: { type: platform, repository: null, currentUser: null },
-      error: { code: 'REMOTE_MISSING', message: 'Git origin remote is not configured', retryable: false }
-    });
-  }
-  const ownerRepo = parseGitHubRemote(remote);
-  if (!ownerRepo) {
-    const nonGitHub = !/github\.com/i.test(remote);
-    return platformResult(nonGitHub ? 'no-op' : 'failed', {
-      platform: { type: platform, repository: null, currentUser: null },
-      error: {
-        code: nonGitHub ? 'PLATFORM_UNSUPPORTED' : 'REMOTE_INVALID',
-        message: `Unable to parse GitHub owner/repo from '${remote}'`,
-        retryable: false
-      }
-    });
-  }
-
-  const repository = client.json(['api', `repos/${ownerRepo}`], { cwd });
-  if (!repository.ok) return failure(repository.error, null);
-  const repositoryValue = repository.value as { fork?: boolean; full_name?: string; parent?: { full_name?: string } } | null;
-  const upstream = repositoryValue?.fork ? repositoryValue.parent?.full_name : repositoryValue?.full_name;
-  if (!upstream) {
-    return platformResult('blocked', {
-      platform: { type: platform, repository: null, currentUser: null },
-      error: { code: 'UPSTREAM_UNRESOLVED', message: 'Unable to resolve the upstream repository', retryable: false }
+      platform: { type: 'none', repository: null, currentUser: null },
+      operations: [{ name: 'resolve', status: 'no-op', reasonCode: 'PLATFORM_DISABLED' }]
     });
   }
-  const user = client.json(['api', 'graphql', '-f', `query=${CURRENT_USER_QUERY}`], { cwd });
-  if (!user.ok) return failure(user.error, upstream);
-  const userValue = user.value as { data?: { viewer?: { login?: string } } } | null;
-  const currentUser = userValue?.data?.viewer?.login || null;
-  const permissions = client.json(['api', `repos/${upstream}`], { cwd });
-  if (!permissions.ok) return failure(permissions.error, upstream);
-  const permissionValue = permissions.value as { permissions?: Record<string, boolean> } | null;
-  const values = permissionValue?.permissions || {};
-  const capabilities = {
-    authenticated: Boolean(currentUser),
-    comment: Boolean(currentUser),
-    triage: Boolean(values.triage || values.push || values.admin),
-    push: Boolean(values.push || values.admin),
-    admin: Boolean(values.admin)
-  };
+  const capabilities = snapshot.capabilities;
   const status = Object.values(capabilities).every(Boolean) ? 'no-op' : 'degraded';
+  const repository = snapshot.scope.label || snapshot.scope.id || null;
   return platformResult(status, {
-    changed: false,
-    platform: { type: platform, repository: upstream, currentUser },
+    platform: {
+      type: snapshot.type || providerType,
+      repository,
+      currentUser: snapshot.currentUser?.name || snapshot.currentUser?.id || null
+    },
     resource: { kind: 'repository', number: null },
     capabilities,
     operations: [{ name: 'resolve', status: 'no-op', reasonCode: null }]
   });
 }
 
-registerPlatformAdapter({
-  type: 'github',
-  resolveContext(options) {
-    return resolveGitHubContext(options as ContextOptions & { cwd: string });
+async function resolvePlatformProviderContext(options: ContextOptions = {}): Promise<
+  { ok: true; value: LoadedContext } | { ok: false; context: PlatformResult }
+> {
+  const workingDirectory = path.resolve(options.cwd || process.cwd());
+  const loaded = await loadPlatformProvider({
+    cwd: workingDirectory,
+    platformType: options.platformType,
+    client: options.client
+  });
+  if (!loaded.ok) {
+    if (!loaded.error.providerType && options.platformType === undefined) {
+      return {
+        ok: false,
+        context: platformResult('no-op', {
+          platform: { type: null, repository: null, currentUser: null },
+          error: {
+            code: 'PLATFORM_UNSUPPORTED',
+            message: 'No platform provider is configured',
+            retryable: false
+          }
+        })
+      };
+    }
+    return { ok: false, context: contextError(loaded.error.providerType || options.platformType || '', loaded.error) };
   }
-});
 
-registerPlatformAdapter({
-  type: 'none',
-  resolveContext() {
-    return platformResult('no-op', {
-      platform: { type: 'none', repository: null, currentUser: null },
-      operations: [{ name: 'resolve', status: 'no-op', reasonCode: 'PLATFORM_DISABLED' }]
-    });
-  }
-});
+  const gitRemote = options.gitRemote ? options.gitRemote(workingDirectory) : null;
+  const resolved = await loaded.value.provider.context.resolve({
+    repositoryRoot: loaded.value.repositoryRoot,
+    workingDirectory,
+    scopeId: loaded.value.repositoryRoot,
+    gitRemote
+  });
+  if (!resolved.ok) return {
+    ok: false,
+    context: contextError(loaded.value.providerType, resolved.error)
+  };
+  return {
+    ok: true,
+    value: {
+      ...loaded.value,
+      snapshot: resolved.value,
+      context: contextFromSnapshot(loaded.value.providerType, resolved.value)
+    }
+  };
+}
 
-function resolvePlatformContext(options: ContextOptions = {}): PlatformResult {
-  const cwd = path.resolve(options.cwd || process.cwd());
-  const repoRoot = findRepoRoot(cwd);
-  const platform = options.platformType ?? readPlatformType(repoRoot);
-  const adapter = getPlatformAdapter(platform);
-  if (!adapter) {
-    return platformResult('no-op', {
-      platform: { type: platform, repository: null, currentUser: null },
-      error: { code: 'PLATFORM_UNSUPPORTED', message: `Platform '${platform || 'none'}' has no registered adapter`, retryable: false }
-    });
-  }
-  return adapter.resolveContext({ cwd, gitRemote: options.gitRemote, client: options.client });
+async function resolvePlatformContext(options: ContextOptions = {}): Promise<PlatformResult> {
+  const resolved = await resolvePlatformProviderContext(options);
+  return resolved.ok ? resolved.value.context : resolved.context;
 }
 
-export { parseGitHubRemote, resolvePlatformContext };
-export type { ContextOptions };
+export { defaultGitRemote, parseGitHubRemote, resolvePlatformContext, resolvePlatformProviderContext };
+export type { ContextOptions, LoadedContext, PlatformClient, PlatformClientResult };

package/lib/platform/github-client.ts

@@ -8,7 +8,7 @@ import type { PlatformError } from './types.ts';
 type RunResult = { status: number | null; stdout: string; stderr: string; error?: Error };
 type RunOptions = { cwd?: string; input?: string };
 type Runner = (args: string[], options: RunOptions) => RunResult;
-type RequestOptions = RunOptions & { method?: 'GET' | 'PATCH' | 'POST' | 'DELETE' };
+type RequestOptions = RunOptions & { method?: 'GET' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' };
 type ClientResult<T> = { ok: true; value: T } | { ok: false; error: PlatformError };
 type ResponseMetadata = {
   status: number;
@@ -158,7 +158,7 @@ function createGitHubClient(options: ClientOptions = {}): GitHubClient {
 
   function run(args: string[], request: RequestOptions = {}): ClientResult<string> {
     const method = request.method || 'GET';
-    const retryableMethod = method === 'GET' || method === 'PATCH';
+    const retryableMethod = method === 'GET' || method === 'PATCH' || method === 'PUT';
     let attempt = 0;
     while (true) {
       const result = runner(args, request);