Retention Policy Ontology

FLOW ALGEBRA
Retention Policy Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/administrative-metadata/retention-policy-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "RetentionPolicyOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := AdministrativeMetadata
ONTOLOGY := RetentionPolicyOntology

ENTITY RetentionPolicy {
    definition:
        "Administrative metadata defining how long a resource, record,
         metadata object, version or related evidence must or may be retained,
         which event starts the retention period, what exceptions suspend or
         extend disposition, and what authorised action occurs when retention
         requirements are satisfied.";
    objectives: [
        RetentionGovernance,
        LifecycleManagement,
        Compliance,
        DispositionControl,
        Preservation,
        Auditability,
        MachineInterpretability
    ];
}

RetentionEntity := {
    RetentionPolicy,
    RetentionRule,
    RetentionPeriod,
    RetentionTrigger,
    RetentionSchedule,
    RetentionStatus,
    RetainedResource,
    RetentionIdentifier
};

DispositionEntity := {
    Disposition,
    Disposal,
    Deletion,
    Archival,
    Transfer,
    Preservation,
    Review,
    DispositionAuthority
};

ExceptionEntity := {
    LegalHold,
    PreservationHold,
    InvestigationHold,
    Extension,
    Suspension,
    ExceptionRule,
    Override
};

MetadataEntity := {
    ResponsibleAgent,
    PolicyAuthority,
    Provenance,
    Version,
    Timestamp,
    Evidence,
    Confidence,
    Jurisdiction
};

RetentionPolicy GOVERNS RetainedResource;
RetentionRule DEFINES RetentionPeriod;
RetentionTrigger STARTS RetentionPeriod;
RetentionSchedule ORGANISES RetentionRules;
Disposition FOLLOWS SatisfiedRetentionRequirement;
LegalHold SUSPENDS_OR_OVERRIDES NormalDisposition;
PolicyAuthority AUTHORISES RetentionPolicy;
Provenance SUPPORTS RetentionDecision;

RetentionPolicyFlow :=
    Resource
    -> IdentifyRetentionSubject
    -> SelectApplicableRetentionPolicy
    -> ResolveRetentionRule
    -> IdentifyRetentionTrigger
    -> CalculateRetentionPeriod
    -> CheckHoldsExceptionsAndOverrides
    -> DetermineRetentionStatus
    -> EvaluateDispositionEligibility
    -> RequireAuthorisedDisposition
    -> RecordAuditAndProvenance
    -> PreserveRequiredEvidence
    -> MaintainAcrossLifecycle;

RetainedResource :=
    ResourceOrRecordSubjectToRetentionRequirement;

RetainedResource MAY_BE {
    Document,
    Dataset,
    File,
    MetadataRecord,
    AuditRecord,
    Communication,
    TransactionRecord,
    Model,
    ResourceVersion,
    PhysicalRecord
};

RetentionPolicy :=
    AuthoritativeRuleSetGoverningRetentionAndDisposition;

RetentionIdentifier :=
    StableReferenceToRetentionPolicyRuleOrSchedule;

RetentionIdentifier MAY_BE {
    URI,
    IRI,
    UUID,
    ScheduleCode,
    PolicyCode,
    InternalIdentifier
};

RetentionRule :=
    RuleDefiningRetentionRequirementForResourceClassOrContext;

RetentionRule MAY_HAVE {
    ResourceScope,
    RetentionTrigger,
    RetentionPeriod,
    DispositionAction,
    Authority,
    Exceptions
};

RetentionSchedule :=
    ManagedCollectionOfRetentionRules;

RetentionSchedule MAY_BE {
    Organisational,
    Regulatory,
    Contractual,
    Departmental,
    SystemSpecific
};

RetentionPeriod :=
    DurationOrConditionForWhichResourceMustOrMayBeRetained;

RetentionPeriod MAY_BE {
    FixedDuration,
    EventBasedDuration,
    Indefinite,
    Permanent,
    UntilSuperseded,
    UntilReview
};

FixedDuration :=
    DefinedLengthOfTimeSuchAsYearsMonthsDays;

EventBasedDuration :=
    DurationCalculatedFromSpecifiedTriggerEvent;

PermanentRetention :=
    RequirementToPreserveResourceWithoutScheduledDisposition;

IndefiniteRetention :=
    RetentionWithoutCurrentlyDefinedEndDate
    BUT MAY_BE SubjectToFutureReview;

UntilSuperseded :=
    RetainUntilReplacementOrSuccessorRecordBecomesEffective;

RetentionTrigger :=
    EventOrDateFromWhichRetentionCalculationBegins;

RetentionTrigger MAY_INCLUDE {
    CreationDate,
    PublicationDate,
    ClosureDate,
    ContractEnd,
    EmploymentEnd,
    TransactionDate,
    LastActivityDate,
    SupersessionDate,
    LegalEvent
};

TriggerDate :=
    ResolvedDateAssociatedWithRetentionTrigger;

RetentionEndDate :=
    TriggerDate
    + RetentionPeriod
    according_to applicable_calendar_and_policy_rules;

RetentionCalculation SHOULD_PRESERVE {
    Trigger,
    TriggerDate,
    Period,
    RuleVersion
};

RetentionStatus MAY_BE {
    NotStarted,
    Active,
    EligibleForReview,
    EligibleForDisposition,
    OnHold,
    PermanentlyRetained,
    Disposed,
    Unknown
};

IF TriggerNotOccurred
THEN RetentionStatus MAY_BE NotStarted;

IF TriggerOccurred
AND RetentionPeriodNotExpired
THEN RetentionStatus := Active;

IF RetentionPeriodExpired
AND NoHoldOrExceptionApplies
THEN RetentionStatus MAY_BE EligibleForDisposition;

Expiration DOES_NOT AutomaticallyAuthoriseDeletion;

Disposition :=
    AuthorisedLifecycleActionAfterRetentionRequirementIsSatisfied;

Disposition MAY_BE {
    Delete,
    Destroy,
    Archive,
    Transfer,
    Preserve,
    Review
};

Disposal :=
    ControlledRemovalOrDestructionOfResource;

Deletion :=
    LogicalOrPhysicalRemovalOfDigitalResourceAccordingToPolicy;

Destruction :=
    ControlledDestructionOfPhysicalOrDigitalRecordWhereRequired;

Archival :=
    TransferOrStateChangeForLongTermHistoricalOrInstitutionalPreservation;

Transfer :=
    MovementOfResourceToAnotherCustodianRepositoryOrAuthority;

Preservation :=
    ContinuedRetentionForLongTermAccessIntegrityOrEvidence;

Review :=
    HumanOrAuthorisedProcessDeterminingNextLifecycleAction;

DispositionAuthority :=
    AgentRoleOrPolicyAuthorityPermittedToApproveDisposition;

DispositionApproval :=
    AuthorisedDecisionAllowingDispositionAction;

IF RetentionExpired
BUT DispositionApprovalRequiredAndMissing
THEN Resource MUST_NOT_BE Disposed;

LegalHold :=
    AdministrativeRestrictionSuspendingNormalDispositionBecauseOfLegalRequirement;

PreservationHold :=
    RestrictionSuspendingDispositionForHistoricalScientificOperationalOrPreservationReason;

InvestigationHold :=
    RestrictionSuspendingDispositionDuringInvestigationOrReview;

Hold MAY_HAVE {
    HoldIdentifier,
    Authority,
    StartDate,
    EndDate,
    Scope,
    Reason
};

IF ActiveHoldApplies
THEN Disposition MUST_BE Suspended;

HoldScope MAY_APPLY_TO {
    SingleResource,
    ResourceClass,
    Collection,
    Subject,
    DateRange
};

HoldRelease :=
    AuthorisedTerminationOfHold;

AfterHoldRelease:
    RetentionAndDispositionEligibility SHOULD_BE Recalculated;

Extension :=
    AuthorisedIncreaseInRetentionPeriod;

Extension MAY_BE {
    FixedExtension,
    EventBasedExtension,
    IndefiniteExtension
};

Suspension :=
    TemporaryPauseOfRetentionClockOrDispositionProcessAccordingToPolicy;

PauseSemantics MUST_BE ExplicitlyDefined;

ExceptionRule :=
    RuleModifyingNormalRetentionBehaviour;

Exception MAY_INCLUDE {
    LegalHold,
    RegulatoryOverride,
    ContractualRequirement,
    HistoricalValue,
    Investigation
};

Override :=
    HigherPriorityRuleReplacingOrModifyingDefaultRetentionRule;

PolicyPrecedence :=
    RulesDeterminingWhichRetentionRequirementControlsWhenMultipleRulesApply;

MultipleRetentionRules MAY_APPLY_TO SameResource;

ConservativeRetention MAY_SELECT LongestApplicableRetention
ONLY_IF PolicyOrLegalFrameworkDefinesThatApproach;

System MUST_NOT AssumeLongestRuleWithoutDefinedPrecedenceSemantics;

RetentionConflict :=
    ApplicableRulesProduceIncompatibleRetentionOrDispositionRequirements;

ConflictHandling MAY {
    PreserveAllRules,
    ApplyAuthorityPrecedence,
    ApplyJurisdictionRules,
    FlagReview
};

Jurisdiction :=
    LegalOrRegulatoryTerritoryRelevantToRetentionRequirement;

RetentionRequirements MAY_DIFFER_BY Jurisdiction;

ContractualRetention :=
    RetentionRequirementDerivedFromContractOrAgreement;

RegulatoryRetention :=
    RetentionRequirementDerivedFromLawOrRegulation;

OrganisationalRetention :=
    RetentionRequirementDefinedByInternalPolicy;

OperationalRetention :=
    RetentionRequirementBasedOnBusinessOrSystemNeed;

PolicyAuthority :=
    AgentOrganisationRegulatorOrGovernanceBodyAuthorisingRetentionRule;

ResponsibleAgent :=
    AgentResponsibleForApplyingOrReviewingRetentionPolicy;

RetentionEvidence :=
    InformationSupportingTriggerRuleHoldDispositionOrComplianceDecision;

Evidence MAY_BE {
    PolicyDocument,
    Contract,
    Regulation,
    SystemRecord,
    Approval,
    AuditRecord
};

RetentionProvenance MAY_INCLUDE {
    PolicySource,
    RuleVersion,
    Calculator,
    ResponsibleAgent,
    Timestamp,
    Evidence
};

RetentionConfidence :=
    EstimatedSupportForInferredOrImportedRetentionMetadata;

AuthoritativeRetention SHOULD_PREFER ValidPolicyAndEvidenceOverProbabilisticInference;

RetentionValidation MAY_CHECK {
    ResourceIdentity,
    PolicyApplicability,
    TriggerValidity,
    PeriodValidity,
    HoldStatus,
    DispositionAuthority,
    RuleVersion
};

IF RetentionPeriodNegativeOrInvalid
THEN ValidationStatus := violation;

IF TriggerRequiredButMissing
THEN RetentionStatus MAY_BE Unknown
AND Disposition MUST_NOT ProceedWithoutResolution;

IF ActiveHoldExists
AND DispositionMarkedApproved
THEN Conflict SHOULD_BE Flagged;

RetentionCompleteness :=
    DegreeToWhichRequiredRuleTriggerPeriodHoldAndDispositionMetadataArePresent;

RetentionConsistency :=
    DegreeToWhichApplicableRulesDatesHoldsAndActionsDoNotConflict;

RetentionIntegrity :=
    PreservationOfAuthoritativePolicyCalculationsApprovalsAndHistory;

RetentionTimeliness :=
    DegreeToWhichRetentionStatusReflectsCurrentEventsAndPolicy;

RetentionMetadataQuality MAY_INCLUDE {
    Completeness,
    Consistency,
    Integrity,
    Timeliness,
    Provenance
};

RetentionVersion :=
    IdentifiedRevisionOfRetentionPolicyOrAssignment;

PolicyVersion :=
    IdentifiedRevisionOfRetentionPolicyDocumentOrRuleSet;

RetentionHistory :=
    OrderedRecordOfPolicyAssignmentsTriggersHoldsReviewsAndDispositionEvents;

RetentionChange MAY_INCLUDE {
    RuleChange,
    PeriodChange,
    TriggerChange,
    ScopeChange,
    HoldChange,
    DispositionChange
};

PolicyRevision MAY_REQUIRE RecalculationOfAffectedRetentionDates;

IF RetentionRuleChanges
THEN ExistingResources SHOULD_BE EvaluatedAccordingTo MigrationAndApplicabilityPolicy;

Grandfathering :=
    RuleAllowingExistingResourcesToRemainUnderEarlierPolicyVersion;

RetroactivePolicy :=
    PolicyRevisionAppliedToExistingResourcesAccordingToAuthorisedRules;

DispositionEvent :=
    RecordedExecutionOfDispositionAction;

DispositionEvent SHOULD_RECORD {
    ResourceIdentifier,
    Action,
    Authority,
    Timestamp,
    Method,
    Evidence
};

DeletionVerification :=
    EvidenceThatRequiredDeletionOrDestructionWasCompleted;

DeletionCertificate MAY_BE UsedAsDispositionEvidenceWhereApplicable;

ArchiveTransferRecord :=
    EvidenceThatResourceWasTransferredToArchiveOrRepository;

RetentionAudit :=
    ReviewOfRetentionPolicyApplicationAndDispositionHistory;

Audit MAY_CHECK {
    OverRetention,
    PrematureDeletion,
    MissingHold,
    MissingApproval,
    PolicyMismatch
};

OverRetention :=
    ResourceRetainedBeyondRequiredOrPermittedPeriodWithoutValidReason;

PrematureDisposition :=
    ResourceDisposedBeforeRetentionRequirementWasSatisfied;

Both MAY_CREATE ComplianceRisk;

DataMinimisation MAY_REQUIRE DeletionWhenRetentionNoLongerJustified
subject_to applicable_policy_and_law;

PrivacyPolicy MAY_INTERACT_WITH RetentionPolicy;

SecurityClassification MAY_AFFECT RetentionAndDispositionHandling;

CopyrightOrLicensing MAY_REQUIRE CertainRecordsToBeRetainedForEvidence
according_to policy;

OwnershipOrCustodyChange MAY_TRIGGER TransferOrRetentionReview;

ProvenanceMetadata SHOULD_PRESERVE RetentionAndDispositionHistory;

AdministrativeMetadata MAY_STORE RetentionAssignmentsAndStatuses;

MetadataRepository MAY_ENFORCE RetentionLocksOrDispositionWorkflows;

MetadataRegistry MAY_REGISTER RetentionPropertiesSchedulesAndDispositionActions;

KnowledgeGraph MAY_REPRESENT:
    Resource
    -> GOVERNED_BY_RETENTION_POLICY
    -> RetentionPolicy;

RetentionRule
    -> HAS_TRIGGER
    -> RetentionTrigger;

RetentionRule
    -> HAS_DISPOSITION
    -> Disposition;

RetentionGraph SHOULD_PRESERVE RuleVersionAuthorityAndTemporalContext;

RDF MAY_REPRESENT RetentionRelationshipsAsTypedStatements;

JSONLD MAY_SERIALISE LinkedRetentionMetadata;

Search MAY_USE RetentionMetadataFor {
    StatusFiltering,
    DispositionReview,
    ArchiveDiscovery,
    ComplianceAudit
};

Search SHOULD_NOT ReturnDisposedOrRestrictedResourcesUnlessPolicyAllows;

RAG MAY_USE RetentionMetadataFor {
    SourceEligibility,
    VersionSelection,
    ArchiveSelection,
    ComplianceFiltering
};

DisposedOrExpiredResource SHOULD_NOT BeUsedInAIContextIfPolicyProhibitsUse;

AI MAY_SUPPORT {
    RetentionRuleClassification,
    TriggerExtraction,
    PolicyMapping,
    HoldDetection,
    ReviewPrioritisation
};

AIGeneratedRetentionRecommendation SHOULD_NOT AuthoriseDispositionWithoutRequiredPolicyAuthority;

RetentionSecurity MAY_INCLUDE {
    PolicyIntegrity,
    HoldIntegrity,
    AccessControl,
    AuditProtection,
    ChangeAuthorisation
};

UnauthorisedModificationOfRetentionOrHoldMetadata MAY_CREATE SeriousGovernanceRisk;

MachineReadableRetentionPolicy SHOULD_PRESERVE {
    PolicyIdentifier,
    PolicyVersion,
    ResourceScope,
    RetentionRule,
    RetentionTrigger,
    RetentionPeriod,
    Holds,
    DispositionAction,
    Authority,
    Provenance,
    Status
};

# ---------- SEMANTIC REASONING ----------
IF AdministrativeMetadataDefinesHowLongResourceMustOrMayBeKept
THEN RetentionPolicyClassification := supported;

IF RetentionTriggerOccurred
THEN RetentionClock MAY_STARTAccordingToRule;

IF RetentionPeriodExpired
AND NoHoldApplies
THEN Resource MAY_BECOME EligibleForDisposition;

IF ActiveLegalHoldApplies
THEN Disposition MUST_BE Suspended;

IF TriggerDateUnknown
THEN AutomaticDisposition MUST_NOT Proceed;

IF PolicyVersionChanges
THEN AffectedRetentionCalculations MAY_REQUIRE Recalculation;

IF DispositionRequiresApproval
AND ApprovalMissing
THEN Disposition MUST_NOT Proceed;

IF ResourceDisposed
THEN DispositionEvidenceAndHistory SHOULD_BE PreservedAccordingToPolicy;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "retention policy" ~= "records retention policy";
    "retention rule" ~= "records retention rule";
    "retention period" ~= "retention duration";
    "retention trigger" ~= "retention start event";
    "retention schedule" ~= "records retention schedule";
    "disposition" ~= "retention disposition action";
    "legal hold" ~= "litigation hold" WHEN legal_context;
    "permanent retention" ~= "permanent preservation" WHEN archival_policy_context;
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_APPLICABLE_RETENTION_POLICY(q) ->
    RESOLVE_RETENTION_RULE(q) ->
    IDENTIFY_TRIGGER_AND_TRIGGER_DATE(q) ->
    CALCULATE_RETENTION_PERIOD_AND_END(q) ->
    IDENTIFY_HOLDS_EXCEPTIONS_AND_OVERRIDES(q) ->
    DETERMINE_RETENTION_STATUS(q) ->
    EVALUATE_DISPOSITION_ELIGIBILITY(q) ->
    VERIFY_DISPOSITION_AUTHORITY(q) ->
    IDENTIFY_PROVENANCE_AND_EVIDENCE(q) ->
    VALIDATE_RETENTION_METADATA(q) ->
    RETURN_AUTHORISED_RETENTION_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        policy_authority,
        source_reliability,
        trigger_resolution_strength,
        temporal_consistency,
        provenance_quality,
        conflict_status,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: RetentionPolicy;
    ontology: RetentionPolicyOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
    enforce_holds_and_disposition_rules: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_retention_assignment:
        identify_resource
        -> select_policy
        -> resolve_rule
        -> identify_trigger
        -> calculate_retention
        -> identify_disposition
        -> attach_authority
        -> attach_provenance
        -> validate
        -> integrate;

    trigger_event:
        identify_affected_resources
        -> record_trigger_date
        -> start_or_recalculate_retention
        -> update_status
        -> audit
        -> integrate;

    hold_event:
        identify_scope
        -> validate_hold_authority
        -> apply_or_release_hold
        -> recalculate_disposition_eligibility
        -> audit
        -> integrate;

    policy_revision:
        preserve_previous_version
        -> apply_authorised_changes
        -> identify_affected_resources
        -> apply_migration_or_grandfathering_rules
        -> recalculate_where_required
        -> regenerate_flow_hash;

    disposition:
        verify_retention_satisfied
        -> verify_no_active_hold
        -> verify_authority_and_approval
        -> execute_archive_transfer_delete_or_review
        -> record_evidence
        -> audit
        -> integrate;

    conflict:
        preserve_all_rules_and_evidence
        -> apply_precedence
        -> block_unsafe_disposition
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + RetentionEntity
    + DispositionEntity
    + ExceptionEntity
    + MetadataEntity
    + RetentionPolicy
    + RetentionValidation
    + Disposition
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
RetentionPolicyOntology
    -> IdentifyRetainedResourceAndApplicablePolicy
    -> AssignStableRetentionPolicyAndRuleIdentifiers
    -> ResolveRetentionTriggerAndTriggerDate
    -> CalculateRetentionPeriodAndExpectedEnd
    -> IdentifyLegalHoldsExceptionsExtensionsAndOverrides
    -> DetermineCurrentRetentionStatus
    -> EvaluateDispositionEligibilityWithoutAutomaticUnsafeDeletion
    -> VerifyDispositionAuthorityAndRequiredApproval
    -> ExecuteArchiveTransferPreserveReviewOrDeleteAccordingToPolicy
    -> RecordDispositionEvidenceAuditAndProvenance
    -> RecalculateWhenPoliciesTriggersOrHoldsChange
    -> ApplyRetentionEligibilityToSearchRAGAndResourceLifecycle
    -> MaintainReliableRetentionPolicyKnowledge;

END FLOW