@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/lib/internal/task-invalidation.ts

@@ -0,0 +1,39 @@
+import { reconcileTaskInvalidation } from '../task/invalidation-command.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
+
+const USAGE = 'Usage: agent-infra-internal task-invalidation <task-ref> reconcile [--max-targets <n>] [--dry-run]\n';
+
+function taskInvalidation(args: string[] = []): void {
+  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: number | undefined;
+  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 };

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,