Ordo in C#

public enum TimeEntryStatus
{
    Recorded,
    Voided,
    Superseded
}

public sealed record TimeEntry(
    EntryId Id,
    PersonId PersonId,
    DateOnly Date,
    TimeOfDay Start,
    DurationMinutes Duration,
    ProjectId ProjectId,
    TimeEntryStatus Status,
    long Revision);

public sealed record TimeOfDay
{
    public int Hour { get; }
    public int Minute { get; }

    private TimeOfDay(int hour, int minute)
    {
        Hour = hour;
        Minute = minute;
    }

    public static TimeOfDay Of(int hour, int minute)
    {
        if (hour is < 0 or > 23)
            throw new ArgumentOutOfRangeException(nameof(hour));

        if (minute is < 0 or > 59)
            throw new ArgumentOutOfRangeException(nameof(minute));

        return new TimeOfDay(hour, minute);
    }

    public int MinutesSinceMidnight => Hour * 60 + Minute;
}

public sealed record DurationMinutes
{
    public int Value { get; }

    private DurationMinutes(int value) => Value = value;

    public static DurationMinutes Of(int minutes) =>
        minutes <= 0
            ? throw new ArgumentOutOfRangeException(nameof(minutes))
            : new DurationMinutes(minutes);
}

public static CommandResult Void(
    WeekDocument week,
    EntryId entryId,
    long expectedRevision,
    string? reason)
{
    var error = RequireStatus(
        week,
        entryId,
        expectedRevision,
        TimeEntryStatus.Recorded,
        out var entry);

    if (error is not null)
        return new CommandResult.Rejected([error]);

    var voided = entry! with
    {
        Status = TimeEntryStatus.Voided,
        Revision = entry.Revision + 1,
        Provenance = entry.Provenance with
        {
            CorrectionReason = reason
        }
    };

    var updatedWeek = week with
    {
        Entries = ReplaceEntry(week.Entries, voided),
        DocumentRevision = week.DocumentRevision + 1
    };

    return new CommandResult.Success(updatedWeek, voided);
}

[Flags]
public enum EntryActions
{
    None           = 0,
    Correct        = 1 << 0,
    Split          = 1 << 1,
    Void           = 1 << 2,
    Restore        = 1 << 3,
    LinkEvidence   = 1 << 4,
    UnlinkEvidence = 1 << 5,
    Merge          = 1 << 6
}

public static class AvailableActions
{
    public static EntryActions For(TimeEntry entry) =>
        entry.Status switch
        {
            TimeEntryStatus.Voided =>
                EntryActions.Restore,

            TimeEntryStatus.Superseded =>
                EntryActions.None,

            TimeEntryStatus.Recorded =>
                ForRecorded(entry)
        };

    private static EntryActions ForRecorded(TimeEntry entry)
    {
        var actions =
            EntryActions.Correct |
            EntryActions.Void |
            EntryActions.LinkEvidence |
            EntryActions.Merge;

        if (entry.Duration.Value >= 2)
            actions |= EntryActions.Split;

        if (entry.Evidence.Count > 0)
            actions |= EntryActions.UnlinkEvidence;

        return actions;
    }
}

public readonly record struct EvidenceId(Guid Value);
public readonly record struct CoverageScope(string Value);

public sealed record Evidence(
    EvidenceId Id,
    string Source,
    DateTimeOffset ObservedAt,
    string Basis);

public enum CoverageStatus
{
    Complete,
    Partial,
    Unknown
}

public sealed record ContextCoverageClaim(
    CoverageScope Scope,
    CoverageStatus Status,
    IReadOnlySet<EvidenceId> Provenance);

public sealed record DecisionContract(
    IReadOnlySet<CoverageScope> RequiredCompleteScopes);

public static class CoverageGate
{
    public static IReadOnlyList<CoverageScope> MissingRequiredCoverage(
        DecisionContract contract,
        IReadOnlyList<ContextCoverageClaim> claims) =>

        contract.RequiredCompleteScopes
            .Where(required =>
                !claims.Any(c =>
                    c.Scope == required &&
                    c.Status == CoverageStatus.Complete))
            .ToList();
}

public readonly record struct CapabilityName(string Value);

public sealed record Capability(
    CapabilityName Name,
    string EstablishedBy,
    DateTimeOffset EstablishedAt);

public static class CapabilityGate
{
    private static readonly CapabilityName CorrectTimeEntry =
        new("time-entry.correct");

    public static bool CanCorrect(IReadOnlySet<Capability> supplied) =>
        supplied.Any(c => c.Name == CorrectTimeEntry);
}

public abstract record DecisionGateResult
{
    private DecisionGateResult() { }

    public sealed record Allowed(
        IReadOnlyList<string> LegalChoices) : DecisionGateResult;

    public sealed record InsufficientCoverage(
        IReadOnlyList<CoverageScope> Missing) : DecisionGateResult;

    public sealed record MissingCapability(
        CapabilityName Capability) : DecisionGateResult;

    public sealed record BlockedByObligation(
        string Obligation) : DecisionGateResult;
}

public static DecisionGateResult EvaluateCorrection(
    DecisionContract contract,
    IReadOnlyList<ContextCoverageClaim> coverage,
    IReadOnlySet<Capability> capabilities,
    IReadOnlyList<string> openObligations)
{
    var missingCoverage =
        CoverageGate.MissingRequiredCoverage(contract, coverage);

    if (missingCoverage.Count > 0)
        return new DecisionGateResult.InsufficientCoverage(missingCoverage);

    var requiredCapability =
        new CapabilityName("time-entry.correct");

    if (!capabilities.Any(c => c.Name == requiredCapability))
        return new DecisionGateResult.MissingCapability(requiredCapability);

    if (openObligations.Count > 0)
        return new DecisionGateResult.BlockedByObligation(
            openObligations[0]);

    return new DecisionGateResult.Allowed(
        ["accept-correction", "reject-correction", "escalate"]);
}

public enum EffectStatus
{
    Succeeded,
    Failed,
    Unknown
}

public sealed record EffectObservation(
    string EffectId,
    EffectStatus Status,
    string? Detail);

public sealed record ReconciliationObligation(
    string EffectId,
    string Reason);

public static ReconciliationObligation? Interpret(
    EffectObservation observation) =>

    observation.Status switch
    {
        EffectStatus.Succeeded => null,

        EffectStatus.Failed => null,

        EffectStatus.Unknown =>
            new ReconciliationObligation(
                observation.EffectId,
                "Observe the external system before any dependent transition.")
    };

<PropertyGroup>
  <TargetFramework>net8.0</TargetFramework>
  <Nullable>enable</Nullable>
  <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
</PropertyGroup>

[Fact]
public void Superseded_entries_have_no_available_actions()
{
    var entry = ExampleEntry.Recorded()
        with { Status = TimeEntryStatus.Superseded };

    var actions = AvailableActions.For(entry);

    Assert.Equal(EntryActions.None, actions);
}