@fitlab-ai/agent-infra 0.11.0 → 0.11.2

package/dist/lib/task/codex-orchestration.js

@@ -1,39 +1,15 @@
 import { preflightCodexLifecycleEvidence, resolveCodexSpawnedChild, resolveCodexTerminal, resolveCodexThread } from '../agent-clients/adapters/codex-lifecycle/app-server.js';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.js';
-import { createCodexCapabilityStore, isCodexCapabilityProvenanceDetail } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
-import { computeLifecycleBuildIdentity, verifyLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
-import { verifyCodexSandboxControllerContextWithWarnings as verifySandboxControllerWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
-import { verifyCodexSandboxControllerContextWithWarnings as verifyControllerContextFileWithWarnings } from '../agent-clients/adapters/codex-lifecycle/controller-context.js';
+import { computeLifecycleBuildIdentity, } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, routeOrchestration, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
-import { randomUUID, createHash } from 'node:crypto';
-import { consumeLifecycleRecoveryAttestation, issueLifecycleRecoveryAttestation, validateLifecycleRecoveryAttestation } from './control-authority.js';
-function buildIdentityDigest(value) {
-    return createHash('sha256').update(JSON.stringify(value), 'utf8').digest('hex');
-}
+import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
 function coreOptions(options) {
     return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
-function bridgeFailure(code, message, detail) {
+function bridgeFailure(code, message) {
     return {
         status: 'failed', changed: false, taskId: null, run: null, next: null,
-        error: { code, message, ...(detail ? { detail } : {}) }
-    };
-}
-function capabilityFailure(error) {
-    const detailValue = error instanceof Error
-        ? error.detail
-        : undefined;
-    return {
-        code: error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
-            ? error.name
-            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
-        message: error instanceof Error ? error.message : String(error),
-        ...(error instanceof Error
-            && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
-            && isCodexCapabilityProvenanceDetail(detailValue)
-            ? { detail: detailValue }
-            : {})
+        error: { code, message }
     };
 }
 function pauseBridge(code, message, options) {
@@ -47,28 +23,6 @@ function requiredStore(options) {
         throw new Error('Codex lifecycle store is required for orchestration bridge events');
     return options.store;
 }
-function brokerControllerBinding() {
-    const raw = process.env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING;
-    if (!raw)
-        return null;
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
-    }
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
-    }
-    const binding = value;
-    if (Object.keys(binding).sort().join(',') !== 'controlGeneration,instanceDigest'
-        || typeof binding.instanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(binding.instanceDigest)
-        || typeof binding.controlGeneration !== 'string' || binding.controlGeneration.length === 0) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
-    }
-    return binding;
-}
 async function prepareCodexOrchestrationDelegation(taskRef, input, options = {}) {
     if (input.client !== 'codex')
         return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
@@ -77,152 +31,13 @@ async function prepareCodexOrchestrationDelegation(taskRef, input, options = {})
         const resolved = resolveTaskRef(taskRef, { repoRoot });
         if (!resolved.ok)
             return bridgeFailure(resolved.code, resolved.message);
-        const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
-        const capabilityRef = input.capabilityRef;
-        if (!capabilityRef) {
-            return bridgeFailure('ORCHESTRATION_CODEX_CAPABILITY_REQUIRED', 'Codex prepare requires a current-session capability reference');
-        }
-        const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
-        const brokerController = options.controllerBinding ?? brokerControllerBinding();
-        const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-        const contextVerification = contextPath
-            ? (brokerController
-                ? verifyControllerContextFileWithWarnings(contextPath, {
-                    repoRoot,
-                    generation: process.env.AGENT_INFRA_CONTROL_GENERATION ?? brokerController.controlGeneration
-                })
-                : verifySandboxControllerWithWarnings(contextPath, { repoRoot }))
-            : null;
-        const identityWarnings = [...(contextVerification?.warnings ?? [])];
-        const localController = contextVerification?.context ?? null;
-        if (localController && brokerController
-            && (localController.controllerInstanceDigest !== brokerController.instanceDigest
-                || localController.controlGeneration !== brokerController.controlGeneration)) {
-            return bridgeFailure('CODEX_SANDBOX_CONTROLLER_BINDING_MISMATCH', 'broker and local controller bindings do not match');
-        }
-        const controller = brokerController ?? (localController ? {
-            instanceDigest: localController.controllerInstanceDigest,
-            controlGeneration: localController.controlGeneration
-        } : null);
-        const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
-        const attested = capabilityStore.inspectReference(capabilityRef);
-        const capabilityIdentity = verifyLifecycleBuildIdentity(attested.buildIdentity, buildIdentity);
-        if (!capabilityIdentity.ok) {
-            return bridgeFailure(capabilityIdentity.code, capabilityIdentity.message);
-        }
-        identityWarnings.push(...capabilityIdentity.warnings);
-        const lifecycleProvenance = {
-            ...attested.buildIdentity,
-            hookDefinitionHash: preflight.hookDefinitionHash,
-            ...preflight.hookProvenance,
-            capabilitySessionId: attested.sessionId,
-            capabilityTurnId: attested.turnId,
-            capabilityToolUseId: attested.toolUseId,
-            controllerInstanceDigest: controller?.instanceDigest ?? null,
-            controlGeneration: controller?.controlGeneration ?? null
-        };
-        const capabilityExpected = {
-            taskId: resolved.taskId,
-            hookDefinitionHash: preflight.hookDefinitionHash,
-            buildIdentity,
-            ...(controller ? { controller: {
-                    instanceDigest: controller.instanceDigest,
-                    controlGeneration: controller.controlGeneration
-                } } : {})
-        };
-        if (input.lifecycleRecoveryAttestation) {
-            try {
-                validateLifecycleRecoveryAttestation(input.lifecycleRecoveryAttestation);
-            }
-            catch (error) {
-                return bridgeFailure('LIFECYCLE_AUTHORITY_ATTESTATION_INVALID', error instanceof Error ? error.message : String(error));
-            }
-        }
-        let lifecycleRecoveryAttestation = input.lifecycleRecoveryAttestation ?? null;
-        const routed = input.capabilityRef && !lifecycleRecoveryAttestation
-            ? routeOrchestration(taskRef, coreOptions(options))
-            : null;
-        if (routed && !routed.next)
-            return routed;
-        if (routed?.next && ['analysis', 'plan', 'code'].includes(routed.next.stage)) {
-            const recoveryRequest = {
-                version: 1,
-                requestId: randomUUID(),
-                operationId: randomUUID(),
-                phase: 'orchestration.prepare',
-                taskId: resolved.taskId,
-                family: routed.next.stage === 'analysis' ? 'analysis'
-                    : routed.next.stage === 'plan' ? 'plan' : 'code',
-                artifact: routed.next.artifact,
-                round: routed.next.round,
-                lifecycleRequestId: randomUUID(),
-                authorityRef: capabilityRef,
-                expectedControlGeneration: controller?.controlGeneration ?? '',
-                expectedControllerInstanceDigest: controller?.instanceDigest ?? '0'.repeat(64),
-                expectedBuildIdentityDigest: buildIdentityDigest(buildIdentity),
-                expectedHookDefinitionHash: preflight.hookDefinitionHash
-            };
-            const authority = issueLifecycleRecoveryAttestation(recoveryRequest, {
-                capabilityStore,
-                ...(controller ? { controllerBinding: controller } : {}),
-                buildIdentity
-            });
-            if (authority.status === 'rejected' || !authority.attestation) {
-                return bridgeFailure(authority.error?.code ?? 'LIFECYCLE_AUTHORITY_REJECTED', authority.error?.message ?? 'lifecycle authority was rejected');
-            }
-            lifecycleRecoveryAttestation = authority.attestation;
-        }
-        const prepared = prepareOrchestrationDelegation(taskRef, {
-            ...input,
-            lifecycleProvenance,
-            lifecycleRecoveryAttestation
-        }, {
-            ...coreOptions(options),
-            validateLifecycleCapability: () => {
-                try {
-                    const validated = capabilityStore.validateReference(capabilityRef, capabilityExpected);
-                    if (validated.sessionId !== attested.sessionId
-                        || validated.turnId !== attested.turnId
-                        || validated.toolUseId !== attested.toolUseId) {
-                        return {
-                            code: 'CODEX_CAPABILITY_IDENTITY_CHANGED',
-                            message: 'capability identity changed during validation'
-                        };
-                    }
-                    return null;
-                }
-                catch (error) {
-                    return capabilityFailure(error);
-                }
-            },
-            consumeLifecycleCapability: () => null
-        });
-        if (lifecycleRecoveryAttestation && !options.deferLifecycleRecoveryConsumption && prepared.status !== 'failed') {
-            try {
-                consumeLifecycleRecoveryAttestation(lifecycleRecoveryAttestation);
-            }
-            catch (error) {
-                return bridgeFailure(error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_CONSUME_FAILED', error instanceof Error ? error.message : String(error));
-            }
-        }
-        return identityWarnings.length > 0 && prepared.status !== 'failed'
-            ? { ...prepared, warnings: Object.freeze(identityWarnings) }
-            : prepared;
+        await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
+        return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
     }
     catch (error) {
         if (error instanceof OrchestrationStateError)
             return bridgeFailure(error.code, error.message);
-        const detailValue = error instanceof Error
-            ? error.detail
-            : undefined;
-        const detail = error instanceof Error
-            && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
-            && isCodexCapabilityProvenanceDetail(detailValue)
-            ? detailValue
-            : undefined;
-        return bridgeFailure(error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
-            ? error.name
-            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error), detail);
+        return bridgeFailure('ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error));
     }
 }
 async function activateCodexOrchestrationDelegation(childThreadId, options = {}) {
@@ -248,16 +63,6 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
             toolUseId: evidence.spawnToolUseId
         });
         const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
-        const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-        const contextVerification = contextPath
-            ? verifySandboxControllerWithWarnings(contextPath, { repoRoot })
-            : null;
-        const controller = options.controllerBinding
-            ?? brokerControllerBinding()
-            ?? (contextVerification?.context ? {
-                instanceDigest: contextVerification.context.controllerInstanceDigest,
-                controlGeneration: contextVerification.context.controlGeneration
-            } : null);
         const activated = activateMatchingOrchestrationDelegation('codex', {
             nativeAgent: evidence.nativeAgent,
             childId: evidence.childThreadId,
@@ -279,14 +84,11 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
                 capabilityTurnId: evidence.parentTurnId,
                 spawnToolUseId: evidence.spawnToolUseId,
                 spawnObservedAt: record.spawnObservedAt ?? undefined,
-                controllerInstanceDigest: controller?.instanceDigest ?? null,
-                controlGeneration: controller?.controlGeneration ?? null
+                controllerInstanceDigest: null,
+                controlGeneration: null
             }
         }, coreOptions(options));
-        const warnings = contextVerification?.warnings ?? [];
-        return warnings.length > 0 && activated.status !== 'failed'
-            ? { ...activated, warnings: Object.freeze(warnings) }
-            : activated;
+        return activated;
     }
     catch (error) {
         if (error instanceof OrchestrationStateError)

package/dist/lib/task/commit-operation.js

@@ -181,16 +181,6 @@ function checkpointIdentity(input, task, delivery) {
 function checkpointTimestamp() {
     return new Date().toISOString();
 }
-function samePreparedCheckpointIdentity(pending, identity) {
-    return pending.state === 'prepared'
-        && pending.taskId === identity.taskId
-        && pending.branch === identity.branch
-        && pending.mode === identity.mode
-        && pending.expectedHead === identity.expectedHead
-        && pending.message === identity.message
-        && pending.round === identity.round
-        && JSON.stringify(pending.paths) === JSON.stringify(identity.paths);
-}
 function executeUnlocked(input, task, mode) {
     const inspected = inspectGitWorkflow(input.cwd);
     if (!inspected.snapshot)
@@ -225,16 +215,11 @@ function executeUnlocked(input, task, mode) {
                 };
             }
             if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity)) {
-                if (!input.recoverPreparedIntent || !samePreparedCheckpointIdentity(pendingIntent, identity))
-                    return {
-                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
-                        error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
-                    };
+                const timestamp = checkpointTimestamp();
                 pendingIntent = {
-                    ...pendingIntent,
-                    expectedTree: identity.expectedTree,
+                    version: 1, ...identity,
                     digest: checkpointIntentDigest(identity),
-                    updatedAt: checkpointTimestamp()
+                    state: 'prepared', committedHead: null, createdAt: timestamp, updatedAt: timestamp
                 };
                 try {
                     writeCheckpointIntent(task.repoRoot, pendingIntent);

package/dist/lib/task/control-authority.js

@@ -535,17 +535,11 @@ function orchestration(context, operation) {
                 client: input.client,
                 requestedModel: input.requestedModel,
                 requestedReasoningEffort: input.requestedReasoningEffort,
-                ...(input.capabilityRef === undefined ? {} : { capabilityRef: input.capabilityRef }),
-                ...(context.lifecycleRecoveryAttestation === undefined
-                    ? {}
-                    : { lifecycleRecoveryAttestation: context.lifecycleRecoveryAttestation })
             };
             if (prepareInput.client === 'codex') {
                 return prepareCodexOrchestrationDelegation(operation.taskRef, prepareInput, {
                     repoRoot: context.repoRoot,
                     orchestrationOptions: options,
-                    deferLifecycleRecoveryConsumption: context.source === 'sandbox-executor',
-                    ...(context.controllerBinding ? { controllerBinding: context.controllerBinding } : {})
                 });
             }
             return prepareOrchestrationDelegation(operation.taskRef, prepareInput, options);
@@ -629,7 +623,7 @@ const FINALIZATION_FLAGS = new Set(['--agent']);
 const ORCHESTRATION_FLAGS = new Set([
     '--agent', '--max-steps', '--executor-model', '--executor-reasoning-effort', '--reviewer-model',
     '--reviewer-reasoning-effort', '--client', '--requested-model', '--requested-reasoning-effort',
-    '--capability-ref', '--parent-id', '--before-fingerprint', '--stage', '--round', '--artifact', '--role',
+    '--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'
@@ -769,7 +763,6 @@ export function parseTaskControlOperation(family, args) {
     if (parsedIntent === 'prepare') {
         input.requestedModel = value(values, '--requested-model');
         input.requestedReasoningEffort = value(values, '--requested-reasoning-effort');
-        input.capabilityRef = value(values, '--capability-ref');
     }
     if (parsedIntent === 'await-activation') {
         required(values, ['--stage', '--round', '--artifact', '--role']);

package/dist/lib/task/delegation-receipts.js

@@ -15,12 +15,6 @@ function hasExactKeys(value, required, optional = []) {
 function exactText(value) {
     return typeof value === 'string' && value.length > 0 && value.trim() === value;
 }
-function validCodexBuildMetadata(value) {
-    return Number.isSafeInteger(value.protocolVersion) && value.protocolVersion > 0
-        && exactText(value.packageVersion)
-        && exactText(value.internalExecutableBuildHash)
-        && exactText(value.lifecycleContractHash);
-}
 function nullableText(value) {
     return value === null || exactText(value);
 }
@@ -88,51 +82,6 @@ function isDelegationHostEvidence(value) {
         && nullableText(value.controllerInstanceDigest)
         && nullableText(value.controlGeneration);
 }
-function hasCurrentCodexEvidence(receipt) {
-    const provenance = receipt.lifecycleProvenance;
-    if (!provenance)
-        return false;
-    const activated = ['activated', 'stage-completed', 'sealed', 'consumed'].includes(receipt.status)
-        || (receipt.status === 'aborted' && receipt.activatedAt !== null);
-    if (!activated)
-        return receipt.hostEvidence === null;
-    const host = receipt.hostEvidence;
-    if (host?.kind !== 'codex-lifecycle-v2'
-        || host.protocolVersion !== provenance.protocolVersion
-        || host.hookDefinitionHash !== provenance.hookDefinitionHash
-        || host.hookSource !== provenance.hookSource
-        || host.hookSourcePathDigest !== provenance.hookSourcePathDigest
-        || host.hookSourceHash !== provenance.hookSourceHash
-        || host.capabilitySessionId !== provenance.capabilitySessionId
-        || host.capabilityTurnId !== provenance.capabilityTurnId
-        || host.controllerInstanceDigest !== provenance.controllerInstanceDigest
-        || host.controlGeneration !== provenance.controlGeneration
-        || receipt.parentId !== provenance.capabilitySessionId
-        || host.spawnToolUseId === provenance.capabilityToolUseId)
-        return false;
-    const spawnObservedAt = Date.parse(host.spawnObservedAt ?? '');
-    const spawnDispatchedAt = Date.parse(receipt.spawnDispatchedAt ?? '');
-    const activationDeadlineAt = Date.parse(receipt.activationDeadlineAt ?? '');
-    if (!Number.isFinite(spawnObservedAt)
-        || !Number.isFinite(spawnDispatchedAt)
-        || !Number.isFinite(activationDeadlineAt)
-        || spawnObservedAt < spawnDispatchedAt
-        || spawnObservedAt > activationDeadlineAt)
-        return false;
-    if (['sealed', 'consumed'].includes(receipt.status)) {
-        return Number.isSafeInteger(host.stopRevision)
-            && host.stopRevision > host.startRevision
-            && host.consumer === receipt.id
-            && exactText(host.consumedAt);
-    }
-    if (receipt.status === 'aborted') {
-        return Number.isSafeInteger(host.stopRevision)
-            && host.stopRevision > host.startRevision
-            && host.consumer === `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
-            && exactText(host.consumedAt);
-    }
-    return host.stopRevision === null && host.consumer === null && host.consumedAt === null;
-}
 const RECEIPT_KEYS = [
     'id', 'taskId', 'runId', 'role', 'stage', 'round', 'artifact', 'client',
     'requestedModel', 'requestedReasoningEffort', 'actualModel', 'actualReasoningEffort',
@@ -263,8 +212,17 @@ function isDelegationReceipt(value) {
     if (!structurallyValid)
         return false;
     const receipt = value;
-    return hasStatusBoundEvidence(receipt)
-        && (receipt.client !== 'codex' || hasCurrentCodexEvidence(receipt));
+    if (!hasStatusBoundEvidence(receipt))
+        return false;
+    const host = receipt.hostEvidence;
+    if (receipt.client === 'codex' && receipt.activatedAt !== null) {
+        if (host?.kind !== 'codex-lifecycle-v2' || host.capabilitySessionId !== receipt.parentId)
+            return false;
+        if (['sealed', 'consumed'].includes(receipt.status)) {
+            return Number.isSafeInteger(host.stopRevision) && host.stopRevision > host.startRevision;
+        }
+    }
+    return true;
 }
 const MANAGED_AGENTS = {
     'agent-infra-lifecycle-executor': 'executor',
@@ -397,29 +355,9 @@ function activateDelegation(receipt, event, options = {}) {
             || !Number.isSafeInteger(event.hostEvidence.startRevision)
             || event.hostEvidence.startRevision < 1))
         return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence reference is invalid');
-    if (event.hostEvidence?.kind === 'codex-lifecycle-v2') {
-        const expected = receipt.lifecycleProvenance;
-        const spawnObservedAt = Date.parse(event.hostEvidence.spawnObservedAt ?? '');
-        const spawnDispatchedAt = Date.parse(receipt.spawnDispatchedAt);
-        const activationDeadlineAt = Date.parse(receipt.activationDeadlineAt);
-        if (!expected
-            || event.hostEvidence.protocolVersion !== expected.protocolVersion
-            || event.hostEvidence.hookDefinitionHash !== expected.hookDefinitionHash
-            || event.hostEvidence.hookSource !== expected.hookSource
-            || event.hostEvidence.hookSourcePathDigest !== expected.hookSourcePathDigest
-            || event.hostEvidence.hookSourceHash !== expected.hookSourceHash
-            || event.hostEvidence.capabilitySessionId !== expected.capabilitySessionId
-            || event.hostEvidence.capabilityTurnId !== expected.capabilityTurnId
-            || !event.hostEvidence.spawnToolUseId?.trim()
-            || event.hostEvidence.spawnToolUseId === expected.capabilityToolUseId
-            || !Number.isFinite(spawnObservedAt)
-            || spawnObservedAt < spawnDispatchedAt
-            || spawnObservedAt > activationDeadlineAt
-            || event.parentId !== expected.capabilitySessionId
-            || (event.hostEvidence.controllerInstanceDigest ?? null) !== expected.controllerInstanceDigest
-            || (event.hostEvidence.controlGeneration ?? null) !== expected.controlGeneration
-            || !validCodexBuildMetadata(event.hostEvidence))
-            return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex lifecycle provenance does not match the prepared receipt');
+    if (event.hostEvidence?.kind === 'codex-lifecycle-v2'
+        && event.hostEvidence.capabilitySessionId !== event.parentId) {
+        return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence does not match the observed parent');
     }
     return { ok: true, receipt: Object.freeze({
             ...receipt,