@fitlab-ai/agent-infra 0.9.12 → 0.9.13

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

@@ -0,0 +1,60 @@
+import { reconcileTaskInvalidation } from '../task/invalidation-command.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+const USAGE = 'Usage: agent-infra-internal task-invalidation <task-ref> reconcile [--max-targets <n>] [--dry-run]\n';
+function taskInvalidation(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const taskRef = args[0];
+    if (!taskRef || args[1] !== 'reconcile') {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'INVALIDATION_PAYLOAD_INVALID', message: 'task ref and reconcile are required' } })}\n`);
+        process.stderr.write(USAGE);
+        process.exitCode = 1;
+        return;
+    }
+    let maxTargets;
+    let dryRun = false;
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        if (flag === '--dry-run') {
+            if (dryRun) {
+                process.exitCode = 1;
+                return;
+            }
+            dryRun = true;
+            continue;
+        }
+        if (flag !== '--max-targets') {
+            process.exitCode = 1;
+            return;
+        }
+        const value = Number(args[++index]);
+        if (!Number.isInteger(value) || value < 1 || maxTargets !== undefined) {
+            process.exitCode = 1;
+            return;
+        }
+        maxTargets = value;
+    }
+    const resolved = resolveTaskRef(taskRef);
+    if (!resolved.ok) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: resolved.code, message: resolved.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-invalidation.reconcile', () => reconcileTaskInvalidation(taskRef, { ...(maxTargets === undefined ? {} : { maxTargets }), dryRun }));
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (result.status === 'failed')
+            process.exitCode = 1;
+    }
+    catch (error) {
+        if (!(error instanceof TaskExecutionLockError))
+            throw error;
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
+        process.exitCode = 1;
+    }
+}
+export { taskInvalidation };
+//# sourceMappingURL=task-invalidation.js.map

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

@@ -4,11 +4,13 @@ import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewStage, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from '../task/ledger.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
-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 = {
     '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
     '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
     '--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']);
@@ -18,7 +20,7 @@ function usageFailure(message) {
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
-function taskLedger(args = []) {
+async function taskLedger(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -28,7 +30,7 @@ function taskLedger(args = []) {
         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;
     }
@@ -72,13 +74,14 @@ function taskLedger(args = []) {
         '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 = {
         '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]);
@@ -139,7 +142,7 @@ function taskLedger(args = []) {
     let result;
     let humanOverride = 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);
             if (current.status !== 'failed' || !values.overrideTicket)
                 return current;
@@ -147,7 +150,7 @@ function taskLedger(args = []) {
                 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/dist/lib/internal/task-lifecycle.js

@@ -11,7 +11,7 @@ function parseFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
 }
-function taskLifecycle(args = []) {
+async function taskLifecycle(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -49,7 +49,7 @@ function taskLifecycle(args = []) {
         }
         repoRoot = resolved.repoRoot;
     }
-    const result = dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), operation);
+    const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), operation);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;

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

@@ -28,7 +28,7 @@ function usageFailure(message) {
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
-function taskOverride(args = []) {
+async function taskOverride(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -79,10 +79,10 @@ function taskOverride(args = []) {
     let result;
     try {
         if (operation === 'diagnose') {
-            result = diagnoseHumanOverrideForTask(taskRef, values.failureId ? String(values.failureId) : undefined, values.target ? String(values.target) : undefined);
+            result = await diagnoseHumanOverrideForTask(taskRef, values.failureId ? String(values.failureId) : undefined, values.target ? String(values.target) : undefined);
         }
         else if (operation === 'issue') {
-            result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.issue', () => issueHumanOverride({
+            result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.issue', async () => issueHumanOverride({
                 taskRef,
                 failureId: String(values.failureId),
                 target: String(values.target),
@@ -99,7 +99,7 @@ function taskOverride(args = []) {
             }));
         }
         else {
-            result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.consume', () => consumeHumanOverride({
+            result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.consume', async () => consumeHumanOverride({
                 taskRef,
                 ticketId: String(values.ticketId),
                 failureId: String(values.failureId),

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

@@ -13,7 +13,7 @@ function failUsage(message) {
     process.stderr.write(USAGE);
     process.exitCode = 2;
 }
-function taskReview(args = []) {
+async function taskReview(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -86,7 +86,7 @@ function taskReview(args = []) {
     let result;
     let humanOverride = 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;
@@ -94,7 +94,7 @@ function taskReview(args = []) {
                 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/dist/lib/internal/task-verify.js

@@ -8,7 +8,7 @@ function fail(message) {
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
-function taskVerify(args = []) {
+async function taskVerify(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -64,8 +64,8 @@ function taskVerify(args = []) {
     let result;
     let humanOverride = 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) {
@@ -80,13 +80,13 @@ function taskVerify(args = []) {
                 : 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/dist/lib/internal/task-warning.js

@@ -13,7 +13,7 @@ function usageFailure(message) {
     process.stderr.write(USAGE);
     process.exitCode = 1;
 }
-function taskWarning(args = []) {
+async function taskWarning(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
@@ -85,7 +85,7 @@ function taskWarning(args = []) {
     let result;
     let humanOverride = 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);
             if (current.status !== 'failed' || !values.overrideTicket)
                 return current;
@@ -93,7 +93,7 @@ function taskWarning(args = []) {
                 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/dist/lib/platform/adapters.js

@@ -8,9 +8,7 @@ function getPlatformAdapter(type) {
     return type ? adapters.get(type) ?? null : null;
 }
 function registerPlatformCapabilities(type, capabilities) {
-    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 };
     adapters.set(type, { ...adapter, ...capabilities });
 }
 function hasPlatformCapability(type, capability) {

package/dist/lib/platform/change-request-git-evidence.js

@@ -2,7 +2,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { execFileSync, spawnSync } from "node:child_process";
-import { resolvePlatformChangeRequestGitEvidence } from "./adapters.js";
+import { resolvePlatformProviderContext } from './context.js';
+import { providerError, providerOperationContext, unsupportedProviderOperation } from './provider-bridge.js';
+import { isResourceIdentity } from './resource-identity.js';
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.js";
 const SHA_PATTERN = /^[0-9a-f]{40}$/i;
 const REVIEWED_HEAD_REF = "refs/agent-infra/reviewed-head";
@@ -37,18 +39,36 @@ function validMergeIdentity(lastReviewedCommit, pullRequest) {
     }
     return null;
 }
-function resolveMaterializedReviewedHeadRelation(input) {
+async function resolveMaterializedReviewedHeadRelation(input) {
     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', 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, 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");
+        return blocked(('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 (!source.value.remoteUrl.trim() ||
         source.value.remoteUrl.trimStart().startsWith("-") ||

package/dist/lib/platform/completion-backfill.js

@@ -9,6 +9,7 @@ import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.js'
 import { captureTaskWriteMetadata } from '../task/write.js';
 import { syncPlatformComment } from './issue-comments.js';
 import { platformResult } from './types.js';
+import { taskIssueIdentity } from './task-identities.js';
 function result(base, artifacts, warnings) {
     return { ...base, artifacts, warnings };
 }
@@ -29,7 +30,7 @@ function excludedPrReview(taskDir, message) {
         return null;
     }
 }
-function backfillCompletionComments(taskRef, options) {
+async function backfillCompletionComments(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return result(platformResult('failed', {
@@ -45,16 +46,16 @@ function backfillCompletionComments(taskRef, options) {
             }
         }), [], []);
     const initialContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    const issueNumber = Number(parseTaskFrontmatter(initialContent).issue_number);
-    if (!Number.isInteger(issueNumber) || issueNumber <= 0)
+    const issueIdentity = taskIssueIdentity(parseTaskFrontmatter(initialContent));
+    if (!issueIdentity)
         return result(platformResult('no-op', {
-            error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+            error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false }
         }), [], []);
     const artifacts = [];
     const operations = [];
     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/dist/lib/platform/context.js

@@ -1,148 +1,88 @@
-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.js';
-import { createGitHubClient, MINIMUM_GITHUB_CLI_VERSION } from './github-client.js';
+import { loadPlatformProvider } from './provider-loader.js';
+import { defaultGitRemote, parseGitHubRemote } from './github-provider.js';
 import { platformResult } from './types.js';
-const CURRENT_USER_QUERY = 'query { viewer { login } }';
-function findRepoRoot(cwd) {
-    try {
-        return execFileSync('git', ['rev-parse', '--show-toplevel'], {
-            cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-        }).trim();
-    }
-    catch {
-        return cwd;
-    }
-}
-function parseGitHubRemote(remote) {
-    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) {
-    try {
-        return execFileSync('git', ['remote', 'get-url', 'origin'], {
-            cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-        }).trim();
-    }
-    catch {
-        return null;
-    }
+function errorStatus(error) {
+    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 readPlatformType(repoRoot) {
-    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 failure(error, repo) {
-    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, error, repository = null) {
+    return platformResult(errorStatus(error), {
+        platform: { type: providerType || null, repository, currentUser: null },
+        error: { code: error.code, message: error.message, retryable: error.retryable }
     });
 }
-function resolveGitHubContext(options) {
-    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, snapshot) {
+    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;
-    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;
-    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;
-    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);
-    }
-});
-registerPlatformAdapter({
-    type: 'none',
-    resolveContext() {
-        return platformResult('no-op', {
-            platform: { type: 'none', repository: null, currentUser: null },
-            operations: [{ name: 'resolve', status: 'no-op', reasonCode: 'PLATFORM_DISABLED' }]
-        });
-    }
-});
-function resolvePlatformContext(options = {}) {
-    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 }
-        });
+async function resolvePlatformProviderContext(options = {}) {
+    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) };
     }
-    return adapter.resolveContext({ cwd, gitRemote: options.gitRemote, client: options.client });
+    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)
+        }
+    };
+}
+async function resolvePlatformContext(options = {}) {
+    const resolved = await resolvePlatformProviderContext(options);
+    return resolved.ok ? resolved.value.context : resolved.context;
 }
-export { parseGitHubRemote, resolvePlatformContext };
+export { defaultGitRemote, parseGitHubRemote, resolvePlatformContext, resolvePlatformProviderContext };
 //# sourceMappingURL=context.js.map

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

@@ -125,7 +125,7 @@ function createGitHubClient(options = {}) {
     const sleep = options.sleep || defaultSleep;
     function run(args, request = {}) {
         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);