@vorionsys/contracts 0.1.0

package/dist/v2/enums.js

@@ -0,0 +1,203 @@
+/**
+ * Core enums for the Vorion Platform
+ */
+/**
+ * Trust bands representing autonomy levels (T0-T7)
+ *
+ * The 8-tier system maps trust scores (0-1000) to discrete autonomy levels:
+ * - T0: Sandbox - Isolated testing, no real operations (0-199)
+ * - T1: Observed - Under active observation and supervision (200-349)
+ * - T2: Provisional - Limited operations with strict constraints (350-499)
+ * - T3: Monitored - Continuous monitoring with expanding freedom (500-649)
+ * - T4: Standard - Trusted for routine operations (650-799)
+ * - T5: Trusted - Expanded capabilities with minimal oversight (800-875)
+ * - T6: Certified - Independent operation with audit trail (876-950)
+ * - T7: Autonomous - Full autonomy for mission-critical operations (951-1000)
+ */
+export var TrustBand;
+(function (TrustBand) {
+    TrustBand[TrustBand["T0_SANDBOX"] = 0] = "T0_SANDBOX";
+    TrustBand[TrustBand["T1_OBSERVED"] = 1] = "T1_OBSERVED";
+    TrustBand[TrustBand["T2_PROVISIONAL"] = 2] = "T2_PROVISIONAL";
+    TrustBand[TrustBand["T3_MONITORED"] = 3] = "T3_MONITORED";
+    TrustBand[TrustBand["T4_STANDARD"] = 4] = "T4_STANDARD";
+    TrustBand[TrustBand["T5_TRUSTED"] = 5] = "T5_TRUSTED";
+    TrustBand[TrustBand["T6_CERTIFIED"] = 6] = "T6_CERTIFIED";
+    TrustBand[TrustBand["T7_AUTONOMOUS"] = 7] = "T7_AUTONOMOUS";
+})(TrustBand || (TrustBand = {}));
+/**
+ * Observation tiers - determines maximum trust ceiling
+ * based on system observability
+ *
+ * Per ATSF v2.0 RTA findings:
+ * - WHITE_BOX reduced from 95% to 90% (sleeper agent risk)
+ * - ATTESTED_BOX reduced from 100% to 95% (TEE side-channel risk)
+ * - VERIFIED_BOX added requiring multiple verification layers
+ */
+export var ObservationTier;
+(function (ObservationTier) {
+    /** I/O only - API accessed proprietary models (max 60%) */
+    ObservationTier["BLACK_BOX"] = "BLACK_BOX";
+    /** I/O + logs - Platform-hosted models (max 75%) */
+    ObservationTier["GRAY_BOX"] = "GRAY_BOX";
+    /** Full code access - Open-source models (max 90%, reduced for sleeper risk) */
+    ObservationTier["WHITE_BOX"] = "WHITE_BOX";
+    /** TEE verified - Models in secure enclaves (max 95%, reduced for side-channel risk) */
+    ObservationTier["ATTESTED_BOX"] = "ATTESTED_BOX";
+    /** Full verification: TEE + zkML + interpretability (max 100%) */
+    ObservationTier["VERIFIED_BOX"] = "VERIFIED_BOX";
+})(ObservationTier || (ObservationTier = {}));
+/**
+ * Trust ceiling values for each observation tier (0-1000 scale)
+ * Updated per ATSF v2.0 Red Team Assessment findings
+ */
+export const OBSERVATION_CEILINGS = {
+    [ObservationTier.BLACK_BOX]: 600,
+    [ObservationTier.GRAY_BOX]: 750,
+    [ObservationTier.WHITE_BOX]: 900, // Reduced from 950 (sleeper agent risk)
+    [ObservationTier.ATTESTED_BOX]: 950, // Reduced from 1000 (TEE side-channel risk)
+    [ObservationTier.VERIFIED_BOX]: 1000, // New: requires full verification stack
+};
+/**
+ * Data sensitivity levels for intent classification
+ */
+export var DataSensitivity;
+(function (DataSensitivity) {
+    DataSensitivity["PUBLIC"] = "PUBLIC";
+    DataSensitivity["INTERNAL"] = "INTERNAL";
+    DataSensitivity["CONFIDENTIAL"] = "CONFIDENTIAL";
+    DataSensitivity["RESTRICTED"] = "RESTRICTED";
+})(DataSensitivity || (DataSensitivity = {}));
+/**
+ * Action reversibility classification
+ */
+export var Reversibility;
+(function (Reversibility) {
+    Reversibility["REVERSIBLE"] = "REVERSIBLE";
+    Reversibility["PARTIALLY_REVERSIBLE"] = "PARTIALLY_REVERSIBLE";
+    Reversibility["IRREVERSIBLE"] = "IRREVERSIBLE";
+})(Reversibility || (Reversibility = {}));
+/**
+ * Action types for categorizing intents
+ */
+export var ActionType;
+(function (ActionType) {
+    ActionType["READ"] = "read";
+    ActionType["WRITE"] = "write";
+    ActionType["DELETE"] = "delete";
+    ActionType["EXECUTE"] = "execute";
+    ActionType["COMMUNICATE"] = "communicate";
+    ActionType["TRANSFER"] = "transfer";
+})(ActionType || (ActionType = {}));
+/**
+ * Proof event types for the audit trail
+ */
+export var ProofEventType;
+(function (ProofEventType) {
+    ProofEventType["INTENT_RECEIVED"] = "intent_received";
+    ProofEventType["DECISION_MADE"] = "decision_made";
+    ProofEventType["TRUST_DELTA"] = "trust_delta";
+    ProofEventType["EXECUTION_STARTED"] = "execution_started";
+    ProofEventType["EXECUTION_COMPLETED"] = "execution_completed";
+    ProofEventType["EXECUTION_FAILED"] = "execution_failed";
+    ProofEventType["INCIDENT_DETECTED"] = "incident_detected";
+    ProofEventType["ROLLBACK_INITIATED"] = "rollback_initiated";
+    ProofEventType["COMPONENT_REGISTERED"] = "component_registered";
+    ProofEventType["COMPONENT_UPDATED"] = "component_updated";
+})(ProofEventType || (ProofEventType = {}));
+/**
+ * Component types in the registry
+ */
+export var ComponentType;
+(function (ComponentType) {
+    ComponentType["AGENT"] = "agent";
+    ComponentType["SERVICE"] = "service";
+    ComponentType["ADAPTER"] = "adapter";
+    ComponentType["POLICY_BUNDLE"] = "policy_bundle";
+})(ComponentType || (ComponentType = {}));
+/**
+ * Component lifecycle status
+ */
+export var ComponentStatus;
+(function (ComponentStatus) {
+    ComponentStatus["ACTIVE"] = "active";
+    ComponentStatus["DEPRECATED"] = "deprecated";
+    ComponentStatus["RETIRED"] = "retired";
+})(ComponentStatus || (ComponentStatus = {}));
+/**
+ * Approval requirement types
+ */
+export var ApprovalType;
+(function (ApprovalType) {
+    ApprovalType["NONE"] = "none";
+    ApprovalType["HUMAN_REVIEW"] = "human_review";
+    ApprovalType["AUTOMATED_CHECK"] = "automated_check";
+    ApprovalType["MULTI_PARTY"] = "multi_party";
+})(ApprovalType || (ApprovalType = {}));
+/**
+ * Decision Tier - Three-tier governance model for fluid decisions
+ *
+ * Part of Fluid Governance Architecture:
+ * - GREEN: Auto-approved within constraints, proceed immediately
+ * - YELLOW: Requires refinement or human review before proceeding
+ * - RED: Denied, cannot proceed (hard policy violation)
+ *
+ * YELLOW decisions support iterative refinement, allowing agents to
+ * modify their request rather than receiving a binary allow/deny.
+ */
+export var DecisionTier;
+(function (DecisionTier) {
+    /** Auto-approved - proceed with constraints */
+    DecisionTier["GREEN"] = "GREEN";
+    /** Requires refinement or review - can be upgraded to GREEN */
+    DecisionTier["YELLOW"] = "YELLOW";
+    /** Denied - hard policy violation, cannot proceed */
+    DecisionTier["RED"] = "RED";
+})(DecisionTier || (DecisionTier = {}));
+/**
+ * Refinement action types for YELLOW decisions
+ */
+export var RefinementAction;
+(function (RefinementAction) {
+    /** Reduce the scope of the request */
+    RefinementAction["REDUCE_SCOPE"] = "REDUCE_SCOPE";
+    /** Add safety constraints */
+    RefinementAction["ADD_CONSTRAINTS"] = "ADD_CONSTRAINTS";
+    /** Request human approval */
+    RefinementAction["REQUEST_APPROVAL"] = "REQUEST_APPROVAL";
+    /** Provide additional context/justification */
+    RefinementAction["PROVIDE_CONTEXT"] = "PROVIDE_CONTEXT";
+    /** Split into smaller sub-requests */
+    RefinementAction["DECOMPOSE"] = "DECOMPOSE";
+    /** Wait for trust score to improve */
+    RefinementAction["WAIT_FOR_TRUST"] = "WAIT_FOR_TRUST";
+})(RefinementAction || (RefinementAction = {}));
+/**
+ * Workflow state for fluid governance
+ */
+export var WorkflowState;
+(function (WorkflowState) {
+    /** Initial submission of intent */
+    WorkflowState["SUBMITTED"] = "SUBMITTED";
+    /** Being evaluated by decision engine */
+    WorkflowState["EVALUATING"] = "EVALUATING";
+    /** GREEN - approved and ready for execution */
+    WorkflowState["APPROVED"] = "APPROVED";
+    /** YELLOW - awaiting refinement */
+    WorkflowState["PENDING_REFINEMENT"] = "PENDING_REFINEMENT";
+    /** YELLOW - awaiting human review */
+    WorkflowState["PENDING_REVIEW"] = "PENDING_REVIEW";
+    /** RED - denied */
+    WorkflowState["DENIED"] = "DENIED";
+    /** Currently executing */
+    WorkflowState["EXECUTING"] = "EXECUTING";
+    /** Completed successfully */
+    WorkflowState["COMPLETED"] = "COMPLETED";
+    /** Failed during execution */
+    WorkflowState["FAILED"] = "FAILED";
+    /** Cancelled by user/system */
+    WorkflowState["CANCELLED"] = "CANCELLED";
+    /** Expired before completion */
+    WorkflowState["EXPIRED"] = "EXPIRED";
+})(WorkflowState || (WorkflowState = {}));
+//# sourceMappingURL=enums.js.map

package/dist/v2/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../src/v2/enums.ts"],"names":[],"mappings":"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"}

package/dist/v2/evidence.d.ts

@@ -0,0 +1,368 @@
+/**
+ * Vorion v2 Evidence Schema (ERPL)
+ *
+ * Defines evidence collection and preservation per ERPL spec.
+ * Supports forensic completeness requirements.
+ */
+import { z } from 'zod';
+export declare const EvidenceTypeSchema: z.ZodEnum<["INTENT_SUBMISSION", "AUTHORIZATION_DECISION", "EXECUTION_START", "EXECUTION_STEP", "EXECUTION_COMPLETE", "TOOL_INVOCATION", "TOOL_RESPONSE", "TRUST_COMPUTATION", "TRUST_DELTA", "POLICY_EVALUATION", "CONSTRAINT_APPLICATION", "ESCALATION_REQUEST", "ESCALATION_RESPONSE", "VIOLATION_DETECTED", "INCIDENT_REPORT", "HUMAN_INTERVENTION", "SYSTEM_EVENT", "AUDIT_CHECKPOINT"]>;
+export declare const EvidenceClassificationSchema: z.ZodEnum<["ROUTINE", "SIGNIFICANT", "COMPLIANCE_RELEVANT", "SECURITY_RELEVANT", "INCIDENT_RELATED", "LEGAL_HOLD"]>;
+export declare const EvidenceItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    schemaVersion: z.ZodDefault<z.ZodString>;
+    correlationId: z.ZodString;
+    type: z.ZodEnum<["INTENT_SUBMISSION", "AUTHORIZATION_DECISION", "EXECUTION_START", "EXECUTION_STEP", "EXECUTION_COMPLETE", "TOOL_INVOCATION", "TOOL_RESPONSE", "TRUST_COMPUTATION", "TRUST_DELTA", "POLICY_EVALUATION", "CONSTRAINT_APPLICATION", "ESCALATION_REQUEST", "ESCALATION_RESPONSE", "VIOLATION_DETECTED", "INCIDENT_REPORT", "HUMAN_INTERVENTION", "SYSTEM_EVENT", "AUDIT_CHECKPOINT"]>;
+    classification: z.ZodEnum<["ROUTINE", "SIGNIFICANT", "COMPLIANCE_RELEVANT", "SECURITY_RELEVANT", "INCIDENT_RELATED", "LEGAL_HOLD"]>;
+    severity: z.ZodOptional<z.ZodEnum<["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]>>;
+    sourceSystem: z.ZodString;
+    sourceComponent: z.ZodOptional<z.ZodString>;
+    relatedEntityType: z.ZodOptional<z.ZodString>;
+    relatedEntityId: z.ZodOptional<z.ZodString>;
+    parentEvidenceId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    rawPayload: z.ZodOptional<z.ZodString>;
+    actorType: z.ZodEnum<["HUMAN", "AGENT", "SYSTEM", "EXTERNAL"]>;
+    actorId: z.ZodString;
+    actorName: z.ZodOptional<z.ZodString>;
+    trustBandAtTime: z.ZodOptional<z.ZodEnum<["T0", "T1", "T2", "T3", "T4", "T5"]>>;
+    trustProfileId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    receivedAt: z.ZodOptional<z.ZodString>;
+    sequenceNumber: z.ZodOptional<z.ZodNumber>;
+    contentHash: z.ZodString;
+    previousHash: z.ZodOptional<z.ZodString>;
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "INTENT_SUBMISSION" | "AUTHORIZATION_DECISION" | "EXECUTION_START" | "EXECUTION_STEP" | "EXECUTION_COMPLETE" | "TOOL_INVOCATION" | "TOOL_RESPONSE" | "TRUST_COMPUTATION" | "TRUST_DELTA" | "POLICY_EVALUATION" | "CONSTRAINT_APPLICATION" | "ESCALATION_REQUEST" | "ESCALATION_RESPONSE" | "VIOLATION_DETECTED" | "INCIDENT_REPORT" | "HUMAN_INTERVENTION" | "SYSTEM_EVENT" | "AUDIT_CHECKPOINT";
+    id: string;
+    schemaVersion: string;
+    correlationId: string;
+    classification: "ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD";
+    sourceSystem: string;
+    summary: string;
+    actorType: "HUMAN" | "AGENT" | "SYSTEM" | "EXTERNAL";
+    actorId: string;
+    timestamp: string;
+    contentHash: string;
+    severity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+    sourceComponent?: string | undefined;
+    relatedEntityType?: string | undefined;
+    relatedEntityId?: string | undefined;
+    parentEvidenceId?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+    rawPayload?: string | undefined;
+    actorName?: string | undefined;
+    trustBandAtTime?: "T0" | "T1" | "T2" | "T3" | "T4" | "T5" | undefined;
+    trustProfileId?: string | undefined;
+    receivedAt?: string | undefined;
+    sequenceNumber?: number | undefined;
+    previousHash?: string | undefined;
+    signature?: string | undefined;
+}, {
+    type: "INTENT_SUBMISSION" | "AUTHORIZATION_DECISION" | "EXECUTION_START" | "EXECUTION_STEP" | "EXECUTION_COMPLETE" | "TOOL_INVOCATION" | "TOOL_RESPONSE" | "TRUST_COMPUTATION" | "TRUST_DELTA" | "POLICY_EVALUATION" | "CONSTRAINT_APPLICATION" | "ESCALATION_REQUEST" | "ESCALATION_RESPONSE" | "VIOLATION_DETECTED" | "INCIDENT_REPORT" | "HUMAN_INTERVENTION" | "SYSTEM_EVENT" | "AUDIT_CHECKPOINT";
+    id: string;
+    correlationId: string;
+    classification: "ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD";
+    sourceSystem: string;
+    summary: string;
+    actorType: "HUMAN" | "AGENT" | "SYSTEM" | "EXTERNAL";
+    actorId: string;
+    timestamp: string;
+    contentHash: string;
+    schemaVersion?: string | undefined;
+    severity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+    sourceComponent?: string | undefined;
+    relatedEntityType?: string | undefined;
+    relatedEntityId?: string | undefined;
+    parentEvidenceId?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+    rawPayload?: string | undefined;
+    actorName?: string | undefined;
+    trustBandAtTime?: "T0" | "T1" | "T2" | "T3" | "T4" | "T5" | undefined;
+    trustProfileId?: string | undefined;
+    receivedAt?: string | undefined;
+    sequenceNumber?: number | undefined;
+    previousHash?: string | undefined;
+    signature?: string | undefined;
+}>;
+export declare const EvidencePackSchema: z.ZodObject<{
+    id: z.ZodString;
+    schemaVersion: z.ZodDefault<z.ZodString>;
+    correlationId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        schemaVersion: z.ZodDefault<z.ZodString>;
+        correlationId: z.ZodString;
+        type: z.ZodEnum<["INTENT_SUBMISSION", "AUTHORIZATION_DECISION", "EXECUTION_START", "EXECUTION_STEP", "EXECUTION_COMPLETE", "TOOL_INVOCATION", "TOOL_RESPONSE", "TRUST_COMPUTATION", "TRUST_DELTA", "POLICY_EVALUATION", "CONSTRAINT_APPLICATION", "ESCALATION_REQUEST", "ESCALATION_RESPONSE", "VIOLATION_DETECTED", "INCIDENT_REPORT", "HUMAN_INTERVENTION", "SYSTEM_EVENT", "AUDIT_CHECKPOINT"]>;
+        classification: z.ZodEnum<["ROUTINE", "SIGNIFICANT", "COMPLIANCE_RELEVANT", "SECURITY_RELEVANT", "INCIDENT_RELATED", "LEGAL_HOLD"]>;
+        severity: z.ZodOptional<z.ZodEnum<["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]>>;
+        sourceSystem: z.ZodString;
+        sourceComponent: z.ZodOptional<z.ZodString>;
+        relatedEntityType: z.ZodOptional<z.ZodString>;
+        relatedEntityId: z.ZodOptional<z.ZodString>;
+        parentEvidenceId: z.ZodOptional<z.ZodString>;
+        summary: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        rawPayload: z.ZodOptional<z.ZodString>;
+        actorType: z.ZodEnum<["HUMAN", "AGENT", "SYSTEM", "EXTERNAL"]>;
+        actorId: z.ZodString;
+        actorName: z.ZodOptional<z.ZodString>;
+        trustBandAtTime: z.ZodOptional<z.ZodEnum<["T0", "T1", "T2", "T3", "T4", "T5"]>>;
+        trustProfileId: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+        receivedAt: z.ZodOptional<z.ZodString>;
+        sequenceNumber: z.ZodOptional<z.ZodNumber>;
+        contentHash: z.ZodString;
+        previousHash: z.ZodOptional<z.ZodString>;
+        signature: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "INTENT_SUBMISSION" | "AUTHORIZATION_DECISION" | "EXECUTION_START" | "EXECUTION_STEP" | "EXECUTION_COMPLETE" | "TOOL_INVOCATION" | "TOOL_RESPONSE" | "TRUST_COMPUTATION" | "TRUST_DELTA" | "POLICY_EVALUATION" | "CONSTRAINT_APPLICATION" | "ESCALATION_REQUEST" | "ESCALATION_RESPONSE" | "VIOLATION_DETECTED" | "INCIDENT_REPORT" | "HUMAN_INTERVENTION" | "SYSTEM_EVENT" | "AUDIT_CHECKPOINT";
+        id: string;
+        schemaVersion: string;
+        correlationId: string;
+        classification: "ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD";
+        sourceSystem: string;
+        summary: string;
+        actorType: "HUMAN" | "AGENT" | "SYSTEM" | "EXTERNAL";
+        actorId: string;
+        timestamp: string;
+        contentHash: string;
+        severity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+        sourceComponent?: string | undefined;
+        relatedEntityType?: string | undefined;
+        relatedEntityId?: string | undefined;
+        parentEvidenceId?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        rawPayload?: string | undefined;
+        actorName?: string | undefined;
+        trustBandAtTime?: "T0" | "T1" | "T2" | "T3" | "T4" | "T5" | undefined;
+        trustProfileId?: string | undefined;
+        receivedAt?: string | undefined;
+        sequenceNumber?: number | undefined;
+        previousHash?: string | undefined;
+        signature?: string | undefined;
+    }, {
+        type: "INTENT_SUBMISSION" | "AUTHORIZATION_DECISION" | "EXECUTION_START" | "EXECUTION_STEP" | "EXECUTION_COMPLETE" | "TOOL_INVOCATION" | "TOOL_RESPONSE" | "TRUST_COMPUTATION" | "TRUST_DELTA" | "POLICY_EVALUATION" | "CONSTRAINT_APPLICATION" | "ESCALATION_REQUEST" | "ESCALATION_RESPONSE" | "VIOLATION_DETECTED" | "INCIDENT_REPORT" | "HUMAN_INTERVENTION" | "SYSTEM_EVENT" | "AUDIT_CHECKPOINT";
+        id: string;
+        correlationId: string;
+        classification: "ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD";
+        sourceSystem: string;
+        summary: string;
+        actorType: "HUMAN" | "AGENT" | "SYSTEM" | "EXTERNAL";
+        actorId: string;
+        timestamp: string;
+        contentHash: string;
+        schemaVersion?: string | undefined;
+        severity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+        sourceComponent?: string | undefined;
+        relatedEntityType?: string | undefined;
+        relatedEntityId?: string | undefined;
+        parentEvidenceId?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        rawPayload?: string | undefined;
+        actorName?: string | undefined;
+        trustBandAtTime?: "T0" | "T1" | "T2" | "T3" | "T4" | "T5" | undefined;
+        trustProfileId?: string | undefined;
+        receivedAt?: string | undefined;
+        sequenceNumber?: number | undefined;
+        previousHash?: string | undefined;
+        signature?: string | undefined;
+    }>, "many">;
+    itemCount: z.ZodNumber;
+    startTime: z.ZodString;
+    endTime: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<["SUCCESS", "FAILURE", "ERROR", "TIMEOUT", "CANCELLED", "BLOCKED", "IN_PROGRESS"]>;
+    highestSeverity: z.ZodOptional<z.ZodEnum<["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"]>>;
+    classifications: z.ZodArray<z.ZodEnum<["ROUTINE", "SIGNIFICANT", "COMPLIANCE_RELEVANT", "SECURITY_RELEVANT", "INCIDENT_RELATED", "LEGAL_HOLD"]>, "many">;
+    hasViolations: z.ZodDefault<z.ZodBoolean>;
+    hasIncidents: z.ZodDefault<z.ZodBoolean>;
+    intentId: z.ZodOptional<z.ZodString>;
+    decisionId: z.ZodOptional<z.ZodString>;
+    trustProfileId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    lastUpdated: z.ZodString;
+    packHash: z.ZodString;
+    merkleRoot: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    schemaVersion: string;
+    correlationId: string;
+    items: {
+        type: "INTENT_SUBMISSION" | "AUTHORIZATION_DECISION" | "EXECUTION_START" | "EXECUTION_STEP" | "EXECUTION_COMPLETE" | "TOOL_INVOCATION" | "TOOL_RESPONSE" | "TRUST_COMPUTATION" | "TRUST_DELTA" | "POLICY_EVALUATION" | "CONSTRAINT_APPLICATION" | "ESCALATION_REQUEST" | "ESCALATION_RESPONSE" | "VIOLATION_DETECTED" | "INCIDENT_REPORT" | "HUMAN_INTERVENTION" | "SYSTEM_EVENT" | "AUDIT_CHECKPOINT";
+        id: string;
+        schemaVersion: string;
+        correlationId: string;
+        classification: "ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD";
+        sourceSystem: string;
+        summary: string;
+        actorType: "HUMAN" | "AGENT" | "SYSTEM" | "EXTERNAL";
+        actorId: string;
+        timestamp: string;
+        contentHash: string;
+        severity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+        sourceComponent?: string | undefined;
+        relatedEntityType?: string | undefined;
+        relatedEntityId?: string | undefined;
+        parentEvidenceId?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        rawPayload?: string | undefined;
+        actorName?: string | undefined;
+        trustBandAtTime?: "T0" | "T1" | "T2" | "T3" | "T4" | "T5" | undefined;
+        trustProfileId?: string | undefined;
+        receivedAt?: string | undefined;
+        sequenceNumber?: number | undefined;
+        previousHash?: string | undefined;
+        signature?: string | undefined;
+    }[];
+    itemCount: number;
+    startTime: string;
+    outcome: "CANCELLED" | "SUCCESS" | "FAILURE" | "ERROR" | "TIMEOUT" | "BLOCKED" | "IN_PROGRESS";
+    classifications: ("ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD")[];
+    hasViolations: boolean;
+    hasIncidents: boolean;
+    createdAt: string;
+    lastUpdated: string;
+    packHash: string;
+    trustProfileId?: string | undefined;
+    endTime?: string | undefined;
+    highestSeverity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+    intentId?: string | undefined;
+    decisionId?: string | undefined;
+    merkleRoot?: string | undefined;
+}, {
+    id: string;
+    correlationId: string;
+    items: {
+        type: "INTENT_SUBMISSION" | "AUTHORIZATION_DECISION" | "EXECUTION_START" | "EXECUTION_STEP" | "EXECUTION_COMPLETE" | "TOOL_INVOCATION" | "TOOL_RESPONSE" | "TRUST_COMPUTATION" | "TRUST_DELTA" | "POLICY_EVALUATION" | "CONSTRAINT_APPLICATION" | "ESCALATION_REQUEST" | "ESCALATION_RESPONSE" | "VIOLATION_DETECTED" | "INCIDENT_REPORT" | "HUMAN_INTERVENTION" | "SYSTEM_EVENT" | "AUDIT_CHECKPOINT";
+        id: string;
+        correlationId: string;
+        classification: "ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD";
+        sourceSystem: string;
+        summary: string;
+        actorType: "HUMAN" | "AGENT" | "SYSTEM" | "EXTERNAL";
+        actorId: string;
+        timestamp: string;
+        contentHash: string;
+        schemaVersion?: string | undefined;
+        severity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+        sourceComponent?: string | undefined;
+        relatedEntityType?: string | undefined;
+        relatedEntityId?: string | undefined;
+        parentEvidenceId?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        rawPayload?: string | undefined;
+        actorName?: string | undefined;
+        trustBandAtTime?: "T0" | "T1" | "T2" | "T3" | "T4" | "T5" | undefined;
+        trustProfileId?: string | undefined;
+        receivedAt?: string | undefined;
+        sequenceNumber?: number | undefined;
+        previousHash?: string | undefined;
+        signature?: string | undefined;
+    }[];
+    itemCount: number;
+    startTime: string;
+    outcome: "CANCELLED" | "SUCCESS" | "FAILURE" | "ERROR" | "TIMEOUT" | "BLOCKED" | "IN_PROGRESS";
+    classifications: ("ROUTINE" | "SIGNIFICANT" | "COMPLIANCE_RELEVANT" | "SECURITY_RELEVANT" | "INCIDENT_RELATED" | "LEGAL_HOLD")[];
+    createdAt: string;
+    lastUpdated: string;
+    packHash: string;
+    schemaVersion?: string | undefined;
+    trustProfileId?: string | undefined;
+    endTime?: string | undefined;
+    highestSeverity?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL" | "INFO" | undefined;
+    hasViolations?: boolean | undefined;
+    hasIncidents?: boolean | undefined;
+    intentId?: string | undefined;
+    decisionId?: string | undefined;
+    merkleRoot?: string | undefined;
+}>;
+export declare const ProofEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    schemaVersion: z.ZodDefault<z.ZodString>;
+    correlationId: z.ZodString;
+    proofType: z.ZodEnum<["DECISION_PROOF", "EXECUTION_PROOF", "TRUST_COMPUTATION_PROOF", "POLICY_EVALUATION_PROOF", "COMPLIANCE_ATTESTATION", "INCIDENT_PROOF", "AUDIT_PROOF"]>;
+    evidencePackId: z.ZodString;
+    evidenceItemIds: z.ZodArray<z.ZodString, "many">;
+    claim: z.ZodString;
+    proofData: z.ZodObject<{
+        algorithm: z.ZodString;
+        publicKey: z.ZodOptional<z.ZodString>;
+        signature: z.ZodString;
+        timestamp: z.ZodString;
+        nonce: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        signature: string;
+        algorithm: string;
+        publicKey?: string | undefined;
+        nonce?: string | undefined;
+    }, {
+        timestamp: string;
+        signature: string;
+        algorithm: string;
+        publicKey?: string | undefined;
+        nonce?: string | undefined;
+    }>;
+    verifiable: z.ZodDefault<z.ZodBoolean>;
+    verificationEndpoint: z.ZodOptional<z.ZodString>;
+    previousProofId: z.ZodOptional<z.ZodString>;
+    previousProofHash: z.ZodOptional<z.ZodString>;
+    chainPosition: z.ZodOptional<z.ZodNumber>;
+    generatedAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    proofHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    schemaVersion: string;
+    correlationId: string;
+    proofType: "DECISION_PROOF" | "EXECUTION_PROOF" | "TRUST_COMPUTATION_PROOF" | "POLICY_EVALUATION_PROOF" | "COMPLIANCE_ATTESTATION" | "INCIDENT_PROOF" | "AUDIT_PROOF";
+    evidencePackId: string;
+    evidenceItemIds: string[];
+    claim: string;
+    proofData: {
+        timestamp: string;
+        signature: string;
+        algorithm: string;
+        publicKey?: string | undefined;
+        nonce?: string | undefined;
+    };
+    verifiable: boolean;
+    generatedAt: string;
+    proofHash: string;
+    verificationEndpoint?: string | undefined;
+    previousProofId?: string | undefined;
+    previousProofHash?: string | undefined;
+    chainPosition?: number | undefined;
+    expiresAt?: string | undefined;
+}, {
+    id: string;
+    correlationId: string;
+    proofType: "DECISION_PROOF" | "EXECUTION_PROOF" | "TRUST_COMPUTATION_PROOF" | "POLICY_EVALUATION_PROOF" | "COMPLIANCE_ATTESTATION" | "INCIDENT_PROOF" | "AUDIT_PROOF";
+    evidencePackId: string;
+    evidenceItemIds: string[];
+    claim: string;
+    proofData: {
+        timestamp: string;
+        signature: string;
+        algorithm: string;
+        publicKey?: string | undefined;
+        nonce?: string | undefined;
+    };
+    generatedAt: string;
+    proofHash: string;
+    schemaVersion?: string | undefined;
+    verifiable?: boolean | undefined;
+    verificationEndpoint?: string | undefined;
+    previousProofId?: string | undefined;
+    previousProofHash?: string | undefined;
+    chainPosition?: number | undefined;
+    expiresAt?: string | undefined;
+}>;
+/** ERPL Evidence type enum (distinct from trust-profile EvidenceType) */
+export type ERPLEvidenceType = z.infer<typeof EvidenceTypeSchema>;
+export type EvidenceClassification = z.infer<typeof EvidenceClassificationSchema>;
+export type EvidenceItem = z.infer<typeof EvidenceItemSchema>;
+export type EvidencePack = z.infer<typeof EvidencePackSchema>;
+export type EvidenceProofEvent = z.infer<typeof ProofEventSchema>;
+//# sourceMappingURL=evidence.d.ts.map

package/dist/v2/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../../src/v2/evidence.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,kBAAkB,8XAmB7B,CAAC;AAEH,eAAO,MAAM,4BAA4B,qHAOvC,CAAC;AAMH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyC7B,CAAC;AAMH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC7B,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8C3B,CAAC;AAMH,yEAAyE;AACzE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAClE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}