@fitlab-ai/agent-infra 0.9.15 → 0.11.0

package/lib/task/orchestration.ts

@@ -11,6 +11,7 @@ import type { LedgerDocument } from './ledger.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import {
   activateDelegation,
+  abortActivatedDelegation,
   abortPreparedDelegation,
   completeDelegationStage,
   consumeDelegation,
@@ -59,6 +60,7 @@ import { hasOpenLifecycleExecution } from './activity-log.ts';
 import { invalidationBlocks } from './invalidation.ts';
 import type { InvalidationDocument } from './invalidation.ts';
 import type { LifecycleAction, LifecycleFacts } from './capabilities.ts';
+import { normalizeAgentToken } from '../agent-clients/tokens.ts';
 
 type OrchestrationStatus = 'running' | 'paused' | 'completed';
 type ModelPolicySource = Readonly<{
@@ -1444,6 +1446,68 @@ function recoverPreparedOrchestrationDelegation(
   }
 }
 
+function recoverActivatedOrchestrationDelegationUnderLock(
+  taskRef: string,
+  event: Readonly<{
+    receiptId: string;
+    stage: DelegationStage;
+    round: number;
+    artifact: string;
+    startedAgent: string;
+    childId: string;
+    stopRevision: number;
+    consumer: string;
+    consumedAt: string;
+  }>,
+  options: OrchestrationOptions = {}
+): OrchestrationResult {
+  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+  if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
+  const run = readRun(resolved.taskDir, options);
+  if (!run) return failed('ORCHESTRATION_RUN_MISSING', 'no orchestration run exists', resolved.taskId);
+  const matches = [
+    ...(run.pendingDelegation ? [run.pendingDelegation] : []),
+    ...run.receipts.filter((receipt) => receipt.id === event.receiptId)
+  ];
+  const receipt = matches.find((candidate) => candidate.id === event.receiptId);
+  if (!receipt) return failed('ORCHESTRATION_DELEGATION_MISSING', 'recovery receipt does not exist', resolved.taskId);
+  if (
+    receipt.taskId !== resolved.taskId
+    || receipt.stage !== event.stage
+    || receipt.round !== event.round
+    || receipt.artifact !== event.artifact
+    || receipt.childId !== event.childId
+    || normalizeAgentToken(event.startedAgent) !== normalizeAgentToken(receipt.client)
+  ) {
+    return failed('ORCHESTRATION_PROVENANCE_MISMATCH', 'recovery selector does not match the delegation receipt', resolved.taskId);
+  }
+  if (receipt.status === 'aborted' && run.pendingDelegation === null) {
+    return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
+  }
+  if (run.pendingDelegation?.id !== receipt.id || receipt.status !== 'activated') {
+    return failed('ORCHESTRATION_RECOVERY_UNSAFE', 'recovery requires one matching activated pending delegation', resolved.taskId);
+  }
+  if (run.receipts.some((candidate) => candidate.id === receipt.id)) {
+    return failed('ORCHESTRATION_RECEIPT_DUPLICATE', 'recovery receipt already exists in the completed receipt history', resolved.taskId);
+  }
+  const aborted = abortActivatedDelegation(receipt, {
+    childId: event.childId,
+    stopRevision: event.stopRevision,
+    consumer: event.consumer,
+    consumedAt: event.consumedAt
+  });
+  if (!aborted.ok) return failed(aborted.code, aborted.message, resolved.taskId);
+  const updated = withUpdatedRun(run, {
+    status: 'running',
+    pause: null,
+    nextStage: null,
+    pendingDelegation: null,
+    receipts: Object.freeze([...run.receipts, aborted.receipt])
+  }, options.now);
+  saveRun(resolved.taskDir, updated);
+  return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+}
+
 function completeOrchestrationStage(
   taskRef: string,
   event: Parameters<typeof completeDelegationStage>[1],
@@ -1598,6 +1662,7 @@ export {
   readRun,
   reconcileMatchingOrchestrationDelegation,
   recoverPreparedOrchestrationDelegation,
+  recoverActivatedOrchestrationDelegationUnderLock,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
   sealMatchingOrchestrationDelegationWithHostEvidence,

package/lib/task/pr-delivery-fact.ts

@@ -1,5 +1,4 @@
 import type { ResourceIdentity } from '../platform/resource-identity.ts';
-import { isLegacyCompatibilityEnabled, legacyCompatibilityError, VERSION } from '../version.ts';
 import {
   isResourceIdentity,
   parseResourceIdentity,
@@ -17,14 +16,6 @@ type PrDeliveryIdentity = {
   base: { repository: string; ref: string; sha: string };
 };
 
-type LegacyPrDeliveryIdentity = {
-  repository: string;
-  number: number;
-  nodeId: string;
-  url: string;
-  head: { repository: string; ref: string; sha: string };
-  base: { repository: string; ref: string; sha: string };
-};
 type CurrentPrDeliveryIdentityInput = {
   resource: ResourceIdentity;
   repository: string;
@@ -93,10 +84,6 @@ function timestamp(value: unknown, label: string): string {
   if (Number.isNaN(Date.parse(result))) throw factError(`${label} must be a valid timestamp`);
   return new Date(result).toISOString();
 }
-function positiveNumber(value: unknown, label: string): number {
-  if (!Number.isSafeInteger(value) || (value as number) <= 0) throw factError(`${label} must be a positive integer`);
-  return value as number;
-}
 function parseRef(value: unknown, label: string): { repository: string; ref: string; sha: string } {
   if (!isRecord(value)) throw factError(`${label} must be an object`);
   exactKeys(value, ['repository', 'ref', 'sha'], label);
@@ -115,35 +102,19 @@ function canonicalIdentity(value: unknown): PrDeliveryIdentity {
   };
 }
 
-function decodeLegacyIdentity(value: unknown): PrDeliveryIdentity {
-  if (!isRecord(value)) throw factError('legacy identity must be an object');
-  // TODO(compat): Remove the v1 identity decoder before the first stable v1.0.0 release.
-  exactKeys(value, ['repository', 'number', 'nodeId', 'url', 'head', 'base'], 'legacy identity');
-  const legacy = {
-    number: positiveNumber(value.number, 'legacy identity.number'),
-    repository: text(value.repository, 'identity.repository'),
-    nodeId: text(value.nodeId, 'legacy identity.nodeId'),
-    url: text(value.url, 'identity.url'),
-    head: parseRef(value.head, 'identity.head'),
-    base: parseRef(value.base, 'identity.base')
-  } satisfies LegacyPrDeliveryIdentity;
-  return {
-    resource: { kind: 'number', value: legacy.number },
-    repository: legacy.repository,
-    url: legacy.url,
-    head: legacy.head,
-    base: legacy.base
-  };
-}
-
 function provenanceForSource(source: PrDeliveryBindingSource): PrDeliveryProvenance { return source === 'created' ? 'create-post' : source === 'reused' ? 'reuse' : source; }
 
-function parseFact(value: unknown, runtimeVersion = VERSION): PrDeliveryFact {
+function legacyFactError(): PrDeliveryFactError {
+  return Object.assign(
+    new Error('PLATFORM_IDENTITY_LEGACY_UNSUPPORTED: v1 PR delivery fact is unsupported; use the previous tool version to view this task or migrate its fact to version 2 before using this version'),
+    { code: 'PLATFORM_IDENTITY_LEGACY_UNSUPPORTED' }
+  );
+}
+
+function parseFact(value: unknown): PrDeliveryFact {
   if (!isRecord(value)) throw factError('fact must be an object');
-  if ((value.version !== 1 && value.version !== 2) || typeof value.state !== 'string') throw factError('version or state is invalid');
-  if (value.version === 1 && !isLegacyCompatibilityEnabled(runtimeVersion)) {
-    throw legacyCompatibilityError('v1 PR delivery fact', runtimeVersion);
-  }
+  if (value.version === 1) throw legacyFactError();
+  if (value.version !== 2 || typeof value.state !== 'string') throw factError('version or state is invalid');
   if (value.state === 'unbound') {
     exactKeys(value, ['version', 'state', 'reason'], 'unbound fact');
     if (value.reason !== 'initial') throw factError('unbound reason is invalid');
@@ -155,24 +126,6 @@ function parseFact(value: unknown, runtimeVersion = VERSION): PrDeliveryFact {
     return { version: 2, state: 'skipped', reason: 'explicit', decidedAt: timestamp(value.decidedAt, 'skipped.decidedAt') };
   }
   if (value.state !== 'bound') throw factError('state is invalid');
-  if (value.version === 1) {
-    // TODO(compat): Remove this v1-to-v2 shape conversion before the first stable v1.0.0 release.
-    exactKeys(value, ['version', 'state', 'identity', 'binding', 'provenance'], 'legacy bound fact');
-    if (!isRecord(value.binding) || !isRecord(value.provenance)) throw factError('legacy binding or provenance is invalid');
-    exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueNumber', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'legacy binding');
-    const issueNumber = value.binding.issueNumber === null ? null : positiveNumber(value.binding.issueNumber, 'legacy binding.issueNumber');
-    return parseFact({
-      version: 2,
-      state: 'bound',
-      identity: decodeLegacyIdentity(value.identity),
-      binding: {
-        status: 'verified', source: value.binding.source, verifiedAt: timestamp(value.binding.verifiedAt, 'binding.verifiedAt'),
-        issueIdentity: issueNumber === null ? null : { kind: 'number', value: issueNumber }, remoteState: value.binding.remoteState,
-        mergedAt: value.binding.mergedAt === null ? null : timestamp(value.binding.mergedAt, 'binding.mergedAt'), mergeCommitSha: nullableText(value.binding.mergeCommitSha, 'binding.mergeCommitSha')
-      },
-      provenance: value.provenance
-    }, runtimeVersion);
-  }
   exactKeys(value, ['version', 'state', 'identity', 'binding', 'provenance'], 'bound fact');
   if (!isRecord(value.binding) || !isRecord(value.provenance)) throw factError('binding or provenance is invalid');
   exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueIdentity', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'binding');
@@ -195,19 +148,19 @@ function parseFact(value: unknown, runtimeVersion = VERSION): PrDeliveryFact {
   };
 }
 
-function decodePrDeliveryFact(value: unknown, runtimeVersion = VERSION): PrDeliveryFact {
+function decodePrDeliveryFact(value: unknown, _runtimeVersion?: string): PrDeliveryFact {
   if (typeof value === 'string') {
     let decoded: unknown;
     try { decoded = JSON.parse(value); }
     catch { throw factError('value is not valid JSON'); }
-    return parseFact(decoded, runtimeVersion);
+    return parseFact(decoded);
   }
-  return parseFact(value, runtimeVersion);
+  return parseFact(value);
 }
 function encodePrDeliveryFact(fact: PrDeliveryFact): string { return JSON.stringify(parseFact(fact)); }
-function readPrDeliveryFact(metadata: Record<string, unknown>, runtimeVersion = VERSION): PrDeliveryFactReadResult {
+function readPrDeliveryFact(metadata: Record<string, unknown>, _runtimeVersion?: string): PrDeliveryFactReadResult {
   if (!Object.hasOwn(metadata, PR_DELIVERY_FACT_KEY) || metadata[PR_DELIVERY_FACT_KEY] === '') return { status: 'missing', fact: null };
-  try { return { status: 'valid', fact: decodePrDeliveryFact(metadata[PR_DELIVERY_FACT_KEY], runtimeVersion) }; }
+  try { return { status: 'valid', fact: decodePrDeliveryFact(metadata[PR_DELIVERY_FACT_KEY]) }; }
   catch (error) { return { status: 'invalid', fact: null, error: asFactError(error) }; }
 }
 function buildUnboundFact(): PrDeliveryFact { return { version: 2, state: 'unbound', reason: 'initial' }; }

package/lib/task/recovery-warning.ts

@@ -0,0 +1,21 @@
+export type RecoveryWarning = Readonly<{ code: string; message: string; action: string }>;
+
+function warningText(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0 && value.trim() === value && !/[\r\n]/u.test(value);
+}
+
+export function isRecoveryWarning(value: unknown): value is RecoveryWarning {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const warning = value as Record<string, unknown>;
+  return Object.keys(warning).sort().join(',') === 'action,code,message'
+    && warningText(warning.code)
+    && warningText(warning.message)
+    && warningText(warning.action);
+}
+
+export function sameRecoveryWarning(left: unknown, right: unknown): boolean {
+  return isRecoveryWarning(left) && isRecoveryWarning(right)
+    && left.code === right.code
+    && left.message === right.message
+    && left.action === right.action;
+}

package/lib/task/review-command.ts

@@ -3,10 +3,11 @@ import type { ReviewFinalizationRequest } from './review-finalization.ts';
 export function parseReviewCommand(args: readonly string[]): ReviewFinalizationRequest & {
   overrideTicket?: string; overrideTarget?: string; overrideScope?: string;
 } {
-  if (!args[0] || args[1] !== 'finalize-summary') throw new Error('task ref and finalize-summary are required');
+  if (!args[0] || !['preflight', 'finalize-summary'].includes(args[1] ?? '')) throw new Error('task ref and a supported review operation are required');
   const values: Record<string, string | boolean> = {};
   const flags = {
     '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun',
+    '--recovery-id': 'recoveryId',
     '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
   } as const;
   for (let index = 2; index < args.length; index += 1) {