Ω-CODE v2.0 aligns the code-domain verification layer with the omega-brain-mcp 10-gate pipeline and VERITAS Ω Build v1.0.0, while preserving the deterministic enforcement innovations from Ω-CODE v1.0.

Claim Object

All pipeline input is a BuildClaim — a structured object, not a string grammar. Every field must be present and non-null.

BuildClaim := {
  id:            ClaimID,
  project:       String,
  version:       SemVer,
  commit:        Hash,
  P:             Set[BuildPrimitive],     // what we measure
  O:             Set[Operator],           // how we combine
  R:             Set[BuildRegime],        // deployment context
  B:             Set[Boundary],           // constraints
  L:             Set[LossModel],          // failure costs
  E:             Set[EvidenceItem],       // proof
  cost:          CostVector,
  cost_bounds:   CostBounds,
  attack_suite:  AttackSuite,
  dependencies:  DependencyManifest,
  security:      SecurityManifest,
  created_at:    Timestamp
}

ClaimID := SHA256(canonical(
  project + version + commit + P + O + R + B + L + PolicyHash
))

Set Canonicalization

All set fields sorted lexicographically by name or id before hashing. Two BuildClaims with same fields in different order MUST produce the same ClaimID.

P: sorted by BuildPrimitive.name
O: sorted by Operator.name
R: sorted by BuildRegime.name
B: sorted by Boundary.name
L: sorted by LossModel.name
E: sorted by EvidenceItem.id

Key Types

BuildPrimitive := { name: String, units: String, domain: Interval }
Operator       := { name: String, arity: Int, inputs: [Ref], output: Ref }
BuildRegime    := { name: "dev"|"staging"|"prod", predicates: [Predicate] }
Boundary       := { name: String, constraint: { variable, operator, target } }
PackageRef     := { name, version, registry, integrity_hash }
SASTFinding    := { tool, location, severity, finding }

Production regime enforces escalated thresholds: K=3, A=0.90, Q=0.80.

Environment Declaration

Preserved from v1.0. Before any pipeline run, the execution environment MUST be explicitly declared and hashed.

ENV_MANIFEST {
  os:              String
  language_ver:    String
  ast_parser:      String
  dependency_lock: Hash
  gate_config:     Hash          // PolicyHash
  timestamp:       Unix_epoch
}

ENV_HASH = SHA256(ENV_MANIFEST in canonical JSON key order). Different output under same ENV_HASH → VIOLATION: NONDETERMINISM.

Verdicts

Verdict := PASS | MODEL_BOUND | INCONCLUSIVE | VIOLATION

Precedence: VIOLATION > INCONCLUSIVE > MODEL_BOUND > PASS

Pipeline

PIPELINE_ORDER := [
  INTAKE,  TYPE,  DEPENDENCY,  EVIDENCE,  MATH,
  COST,  INCENTIVE,  SECURITY,  ADVERSARY,  TRACE_SEAL
]

Fail-Fast Rule

IF Gate N returns VIOLATION:
  → HALT immediately → final_verdict = VIOLATION

IF Gate N returns INCONCLUSIVE:
  → HALT unless policy gate-skip
  → If skipped: downgraded to MODEL_BOUND

Final Verdict

EXECUTED_GATES := all gates that ran (inclusive of halting gate)
final_verdict  = max(verdicts over EXECUTED_GATES, by precedence)

Only executed gates participate. Gates that never ran are absent, not defaulted.

Gate Definitions

INTAKE_GATE(payload):
  1. Parse BuildClaim from source (CI, CLI, API)
  2. Validate all required fields present and non-null
  3. Verify commit hash matches HEAD
  4. Compute ClaimID — verify match
  5. Verify lockfile_hash matches disk
  6. Validate ENV_MANIFEST present and hashable

  → PASS or VIOLATION: INTAKE_MALFORMED
                        INTAKE_COMMIT_MISMATCH
                        INTAKE_LOCKFILE_DRIFT

TYPE_GATE(claim):
  1. Enforce unique primitive names
  2. Validate non-empty domains
  3. Validate operator arity + type references
  4. Check all constraint symbols → declared primitives
  5. Validate unit consistency across operators
  6. Verify regime predicates reference declared primitives

  → PASS or VIOLATION: UNDEFINED_SYMBOL | UNIT_MISMATCH
                        ARITY_ERROR | EMPTY_DOMAIN

DEPENDENCY_GATE(claim):
  1. Parse SBOM from DependencyManifest
  2. Verify every PackageRef integrity_hash vs registry
  3. Scan CVEs:
     CRITICAL/HIGH (no patch) → VIOLATION(CVE_CRITICAL)
     MEDIUM → MODEL_BOUND(CVE_MEDIUM) if policy allows
     LOW → log + PASS
  4. Check dependency depth vs DEPENDENCY_DEPTH_REDLINE
  5. Detect deprecated/abandoned packages (>2yr, archived)
  6. Detect duplicate packages at different versions
  7. Verify license compatibility

clamp01(x) := max(0, min(1, x))

Quality(e) = clamp01(
  0.40 × provenance_score(tier)      // A=1.0, B=0.7, C=0.4
+ 0.25 × repeatability_score(method) // repeatable=1.0, else=0.5
+ 0.20 × freshness_score(e)          // within TTL=1.0, expired=0.0
+ 0.15 × environment_match_score(e)  // matches=1.0, partial=0.5
)

Edge between e_i, e_j if:
  same source_id
  OR same tool + config + |Δt| ≤ 60s
  OR explicit dependency declared

MIS_GREEDY(G):
  Order by (degree asc, id asc)
  Greedily pick non-adjacent → Timeout → INCONCLUSIVE(MIS_TIMEOUT)

MATH_GATE(claim):
  1. Bind evidence values → constraint variables
  2. Translate → interval propagation or SMT
  3. SAT → PASS
     UNSAT → VIOLATION(UNSAT_CONSTRAINT)
     TIMEOUT → INCONCLUSIVE(DECIDABILITY_TIMEOUT)

COST_GATE(claim):
  u = max(cost_i / bound_i) over all components

  u < 0.80  → PASS
  u < 0.95  → PASS with warning
  u ≥ 0.95  → MODEL_BOUND(COST_REDLINING)
  no bound  → VIOLATION(UNDECLARED_COST_BOUND)

INCENTIVE_GATE(claim):
  Dominance(x) = max_count_by_source / |S_x|

  > 0.75 → VIOLATION(EVIDENCE_CAPTURE)
  > 0.50 → MODEL_BOUND(DOMINANCE_DETECTED)

  Registry concentration:
  single registry >80% → MODEL_BOUND(VENDOR_CONCENTRATION)

SECURITY_GATE(claim):
  0. Verify type_report.json + trust_boundaries exist
  1. secrets_detected == true → VIOLATION(SECRET_DETECTED)  // zero tolerance
  2. SAST: CRITICAL → VIOLATION  HIGH → VIOLATION
          MEDIUM → MODEL_BOUND  LOW → log
  3. Verify auth_boundaries declared
  4. Verify injection_surfaces mitigated
  5. Verify TLS ≥ 1.2
  6. Trust boundaries without mitigation → VIOLATION(UNMITIGATED_BOUNDARY)

ADVERSARY_GATE(claim):
  For each attack in AttackSuite:
    PerturbParam: param × (1 + delta_rel)
      magnitude := 0.05 (default, in PolicyHash)
      sign := +1 if hash(attack.id) % 2 == 0, else -1
      delta_rel := sign × magnitude

    Re-evaluate constraints under perturbation
    Constraint flips SAT→UNSAT → VIOLATION(ADVERSARY_FRAGILE)

  Categories: fuzz · mutation · supply_chain · outage · load_spike · exploit
  Incomplete coverage → INCONCLUSIVE(COVERAGE_INCOMPLETE)

TRACE_SEAL_GATE(claim, gate_results):
  1. PolicyHash = SHA256(canonical(version, hash_alg, solver_backend,
     timeouts, thresholds, attack_params, gate_order, attack_suite_hash))

  2. trace_0 = SHA256("GENESIS" + PolicyHash + ClaimID)
     trace_k = SHA256(trace_prev + canonical(gate_result_k))

  3. seal = trace_final

  4. manifest.json = { claim_id, env_hash, policy_hash,
     gate_results: [hashes], final_verdict, seal, timestamp }

  5. Append seal to S.E.A.L. ledger

  Always PASS (recording, not evaluation)

Artifact Canonicalization

CANONICAL_FORM:
  Encoding:    UTF-8 (no BOM)
  Format:      JSON
  Key order:   lexicographic (recursive)
  Whitespace:  compact — no trailing, no indentation
  Numbers:     no leading zeros, no trailing decimal zeros
  Strings:     double-quoted, escaped per RFC 8259
  Nulls:       literal "null" (not absent keys)

Binary artifacts → Base64 JSON wrapper: {"_binary": true, "encoding": "base64", "data": "..."}

Determinism Invariant

Given identical ENV_HASH + ClaimID + PolicyHash → pipeline MUST produce identical seal. Failure → VIOLATION: NONDETERMINISM.

State Evolution

Reason Codes — Complete Index

System Integration

Delta from v1.0

What Is Not In Scope

• Reason narratively about code quality, style, or intent
• Produce probabilistic severity scores (use AEGIS for triage)
• Evaluate claims not expressible as structured BuildClaim objects
• Replace formal verification for safety-critical systems
• Model epistemic entropy, fractal composability, or causal do-calculus