@fitlab-ai/agent-infra 0.11.2 → 0.11.4

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,14 +23,10 @@ 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,
+  commitPreparedTaskFinalization,
   type TaskFinalizationRequest,
   type TaskFinalizationResult
 } from './finalization.ts';
@@ -39,12 +36,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 +537,6 @@ export type TaskControlExecutionContext =
       generation: string;
       manifestPath: string;
       requestId: string;
-      diagnosticLog?: OrchestrationDiagnosticLogger;
       controllerBinding?: TaskControlControllerBinding | null;
       lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
     }>;
@@ -631,7 +625,6 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
   generation: string;
   manifestPath: string;
   requestId: string;
-  diagnosticLog?: OrchestrationDiagnosticLogger;
   controllerBinding?: TaskControlControllerBinding | null;
   lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
 }>): TaskControlExecutionContext {
@@ -652,7 +645,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 +689,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 +713,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 +759,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 +793,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,
         });
@@ -856,7 +861,8 @@ export function dispatchTaskControlOperation(
   }
   if (operation.family === 'task-finalization') {
     operationTaskId(context, operation.request.taskRef);
-    return applyTaskFinalization(operation.request, {
+    const finalize = context.source === 'sandbox-executor' ? commitPreparedTaskFinalization : applyTaskFinalization;
+    return finalize(operation.request, {
       repoRoot: context.repoRoot,
       ...(context.source === 'sandbox-executor' ? {
         controlBinding: { generation: context.generation, requestId: context.requestId }
@@ -898,7 +904,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 +915,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 +926,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 +984,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 +1088,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/decision-intents.ts

@@ -17,6 +17,7 @@ import { extractSection, extractSubSection, findSectionHeading } from './section
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
 import { allowsManualOverride } from './guard-override.ts';
+import { consumeHumanDecisionReworkIntents, parseReworkIntentDocument, reworkIntentMutation } from './rework-intent.ts';
 
 type HumanDecisionRequest = {
   taskRef?: string;
@@ -177,6 +178,14 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
     kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
     body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
   });
+  try {
+    const parsedRework = parseReworkIntentDocument(content);
+    if (!parsedRework.ok) return failed('DECISION_DOCUMENT_INVALID', parsedRework.message, resolved.taskId, row.id);
+    const consumed = consumeHumanDecisionReworkIntents(parsedRework.intents, row.id, metadata.timestamp);
+    if (consumed.changed) mutations.push(reworkIntentMutation(content, consumed.intents));
+  } catch (error) {
+    return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, row.id);
+  }
   const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
     ...options,
     taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },

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/delivery.ts

@@ -4,8 +4,7 @@ import path from 'node:path';
 
 import { parseTaskFrontmatter } from './frontmatter.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
-import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead, validateBaseRef, validateRemote } from './delivery-target.ts';
-import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead, findAuthoritativeReviewCodeArtifact } from './review-fingerprint.ts';
+import { resolveDeliveryTarget, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 
@@ -47,40 +46,6 @@ function validateBranch(cwd: string, branch: string): boolean {
   return git(cwd, ['check-ref-format', `refs/heads/${branch}`]).status === 0;
 }
 
-function validateReviewTargetCompatibility(
-  repoRoot: string,
-  taskDir: string,
-  target: { remote: string; baseRef: string },
-  reviewedHead: string
-): { ok: true } | { ok: false; code: string; message: string } {
-  const artifact = findAuthoritativeReviewCodeArtifact(taskDir);
-  if (!artifact.ok || !artifact.path) return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'A current review-code artifact is required before delivery' };
-  let content: string;
-  try { content = fs.readFileSync(artifact.path, 'utf8'); }
-  catch (error) { return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: error instanceof Error ? error.message : String(error) }; }
-  const savedReviewedHead = extractReviewedHead(content) || extractReviewBaseline(content);
-  const savedTargetHead = extractReviewTargetHead(content);
-  const savedDiffBase = extractReviewDiffBase(content);
-  if (!savedReviewedHead || !savedTargetHead || !savedDiffBase) {
-    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: 'review-code must save reviewed head, target head, and diff base before delivery' };
-  }
-  if (savedReviewedHead !== reviewedHead) {
-    return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'review-code reviewed head does not match last_reviewed_commit' };
-  }
-  const saved = resolveDiffBase(repoRoot, reviewedHead, savedTargetHead);
-  if (!saved.ok || saved.diffBase !== savedDiffBase) {
-    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: saved.ok ? 'saved review diff base does not match saved target head' : saved.message };
-  }
-  const currentTarget = resolveTargetHead(repoRoot, target);
-  if (!currentTarget.ok) return { ok: false, code: currentTarget.code, message: currentTarget.message };
-  const current = resolveDiffBase(repoRoot, reviewedHead, currentTarget.head!);
-  if (!current.ok) return { ok: false, code: current.code, message: current.message };
-  if (current.diffBase !== savedDiffBase) {
-    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_CHANGED', message: 'current delivery target changed the reviewed diff base; re-run review-code' };
-  }
-  return { ok: true };
-}
-
 function failure(taskId: string | null, code: string, message: string, retryable = false, status: 'failed' | 'blocked' = retryable ? 'blocked' : 'failed'): TaskBranchDeliveryResult {
   return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
 }
@@ -115,10 +80,6 @@ function deliverUnlocked(
   const status = git(repoRoot, ['status', '--porcelain=v1']);
   if (status.status !== 0) return failure(taskId, 'DELIVERY_GIT_INSPECT_FAILED', status.stderr.trim() || 'Unable to inspect Git state');
   if (status.stdout.trim()) return failure(taskId, 'DELIVERY_WORKTREE_DIRTY', 'Working tree must be clean before branch delivery');
-  const reviewed = frontmatter.last_reviewed_commit ?? '';
-  if (reviewed !== localHead) return failure(taskId, 'DELIVERY_REVIEW_REQUIRED', 'Local HEAD must equal last_reviewed_commit before delivery');
-  const reviewTarget = validateReviewTargetCompatibility(repoRoot, taskDir, target.value, reviewed);
-  if (!reviewTarget.ok) return failure(taskId, reviewTarget.code, reviewTarget.message, reviewTarget.code.includes('UNAVAILABLE'), reviewTarget.code.includes('UNAVAILABLE') ? 'blocked' : 'failed');
   const ref = `refs/heads/${branch}`;
   const remoteOutput = git(repoRoot, ['ls-remote', '--refs', target.value.remote, ref]);
   if (remoteOutput.status !== 0) return failure(taskId, 'DELIVERY_REMOTE_UNAVAILABLE', remoteOutput.stderr.trim() || 'Unable to inspect the delivery remote', true);