@fitlab-ai/agent-infra 0.11.2 → 0.11.3

package/lib/sandbox/control/task-view.ts

@@ -56,11 +56,10 @@ function receiptIdentity(value: unknown, generation: string, requestId?: string)
   const binding = receipt.controlBinding;
   if (!binding || typeof binding !== 'object' || Array.isArray(binding)) return null;
   const controlBinding = binding as Record<string, unknown>;
-  if (receipt.version !== 3 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
+  if (receipt.version !== 4 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
     || !Number.isSafeInteger(receipt.revision) || (receipt.revision as number) < 0
     || receipt.lifecycle !== 'done'
     || !['pending', 'done', 'skipped'].includes(String(receipt.summary))
-    || !['pending', 'done', 'skipped'].includes(String(receipt.postSummaryVerification))
     || controlBinding.generation !== generation
     || typeof controlBinding.requestId !== 'string'
     || !/^[a-f0-9-]{16,64}$/u.test(controlBinding.requestId)

package/lib/task/control-authority.ts

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
 import { isAgentClientId } from '../agent-clients/types.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
+import { getAgentClientAdapter } from '../agent-clients/registry.ts';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from './human-override.ts';
 import {
   activateMatchingOrchestrationDelegation,
@@ -22,12 +23,7 @@ import {
   sealOrchestrationDelegation,
   statusOrchestration
 } from './orchestration.ts';
-import type {
-  OrchestrationDiagnosticLogger,
-  OrchestrationOptions,
-  OrchestrationResult
-} from './orchestration.ts';
-import { prepareCodexOrchestrationDelegation } from './codex-orchestration.ts';
+import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
 import {
   applyTaskFinalization,
   type TaskFinalizationRequest,
@@ -39,12 +35,10 @@ import {
   type TaskLifecycleRequest,
   type TaskLifecycleResult
 } from './lifecycle.ts';
-import {
-  recoverStartedLifecycleUnderLock,
-  recoveryFailure,
-  type LifecycleRecoveryResult
-} from './lifecycle-recovery.ts';
-import type { LifecycleRecoveryRequest } from './lifecycle-recovery.ts';
+import type {
+  AgentClientLifecycleRecoveryRequest as LifecycleRecoveryRequest,
+  AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult
+} from '../agent-clients/adapter.ts';
 import { locateActivityLog } from './activity-log.ts';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
@@ -542,7 +536,6 @@ export type TaskControlExecutionContext =
       generation: string;
       manifestPath: string;
       requestId: string;
-      diagnosticLog?: OrchestrationDiagnosticLogger;
       controllerBinding?: TaskControlControllerBinding | null;
       lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
     }>;
@@ -631,7 +624,6 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
   generation: string;
   manifestPath: string;
   requestId: string;
-  diagnosticLog?: OrchestrationDiagnosticLogger;
   controllerBinding?: TaskControlControllerBinding | null;
   lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
 }>): TaskControlExecutionContext {
@@ -652,7 +644,6 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
     generation: params.generation,
     manifestPath: absolute('manifestPath', params.manifestPath),
     requestId: params.requestId,
-    ...(params.diagnosticLog === undefined ? {} : { diagnosticLog: params.diagnosticLog }),
     ...(params.controllerBinding === undefined ? {} : { controllerBinding: binding(params.controllerBinding) }),
     ...(params.lifecycleRecoveryAttestation === undefined ? {} : {
       lifecycleRecoveryAttestation: params.lifecycleRecoveryAttestation === null
@@ -697,11 +688,7 @@ function domainOptions(
 ): OrchestrationOptions {
   return {
     ...options,
-    repoRoot: context.repoRoot,
-    ...(context.source === 'sandbox-executor' && context.diagnosticLog !== undefined
-      ? { diagnosticLog: context.diagnosticLog }
-      : {}),
-    ...(context.source === 'sandbox-executor' ? { gitWorktreeRoot: context.worktreeRoot } : {})
+    repoRoot: context.repoRoot
   };
 }
 
@@ -725,7 +712,17 @@ async function applyLifecycleWithAuthority(
   }
   const execute = async (): Promise<(TaskLifecycleResult | LifecycleRecoveryResult) & { humanOverride?: unknown }> => {
     if (request.intent === 'recover-started') {
-      return recoverStartedLifecycleUnderLock(request as LifecycleRecoveryRequest, { repoRoot: context.repoRoot });
+      const adapter = isAgentClientId(request.agent)
+        ? getAgentClientAdapter(request.agent).orchestrationAdapter
+        : undefined;
+      if (!adapter?.recoverStarted) {
+        return {
+          status: 'no-op', changed: false, targetState: 'active',
+          requestRef: request.taskRef, intent: 'recover-started', taskId: null,
+          receiptId: null, childId: null, error: null
+        };
+      }
+      return adapter.recoverStarted(request as LifecycleRecoveryRequest, { repoRoot: context.repoRoot });
     }
     const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
     if (lifecycleResult.status !== 'failed' || !request.overrideTicket) return lifecycleResult;
@@ -761,7 +758,12 @@ async function applyLifecycleWithAuthority(
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;
     if (request.intent === 'recover-started') {
-      return recoveryFailure(request as LifecycleRecoveryRequest, 'owner-unknown', error.code, error.message);
+      return {
+        status: 'owner-unknown', changed: false, targetState: 'active',
+        requestRef: request.taskRef, intent: 'recover-started', taskId,
+        receiptId: null, childId: null,
+        error: { code: error.code, message: error.message }
+      };
     }
     return taskLifecycleFailure(request, { code: error.code, message: error.message }, taskId);
   }
@@ -790,8 +792,10 @@ function orchestration(
         requestedModel: input.requestedModel as string | undefined,
         requestedReasoningEffort: input.requestedReasoningEffort as string | undefined,
       };
-      if (prepareInput.client === 'codex') {
-        return prepareCodexOrchestrationDelegation(operation.taskRef, prepareInput, {
+      const prepareDelegation = getAgentClientAdapter(prepareInput.client)
+        .orchestrationAdapter?.prepareDelegation;
+      if (prepareDelegation) {
+        return prepareDelegation(operation.taskRef, prepareInput, {
           repoRoot: context.repoRoot,
           orchestrationOptions: options,
         });
@@ -898,7 +902,7 @@ function operationInvalid(message: string): never {
 
 const LIFECYCLE_FLAGS = new Set([
   '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-  '--stage', '--round', '--artifact', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
+  '--auto', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
 ]);
 
 const FINALIZATION_FLAGS = new Set(['--agent']);
@@ -909,7 +913,7 @@ const ORCHESTRATION_FLAGS = new Set([
   '--parent-id', '--before-fingerprint', '--stage', '--round', '--artifact', '--role',
   '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
   '--model-fallback-reason', '--reasoning-effort-fallback-reason', '--exit-code', '--after-fingerprint',
-  '--changed-paths', '--code', '--message', '--recoverable', '--git-worktree-root'
+  '--changed-paths', '--code', '--message', '--recoverable'
 ]);
 
 function parseValues(
@@ -920,7 +924,7 @@ function parseValues(
   const values: Record<string, string | boolean> = {};
   for (let index = start; index < args.length; index += 1) {
     const flag = args[index]!;
-    if (flag === '--dry-run') {
+    if (flag === '--dry-run' || flag === '--auto') {
       if (!flags.has(flag)) operationInvalid(`unknown option '${flag}'`);
       if (values[flag] !== undefined) operationInvalid(`duplicate option '${flag}'`);
       values[flag] = true;
@@ -978,28 +982,18 @@ export function parseTaskControlOperation(
       ...(value(values, '--override-scope') ? { overrideScope: value(values, '--override-scope') } : {}),
       ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
       ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
-      ...(value(values, '--stage') ? { stage: value(values, '--stage') } : {}),
-      ...(value(values, '--round') ? { round: Number(value(values, '--round')) } : {}),
-      ...(value(values, '--artifact') ? { artifact: value(values, '--artifact') } : {}),
+      ...(values['--auto'] === true ? { auto: true } : {}),
       ...(values['--dry-run'] === true ? { dryRun: true } : {})
     };
     if (intent === 'recover-started') {
-      const recoveryFlags = new Set(['--agent', '--stage', '--round', '--artifact', '--reason']);
+      const recoveryFlags = new Set(['--agent', '--auto']);
       for (const flag of Object.keys(values)) {
         if (!recoveryFlags.has(flag)) operationInvalid(`option '${flag}' is not supported for recover-started`);
       }
-      required(values, ['--stage', '--round', '--artifact', '--reason']);
-      const stage = value(values, '--stage');
-      if (!['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'].includes(stage ?? '')) {
-        operationInvalid('--stage must be a supported lifecycle stage');
-      }
-      const round = Number(value(values, '--round'));
-      if (!Number.isSafeInteger(round) || round < 1) operationInvalid('--round must be a positive integer');
-      if (value(values, '--reason')!.includes('\n') || value(values, '--reason')!.includes('\r')) {
-        operationInvalid('--reason must be a single line');
-      }
-    } else if (values['--stage'] !== undefined || values['--round'] !== undefined || values['--artifact'] !== undefined) {
-      operationInvalid('--stage, --round, and --artifact are only supported for recover-started');
+      if (values['--auto'] !== true) operationInvalid('--auto is required for recover-started');
+      return { family, request: input as unknown as TaskLifecycleControlRequest };
+    } else if (values['--auto'] !== undefined) {
+      operationInvalid('--auto is only supported for recover-started');
     }
     return { family, request: input as unknown as TaskLifecycleControlRequest };
   }
@@ -1092,8 +1086,5 @@ export function parseTaskControlOperation(
     if (recoverable !== 'true' && recoverable !== 'false') operationInvalid('--recoverable must be true or false');
     input.code = value(values, '--code'); input.message = value(values, '--message'); input.recoverable = recoverable === 'true';
   }
-  const options = value(values, '--git-worktree-root') === undefined
-    ? undefined
-    : { gitWorktreeRoot: value(values, '--git-worktree-root') };
-  return { family, taskRef, intent: parsedIntent, input, ...(options ? { options } : {}) };
+  return { family, taskRef, intent: parsedIntent, input };
 }

package/lib/task/control-recovery.ts

@@ -1,7 +1,4 @@
 import { createHash } from 'node:crypto';
-import { isCompletionEvidence } from './orchestration.ts';
-import { TASK_WORKFLOW_OPERATIONS } from './workflow-command.ts';
-import { sameRecoveryWarning } from './recovery-warning.ts';
 
 export type ControlRecoveryOutcome = 'not-executed' | 'in-progress' | 'success' | 'failure' | 'unknown' | 'rejected';
 
@@ -16,7 +13,7 @@ export function parseControlOutput(output: string | null): Record<string, unknow
 }
 
 export type ControlRecoveryOperation = Readonly<{
-  family: 'task-lifecycle' | 'task-finalization' | 'task-orchestration' | 'task-create' | 'codex-controller' | 'task-workflow';
+  family: 'task-lifecycle' | 'task-finalization' | 'task-create' | 'codex-controller';
   intent: string;
   class: string;
 }>;
@@ -55,21 +52,10 @@ export type ControlRecoveryDecision = Readonly<{
 }>;
 
 const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'] as const;
-const ORCHESTRATION_INTENTS = [
-  'begin-or-resume', 'route.read', 'route.clean-completion', 'status', 'prepare', 'dispatch',
-  'await-activation', 'recover-prepared', 'hook-start', 'hook-stop', 'advance', 'pause'
-] as const;
-
 export const SANDBOX_CONTROL_RECOVERY_OPERATIONS: readonly ControlRecoveryOperation[] = Object.freeze([
   ...LIFECYCLE_INTENTS.map((intent) => ({ family: 'task-lifecycle' as const, intent, class: 'lifecycle-mutation' })),
   { family: 'task-finalization', intent: 'complete', class: 'finalization' },
-  ...ORCHESTRATION_INTENTS.map((intent) => ({
-    family: 'task-orchestration' as const,
-    intent,
-    class: intent === 'route.clean-completion' ? 'route.clean-completion' : intent === 'route.read' || intent === 'status' ? 'read-only' : 'orchestration'
-  })),
   { family: 'task-create', intent: 'create', class: 'task-create' },
-  ...TASK_WORKFLOW_OPERATIONS.map((intent) => ({ family: 'task-workflow' as const, intent, class: intent === 'artifact-inspect' || intent === 'decision-next-id' ? 'read-only' : 'workflow' })),
   ...(['open', 'close', 'verify'] as const).map((intent) => ({ family: 'codex-controller' as const, intent, class: 'codex-controller' }))
 ]);
 
@@ -95,29 +81,7 @@ function domainEvidenceMatches(
 ): boolean {
   if (!domain) return false;
   if (domain.consistent !== true) return false;
-  if (operation.class === 'route.clean-completion') {
-    const completion = domain.completionEvidence as Record<string, unknown> | undefined;
-    const snapshot = domain.snapshot as Record<string, unknown> | undefined;
-    const lastReviewedCommit = domain.lastReviewedCommit;
-    return result.status === 'completed'
-      && domain.status === 'completed'
-      && domain.pendingDelegation === null
-      && isCompletionEvidence(completion)
-      && snapshot?.head === completion.head
-      && snapshot.headTree === completion.headTree
-      && snapshot.worktreeTree === completion.worktreeTree
-      && lastReviewedCommit === completion.lastReviewedCommit;
-  }
-  if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started') {
-    const retryRequired = domain.recoveryState === 'retry-required'
-      && sameRecoveryWarning(domain.warning, result.warning);
-    return result.targetState === 'active'
-      && ['applied', 'no-op'].includes(String(result.status))
-      && domain.recovery === true
-      && domain.targetState === 'active'
-      && (domain.recoveryState === 'released' || retryRequired);
-  }
-  if (operation.class === 'read-only') return result.changed === false && domain.snapshotValid === true;
+  if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started') return false;
   return true;
 }
 
@@ -167,11 +131,7 @@ export function classifySandboxControlRecovery(input: ControlRecoveryInput): Con
   return {
     outcome: 'success',
     responseReconstructable: true,
-    reasonCode: input.operation.class === 'route.clean-completion' && result.changed === false
-      ? 'RECOVERY_ROUTE_COMPLETION_NOOP'
-      : input.operation.intent === 'recover-started' && input.domain?.recoveryState === 'retry-required'
-        ? 'RECOVERY_RELEASE_RETRY_REQUIRED'
-      : 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
+    reasonCode: 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
   };
 }
 

package/lib/task/delegation-receipts.ts

@@ -248,7 +248,7 @@ function hasStatusBoundEvidence(receipt: DelegationReceipt): boolean {
       && host !== undefined
       && Number.isSafeInteger(host.stopRevision)
       && (host.stopRevision as number) > host.startRevision
-      && host.consumer === `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
+      && host.consumer === receipt.id
       && exactText(host.consumedAt);
   }
 
@@ -562,7 +562,7 @@ function abortActivatedDelegation(
     event.childId !== receipt.childId
     || !Number.isSafeInteger(event.stopRevision)
     || event.stopRevision <= receipt.hostEvidence.startRevision
-    || event.consumer !== `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
+    || event.consumer !== receipt.id
     || !exactText(event.consumedAt)
   ) {
     return fail('DELEGATION_RECOVERY_EVIDENCE_INVALID', 'recovery stop evidence does not match the activated delegation');

package/lib/task/finalization-artifacts.ts

@@ -15,9 +15,7 @@ const COMPLETION_BACKFILL_FAMILIES = [
   'plan',
   'review-plan',
   'code',
-  'review-code',
-  'manual-validation',
-  'validation-run'
+  'review-code'
 ] as const satisfies readonly ArtifactFamily[];
 
 type CompletionArtifactResult = {

package/lib/task/finalization-state.ts

@@ -6,7 +6,7 @@ export type TaskControlBindingEvidence = (taskId: string, binding: TaskControlBi
 export function taskFinalizationReceiptState(receipt: TaskFinalizationReceipt): 'pending' | 'unresolved' | 'complete' {
   if (receipt.lifecycle !== 'done' || receipt.taskComment === 'pending'
     || receipt.verification === 'pending' || receipt.summary === 'pending'
-    || receipt.postSummaryVerification === 'pending' || receipt.warningProjection !== 'done') return 'pending';
+    || receipt.warningProjection !== 'done') return 'pending';
   if (receipt.lastError !== null || receipt.warnings.some((warning) => warning.status === 'open')) return 'unresolved';
   return 'complete';
 }