@fitlab-ai/agent-infra 0.11.1 → 0.11.3

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

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { parseArtifactName } from './artifact-name.js';
-import { validateCompletedArtifact, hasOpenArtifactRound, validateArtifactPublication } from './artifact-lifecycle.js';
+import { validateCompletedArtifact, validateArtifactPublication } from './artifact-lifecycle.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { finalizeReviewSummaryContent } from './review-artifacts.js';
 import { inspectDecisionDetailDuplicates } from './decision-details.js';
@@ -11,8 +13,6 @@ import { allowsManualOverride } from './guard-override.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
 import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.js';
-import { readArtifactRecoveryIntent } from './artifact-repair-intent.js';
-import { beginArtifactRecovery, commitArtifactRecovery, prepareArtifactRecoveryFinal, prepareArtifactRecoveryCommit, reconcileArtifactRecovery, recoveryContextFromIntent, stageArtifactCandidate } from './artifact-recovery.js';
 const STAGES = {
     analysis: { family: 'review-analysis' },
     plan: { family: 'review-plan' },
@@ -47,7 +47,7 @@ function preflightFailed(request, code, message, taskId = null, extra = {}) {
         stageStatus: null
     };
 }
-/** Validate and seal a review draft before any finding-ledger write. */
+/** Validate the current review draft before any finding-ledger write. */
 function preflightReviewSummaryUnlocked(request, options = {}) {
     const stage = request.stage;
     const spec = STAGES[stage];
@@ -68,37 +68,16 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
         return preflightFailed(request, 'REVIEW_ARTIFACT_IDENTITY_INVALID', publicationError.message, resolved.taskId);
     let taskContent;
     let content;
-    let recovery;
     try {
         taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
-        if (request.recoveryId) {
-            const intent = readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, spec.family, request.artifact);
-            if (!intent || intent.recoveryOperationId !== request.recoveryId)
-                return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', 'recovery id does not match the artifact journal', resolved.taskId);
-            if (!['awaiting-preflight-recovery', 'preflight-ready'].includes(intent.state))
-                return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', `recovery journal is in '${intent.state}' state`, resolved.taskId);
-            recovery = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, intent);
-            content = fs.existsSync(recovery.stagingPath)
-                ? fs.readFileSync(recovery.stagingPath, 'utf8')
-                : fs.readFileSync(recovery.formalPath, 'utf8');
-        }
-        else {
-            const validated = validateCompletedArtifact(resolved.taskDir, spec.family, request.artifact);
-            if (!validated.ok)
-                return preflightFailed(request, validated.error.code === 'ARTIFACT_NOT_REGULAR' ? 'REVIEW_ARTIFACT_NOT_REGULAR' : 'REVIEW_ARTIFACT_IDENTITY_INVALID', validated.error.message, resolved.taskId);
-            content = fs.readFileSync(validated.artifact.path, 'utf8');
-            const intent = readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, spec.family, request.artifact);
-            if (intent?.state === 'preflight-ready')
-                recovery = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, intent);
-            if (intent?.state === 'consumed')
-                return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', 'review artifact was already finalized', resolved.taskId);
-        }
+        const validated = validateCompletedArtifact(resolved.taskDir, spec.family, request.artifact);
+        if (!validated.ok)
+            return preflightFailed(request, validated.error.code === 'ARTIFACT_NOT_REGULAR' ? 'REVIEW_ARTIFACT_NOT_REGULAR' : 'REVIEW_ARTIFACT_IDENTITY_INVALID', validated.error.message, resolved.taskId);
+        content = fs.readFileSync(validated.artifact.path, 'utf8');
     }
     catch (error) {
         return preflightFailed(request, 'REVIEW_ARTIFACT_NOT_REGULAR', String(error), resolved.taskId);
     }
-    if (!hasOpenArtifactRound(taskContent, spec.family, parsed.round))
-        return preflightFailed(request, 'REVIEW_ARTIFACT_IDENTITY_INVALID', `${request.artifact} does not have one matching open started review event`, resolved.taskId);
     const execution = validateLifecycleExecution(request.taskRef, {
         mode: request.orchestrated ? 'orchestrated' : 'standalone',
         identity: { stage: spec.family, round: parsed.round, artifact: request.artifact, role: 'reviewer' },
@@ -120,17 +99,6 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
     });
     const qualificationError = qualification.ok ? null : qualification;
     if (!detail.ok || !structure.ok || qualificationError) {
-        if (!recovery && !request.dryRun) {
-            try {
-                recovery = beginArtifactRecovery({
-                    taskId: resolved.taskId, family: spec.family, artifact: request.artifact, round: parsed.round,
-                    requestId: `review-preflight:${resolved.taskId}:${stage}:${parsed.round}`
-                }, Buffer.from(content, 'utf8'), { repoRoot: resolved.repoRoot, taskDir: resolved.taskDir, lockAlreadyHeld: options.lockAlreadyHeld });
-            }
-            catch (error) {
-                return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', String(error), resolved.taskId);
-            }
-        }
         const diagnostics = [
             ...(!detail.ok ? [`${detail.code}: ${detail.message}`] : []),
             ...structure.diagnostics.map((item) => `${item.code}: ${item.message}`),
@@ -138,30 +106,18 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
         ].join('; ');
         return preflightFailed(request, !detail.ok ? 'REVIEW_DECISION_DETAIL_INVALID' : !structure.ok ? 'REVIEW_ARTIFACT_STRUCTURE_INVALID' : 'REVIEW_ARTIFACT_QUALIFICATION_INVALID', diagnostics, resolved.taskId, {
             artifactSha256, semanticDigest,
-            ...(recovery ? { recovery: recoveryInfo(recovery) } : {})
         });
     }
-    if (request.dryRun || recovery && readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, spec.family, request.artifact)?.state === 'preflight-ready') {
+    if (request.dryRun) {
         return {
-            ...preflightFailed(request, 'REVIEW_ARTIFACT_CONFLICT', '', resolved.taskId, { artifactSha256, semanticDigest, ...(recovery ? { recovery: recoveryInfo(recovery) } : {}) }),
+            ...preflightFailed(request, 'REVIEW_ARTIFACT_CONFLICT', '', resolved.taskId, { artifactSha256, semanticDigest }),
             status: 'passed', changed: false, error: null
         };
     }
-    try {
-        recovery ??= beginArtifactRecovery({
-            taskId: resolved.taskId, family: spec.family, artifact: request.artifact, round: parsed.round,
-            requestId: `review-preflight:${resolved.taskId}:${stage}:${parsed.round}`
-        }, Buffer.from(content, 'utf8'), { repoRoot: resolved.repoRoot, taskDir: resolved.taskDir, lockAlreadyHeld: options.lockAlreadyHeld });
-        const staged = stageArtifactCandidate(recovery, Buffer.from(content, 'utf8'), { lockAlreadyHeld: options.lockAlreadyHeld });
-        prepareArtifactRecoveryCommit(recovery, staged.candidateSha256, staged.semanticDigest, { lockAlreadyHeld: options.lockAlreadyHeld });
-        return {
-            ...preflightFailed(request, 'REVIEW_ARTIFACT_CONFLICT', '', resolved.taskId, { artifactSha256, semanticDigest, recovery: recoveryInfo(recovery) }),
-            status: 'passed', changed: false, error: null
-        };
-    }
-    catch (error) {
-        return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', String(error), resolved.taskId, { artifactSha256, semanticDigest });
-    }
+    return {
+        ...preflightFailed(request, 'REVIEW_ARTIFACT_CONFLICT', '', resolved.taskId, { artifactSha256, semanticDigest }),
+        status: 'passed', changed: false, error: null
+    };
 }
 function preflightReviewSummary(request, options = {}) {
     if (request.dryRun || options.lockAlreadyHeld)
@@ -178,14 +134,6 @@ function preflightReviewSummary(request, options = {}) {
         return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', `${error.code}: ${error.message}`, resolved.taskId);
     }
 }
-function recoveryInfo(recovery) {
-    return {
-        recoveryId: recovery.recoveryId,
-        candidatePath: recovery.stagingPath,
-        baselineSha256: recovery.baselineSha256,
-        baselineSemanticDigest: recovery.baselineSemanticDigest
-    };
-}
 /** Prepare domain validation, summary bytes and provenance before any publication. */
 function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     let taskId = null;
@@ -219,45 +167,9 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     catch (error) {
         return reject('REVIEW_ARTIFACT_NOT_REGULAR', String(error));
     }
-    let recovery;
-    if (request.recoveryId) {
-        try {
-            const intent = readArtifactRecoveryIntent(resolved.repoRoot, taskId, spec.family, request.artifact);
-            if (!intent || intent.recoveryOperationId !== request.recoveryId)
-                return reject('REVIEW_PROVENANCE_INVALID', 'recovery id does not match the artifact journal');
-            if (!['awaiting-preflight-recovery', 'preflight-ready', 'preflight-commit-started', 'preflight-passed', 'full-finalizer-ready', 'commit-started'].includes(intent.state))
-                return reject('REVIEW_PROVENANCE_INVALID', `recovery journal is in '${intent.state}' state`);
-            recovery = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, intent);
-            artifactContent = fs.existsSync(recovery.stagingPath)
-                ? fs.readFileSync(recovery.stagingPath, 'utf8')
-                : fs.readFileSync(recovery.formalPath, 'utf8');
-        }
-        catch (error) {
-            return reject('REVIEW_PROVENANCE_INVALID', String(error));
-        }
-    }
     const artifactSha256 = sha256Content(artifactContent);
     const semanticDigest = canonicalSemanticDigest(artifactContent);
     const digests = { artifactSha256, semanticDigest };
-    let repairIntent;
-    try {
-        repairIntent = readArtifactRecoveryIntent(resolved.repoRoot, taskId, spec.family, request.artifact);
-    }
-    catch (error) {
-        return reject('REVIEW_PROVENANCE_INVALID', String(error), digests);
-    }
-    if (repairIntent?.state === 'consumed') {
-        if (repairIntent.finalArtifactSha256 !== artifactSha256 || repairIntent.finalSemanticDigest !== semanticDigest) {
-            return reject('REVIEW_PROVENANCE_INVALID', 'the review artifact changed after its finalization provenance was recorded', digests);
-        }
-    }
-    if (repairIntent?.state === 'passed'
-        && (repairIntent.finalArtifactSha256 !== artifactSha256 || repairIntent.finalSemanticDigest !== semanticDigest)) {
-        repairIntent = undefined;
-    }
-    if (!hasOpenArtifactRound(taskContent, spec.family, parsed.round)) {
-        return reject('REVIEW_ARTIFACT_IDENTITY_INVALID', `${request.artifact} does not have one matching open started review event`);
-    }
     const execution = validateLifecycleExecution(request.taskRef, {
         mode: request.orchestrated ? 'orchestrated' : 'standalone',
         identity: { stage: spec.family, round: parsed.round, artifact: request.artifact, role: 'reviewer' },
@@ -284,67 +196,16 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     const schema = getArtifactSchema(spec.family);
     const structure = inspectArtifactContract(artifactContent, schema);
     if (!structure.ok) {
-        if (!recovery && !request.dryRun && options.startRecovery) {
-            try {
-                recovery = beginArtifactRecovery({
-                    taskId: taskId, family: spec.family, artifact: request.artifact, round: parsed.round,
-                    requestId: `review-finalize:${taskId}:${stage}:${parsed.round}`
-                }, Buffer.from(artifactContent, 'utf8'), { repoRoot: resolved.repoRoot, taskDir: resolved.taskDir, lockAlreadyHeld: options.lockAlreadyHeld });
-            }
-            catch (error) {
-                return reject('REVIEW_PROVENANCE_INVALID', String(error), digests);
-            }
-        }
-        return {
-            ...reject('REVIEW_ARTIFACT_STRUCTURE_INVALID', structure.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; '), {
-                artifactSha256, semanticDigest: structure.semanticDigest,
-                ...(recovery ? { recovery: {
-                        recoveryId: recovery.recoveryId,
-                        candidatePath: recovery.stagingPath,
-                        baselineSha256: recovery.baselineSha256,
-                        baselineSemanticDigest: recovery.baselineSemanticDigest
-                    } } : {})
-            }),
-            ...(recovery ? { recovery } : {})
-        };
+        return reject('REVIEW_ARTIFACT_STRUCTURE_INVALID', structure.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; '), {
+            artifactSha256, semanticDigest: structure.semanticDigest
+        });
     }
     const transformed = finalizeReviewSummaryContent(artifactContent, stageStatus.unresolvedFindingCounts, {
-        refreshNumericCounts: Boolean(request.recoveryId && recovery)
+        refreshNumericCounts: true
     });
     if (!transformed.ok)
         return reject(transformed.code, transformed.message);
     const finalDigests = { artifactSha256: sha256Content(transformed.content), semanticDigest: canonicalSemanticDigest(transformed.content) };
-    if (!recovery && repairIntent?.state === 'commit-started') {
-        if (repairIntent.finalArtifactSha256 !== finalDigests.artifactSha256 || repairIntent.finalSemanticDigest !== finalDigests.semanticDigest) {
-            return reject('REVIEW_PROVENANCE_INVALID', 'formal review artifact does not match the interrupted recovery journal', finalDigests);
-        }
-        recovery = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, repairIntent);
-    }
-    if (!recovery && (repairIntent?.state === 'passed' || repairIntent?.state === 'consumed')) {
-        if (transformed.changed)
-            return reject('REVIEW_PROVENANCE_INVALID', 'the review artifact requires changes after its completed recovery was consumed', finalDigests);
-        return {
-            content: transformed.content,
-            result: {
-                ...failed(request, 'REVIEW_ARTIFACT_CONFLICT', '', taskId, stageStatus, finalDigests),
-                status: 'no-op',
-                changed: false,
-                error: null
-            },
-            lockAlreadyHeld: options.lockAlreadyHeld
-        };
-    }
-    if (!recovery && !request.dryRun && options.startRecovery) {
-        try {
-            recovery = beginArtifactRecovery({
-                taskId: taskId, family: spec.family, artifact: request.artifact, round: parsed.round,
-                requestId: `review-finalize:${taskId}:${stage}:${parsed.round}`
-            }, Buffer.from(artifactContent, 'utf8'), { repoRoot: resolved.repoRoot, taskDir: resolved.taskDir, lockAlreadyHeld: options.lockAlreadyHeld });
-        }
-        catch (error) {
-            return reject('REVIEW_PROVENANCE_INVALID', String(error), finalDigests);
-        }
-    }
     return {
         content: transformed.content,
         result: {
@@ -354,65 +215,26 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
             operations: transformed.changed ? [{ kind: 'artifact', artifact: request.artifact, operation: 'update' }] : [],
             error: null
         },
-        ...(recovery ? { recovery } : {}),
         lockAlreadyHeld: options.lockAlreadyHeld
     };
 }
 function commitReviewSummaryProvenance(prepared, repoRoot, options = {}) {
-    if (prepared.result.status === 'failed' || !prepared.recovery)
-        return prepared.result;
+    return prepared.result;
+}
+function replaceCurrentArtifactAtomically(file, content) {
+    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
     try {
-        const intent = readArtifactRecoveryIntent(prepared.recovery.repoRoot, prepared.recovery.taskId, prepared.recovery.family, prepared.recovery.artifact);
-        if (!intent)
-            throw new Error('ARTIFACT_RECOVERY_INTENT_MISSING');
-        let committed;
-        if (intent.state === 'passed' || intent.state === 'consumed') {
-            return {
-                ...prepared.result,
-                status: 'no-op',
-                changed: false,
-                artifactSha256: intent.finalArtifactSha256,
-                semanticDigest: intent.finalSemanticDigest,
-                error: null
-            };
-        }
-        else if (intent.state === 'commit-started') {
-            const reconciled = reconcileArtifactRecovery(prepared.recovery, {
-                lockAlreadyHeld: prepared.lockAlreadyHeld,
-                afterPublish: options.afterPublish
-            });
-            committed = reconciled.intent;
-        }
-        else if (intent.state === 'awaiting-preflight-recovery') {
-            const staged = stageArtifactCandidate(prepared.recovery, Buffer.from(prepared.content, 'utf8'), { lockAlreadyHeld: prepared.lockAlreadyHeld });
-            prepareArtifactRecoveryCommit(prepared.recovery, staged.candidateSha256, staged.semanticDigest, { lockAlreadyHeld: prepared.lockAlreadyHeld });
-            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld });
-        }
-        else if (intent.state === 'preflight-ready' || intent.state === 'preflight-commit-started') {
-            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld });
-        }
-        if (committed?.state === 'preflight-passed' || intent.state === 'preflight-passed') {
-            prepareArtifactRecoveryFinal(prepared.recovery, Buffer.from(prepared.content, 'utf8'), { lockAlreadyHeld: prepared.lockAlreadyHeld });
-            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld, afterPublish: options.afterPublish });
+        fs.writeFileSync(temporary, content, { encoding: 'utf8', flag: 'wx' });
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
         }
-        else if (intent.state === 'full-finalizer-ready') {
-            committed = commitArtifactRecovery(prepared.recovery, { lockAlreadyHeld: prepared.lockAlreadyHeld, afterPublish: options.afterPublish });
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
         }
-        if (!committed || committed.state !== 'passed')
-            throw new Error(`ARTIFACT_RECOVERY_STATE_INVALID: commit ended in '${committed?.state ?? intent.state}'`);
-        return {
-            ...prepared.result,
-            artifactSha256: committed.finalArtifactSha256,
-            semanticDigest: committed.finalSemanticDigest,
-            error: null
-        };
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith('TASK_WORKFLOW_FAULT_INJECTED:'))
-            throw error;
-        return { ...prepared.result, status: 'failed', error: {
-                code: 'REVIEW_RECOVERY_COMMIT_FAILED', message: `cannot publish review candidate: ${String(error)}`
-            } };
     }
 }
 function finalizeReviewSummaryUnlocked(request, options = {}) {
@@ -437,10 +259,23 @@ function finalizeReviewSummaryUnlocked(request, options = {}) {
     const prepared = prepareReviewSummaryCandidate(request, content, options);
     if (request.dryRun)
         return prepared.result;
-    return commitReviewSummaryProvenance(prepared, resolved.repoRoot);
+    if (prepared.result.status === 'failed' || !prepared.result.changed)
+        return prepared.result;
+    try {
+        replaceCurrentArtifactAtomically(validated.artifact.path, prepared.content);
+        return {
+            ...prepared.result,
+            status: 'applied',
+            artifactSha256: sha256Content(prepared.content),
+            semanticDigest: canonicalSemanticDigest(prepared.content)
+        };
+    }
+    catch (error) {
+        return failed(request, 'REVIEW_RECOVERY_COMMIT_FAILED', `cannot update current review artifact: ${error instanceof Error ? error.message : String(error)}`, resolved.taskId);
+    }
 }
 function finalizeReviewSummary(request, options = {}) {
-    const effectiveOptions = { ...options, startRecovery: !request.dryRun };
+    const effectiveOptions = options;
     if (request.dryRun || options.lockAlreadyHeld)
         return finalizeReviewSummaryUnlocked(request, effectiveOptions);
     const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.1",
-  "sourceInputHash": "0d66fb32bbdc0982d38a04b86b0278768bb6091eb945ebd90a432f9bae363712",
-  "internalExecutableBuildHash": "4b1edd20ed87d3d742e5e7975fd49b1ac1fb0ff14f837d52ee9ba3ab11318365"
+  "packageVersion": "0.11.3",
+  "sourceInputHash": "99efbc575d475879773bf1676cc2de5ea628b9c193f69a9812a723313ba5ae7f",
+  "internalExecutableBuildHash": "6912a66863d013c476699b88cc1d4154082971164cbae3f98ea79dda39a46e7a"
 }

package/lib/agent-clients/adapter.ts

@@ -7,6 +7,10 @@ import type {
   AgentClientCapabilityMap,
   AgentClientId
 } from './types.ts';
+import type {
+  OrchestrationOptions,
+  OrchestrationResult
+} from '../task/orchestration.ts';
 import {
   SANDBOX_HOOK_PHASES
 } from '../sandbox/tool-types.ts';
@@ -43,6 +47,41 @@ type AgentClientDelegationEvidence = Readonly<{
   actualReasoningEffort: 'host-event' | 'app-server' | 'spawn-ack' | 'unavailable';
 }>;
 
+type AgentClientLifecycleRecoveryRequest = Readonly<{
+  taskRef: string;
+  intent: 'recover-started';
+  agent: string;
+  auto: true;
+}>;
+
+type AgentClientLifecycleRecoveryResult = Readonly<{
+  status: 'applied' | 'no-op' | 'owner-unknown' | 'conflict';
+  changed: boolean;
+  targetState: 'active';
+  requestRef: string;
+  intent: 'recover-started';
+  taskId: string | null;
+  receiptId: string | null;
+  childId: string | null;
+  error: Readonly<{ code: string; message: string }> | null;
+}>;
+
+type AgentClientOrchestrationAdapter = Readonly<{
+  prepareDelegation?: (
+    taskRef: string,
+    input: Readonly<{
+      client: AgentClientId;
+      requestedModel?: string;
+      requestedReasoningEffort?: string;
+    }>,
+    options?: Readonly<{ repoRoot?: string; orchestrationOptions?: OrchestrationOptions }>
+  ) => Promise<OrchestrationResult>;
+  recoverStarted?: (
+    request: AgentClientLifecycleRecoveryRequest,
+    options: Readonly<{ repoRoot: string }>
+  ) => AgentClientLifecycleRecoveryResult | Promise<AgentClientLifecycleRecoveryResult>;
+}>;
+
 type AgentClientSeedCommand = Readonly<{
   templates: Readonly<{
     en: string;
@@ -75,6 +114,7 @@ type AgentClientAdapter = Readonly<{
   capabilities: AgentClientCapabilities;
   modelSelection: AgentClientModelSelectionContext;
   delegationEvidence: AgentClientDelegationEvidence;
+  orchestrationAdapter?: AgentClientOrchestrationAdapter;
   project: AgentClientProjectDescriptor;
   sandbox: AgentClientSandboxDescriptor;
 }>;
@@ -628,6 +668,9 @@ function defineAgentClientAdapter(
     capabilities: Object.freeze(capabilities),
     modelSelection: frozenModelSelection,
     delegationEvidence: Object.freeze({ ...evidence }),
+    ...(candidate.orchestrationAdapter === undefined
+      ? {}
+      : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
     project: Object.freeze({
       ownedPathPrefixes: Object.freeze(paths),
       ...projectAssets,
@@ -650,6 +693,9 @@ export type {
   AgentClientCapabilities,
   AgentClientCustomCommandDescriptor,
   AgentClientDelegationEvidence,
+  AgentClientLifecycleRecoveryRequest,
+  AgentClientLifecycleRecoveryResult,
+  AgentClientOrchestrationAdapter,
   AgentClientManifestEntry,
   AgentClientModelSelectionContext,
   AgentClientProjectDescriptor,