@vorionsys/atsf-core 0.3.1 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/dist/basis/parser.d.ts +46 -46
  2. package/dist/index.d.ts +1 -1
  3. package/dist/index.d.ts.map +1 -1
  4. package/dist/index.js +1 -1
  5. package/dist/index.js.map +1 -1
  6. package/dist/phase6/provenance.d.ts +2 -2
  7. package/dist/phase6/provenance.js +2 -2
  8. package/dist/phase6/types.d.ts +196 -196
  9. package/dist/trust-engine/index.d.ts +1 -2
  10. package/dist/trust-engine/index.d.ts.map +1 -1
  11. package/dist/trust-engine/index.js.map +1 -1
  12. package/package.json +140 -140
package/dist/phase6/types.d.ts CHANGED
@@ -99,22 +99,22 @@ export declare const deploymentContextSchema: z.ZodObject<{
99
99
  deployedBy: z.ZodString;
100
100
  immutable: z.ZodLiteral<true>;
101
101
  }, "strip", z.ZodTypeAny, {
102
- regulatoryFramework?: RegulatoryFramework;
103
102
  deploymentId?: string;
103
+ deploymentHash?: string;
104
+ regulatoryFramework?: RegulatoryFramework;
104
105
  maxAllowedTier?: TrustTier;
105
106
  allowedContextTypes?: ContextType[];
106
107
  deployedAt?: Date;
107
108
  deployedBy?: string;
108
- deploymentHash?: string;
109
109
  immutable?: true;
110
110
  }, {
111
- regulatoryFramework?: RegulatoryFramework;
112
111
  deploymentId?: string;
112
+ deploymentHash?: string;
113
+ regulatoryFramework?: RegulatoryFramework;
113
114
  maxAllowedTier?: TrustTier;
114
115
  allowedContextTypes?: ContextType[];
115
116
  deployedAt?: Date;
116
117
  deployedBy?: string;
117
- deploymentHash?: string;
118
118
  immutable?: true;
119
119
  }>;
120
120
  /**
@@ -150,22 +150,22 @@ export declare const organizationalContextSchema: z.ZodObject<{
150
150
  deployedBy: z.ZodString;
151
151
  immutable: z.ZodLiteral<true>;
152
152
  }, "strip", z.ZodTypeAny, {
153
- regulatoryFramework?: RegulatoryFramework;
154
153
  deploymentId?: string;
154
+ deploymentHash?: string;
155
+ regulatoryFramework?: RegulatoryFramework;
155
156
  maxAllowedTier?: TrustTier;
156
157
  allowedContextTypes?: ContextType[];
157
158
  deployedAt?: Date;
158
159
  deployedBy?: string;
159
- deploymentHash?: string;
160
160
  immutable?: true;
161
161
  }, {
162
- regulatoryFramework?: RegulatoryFramework;
163
162
  deploymentId?: string;
163
+ deploymentHash?: string;
164
+ regulatoryFramework?: RegulatoryFramework;
164
165
  maxAllowedTier?: TrustTier;
165
166
  allowedContextTypes?: ContextType[];
166
167
  deployedAt?: Date;
167
168
  deployedBy?: string;
168
- deploymentHash?: string;
169
169
  immutable?: true;
170
170
  }>;
171
171
  lockedAt: z.ZodOptional<z.ZodDate>;
@@ -179,56 +179,56 @@ export declare const organizationalContextSchema: z.ZodObject<{
179
179
  maxTrustTier?: TrustTier;
180
180
  deniedDomains?: string[];
181
181
  requiredAttestations?: string[];
182
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
183
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
182
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
183
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
184
184
  }, {
185
185
  maxTrustTier?: TrustTier;
186
186
  deniedDomains?: string[];
187
187
  requiredAttestations?: string[];
188
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
189
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
188
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
189
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
190
190
  }>;
191
191
  orgHash: z.ZodString;
192
192
  }, "strip", z.ZodTypeAny, {
193
+ tenantId?: string;
193
194
  constraints?: {
194
195
  maxTrustTier?: TrustTier;
195
196
  deniedDomains?: string[];
196
197
  requiredAttestations?: string[];
197
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
198
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
198
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
199
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
199
200
  };
200
- tenantId?: string;
201
201
  orgId?: string;
202
202
  parentDeployment?: {
203
- regulatoryFramework?: RegulatoryFramework;
204
203
  deploymentId?: string;
204
+ deploymentHash?: string;
205
+ regulatoryFramework?: RegulatoryFramework;
205
206
  maxAllowedTier?: TrustTier;
206
207
  allowedContextTypes?: ContextType[];
207
208
  deployedAt?: Date;
208
209
  deployedBy?: string;
209
- deploymentHash?: string;
210
210
  immutable?: true;
211
211
  };
212
212
  lockedAt?: Date;
213
213
  orgHash?: string;
214
214
  }, {
215
+ tenantId?: string;
215
216
  constraints?: {
216
217
  maxTrustTier?: TrustTier;
217
218
  deniedDomains?: string[];
218
219
  requiredAttestations?: string[];
219
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
220
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
220
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
221
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
221
222
  };
222
- tenantId?: string;
223
223
  orgId?: string;
224
224
  parentDeployment?: {
225
- regulatoryFramework?: RegulatoryFramework;
226
225
  deploymentId?: string;
226
+ deploymentHash?: string;
227
+ regulatoryFramework?: RegulatoryFramework;
227
228
  maxAllowedTier?: TrustTier;
228
229
  allowedContextTypes?: ContextType[];
229
230
  deployedAt?: Date;
230
231
  deployedBy?: string;
231
- deploymentHash?: string;
232
232
  immutable?: true;
233
233
  };
234
234
  lockedAt?: Date;
@@ -262,22 +262,22 @@ export declare const agentContextSchema: z.ZodObject<{
262
262
  deployedBy: z.ZodString;
263
263
  immutable: z.ZodLiteral<true>;
264
264
  }, "strip", z.ZodTypeAny, {
265
- regulatoryFramework?: RegulatoryFramework;
266
265
  deploymentId?: string;
266
+ deploymentHash?: string;
267
+ regulatoryFramework?: RegulatoryFramework;
267
268
  maxAllowedTier?: TrustTier;
268
269
  allowedContextTypes?: ContextType[];
269
270
  deployedAt?: Date;
270
271
  deployedBy?: string;
271
- deploymentHash?: string;
272
272
  immutable?: true;
273
273
  }, {
274
- regulatoryFramework?: RegulatoryFramework;
275
274
  deploymentId?: string;
275
+ deploymentHash?: string;
276
+ regulatoryFramework?: RegulatoryFramework;
276
277
  maxAllowedTier?: TrustTier;
277
278
  allowedContextTypes?: ContextType[];
278
279
  deployedAt?: Date;
279
280
  deployedBy?: string;
280
- deploymentHash?: string;
281
281
  immutable?: true;
282
282
  }>;
283
283
  lockedAt: z.ZodOptional<z.ZodDate>;
@@ -291,56 +291,56 @@ export declare const agentContextSchema: z.ZodObject<{
291
291
  maxTrustTier?: TrustTier;
292
292
  deniedDomains?: string[];
293
293
  requiredAttestations?: string[];
294
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
295
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
294
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
295
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
296
296
  }, {
297
297
  maxTrustTier?: TrustTier;
298
298
  deniedDomains?: string[];
299
299
  requiredAttestations?: string[];
300
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
301
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
300
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
301
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
302
302
  }>;
303
303
  orgHash: z.ZodString;
304
304
  }, "strip", z.ZodTypeAny, {
305
+ tenantId?: string;
305
306
  constraints?: {
306
307
  maxTrustTier?: TrustTier;
307
308
  deniedDomains?: string[];
308
309
  requiredAttestations?: string[];
309
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
310
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
310
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
311
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
311
312
  };
312
- tenantId?: string;
313
313
  orgId?: string;
314
314
  parentDeployment?: {
315
- regulatoryFramework?: RegulatoryFramework;
316
315
  deploymentId?: string;
316
+ deploymentHash?: string;
317
+ regulatoryFramework?: RegulatoryFramework;
317
318
  maxAllowedTier?: TrustTier;
318
319
  allowedContextTypes?: ContextType[];
319
320
  deployedAt?: Date;
320
321
  deployedBy?: string;
321
- deploymentHash?: string;
322
322
  immutable?: true;
323
323
  };
324
324
  lockedAt?: Date;
325
325
  orgHash?: string;
326
326
  }, {
327
+ tenantId?: string;
327
328
  constraints?: {
328
329
  maxTrustTier?: TrustTier;
329
330
  deniedDomains?: string[];
330
331
  requiredAttestations?: string[];
331
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
332
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
332
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
333
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
333
334
  };
334
- tenantId?: string;
335
335
  orgId?: string;
336
336
  parentDeployment?: {
337
- regulatoryFramework?: RegulatoryFramework;
338
337
  deploymentId?: string;
338
+ deploymentHash?: string;
339
+ regulatoryFramework?: RegulatoryFramework;
339
340
  maxAllowedTier?: TrustTier;
340
341
  allowedContextTypes?: ContextType[];
341
342
  deployedAt?: Date;
342
343
  deployedBy?: string;
343
- deploymentHash?: string;
344
344
  immutable?: true;
345
345
  };
346
346
  lockedAt?: Date;
@@ -352,61 +352,61 @@ export declare const agentContextSchema: z.ZodObject<{
352
352
  contextHash: z.ZodString;
353
353
  }, "strip", z.ZodTypeAny, {
354
354
  agentId?: string;
355
- contextType?: ContextType;
356
355
  createdAt?: Date;
357
- createdBy?: string;
358
356
  parentOrg?: {
357
+ tenantId?: string;
359
358
  constraints?: {
360
359
  maxTrustTier?: TrustTier;
361
360
  deniedDomains?: string[];
362
361
  requiredAttestations?: string[];
363
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
364
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
362
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
363
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
365
364
  };
366
- tenantId?: string;
367
365
  orgId?: string;
368
366
  parentDeployment?: {
369
- regulatoryFramework?: RegulatoryFramework;
370
367
  deploymentId?: string;
368
+ deploymentHash?: string;
369
+ regulatoryFramework?: RegulatoryFramework;
371
370
  maxAllowedTier?: TrustTier;
372
371
  allowedContextTypes?: ContextType[];
373
372
  deployedAt?: Date;
374
373
  deployedBy?: string;
375
- deploymentHash?: string;
376
374
  immutable?: true;
377
375
  };
378
376
  lockedAt?: Date;
379
377
  orgHash?: string;
380
378
  };
379
+ contextType?: ContextType;
380
+ createdBy?: string;
381
381
  contextHash?: string;
382
382
  }, {
383
383
  agentId?: string;
384
- contextType?: ContextType;
385
384
  createdAt?: Date;
386
- createdBy?: string;
387
385
  parentOrg?: {
386
+ tenantId?: string;
388
387
  constraints?: {
389
388
  maxTrustTier?: TrustTier;
390
389
  deniedDomains?: string[];
391
390
  requiredAttestations?: string[];
392
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
393
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
391
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
392
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
394
393
  };
395
- tenantId?: string;
396
394
  orgId?: string;
397
395
  parentDeployment?: {
398
- regulatoryFramework?: RegulatoryFramework;
399
396
  deploymentId?: string;
397
+ deploymentHash?: string;
398
+ regulatoryFramework?: RegulatoryFramework;
400
399
  maxAllowedTier?: TrustTier;
401
400
  allowedContextTypes?: ContextType[];
402
401
  deployedAt?: Date;
403
402
  deployedBy?: string;
404
- deploymentHash?: string;
405
403
  immutable?: true;
406
404
  };
407
405
  lockedAt?: Date;
408
406
  orgHash?: string;
409
407
  };
408
+ contextType?: ContextType;
409
+ createdBy?: string;
410
410
  contextHash?: string;
411
411
  }>;
412
412
  /**
@@ -440,22 +440,22 @@ export declare const operationContextSchema: z.ZodObject<{
440
440
  deployedBy: z.ZodString;
441
441
  immutable: z.ZodLiteral<true>;
442
442
  }, "strip", z.ZodTypeAny, {
443
- regulatoryFramework?: RegulatoryFramework;
444
443
  deploymentId?: string;
444
+ deploymentHash?: string;
445
+ regulatoryFramework?: RegulatoryFramework;
445
446
  maxAllowedTier?: TrustTier;
446
447
  allowedContextTypes?: ContextType[];
447
448
  deployedAt?: Date;
448
449
  deployedBy?: string;
449
- deploymentHash?: string;
450
450
  immutable?: true;
451
451
  }, {
452
- regulatoryFramework?: RegulatoryFramework;
453
452
  deploymentId?: string;
453
+ deploymentHash?: string;
454
+ regulatoryFramework?: RegulatoryFramework;
454
455
  maxAllowedTier?: TrustTier;
455
456
  allowedContextTypes?: ContextType[];
456
457
  deployedAt?: Date;
457
458
  deployedBy?: string;
458
- deploymentHash?: string;
459
459
  immutable?: true;
460
460
  }>;
461
461
  lockedAt: z.ZodOptional<z.ZodDate>;
@@ -469,56 +469,56 @@ export declare const operationContextSchema: z.ZodObject<{
469
469
  maxTrustTier?: TrustTier;
470
470
  deniedDomains?: string[];
471
471
  requiredAttestations?: string[];
472
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
473
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
472
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
473
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
474
474
  }, {
475
475
  maxTrustTier?: TrustTier;
476
476
  deniedDomains?: string[];
477
477
  requiredAttestations?: string[];
478
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
479
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
478
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
479
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
480
480
  }>;
481
481
  orgHash: z.ZodString;
482
482
  }, "strip", z.ZodTypeAny, {
483
+ tenantId?: string;
483
484
  constraints?: {
484
485
  maxTrustTier?: TrustTier;
485
486
  deniedDomains?: string[];
486
487
  requiredAttestations?: string[];
487
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
488
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
488
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
489
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
489
490
  };
490
- tenantId?: string;
491
491
  orgId?: string;
492
492
  parentDeployment?: {
493
- regulatoryFramework?: RegulatoryFramework;
494
493
  deploymentId?: string;
494
+ deploymentHash?: string;
495
+ regulatoryFramework?: RegulatoryFramework;
495
496
  maxAllowedTier?: TrustTier;
496
497
  allowedContextTypes?: ContextType[];
497
498
  deployedAt?: Date;
498
499
  deployedBy?: string;
499
- deploymentHash?: string;
500
500
  immutable?: true;
501
501
  };
502
502
  lockedAt?: Date;
503
503
  orgHash?: string;
504
504
  }, {
505
+ tenantId?: string;
505
506
  constraints?: {
506
507
  maxTrustTier?: TrustTier;
507
508
  deniedDomains?: string[];
508
509
  requiredAttestations?: string[];
509
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
510
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
510
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
511
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
511
512
  };
512
- tenantId?: string;
513
513
  orgId?: string;
514
514
  parentDeployment?: {
515
- regulatoryFramework?: RegulatoryFramework;
516
515
  deploymentId?: string;
516
+ deploymentHash?: string;
517
+ regulatoryFramework?: RegulatoryFramework;
517
518
  maxAllowedTier?: TrustTier;
518
519
  allowedContextTypes?: ContextType[];
519
520
  deployedAt?: Date;
520
521
  deployedBy?: string;
521
- deploymentHash?: string;
522
522
  immutable?: true;
523
523
  };
524
524
  lockedAt?: Date;
@@ -530,61 +530,61 @@ export declare const operationContextSchema: z.ZodObject<{
530
530
  contextHash: z.ZodString;
531
531
  }, "strip", z.ZodTypeAny, {
532
532
  agentId?: string;
533
- contextType?: ContextType;
534
533
  createdAt?: Date;
535
- createdBy?: string;
536
534
  parentOrg?: {
535
+ tenantId?: string;
537
536
  constraints?: {
538
537
  maxTrustTier?: TrustTier;
539
538
  deniedDomains?: string[];
540
539
  requiredAttestations?: string[];
541
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
542
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
540
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
541
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
543
542
  };
544
- tenantId?: string;
545
543
  orgId?: string;
546
544
  parentDeployment?: {
547
- regulatoryFramework?: RegulatoryFramework;
548
545
  deploymentId?: string;
546
+ deploymentHash?: string;
547
+ regulatoryFramework?: RegulatoryFramework;
549
548
  maxAllowedTier?: TrustTier;
550
549
  allowedContextTypes?: ContextType[];
551
550
  deployedAt?: Date;
552
551
  deployedBy?: string;
553
- deploymentHash?: string;
554
552
  immutable?: true;
555
553
  };
556
554
  lockedAt?: Date;
557
555
  orgHash?: string;
558
556
  };
557
+ contextType?: ContextType;
558
+ createdBy?: string;
559
559
  contextHash?: string;
560
560
  }, {
561
561
  agentId?: string;
562
- contextType?: ContextType;
563
562
  createdAt?: Date;
564
- createdBy?: string;
565
563
  parentOrg?: {
564
+ tenantId?: string;
566
565
  constraints?: {
567
566
  maxTrustTier?: TrustTier;
568
567
  deniedDomains?: string[];
569
568
  requiredAttestations?: string[];
570
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
571
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
569
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
570
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
572
571
  };
573
- tenantId?: string;
574
572
  orgId?: string;
575
573
  parentDeployment?: {
576
- regulatoryFramework?: RegulatoryFramework;
577
574
  deploymentId?: string;
575
+ deploymentHash?: string;
576
+ regulatoryFramework?: RegulatoryFramework;
578
577
  maxAllowedTier?: TrustTier;
579
578
  allowedContextTypes?: ContextType[];
580
579
  deployedAt?: Date;
581
580
  deployedBy?: string;
582
- deploymentHash?: string;
583
581
  immutable?: true;
584
582
  };
585
583
  lockedAt?: Date;
586
584
  orgHash?: string;
587
585
  };
586
+ contextType?: ContextType;
587
+ createdBy?: string;
588
588
  contextHash?: string;
589
589
  }>;
590
590
  requestMetadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -593,75 +593,75 @@ export declare const operationContextSchema: z.ZodObject<{
593
593
  expiresAt: z.ZodDate;
594
594
  ephemeral: z.ZodLiteral<true>;
595
595
  }, "strip", z.ZodTypeAny, {
596
+ correlationId?: string;
596
597
  expiresAt?: Date;
597
598
  startedAt?: Date;
598
- correlationId?: string;
599
599
  operationId?: string;
600
600
  parentAgent?: {
601
601
  agentId?: string;
602
- contextType?: ContextType;
603
602
  createdAt?: Date;
604
- createdBy?: string;
605
603
  parentOrg?: {
604
+ tenantId?: string;
606
605
  constraints?: {
607
606
  maxTrustTier?: TrustTier;
608
607
  deniedDomains?: string[];
609
608
  requiredAttestations?: string[];
610
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
611
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
609
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
610
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
612
611
  };
613
- tenantId?: string;
614
612
  orgId?: string;
615
613
  parentDeployment?: {
616
- regulatoryFramework?: RegulatoryFramework;
617
614
  deploymentId?: string;
615
+ deploymentHash?: string;
616
+ regulatoryFramework?: RegulatoryFramework;
618
617
  maxAllowedTier?: TrustTier;
619
618
  allowedContextTypes?: ContextType[];
620
619
  deployedAt?: Date;
621
620
  deployedBy?: string;
622
- deploymentHash?: string;
623
621
  immutable?: true;
624
622
  };
625
623
  lockedAt?: Date;
626
624
  orgHash?: string;
627
625
  };
626
+ contextType?: ContextType;
627
+ createdBy?: string;
628
628
  contextHash?: string;
629
629
  };
630
630
  requestMetadata?: Record<string, unknown>;
631
631
  ephemeral?: true;
632
632
  }, {
633
+ correlationId?: string;
633
634
  expiresAt?: Date;
634
635
  startedAt?: Date;
635
- correlationId?: string;
636
636
  operationId?: string;
637
637
  parentAgent?: {
638
638
  agentId?: string;
639
- contextType?: ContextType;
640
639
  createdAt?: Date;
641
- createdBy?: string;
642
640
  parentOrg?: {
641
+ tenantId?: string;
643
642
  constraints?: {
644
643
  maxTrustTier?: TrustTier;
645
644
  deniedDomains?: string[];
646
645
  requiredAttestations?: string[];
647
- dataClassification?: "internal" | "public" | "confidential" | "restricted";
648
- auditLevel?: "standard" | "minimal" | "comprehensive" | "forensic";
646
+ dataClassification?: "public" | "internal" | "confidential" | "restricted";
647
+ auditLevel?: "minimal" | "standard" | "comprehensive" | "forensic";
649
648
  };
650
- tenantId?: string;
651
649
  orgId?: string;
652
650
  parentDeployment?: {
653
- regulatoryFramework?: RegulatoryFramework;
654
651
  deploymentId?: string;
652
+ deploymentHash?: string;
653
+ regulatoryFramework?: RegulatoryFramework;
655
654
  maxAllowedTier?: TrustTier;
656
655
  allowedContextTypes?: ContextType[];
657
656
  deployedAt?: Date;
658
657
  deployedBy?: string;
659
- deploymentHash?: string;
660
658
  immutable?: true;
661
659
  };
662
660
  lockedAt?: Date;
663
661
  orgHash?: string;
664
662
  };
663
+ contextType?: ContextType;
664
+ createdBy?: string;
665
665
  contextHash?: string;
666
666
  };
667
667
  requestMetadata?: Record<string, unknown>;
@@ -699,27 +699,27 @@ export declare const trustWeightsSchema: z.ZodEffects<z.ZodObject<{
699
699
  governance: z.ZodNumber;
700
700
  context: z.ZodNumber;
701
701
  }, "strip", z.ZodTypeAny, {
702
- context?: number;
703
702
  governance?: number;
704
703
  capability?: number;
704
+ context?: number;
705
705
  observability?: number;
706
706
  behavior?: number;
707
707
  }, {
708
- context?: number;
709
708
  governance?: number;
710
709
  capability?: number;
710
+ context?: number;
711
711
  observability?: number;
712
712
  behavior?: number;
713
713
  }>, {
714
- context?: number;
715
714
  governance?: number;
716
715
  capability?: number;
716
+ context?: number;
717
717
  observability?: number;
718
718
  behavior?: number;
719
719
  }, {
720
- context?: number;
721
720
  governance?: number;
722
721
  capability?: number;
722
+ context?: number;
723
723
  observability?: number;
724
724
  behavior?: number;
725
725
  }>;
@@ -754,27 +754,27 @@ export declare const trustPresetSchema: z.ZodObject<{
754
754
  governance: z.ZodNumber;
755
755
  context: z.ZodNumber;
756
756
  }, "strip", z.ZodTypeAny, {
757
- context?: number;
758
757
  governance?: number;
759
758
  capability?: number;
759
+ context?: number;
760
760
  observability?: number;
761
761
  behavior?: number;
762
762
  }, {
763
- context?: number;
764
763
  governance?: number;
765
764
  capability?: number;
765
+ context?: number;
766
766
  observability?: number;
767
767
  behavior?: number;
768
768
  }>, {
769
- context?: number;
770
769
  governance?: number;
771
770
  capability?: number;
771
+ context?: number;
772
772
  observability?: number;
773
773
  behavior?: number;
774
774
  }, {
775
- context?: number;
776
775
  governance?: number;
777
776
  capability?: number;
777
+ context?: number;
778
778
  observability?: number;
779
779
  behavior?: number;
780
780
  }>;
@@ -787,15 +787,15 @@ export declare const trustPresetSchema: z.ZodObject<{
787
787
  governance: z.ZodOptional<z.ZodNumber>;
788
788
  context: z.ZodOptional<z.ZodNumber>;
789
789
  }, "strip", z.ZodTypeAny, {
790
- context?: number;
791
790
  governance?: number;
792
791
  capability?: number;
792
+ context?: number;
793
793
  observability?: number;
794
794
  behavior?: number;
795
795
  }, {
796
- context?: number;
797
796
  governance?: number;
798
797
  capability?: number;
798
+ context?: number;
799
799
  observability?: number;
800
800
  behavior?: number;
801
801
  }>>;
@@ -804,56 +804,56 @@ export declare const trustPresetSchema: z.ZodObject<{
804
804
  presetHash: z.ZodString;
805
805
  comment: z.ZodOptional<z.ZodString>;
806
806
  }, "strip", z.ZodTypeAny, {
807
+ source?: "vorion" | "car" | "axiom";
807
808
  name?: string;
808
809
  version?: number;
809
810
  description?: string;
810
- source?: "vorion" | "axiom" | "car";
811
811
  createdAt?: Date;
812
812
  createdBy?: string;
813
- presetHash?: string;
814
813
  presetId?: string;
815
814
  weights?: {
816
- context?: number;
817
815
  governance?: number;
818
816
  capability?: number;
817
+ context?: number;
819
818
  observability?: number;
820
819
  behavior?: number;
821
820
  };
822
821
  parentPresetId?: string;
823
822
  parentHash?: string;
824
823
  derivationDelta?: {
825
- context?: number;
826
824
  governance?: number;
827
825
  capability?: number;
826
+ context?: number;
828
827
  observability?: number;
829
828
  behavior?: number;
830
829
  };
830
+ presetHash?: string;
831
831
  comment?: string;
832
832
  }, {
833
+ source?: "vorion" | "car" | "axiom";
833
834
  name?: string;
834
835
  version?: number;
835
836
  description?: string;
836
- source?: "vorion" | "axiom" | "car";
837
837
  createdAt?: Date;
838
838
  createdBy?: string;
839
- presetHash?: string;
840
839
  presetId?: string;
841
840
  weights?: {
842
- context?: number;
843
841
  governance?: number;
844
842
  capability?: number;
843
+ context?: number;
845
844
  observability?: number;
846
845
  behavior?: number;
847
846
  };
848
847
  parentPresetId?: string;
849
848
  parentHash?: string;
850
849
  derivationDelta?: {
851
- context?: number;
852
850
  governance?: number;
853
851
  capability?: number;
852
+ context?: number;
854
853
  observability?: number;
855
854
  behavior?: number;
856
855
  };
856
+ presetHash?: string;
857
857
  comment?: string;
858
858
  }>;
859
859
  /**
@@ -875,18 +875,18 @@ export declare const presetLineageSchema: z.ZodObject<{
875
875
  verifiedAt: z.ZodOptional<z.ZodDate>;
876
876
  verifiedBy: z.ZodOptional<z.ZodString>;
877
877
  }, "strip", z.ZodTypeAny, {
878
- leafPresetId?: string;
878
+ verifiedAt?: Date;
879
879
  chain?: string[];
880
+ leafPresetId?: string;
880
881
  hashes?: string[];
881
882
  verified?: boolean;
882
- verifiedAt?: Date;
883
883
  verifiedBy?: string;
884
884
  }, {
885
- leafPresetId?: string;
885
+ verifiedAt?: Date;
886
886
  chain?: string[];
887
+ leafPresetId?: string;
887
888
  hashes?: string[];
888
889
  verified?: boolean;
889
- verifiedAt?: Date;
890
890
  verifiedBy?: string;
891
891
  }>;
892
892
  /**
@@ -912,19 +912,19 @@ export declare const agentProvenanceSchema: z.ZodObject<{
912
912
  }, "strip", z.ZodTypeAny, {
913
913
  agentId?: string;
914
914
  createdAt?: Date;
915
+ provenanceHash?: string;
915
916
  createdBy?: string;
916
917
  creationType?: CreationType;
917
918
  parentAgentId?: string;
918
919
  parentProvenanceHash?: string;
919
- provenanceHash?: string;
920
920
  }, {
921
921
  agentId?: string;
922
922
  createdAt?: Date;
923
+ provenanceHash?: string;
923
924
  createdBy?: string;
924
925
  creationType?: CreationType;
925
926
  parentAgentId?: string;
926
927
  parentProvenanceHash?: string;
927
- provenanceHash?: string;
928
928
  }>;
929
929
  /**
930
930
  * Creation modifier policy (MUTABLE - can evolve independently)
@@ -1059,8 +1059,8 @@ export declare const modifierEvaluationRecordSchema: z.ZodObject<{
1059
1059
  evaluatedAt: z.ZodDate;
1060
1060
  evaluationHash: z.ZodString;
1061
1061
  }, "strip", z.ZodTypeAny, {
1062
- agentId?: string;
1063
1062
  evaluatedAt?: Date;
1063
+ agentId?: string;
1064
1064
  policyId?: string;
1065
1065
  provenanceHash?: string;
1066
1066
  evaluationId?: string;
@@ -1069,8 +1069,8 @@ export declare const modifierEvaluationRecordSchema: z.ZodObject<{
1069
1069
  conditionsMatched?: string[];
1070
1070
  evaluationHash?: string;
1071
1071
  }, {
1072
- agentId?: string;
1073
1072
  evaluatedAt?: Date;
1073
+ agentId?: string;
1074
1074
  policyId?: string;
1075
1075
  provenanceHash?: string;
1076
1076
  evaluationId?: string;
@@ -1141,6 +1141,7 @@ export declare const trustComputationEventSchema: z.ZodObject<{
1141
1141
  }, "strip", z.ZodTypeAny, {
1142
1142
  timestamp?: Date;
1143
1143
  agentId?: string;
1144
+ contextType?: ContextType;
1144
1145
  eventId?: string;
1145
1146
  rawScore?: number;
1146
1147
  clampedScore?: number;
@@ -1154,7 +1155,6 @@ export declare const trustComputationEventSchema: z.ZodObject<{
1154
1155
  kernelValidated?: boolean;
1155
1156
  policyValidated?: boolean;
1156
1157
  regulatoryLogged?: boolean;
1157
- contextType?: ContextType;
1158
1158
  contextCeiling?: number;
1159
1159
  effectiveTier?: TrustTier;
1160
1160
  eventHash?: string;
@@ -1162,6 +1162,7 @@ export declare const trustComputationEventSchema: z.ZodObject<{
1162
1162
  }, {
1163
1163
  timestamp?: Date;
1164
1164
  agentId?: string;
1165
+ contextType?: ContextType;
1165
1166
  eventId?: string;
1166
1167
  rawScore?: number;
1167
1168
  clampedScore?: number;
@@ -1175,7 +1176,6 @@ export declare const trustComputationEventSchema: z.ZodObject<{
1175
1176
  kernelValidated?: boolean;
1176
1177
  policyValidated?: boolean;
1177
1178
  regulatoryLogged?: boolean;
1178
- contextType?: ContextType;
1179
1179
  contextCeiling?: number;
1180
1180
  effectiveTier?: TrustTier;
1181
1181
  eventHash?: string;
@@ -1222,15 +1222,15 @@ export declare const regulatoryAuditEntrySchema: z.ZodObject<{
1222
1222
  }, "strip", z.ZodTypeAny, {
1223
1223
  timestamp?: Date;
1224
1224
  agentId?: string;
1225
+ regulatoryFramework?: RegulatoryFramework;
1225
1226
  rawScore?: number;
1226
1227
  clampedScore?: number;
1227
- complianceStatus?: "violation" | "warning" | "compliant";
1228
1228
  entryId?: string;
1229
1229
  variance?: number;
1230
1230
  varianceAnomaly?: boolean;
1231
1231
  frequencyAnomaly?: boolean;
1232
1232
  patternAnomaly?: boolean;
1233
- regulatoryFramework?: RegulatoryFramework;
1233
+ complianceStatus?: "warning" | "compliant" | "violation";
1234
1234
  retentionRequired?: boolean;
1235
1235
  retentionUntil?: Date;
1236
1236
  entryHash?: string;
@@ -1239,15 +1239,15 @@ export declare const regulatoryAuditEntrySchema: z.ZodObject<{
1239
1239
  }, {
1240
1240
  timestamp?: Date;
1241
1241
  agentId?: string;
1242
+ regulatoryFramework?: RegulatoryFramework;
1242
1243
  rawScore?: number;
1243
1244
  clampedScore?: number;
1244
- complianceStatus?: "violation" | "warning" | "compliant";
1245
1245
  entryId?: string;
1246
1246
  variance?: number;
1247
1247
  varianceAnomaly?: boolean;
1248
1248
  frequencyAnomaly?: boolean;
1249
1249
  patternAnomaly?: boolean;
1250
- regulatoryFramework?: RegulatoryFramework;
1250
+ complianceStatus?: "warning" | "compliant" | "violation";
1251
1251
  retentionRequired?: boolean;
1252
1252
  retentionUntil?: Date;
1253
1253
  entryHash?: string;
@@ -1322,63 +1322,63 @@ export declare const roleGatePolicySchema: z.ZodObject<{
1322
1322
  }>>;
1323
1323
  requiresAttestation: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
1324
1324
  }, "strip", z.ZodTypeAny, {
1325
+ roles?: AgentRole[];
1326
+ tiers?: TrustTier[];
1327
+ contextTypes?: ContextType[];
1328
+ domains?: string[];
1325
1329
  timeWindow?: {
1326
1330
  start?: string;
1327
1331
  end?: string;
1328
1332
  };
1329
- domains?: string[];
1330
1333
  requiresAttestation?: string[];
1334
+ }, {
1331
1335
  roles?: AgentRole[];
1332
1336
  tiers?: TrustTier[];
1333
1337
  contextTypes?: ContextType[];
1334
- }, {
1338
+ domains?: string[];
1335
1339
  timeWindow?: {
1336
1340
  start?: string;
1337
1341
  end?: string;
1338
1342
  };
1339
- domains?: string[];
1340
1343
  requiresAttestation?: string[];
1341
- roles?: AgentRole[];
1342
- tiers?: TrustTier[];
1343
- contextTypes?: ContextType[];
1344
1344
  }>;
1345
1345
  action: z.ZodEnum<["ALLOW", "DENY", "ESCALATE"]>;
1346
1346
  priority: z.ZodNumber;
1347
1347
  reason: z.ZodString;
1348
1348
  }, "strip", z.ZodTypeAny, {
1349
- reason?: string;
1350
- name?: string;
1351
1349
  action?: "ALLOW" | "DENY" | "ESCALATE";
1350
+ name?: string;
1352
1351
  ruleId?: string;
1352
+ reason?: string;
1353
+ priority?: number;
1353
1354
  condition?: {
1355
+ roles?: AgentRole[];
1356
+ tiers?: TrustTier[];
1357
+ contextTypes?: ContextType[];
1358
+ domains?: string[];
1354
1359
  timeWindow?: {
1355
1360
  start?: string;
1356
1361
  end?: string;
1357
1362
  };
1358
- domains?: string[];
1359
1363
  requiresAttestation?: string[];
1360
- roles?: AgentRole[];
1361
- tiers?: TrustTier[];
1362
- contextTypes?: ContextType[];
1363
1364
  };
1364
- priority?: number;
1365
1365
  }, {
1366
- reason?: string;
1367
- name?: string;
1368
1366
  action?: "ALLOW" | "DENY" | "ESCALATE";
1367
+ name?: string;
1369
1368
  ruleId?: string;
1369
+ reason?: string;
1370
+ priority?: number;
1370
1371
  condition?: {
1372
+ roles?: AgentRole[];
1373
+ tiers?: TrustTier[];
1374
+ contextTypes?: ContextType[];
1375
+ domains?: string[];
1371
1376
  timeWindow?: {
1372
1377
  start?: string;
1373
1378
  end?: string;
1374
1379
  };
1375
- domains?: string[];
1376
1380
  requiresAttestation?: string[];
1377
- roles?: AgentRole[];
1378
- tiers?: TrustTier[];
1379
- contextTypes?: ContextType[];
1380
1381
  };
1381
- priority?: number;
1382
1382
  }>, "many">;
1383
1383
  effectiveFrom: z.ZodDate;
1384
1384
  effectiveUntil: z.ZodOptional<z.ZodDate>;
@@ -1388,22 +1388,22 @@ export declare const roleGatePolicySchema: z.ZodObject<{
1388
1388
  }, "strip", z.ZodTypeAny, {
1389
1389
  version?: number;
1390
1390
  rules?: {
1391
- reason?: string;
1392
- name?: string;
1393
1391
  action?: "ALLOW" | "DENY" | "ESCALATE";
1392
+ name?: string;
1394
1393
  ruleId?: string;
1394
+ reason?: string;
1395
+ priority?: number;
1395
1396
  condition?: {
1397
+ roles?: AgentRole[];
1398
+ tiers?: TrustTier[];
1399
+ contextTypes?: ContextType[];
1400
+ domains?: string[];
1396
1401
  timeWindow?: {
1397
1402
  start?: string;
1398
1403
  end?: string;
1399
1404
  };
1400
- domains?: string[];
1401
1405
  requiresAttestation?: string[];
1402
- roles?: AgentRole[];
1403
- tiers?: TrustTier[];
1404
- contextTypes?: ContextType[];
1405
1406
  };
1406
- priority?: number;
1407
1407
  }[];
1408
1408
  policyId?: string;
1409
1409
  createdAt?: Date;
@@ -1414,22 +1414,22 @@ export declare const roleGatePolicySchema: z.ZodObject<{
1414
1414
  }, {
1415
1415
  version?: number;
1416
1416
  rules?: {
1417
- reason?: string;
1418
- name?: string;
1419
1417
  action?: "ALLOW" | "DENY" | "ESCALATE";
1418
+ name?: string;
1420
1419
  ruleId?: string;
1420
+ reason?: string;
1421
+ priority?: number;
1421
1422
  condition?: {
1423
+ roles?: AgentRole[];
1424
+ tiers?: TrustTier[];
1425
+ contextTypes?: ContextType[];
1426
+ domains?: string[];
1422
1427
  timeWindow?: {
1423
1428
  start?: string;
1424
1429
  end?: string;
1425
1430
  };
1426
- domains?: string[];
1427
1431
  requiresAttestation?: string[];
1428
- roles?: AgentRole[];
1429
- tiers?: TrustTier[];
1430
- contextTypes?: ContextType[];
1431
1432
  };
1432
- priority?: number;
1433
1433
  }[];
1434
1434
  policyId?: string;
1435
1435
  createdAt?: Date;
@@ -1496,15 +1496,15 @@ export declare const roleGateEvaluationSchema: z.ZodObject<{
1496
1496
  action: z.ZodEnum<["ALLOW", "DENY", "ESCALATE"]>;
1497
1497
  reason: z.ZodString;
1498
1498
  }, "strip", z.ZodTypeAny, {
1499
+ action?: "ALLOW" | "DENY" | "ESCALATE";
1499
1500
  reason?: string;
1500
1501
  valid?: boolean;
1501
- action?: "ALLOW" | "DENY" | "ESCALATE";
1502
1502
  appliedRuleId?: string;
1503
1503
  appliedPolicyVersion?: number;
1504
1504
  }, {
1505
+ action?: "ALLOW" | "DENY" | "ESCALATE";
1505
1506
  reason?: string;
1506
1507
  valid?: boolean;
1507
- action?: "ALLOW" | "DENY" | "ESCALATE";
1508
1508
  appliedRuleId?: string;
1509
1509
  appliedPolicyVersion?: number;
1510
1510
  }>;
@@ -1531,10 +1531,11 @@ export declare const roleGateEvaluationSchema: z.ZodObject<{
1531
1531
  decidedAt: z.ZodDate;
1532
1532
  evaluationHash: z.ZodString;
1533
1533
  }, "strip", z.ZodTypeAny, {
1534
- tier?: TrustTier;
1535
- decision?: "ALLOW" | "DENY" | "ESCALATE";
1536
1534
  timestamp?: Date;
1537
1535
  agentId?: string;
1536
+ tier?: TrustTier;
1537
+ decision?: "ALLOW" | "DENY" | "ESCALATE";
1538
+ decidedAt?: Date;
1538
1539
  role?: AgentRole;
1539
1540
  evaluationId?: string;
1540
1541
  evaluationHash?: string;
@@ -1544,9 +1545,9 @@ export declare const roleGateEvaluationSchema: z.ZodObject<{
1544
1545
  matrixAllows?: boolean;
1545
1546
  };
1546
1547
  policyResult?: {
1548
+ action?: "ALLOW" | "DENY" | "ESCALATE";
1547
1549
  reason?: string;
1548
1550
  valid?: boolean;
1549
- action?: "ALLOW" | "DENY" | "ESCALATE";
1550
1551
  appliedRuleId?: string;
1551
1552
  appliedPolicyVersion?: number;
1552
1553
  };
@@ -1557,12 +1558,12 @@ export declare const roleGateEvaluationSchema: z.ZodObject<{
1557
1558
  overrideSignatures?: string[];
1558
1559
  contextConstraintsMet?: boolean;
1559
1560
  };
1560
- decidedAt?: Date;
1561
1561
  }, {
1562
- tier?: TrustTier;
1563
- decision?: "ALLOW" | "DENY" | "ESCALATE";
1564
1562
  timestamp?: Date;
1565
1563
  agentId?: string;
1564
+ tier?: TrustTier;
1565
+ decision?: "ALLOW" | "DENY" | "ESCALATE";
1566
+ decidedAt?: Date;
1566
1567
  role?: AgentRole;
1567
1568
  evaluationId?: string;
1568
1569
  evaluationHash?: string;
@@ -1572,9 +1573,9 @@ export declare const roleGateEvaluationSchema: z.ZodObject<{
1572
1573
  matrixAllows?: boolean;
1573
1574
  };
1574
1575
  policyResult?: {
1576
+ action?: "ALLOW" | "DENY" | "ESCALATE";
1575
1577
  reason?: string;
1576
1578
  valid?: boolean;
1577
- action?: "ALLOW" | "DENY" | "ESCALATE";
1578
1579
  appliedRuleId?: string;
1579
1580
  appliedPolicyVersion?: number;
1580
1581
  };
@@ -1585,7 +1586,6 @@ export declare const roleGateEvaluationSchema: z.ZodObject<{
1585
1586
  overrideSignatures?: string[];
1586
1587
  contextConstraintsMet?: boolean;
1587
1588
  };
1588
- decidedAt?: Date;
1589
1589
  }>;
1590
1590
  /**
1591
1591
  * Trust score computation configuration
@@ -1613,15 +1613,15 @@ export declare const trustMetricsSchema: z.ZodObject<{
1613
1613
  governance: z.ZodNumber;
1614
1614
  context: z.ZodNumber;
1615
1615
  }, "strip", z.ZodTypeAny, {
1616
- context?: number;
1617
1616
  governance?: number;
1618
1617
  capability?: number;
1618
+ context?: number;
1619
1619
  observability?: number;
1620
1620
  behavior?: number;
1621
1621
  }, {
1622
- context?: number;
1623
1622
  governance?: number;
1624
1623
  capability?: number;
1624
+ context?: number;
1625
1625
  observability?: number;
1626
1626
  behavior?: number;
1627
1627
  }>;
@@ -1678,27 +1678,27 @@ export declare const trustComputationResultSchema: z.ZodObject<{
1678
1678
  governance: z.ZodNumber;
1679
1679
  context: z.ZodNumber;
1680
1680
  }, "strip", z.ZodTypeAny, {
1681
- context?: number;
1682
1681
  governance?: number;
1683
1682
  capability?: number;
1683
+ context?: number;
1684
1684
  observability?: number;
1685
1685
  behavior?: number;
1686
1686
  }, {
1687
- context?: number;
1688
1687
  governance?: number;
1689
1688
  capability?: number;
1689
+ context?: number;
1690
1690
  observability?: number;
1691
1691
  behavior?: number;
1692
1692
  }>, {
1693
- context?: number;
1694
1693
  governance?: number;
1695
1694
  capability?: number;
1695
+ context?: number;
1696
1696
  observability?: number;
1697
1697
  behavior?: number;
1698
1698
  }, {
1699
- context?: number;
1700
1699
  governance?: number;
1701
1700
  capability?: number;
1701
+ context?: number;
1702
1702
  observability?: number;
1703
1703
  behavior?: number;
1704
1704
  }>;
@@ -1711,18 +1711,18 @@ export declare const trustComputationResultSchema: z.ZodObject<{
1711
1711
  verifiedAt: z.ZodOptional<z.ZodDate>;
1712
1712
  verifiedBy: z.ZodOptional<z.ZodString>;
1713
1713
  }, "strip", z.ZodTypeAny, {
1714
- leafPresetId?: string;
1714
+ verifiedAt?: Date;
1715
1715
  chain?: string[];
1716
+ leafPresetId?: string;
1716
1717
  hashes?: string[];
1717
1718
  verified?: boolean;
1718
- verifiedAt?: Date;
1719
1719
  verifiedBy?: string;
1720
1720
  }, {
1721
- leafPresetId?: string;
1721
+ verifiedAt?: Date;
1722
1722
  chain?: string[];
1723
+ leafPresetId?: string;
1723
1724
  hashes?: string[];
1724
1725
  verified?: boolean;
1725
- verifiedAt?: Date;
1726
1726
  verifiedBy?: string;
1727
1727
  }>;
1728
1728
  contextValid: z.ZodBoolean;
@@ -1733,6 +1733,7 @@ export declare const trustComputationResultSchema: z.ZodObject<{
1733
1733
  }, "strip", z.ZodTypeAny, {
1734
1734
  agentId?: string;
1735
1735
  finalScore?: number;
1736
+ presetId?: string;
1736
1737
  rawScore?: number;
1737
1738
  ceilingApplied?: boolean;
1738
1739
  ceilingSource?: {
@@ -1741,24 +1742,23 @@ export declare const trustComputationResultSchema: z.ZodObject<{
1741
1742
  constraint?: string;
1742
1743
  };
1743
1744
  effectiveTier?: TrustTier;
1744
- presetId?: string;
1745
1745
  computedAt?: Date;
1746
1746
  ceilingValue?: number;
1747
1747
  creationModifier?: number;
1748
1748
  modifierPolicyVersion?: number;
1749
1749
  weightsUsed?: {
1750
- context?: number;
1751
1750
  governance?: number;
1752
1751
  capability?: number;
1752
+ context?: number;
1753
1753
  observability?: number;
1754
1754
  behavior?: number;
1755
1755
  };
1756
1756
  presetLineage?: {
1757
- leafPresetId?: string;
1757
+ verifiedAt?: Date;
1758
1758
  chain?: string[];
1759
+ leafPresetId?: string;
1759
1760
  hashes?: string[];
1760
1761
  verified?: boolean;
1761
- verifiedAt?: Date;
1762
1762
  verifiedBy?: string;
1763
1763
  };
1764
1764
  contextValid?: boolean;
@@ -1769,6 +1769,7 @@ export declare const trustComputationResultSchema: z.ZodObject<{
1769
1769
  }, {
1770
1770
  agentId?: string;
1771
1771
  finalScore?: number;
1772
+ presetId?: string;
1772
1773
  rawScore?: number;
1773
1774
  ceilingApplied?: boolean;
1774
1775
  ceilingSource?: {
@@ -1777,24 +1778,23 @@ export declare const trustComputationResultSchema: z.ZodObject<{
1777
1778
  constraint?: string;
1778
1779
  };
1779
1780
  effectiveTier?: TrustTier;
1780
- presetId?: string;
1781
1781
  computedAt?: Date;
1782
1782
  ceilingValue?: number;
1783
1783
  creationModifier?: number;
1784
1784
  modifierPolicyVersion?: number;
1785
1785
  weightsUsed?: {
1786
- context?: number;
1787
1786
  governance?: number;
1788
1787
  capability?: number;
1788
+ context?: number;
1789
1789
  observability?: number;
1790
1790
  behavior?: number;
1791
1791
  };
1792
1792
  presetLineage?: {
1793
- leafPresetId?: string;
1793
+ verifiedAt?: Date;
1794
1794
  chain?: string[];
1795
+ leafPresetId?: string;
1795
1796
  hashes?: string[];
1796
1797
  verified?: boolean;
1797
- verifiedAt?: Date;
1798
1798
  verifiedBy?: string;
1799
1799
  };
1800
1800
  contextValid?: boolean;