Organization shapes

scope Northwind : org.Organization {
  persona NorthwindCo

  use gov.Constitution(
    founders = { CEO, CTO },
    amendBy  = CEO,
    board    = CTO,
    quorum   = 1,
    delay    = 2 d
  ) as Const

  position CEO : org.Owner {
    cardinality 1
    eligible when self is pp.Person
  }

  position CTO : org.Officer {
    cardinality 1
    eligible when self is pp.Person
  }

  position Deployer : org.Member {
    cardinality 1
    eligible when self is ag.Program
  }

  position Ops : org.Member {
    cardinality 1
    eligible when self is ag.Autonomous
  }

  position Support : org.Member {
    cardinality 1
    eligible when self is ag.ModelBased
  }

  position Architect : org.Member {
    cardinality 1
    eligible when self is ag.Autonomous
    incompatible with Ops
  }

  use rz.RealizationEnvelope(
    holder      = Ops,
    requirement = Api,
    operation   = ops.Scale,
    admissible  = a.n <= 12
                  and holds ops.price(bound(Api)) * a.n <= 4_000 USD per month
  ) as OpsEnvelope

  use org.Approval(
    approver   = CTO,
    subject    = ops.ScaleRequest,
    threshold  = true,
    deadline   = 1 business-days,
    escalateTo = CEO
  ) as ScaleApproval

  use rz.ExperimentPower(
    holder   = Architect,
    pattern  = Experiment,
    budget   = 200 USD,
    duration = 1 d
  ) as Research

  use fin.Budget(
    scope    = Northwind,
    resource = econ.Money,
    limit    = 18_000 USD per month,
    reserve  = 2_000 USD,
    window   = month,
    orElse   = gov.Freeze(except = { Const.Materialize })
  ) as Runway
}

pattern Squad(focus : Text) {
  scope S : org.Team in Product {
    persona SquadP

    position PM : org.Officer {
      cardinality 1
    }

    position EM : org.Officer {
      cardinality 1
      incompatible with PM
    }

    position Engineer : org.Member {
      cardinality 2..6
    }

    norm Experiments {
      power of PM to decide launch | stop about growth.Experiment
      when e.traffic <= 20 % and e.squad = here
    }

    norm ShipsOwnCode {
      power of EM to authorize execute about eng.Deploy
      when c.owner = here and c.risk = "low"
    }
  }
}

use Squad(focus = "acquisition") as Growth
use Squad(focus = "onboarding")  as Activation
use Squad(focus = "revenue")     as Billing

-- Pricing changes cross squad boundaries: Billing proposes, the VP Product decides after Finance reviews.
use gov.ReviewedProposal(
  kind       = growth.PriceChange,
  approver   = VPProduct,
  reviewer   = Finance.Lead,
  deadline   = 5 business-days,
  escalateTo = CEO
) as PricingRoute

scope WebGuild : org.Team in Brightline {
  member when self member of Product and holds eng.frontend(self)

  norm Standards {
    power of persona to enact _ at level operational about eng.FrontendStandard
  }
}

scope Platform : org.Team in Corvid {
  persona PlatformP

  offers capability Deploy {
    operation deploy(c : Entity) -> outcome : Claim
    guarantee eventually holds eng.deployed(c) or holds eng.rolled-back(c)
    property  lead-time    <= 15 min
    property  availability >= 99.9 % per month
  }

  offers capability Observe {
    operation probe(r : Capability) -> observations : Claim
    property  freshness <= 1 min
  }
}

scope Checkout : org.Team in StreamAligned {
  requires capability ShipCheckout {
    operation deploy(c : Entity) -> outcome : Claim
    property  lead-time <= 30 min
    for CheckoutConversion
  }
}

-- enabling teams hold time-boxed powers inside the team they are helping
use org.Delegation(
  from    = SecurityEnablement.persona,
  into    = StreamAligned,
  expires = 6 weeks
) as Embed

scope AcmeDPA : org.Contract in Customers {
  persona AcmeDPAP

  norm Residency {
    prohibition on any Party
    aim exists x : Entity . x is cu.AcmeData
        and custody-jurisdiction(x) not in { EU }
    source external acme.DPA # "§4.2"
    level constitutional   not tradeable   not defeasible
  }

  norm BreachNotice {
    obligation of SecurityGRC.CISO to acme.Party
    when holds sec.breach(x) and x is cu.AcmeData
    aim within 72 h: occurred assert(sec.Notified(acme.Party, x))
  }
}

use org.SegregationOfDuties(
  act      = authorize execute(eng.Deploy, c),
  subject  = eng.Change,
  separate = { c.author }
) as NoSelfDeploy

norm ControlEvidence {
  obligation of SecurityGRC.Evidence to persona
  when occurred tick(t) and t.boundary = "day"
  aim within 4 h: occurred derive(grc.ControlStatus(_, t.day)) by SecurityGRC.Evidence
  not tradeable
}