causalontology 2.0.0 → 4.0.0

data/lib/causalontology/canonical.rb

@@ -14,9 +14,13 @@ require_relative "jcs"
 
 module Causalontology
   module Canonical
-    # The identity-bearing fields of each of the seventeen kinds. "type" is
-    # always injected, so it is not listed here. Order does not matter (JCS
-    # sorts keys).
+    # The identity-bearing fields of each of the twenty-one kinds (3.0.0 adds the
+    # cross_stratal_seam; the conduit gains realized_by; 4.0.0 adds the attitude,
+    # the predicted_occurrence, and the prediction_error - all additive and
+    # identity-preserving - a record that omits a new field keeps its earlier
+    # identifier byte-for-byte, and the new kinds open new identity schemes that
+    # disturb no existing record). "type" is always injected, so it is not listed
+    # here. Order does not matter (JCS sorts keys).
     IDENTITY_FIELDS = {
       # ---- type tier ----
       "occurrent"  => ["label", "category", "stratum"],
@@ -26,8 +30,10 @@ module Causalontology
       "realizable" => ["kind", "bearer", "label"],
       "stratum"    => ["label", "scheme", "ordinal", "unit", "governs"],
       "bridge"     => ["coarse", "fine", "relation"],
+      "cross_stratal_seam" => ["source", "target", "mechanism_status", "chain"],
       "port"       => ["bearer", "label", "direction", "accepts", "realizable"],
-      "conduit"    => ["label", "from", "to", "carries", "transform"],
+      "conduit"    => ["label", "from", "to", "carries", "transform",
+                       "realized_by"],
       "quality"    => ["label", "datatype", "unit", "stratum"],
       # ---- token tier ----
       "token_individual"   => ["instantiates", "designator", "part_of"],
@@ -36,6 +42,10 @@ module Causalontology
       "state_assertion"    => ["subject", "quality", "value", "interval"],
       "token_causal_claim" => ["causes", "effects", "covering_law",
                                "actual_delay", "counterfactual"],
+      "attitude"             => ["holder", "attitude_type", "content"],
+      "predicted_occurrence" => ["instantiates", "interval", "predictor",
+                                 "strength"],
+      "prediction_error"     => ["predicted", "observed", "discrepancy"],
       # ---- provenance tier ----
       "assertion"  => ["about", "source", "evidence_type", "evidence", "strength",
                        "confidence", "timestamp", "evidenced_by"],

data/lib/causalontology/schema.rb

@@ -3,7 +3,7 @@
 # Schema validation against spec/schema/*.schema.json.
 #
 # A deliberately small interpreter for exactly the JSON Schema keywords the
-# seventeen Causalontology schemas use: type, const, enum, pattern, required,
+# twenty-one Causalontology schemas use: type, const, enum, pattern, required,
 # properties, additionalProperties, items, minItems, minLength, minimum,
 # maximum, oneOf, local $ref (#/$defs/...), and cross-file $ref to a sibling
 # schema (https://causalontology.org/schema/<file>.schema.json#/...). "format"
@@ -23,6 +23,7 @@ module Causalontology
       "realizable" => "realizable.schema.json",
       "stratum"    => "stratum.schema.json",
       "bridge"     => "bridge.schema.json",
+      "cross_stratal_seam" => "cross_stratal_seam.schema.json",
       "port"       => "port.schema.json",
       "conduit"    => "conduit.schema.json",
       "quality"    => "quality.schema.json",
@@ -30,6 +31,9 @@ module Causalontology
       "token_occurrence"   => "token.schema.json",
       "state_assertion"    => "state.schema.json",
       "token_causal_claim" => "token_causal_claim.schema.json",
+      "attitude"             => "attitude.schema.json",
+      "predicted_occurrence" => "predicted_occurrence.schema.json",
+      "prediction_error"     => "prediction_error.schema.json",
       "assertion"  => "assertion.schema.json",
       "enrichment" => "enrichment.schema.json",
       "retraction" => "retraction.schema.json",
@@ -41,9 +45,18 @@ module Causalontology
     @cache = {}
 
     class << self
+      # Where the twenty-one *.schema.json files live, in strict precedence:
+      #
+      #   (a) $CAUSALONTOLOGY_SPEC/schema  - explicit override, always wins;
+      #   (b) the copy vendored inside the gem - what an installed consumer
+      #       uses, so validation works standalone with no repository present;
+      #   (c) the repository-relative path - last resort, for working directly
+      #       in a checkout where (b) has not been vendored yet.
       def schema_dir
         env = ENV["CAUSALONTOLOGY_SPEC"]
         return File.join(env, "schema") if env && !env.empty?
+        bundled = File.expand_path("spec/schema", __dir__)
+        return bundled if File.directory?(bundled)
         # lib/causalontology -> lib -> ruby -> bindings -> repository root
         File.expand_path("../../../../spec/schema", __dir__)
       end

data/lib/causalontology/semantics.rb

@@ -22,6 +22,13 @@ module Causalontology
       "years"   => 31556952,
     }.freeze
 
+    # 3.0.0: the ordinal (dimensionless) temporal units. A tick is a discrete
+    # step with NO wall-clock mapping; a tick window is ordered by integer
+    # comparison, and an ordinal window and a wall-clock window are DIFFERENT
+    # DIMENSIONS that do not compare (mixing them is never within-window and
+    # never overlapping).
+    ORDINAL_UNITS = Set.new(["ticks"]).freeze
+
     # Rule 12: enrichment field-to-kind validity and entry shapes. Two
     # occurrent forms added in 2.0.0.
     ENRICHMENT_FIELDS = {
@@ -47,6 +54,19 @@ module Causalontology
       Canonical::KIND_OF_PREFIX[identifier.split(":", 2)[0]]
     end
 
+    # 3.0.0: "ordinal" for a tick-like unit, else "wallclock".
+    def dimension(unit)
+      ORDINAL_UNITS.include?(unit) ? "ordinal" : "wallclock"
+    end
+
+    # 3.0.0: a comparable magnitude within ONE dimension: raw tick count for an
+    # ordinal unit, seconds for a wall-clock unit. Never mix dimensions.
+    def magnitude(value, unit)
+      return value if ORDINAL_UNITS.include?(unit) # a dimensionless tick count
+      return 0 if unit == "instant"
+      value * UNIT_SECONDS.fetch(unit)
+    end
+
     # [ok, reasons] - the locally checkable semantic rules.
     def validate_semantics(obj, kind = nil)
       kind ||= Canonical.infer_kind(obj)
@@ -96,6 +116,41 @@ module Causalontology
         end
       end
 
+      # 3.0.0 Rule 22, local clause: a Cross Stratal Seam that DRAWS a chain has,
+      # by drawing it, a modelled intervening mechanism - so mechanism_status
+      # 'absent' contradicts a present chain (the honest-ignorance distinction
+      # must stay honest). The stratal well-formedness (non-adjacency, adjacency
+      # of chain steps, scheme, the home rule) needs the strata map and lives in
+      # seam_wellformed, exactly as bridge well-formedness does.
+      if kind == "cross_stratal_seam"
+        if !obj["chain"].nil? && obj["mechanism_status"] == "absent"
+          errors << "contradictory_seam: a drawn chain cannot carry " \
+                    "mechanism_status 'absent' (a drawn mechanism is not absent)"
+        end
+      end
+
+      # 4.0.0 Rule 24, local clause: a predicted_occurrence's interval carries
+      # exactly ONE temporal dimension - a wall-clock start (optional end) or an
+      # ordinal start_tick (optional end_tick), never both and never neither.
+      # Per Rule 23 the two dimensions never compare. The pairing check of a
+      # prediction_error against its predicted_occurrence and its observed
+      # token_occurrence needs those objects and lives in
+      # prediction_pairing_mismatch, exactly as covering_law_mismatch does.
+      if kind == "predicted_occurrence"
+        iv = obj["interval"] || {}
+        wall = iv.key?("start")
+        tick = iv.key?("start_tick")
+        if wall && tick
+          errors << "dimension_conflict: a predicted interval must " \
+                    "carry exactly one temporal dimension, not a " \
+                    "wall-clock start AND an ordinal start_tick"
+        end
+        if !wall && !tick
+          errors << "missing_dimension: a predicted interval must " \
+                    "carry a wall-clock start or an ordinal start_tick"
+        end
+      end
+
       [errors.empty?, errors]
     end
 
@@ -105,26 +160,27 @@ module Causalontology
       [!missing.empty?, missing]
     end
 
-    # Rule 4: temporal admissibility with the fixed constants.
-    def admissible(cro, elapsed_seconds)
+    # Rule 4: temporal admissibility. For a wall-clock window `elapsed` is in
+    # seconds; for an ordinal ('ticks') window `elapsed` is a tick count.
+    # Ordering is by magnitude WITHIN the window's own dimension (3.0.0).
+    def admissible(cro, elapsed)
       t = cro["temporal"]
       return true if t.nil? # no window imposes no constraint
-      unit = UNIT_SECONDS.fetch(t["unit"])
-      lo = t["minimum_delay"] * unit
-      hi = t["maximum_delay"] * unit
-      lo <= elapsed_seconds && elapsed_seconds <= hi
+      lo = magnitude(t["minimum_delay"], t["unit"])
+      hi = magnitude(t["maximum_delay"], t["unit"])
+      lo <= elapsed && elapsed <= hi
     end
 
     def window_overlap(a, b)
       ta = a["temporal"]
       tb = b["temporal"]
       return true if ta.nil? || tb.nil? # either absent counts as overlapping
-      ua = UNIT_SECONDS.fetch(ta["unit"])
-      ub = UNIT_SECONDS.fetch(tb["unit"])
-      lo_a = ta["minimum_delay"] * ua
-      hi_a = ta["maximum_delay"] * ua
-      lo_b = tb["minimum_delay"] * ub
-      hi_b = tb["maximum_delay"] * ub
+      # 3.0.0: an ordinal window and a wall-clock window never overlap
+      return false if dimension(ta["unit"]) != dimension(tb["unit"])
+      lo_a = magnitude(ta["minimum_delay"], ta["unit"])
+      hi_a = magnitude(ta["maximum_delay"], ta["unit"])
+      lo_b = magnitude(tb["minimum_delay"], tb["unit"])
+      hi_b = magnitude(tb["maximum_delay"], tb["unit"])
       lo_a <= hi_b && lo_b <= hi_a
     end
 
@@ -309,19 +365,31 @@ module Causalontology
     end
 
     # ALGORITHM E helper: normalize a delay to seconds by the fixed table.
+    # 3.0.0: an ordinal ('ticks') unit is dimensionless and has NO wall-clock
+    # mapping - converting one to seconds is a category error and is refused.
     def to_seconds(duration, unit)
+      if ORDINAL_UNITS.include?(unit)
+        raise ArgumentError,
+              "'#{unit}' is an ordinal (dimensionless) unit and has no " \
+              "wall-clock seconds mapping"
+      end
       return 0 if unit == "instant"
       duration * UNIT_SECONDS.fetch(unit)
     end
 
     # ALGORITHM E (Rule 20): does an observed delay fall within a covering
-    # law's temporal window? Inclusive at both ends (N12.5.2).
+    # law's temporal window? Inclusive at both ends (N12.5.2). 3.0.0: an ordinal
+    # delay compares to an ordinal window by integer tick count; an ordinal
+    # delay and a wall-clock window (or vice versa) are different dimensions and
+    # never fall within one another.
     def delay_within_window(actual_delay, temporal)
       return true if actual_delay.nil? || actual_delay.empty? ||
                      temporal.nil? || temporal.empty?
-      observed = to_seconds(actual_delay["duration"], actual_delay["unit"])
-      lo = to_seconds(temporal["minimum_delay"], temporal["unit"])
-      hi = to_seconds(temporal["maximum_delay"], temporal["unit"])
+      # dimension mismatch: a tick delay is not within a wall-clock window
+      return false if dimension(actual_delay["unit"]) != dimension(temporal["unit"])
+      observed = magnitude(actual_delay["duration"], actual_delay["unit"])
+      lo = magnitude(temporal["minimum_delay"], temporal["unit"])
+      hi = magnitude(temporal["maximum_delay"], temporal["unit"])
       lo <= observed && observed <= hi
     end
 
@@ -348,6 +416,73 @@ module Causalontology
       [true, "well-formed bridge"]
     end
 
+    # 3.0.0 Rule 22 / Algorithm F: Cross Stratal Seam well-formedness.
+    # [ok, reason]. All of (a)-(g) must hold, else malformed_seam. A seam is a
+    # MANAGED jump across NON-ADJACENT strata; when it DRAWS a chain, the chain
+    # must be an adjacent-stratum path spanning the two endpoints' strata.
+    def seam_wellformed(seam, occ_map, stratum_map)
+      src_s = (occ_map[seam["source"]] || {})["stratum"]
+      tgt_s = (occ_map[seam["target"]] || {})["stratum"]
+      if src_s.nil? || tgt_s.nil?
+        return [false, "malformed_seam: an endpoint has no stratum (a)"]
+      end
+      if stratum_map[src_s]["scheme"] != stratum_map[tgt_s]["scheme"]
+        return [false, "malformed_seam: endpoints differ in scheme (b)"]
+      end
+      so = stratum_map[src_s]["ordinal"]
+      to_ = stratum_map[tgt_s]["ordinal"]
+      if (so - to_).abs <= 1
+        return [false, "malformed_seam: endpoints are adjacent or co-stratal; " \
+                       "a seam is for NON-adjacent strata (c)"]
+      end
+      chain = seam["chain"]
+      unless chain.nil?
+        if seam["mechanism_status"] == "absent"
+          return [false, "malformed_seam: a drawn chain contradicts " \
+                         "mechanism_status 'absent' (d)"]
+        end
+        lo = [so, to_].min
+        hi = [so, to_].max
+        ords = []
+        chain.each do |oid|
+          st = (occ_map[oid] || {})["stratum"]
+          if st.nil?
+            return [false, "malformed_seam: a chain member has no stratum (e)"]
+          end
+          if stratum_map[st]["scheme"] != stratum_map[src_s]["scheme"]
+            return [false, "malformed_seam: a chain member differs in scheme (e)"]
+          end
+          ords << stratum_map[st]["ordinal"]
+        end
+        unless ords.all? { |o| lo < o && o < hi }
+          return [false, "malformed_seam: a chain member is not at an " \
+                         "INTERVENING stratum, strictly between the endpoints (f)"]
+        end
+        diffs = (0...(ords.length - 1)).map { |i| ords[i + 1] - ords[i] }
+        if !diffs.empty? &&
+           !(diffs.all? { |d| d > 0 } || diffs.all? { |d| d < 0 })
+          return [false, "malformed_seam: chain is not strictly monotone from " \
+                         "one endpoint toward the other (g)"]
+        end
+      end
+      [true, "well-formed cross_stratal_seam"]
+    end
+
+    # THE HOME RULE (3.0.0): a Cross Stratal Seam belongs to the COARSEST stratum
+    # it touches - the endpoint of the greater ordinal. Returns that stratum's
+    # identifier (nil if an endpoint is unstratified). A layer-to-stratum binding
+    # places and checks the seam by this rule.
+    def seam_home(seam, occ_map, stratum_map)
+      src_s = (occ_map[seam["source"]] || {})["stratum"]
+      tgt_s = (occ_map[seam["target"]] || {})["stratum"]
+      return nil if src_s.nil? || tgt_s.nil?
+      if stratum_map[src_s]["ordinal"] >= stratum_map[tgt_s]["ordinal"]
+        src_s
+      else
+        tgt_s
+      end
+    end
+
     # Rule 17 / N4.2.1-2: Conduit well-formedness. [ok, reason]. N4.2.1 with
     # the transform exception of N4.2.2.
     def conduit_wellformed(conduit, port_map, cro_map = nil)
@@ -417,6 +552,16 @@ module Causalontology
       false
     end
 
+    # 4.0.0 Rule 24: prediction-to-observation pairing. True iff the prediction
+    # error's observed token does not instantiate the occurrent its
+    # predicted_occurrence instantiates (surfaces pairing_mismatch). An ABSENT
+    # observed is never a mismatch - it means the predicted occurrence was not
+    # fulfilled by any recorded occurrence.
+    def prediction_pairing_mismatch(error, predicted, observed)
+      return false if error["observed"].nil? || observed.nil?
+      observed["instantiates"] != predicted["instantiates"]
+    end
+
     # Rule 21: true iff any cause token starts after any effect token (HARD;
     # retrocausal_claim). RFC 3339 UTC "Z" strings compare lexicographically.
     def retrocausal(tcc, token_map)

data/lib/causalontology/spec/schema/assertion.schema.json

@@ -0,0 +1,75 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://causalontology.org/schema/assertion.schema.json",
+  "title": "Assertion",
+  "type": "object",
+  "required": [
+    "id",
+    "about",
+    "source",
+    "evidence_type",
+    "confidence",
+    "timestamp"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^assertion:[0-9a-f]{64}$"
+    },
+    "type": {
+      "const": "assertion"
+    },
+    "about": {
+      "type": "string",
+      "pattern": "^(causal_relation_object|occurrent|continuant|realizable|stratum|bridge|cross_stratal_seam|port|conduit|quality|token_individual|token_occurrence|state_assertion|token_causal_claim|attitude|predicted_occurrence|prediction_error):[0-9a-f]{64}$",
+      "description": "the content object this assertion is about (widened in 2.0.0 to the nine new content kinds; widened in 4.0.0 to attitude, predicted_occurrence, and prediction_error, and to the cross_stratal_seam, whose absence here was a 3.0.0 drift repaired in this major version); about a non-causal object it means the source vouches for the vocabulary item"
+    },
+    "source": {
+      "type": "string",
+      "pattern": "^ed25519:[0-9a-f]{64}$"
+    },
+    "evidence_type": {
+      "enum": [
+        "intervention",
+        "observation",
+        "simulation",
+        "derivation",
+        "human_hint",
+        "imported"
+      ],
+      "description": "how the source came to the claim; ordering from strongest to weakest is intervention, observation, simulation, derivation, human_hint, imported (2.0.0 6.2)"
+    },
+    "evidence": {
+      "type": "string"
+    },
+    "strength": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "description": "the source's estimate of causal strength (semantics.md rule 5); meaningful only when about references a Causal Relation Object"
+    },
+    "confidence": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1
+    },
+    "timestamp": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "evidenced_by": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^(token_occurrence|token_causal_claim|state_assertion):[0-9a-f]{64}$"
+      },
+      "description": "the PARTICULAR token records that are the evidence for this claim (2.0.0 6.2). IDENTITY-BEARING."
+    },
+    "signature": {
+      "type": "string",
+      "pattern": "^[0-9a-f]{128}$",
+      "description": "Ed25519 signature over the record's canonical identity-bearing bytes; excluded from the identity hash"
+    }
+  }
+}

data/lib/causalontology/spec/schema/attitude.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://causalontology.org/schema/attitude.schema.json",
+  "title": "Attitude",
+  "description": "4.0.0. A first-class record of a PROPOSITIONAL ATTITUDE: what a holder's mind CONTAINS, never what is true. The holder is a MODELED agent inside the ontology (a continuant type or a particular token individual), never a cryptographic key; the content is a reference by identity to ANY content object - which may be FALSE, and may itself be another attitude (nesting). An attitude is NOT an assertion and carries no strength (Principle P4): it is asserted, graded, and retracted through the ordinary provenance layer, and the SOURCE that signs an assertion ABOUT an attitude is a different thing from the HOLDER of the attitude (Rule 25).",
+  "type": "object",
+  "required": [
+    "id",
+    "type",
+    "holder",
+    "attitude_type",
+    "content"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^attitude:[0-9a-f]{64}$"
+    },
+    "type": {
+      "const": "attitude"
+    },
+    "holder": {
+      "type": "string",
+      "pattern": "^(continuant|token_individual):[0-9a-f]{64}$",
+      "description": "the agent whose mind contains the content: a MODELED agent inside the ontology (a continuant type or a particular token individual), never a cryptographic key - the signer of an assertion about this attitude is a SOURCE, and the two are different things (Rule 25)"
+    },
+    "attitude_type": {
+      "enum": [
+        "believes",
+        "desires",
+        "intends",
+        "knows",
+        "expects",
+        "fears"
+      ],
+      "description": "CLOSED enumeration; extending it is a MAJOR change (Locked Decision 24)"
+    },
+    "content": {
+      "type": "string",
+      "pattern": "^(occurrent|causal_relation_object|continuant|realizable|stratum|bridge|cross_stratal_seam|port|conduit|quality|token_individual|token_occurrence|state_assertion|token_causal_claim|attitude|predicted_occurrence|prediction_error):[0-9a-f]{64}$",
+      "description": "a reference by identity to ANY content object, INCLUDING another attitude (nesting: A believes that B believes X). The content records what the holder's mind contains, not what is true - it may be FALSE, and a content that contradicts the actual record raises NO conflict (Rule 25: that mismatch IS a false belief, first-class and shareable)"
+    }
+  }
+}

data/lib/causalontology/spec/schema/bridge.schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://causalontology.org/schema/bridge.schema.json",
+  "title": "Bridge",
+  "type": "object",
+  "required": [
+    "id",
+    "type",
+    "coarse",
+    "fine",
+    "relation"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^bridge:[0-9a-f]{64}$"
+    },
+    "type": {
+      "const": "bridge"
+    },
+    "coarse": {
+      "type": "string",
+      "pattern": "^occurrent:[0-9a-f]{64}$",
+      "description": "the occurrent at the coarser stratum"
+    },
+    "fine": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "string",
+        "pattern": "^occurrent:[0-9a-f]{64}$"
+      },
+      "description": "the occurrents at the finer stratum that jointly constitute, aggregate to, realize, or subvene the coarse one"
+    },
+    "relation": {
+      "enum": [
+        "constitutes",
+        "aggregates",
+        "realizes",
+        "supervenes_on"
+      ],
+      "description": "the cross-stratal relation asserted; CLOSED enumeration"
+    }
+  }
+}

data/lib/causalontology/spec/schema/causal_relation_object.schema.json

@@ -0,0 +1,111 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://causalontology.org/schema/causal_relation_object.schema.json",
+  "title": "Causal Relation Object",
+  "type": "object",
+  "required": [
+    "id",
+    "causes",
+    "effects"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "id": {
+      "$ref": "#/$defs/croId"
+    },
+    "type": {
+      "const": "causal_relation_object"
+    },
+    "causes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/occId"
+      }
+    },
+    "effects": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/$defs/occId"
+      }
+    },
+    "mechanism": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/croId"
+      },
+      "description": "identifiers of finer Causal Relation Objects whose composition realizes this one (hierarchical decomposition; must be acyclic; consistency per semantics.md rule 7, amended to BRIDGED reachability in 2.0.0)"
+    },
+    "temporal": {
+      "$ref": "#/$defs/temporalWindow"
+    },
+    "modality": {
+      "enum": [
+        "necessary",
+        "sufficient",
+        "contributory",
+        "preventive",
+        "enabling"
+      ]
+    },
+    "context": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/occId"
+      },
+      "description": "enabling conditions under which the relation holds"
+    },
+    "refines": {
+      "$ref": "#/$defs/croId",
+      "description": "the more partial Causal Relation Object this one enriches (lineage; acyclic; must preserve the parent's specified fields)"
+    },
+    "skips": {
+      "type": "boolean",
+      "description": "TRUE asserts that this relation crosses non-adjacent strata WITHOUT being re-encoded at the intervening strata: the absence of a mechanism is a POSITIVE FINDING, not a gap (2.0.0 4.4)"
+    }
+  },
+  "$defs": {
+    "croId": {
+      "type": "string",
+      "pattern": "^causal_relation_object:[0-9a-f]{64}$"
+    },
+    "occId": {
+      "type": "string",
+      "pattern": "^occurrent:[0-9a-f]{64}$"
+    },
+    "temporalWindow": {
+      "type": "object",
+      "required": [
+        "minimum_delay",
+        "maximum_delay",
+        "unit"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "minimum_delay": {
+          "type": "number",
+          "minimum": 0
+        },
+        "maximum_delay": {
+          "type": "number",
+          "minimum": 0
+        },
+        "unit": {
+          "enum": [
+            "instant",
+            "seconds",
+            "minutes",
+            "hours",
+            "days",
+            "weeks",
+            "months",
+            "years",
+            "ticks"
+          ],
+          "description": "3.0.0: the wall-clock units carry a fixed seconds mapping; 'ticks' is a discrete, dimensionless ORDINAL unit (a step counter) with NO wall-clock mapping - a tick window is ordered by integer comparison, and a tick window and a wall-clock window are different dimensions that do not compare."
+        }
+      }
+    }
+  }
+}

data/lib/causalontology/spec/schema/conduit.schema.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://causalontology.org/schema/conduit.schema.json",
+  "title": "Conduit",
+  "type": "object",
+  "required": [
+    "id",
+    "type",
+    "from",
+    "to",
+    "carries"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^conduit:[0-9a-f]{64}$"
+    },
+    "type": {
+      "const": "conduit"
+    },
+    "label": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9_]*$",
+      "description": "the name of the connection (for example: corticospinal_tract)"
+    },
+    "from": {
+      "type": "string",
+      "pattern": "^port:[0-9a-f]{64}$"
+    },
+    "to": {
+      "type": "string",
+      "pattern": "^port:[0-9a-f]{64}$"
+    },
+    "carries": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "string",
+        "pattern": "^occurrent:[0-9a-f]{64}$"
+      },
+      "description": "the kinds of occurrent this conduit conducts"
+    },
+    "transform": {
+      "type": "string",
+      "pattern": "^causal_relation_object:[0-9a-f]{64}$",
+      "description": "OPTIONAL. ABSENT asserts the conduit is TRANSMISSIVE. PRESENT names the Causal Relation Object the conduit performs upon what it carries, asserting the conduit is COMPUTATIONAL."
+    },
+    "realized_by": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9_]*:.+$",
+      "minLength": 3,
+      "description": "3.0.0 OPTIONAL. A scheme-qualified REFERENCE, by identity, to the native law or signal that REALIZES this conduit's transform (for example a native rate law a computational conduit stands for, or a runtime signal a transmissive conduit stands for). It is a reference, not an embedded law - the native dynamics stay native; the standard only records the binding. ABSENT (unbound) is legal and identity-preserving; a conduit that carried no realized_by in 2.0.0 keeps its identifier under 3.0.0."
+    }
+  }
+}