diff --git a/Strata/Languages/Core/Factory.lean b/Strata/Languages/Core/Factory.lean
index 67002bf27f..e4486c9d2c 100644
--- a/Strata/Languages/Core/Factory.lean
+++ b/Strata/Languages/Core/Factory.lean
@@ -42,6 +42,7 @@ def KnownLTys : LTys :=
    t[real],
    t[Triggers],
    t[TriggerGroup],
+   t[errorVoid],
    -- Note: t[bv<n>] elaborates to (.forAll [] .tcons "bitvec" <n>).
    -- We can simply add the following here.
    t[∀n. bitvec n],
diff --git a/Strata/Languages/Core/ProcedureEval.lean b/Strata/Languages/Core/ProcedureEval.lean
index 9ea328f41b..fcf6721d20 100644
--- a/Strata/Languages/Core/ProcedureEval.lean
+++ b/Strata/Languages/Core/ProcedureEval.lean
@@ -93,13 +93,13 @@ def eval (E : Env) (p : Procedure) : Env × Statistics :=
                 match check.attr with
                 | .Free =>
                     -- NOTE: A free postcondition is not checked.
-                    -- We simply change a free-postcondition to "true", but
+                    -- We simply change a free-postcondition to "assume true", but
                     -- keep a record in the metadata field.
                     -- TODO: Perhaps introduce an "opaque" expression construct
                     -- that hides the expression from the evaluator, allowing us
                     -- to retain the postcondition body instead of replacing it
                     -- with "true".
-                  (.assert label (.true ())
+                  (.assume label (.true ())
                                  ((Imperative.MetaData.pushElem
                                   #[]
                                   (.label label)
diff --git a/Strata/Languages/Core/SMTEncoder.lean b/Strata/Languages/Core/SMTEncoder.lean
index 20907ceea2..6f086b736c 100644
--- a/Strata/Languages/Core/SMTEncoder.lean
+++ b/Strata/Languages/Core/SMTEncoder.lean
@@ -236,7 +236,12 @@ def LMonoTy.toSMTType (E: Env) (ty : LMonoTy) (ctx : SMT.Context) (useArrayTheor
   | .ftvar tyv => match ctx.tySubst.find? tyv with
                     | .some termTy =>
                       .ok (termTy, ctx)
-                    | _ => .error f!"Unimplemented encoding for type var {tyv}"
+                    | _ =>
+                      -- Unresolved type variables can arise from polymorphic
+                      -- precondition assertions (PrecondElim) where the element
+                      -- type is unconstrained. Default to `int` since the
+                      -- assertion's semantics are independent of the type.
+                      .ok (.int, ctx)
 
 def LMonoTys.toSMTType (E: Env) (args : LMonoTys) (ctx : SMT.Context) (useArrayTheory : Bool := false) :
     Except Format ((List TermType) × SMT.Context) := do
diff --git a/Strata/Languages/Laurel/ContractPass.lean b/Strata/Languages/Laurel/ContractPass.lean
new file mode 100644
index 0000000000..6f407b896a
--- /dev/null
+++ b/Strata/Languages/Laurel/ContractPass.lean
@@ -0,0 +1,550 @@
+/-
+  Copyright Strata Contributors
+
+  SPDX-License-Identifier: Apache-2.0 OR MIT
+-/
+module
+
+public import Strata.Languages.Laurel.MapStmtExpr
+public import Strata.Languages.Laurel.TransparencyPass
+
+/-!
+## Contract Pass (Laurel → Laurel)
+
+Removes pre- and postconditions from all procedures and replaces them with
+explicit precondition/postcondition helper procedures, assumptions, and
+assertions.
+
+For each procedure with contracts:
+- Generate a precondition procedure (`foo$pre`) returning the conjunction of preconditions.
+- Generate a postcondition procedure (`foo$post`) that takes all inputs and all
+  outputs as parameters and returns the conjunction of postconditions. It is
+  marked as functional and does not call the original procedure.
+- Insert `assume foo$pre(inputs)` at the start of the body.
+- Insert `assert foo$post(inputs, outputs)` at the end of the body.
+
+For each call to a contracted procedure:
+- Assign all input arguments to temporary variables before the call.
+- Insert `assert foo$pre(temps)` before the call (precondition check).
+- After the call, insert `assume foo$post(temps, outputs)` (postcondition assumption).
+-/
+
+namespace Strata.Laurel
+
+public section
+
+private def mkMd (e : StmtExpr) : StmtExprMd := { val := e, source := none }
+private def mkVarMd (v : Variable) : VariableMd := { val := v, source := none }
+
+/-- Build a conjunction of expressions. Returns `LiteralBool true` for an empty list. -/
+private def conjoin (exprs : List StmtExprMd) : StmtExprMd :=
+  match exprs with
+  | [] => mkMd (.LiteralBool true)
+  | [e] => e
+  | e :: rest => rest.foldl (fun acc x =>
+      mkMd (.PrimitiveOp .And [acc, x])) e
+
+/-- Name for the precondition helper procedure. -/
+def preCondProcName (procName : String) : String := s!"{procName}$pre"
+
+/-- Name for the postcondition helper procedure. -/
+def postCondProcName (procName : String) : String := s!"{procName}$post"
+
+/-- Get postconditions from a procedure body. -/
+private def getPostconditions (body : Body) : List Condition :=
+  match body with
+  | .Opaque postconds _ _ => postconds
+  | .Abstract postconds => postconds
+  | _ => []
+
+/-- Build a call expression. -/
+private def mkCall (callee : String) (args : List StmtExprMd) : StmtExprMd :=
+  mkMd (.StaticCall (mkId callee) args)
+
+/-- Convert parameters to identifier expressions. -/
+private def paramsToArgs (params : List Parameter) : List StmtExprMd :=
+  params.map fun p => mkMd (.Var (.Local p.name))
+
+/-- Build a helper function that returns the conjunction of the given conditions. -/
+private def mkConditionProc (name : String) (params : List Parameter)
+    (conditions : List Condition) : Procedure :=
+  { name := mkId name
+    inputs := params
+    outputs := [⟨mkId "$result", { val := .TBool, source := none }⟩]
+    preconditions := []
+    decreases := none
+    isFunctional := true
+    body := .Transparent (conjoin (conditions.map (·.condition))) }
+
+/-- Build a postcondition function that takes all inputs and all outputs as
+    parameters and returns the conjunction of postconditions. The function is
+    marked as functional and does not call the original procedure.
+
+    For a procedure `foo(a, b) returns (x, y)` with postcondition `P(a, b, x, y)`,
+    generates:
+    ```
+    function foo$post(a, b, x, y) returns ($result : bool) {
+      P(a, b, x, y)
+    }
+    ```
+-/
+private def mkPostConditionProc (name : String)
+    (inputParams : List Parameter) (outputParams : List Parameter)
+    (conditions : List Condition) : Procedure :=
+  let allParams := inputParams ++ outputParams
+  { name := mkId name
+    inputs := allParams
+    outputs := [⟨mkId "$result", { val := .TBool, source := none }⟩]
+    preconditions := []
+    decreases := none
+    isFunctional := false
+    body := .Transparent (conjoin (conditions.map (·.condition))) }
+
+/-- Extract a combined summary from a list of conditions. -/
+private def combinedSummary (clauses : List Condition) : Option String :=
+  let summaries := clauses.filterMap (·.summary)
+  match summaries with
+  | [] => none
+  | [s] => some s
+  | ss => some (String.intercalate ", " ss)
+
+/-- Information about a procedure's contracts. -/
+private structure ContractInfo where
+  hasPreCondition : Bool
+  hasPostCondition : Bool
+  preName : String
+  postName : String
+  preSummary : Option String
+  postSummary : Option String
+  inputParams : List Parameter
+  outputParams : List Parameter
+
+/-- Collect contract info for all procedures with contracts. -/
+private def collectContractInfo (procs : List Procedure) : Std.HashMap String ContractInfo :=
+  procs.foldl (fun m proc =>
+    let postconds := getPostconditions proc.body
+    let hasPre := !proc.preconditions.isEmpty
+    let hasPost := !postconds.isEmpty
+    if hasPre || hasPost then
+      m.insert proc.name.text {
+        hasPreCondition := hasPre
+        hasPostCondition := hasPost
+        preName := preCondProcName proc.name.text
+        postName := postCondProcName proc.name.text
+        preSummary := combinedSummary proc.preconditions
+        postSummary := combinedSummary postconds
+        inputParams := proc.inputs
+        outputParams := proc.outputs
+      }
+    else m) {}
+
+/-- Collect contract info for all procedures, excluding free postconditions.
+    Used by `contractPassInCore` where free postconditions (added by the
+    transparency pass) should be left untouched. -/
+private def collectContractInfoNonFree (procs : List Procedure) : Std.HashMap String ContractInfo :=
+  procs.foldl (fun m proc =>
+    let postconds := (getPostconditions proc.body).filter (! ·.free)
+    let hasPre := !proc.preconditions.isEmpty
+    let hasPost := !postconds.isEmpty
+    if hasPre || hasPost then
+      m.insert proc.name.text {
+        hasPreCondition := hasPre
+        hasPostCondition := hasPost
+        preName := preCondProcName proc.name.text
+        postName := postCondProcName proc.name.text
+        preSummary := combinedSummary proc.preconditions
+        postSummary := combinedSummary postconds
+        inputParams := proc.inputs
+        outputParams := proc.outputs
+      }
+    else m) {}
+
+/-- Transform a procedure body to add assume/assert for its own contracts. -/
+private def transformProcBody (proc : Procedure) (info : ContractInfo) : Body :=
+  let inputArgs := paramsToArgs proc.inputs
+  let postconds := getPostconditions proc.body
+  let preAssume : List StmtExprMd :=
+    if info.hasPreCondition then
+      let preSrc := match proc.preconditions.head? with
+        | some pc => pc.condition.source
+        | none => none
+      [⟨.Assume (mkCall info.preName inputArgs), preSrc⟩]
+    else []
+  let postAssert : List StmtExprMd :=
+    if info.hasPostCondition then
+      postconds.map fun pc =>
+        let summary := pc.summary.getD "postcondition"
+        ⟨.Assert { condition := pc.condition, summary := some summary }, pc.condition.source⟩
+    else []
+  match proc.body with
+  | .Transparent body =>
+    .Transparent ⟨.Block (preAssume ++ [body] ++ postAssert) none, body.source⟩
+  | .Opaque _ (some impl) _ =>
+    .Opaque [] (some ⟨.Block (preAssume ++ [impl] ++ postAssert) none, impl.source⟩) []
+  | .Opaque _ none mods =>
+    .Opaque [] none mods
+  | .Abstract _ =>
+    .Abstract []
+  | b => b
+
+/-- Generate temporary variable assignments for input arguments at a call site.
+    Returns (temp declarations+assignments, temp variable references).
+    Uses the parameter types from the procedure's contract info so that
+    resolution can type-check the generated temporaries.
+    `callIdx` distinguishes multiple calls to the same procedure. -/
+private def mkTempAssignments (args : List StmtExprMd) (calleeName : String)
+    (inputParams : List Parameter) (callIdx : Nat) (src : Option FileRange)
+    : List StmtExprMd × List StmtExprMd :=
+  let indexed := args.zipIdx
+  let decls := indexed.map fun (arg, i) =>
+    let tempName := s!"${calleeName}${callIdx}$arg{i}"
+    let paramType := match inputParams[i]? with
+      | some p => p.type
+      | none => { val := .Unknown, source := none }
+    let param : Parameter := { name := mkId tempName, type := paramType }
+    ⟨StmtExpr.Assign [mkVarMd (.Declare param)] arg, src⟩
+  let refs := indexed.map fun (_, i) =>
+    let tempName := s!"${calleeName}${callIdx}$arg{i}"
+    mkMd (.Var (.Local (mkId tempName)))
+  (decls, refs)
+
+/-- Rewrite a single statement that may be a call to a contracted procedure.
+    Returns a list of statements (the original plus any inserted assert/assume).
+    Takes and returns a call counter for generating unique temp variable names.
+    When `isFunctional` is true, precondition checks use `assume` instead of
+    `assert` since asserts are not supported in functions during Core translation.
+
+    At call sites:
+    1. Assign input arguments to temporary variables.
+    2. Assert precondition using temps.
+    3. Execute the call using temps as arguments.
+    4. Assume postcondition using temps + output variables. -/
+private def rewriteStmt (contractInfoMap : Std.HashMap String ContractInfo)
+    (isFunctional : Bool) (callCounter : Nat) (e : StmtExprMd) : List StmtExprMd × Nat :=
+  let src := e.source
+  let mkWithSrc (se : StmtExpr) : StmtExprMd := ⟨se, src⟩
+  match e.val with
+  | .Assign targets (.mk (.StaticCall callee args) callSrc) =>
+    match contractInfoMap.get? callee.text with
+    | some info =>
+      let (tempDecls, tempRefs) := mkTempAssignments args callee.text info.inputParams callCounter src
+      let callWithTemps : StmtExprMd := ⟨.Assign targets ⟨.StaticCall callee tempRefs, callSrc⟩, src⟩
+      let preCheck := if info.hasPreCondition then
+        if isFunctional then
+          [mkWithSrc (.Assume (mkCall info.preName tempRefs))]
+        else
+          [mkWithSrc (.Assert { condition := mkCall info.preName tempRefs, summary := some (info.preSummary.getD "precondition") })]
+        else []
+      -- After the call, assume postcondition with temps (inputs) + output variables
+      let outputArgs := targets.filterMap fun t =>
+        match t.val with
+        | .Local name => some (mkMd (.Var (.Local name)))
+        | .Declare param => some (mkMd (.Var (.Local param.name)))
+        | _ => none
+      let postAssume := if info.hasPostCondition
+        then [mkWithSrc (.Assume (mkCall info.postName (tempRefs ++ outputArgs)))] else []
+      (tempDecls ++ preCheck ++ [callWithTemps] ++ postAssume, callCounter + 1)
+    | none => ([e], callCounter)
+  | .StaticCall callee args =>
+    match contractInfoMap.get? callee.text with
+    | some info =>
+      let (tempDecls, tempRefs) := mkTempAssignments args callee.text info.inputParams callCounter src
+      let preCheck := if info.hasPreCondition then
+        if isFunctional then
+          [mkWithSrc (.Assume (mkCall info.preName tempRefs))]
+        else
+          [mkWithSrc (.Assert { condition := mkCall info.preName tempRefs, summary := some (info.preSummary.getD "precondition") })]
+        else []
+      -- For bare calls with postconditions, capture outputs in temp variables
+      -- so we can pass them to the $post function.
+      let (callStmt, postAssume, returnValue) :=
+        if info.hasPostCondition && !info.outputParams.isEmpty then
+          let outputTempDecls := info.outputParams.zipIdx.map fun (p, i) =>
+            let tempName := s!"${callee.text}${callCounter}$out{i}"
+            mkVarMd (.Declare { name := mkId tempName, type := p.type })
+          let callWithOutputs : StmtExprMd :=
+            ⟨.Assign outputTempDecls ⟨.StaticCall callee tempRefs, src⟩, src⟩
+          let outputRefs := info.outputParams.zipIdx.map fun (_, i) =>
+            let tempName := s!"${callee.text}${callCounter}$out{i}"
+            mkMd (.Var (.Local (mkId tempName)))
+          let assume := [mkWithSrc (.Assume (mkCall info.postName (tempRefs ++ outputRefs)))]
+          -- If the procedure has a single output, append the output variable
+          -- reference so the expanded block evaluates to the call result
+          -- (needed when the call appears in expression position).
+          let retVal : List StmtExprMd := match outputRefs with
+            | [single] => [single]
+            | _ => []
+          (callWithOutputs, assume, retVal)
+        else
+          (mkWithSrc (.StaticCall callee tempRefs), [], [])
+      (tempDecls ++ preCheck ++ [callStmt] ++ postAssume ++ returnValue, callCounter + 1)
+    | none => ([e], callCounter)
+  | _ => ([e], callCounter)
+
+/-- Rewrite call sites in a statement/expression tree. Uses `mapStmtExprFlattenM`:
+    - `pre` intercepts `Assign targets (StaticCall ...)` to a contracted procedure,
+      handling it directly so the assignment targets are used as output variables
+      for the postcondition assume.
+    - `post` handles bare `StaticCall` to a contracted procedure anywhere in the
+      tree, returning the expanded list of statements (argument assignments,
+      precondition assert, call, postcondition assume, output variable reference).
+      For Block parents the list is flattened; for other parents it is wrapped
+      in a Block. -/
+private def rewriteCallSites (contractInfoMap : Std.HashMap String ContractInfo)
+    (isFunctional : Bool) (expr : StmtExprMd) : StmtExprMd :=
+  let rewriteStaticCall (counter : Nat) (callee : Identifier) (args : List StmtExprMd)
+      (info : ContractInfo) (src : Option FileRange)
+      : List StmtExprMd × Nat :=
+    let mkWithSrc (se : StmtExpr) : StmtExprMd := ⟨se, src⟩
+    let (tempDecls, tempRefs) := mkTempAssignments args callee.text info.inputParams counter src
+    let preCheck := if info.hasPreCondition then
+      if isFunctional then
+        [mkWithSrc (.Assume (mkCall info.preName tempRefs))]
+      else
+        [mkWithSrc (.Assert { condition := mkCall info.preName tempRefs, summary := some (info.preSummary.getD "precondition") })]
+      else []
+    let (callStmt, postAssume, returnValue) :=
+      if info.hasPostCondition && !info.outputParams.isEmpty then
+        let outputTempDecls := info.outputParams.zipIdx.map fun (p, i) =>
+          let tempName := s!"${callee.text}${counter}$out{i}"
+          mkVarMd (.Declare { name := mkId tempName, type := p.type })
+        let callWithOutputs : StmtExprMd :=
+          ⟨.Assign outputTempDecls ⟨.StaticCall callee tempRefs, src⟩, src⟩
+        let outputRefs := info.outputParams.zipIdx.map fun (_, i) =>
+          let tempName := s!"${callee.text}${counter}$out{i}"
+          mkMd (.Var (.Local (mkId tempName)))
+        let assume := [mkWithSrc (.Assume (mkCall info.postName (tempRefs ++ outputRefs)))]
+        let retVal : List StmtExprMd := match outputRefs with
+          | [single] => [single]
+          | _ => []
+        (callWithOutputs, assume, retVal)
+      else
+        (mkWithSrc (.StaticCall callee tempRefs), [], [])
+    (tempDecls ++ preCheck ++ [callStmt] ++ postAssume ++ returnValue, counter + 1)
+  let (result, _) := StateT.run (s := (0 : Nat)) <|
+    mapStmtExprFlattenM (m := StateM Nat)
+      -- Pre: intercept Assign targets (StaticCall ...) before recursion
+      (fun e => do
+        match e.val with
+        | .Assign targets (.mk (.StaticCall callee args) callSrc) =>
+          match contractInfoMap.get? callee.text with
+          | some info =>
+            let counter ← get
+            let src := e.source
+            let mkWithSrc (se : StmtExpr) : StmtExprMd := ⟨se, src⟩
+            -- Recurse into arguments using mapStmtExprM with the post logic
+            let args' ← args.mapM (mapStmtExprM (m := StateM Nat) (fun e' => do
+              match e'.val with
+              | .StaticCall callee' args' =>
+                match contractInfoMap.get? callee'.text with
+                | some info' =>
+                  let counter' ← get
+                  let (stmts, counter'') := rewriteStaticCall counter' callee' args' info' e'.source
+                  set counter''
+                  return ⟨.Block stmts none, e'.source⟩
+                | none => return e'
+              | _ => return e'))
+            let (tempDecls, tempRefs) := mkTempAssignments args' callee.text info.inputParams counter src
+            let callWithTemps : StmtExprMd := ⟨.Assign targets ⟨.StaticCall callee tempRefs, callSrc⟩, src⟩
+            let preCheck := if info.hasPreCondition then
+              if isFunctional then
+                [mkWithSrc (.Assume (mkCall info.preName tempRefs))]
+              else
+                [mkWithSrc (.Assert { condition := mkCall info.preName tempRefs, summary := some (info.preSummary.getD "precondition") })]
+              else []
+            let outputArgs := targets.filterMap fun t =>
+              match t.val with
+              | .Local name => some (mkMd (.Var (.Local name)))
+              | .Declare param => some (mkMd (.Var (.Local param.name)))
+              | _ => none
+            let postAssume := if info.hasPostCondition
+              then [mkWithSrc (.Assume (mkCall info.postName (tempRefs ++ outputArgs)))] else []
+            set (counter + 1)
+            return some (tempDecls ++ preCheck ++ [callWithTemps] ++ postAssume)
+          | none => return none
+        | _ => return none)
+      -- Post: handle bare StaticCall (not direct RHS of Assign to contracted proc)
+      (fun e => do
+        match e.val with
+        | .StaticCall callee args =>
+          match contractInfoMap.get? callee.text with
+          | some info =>
+            let counter ← get
+            let (stmts, counter') := rewriteStaticCall counter callee args info e.source
+            set counter'
+            return stmts
+          | none => return [e]
+        | _ => return [e]) expr
+  result
+
+/-- Rewrite call sites in all bodies of a procedure. -/
+private def rewriteCallSitesInProc (contractInfoMap : Std.HashMap String ContractInfo)
+    (proc : Procedure) : Procedure :=
+  let rw := rewriteCallSites contractInfoMap proc.isFunctional
+  match proc.body with
+  | .Transparent body =>
+    { proc with body := .Transparent (rw body) }
+  | .Opaque posts impl mods =>
+    let body := Body.Opaque (posts.map (·.mapCondition rw)) (impl.map rw) (mods.map rw)
+    { proc with body := body }
+  | _ => proc
+
+/-- Build an axiom expression from `invokeOn` trigger and ensures clauses.
+    Produces `∀ p1, ∀ p2, ..., ∀ pn :: { trigger } (ensures1 && ensures2 && ...)`.
+    The trigger controls when the SMT solver instantiates the axiom. -/
+private def mkInvokeOnAxiom (params : List Parameter) (trigger : StmtExprMd)
+    (postconds : List Condition) : StmtExprMd :=
+  let body := conjoin (postconds.map (·.condition))
+  -- Wrap in nested Forall from last param (innermost) to first (outermost).
+  -- The trigger is placed on the innermost quantifier.
+  params.foldr (init := (body, true)) (fun p (acc, isInnermost) =>
+    let trig := if isInnermost then some trigger else none
+    (mkMd (.Quantifier .Forall p trig acc), false)) |>.1
+
+/-- Run the contract pass on a Laurel program.
+    All procedures with contracts are transformed. -/
+def contractPass (program : Program) : Program :=
+  let contractInfoMap := collectContractInfo program.staticProcedures
+
+  -- Generate helper procedures for all procedures with contracts
+  let helperProcs := program.staticProcedures.flatMap fun proc =>
+    let postconds := getPostconditions proc.body
+    let preProc :=
+      if proc.preconditions.isEmpty then []
+      else [mkConditionProc (preCondProcName proc.name.text) proc.inputs proc.preconditions]
+    let postProc :=
+      if postconds.isEmpty then []
+      else [mkPostConditionProc (postCondProcName proc.name.text)
+              proc.inputs proc.outputs postconds]
+    preProc ++ postProc
+
+  -- Transform procedures: strip contracts, add assume/assert, rewrite call sites
+  let transformedProcs := program.staticProcedures.map fun proc =>
+    let proc := match proc.invokeOn with
+      | some trigger =>
+        let postconds := getPostconditions proc.body
+        if postconds.isEmpty then { proc with invokeOn := none }
+        else { proc with
+          axioms := [mkInvokeOnAxiom proc.inputs trigger postconds]
+          invokeOn := none }
+      | none => proc
+    let proc := match contractInfoMap.get? proc.name.text with
+      | some info =>
+        { proc with
+          preconditions := []
+          body := transformProcBody proc info }
+      | none => proc
+    -- Rewrite call sites in the procedure body
+    rewriteCallSitesInProc contractInfoMap proc
+
+  { program with staticProcedures := helperProcs ++ transformedProcs }
+
+/-- Transform a procedure body to add assume/assert for its own contracts,
+    inlining the contract expressions directly (no helper function calls).
+    Free postconditions are preserved in the body's postcondition list untouched. -/
+private def transformProcBodyInline (proc : Procedure) : Body :=
+  let postconds := getPostconditions proc.body
+  let freePostconds := postconds.filter (·.free)
+  let checkedPostconds := postconds.filter (! ·.free)
+  let preAssume : List StmtExprMd :=
+    if !proc.preconditions.isEmpty then
+      let preExpr := conjoin (proc.preconditions.map (·.condition))
+      let preSrc := match proc.preconditions.head? with
+        | some pc => pc.condition.source
+        | none => none
+      [⟨.Assume preExpr, preSrc⟩]
+    else []
+  let postAssert : List StmtExprMd :=
+    if !checkedPostconds.isEmpty then
+      checkedPostconds.map fun pc =>
+        let summary := pc.summary.getD "postcondition"
+        ⟨.Assert { condition := pc.condition, summary := some summary }, pc.condition.source⟩
+    else []
+  match proc.body with
+  | .Transparent body =>
+    .Transparent ⟨.Block (preAssume ++ [body] ++ postAssert) none, body.source⟩
+  | .Opaque _ (some impl) _ =>
+    .Opaque freePostconds (some ⟨.Block (preAssume ++ [impl] ++ postAssert) none, impl.source⟩) []
+  | .Opaque _ none mods =>
+    .Opaque freePostconds none mods
+  | .Abstract _ =>
+    .Abstract freePostconds
+  | b => b
+
+/-- Rewrite call sites in all bodies of a procedure, but leave free
+    postconditions untouched (they are managed by the transparency pass). -/
+private def rewriteCallSitesInProcSkipFree (contractInfoMap : Std.HashMap String ContractInfo)
+    (proc : Procedure) : Procedure :=
+  let rw := rewriteCallSites contractInfoMap proc.isFunctional
+  match proc.body with
+  | .Transparent body =>
+    { proc with body := .Transparent (rw body) }
+  | .Opaque posts impl mods =>
+    -- Only rewrite non-free postconditions; leave free ones untouched
+    let posts' := posts.map fun c =>
+      if c.free then c else c.mapCondition rw
+    let body := Body.Opaque posts' (impl.map rw) (mods.map rw)
+    { proc with body := body }
+  | _ => proc
+
+/-- Run the contract pass on an `UnorderedCoreWithLaurelTypes`.
+    - Own body: inlines contract expressions directly (no helper function calls).
+    - Call sites: uses helper procedures (`foo$pre`, `foo$post`) as in the
+      original `contractPass`. -/
+def contractPassInCore (uc : UnorderedCoreWithLaurelTypes) : UnorderedCoreWithLaurelTypes :=
+  let contractInfoMap := collectContractInfoNonFree uc.coreProcedures
+
+  -- Generate helper procedures for all procedures with non-free contracts
+  let helperProcs := uc.coreProcedures.flatMap fun proc =>
+    let postconds := (getPostconditions proc.body).filter (! ·.free)
+    let preProc :=
+      if proc.preconditions.isEmpty then []
+      else [mkConditionProc (preCondProcName proc.name.text) proc.inputs proc.preconditions]
+    let postProc :=
+      if postconds.isEmpty then []
+      else [mkPostConditionProc (postCondProcName proc.name.text)
+              proc.inputs proc.outputs postconds]
+    preProc ++ postProc
+
+  -- Transform core procedures: strip contracts, add assume/assert with inlined
+  -- expressions for own body, rewrite call sites using helpers
+  let nonExternalNames := uc.coreProcedures.map (·.name.text)
+  let transformedProcs := uc.coreProcedures.map fun proc =>
+    let proc := match proc.invokeOn with
+      | some trigger =>
+        let postconds := getPostconditions proc.body
+        if postconds.isEmpty then { proc with invokeOn := none }
+        else { proc with
+          axioms := [rewriteCallsToFunctional nonExternalNames
+                      (mkInvokeOnAxiom proc.inputs trigger postconds)]
+          invokeOn := none }
+      | none => proc
+    let hasContract := !proc.preconditions.isEmpty || !((getPostconditions proc.body).filter (! ·.free)).isEmpty
+    let proc := if hasContract then
+        { proc with
+          preconditions := []
+          body := transformProcBodyInline proc }
+      else proc
+    -- Rewrite call sites in the procedure body using helpers (skip free postconditions)
+    rewriteCallSitesInProcSkipFree contractInfoMap proc
+
+  -- Also rewrite call sites in functions (they may call contracted procedures)
+  -- Helper procedures are added as functions (they are functional/pure)
+  -- Apply rewriteCallsToFunctional so that procedure calls in helper bodies
+  -- (e.g. precondition helpers referencing procedures) are rewritten to their
+  -- $asFunction equivalents, matching what the transparency pass does.
+  let functionalHelpers := helperProcs.map fun p =>
+    let p := { p with isFunctional := true }
+    match p.body with
+    | .Transparent body =>
+      { p with body := .Transparent (rewriteCallsToFunctional nonExternalNames body) }
+    | _ => p
+  let allFunctions := (uc.functions ++ functionalHelpers).map fun proc =>
+    rewriteCallSitesInProc contractInfoMap proc
+
+  { uc with
+    coreProcedures := transformedProcs
+    functions := allFunctions }
+
+end -- public section
+end Strata.Laurel
diff --git a/Strata/Languages/Laurel/CoreDefinitionsForLaurel.lean b/Strata/Languages/Laurel/CoreDefinitionsForLaurel.lean
index 2df59b8ceb..23b8a2ec7b 100644
--- a/Strata/Languages/Laurel/CoreDefinitionsForLaurel.lean
+++ b/Strata/Languages/Laurel/CoreDefinitionsForLaurel.lean
@@ -27,16 +27,21 @@ program Laurel;
 
 datatype LaurelResolutionErrorPlaceholder {}
 datatype Float64IsNotSupportedYet {}
+datatype LaurelUnit { MkLaurelUnit() }
 
 // The types for these Map functions are incorrect.
 // We'll fix them when Laurel supports polymorphism
-function select(map: int, key: int) : int
+// And then we can remove the datatype Box as well
+// And remove the hacky filter in HeapParameterization
+datatype Box { MkBox() }
+
+function select(map: int, key: int) : Box
   external;
 
-function update(map: int, key: int, value: int) : int
+function update(map: int, key: int, value: int) : Box
   external;
 
-function const(value: int) : int
+function const(value: int) : Box
   external;
 
 #end
diff --git a/Strata/Languages/Laurel/CoreGroupingAndOrdering.lean b/Strata/Languages/Laurel/CoreGroupingAndOrdering.lean
index f75057d88f..9efe14f0cf 100644
--- a/Strata/Languages/Laurel/CoreGroupingAndOrdering.lean
+++ b/Strata/Languages/Laurel/CoreGroupingAndOrdering.lean
@@ -5,9 +5,10 @@
 -/
 
 module
-public import Strata.Languages.Laurel.Laurel
+public import Strata.Languages.Laurel.TransparencyPass
 import Strata.DL.Lambda.LExpr
 import Strata.DDM.Util.Graph.Tarjan
+import Strata.Languages.Laurel.Grammar.AbstractToConcreteTreeTranslator
 
 /-!
 ## Grouping and Ordering for Core Translation
@@ -15,8 +16,6 @@ import Strata.DDM.Util.Graph.Tarjan
 Utilities for computing the grouping and topological ordering of Laurel
 declarations before they are emitted as Strata Core declarations.
 
-- `groupDatatypesByScc` — groups mutually recursive datatypes into SCC groups
-  using Tarjan's SCC algorithm.
 - `computeSccDecls` — builds the procedure call graph, runs Tarjan's SCC
   algorithm, and returns each SCC as a list of procedures paired with a flag
   indicating whether the SCC is recursive. The result is in reverse topological
@@ -90,7 +89,7 @@ def collectStaticCallNames (expr : StmtExprMd) : List String :=
   | .InstanceCall t _ args =>
       collectStaticCallNames t ++ args.flatMap (fun a => collectStaticCallNames a)
   | .Old v | .Fresh v | .Assume v => collectStaticCallNames v
-  | .Assert ⟨cond, _summary⟩ => collectStaticCallNames cond
+  | .Assert ⟨cond, _summary, _⟩ => collectStaticCallNames cond
   | .ProveBy v p => collectStaticCallNames v ++ collectStaticCallNames p
   | .ReferenceEquals l r => collectStaticCallNames l ++ collectStaticCallNames r
   | .AsType t _ | .IsType t _ => collectStaticCallNames t
@@ -113,27 +112,24 @@ Build the procedure call graph, run Tarjan's SCC algorithm, and return each SCC
 as a list of procedures paired with a flag indicating whether the SCC is recursive.
 Results are in reverse topological order: dependencies before dependents.
 
-Procedures with an `invokeOn` trigger are placed as early as possible — before
-unrelated procedures without one — by stably partitioning them first before building
+Procedures with axioms are placed as early as possible — before
+unrelated procedures without them — by stably partitioning them first before building
 the graph. Tarjan then naturally assigns them lower indices, causing them to appear
 earlier in the output.
-
-External procedures are excluded.
 -/
-public def computeSccDecls (program : Program) : List (List Procedure × Bool) :=
-  -- External procedures are completely ignored (not translated to Core).
-  -- Stable partition: procedures with invokeOn come first, preserving relative
+public def computeSccDecls (program : UnorderedCoreWithLaurelTypes) : List (List Procedure × Bool) :=
+  -- Stable partition: procedures with axioms come first, preserving relative
   -- order within each group. Tarjan then places them earlier in the topological output.
-  let (withInvokeOn, withoutInvokeOn) :=
-    (program.staticProcedures.filter (fun p => !p.body.isExternal))
-    |>.partition (fun p => p.invokeOn.isSome)
-  let nonExternal : List Procedure := withInvokeOn ++ withoutInvokeOn
+  let allProcs := program.functions ++ program.coreProcedures
+  let (withAxioms, withoutAxioms) :=
+    allProcs.partition (fun p => !p.axioms.isEmpty)
+  let orderedProcs : List Procedure := withAxioms ++ withoutAxioms
 
-  -- Build a call-graph over all non-external procedures.
+  -- Build a call-graph over all procedures.
   -- An edge proc → callee means proc's body/contracts contain a StaticCall to callee.
-  let nonExternalArr : Array Procedure := nonExternal.toArray
+  let procsArr : Array Procedure := orderedProcs.toArray
   let nameToIdx : Std.HashMap String Nat :=
-    nonExternalArr.foldl (fun (acc : Std.HashMap String Nat × Nat) proc =>
+    procsArr.foldl (fun (acc : Std.HashMap String Nat × Nat) proc =>
       (acc.1.insert proc.name.text acc.2, acc.2 + 1)) ({}, 0) |>.1
 
   -- Collect all callee names from a procedure's body and contracts.
@@ -145,13 +141,14 @@ public def computeSccDecls (program : Program) : List (List Procedure × Bool) :
       | _ => []
     let contractExprs : List StmtExprMd :=
       proc.preconditions.map (·.condition) ++
-      proc.invokeOn.toList
+      proc.invokeOn.toList ++
+      proc.axioms
     (bodyExprs ++ contractExprs).flatMap collectStaticCallNames
 
   -- Build the OutGraph for Tarjan.
-  let n := nonExternalArr.size
+  let n := procsArr.size
   let graph : Strata.OutGraph n :=
-    nonExternalArr.foldl (fun (acc : Strata.OutGraph n × Nat) proc =>
+    procsArr.foldl (fun (acc : Strata.OutGraph n × Nat) proc =>
       let callerIdx := acc.2
       let g := acc.1
       let callees := procCallees proc
@@ -167,7 +164,7 @@ public def computeSccDecls (program : Program) : List (List Procedure × Bool) :
 
   sccs.toList.filterMap fun scc =>
     let procs := scc.toList.filterMap fun idx =>
-      nonExternalArr[idx.val]?
+      procsArr[idx.val]?
     if procs.isEmpty then none else
     let isRecursive := procs.length > 1 ||
       (match scc.toList.head? with
@@ -176,60 +173,85 @@ public def computeSccDecls (program : Program) : List (List Procedure × Bool) :
     some (procs, isRecursive)
 
 /--
-A single declaration in an ordered Laurel program. Declarations are in
+A single declaration in a CoreWithLaurelTypes program. Declarations are in
 dependency order (dependencies before dependents).
 -/
 public inductive OrderedDecl where
-  /-- A group of functions (single non-recursive, or mutually recursive). -/
-  | procs (procs : List Procedure) (isRecursive : Bool)
+  /-- A group of functions (single non-recursive, or mutually recursive).
+      Invariant: `funcs.length > 1 → isRecursive = true`. -/
+  | funcs (funcs : List Procedure) (isRecursive : Bool)
+  /-- A single (non-functional) procedure. -/
+  | procedure (procedure : Procedure)
   /-- A group of (possibly mutually recursive) datatypes. -/
   | datatypes (dts : List DatatypeDefinition)
   /-- A named constant. -/
   | constant (c : Constant)
 
 /--
-A Laurel program whose declarations have been grouped and topologically ordered.
-Produced by `orderProgram` from a `Program`.
+A program whose declarations have been grouped and topologically ordered,
+using Laurel types. Produced by `orderFunctionsAndProofs` from a
+`UnorderedCoreWithLaurelTypes`.
 -/
-public structure OrderedLaurel where
+public structure CoreWithLaurelTypes where
   decls : List OrderedDecl
 
-/--
-Group mutually recursive datatypes into SCC groups using Tarjan's SCC algorithm.
-Returns groups in topological order (dependencies before dependents).
--/
-public def groupDatatypesByScc (program : Program) : List (List DatatypeDefinition) :=
-  let laurelDatatypes := program.types.filterMap fun td => match td with
-    | .Datatype dt => some dt
-    | _ => none
-  let n := laurelDatatypes.length
-  if n == 0 then [] else
-  let nameToIdx : Std.HashMap String Nat :=
-    laurelDatatypes.foldlIdx (fun m i dt => m.insert dt.name.text i) {}
-  let edges : List (Nat × Nat) :=
-    laurelDatatypes.foldlIdx (fun acc i dt =>
-      (datatypeRefs dt).filterMap nameToIdx.get? |>.foldl (fun acc j => (j, i) :: acc) acc) []
-  let g := OutGraph.ofEdges! n edges
-  let dtsArr := laurelDatatypes.toArray
-  OutGraph.tarjan g |>.toList.filterMap fun comp =>
-    let members := comp.toList.filterMap fun idx => dtsArr[idx]?
-    if members.isEmpty then none else some members
+open Std (Format ToFormat)
 
-/--
-Group procedures into SCC groups and wrap them as `OrderedDecl.procs`.
--/
-public def groupProcsByScc (program : Program) : List OrderedDecl :=
-  (computeSccDecls program).map fun (procs, isRecursive) =>
-    OrderedDecl.procs procs isRecursive
+public section
+
+def formatOrderedDecl : OrderedDecl → Format
+  | .funcs funcs _ => Format.joinSep (funcs.map ToFormat.format) "\n\n"
+  | .procedure proc => ToFormat.format proc
+  | .datatypes dts => Format.joinSep (dts.map ToFormat.format) "\n\n"
+  | .constant c => ToFormat.format c
+
+instance : ToFormat OrderedDecl where
+  format := formatOrderedDecl
+
+def formatCoreWithLaurelTypes (p : CoreWithLaurelTypes) : Format :=
+  Format.joinSep (p.decls.map formatOrderedDecl) "\n\n"
+
+instance : ToFormat CoreWithLaurelTypes where
+  format := formatCoreWithLaurelTypes
+
+end -- public section
 
 /--
-Produce an `OrderedLaurel` from a `Program` by grouping and ordering
-procedures via SCC, collecting datatypes, and constants.
+Produce a `CoreWithLaurelTypes` from a `UnorderedCoreWithLaurelTypes` by
+computing a combined ordering of functions and proofs using the call graph,
+then collecting datatypes and constants.
+
+Functions are grouped into SCCs (for mutual recursion). Proofs are emitted
+as individual `procedure` decls. Both participate in the topological ordering
+so that axioms are available to functions that need them.
 -/
-public def orderProgram (program : Program) : OrderedLaurel :=
-  let datatypeDecls := (groupDatatypesByScc program).map OrderedDecl.datatypes
+public def orderFunctionsAndProofs (program : UnorderedCoreWithLaurelTypes) : CoreWithLaurelTypes :=
+  let datatypeDecls := (groupDatatypesByScc' program).map OrderedDecl.datatypes
   let constantDecls := program.constants.map OrderedDecl.constant
-  let procDecls := groupProcsByScc program
-  { decls := datatypeDecls ++ constantDecls ++ procDecls }
+  let funcNames : Std.HashSet String :=
+    program.functions.foldl (fun s p => s.insert p.name.text) {}
+  let orderedDecls := (computeSccDecls program).flatMap fun (procs, isRecursive) =>
+    -- Split the SCC into functions and proofs
+    let (funcs, proofs) := procs.partition (fun p => funcNames.contains p.name.text)
+    let funcDecl := if funcs.isEmpty then [] else [OrderedDecl.funcs funcs isRecursive]
+    let proofDecls := proofs.map OrderedDecl.procedure
+    funcDecl ++ proofDecls
+  { decls := datatypeDecls ++ constantDecls ++ orderedDecls }
+where
+  /-- Group datatypes from a UnorderedCoreWithLaurelTypes by SCC. -/
+  groupDatatypesByScc' (program : UnorderedCoreWithLaurelTypes) : List (List DatatypeDefinition) :=
+    let laurelDatatypes := program.datatypes
+    let n := laurelDatatypes.length
+    if n == 0 then [] else
+    let nameToIdx : Std.HashMap String Nat :=
+      laurelDatatypes.foldlIdx (fun m i dt => m.insert dt.name.text i) {}
+    let edges : List (Nat × Nat) :=
+      laurelDatatypes.foldlIdx (fun acc i dt =>
+        (datatypeRefs dt).filterMap nameToIdx.get? |>.foldl (fun acc j => (j, i) :: acc) acc) []
+    let g := OutGraph.ofEdges! n edges
+    let dtsArr := laurelDatatypes.toArray
+    OutGraph.tarjan g |>.toList.filterMap fun comp =>
+      let members := comp.toList.filterMap fun idx => dtsArr[idx]?
+      if members.isEmpty then none else some members
 
 end Strata.Laurel
diff --git a/Strata/Languages/Laurel/DatatypeTesters.lean b/Strata/Languages/Laurel/DatatypeTesters.lean
new file mode 100644
index 0000000000..542546d642
--- /dev/null
+++ b/Strata/Languages/Laurel/DatatypeTesters.lean
@@ -0,0 +1,54 @@
+/-
+  Copyright Strata Contributors
+
+  SPDX-License-Identifier: Apache-2.0 OR MIT
+-/
+module
+
+public import Strata.Languages.Laurel.Laurel
+
+/-!
+## Datatype Tester Generation
+
+For each constructor of a datatype, generate an external testing function.
+The tester function takes a single argument of the datatype's type and returns
+`bool`. Its name is determined by `DatatypeDefinition.testerName`.
+
+This pass runs at the start of the Laurel pipeline, before resolution, so that
+the tester functions are available as normal static procedures.
+-/
+
+namespace Strata.Laurel
+
+public section
+
+/-- Generate an external tester function for a single constructor of a datatype. -/
+private def mkTesterFunction (dt : DatatypeDefinition) (ctor : DatatypeConstructor) : Procedure :=
+  let testerName := dt.testerName ctor
+  let inputParam : Parameter := {
+    name := mkId "value"
+    type := { val := .UserDefined dt.name, source := none }
+  }
+  let outputParam : Parameter := {
+    name := mkId "$result"
+    type := { val := .TBool, source := none }
+  }
+  { name := mkId testerName
+    inputs := [inputParam]
+    outputs := [outputParam]
+    preconditions := []
+    decreases := none
+    isFunctional := true
+    body := .External }
+
+/-- Generate external tester functions for all constructors of all datatypes in the program. -/
+def generateDatatypeTesters (program : Program) : Program :=
+  let testers := program.types.flatMap fun td =>
+    match td with
+    | .Datatype dt => dt.constructors.map (mkTesterFunction dt)
+    | _ => []
+  { program with staticProcedures := testers ++ program.staticProcedures }
+
+end -- public section
+
+end Strata.Laurel
diff --git a/Strata/Languages/Laurel/DesugarShortCircuit.lean b/Strata/Languages/Laurel/DesugarShortCircuit.lean
index 6f4e9c5218..f779526d86 100644
--- a/Strata/Languages/Laurel/DesugarShortCircuit.lean
+++ b/Strata/Languages/Laurel/DesugarShortCircuit.lean
@@ -23,11 +23,11 @@ namespace Strata.Laurel
 
 public section
 
-private def bare (v : StmtExpr) : StmtExprMd := ⟨v, none⟩
 
 /-- Local rewrite of a single short-circuit node. Recursion is handled by `mapStmtExpr`. -/
-private def desugarShortCircuitNode (model : SemanticModel) (expr : StmtExprMd) : StmtExprMd :=
+private def desugarShortCircuitNode (imperativeCallees : List String) (expr : StmtExprMd) : StmtExprMd :=
   let source := expr.source
+  let wrap (v : StmtExpr) : StmtExprMd := ⟨v, source⟩
   match expr.val with
   | .PrimitiveOp op args =>
     match op, args with
@@ -35,20 +35,21 @@ private def desugarShortCircuitNode (model : SemanticModel) (expr : StmtExprMd)
     -- short-circuits converted to IfThenElse). The check still works because
     -- `containsAssignmentOrImperativeCall` recurses into IfThenElse.
     | .AndThen, [a, b] | .Implies, [a, b] =>
-      if containsAssignmentOrImperativeCall model b then
+      if containsAssignmentOrImperativeCall imperativeCallees b then
         let elseVal := match op with | .AndThen => false | _ => true
-        ⟨.IfThenElse a b (some (bare (.LiteralBool elseVal))), source⟩
+        ⟨.IfThenElse a b (some (wrap (.LiteralBool elseVal))), source⟩
       else expr
     | .OrElse, [a, b] =>
-      if containsAssignmentOrImperativeCall model b then
-        ⟨.IfThenElse a (bare (.LiteralBool true)) (some b), source⟩
+      if containsAssignmentOrImperativeCall imperativeCallees b then
+        ⟨.IfThenElse a (wrap (.LiteralBool true)) (some b), source⟩
       else expr
     | _, _ => expr
   | _ => expr
 
 /-- Desugar short-circuit operators in a program. -/
-def desugarShortCircuit (model : SemanticModel) (program : Program) : Program :=
-  mapProgram (mapStmtExpr (desugarShortCircuitNode model)) program
+def desugarShortCircuit (program : Program) : Program :=
+  let imperativeCallees := program.staticProcedures.map (fun p => p.name.text)
+  mapProgram (mapStmtExpr (desugarShortCircuitNode imperativeCallees)) program
 
 end -- public section
 end Strata.Laurel
diff --git a/Strata/Languages/Laurel/EliminateMultipleOutputs.lean b/Strata/Languages/Laurel/EliminateMultipleOutputs.lean
new file mode 100644
index 0000000000..ae932c9b7e
--- /dev/null
+++ b/Strata/Languages/Laurel/EliminateMultipleOutputs.lean
@@ -0,0 +1,166 @@
+/-
+  Copyright Strata Contributors
+
+  SPDX-License-Identifier: Apache-2.0 OR MIT
+-/
+module
+
+public import Strata.Languages.Laurel.TransparencyPass
+
+/-!
+# Eliminate Multiple Outputs
+
+Transforms bodiless functions with multiple outputs into functions that return
+a single synthesized result datatype. Call sites are rewritten to destructure
+the result using the generated accessors.
+
+This pass operates on `UnorderedCoreWithLaurelTypes → UnorderedCoreWithLaurelTypes`.
+-/
+
+namespace Strata.Laurel
+
+public section
+
+
+private def mkMd (e : StmtExpr) : StmtExprMd := { val := e, source := none }
+private def mkVarMd (v : Variable) : VariableMd := { val := v, source := none }
+private def mkTy (t : HighType) : HighTypeMd := { val := t, source := none }
+
+/-- Info about a function whose multiple outputs have been collapsed into a result datatype. -/
+private structure MultiOutInfo where
+  funcName : String
+  resultTypeName : String
+  constructorName : String
+  /-- Original output parameters (name, type). -/
+  outputs : List Parameter
+  /-- Number of input parameters (used to detect implicit heap args at call sites). -/
+  inputCount : Nat
+
+/-- Identify bodiless functions with multiple outputs and build info records. -/
+private def collectMultiOutFunctions (funcs : List Procedure) : List MultiOutInfo :=
+  funcs.filterMap fun f =>
+    if f.outputs.length > 1 && !f.body.isTransparent then
+      some {
+        funcName := f.name.text
+        resultTypeName := s!"{f.name.text}$result"
+        constructorName := s!"{f.name.text}$result$mk"
+        outputs := f.outputs
+        inputCount := f.inputs.length
+      }
+    else none
+
+/-- Generate a result datatype for a multi-output function. -/
+private def mkResultDatatype (info : MultiOutInfo) : DatatypeDefinition :=
+  let args := info.outputs.zipIdx.map fun (p, i) =>
+    { name := mkId s!"out{i}", type := p.type : Parameter }
+  { name := mkId info.resultTypeName
+    typeArgs := []
+    constructors := [{ name := mkId info.constructorName, args := args }] }
+
+/-- Transform a multi-output function to return the result datatype. -/
+private def transformFunction (info : MultiOutInfo) (proc : Procedure) : Procedure :=
+  let resultOutput : Parameter :=
+    { name := mkId "$result", type := mkTy (.UserDefined (mkId info.resultTypeName)) }
+  { proc with outputs := [resultOutput] }
+
+/-- Destructor name for field `outN` of the result datatype. -/
+private def destructorName (info : MultiOutInfo) (idx : Nat) : String :=
+  s!"{info.resultTypeName}..out{idx}"
+
+/-- Check whether a statement is an Assume node. -/
+private def isAssume (stmt : StmtExprMd) : Bool :=
+  match stmt.val with
+  | .Assume _ => true
+  | _ => false
+
+/-- Rewrite a single multi-output Assign into a temp declaration + destructuring
+    assignments. Any `Assume` statements from `following` that appear immediately
+    after the call are collected and placed after the destructuring assignments,
+    so they observe the post-call variable values.
+    Returns the rewritten statements and the number of consumed following statements. -/
+private def rewriteAssign (infoMap : Std.HashMap String MultiOutInfo)
+    (targets : List VariableMd) (callee : Identifier) (args : List StmtExprMd)
+    (callSrc : Option FileRange)
+    (following : List StmtExprMd) (counter : Nat) : Option (List StmtExprMd × Nat) :=
+  match infoMap.get? callee.text with
+  | some info =>
+    if targets.length ≤ info.outputs.length then
+      let tempName := s!"${callee.text}$temp{counter}"
+      let fullArgs := args
+      let tempDecl := mkMd (.Assign [mkVarMd (.Declare ⟨mkId tempName, mkTy (.UserDefined (mkId info.resultTypeName))⟩)]
+          ⟨.StaticCall callee fullArgs, callSrc⟩)
+      let assigns := targets.zipIdx.map fun (tgt, i) =>
+        mkMd (.Assign [tgt]
+          (mkMd (.StaticCall (mkId (destructorName info i))
+            [mkMd (.Var (.Local (mkId tempName)))])))
+      -- Collect any Assume statements that immediately follow the call.
+      -- These are placed after the destructuring assignments so they
+      -- observe the post-call values of output variables.
+      let assumes := following.takeWhile isAssume
+      let consumed := assumes.length
+      some (tempDecl :: assigns ++ assumes, consumed)
+    else none
+  | none => none
+
+/-- Rewrite a statement list, replacing multi-output call patterns.
+    When a multi-output Assign is followed by Assume statements (inserted by
+    the contract pass), the Assumes are placed after the destructuring
+    assignments so they reference post-call variable values. -/
+private def rewriteStmts (infoMap : Std.HashMap String MultiOutInfo)
+    (stmts : List StmtExprMd) : List StmtExprMd :=
+  let rec go (remaining : List StmtExprMd) (acc : List StmtExprMd) (counter : Nat) : List StmtExprMd :=
+    match remaining with
+    | [] => acc.reverse
+    | stmt :: rest =>
+      match stmt.val with
+      | .Assign targets ⟨.StaticCall callee args, callSrc⟩ =>
+        match rewriteAssign infoMap targets callee args callSrc rest counter with
+        | some (expanded, consumed) => go (rest.drop consumed) (expanded.reverse ++ acc) (counter + 1)
+        | none => go rest (stmt :: acc) counter
+      | _ => go rest (stmt :: acc) counter
+  termination_by remaining.length
+  go stmts [] 0
+
+/-- Rewrite blocks in a StmtExprMd tree to handle multi-output calls. -/
+private def rewriteExpr (infoMap : Std.HashMap String MultiOutInfo)
+    (expr : StmtExprMd) : StmtExprMd :=
+  mapStmtExpr (fun e =>
+    match e.val with
+    | .Block stmts label => ⟨.Block (rewriteStmts infoMap stmts) label, e.source⟩
+    | _ => e) expr
+
+/-- Rewrite all procedure bodies. -/
+private def rewriteProcedure (infoMap : Std.HashMap String MultiOutInfo)
+    (proc : Procedure) : Procedure :=
+  match proc.body with
+  | .Transparent b =>
+    -- Wrap in a block so rewriteStmts can process top-level statements
+    let wrapped := mkMd (.Block [b] none)
+    let rewritten := rewriteExpr infoMap wrapped
+    { proc with body := .Transparent rewritten }
+  | .Opaque posts (some impl) mods =>
+    let wrapped := mkMd (.Block [impl] none)
+    let rewritten := rewriteExpr infoMap wrapped
+    { proc with body := .Opaque posts (some rewritten) mods }
+  | _ => proc
+
+/-- Eliminate multiple outputs from a UnorderedCoreWithLaurelTypes. -/
+def eliminateMultipleOutputs (program : UnorderedCoreWithLaurelTypes)
+    : UnorderedCoreWithLaurelTypes :=
+  let infos := collectMultiOutFunctions program.functions
+  if infos.isEmpty then program else
+  let infoMap : Std.HashMap String MultiOutInfo :=
+    infos.foldl (fun m info => m.insert info.funcName info) {}
+  let newDatatypes := infos.map mkResultDatatype
+  let functions := program.functions.map fun f =>
+    match infoMap.get? f.name.text with
+    | some info => rewriteProcedure infoMap (transformFunction info f)
+    | none => rewriteProcedure infoMap f
+  let coreProcedures := program.coreProcedures.map fun p => rewriteProcedure infoMap p
+  { program with
+    functions := functions
+    coreProcedures := coreProcedures
+    datatypes := program.datatypes ++ newDatatypes }
+
+end -- public section
+end Strata.Laurel
diff --git a/Strata/Languages/Laurel/EliminateReturnStatements.lean b/Strata/Languages/Laurel/EliminateReturnStatements.lean
new file mode 100644
index 0000000000..b8ea0c1fad
--- /dev/null
+++ b/Strata/Languages/Laurel/EliminateReturnStatements.lean
@@ -0,0 +1,76 @@
+/-
+  Copyright Strata Contributors
+
+  SPDX-License-Identifier: Apache-2.0 OR MIT
+-/
+module
+
+public import Strata.Languages.Laurel.MapStmtExpr
+public import Strata.Languages.Laurel.TransparencyPass
+
+/-!
+# Eliminate Return Statements
+
+Replaces `return` statements in imperative procedure bodies with assignments
+to the output parameters followed by an `exit` to a labelled block that wraps
+the entire body. This ensures that code placed after the body block (e.g.,
+postcondition assertions inserted by the contract pass) is always reached.
+
+This pass should run after `EliminateReturnsInExpression` (which handles
+functional/expression-position returns) and before the contract pass.
+-/
+
+namespace Strata.Laurel
+
+public section
+
+private def returnLabel : String := "$return"
+
+/-- Transform a single procedure: wrap body in a labelled block and replace returns. -/
+private def eliminateReturnStmts (proc : Procedure) : Procedure :=
+  match proc.body with
+  | .Opaque postconds (some impl) mods =>
+    let impl' := replaceReturn proc.outputs impl
+    let wrapped := match impl'.val with
+      | .Block stmts none => ⟨.Block stmts (some returnLabel), impl'.source⟩
+      | _ => mkMd (.Block [impl'] (some returnLabel))
+    { proc with body := .Opaque postconds (some wrapped) mods }
+  | .Transparent body =>
+    let body' := replaceReturn proc.outputs body
+    let wrapped := match body'.val with
+      | .Block stmts none => ⟨.Block stmts (some returnLabel), body'.source⟩
+      | _ => mkMd (.Block [body'] (some returnLabel))
+    { proc with body := .Transparent wrapped }
+  | _ => proc
+where
+
+  mkMd (e : StmtExpr) : StmtExprMd := { val := e, source := proc.name.source }
+  mkVarMd (v : Variable) : VariableMd := { val := v, source := proc.name.source }
+
+  /-- Replace `Return val` with `output := val; exit "$return"` (or just `exit`
+    for valueless returns). Uses `mapStmtExpr` for bottom-up traversal. -/
+  replaceReturn (outputs : List Parameter) (expr : StmtExprMd) : StmtExprMd :=
+    mapStmtExpr (fun e =>
+      match e.val with
+      | .Return (some val) =>
+        match outputs with
+        | [out] =>
+          let assign := mkMd (.Assign [mkVarMd (.Local out.name)] val)
+          let exit := mkMd (.Exit returnLabel)
+          ⟨.Block [assign, exit] none, e.source⟩
+        | _ => mkMd (.Exit returnLabel)
+      | .Return none => mkMd (.Exit returnLabel)
+      | _ => e) expr
+
+/-- Transform a program by eliminating return statements in all procedure bodies. -/
+def eliminateReturnStatements (program : Program) : Program :=
+  { program with staticProcedures := program.staticProcedures.map eliminateReturnStmts }
+
+/-- Transform an `UnorderedCoreWithLaurelTypes` by eliminating return statements
+    in all core procedure bodies. -/
+def eliminateReturnStatementsInCore (uc : UnorderedCoreWithLaurelTypes) : UnorderedCoreWithLaurelTypes :=
+  { uc with coreProcedures := uc.coreProcedures.map eliminateReturnStmts }
+
+end -- public section
+
+end Strata.Laurel
diff --git a/Strata/Languages/Laurel/EliminateReturnsInExpression.lean b/Strata/Languages/Laurel/EliminateReturnsInExpression.lean
index b400d3690f..a4a4c0870a 100644
--- a/Strata/Languages/Laurel/EliminateReturnsInExpression.lean
+++ b/Strata/Languages/Laurel/EliminateReturnsInExpression.lean
@@ -5,7 +5,7 @@
 -/
 module
 
-public import Strata.Languages.Laurel.Laurel
+public import Strata.Languages.Laurel.TransparencyPass
 import Strata.Util.Tactics
 
 /-!
@@ -24,6 +24,8 @@ accumulating a result expression:
   - `if (cond) { body }` (no else) becomes `if cond then lastStmtToExpr(body) else acc`
   - Other statements are kept in a two-element block with the accumulator.
 
+This pass operates on `UnorderedCoreWithLaurelTypes`, transforming the
+`functions` list after the transparency pass has produced it.
 -/
 
 namespace Strata.Laurel
@@ -61,7 +63,7 @@ def stmtsToExpr (stmts : List StmtExprMd) (acc : StmtExprMd)
     | ⟨.IfThenElse cond thenBr none, ssrc⟩ =>
       ⟨.IfThenElse cond (lastStmtToExpr thenBr) (some acc'), ssrc⟩
     | _ =>
-      { val := .Block [s, acc'] none, source := none }
+      { val := .Block [s, acc'] none, source := s.source }
   termination_by (sizeOf stmts, 1)
 
 /--
@@ -104,16 +106,23 @@ def eliminateReturnsInExpression (proc : Procedure) : Procedure :=
     | .Transparent bodyExpr =>
       { proc with body := .Transparent (lastStmtToExpr bodyExpr) }
     | .Opaque postconds (some impl) modif =>
-      { proc with body := .Opaque postconds (some (lastStmtToExpr impl)) modif }
+      -- Handle the pattern produced by the transparency pass:
+      -- Block [Assign targets expr] none → apply lastStmtToExpr to expr
+      let impl' := match impl.val with
+        | .Block [⟨.Assign targets expr, src⟩] none =>
+          { impl with val := .Block [⟨.Assign targets (lastStmtToExpr expr), src⟩] none }
+        | _ => lastStmtToExpr impl
+      { proc with body := .Opaque postconds (some impl') modif }
     | _ => proc
 
 public section
 
 /--
-Transform a program by eliminating returns in all functional procedure bodies.
+Transform an `UnorderedCoreWithLaurelTypes` by eliminating returns in all
+functional procedure bodies (the `functions` list).
 -/
-def eliminateReturnsInExpressionTransform (program : Program) : Program :=
-  { program with staticProcedures := program.staticProcedures.map eliminateReturnsInExpression }
+def eliminateReturnsInExpressionTransform (uc : UnorderedCoreWithLaurelTypes) : UnorderedCoreWithLaurelTypes :=
+  { uc with functions := uc.functions.map eliminateReturnsInExpression }
 
 end -- public section
 
diff --git a/Strata/Languages/Laurel/FilterPrelude.lean b/Strata/Languages/Laurel/FilterPrelude.lean
index c4c2181c81..5f79295cd9 100644
--- a/Strata/Languages/Laurel/FilterPrelude.lean
+++ b/Strata/Languages/Laurel/FilterPrelude.lean
@@ -216,8 +216,6 @@ private def buildDependencyMap (prog : Laurel.Program)
         for c in dt.constructors do
           insertNew c.name.text (deps.insert name)
             s!"constructor '{c.name.text}' of datatype '{name}'"
-          insertNew (dt.testerName c) (deps.insert name)
-            s!"tester '{dt.testerName c}' of datatype '{name}'"
           for a in c.args do
             insertNew (dt.destructorName a) (deps.insert name)
               s!"destructor '{dt.destructorName a}'"
diff --git a/Strata/Languages/Laurel/Grammar/ConcreteToAbstractTreeTranslator.lean b/Strata/Languages/Laurel/Grammar/ConcreteToAbstractTreeTranslator.lean
index cf8545d95d..9d25738c57 100644
--- a/Strata/Languages/Laurel/Grammar/ConcreteToAbstractTreeTranslator.lean
+++ b/Strata/Languages/Laurel/Grammar/ConcreteToAbstractTreeTranslator.lean
@@ -520,6 +520,9 @@ def parseProcedure (arg : Arg) : TransM Procedure := do
         | _, _ => TransM.error s!"Expected body or externalBody operation, got {repr bodyOp.name}"
       | .option _ none => pure none
       | _ => TransM.error s!"Expected body, got {repr bodyArg}"
+    -- Do NOT wrap function bodies in an implicit Return here.
+    -- The EliminateReturnsInExpression pass treats the last expression
+    -- in a function body as the return value directly.
     -- Determine procedure body kind
     let procBody :=
       if isExternal then Body.External
diff --git a/Strata/Languages/Laurel/Grammar/LaurelGrammar.lean b/Strata/Languages/Laurel/Grammar/LaurelGrammar.lean
index c185d90edc..e4a061b934 100644
--- a/Strata/Languages/Laurel/Grammar/LaurelGrammar.lean
+++ b/Strata/Languages/Laurel/Grammar/LaurelGrammar.lean
@@ -9,7 +9,7 @@ module
 -- Laurel dialect definition, loaded from LaurelGrammar.st
 -- NOTE: Changes to LaurelGrammar.st are not automatically tracked by the build system.
 -- Update this file (e.g. this comment) to trigger a recompile after modifying LaurelGrammar.st.
--- Last grammar change: block format uses indent(2) with leading spaces for vertical layout.
+-- Last grammar change: ifThenElse prints then/else branches on new lines.
 public import Strata.DDM.Integration.Lean
 public meta import Strata.DDM.Integration.Lean
 
diff --git a/Strata/Languages/Laurel/Grammar/LaurelGrammar.st b/Strata/Languages/Laurel/Grammar/LaurelGrammar.st
index 5ddc8609f5..b6166444ad 100644
--- a/Strata/Languages/Laurel/Grammar/LaurelGrammar.st
+++ b/Strata/Languages/Laurel/Grammar/LaurelGrammar.st
@@ -98,10 +98,10 @@ op errorSummary(msg: Str): ErrorSummary => " summary " msg;
 
 // If-else
 category ElseBranch;
-op elseBranch(stmts : StmtExpr) : ElseBranch => @[prec(0)] " else " stmts;
+op elseBranch(stmts : StmtExpr) : ElseBranch => @[prec(0)] "\nelse " stmts;
 
 op ifThenElse (cond: StmtExpr, thenBranch: StmtExpr, elseBranch: Option ElseBranch): StmtExpr =>
-  @[prec(20)] "if " cond " then " thenBranch:0 elseBranch:0;
+  @[prec(20)] "if " cond "\nthen " thenBranch:0 elseBranch:0;
 
 op assert (cond : StmtExpr, errorMessage: Option ErrorSummary) : StmtExpr => @[prec(0)] "assert " cond:0 errorMessage:0;
 op assume (cond : StmtExpr) : StmtExpr => @[prec(0)] "assume " cond:0;
diff --git a/Strata/Languages/Laurel/HeapParameterization.lean b/Strata/Languages/Laurel/HeapParameterization.lean
index dae58c3caa..4c83d2c9f8 100644
--- a/Strata/Languages/Laurel/HeapParameterization.lean
+++ b/Strata/Languages/Laurel/HeapParameterization.lean
@@ -85,7 +85,7 @@ def collectExpr (expr : StmtExpr) : StateM AnalysisResult Unit := do
   | .Assigned n => collectExprMd n
   | .Old v => collectExprMd v
   | .Fresh v => collectExprMd v
-  | .Assert ⟨c, _⟩ => collectExprMd c
+  | .Assert ⟨c, _, _⟩ => collectExprMd c
   | .Assume c => collectExprMd c
   | .ProveBy v p => collectExprMd v; collectExprMd p
   | .ContractOf _ f => collectExprMd f
@@ -434,8 +434,8 @@ where
     | .Assigned n => return [⟨ .Assigned (← recurseOne n), source ⟩]
     | .Old v => return [⟨ .Old (← recurseOne v), source ⟩]
     | .Fresh v => return [⟨ .Fresh (← recurseOne v), source ⟩]
-    | .Assert ⟨condExpr, summary⟩ =>
-        return [⟨ .Assert { condition := ← recurseOne condExpr, summary }, source ⟩]
+    | .Assert ⟨condExpr, summary, free⟩ =>
+        return [⟨ .Assert { condition := ← recurseOne condExpr, summary, free }, source ⟩]
     | .Assume c => return [⟨ .Assume (← recurseOne c), source ⟩]
     | .ProveBy v p => return [⟨ .ProveBy (← recurseOne v) (← recurseOne p), source ⟩]
     | .ContractOf ty f => return [⟨ .ContractOf ty (← recurseOne f), source ⟩]
@@ -566,10 +566,17 @@ def heapParameterization (model: SemanticModel) (program : Program) : Program :=
     ([], state1)
   -- Generate Box datatype from all constructors used during transformation
   let boxDatatype : TypeDefinition :=
-    .Datatype { name := "Box", typeArgs := [], constructors := state2.usedBoxConstructors }
+    .Datatype {
+      name := "Box", typeArgs := [], constructors := state2.usedBoxConstructors }
+
+  let types := fieldDatatype :: boxDatatype :: heapConstants.types ++
+    -- The filter is a hack to deal with another hack,
+    -- the box that was added in CoreDefinitionsForLaurel.lean
+    -- because Laurel does not support polymorphism yet
+    types'.filter (fun td => td.name.text != "Box")
   { program with
     staticProcedures := heapConstants.staticProcedures ++ procs',
-    types := fieldDatatype :: boxDatatype :: heapConstants.types ++ types' }
+    types }
 
 end Strata.Laurel
 
diff --git a/Strata/Languages/Laurel/InferHoleTypes.lean b/Strata/Languages/Laurel/InferHoleTypes.lean
index ff80f37c5e..8f0ae491b3 100644
--- a/Strata/Languages/Laurel/InferHoleTypes.lean
+++ b/Strata/Languages/Laurel/InferHoleTypes.lean
@@ -149,9 +149,10 @@ private def inferExpr (expr : StmtExprMd) (expectedType : HighTypeMd) : InferHol
         | some d => pure (some (← inferExpr d (⟨ .TInt, source ⟩)))
         | none => pure none
       return ⟨.While (← inferExpr cond ⟨ .TBool, source ⟩) (← invs.mapM (inferExpr · ⟨ .TBool, source ⟩)) dec' (← inferExpr body ⟨ .TVoid, source⟩), source⟩
-  | .Assert ⟨condExpr, summary⟩ =>
-      return ⟨.Assert { condition := ← inferExpr condExpr ⟨ .TBool, source ⟩, summary }, source⟩
-  | .Assume cond => return ⟨.Assume (← inferExpr cond ⟨ .TBool, source ⟩), source⟩
+  | .Assert ⟨condExpr, summary, free⟩ =>
+      return ⟨.Assert { condition := ← inferExpr condExpr ⟨ .TBool, source ⟩, summary, free }, source⟩
+  | .Assume cond =>
+      return ⟨.Assume (← inferExpr cond ⟨ .TBool, source ⟩), source⟩
   | .Return (some retExpr) =>
       return ⟨.Return (some (← inferExpr retExpr (← get).currentOutputType)), source⟩
   | .Old v => return ⟨.Old (← inferExpr v expectedType), source⟩
@@ -180,6 +181,7 @@ private def inferProcedure (proc : Procedure) : InferHoleM Procedure := do
 
 /--
 Annotate every `.Hole` in the program with a type inferred from context.
+Returns the updated program and any diagnostics (e.g. holes whose type could not be inferred).
 -/
 def inferHoleTypes (model : SemanticModel) (program : Program) : Program × List DiagnosticModel × Statistics :=
   let initState : InferHoleState := { model := model, currentOutputType := { val := .Unknown, source := none }}
diff --git a/Strata/Languages/Laurel/InlineLocalVariablesInExpressions.lean b/Strata/Languages/Laurel/InlineLocalVariablesInExpressions.lean
new file mode 100644
index 0000000000..0e311bdc11
--- /dev/null
+++ b/Strata/Languages/Laurel/InlineLocalVariablesInExpressions.lean
@@ -0,0 +1,83 @@
+/-
+  Copyright Strata Contributors
+
+  SPDX-License-Identifier: Apache-2.0 OR MIT
+-/
+module
+
+public import Strata.Languages.Laurel.MapStmtExpr
+public import Strata.Languages.Laurel.TransparencyPass
+import Strata.Util.Tactics
+
+/-!
+# Inline Local Variables in Expression Position
+
+Replaces local variable declarations in functional procedure bodies with
+direct substitution of the initializer into the remaining statements of
+the block. This eliminates `LocalVariable` nodes from expression contexts
+so the Core translator does not need to handle let-bindings in expressions.
+
+Example:
+```
+function f() returns (r: int) {
+  var x: int := 1;
+  var y: int := x + 1;
+  y
+}
+```
+becomes:
+```
+function f() returns (r: int) {
+  0 + 1
+}
+```
+-/
+
+namespace Strata.Laurel
+
+public section
+
+/-- Substitute all occurrences of local variable `name` with `replacement` in `expr`. -/
+private def substIdentifier (name : Identifier) (replacement : StmtExprMd) (expr : StmtExprMd)
+    : StmtExprMd :=
+  mapStmtExpr (fun e =>
+    match e.val with
+    | .Var (.Local n) => if n == name then replacement else e
+    | _ => e) expr
+
+/-- Inline initialized local variables in a block, substituting their
+    initializers into the remaining statements. Non-Assign/Declare
+    statements are kept as-is. -/
+private def inlineLocalsInStmts (stmts : List StmtExprMd) : List StmtExprMd :=
+  match stmts with
+  | [] => []
+  | ⟨.Assign [⟨.Declare parameter, _⟩] initializer, _⟩ :: rest =>
+    let rest' := rest.map (substIdentifier parameter.name initializer)
+    inlineLocalsInStmts rest'
+  | s :: rest => s :: inlineLocalsInStmts rest
+termination_by stmts.length
+
+/-- Rewrite a single node: if it is a Block, inline any LocalVariable
+    declarations. Recursion into children is handled by `mapStmtExpr`. -/
+private def inlineLocalsNode (expr : StmtExprMd) : StmtExprMd :=
+  match expr.val with
+  | .Block stmts label =>
+    let stmts' := inlineLocalsInStmts stmts
+    match stmts' with
+    | [single] => single
+    | _ => ⟨.Block stmts' label, expr.source⟩
+  | _ => expr
+
+/-- Apply local-variable inlining to all functional procedure bodies. -/
+def inlineLocalVariablesInExpressions (program : UnorderedCoreWithLaurelTypes) : UnorderedCoreWithLaurelTypes :=
+  { program with functions := program.functions.map fun proc =>
+      match proc.body with
+      | .Transparent body =>
+        { proc with body := .Transparent (mapStmtExpr inlineLocalsNode body) }
+      | .Opaque postconds (some impl) modif =>
+        { proc with body := .Opaque postconds (some (mapStmtExpr inlineLocalsNode impl)) modif }
+      | _ => proc
+  }
+
+end -- public section
+end Strata.Laurel
diff --git a/Strata/Languages/Laurel/Laurel.lean b/Strata/Languages/Laurel/Laurel.lean
index 86ae83d022..da16a9c9ab 100644
--- a/Strata/Languages/Laurel/Laurel.lean
+++ b/Strata/Languages/Laurel/Laurel.lean
@@ -200,6 +200,9 @@ structure Procedure : Type where
       whose body is the ensures clause universally quantified over the procedure's inputs,
       with this expression as the SMT trigger. -/
   invokeOn : Option (AstNode StmtExpr) := none
+  /-- Axioms to emit alongside this procedure. Populated by the contract pass from
+      `invokeOn` and ensures clauses. -/
+  axioms : List (AstNode StmtExpr) := []
 
 /--
 A typed parameter for a procedure.
@@ -219,6 +222,11 @@ structure Condition where
   condition : AstNode StmtExpr
   /-- Optional human-readable summary describing the property being checked. -/
   summary : Option String := none
+  /-- When `true`, this condition is *free*: assumed but not checked.
+      A free precondition is assumed by the implementation but not asserted at
+      call sites. A free postcondition is assumed upon return from calls but
+      not checked on exit from implementations. -/
+  free : Bool := false
 
 /--
 The body of a procedure. A body can be transparent (with a visible
@@ -445,6 +453,41 @@ def HighType.isBool : HighType → Bool
   | TBool => true
   | _ => false
 
+/-- Return the constructor name of a `StmtExprMd` as a `String`. -/
+def StmtExpr.constructorName (e : StmtExpr) : String :=
+  match e with
+  | .IfThenElse .. => "IfThenElse"
+  | .Block .. => "Block"
+  | .While .. => "While"
+  | .Exit .. => "Exit"
+  | .Return .. => "Return"
+  | .LiteralInt .. => "LiteralInt"
+  | .LiteralBool .. => "LiteralBool"
+  | .LiteralString .. => "LiteralString"
+  | .LiteralDecimal .. => "LiteralDecimal"
+  | .Var .. => "Var"
+  | .Assign .. => "Assign"
+  | .PureFieldUpdate .. => "PureFieldUpdate"
+  | .StaticCall .. => "StaticCall"
+  | .PrimitiveOp .. => "PrimitiveOp"
+  | .New .. => "New"
+  | .This => "This"
+  | .ReferenceEquals .. => "ReferenceEquals"
+  | .AsType .. => "AsType"
+  | .IsType .. => "IsType"
+  | .InstanceCall .. => "InstanceCall"
+  | .Quantifier .. => "Quantifier"
+  | .Assigned .. => "Assigned"
+  | .Old .. => "Old"
+  | .Fresh .. => "Fresh"
+  | .Assert .. => "Assert"
+  | .Assume .. => "Assume"
+  | .ProveBy .. => "ProveBy"
+  | .ContractOf .. => "ContractOf"
+  | .Abstract => "Abstract"
+  | .All => "All"
+  | .Hole .. => "Hole"
+
 /-- Check whether a single modifies entry is the wildcard (`*`). -/
 def StmtExprMd.isWildcard (m : StmtExprMd) : Bool := match m.val with | .All => true | _ => false
 
diff --git a/Strata/Languages/Laurel/LaurelCompilationPipeline.lean b/Strata/Languages/Laurel/LaurelCompilationPipeline.lean
index 4c91d7c460..0a974a93c4 100644
--- a/Strata/Languages/Laurel/LaurelCompilationPipeline.lean
+++ b/Strata/Languages/Laurel/LaurelCompilationPipeline.lean
@@ -6,10 +6,15 @@
 module
 
 public import Strata.Languages.Laurel.LaurelToCoreTranslator
+import Strata.Languages.Laurel.DatatypeTesters
 import Strata.Languages.Laurel.DesugarShortCircuit
 import Strata.Languages.Laurel.EliminateReturnsInExpression
+import Strata.Languages.Laurel.EliminateReturnStatements
 import Strata.Languages.Laurel.EliminateValueReturns
+import Strata.Languages.Laurel.InlineLocalVariablesInExpressions
 import Strata.Languages.Laurel.ConstrainedTypeElim
+import Strata.Languages.Laurel.ContractPass
+import Strata.Languages.Laurel.EliminateMultipleOutputs
 import Strata.Languages.Laurel.TypeAliasElim
 import Strata.Languages.Core.Verifier
 import Strata.Util.Statistics
@@ -23,9 +28,10 @@ to Strata Core. The pipeline is:
 1. Prepend core definitions for Laurel.
 2. Run a sequence of Laurel-to-Laurel lowering passes (resolution, heap
    parameterization, type hierarchy, modifies clauses, hole inference,
-   desugaring, lifting, constrained type elimination).
-3. Group and order declarations into an `OrderedLaurel`.
-4. Translate the `OrderedLaurel` to a `Core.Program`.
+   desugaring, lifting, constrained type elimination, contract pass).
+3. Run the transparency pass to produce an `UnorderedCoreWithLaurelTypes`.
+4. Group and order declarations into a `CoreWithLaurelTypes`.
+5. Translate the `CoreWithLaurelTypes` to a `Core.Program`.
 -/
 
 open Core (VCResult VCResults VerifyOptions)
@@ -119,15 +125,11 @@ private def laurelPipeline : Array LaurelPass := #[
       let (p', stats) := eliminateHoles p
       (p', [], stats) },
   { name := "DesugarShortCircuit"
-    run := fun p m =>
-      (desugarShortCircuit m p, [], {}) },
+    run := fun p _ =>
+      (desugarShortCircuit p, [], {}) },
   { name := "LiftExpressionAssignments"
     run := fun p m =>
-      (liftExpressionAssignments m p, [], {}) },
-  { name := "EliminateReturns"
-    needsResolves := true
-    run := fun p _m =>
-      (eliminateReturnsInExpressionTransform p, [], {}) },
+      (liftExpressionAssignments p m [], [], {}) },
   { name := "ConstrainedTypeElim"
     needsResolves := true
     run := fun p m =>
@@ -151,6 +153,9 @@ private def runLaurelPasses (options : LaurelTranslateOptions)
     types := coreDefinitionsForLaurel.types ++ program.types
   }
 
+  -- Generate external tester functions for datatype constructors
+  let program := generateDatatypeTesters program
+
   -- Step 0: the input program before any passes
   emit "Initial" "laurel.st" program
 
@@ -181,13 +186,67 @@ private def runLaurelPasses (options : LaurelTranslateOptions)
       let result := resolve program (some model)
       let newErrors := result.errors.filter fun e => !resolutionErrors.contains e
       if !newErrors.isEmpty then
+        let newDiags := newErrors.toList.map fun d =>
+          { d with
+              message :=
+                s!"Internal error: resolution after '{pass.name}' introduced this diagnostic: {d.message}"
+              type := .StrataBug }
         emit pass.name "laurel.st" program
+        return (program, model, allDiags ++ newDiags, allStats)
       program := result.program
       model := result.model
     emit pass.name "laurel.st" program
 
   return (program, model, allDiags, allStats)
 
+/--
+Apply `liftExpressionAssignments` to the core (non-functional) procedures in an
+`UnorderedCoreWithLaurelTypes`. Only procedures whose names appear in the core
+procedure list are transformed; functions are left unchanged.
+-/
+def liftImperativeExpressionsInCore (uc : UnorderedCoreWithLaurelTypes)
+    (model : SemanticModel) : UnorderedCoreWithLaurelTypes :=
+  let imperativeCallees := uc.coreProcedures.map (·.name.text)
+  if imperativeCallees.isEmpty then uc
+  else
+    let liftedProgram := liftExpressionAssignments
+      { staticProcedures := uc.coreProcedures, staticFields := [], types := [], constants := [] }
+      model imperativeCallees
+    let liftedProcs := liftedProgram.staticProcedures
+    { uc with
+      functions := uc.functions
+      coreProcedures := liftedProcs
+    }
+
+/-- A single pass on the unordered Core representation. Each pass receives the
+    current `UnorderedCoreWithLaurelTypes` and the semantic model and returns
+    the (possibly modified) program. -/
+structure CorePass where
+  /-- Human-readable name, used for profiling and file emission. -/
+  name : String
+  /-- Whether `resolveUnorderedCore` should be run after the pass. -/
+  needsResolves : Bool := false
+  /-- The pass action. -/
+  run : UnorderedCoreWithLaurelTypes → SemanticModel → UnorderedCoreWithLaurelTypes
+
+/-- The ordered sequence of passes on the unordered Core representation. -/
+private def corePipeline : Array CorePass := #[
+  { name := "EliminateReturnStatements"
+    run := fun uc _m => eliminateReturnStatementsInCore uc },
+  { name := "ContractPass"
+    run := fun uc _m => contractPassInCore uc },
+  { name := "EliminateReturnsInExpression"
+    run := fun uc _m => eliminateReturnsInExpressionTransform uc },
+  { name := "EliminateMultipleOutputs"
+    run := fun uc _m => eliminateMultipleOutputs uc },
+  { name := "InlineLocalVariablesInExpressions"
+    needsResolves := true
+    run := fun uc _m => inlineLocalVariablesInExpressions uc },
+  { name := "LiftImperativeExpressionsInCore"
+    needsResolves := true
+    run := fun uc m => liftImperativeExpressionsInCore uc m }
+]
+
 /--
 Translate Laurel Program to Core Program, also returning the lowered Laurel program.
 
@@ -201,29 +260,51 @@ def translateWithLaurel (options : LaurelTranslateOptions) (program : Program)
     | some ctx => pure ctx
     | none => Strata.Pipeline.PipelineContext.create (outputMode := .quiet)
   runPipelineM options.keepAllFilesPrefix do
-    let (program, model, passDiags, stats) ← runLaurelPasses options pctx program
-    let ordered := orderProgram program
+  let (program, model, passDiags, stats) ← runLaurelPasses options pctx program
+  if ! passDiags.isEmpty then
+    return (none, passDiags, program, stats)
 
-    -- This early return is a simple way to protect against duplicative errors. Without this return,
-    -- resolution errors reported by Laurel would also be reported by Core.
-    -- There might be better solution that allows getting some resolution errors from Laurel and some verification errors from Core,
-    -- but that would need more consideration.
-    if passDiags.any (·.type != .Warning) then
-      return (none, passDiags, program, stats)
+  let unorderedCore := transparencyPass program
+  emit "transparencyPass" "core.st" unorderedCore
+  let mut unorderedCore := unorderedCore
+  let mut fnModel := model
 
-    let initState : TranslateState := { model := model, overflowChecks := options.overflowChecks }
+  for pass in corePipeline do
+    unorderedCore := pass.run unorderedCore fnModel
+    if pass.needsResolves then
+      let (uc', m', errors) := resolveUnorderedCore unorderedCore program (some fnModel)
+      if !errors.isEmpty then
+        let newDiags := errors.toList.map fun d =>
+          { d with message :=
+              s!"Internal error: resolution after '{pass.name}' introduced this diagnostic: {d.message}" }
+        emit pass.name "core.st" unorderedCore
+        return (none, passDiags ++ newDiags, program, stats)
+      unorderedCore := uc'
+      fnModel := m'
+    emit pass.name "unorderedCoreWithLaurelTypes.st" unorderedCore
+
+  let coreWithLaurelTypes := orderFunctionsAndProofs unorderedCore
+  -- This early return is a simple way to protect against duplicative errors. Without this return,
+  -- resolution errors reported by Laurel would also be reported by Core.
+  -- There might be better solution that allows getting some resolution errors from Laurel and some verification errors from Core,
+  -- but that would need more consideration.
+  if ! passDiags.isEmpty then
+    return (none, passDiags, program, stats)
+  else
+      emit "CoreWithLaurelTypes" "core.st" coreWithLaurelTypes
+    let initState : TranslateState := { model := fnModel, overflowChecks := options.overflowChecks }
     let (coreProgramOption, translateState) :=
-      runTranslateM initState (translateLaurelToCore options program ordered)
-    if let some coreProgram := coreProgramOption then
-      emit "CoreProgram" "core.st" coreProgram
-    let mut allDiagnostics := passDiags ++ translateState.diagnostics
-
+      runTranslateM initState (translateLaurelToCore options program coreWithLaurelTypes)
+    -- Because of the duplication between functions and proofs, this translation is liable to create duplicate diagnostics
+    -- User errors should be checked in an earlier phase, and all dumb translation errors are Strata bugs
+    let mut allDiagnostics := translateState.diagnostics.eraseDups
     if translateState.coreDiagnostics.length > 0 && allDiagnostics.isEmpty then
       -- The program was suppressed but no diagnostics explain why — report the core diagnostics
       -- that have a known source location (those without one are not actionable for the user).
-      let locatedDiags := translateState.coreDiagnostics.filter (·.fileRange != FileRange.unknown)
-      allDiagnostics := allDiagnostics ++ locatedDiags
+      allDiagnostics := allDiagnostics ++ translateState.coreDiagnostics
 
+    if coreProgramOption.isSome then
+      emit "Core" "core.st" coreProgramOption.get!
     let coreProgramOption :=
       if !translateState.coreDiagnostics.isEmpty then none else coreProgramOption
     return (coreProgramOption, allDiagnostics, program, stats)
diff --git a/Strata/Languages/Laurel/LaurelToCoreTranslator.lean b/Strata/Languages/Laurel/LaurelToCoreTranslator.lean
index cc33f2dae8..ec24a1cbe7 100644
--- a/Strata/Languages/Laurel/LaurelToCoreTranslator.lean
+++ b/Strata/Languages/Laurel/LaurelToCoreTranslator.lean
@@ -33,7 +33,7 @@ import Strata.Languages.Laurel.ConstrainedTypeElim
 import Strata.Util.Tactics
 
 open Core (VCResult VCResults VerifyOptions)
-open Core (intAddOp intSubOp intMulOp intSafeDivOp intSafeModOp intSafeDivTOp intSafeModTOp intNegOp intLtOp intLeOp intGtOp intGeOp boolAndOp boolOrOp boolNotOp boolImpliesOp strConcatOp)
+open Core (intAddOp intSubOp intMulOp intDivOp intSafeDivOp intModOp intSafeModOp intDivTOp intSafeDivTOp intModTOp intSafeModTOp intNegOp intLtOp intLeOp intGtOp intGeOp boolAndOp boolOrOp boolNotOp boolImpliesOp strConcatOp)
 open Core (realAddOp realSubOp realMulOp realDivOp realNegOp realLtOp realLeOp realGtOp realGeOp)
 
 namespace Strata.Laurel
@@ -68,6 +68,11 @@ structure TranslateState where
       why the program was deemed invalid so that if no other diagnostics explain
       the suppression, these can be surfaced to the user. -/
   coreDiagnostics : List DiagnosticModel := []
+  /-- When `true`, use safe division (`intSafeDivOp`) and safe datatype selectors
+      (with preconditions). When `false`, use unsafe division (`intDivOp`) and
+      unsafe datatype selectors (without preconditions).
+      Set to `true` for proof procedures and `false` for functions. -/
+  proof : Bool := false
 
 /-- The translation monad: state over Except, allowing both accumulated diagnostics and hard failures -/
 @[expose] abbrev TranslateM := OptionT (StateM TranslateState)
@@ -76,6 +81,25 @@ structure TranslateState where
 def emitDiagnostic (d : DiagnosticModel) : TranslateM Unit :=
   modify fun s => { s with diagnostics := s.diagnostics ++ [d] }
 
+/-- Adjust a datatype selector (destructor) name based on the `proof` flag.
+    Destructor names contain `..` (e.g. `IntList..head`, `IntList..head!`).
+    Tester names also contain `..` but start with `is` after the separator.
+    - `proof = true` → use safe selectors (strip `!` suffix)
+    - `proof = false` → use unsafe selectors (add `!` suffix) -/
+private def adjustSelectorName (name : String) (proof : Bool) : String :=
+  -- Only adjust destructor names (contain ".." but are not testers)
+  match name.splitOn ".." with
+  | [_, suffix] =>
+    if suffix.startsWith "is" then name  -- tester, leave unchanged
+    else if proof then
+      name
+      -- Safe: strip trailing "!"
+      -- if name.endsWith "!" then (name.dropEnd 1).toString else name
+    else
+      -- Unsafe: add trailing "!" if not already present
+      if name.endsWith "!" then name else name ++ "!"
+  | _ => name  -- not a destructor name, leave unchanged
+
 private def invalidCoreType (source : Option FileRange) (reason : String) : TranslateM LMonoTy := do
   modify fun s => { s with coreDiagnostics := s.coreDiagnostics ++
     [diagnosticFromSource source reason DiagnosticType.StrataBug] }
@@ -122,9 +146,6 @@ def lookupType (name : Identifier) : TranslateM LMonoTy := do
 def runTranslateM (s : TranslateState) (m : TranslateM α) : (Option α × TranslateState) :=
   m s
 
-def returnNone: TranslateM α :=
-  StateT.pure none
-
 /-- Allocate a fresh unique ID. -/
 private def freshId : TranslateM Nat := do
   let s ← get
@@ -158,11 +179,9 @@ def translateExpr (expr : StmtExprMd)
   let s ← get
   let model := s.model
   let md := astNodeToCoreMd expr
+  let proof := (← get).proof
   let disallowed (source : Option FileRange) (msg : String) : TranslateM Core.Expression.Expr := do
-    if isPureContext then
       throwExprDiagnostic $ diagnosticFromSource source msg
-    else
-      throwExprDiagnostic $ diagnosticFromSource source s!"{msg} (should have been lifted)" DiagnosticType.StrataBug
 
   match h: expr.val with
   | .LiteralBool b => return .const () (.boolConst b)
@@ -214,10 +233,10 @@ def translateExpr (expr : StmtExprMd)
     | .Add => return binOp (if isReal then realAddOp else intAddOp)
     | .Sub => return binOp (if isReal then realSubOp else intSubOp)
     | .Mul => return binOp (if isReal then realMulOp else intMulOp)
-    | .Div => return binOp (if isReal then realDivOp else intSafeDivOp)
-    | .Mod => return binOp intSafeModOp
-    | .DivT => return binOp intSafeDivTOp
-    | .ModT => return binOp intSafeModTOp
+    | .Div => return binOp (if isReal then realDivOp else if proof then intSafeDivOp else intDivOp)
+    | .Mod => return binOp (if (← get).proof then intSafeModOp else intModOp)
+    | .DivT => return binOp (if (← get).proof then intSafeDivTOp else intDivTOp)
+    | .ModT => return binOp (if (← get).proof then intSafeModTOp else intModTOp)
     | .Lt => return binOp (if isReal then realLtOp else intLtOp)
     | .Leq => return binOp (if isReal then realLeOp else intLeOp)
     | .Gt => return binOp (if isReal then realGtOp else intGtOp)
@@ -242,9 +261,10 @@ def translateExpr (expr : StmtExprMd)
   | .StaticCall callee args =>
       -- In a pure context, only Core functions (not procedures) are allowed
       if isPureContext && !model.isFunction callee then
-        disallowed expr.source "calls to procedures are not supported in functions or contracts"
+        disallowed expr.source s!"calls to procedures are not supported in functions or contracts. Callee: {callee}"
       else
-        let fnOp : Core.Expression.Expr := .op () ⟨callee.text, ()⟩ none
+        let calleeName := adjustSelectorName callee.text (← get).proof
+        let fnOp : Core.Expression.Expr := .op () ⟨calleeName, ()⟩ none
         args.attach.foldlM (fun acc ⟨arg, _⟩ => do
           let re ← translateExpr arg boundVars isPureContext
           return .app () acc re) fnOp
@@ -299,8 +319,12 @@ def translateExpr (expr : StmtExprMd)
       -- Field selects should have been eliminated by heap parameterization
       -- If we see one here, it's an error in the pipeline
       throwExprDiagnostic $ diagnosticFromSource expr.source s!"FieldSelect should have been eliminated by heap parameterization: {Std.ToFormat.format target}#{fieldId.text}" DiagnosticType.StrataBug
-  | .Block _ _ =>
-      throwExprDiagnostic $ diagnosticFromSource expr.source "block expression should have been lowered in a separate pass" DiagnosticType.StrataBug
+  | .Block (⟨ .Assign _ _, _⟩ :: tail) _ =>
+      disallowed expr.source "destructive assignments are not supported in functions or contracts"
+  | .Block (head :: tail) _ =>
+      throwExprDiagnostic $ diagnosticFromSource expr.source s!"block expression starting with {head.val.constructorName} should have been lowered in a separate pass" DiagnosticType.StrataBug
+  | .Block [] _ =>
+      throwExprDiagnostic $ diagnosticFromSource expr.source "empty block expression should have been lowered in a separate pass" DiagnosticType.StrataBug
   | .Return _ => disallowed expr.source "return expression should be lowered in a separate pass"
 
   | .AsType target _ => throwExprDiagnostic $ diagnosticFromSource expr.source "AsType expression translation" DiagnosticType.NotYetImplemented
@@ -346,9 +370,10 @@ private def exprAsUnusedInit (expr : StmtExprMd) (md : Imperative.MetaData Core.
     : TranslateM (List Core.Statement) := do
   let coreExpr ← translateExpr expr
   let id ← freshId
+  let model := (← get).model
   let ident : Core.CoreIdent := ⟨s!"$unused_{id}", ()⟩
-  let tyVarName := s!"$__ty_unused_{id}"
-  let coreType := LTy.forAll [tyVarName] (.ftvar tyVarName)
+  let ty ← translateType (computeExprType model expr)
+  let coreType := LTy.forAll [] ty
   return [Core.Statement.init ident coreType (.det coreExpr) md]
 
 def throwStmtDiagnostic (d : DiagnosticModel): TranslateM (List Core.Statement) := do
@@ -538,7 +563,8 @@ private def translateChecks (checks : List Condition) (labelBase : String)
     let md := match check.summary with
       | some msg => baseMd.pushElem Imperative.MetaData.propertySummary (.msg msg)
       | none => baseMd
-    let c : Core.Procedure.Check := { expr := checkExpr, md }
+    let attr := if check.free then Core.Procedure.CheckAttr.Free else .Default
+    let c : Core.Procedure.Check := { expr := checkExpr, attr, md }
     return (label, c))
 
 /--
@@ -677,8 +703,13 @@ def translateProcedureToFunction (options: LaurelTranslateOptions) (isRecursive:
   let body ← match proc.body with
     | .Transparent bodyExpr => some <$> translateExpr bodyExpr [] (isPureContext := true)
     | .Opaque _ (some bodyExpr) _ =>
-      emitDiagnostic (diagnosticFromSource proc.name.source "functions with postconditions are not yet supported")
-      some <$> translateExpr bodyExpr [] (isPureContext := true)
+      -- Extract the expression from an `Assign _ expr` or `Block [Assign _ expr]`
+      -- pattern produced by the transparency pass.
+      let expr := match bodyExpr.val with
+        | .Assign _ e => e
+        | .Block [⟨.Assign _ e, _⟩] none => e
+        | _ => bodyExpr
+      some <$> translateExpr expr [] (isPureContext := true)
     | _ => pure none
   let f : Core.Function := {
     name := ⟨proc.name.text, ()⟩
@@ -719,35 +750,31 @@ def translateDatatypeDefinition (dt : DatatypeDefinition)
 abbrev TranslateResult := (Option Core.Program) × (List DiagnosticModel)
 
 /--
-Translate an `OrderedLaurel` program to a `Core.Program`.
+Translate a `CoreWithLaurelTypes` program to a `Core.Program`.
 The `program` parameter is the lowered Laurel program, used for type definitions.
 -/
-def translateLaurelToCore (options: LaurelTranslateOptions) (program : Program) (ordered : OrderedLaurel): TranslateM Core.Program := do
+def translateLaurelToCore (options: LaurelTranslateOptions) (program : Program) (ordered : CoreWithLaurelTypes): TranslateM Core.Program := do
 
   let coreDecls ← ordered.decls.flatMapM fun
-    | .procs procs isRecursive => do
-      -- For each SCC, determine if it is purely functional or contains procedures.
-      let isFuncSCC := procs.all (·.isFunctional)
-      if isFuncSCC then
-        let funcs ← procs.mapM (translateProcedureToFunction options isRecursive)
-        if isRecursive then
-          let coreFuncs := funcs.filterMap (fun d => match d with
-            | .func f _ => some f
-            | _ => none)
-          return [Core.Decl.recFuncBlock coreFuncs mdWithUnknownLoc]
-        else
-          return funcs
+    | .funcs funcs isRecursive => do
+      modify fun s => { s with proof := false }
+      let nonExternal := funcs.filter (fun p => !p.body.isExternal)
+      let coreFuncs ← nonExternal.mapM (translateProcedureToFunction options isRecursive)
+      if isRecursive then
+        let coreFuncValues := coreFuncs.filterMap (fun d => match d with
+          | .func f _ => some f
+          | _ => none)
+        return [Core.Decl.recFuncBlock coreFuncValues mdWithUnknownLoc]
       else
-        let procDecls ← procs.flatMapM fun proc => do
-          let procDecl ← translateProcedure proc
-          -- Turn free postconditions into axioms placed right behind the related procedure
-          let axiomDecls : List Core.Decl ← match proc.invokeOn with
-            | none => pure []
-            | some trigger => do
-              let axDecl? ← translateInvokeOnAxiom proc trigger
-              pure axDecl?.toList
-          return [Core.Decl.proc procDecl (identifierToCoreMd proc.name)] ++ axiomDecls
-        return procDecls
+        return coreFuncs
+    | .procedure proc => do
+      modify fun s => { s with proof := true }
+      let procDecl ← translateProcedure proc
+      -- Translate axioms (populated by the contract pass from invokeOn + ensures)
+      let axiomDecls ← proc.axioms.mapM fun ax => do
+        let coreExpr ← translateExpr ax [] (isPureContext := true)
+        return Core.Decl.ax { name := s!"invokeOn_{proc.name.text}", e := coreExpr } (identifierToCoreMd proc.name)
+      return [Core.Decl.proc procDecl (identifierToCoreMd proc.name)] ++ axiomDecls
     | .datatypes dts => do
       let ldatatypes ← dts.mapM translateDatatypeDefinition
       return [Core.Decl.type (.data ldatatypes) mdWithUnknownLoc]
@@ -770,6 +797,7 @@ def translateLaurelToCore (options: LaurelTranslateOptions) (program : Program)
         emitDiagnostic $ diagnosticFromSource proc.name.source
           s!"Instance procedure '{proc.name.text}' on composite type '{ct.name.text}' is not yet supported"
           DiagnosticType.NotYetImplemented
+
   pure { decls := coreDecls }
 
 end -- public section
diff --git a/Strata/Languages/Laurel/LiftImperativeExpressions.lean b/Strata/Languages/Laurel/LiftImperativeExpressions.lean
index e87b24d480..92312b0b79 100644
--- a/Strata/Languages/Laurel/LiftImperativeExpressions.lean
+++ b/Strata/Languages/Laurel/LiftImperativeExpressions.lean
@@ -82,17 +82,13 @@ structure LiftState where
   condCounter : Nat := 0
   /-- All procedures in the program, used to look up return types of imperative calls -/
   procedures : List Procedure := []
+  /-- Names of callees whose calls should be treated as imperative (lifted) -/
+  imperativeCallees : List String := []
 
 @[expose] abbrev LiftM := StateM LiftState
 
 private def emptyMd : Option String := none
 
-/-- Wrap a StmtExpr value with empty metadata -/
-private def bare (v : StmtExpr) : StmtExprMd := ⟨v, none⟩
-
-/-- Wrap a HighType value with empty metadata -/
-private def bareType (v : HighType) : HighTypeMd := ⟨v, none⟩
-
 private def freshTempFor (varName : Identifier) : LiftM Identifier := do
   let counters := (← get).varCounters
   let counter := counters.find? (·.1 == varName) |>.map (·.2) |>.getD 0
@@ -102,7 +98,7 @@ private def freshTempFor (varName : Identifier) : LiftM Identifier := do
 private def freshCondVar : LiftM Identifier := do
   let n := (← get).condCounter
   modify fun s => { s with condCounter := n + 1 }
-  return s!"$c_{n}"
+  return s!"$cndtn_{n}"
 
 private def prepend (stmt : StmtExprMd) : LiftM Unit :=
   modify fun s => { s with prependedStmts := stmt :: s.prependedStmts }
@@ -111,24 +107,16 @@ private def onlyKeepSideEffectStmtsAndLast (stmts : List StmtExprMd) : LiftM (Li
   match stmts with
   | [] => return []
   | _ =>
+    -- return stmts
     let last := stmts.getLast!
     let nonLast ← stmts.dropLast.flatMapM (fun s =>
       match s.val with
       | .Var (.Declare ..) | .Assign ([⟨.Declare .., _⟩]) _ => do
-          -- This addPrepend is a hack to work around Core not having let expressions
-          -- Otherwise we could keep them in the block
-          prepend s
-          pure []
-      | .Assert _ => do
-          -- Hack to work around Core not supporting assert expressions
-          -- Otherwise we could keep them in the block
-          prepend s
-          pure []
-      | .Assume _ => do
-          -- Hack to work around Core not supporting assume expressions
-          -- Otherwise we could keep them in the block
-          prepend s
-          pure []
+          pure [s]
+      -- | .Assert _ => do
+      --     pure [s]
+      -- | .Assume _ => do
+      --     pure [s]
 
       /-
       Any other impure StmtExpr, like .Assign, .Exit or .Return,
@@ -157,22 +145,53 @@ private def computeType (expr : StmtExprMd) : LiftM HighTypeMd := do
   let s ← get
   return computeExprType s.model expr
 
-/-- Check if an expression contains any assignments (recursively). -/
-def containsAssignment (expr : StmtExprMd) : Bool :=
+/-- Check if an expression contains any assignments or imperative calls (recursively). -/
+def containsAssignmentOrImperativeCall (imperativeCallees : List String) (expr : StmtExprMd) : Bool :=
   match expr with
   | AstNode.mk val _ =>
   match val with
   | .Assign .. => true
-  | .StaticCall _ args => args.attach.any (fun x => containsAssignment x.val)
-  | .PrimitiveOp _ args => args.attach.any (fun x => containsAssignment x.val)
-  | .Block stmts _ => stmts.attach.any (fun x => containsAssignment x.val)
+  | .StaticCall name args1 =>
+    imperativeCallees.contains name.text ||
+      args1.attach.any (fun x => containsAssignmentOrImperativeCall imperativeCallees x.val)
+  | .PrimitiveOp _ args2 => args2.attach.any (fun x => containsAssignmentOrImperativeCall imperativeCallees x.val)
+  | .Block stmts _ => stmts.attach.any (fun x => containsAssignmentOrImperativeCall imperativeCallees x.val)
   | .IfThenElse cond th el =>
-      containsAssignment cond || containsAssignment th ||
-      match el with | some e => containsAssignment e | none => false
+      containsAssignmentOrImperativeCall imperativeCallees cond ||
+      containsAssignmentOrImperativeCall imperativeCallees th ||
+      match el with | some e => containsAssignmentOrImperativeCall imperativeCallees e | none => false
+  | .Assume cond => containsAssignmentOrImperativeCall imperativeCallees cond
+  | .Assert cond => containsAssignmentOrImperativeCall imperativeCallees cond.condition
+  | .InstanceCall target _ args =>
+      containsAssignmentOrImperativeCall imperativeCallees target ||
+      args.attach.any (fun x => containsAssignmentOrImperativeCall imperativeCallees x.val)
+  | .Quantifier _ _ trigger body =>
+      containsAssignmentOrImperativeCall imperativeCallees body ||
+      match trigger with | some t => containsAssignmentOrImperativeCall imperativeCallees t | none => false
+  | .Old value => containsAssignmentOrImperativeCall imperativeCallees value
+  | .Fresh value => containsAssignmentOrImperativeCall imperativeCallees value
+  | .ProveBy value proof =>
+      containsAssignmentOrImperativeCall imperativeCallees value ||
+      containsAssignmentOrImperativeCall imperativeCallees proof
+  | .ReferenceEquals lhs rhs =>
+      containsAssignmentOrImperativeCall imperativeCallees lhs ||
+      containsAssignmentOrImperativeCall imperativeCallees rhs
+  | .PureFieldUpdate target _ newValue =>
+      containsAssignmentOrImperativeCall imperativeCallees target ||
+      containsAssignmentOrImperativeCall imperativeCallees newValue
+  | .AsType target _ => containsAssignmentOrImperativeCall imperativeCallees target
+  | .IsType target _ => containsAssignmentOrImperativeCall imperativeCallees target
+  | .Assigned name => containsAssignmentOrImperativeCall imperativeCallees name
+  | .ContractOf _ func => containsAssignmentOrImperativeCall imperativeCallees func
+  | .Return (some v) => containsAssignmentOrImperativeCall imperativeCallees v
   | _ => false
   termination_by expr
   decreasing_by
-    all_goals ((try cases x); simp_all; try term_by_mem)
+    all_goals (try cases x)
+    all_goals (try simp_all)
+    all_goals (try have := Condition.sizeOf_condition_lt ‹_›)
+    all_goals (try term_by_mem)
+    all_goals omega
 
 /-- Like containsAssignment but does NOT recurse into Blocks (treats them as opaque).
     Used by assert/assume handlers to allow generated Block wrappers through. -/
@@ -213,10 +232,6 @@ def containsImperativeCall (model : SemanticModel) (expr : StmtExprMd) : Bool :=
   decreasing_by
     all_goals ((try cases x); simp_all; try term_by_mem)
 
-/-- Check if an expression contains any assignments or non-functional procedure calls (recursively). -/
-def containsAssignmentOrImperativeCall (model : SemanticModel) (expr : StmtExprMd) : Bool :=
-  containsAssignment expr || containsImperativeCall model expr
-
 /--
 Shared logic for lifting an assignment in expression position:
 prepends the assignment, creates before-snapshots for all targets,
@@ -231,7 +246,7 @@ private def liftAssignExpr (targets : List VariableMd) (seqValue : StmtExprMd)
     match target.val with
     | .Local varName =>
         let snapshotName ← freshTempFor varName
-        let varType ← computeType (bare (.Var (.Local varName)))
+        let varType ← computeType ⟨ .Var (.Local varName), source ⟩
         -- Snapshot goes before the assignment (cons pushes to front)
         prepend (⟨.Assign [⟨.Declare ⟨snapshotName, varType⟩, source⟩] (⟨.Var (.Local varName), source⟩), source⟩)
         setSubst varName snapshotName
@@ -254,8 +269,8 @@ def transformExpr (expr : StmtExprMd) : LiftM StmtExprMd := do
   | .Hole false (some holeType) =>
       -- Nondeterministic typed hole: lift to a fresh variable with no initializer (havoc)
       let holeVar ← freshCondVar
-      prepend (bare (.Var (.Declare ⟨holeVar, holeType⟩)))
-      return bare (.Var (.Local holeVar))
+      prepend ⟨ .Var (.Declare ⟨holeVar, holeType⟩), source ⟩
+      return ⟨.Var (.Local holeVar), source ⟩
 
   | .Assign targets value =>
       -- The expression result is the current substitution for the first target
@@ -272,7 +287,7 @@ def transformExpr (expr : StmtExprMd) : LiftM StmtExprMd := do
           if hasSubst then
             pure (⟨.Var (.Local (← getSubst param.name)), source⟩)
           else
-            return expr
+            pure (⟨.Var (.Local param.name), source⟩)
         | _ =>
           dbg_trace "Strata bug: non-identifier targets should have been removed before the lift expression phase";
           return expr
@@ -290,9 +305,10 @@ def transformExpr (expr : StmtExprMd) : LiftM StmtExprMd := do
 
   | .StaticCall callee args =>
     let model := (← get).model
+    let imperativeCallees := (← get).imperativeCallees
     let seqArgs ← args.reverse.mapM transformExpr
     let seqCall := ⟨.StaticCall callee seqArgs.reverse, source⟩
-    if model.isFunction callee then
+    if !imperativeCallees.contains callee.text then
       return seqCall
     else
       -- Imperative call in expression position: lift to an assignment.
@@ -309,49 +325,61 @@ def transformExpr (expr : StmtExprMd) : LiftM StmtExprMd := do
         | [single] => pure single.type
         | _ => computeType expr
       let liftedCall := [
-        ⟨.Var (.Declare ⟨callResultVar, callResultType⟩), source⟩,
-        ⟨.Assign [⟨.Local callResultVar, source⟩] seqCall, source⟩
+        ⟨ (.Var (.Declare ⟨callResultVar, callResultType⟩)), source ⟩,
+        ⟨.Assign [⟨ .Local callResultVar, source⟩] seqCall, source⟩
       ]
       modify fun s => { s with prependedStmts := s.prependedStmts ++ liftedCall}
-      return bare (.Var (.Local callResultVar))
+      return ⟨.Var (.Local callResultVar), source ⟩
 
   | .IfThenElse cond thenBranch elseBranch =>
-      let model :=  (← get).model
-      let thenHasAssign := containsAssignmentOrImperativeCall model thenBranch
+      let imperativeCallees := (← get).imperativeCallees
+      let thenHasAssign := containsAssignmentOrImperativeCall imperativeCallees thenBranch
       let elseHasAssign := match elseBranch with
-        | some e => containsAssignmentOrImperativeCall model e
+        | some e => containsAssignmentOrImperativeCall imperativeCallees e
         | none => false
       if thenHasAssign || elseHasAssign then
+
+        -- Infer type from the ORIGINAL then-branch (not the transformed one),
+        -- because the transformed expression may reference freshly generated
+        -- variables (e.g. $c_2) that don't exist in the SemanticModel yet.
+        let condType ← computeType thenBranch
+        let needsCondVar := condType.val != .TVoid
+
         -- Lift the entire if-then-else. Introduce a fresh variable for the result.
         let condVar ← freshCondVar
-        let seqCond ← transformExpr cond
         -- Save outer state
         let savedSubst := (← get).subst
         let savedPrepends := (← get).prependedStmts
+
+        let seqCond ← transformExpr cond
+        let condPrepends := (← get).prependedStmts
         -- Process then-branch from scratch
         modify fun s => { s with prependedStmts := [], subst := [] }
         let seqThen ← transformExpr thenBranch
         let thenPrepends ← takePrepends
-        let thenBlock := bare (.Block (thenPrepends ++ [⟨.Assign [⟨ .Local condVar, source⟩] seqThen, source⟩]) none)
+        let assignStmts := if needsCondVar then [⟨.Assign [⟨ .Local condVar, source⟩] seqThen, source⟩] else [seqThen]
+        let thenBlock := ⟨.Block (thenPrepends ++ assignStmts) none, source ⟩
         -- Process else-branch from scratch
         modify fun s => { s with prependedStmts := [], subst := [] }
         let seqElse ← match elseBranch with
           | some e => do
               let se ← transformExpr e
               let elsePrepends ← takePrepends
-              pure (some (bare (.Block (elsePrepends ++ [⟨.Assign [⟨ .Local condVar, source⟩] se, source⟩]) none)))
+              let assignStmts: List StmtExprMd := if needsCondVar then [⟨.Assign [⟨ .Local condVar, source⟩] se, source⟩] else [se];
+              pure (some (⟨.Block (elsePrepends ++ assignStmts) none, source ⟩))
           | none => pure none
         -- Restore outer state
         modify fun s => { s with subst := savedSubst, prependedStmts := savedPrepends }
-        -- Infer type from the ORIGINAL then-branch (not the transformed one),
-        -- because the transformed expression may reference freshly generated
-        -- variables (e.g. $c_2) that don't exist in the SemanticModel yet.
-        let condType ← computeType thenBranch
         -- IfThenElse added first (cons puts it deeper), then declaration (cons puts it on top)
         -- Output order: declaration, then if-then-else
         prepend (⟨.IfThenElse seqCond thenBlock seqElse, source⟩)
-        prepend (bare (.Var (.Declare ⟨condVar, condType⟩)))
-        return bare (.Var (.Local condVar))
+        if needsCondVar then
+          prepend ⟨.Var (.Declare ⟨condVar, condType⟩), source ⟩
+          modify fun s => { s with prependedStmts := condPrepends ++ s.prependedStmts }
+          return ⟨.Var (.Local condVar), source⟩
+        else
+          modify fun s => { s with prependedStmts := condPrepends ++ s.prependedStmts }
+          return default
       else
         -- No assignments in branches — recurse normally
         let seqCond ← transformExpr cond
@@ -399,10 +427,89 @@ def transformExpr (expr : StmtExprMd) : LiftM StmtExprMd := do
       else
         return expr
 
+  | .Assume cond =>
+      let prepends ← takePrepends
+      let seqCond ← transformExpr cond
+      let argPrepends ← takePrepends
+      modify fun s => { s with prependedStmts := argPrepends ++ [⟨.Assume seqCond, source⟩] ++ prepends }
+      default
+
+  | .Assert cond =>
+      let prepends ← takePrepends
+      let seqCond ← transformExpr cond.condition
+      let argPrepends ← takePrepends
+      modify fun s => { s with prependedStmts := argPrepends ++ [⟨.Assert { cond with condition := seqCond }, source⟩] ++ prepends }
+      default
+
+  | .Return (some retExpr) =>
+      let seqRet ← transformExpr retExpr
+      return ⟨.Return (some seqRet), source⟩
+
+  | .While cond invs dec body =>
+      let seqCond ← transformExpr cond
+      let seqInvs ← invs.mapM transformExpr
+      let seqDec ← match dec with
+        | some d => pure (some (← transformExpr d))
+        | none => pure none
+      let seqBody ← transformExpr body
+      return ⟨.While seqCond seqInvs seqDec seqBody, source⟩
+
+  | .PureFieldUpdate target fieldName newValue =>
+      let seqTarget ← transformExpr target
+      let seqNewValue ← transformExpr newValue
+      return ⟨.PureFieldUpdate seqTarget fieldName seqNewValue, source⟩
+
+  | .ReferenceEquals lhs rhs =>
+      let seqRhs ← transformExpr rhs
+      let seqLhs ← transformExpr lhs
+      return ⟨.ReferenceEquals seqLhs seqRhs, source⟩
+
+  | .AsType target ty =>
+      let seqTarget ← transformExpr target
+      return ⟨.AsType seqTarget ty, source⟩
+
+  | .IsType target ty =>
+      let seqTarget ← transformExpr target
+      return ⟨.IsType seqTarget ty, source⟩
+
+  | .InstanceCall target callee args =>
+      let seqArgs ← args.reverse.mapM transformExpr
+      let seqTarget ← transformExpr target
+      return ⟨.InstanceCall seqTarget callee seqArgs.reverse, source⟩
+
+  | .Quantifier mode param trigger body =>
+      let seqBody ← transformExpr body
+      let seqTrigger ← match trigger with
+        | some t => pure (some (← transformExpr t))
+        | none => pure none
+      return ⟨.Quantifier mode param seqTrigger seqBody, source⟩
+
+  | .Old value =>
+      let seqValue ← transformExpr value
+      return ⟨.Old seqValue, source⟩
+
+  | .Fresh value =>
+      let seqValue ← transformExpr value
+      return ⟨.Fresh seqValue, source⟩
+
+  | .Assigned name =>
+      let seqName ← transformExpr name
+      return ⟨.Assigned seqName, source⟩
+
+  | .ProveBy value proof =>
+      let seqValue ← transformExpr value
+      let seqProof ← transformExpr proof
+      return ⟨.ProveBy seqValue seqProof, source⟩
+
+  | .ContractOf ty func =>
+      let seqFunc ← transformExpr func
+      return ⟨.ContractOf ty seqFunc, source⟩
+
   | _ => return expr
   termination_by (sizeOf expr, 0)
   decreasing_by
-    all_goals (simp_all; try term_by_mem)
+    all_goals (simp_all; try have := Condition.sizeOf_condition_lt ‹_›; try term_by_mem)
+    all_goals (apply Prod.Lex.left; try term_by_mem; try omega)
 
 /--
 Process a statement, handling any assignments in its sub-expressions.
@@ -413,30 +520,28 @@ def transformStmt (stmt : StmtExprMd) : LiftM (List StmtExprMd) := do
   | AstNode.mk val source =>
   match val with
   | .Assert cond =>
-      -- Do not transform assert conditions with bare assignments — they are
-      -- semantic errors that should be rejected downstream.
-      -- But Blocks with assignments (generated multi-output call wrappers)
-      -- are handled by the Block case in transformExpr above.
-      if !containsBareAssignment cond.condition then
+      -- Do not transform assert conditions with assignments — they must be rejected.
+      -- But nondeterministic holes need to be lifted.
+      -- if containsNondetHole cond.condition && !containsAssignmentOrImperativeCall (← get).model cond.condition then
         let seqCond ← transformExpr cond.condition
         let prepends ← takePrepends
         modify fun s => { s with subst := [] }
         return prepends ++ [⟨.Assert { cond with condition := seqCond }, source⟩]
-      else
-        return [stmt]
+      -- else
+      --   return [stmt]
 
   | .Assume cond =>
-      if !containsBareAssignment cond then
+      -- if containsNondetHole cond && !containsAssignmentOrImperativeCall (← get).model cond then
         let seqCond ← transformExpr cond
         let prepends ← takePrepends
         modify fun s => { s with subst := [] }
         return prepends ++ [⟨.Assume seqCond, source⟩]
-      else
-        return [stmt]
+      -- else
+      --   return [stmt]
 
   | .Block stmts metadata =>
       let seqStmts ← stmts.mapM transformStmt
-      return [bare (.Block seqStmts.flatten metadata)]
+      return [⟨.Block seqStmts.flatten metadata, source ⟩]
 
   | .Var (.Declare _) =>
       return [stmt]
@@ -448,8 +553,8 @@ def transformStmt (stmt : StmtExprMd) : LiftM (List StmtExprMd) := do
       | AstNode.mk value _ =>
       match _: value with
       | .StaticCall callee args =>
-          let model := (← get).model
-          if model.isFunction callee then
+          let imperativeCallees := (← get).imperativeCallees
+          if !imperativeCallees.contains callee.text then
             let seqValue ← transformExpr valueMd
             let prepends ← takePrepends
             modify fun s => { s with subst := [] }
@@ -470,11 +575,11 @@ def transformStmt (stmt : StmtExprMd) : LiftM (List StmtExprMd) := do
       let condPrepends ← takePrepends
       let seqThen ← do
         let stmts ← transformStmt thenBranch
-        pure (bare (.Block stmts none))
+        pure ⟨ .Block stmts none, source ⟩
       let seqElse ← match elseBranch with
         | some e => do
             let se ← transformStmt e
-            pure (some (bare (.Block se none)))
+            pure (some (⟨.Block se none, source ⟩))
         | none => pure none
       return condPrepends ++ [⟨.IfThenElse seqCond seqThen seqElse, source⟩]
 
@@ -490,7 +595,7 @@ def transformStmt (stmt : StmtExprMd) : LiftM (List StmtExprMd) := do
       let decPrepends ← takePrepends
       let seqBody ← do
         let stmts ← transformStmt body
-        pure (bare (.Block stmts none))
+        pure ⟨.Block stmts none, source⟩
       return condPrepends ++ invPrepends ++ decPrepends ++
         [⟨.While seqCond seqInvs seqDec seqBody, source⟩]
 
@@ -505,6 +610,10 @@ def transformStmt (stmt : StmtExprMd) : LiftM (List StmtExprMd) := do
       modify fun s => { s with subst := [] }
       return prepends ++ [⟨.Return (some seqRet), source⟩]
 
+  | .PrimitiveOp name args =>
+      let seqArgs ← args.mapM transformExpr
+      let prepends ← takePrepends
+      return prepends ++ [⟨.PrimitiveOp name seqArgs, source⟩]
   | _ =>
       return [stmt]
   termination_by (sizeOf stmt, 0)
@@ -513,20 +622,20 @@ def transformStmt (stmt : StmtExprMd) : LiftM (List StmtExprMd) := do
     all_goals (apply Prod.Lex.left; try term_by_mem)
 end
 
-def transformProcedureBody (body : StmtExprMd) : LiftM StmtExprMd := do
+def transformProcedureBody (source: Option FileRange) (body : StmtExprMd) : LiftM StmtExprMd := do
   let stmts ← transformStmt body
   match stmts with
   | [single] => pure single
-  | multiple => pure (bare (.Block multiple none))
+  | multiple => pure ⟨.Block multiple none, source ⟩
 
 def transformProcedure (proc : Procedure) : LiftM Procedure := do
   modify fun s => { s with subst := [], prependedStmts := [], varCounters := [] }
   match proc.body with
   | .Transparent bodyExpr =>
-      let seqBody ← transformProcedureBody bodyExpr
+      let seqBody ← transformProcedureBody proc.name.source bodyExpr
       pure { proc with body := .Transparent seqBody }
   | .Opaque postconds impl modif =>
-      let impl' ← impl.mapM transformProcedureBody
+      let impl' ← impl.mapM (transformProcedureBody proc.name.source)
       pure { proc with body := .Opaque postconds impl' modif }
   | .Abstract _ =>
       pure proc
@@ -535,10 +644,15 @@ def transformProcedure (proc : Procedure) : LiftM Procedure := do
 
 /--
 Transform a program to lift all assignments that occur in an expression context.
+When `procedureNames` is non-empty, only procedures whose name appears in the
+list are transformed; all others are left unchanged. When `procedureNames` is
+empty, no procedures are transformed.
 -/
-def liftExpressionAssignments (model: SemanticModel) (program : Program) : Program :=
-  let initState : LiftState := { model := model }
-  let (seqProcedures, _) := (program.staticProcedures.mapM transformProcedure).run initState
+def liftExpressionAssignments (program : Program)
+    (model : SemanticModel) (imperativeCallees : List String) : Program :=
+  let initState : LiftState := { model := model, imperativeCallees := imperativeCallees }
+  let transform := program.staticProcedures.mapM transformProcedure
+  let (seqProcedures, _) := transform.run initState
   { program with staticProcedures := seqProcedures }
 
 end -- public section
diff --git a/Strata/Languages/Laurel/MapStmtExpr.lean b/Strata/Languages/Laurel/MapStmtExpr.lean
index e3892bae93..ca8394f96c 100644
--- a/Strata/Languages/Laurel/MapStmtExpr.lean
+++ b/Strata/Languages/Laurel/MapStmtExpr.lean
@@ -106,6 +106,175 @@ decreasing_by
 def mapStmtExpr (f : StmtExprMd → StmtExprMd) (expr : StmtExprMd) : StmtExprMd :=
   (mapStmtExprM (m := Id) f expr)
 
+/--
+Bottom-up monadic traversal with a pre-filter. Before recursing into a node's
+children, `pre` is called. If `pre` returns `some result`, that result is used
+directly (children are NOT recursed into). If `pre` returns `none`, normal
+bottom-up recursion proceeds and `post` is applied after children are rebuilt.
+-/
+def mapStmtExprPrePostM [Monad m] (pre : StmtExprMd → m (Option StmtExprMd))
+    (post : StmtExprMd → m StmtExprMd) (expr : StmtExprMd) : m StmtExprMd := do
+  match ← pre expr with
+  | some result => return result
+  | none =>
+  let source := expr.source
+  let rebuilt ← match _h : expr.val with
+  | .IfThenElse cond th el =>
+    pure ⟨.IfThenElse (← mapStmtExprPrePostM pre post cond) (← mapStmtExprPrePostM pre post th)
+      (← el.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e), source⟩
+  | .Block stmts label =>
+    pure ⟨.Block (← stmts.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e) label, source⟩
+  | .While cond invs dec body =>
+    pure ⟨.While (← mapStmtExprPrePostM pre post cond)
+      (← invs.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e)
+      (← dec.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e)
+      (← mapStmtExprPrePostM pre post body), source⟩
+  | .Return v =>
+    pure ⟨.Return (← v.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e), source⟩
+  | .Assign targets value =>
+    let targets' ← targets.attach.mapM fun ⟨v, _⟩ => do
+      let ⟨vv, vs⟩ := v
+      match vv with
+      | .Field target fieldName =>
+        pure ⟨Variable.Field (← mapStmtExprPrePostM pre post target) fieldName, vs⟩
+      | .Local _ | .Declare _ => pure v
+    pure ⟨.Assign targets' (← mapStmtExprPrePostM pre post value), source⟩
+  | .Var (.Field target fieldName) =>
+    pure ⟨.Var (.Field (← mapStmtExprPrePostM pre post target) fieldName), source⟩
+  | .PureFieldUpdate target fieldName newValue =>
+    pure ⟨.PureFieldUpdate (← mapStmtExprPrePostM pre post target) fieldName (← mapStmtExprPrePostM pre post newValue), source⟩
+  | .StaticCall callee args =>
+    pure ⟨.StaticCall callee (← args.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e), source⟩
+  | .PrimitiveOp op args =>
+    pure ⟨.PrimitiveOp op (← args.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e), source⟩
+  | .ReferenceEquals lhs rhs =>
+    pure ⟨.ReferenceEquals (← mapStmtExprPrePostM pre post lhs) (← mapStmtExprPrePostM pre post rhs), source⟩
+  | .AsType target ty =>
+    pure ⟨.AsType (← mapStmtExprPrePostM pre post target) ty, source⟩
+  | .IsType target ty =>
+    pure ⟨.IsType (← mapStmtExprPrePostM pre post target) ty, source⟩
+  | .InstanceCall target callee args =>
+    pure ⟨.InstanceCall (← mapStmtExprPrePostM pre post target) callee
+      (← args.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e), source⟩
+  | .Quantifier mode param trigger body =>
+    pure ⟨.Quantifier mode param (← trigger.attach.mapM fun ⟨e, _⟩ => mapStmtExprPrePostM pre post e)
+      (← mapStmtExprPrePostM pre post body), source⟩
+  | .Assigned name =>
+    pure ⟨.Assigned (← mapStmtExprPrePostM pre post name), source⟩
+  | .Old value =>
+    pure ⟨.Old (← mapStmtExprPrePostM pre post value), source⟩
+  | .Fresh value =>
+    pure ⟨.Fresh (← mapStmtExprPrePostM pre post value), source⟩
+  | .Assert cond =>
+    pure ⟨.Assert { cond with condition := ← mapStmtExprPrePostM pre post cond.condition }, source⟩
+  | .Assume cond =>
+    pure ⟨.Assume (← mapStmtExprPrePostM pre post cond), source⟩
+  | .ProveBy value proof =>
+    pure ⟨.ProveBy (← mapStmtExprPrePostM pre post value) (← mapStmtExprPrePostM pre post proof), source⟩
+  | .ContractOf ty func =>
+    pure ⟨.ContractOf ty (← mapStmtExprPrePostM pre post func), source⟩
+  | .Exit _ | .LiteralInt _ | .LiteralBool _ | .LiteralString _ | .LiteralDecimal _
+  | .Var (.Local _) | .Var (.Declare _) | .New _ | .This | .Abstract | .All | .Hole .. => pure expr
+  post rebuilt
+termination_by sizeOf expr
+decreasing_by
+  all_goals simp_wf
+  all_goals (try have := AstNode.sizeOf_val_lt expr)
+  all_goals (try have := Condition.sizeOf_condition_lt ‹_›)
+  all_goals (try term_by_mem)
+  all_goals (cases expr; simp_all; omega)
+
+/--
+Bottom-up monadic traversal where `post` returns a list of statements.
+- For `Block` nodes: each child is processed and the resulting lists are
+  flattened into the block's statement list.
+- For all other nodes: if `post` returns a single element, that element is
+  used directly. If it returns multiple elements, they are wrapped in a new
+  `Block none`.
+
+`pre` works the same as in `mapStmtExprPrePostM`: returning `some` skips
+recursion into children.
+-/
+def mapStmtExprFlattenM [Monad m] (pre : StmtExprMd → m (Option (List StmtExprMd)))
+    (post : StmtExprMd → m (List StmtExprMd)) (expr : StmtExprMd) : m StmtExprMd := do
+  let collapse (results : List StmtExprMd) (src : Option FileRange) : StmtExprMd :=
+    match results with
+    | [single] => single
+    | many => ⟨.Block many none, src⟩
+  let rec go (e : StmtExprMd) : m StmtExprMd := do
+    match ← pre e with
+    | some results => return collapse results e.source
+    | none =>
+    let source := e.source
+    let rebuilt ← match _h : e.val with
+    | .IfThenElse cond th el =>
+      pure ⟨.IfThenElse (← go cond) (← go th)
+        (← el.attach.mapM fun ⟨x, _⟩ => go x), source⟩
+    | .Block stmts label =>
+      let flatStmts ← stmts.attach.flatMapM fun ⟨x, _⟩ => do
+        match ← pre x with
+        | some results => return results
+        | none =>
+        let r ← go x
+        post r
+      pure ⟨.Block flatStmts label, source⟩
+    | .While cond invs dec body =>
+      pure ⟨.While (← go cond)
+        (← invs.attach.mapM fun ⟨x, _⟩ => go x)
+        (← dec.attach.mapM fun ⟨x, _⟩ => go x)
+        (← go body), source⟩
+    | .Return v =>
+      pure ⟨.Return (← v.attach.mapM fun ⟨x, _⟩ => go x), source⟩
+    | .Assign targets value =>
+      let targets' ← targets.attach.mapM fun ⟨v, _⟩ => do
+        let ⟨vv, vs⟩ := v
+        match vv with
+        | .Field target fieldName =>
+          pure ⟨Variable.Field (← go target) fieldName, vs⟩
+        | .Local _ | .Declare _ => pure v
+      pure ⟨.Assign targets' (← go value), source⟩
+    | .Var (.Field target fieldName) =>
+      pure ⟨.Var (.Field (← go target) fieldName), source⟩
+    | .PureFieldUpdate target fieldName newValue =>
+      pure ⟨.PureFieldUpdate (← go target) fieldName (← go newValue), source⟩
+    | .StaticCall callee args =>
+      pure ⟨.StaticCall callee (← args.attach.mapM fun ⟨x, _⟩ => go x), source⟩
+    | .PrimitiveOp op args =>
+      pure ⟨.PrimitiveOp op (← args.attach.mapM fun ⟨x, _⟩ => go x), source⟩
+    | .ReferenceEquals lhs rhs =>
+      pure ⟨.ReferenceEquals (← go lhs) (← go rhs), source⟩
+    | .AsType target ty =>
+      pure ⟨.AsType (← go target) ty, source⟩
+    | .IsType target ty =>
+      pure ⟨.IsType (← go target) ty, source⟩
+    | .InstanceCall target callee args =>
+      pure ⟨.InstanceCall (← go target) callee
+        (← args.attach.mapM fun ⟨x, _⟩ => go x), source⟩
+    | .Quantifier mode param trigger body =>
+      pure ⟨.Quantifier mode param (← trigger.attach.mapM fun ⟨x, _⟩ => go x)
+        (← go body), source⟩
+    | .Assigned name => pure ⟨.Assigned (← go name), source⟩
+    | .Old value => pure ⟨.Old (← go value), source⟩
+    | .Fresh value => pure ⟨.Fresh (← go value), source⟩
+    | .Assert cond =>
+      pure ⟨.Assert { cond with condition := ← go cond.condition }, source⟩
+    | .Assume cond => pure ⟨.Assume (← go cond), source⟩
+    | .ProveBy value proof =>
+      pure ⟨.ProveBy (← go value) (← go proof), source⟩
+    | .ContractOf ty func => pure ⟨.ContractOf ty (← go func), source⟩
+    | .Exit _ | .LiteralInt _ | .LiteralBool _ | .LiteralString _ | .LiteralDecimal _
+    | .Var (.Local _) | .Var (.Declare _) | .New _ | .This | .Abstract | .All | .Hole .. => pure e
+    let results ← post rebuilt
+    return collapse results source
+  termination_by sizeOf e
+  decreasing_by
+    all_goals simp_wf
+    all_goals (try have := AstNode.sizeOf_val_lt e)
+    all_goals (try have := Condition.sizeOf_condition_lt ‹_›)
+    all_goals (try term_by_mem)
+    all_goals (cases e; simp_all; omega)
+  go expr
+
 /-- Apply a monadic transformation to all procedure bodies. -/
 def mapProcedureBodiesM [Monad m] (f : StmtExprMd → m StmtExprMd) (proc : Procedure) : m Procedure := do
   match proc.body with
@@ -116,13 +285,14 @@ def mapProcedureBodiesM [Monad m] (f : StmtExprMd → m StmtExprMd) (proc : Proc
   | .External => return proc
 
 /-- Apply a monadic transformation to all `StmtExprMd` nodes in a procedure
-    (preconditions, decreases, body, and invokeOn). -/
+    (preconditions, decreases, body, invokeOn, and axioms). -/
 def mapProcedureM [Monad m] (f : StmtExprMd → m StmtExprMd) (proc : Procedure) : m Procedure := do
   let proc ← mapProcedureBodiesM f proc
   return { proc with
     preconditions := ← proc.preconditions.mapM (·.mapM f)
     decreases := ← proc.decreases.mapM f
-    invokeOn := ← proc.invokeOn.mapM f }
+    invokeOn := ← proc.invokeOn.mapM f
+    axioms := ← proc.axioms.mapM f }
 
 /-- Apply a monadic transformation to procedure bodies in a program.
     Does **not** traverse preconditions, decreases, or invokeOn — use
diff --git a/Strata/Languages/Laurel/Resolution.lean b/Strata/Languages/Laurel/Resolution.lean
index 75e6ac1292..b07cef0eaa 100644
--- a/Strata/Languages/Laurel/Resolution.lean
+++ b/Strata/Languages/Laurel/Resolution.lean
@@ -7,6 +7,7 @@ module
 
 public import Strata.Languages.Laurel.Laurel
 public import Strata.Languages.Laurel.Grammar.AbstractToConcreteTreeTranslator
+public import Strata.Languages.Laurel.TransparencyPass
 import Strata.Util.Tactics
 import Strata.Languages.Python.PythonLaurelCorePrelude
 
@@ -177,7 +178,16 @@ def SemanticModel.get? (model: SemanticModel) (iden: Identifier): Option Resolve
   iden.uniqueId.bind model.refToDef.get?
 
 def SemanticModel.get (model: SemanticModel) (iden: Identifier): ResolvedNode :=
-  (model.get? iden).getD default
+  match iden.uniqueId with
+  | some key =>
+    match model.refToDef.get? key with
+    | some node => node
+    | none =>
+      -- An ID was assigned during Phase 1 but the reference was never registered in
+      -- Phase 2 (buildRefToDef). This is a bug in the resolution pass itself.
+      dbg_trace s!"SOUND BUG: identifier '{iden.text}' (id={key}) has a uniqueId but is missing from refToDef"
+      .unresolved iden.source
+  | none => .unresolved iden.source
 
 def SemanticModel.isFunction (model: SemanticModel) (id: Identifier): Bool :=
   match model.get id with
@@ -240,7 +250,6 @@ private def freshId : ResolveM Nat := do
   set { s with nextId := id + 1 }
   return id
 
-
 /-- Like `defineName`, but reports a diagnostic if the name already exists in the current scope.
     Inserts an `.unresolved` node so subsequent references still resolve without cascading errors. -/
 def defineNameCheckDup (iden : Identifier) (node : ResolvedNode) (overrideResolutionName: Option String := none) : ResolveM Identifier := do
@@ -524,12 +533,12 @@ def resolveStmtExpr (exprMd : StmtExprMd) : ResolveM StmtExprMd := do
   | .Fresh val =>
     let val' ← resolveStmtExpr val
     pure (.Fresh val')
-  | .Assert ⟨condExpr, summary⟩ =>
+  | .Assert ⟨condExpr, summary, free⟩ =>
     let saved := (← get).inValueContext
     modify fun s => { s with inValueContext := true }
     let cond' ← resolveStmtExpr condExpr
     modify fun s => { s with inValueContext := saved }
-    pure (.Assert { condition := cond', summary })
+    pure (.Assert { condition := cond', summary, free })
   | .Assume cond =>
     let saved := (← get).inValueContext
     modify fun s => { s with inValueContext := true }
@@ -585,15 +594,13 @@ def resolveProcedure (proc : Procedure) : ResolveM Procedure := do
     let pres' ← proc.preconditions.mapM (·.mapM resolveStmtExpr)
     let dec' ← proc.decreases.mapM resolveStmtExpr
     let body' ← resolveBody proc.body
-    if !proc.isFunctional && body'.isTransparent then
-      let diag := diagnosticFromSource proc.name.source
-        s!"transparent procedures are not yet supported. Add 'opaque' to make the procedure opaque"
-      modify fun s => { s with errors := s.errors.push diag }
     let invokeOn' ← proc.invokeOn.mapM resolveStmtExpr
+    let axioms' ← proc.axioms.mapM resolveStmtExpr
     return { name := procName', inputs := inputs', outputs := outputs',
              isFunctional := proc.isFunctional,
              preconditions := pres', decreases := dec',
              invokeOn := invokeOn',
+             axioms := axioms',
              body := body' }
 
 /-- Resolve a field: define its name under the qualified key (OwnerType.fieldName) and resolve its type. -/
@@ -618,16 +625,18 @@ def resolveInstanceProcedure (typeName : Identifier) (proc : Procedure) : Resolv
     let pres' ← proc.preconditions.mapM (·.mapM resolveStmtExpr)
     let dec' ← proc.decreases.mapM resolveStmtExpr
     let body' ← resolveBody proc.body
-    if !proc.isFunctional && body'.isTransparent then
+    if !proc.isFunctional && body'.isTransparent && !proc.name.text.any (· == '$') then
       let diag := diagnosticFromSource proc.name.source
-        s!"transparent procedures are not yet supported. Add 'opaque' to make the procedure opaque"
+        s!"transparent statement bodies are not supported. Add 'opaque' to make the procedure opaque"
       modify fun s => { s with errors := s.errors.push diag }
     let invokeOn' ← proc.invokeOn.mapM resolveStmtExpr
     modify fun s => { s with instanceTypeName := savedInstType }
+    let axioms' ← proc.axioms.mapM resolveStmtExpr
     return { name := procName', inputs := inputs', outputs := outputs',
              isFunctional := proc.isFunctional,
              preconditions := pres', decreases := dec',
              invokeOn := invokeOn',
+             axioms := axioms',
              body := body' }
 
 /-- Resolve a type definition. -/
@@ -778,7 +787,7 @@ private def collectStmtExpr (map : Std.HashMap Nat ResolvedNode) (expr : StmtExp
   | .Assigned name => collectStmtExpr map name
   | .Old val => collectStmtExpr map val
   | .Fresh val => collectStmtExpr map val
-  | .Assert ⟨cond, _⟩ => collectStmtExpr map cond
+  | .Assert ⟨cond, _, _⟩ => collectStmtExpr map cond
   | .Assume cond => collectStmtExpr map cond
   | .ProveBy val proof =>
     let map := collectStmtExpr map val
@@ -890,13 +899,7 @@ private def preRegisterTopLevel (program : Program) : ResolveM Unit := do
     | .Datatype dt =>
       let _ ← defineNameCheckDup dt.name (.datatypeDefinition dt)
       for ctor in dt.constructors do
-        -- Register the tester override first; the second call reuses the
-        -- returned Identifier (now carrying a uniqueId) so the unprefixed
-        -- constructor name and the `TypeName..isCtor` tester name resolve to
-        -- the same uniqueId, which `buildRefToDef` in turn maps to
-        -- `.datatypeConstructor`.
-        let ctorName ← defineNameCheckDup ctor.name (.datatypeConstructor dt.name ctor) (some (dt.testerName ctor))
-        let _ ← defineNameCheckDup ctorName (.datatypeConstructor dt.name ctor)
+        let _ ← defineNameCheckDup ctor.name (.datatypeConstructor dt.name ctor)
         for p in ctor.args do
           -- Same chaining trick for the safe and unsafe destructor names: both
           -- point to the same uniqueId so `IntList..head` and `IntList..head!`
@@ -916,8 +919,18 @@ private def preRegisterTopLevel (program : Program) : ResolveM Unit := do
 
 /-- Run the full resolution pass on a Laurel program. -/
 def resolve (program : Program) (existingModel: Option SemanticModel := none) : ResolutionResult :=
+
   -- Phase 1: pre-register all top-level names, then assign IDs and resolve references
   let phase1 : ResolveM Program := do
+
+    for td in program.types do
+      if let .Composite ct := td then
+        for proc in ct.instanceProcedures do
+          let diag := diagnosticFromSource proc.name.source
+            s!"Instance procedure '{proc.name.text}' on composite type '{ct.name.text}' is not yet supported"
+            DiagnosticType.NotYetImplemented
+          modify fun s => { s with errors := s.errors.push diag }
+
     preRegisterTopLevel program
     let types' ← program.types.mapM resolveTypeDefinition
     let constants' ← program.constants.mapM resolveConstant
@@ -938,4 +951,92 @@ def resolve (program : Program) (existingModel: Option SemanticModel := none) :
     errors := finalState.errors
   }
 
+/-! ## Resolution for UnorderedCoreWithLaurelTypes -/
+
+/--
+Pre-register all top-level names from an `UnorderedCoreWithLaurelTypes` into
+scope. This mirrors `preRegisterTopLevel` but operates on the unordered Core
+structure directly, also pre-registering composite types from the original
+Laurel program so that type references resolve correctly.
+-/
+private def preRegisterUnorderedCore (uc : UnorderedCoreWithLaurelTypes)
+    (laurelTypes : List TypeDefinition) : ResolveM Unit := do
+  -- Pre-register datatype definitions
+  for dt in uc.datatypes do
+    let _ ← defineNameCheckDup dt.name (.datatypeDefinition dt)
+    for ctor in dt.constructors do
+      let _ ← defineNameCheckDup ctor.name (.datatypeConstructor dt.name ctor)
+      for p in ctor.args do
+        let pName ← defineNameCheckDup p.name (.datatypeDestructor dt.name p) (some (dt.destructorName p))
+        let _ ← defineNameCheckDup pName (.datatypeDestructor dt.name p) (some (dt.unsafeDestructorName p))
+  -- Pre-register composite types from the Laurel program so type references resolve
+  for td in laurelTypes do
+    match td with
+    | .Composite ct =>
+      let _ ← defineNameCheckDup ct.name (.compositeType ct)
+      for field in ct.fields do
+        let qualifiedName := ct.name.text ++ "." ++ field.name.text
+        let _ ← defineNameCheckDup field.name (.field ct.name field) (some qualifiedName)
+      for proc in ct.instanceProcedures do
+        let _ ← defineNameCheckDup proc.name (.instanceProcedure ct.name proc)
+    | _ => pure ()
+  -- Pre-register constants
+  for c in uc.constants do
+    let _ ← defineNameCheckDup c.name (.constant c)
+  -- Pre-register functions and core procedures
+  for proc in uc.functions do
+    let _ ← defineNameCheckDup proc.name (.staticProcedure proc)
+  for proc in uc.coreProcedures do
+    let _ ← defineNameCheckDup proc.name (.staticProcedure proc)
+
+/--
+Build the refToDef map for an `UnorderedCoreWithLaurelTypes` by walking its
+resolved components. Also includes composite types from the Laurel program
+so that `UserDefined` type references can be resolved during translation.
+-/
+private def buildRefToDefUnorderedCore (uc : UnorderedCoreWithLaurelTypes)
+    (laurelTypes : List TypeDefinition) : Std.HashMap Nat ResolvedNode :=
+  let map : Std.HashMap Nat ResolvedNode := {}
+  let map := laurelTypes.foldl collectTypeDefinition map
+  let map := uc.datatypes.foldl (fun m dt => collectTypeDefinition m (.Datatype dt)) map
+  let map := uc.constants.foldl collectConstant map
+  let map := uc.functions.foldl (collectProcedure · · .staticProcedure) map
+  uc.coreProcedures.foldl (collectProcedure · · .staticProcedure) map
+
+/--
+Resolve an `UnorderedCoreWithLaurelTypes` directly, preserving the separation
+between functions and core procedures without relying on `isFunctional`.
+
+The `laurelProgram` is used to bring composite type definitions into scope so
+that type references (e.g. `UserDefined`) resolve correctly.
+-/
+def resolveUnorderedCore (uc : UnorderedCoreWithLaurelTypes)
+    (laurelProgram : Program) (existingModel : Option SemanticModel := none)
+    : UnorderedCoreWithLaurelTypes × SemanticModel × Array DiagnosticModel :=
+  let laurelTypes := laurelProgram.types.filter fun t =>
+    match t with | .Composite _ => true | _ => false
+
+  let phase1 : ResolveM UnorderedCoreWithLaurelTypes := do
+    preRegisterUnorderedCore uc laurelTypes
+    let datatypes' ← uc.datatypes.mapM fun dt => do
+      let td' ← resolveTypeDefinition (.Datatype dt)
+      match td' with | .Datatype dt' => pure dt' | _ => pure dt
+    let constants' ← uc.constants.mapM resolveConstant
+    let functions' ← uc.functions.mapM resolveProcedure
+    let coreProcedures' ← uc.coreProcedures.mapM resolveProcedure
+    return { functions := functions'
+             coreProcedures := coreProcedures'
+             datatypes := datatypes'
+             constants := constants' }
+
+  let nextId := existingModel.elim 1 (fun m => m.nextId)
+  let (uc', finalState) := phase1.run { nextId := nextId }
+  let refToDef := buildRefToDefUnorderedCore uc' laurelTypes
+  let model : SemanticModel := {
+    compositeCount := laurelTypes.length
+    refToDef := refToDef
+    nextId := finalState.nextId
+  }
+  (uc', model, finalState.errors)
+
 end
diff --git a/Strata/Languages/Laurel/TransparencyPass.lean b/Strata/Languages/Laurel/TransparencyPass.lean
new file mode 100644
index 0000000000..01f4225a1b
--- /dev/null
+++ b/Strata/Languages/Laurel/TransparencyPass.lean
@@ -0,0 +1,203 @@
+/-
+  Copyright Strata Contributors
+
+  SPDX-License-Identifier: Apache-2.0 OR MIT
+-/
+module
+
+public import Strata.Languages.Laurel.MapStmtExpr
+public import Strata.Languages.Laurel.Laurel
+import Strata.Languages.Laurel.Grammar.AbstractToConcreteTreeTranslator
+
+/-!
+## Transparency Pass
+
+For each Core procedure, generate a function with the same signature and name
+suffixed with `$asFunction`. If a Core procedure is marked as transparent,
+attempt to add a body to its function version. In the functional body,
+assertions are erased and all calls are to functional versions. If the function
+has a body, add a free postcondition to the related procedure that equates the
+two.
+
+This IR sits between Laurel and CoreWithLaurelTypes in the pipeline:
+  Laurel → UnorderedCoreWithLaurelTypes → CoreWithLaurelTypes → Core
+-/
+
+namespace Strata.Laurel
+
+public section
+
+/--
+An intermediate representation produced by the transparency pass.
+Functions are pure computational procedures (suffixed `$asFunction`);
+coreProcedures are the original procedures with any free postconditions
+embedded in their `Body.Opaque` postcondition lists.
+-/
+public structure UnorderedCoreWithLaurelTypes where
+  functions : List Procedure
+  coreProcedures : List Procedure
+  datatypes : List DatatypeDefinition
+  constants : List Constant
+
+private def mkMd (e : StmtExpr) : StmtExprMd := { val := e, source := none }
+
+/-- Deep traversal that strips all Assert and Assume nodes from a StmtExpr tree.
+    Assert/Assume nodes are replaced with `LiteralBool true`, and Block nodes
+    are collapsed by filtering out trivial `LiteralBool true` leftovers. -/
+def stripAssertAssume (expr : StmtExprMd) : StmtExprMd :=
+  mapStmtExpr (fun e =>
+    match e.val with
+    | .Assert _ | .Assume _ => ⟨.LiteralBool true, e.source⟩
+    | .Block stmts label =>
+      let stmts' := stmts.filter fun s =>
+        match s.val with | .LiteralBool true => false | _ => true
+      match stmts' with
+      | [] => ⟨.LiteralBool true, e.source⟩
+      | [s] => if label.isNone then s else ⟨.Block [s] label, e.source⟩
+      | _ => ⟨.Block stmts' label, e.source⟩
+    | _ => e) expr
+
+/-- Rewrite StaticCall callees to their `$asFunction` versions,
+    but only for procedures whose names appear in `nonExternalNames`. -/
+def rewriteCallsToFunctional (nonExternalNames : List String) (expr : StmtExprMd) : StmtExprMd :=
+  mapStmtExpr (fun e =>
+    match e.val with
+    | .StaticCall callee args =>
+      if nonExternalNames.contains callee.text then
+        let funcCallee := { callee with text := callee.text ++ "$asFunction", uniqueId := none }
+        ⟨.StaticCall funcCallee args, e.source⟩
+      else e
+    | _ => e) expr
+
+/-- Rewrite quantifier bodies like function bodies: strip assert/assume and
+    rewrite calls to their `$asFunction` variants. This ensures that calls
+    inside quantifiers (e.g. in modifies frame conditions) reference the
+    pure functional version and are not treated as imperative by later passes. -/
+private def rewriteQuantifierBodies (nonExternalNames : List String) (expr : StmtExprMd) : StmtExprMd :=
+  mapStmtExpr (fun e =>
+    match e.val with
+    | .Quantifier mode param trigger body =>
+      let body' := rewriteCallsToFunctional nonExternalNames (stripAssertAssume body)
+      let trigger' := trigger.map (rewriteCallsToFunctional nonExternalNames)
+      ⟨.Quantifier mode param trigger' body', e.source⟩
+    | _ => e) expr
+
+/-- Apply quantifier body rewriting to all postconditions and the implementation
+    of a procedure. -/
+private def rewriteQuantifierBodiesInProc (nonExternalNames : List String) (proc : Procedure) : Procedure :=
+  let rewrite := rewriteQuantifierBodies nonExternalNames
+  match proc.body with
+  | .Opaque postconds impl modif =>
+    let postconds' := postconds.map fun c => { c with condition := rewrite c.condition }
+    let impl' := impl.map rewrite
+    { proc with body := .Opaque postconds' impl' modif }
+  | .Transparent body =>
+    { proc with body := .Transparent (rewrite body) }
+  | .Abstract postconds =>
+    let postconds' := postconds.map fun c => { c with condition := rewrite c.condition }
+    { proc with body := .Abstract postconds' }
+  | .External => proc
+
+/-- Build a free postcondition equating the procedure's output to its functional version.
+    For a procedure `foo(a, b) returns (r)`, produces:
+      `r == foo$asFunction(a, b)` -/
+private def mkFreePostcondition (proc : Procedure) : StmtExprMd :=
+  let funcName := { proc.name with text := proc.name.text ++ "$asFunction", uniqueId := none }
+  let inputArgs := proc.inputs.map fun p => mkMd (.Var (.Local p.name))
+  let funcCall := mkMd (.StaticCall funcName inputArgs)
+  match proc.outputs with
+  | [out] => mkMd (.PrimitiveOp .Eq [mkMd (.Var (.Local out.name)), funcCall])
+  | _ => mkMd (.LiteralBool true)
+
+/-- Create the function copy of a procedure (suffixed `$asFunction`).
+    If the procedure is transparent, include a functional body.
+    Otherwise the function is opaque. -/
+private def mkFunctionCopy (nonExternalNames : List String) (proc : Procedure) : Procedure :=
+  let funcName := { proc.name with text := proc.name.text ++ "$asFunction", uniqueId := none }
+  let body := match proc.body with
+    | .Transparent b =>
+      let expr := rewriteCallsToFunctional nonExternalNames (stripAssertAssume b)
+      let targets := proc.outputs.map fun p => { val := Variable.Local p.name, source := none : AstNode Variable }
+      let assign := mkMd (.Assign targets expr)
+      .Opaque [] (some (mkMd (.Block [assign] none))) []
+    | .Opaque _ _ _ => .Opaque [] none []
+    | x => x
+  { proc with name := funcName, isFunctional := true, preconditions := [], body := body }
+
+/-- Check whether a function copy has a body (i.e. the procedure was transparent). -/
+private def functionHasBody (proc : Procedure) : Bool :=
+  match proc.body with
+  | .Opaque _ (some _) _ => true
+  | _ => false
+
+/-- Check whether a StmtExprMd tree contains any Return nodes. -/
+private partial def hasReturn (expr : StmtExprMd) : Bool :=
+  match expr.val with
+  | .Return _ => true
+  | .Block stmts _ => stmts.any hasReturn
+  | .IfThenElse _ thenBr elseBr => hasReturn thenBr || elseBr.any hasReturn
+  | .While _ _ _ body => hasReturn body
+  | _ => false
+
+/-- Append a free postcondition to a procedure's body postconditions.
+    For Opaque and Abstract bodies, the free condition is appended to the
+    existing postcondition list. For Transparent bodies, the body is promoted
+    to Opaque so the free postcondition can be carried. -/
+private def addFreePostcondition (proc : Procedure) (freePost : StmtExprMd) : Procedure :=
+  match freePost.val with
+  | .LiteralBool true => proc  -- trivial, skip
+  | _ =>
+    let freeCond : Condition := { condition := freePost, free := true }
+    match proc.body with
+    | .Opaque postconds impl modif =>
+      { proc with body := .Opaque (postconds ++ [freeCond]) impl modif }
+    | .Abstract postconds =>
+      { proc with body := .Abstract (postconds ++ [freeCond]) }
+    | .Transparent body =>
+      let returnBody : StmtExprMd :=
+        if hasReturn body then body
+        else ⟨.Return (some body), body.source⟩
+      { proc with body := .Opaque [freeCond] (some returnBody) [] }
+    | _ => proc
+
+/--
+Transparency pass: translate a Laurel program to the UnorderedCoreWithLaurelTypes IR.
+
+For each procedure:
+- Generate a function with the same signature, named `foo$asFunction`
+- If transparent, the function gets a functional body (assertions erased, calls to functional versions)
+- If the function has a body, add a free postcondition equating the procedure output to the function
+-/
+def transparencyPass (program : Program) : UnorderedCoreWithLaurelTypes :=
+  let nonExternal := program.staticProcedures.filter (fun p => !p.body.isExternal)
+  let nonExternalNames := nonExternal.map (fun p => p.name.text)
+  -- $asFunction copies for non-external procedures
+  let asFunctions := nonExternal.map (mkFunctionCopy nonExternalNames)
+  -- External procedures get a plain function copy (they have no $asFunction version)
+  let externalFunctions := program.staticProcedures.filter (fun p => p.body.isExternal)
+    |>.map fun proc => { proc with isFunctional := true }
+  let functions := externalFunctions ++ asFunctions
+  let coreProcedures := nonExternal.map fun proc =>
+    let freePostcondition := mkFreePostcondition proc
+    let proc := { proc with isFunctional := false, axioms := proc.axioms.map (rewriteCallsToFunctional nonExternalNames) }
+    let proc := rewriteQuantifierBodiesInProc nonExternalNames proc
+    addFreePostcondition proc freePostcondition
+  let datatypes := program.types.filterMap fun td => match td with
+    | .Datatype dt => some dt
+    | _ => none
+  { functions, coreProcedures, datatypes, constants := program.constants }
+
+open Std (Format ToFormat)
+
+def formatUnorderedCoreWithLaurelTypes (p : UnorderedCoreWithLaurelTypes) : Format :=
+  let datatypeFmts := p.datatypes.map ToFormat.format
+  let constantFmts := p.constants.map ToFormat.format
+  let functionFmts := p.functions.map ToFormat.format
+  let procFmts := p.coreProcedures.map ToFormat.format
+  Format.joinSep (datatypeFmts ++ constantFmts ++ functionFmts ++ procFmts) "\n\n"
+
+instance : ToFormat UnorderedCoreWithLaurelTypes where
+  format := formatUnorderedCoreWithLaurelTypes
+
+end -- public section
+end Strata.Laurel
diff --git a/Strata/Languages/Python/PythonToLaurel.lean b/Strata/Languages/Python/PythonToLaurel.lean
index 0c1a030899..e272c562fd 100644
--- a/Strata/Languages/Python/PythonToLaurel.lean
+++ b/Strata/Languages/Python/PythonToLaurel.lean
@@ -2061,7 +2061,7 @@ partial def translateStmt (ctx : TranslationContext) (s : Python.stmt SourceRang
             let assumeInRange := mkStmtExprMdWithLoc (.Assume inRangeExpr) md
             pure [assumeTypeInt, assumeInRange]
           | _ =>
-            let targetInIter := mkStmtExprMd (.StaticCall "PIn" [targetVar, iterExpr])
+            let targetInIter := mkStmtExprMdWithLoc (.StaticCall "PIn" [targetVar, iterExpr]) md
             let assumeInStmt := mkStmtExprMdWithLoc (.Assume (Any_to_bool targetInIter)) md
             pure [assumeInStmt]
       | _ => pure []
diff --git a/StrataTest/Backends/CBMC/contracts/test_contract.lr.st b/StrataTest/Backends/CBMC/contracts/test_contract.lr.st
index 5660809918..20505c2cbc 100644
--- a/StrataTest/Backends/CBMC/contracts/test_contract.lr.st
+++ b/StrataTest/Backends/CBMC/contracts/test_contract.lr.st
@@ -6,7 +6,9 @@ procedure add(x: int, y: int) returns (r: int)
   r := x + y;
 };
 
-procedure main() {
+procedure main()
+  opaque
+{
   var a: int := 42;
   assert a > 0;
 };
diff --git a/StrataTest/Backends/CBMC/contracts/test_contracts_e2e.sh b/StrataTest/Backends/CBMC/contracts/test_contracts_e2e.sh
index eef32397e1..0ab00ccab1 100755
--- a/StrataTest/Backends/CBMC/contracts/test_contracts_e2e.sh
+++ b/StrataTest/Backends/CBMC/contracts/test_contracts_e2e.sh
@@ -66,12 +66,15 @@ echo "--- Test 1: Procedure with requires/ensures (full DFCC + CBMC) ---"
 
 build_goto "contract" 'procedure add(x: int, y: int, out r: int)
   requires x >= 0
+  opaque
   ensures r >= x
 {
   r := x + y;
 }
 
-procedure main() {
+procedure main()
+  opaque
+{
   var a: int := 42;
   assert a > 0;
 }'
@@ -102,7 +105,9 @@ echo ""
 # ---- Test 2: Simple assert (full CBMC verification) ----
 echo "--- Test 2: Simple assert (full DFCC + CBMC) ---"
 
-build_goto "assert" 'procedure main() {
+build_goto "assert" 'procedure main()
+  opaque
+{
   var x: int := 10;
   var y: int := x + 5;
   assert y > x;
@@ -122,12 +127,15 @@ echo "--- Test 3: Procedure with ensures (full DFCC + CBMC) ---"
 
 build_goto "ensures" 'procedure inc(x: int, out r: int)
   requires x >= 0
+  opaque
   ensures r > x
 {
   r := x + 1;
 }
 
-procedure main() {
+procedure main()
+  opaque
+{
   var v: int := 10;
   assert v > 0;
 }'
@@ -146,6 +154,7 @@ echo "--- Test 4: Loop with invariant (full DFCC + CBMC) ---"
 
 build_goto "loop" 'procedure sum_to_n(n: int, out s: int)
   requires n >= 0
+  opaque
   ensures s >= 0
 {
   var i: int := 0;
@@ -159,7 +168,9 @@ build_goto "loop" 'procedure sum_to_n(n: int, out s: int)
   }
 }
 
-procedure main() {
+procedure main()
+  opaque
+{
   var x: int := 5;
   assert x > 0;
 }'
@@ -179,12 +190,15 @@ echo "--- Test 5: Procedure call (full DFCC + CBMC) ---"
 
 build_goto "call" 'procedure double(x: int, out r: int)
   requires x >= 0
+  opaque
   ensures r == x + x
 {
   r := x + x;
 }
 
-procedure main() {
+procedure main()
+  opaque
+{
   var a: int := 3;
   assert a > 0;
 }'
@@ -217,6 +231,7 @@ echo "--- Test 6: Multiple procedures with contracts ---"
 
 build_goto "multi" 'procedure inc(x: int, out r: int)
   requires x >= 0
+  opaque
   ensures r == x + 1
 {
   r := x + 1;
@@ -224,12 +239,15 @@ build_goto "multi" 'procedure inc(x: int, out r: int)
 
 procedure dec(x: int, out r: int)
   requires x > 0
+  opaque
   ensures r == x - 1
 {
   r := x - 1;
 }
 
-procedure main() {
+procedure main()
+  opaque
+{
   var x: int := 5;
   assert x > 0;
 }'
@@ -263,12 +281,15 @@ echo "--- Test 7: Call inside if-then-else (GOTO output) ---"
 
 build_goto "nested_call" 'procedure inc(x: int, out r: int)
   requires x >= 0
+  opaque
   ensures r == x + 1
 {
   r := x + 1;
 }
 
-procedure main() {
+procedure main()
+  opaque
+{
   var a: int := 3;
   var b: int;
   if (a > 0) {
@@ -299,12 +320,15 @@ echo "--- Test 8: Call inside loop (GOTO output) ---"
 
 build_goto "loop_call" 'procedure inc(x: int, out r: int)
   requires x >= 0
+  opaque
   ensures r == x + 1
 {
   r := x + 1;
 }
 
-procedure main() {
+procedure main()
+  opaque
+{
   var i: int := 0;
   var s: int := 0;
   while (i < 3)
diff --git a/StrataTest/Languages/Boole/FeatureRequests/seq_slicing.lean b/StrataTest/Languages/Boole/FeatureRequests/seq_slicing.lean
index e1287844bc..235071e48c 100644
--- a/StrataTest/Languages/Boole/FeatureRequests/seq_slicing.lean
+++ b/StrataTest/Languages/Boole/FeatureRequests/seq_slicing.lean
@@ -74,6 +74,42 @@ rec function reconstruct(naf: Sequence int) : int
 #end
 
 /-- info:
+Obligation: seq_slicing_seed_post_seq_slicing_seed_ensures_2_1470_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: seq_slicing_seed_post_seq_slicing_seed_ensures_5_1607_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: seq_slicing_seed_post_seq_slicing_seed_ensures_5_1607_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: seq_slicing_seed_post_seq_slicing_seed_ensures_6_1667_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: seq_slicing_seed_post_seq_slicing_seed_ensures_6_1667_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_head_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_tail_calls_Sequence.drop_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_mid_calls_Sequence.drop_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_mid_calls_Sequence.take_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: seq_slicing_seed_ensures_2_1470
 Property: assert
 Result: ✅ pass
@@ -94,6 +130,10 @@ Obligation: seq_slicing_seed_ensures_6_1667
 Property: assert
 Result: ✅ pass
 
+Obligation: seq_empty_bv64_seed_post_seq_empty_bv64_seed_ensures_8_1938_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: seq_empty_bv64_seed_ensures_7_1903
 Property: assert
 Result: ✅ pass
@@ -102,6 +142,14 @@ Obligation: seq_empty_bv64_seed_ensures_8_1938
 Property: assert
 Result: ✅ pass
 
+Obligation: reconstruct_body_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: reconstruct_body_calls_Sequence.drop_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: reconstruct_terminates_0
 Property: assert
 Result: ✅ pass
@@ -116,9 +164,9 @@ example : Strata.smtVCsCorrect seqSlicingSeed := by
   gen_smt_vcs
   all_goals (try grind)
 
--- Shape test: Sequence.select on an empty sequence currently produces no
--- out-of-bounds precondition VC (that guard is tracked separately).
--- The ensures clause passes because the result is unconstrained.
+-- Shape test: Sequence.select on an empty sequence produces an
+-- out-of-bounds precondition VC that is unknown (0 < length(empty) = 0 is false).
+-- The ensures clause is also unknown because the result is unconstrained.
 private def seqOutOfBoundsSeed : Strata.Program :=
 #strata
 program Boole;
@@ -133,7 +181,11 @@ spec {
 #end
 
 /-- info:
-Obligation: seq_oob_seed_ensures_0_3481
+Obligation: set_v_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: seq_oob_seed_ensures_0_4976
 Property: assert
 Result: ❓ unknown-/
 #guard_msgs in
diff --git a/StrataTest/Languages/Boole/FeatureRequests/sha256_compact_indexed.lean b/StrataTest/Languages/Boole/FeatureRequests/sha256_compact_indexed.lean
index 47ded901b9..bc4589c1e8 100644
--- a/StrataTest/Languages/Boole/FeatureRequests/sha256_compact_indexed.lean
+++ b/StrataTest/Languages/Boole/FeatureRequests/sha256_compact_indexed.lean
@@ -195,6 +195,14 @@ spec {
 #end
 
 /-- info:
+Obligation: Seq_lib_insert_body_calls_Sequence.take_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: Seq_lib_insert_body_calls_Sequence.drop_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
 Obligation: assert_1_3021
 Property: assert
 Result: ✅ pass
@@ -215,6 +223,66 @@ Obligation: assert_5_3658
 Property: assert
 Result: ✅ pass
 
+Obligation: set_res_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_res_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_res_calls_Sequence.select_2
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_res_calls_Sequence.select_3
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_res_calls_Sequence.update_4
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_a_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_b_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_c_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_d_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_e_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_f_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_g_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_h_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_tmp36_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_w15_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
 Obligation: callElimAssert_rotate_right_requires_0_2970_39
 Property: assert
 Result: ✅ pass
@@ -227,6 +295,10 @@ Obligation: assert_7_5332
 Property: assert
 Result: ✅ pass
 
+Obligation: set_w2_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
 Obligation: callElimAssert_rotate_right_requires_0_2970_31
 Property: assert
 Result: ✅ pass
@@ -239,6 +311,18 @@ Obligation: assert_8_5571
 Property: assert
 Result: ✅ pass
 
+Obligation: set_new_w_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_new_w_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_block_local_calls_Sequence.update_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
 Obligation: callElimAssert_rotate_right_requires_0_2970_23
 Property: assert
 Result: ✅ pass
@@ -251,6 +335,10 @@ Obligation: callElimAssert_rotate_right_requires_0_2970_15
 Property: assert
 Result: ✅ pass
 
+Obligation: set_t1_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
 Obligation: callElimAssert_rotate_right_requires_0_2970_11
 Property: assert
 Result: ✅ pass
@@ -261,6 +349,74 @@ Result: ✅ pass
 
 Obligation: callElimAssert_rotate_right_requires_0_2970_3
 Property: assert
-Result: ✅ pass-/
+Result: ✅ pass
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: set_state_out_calls_Sequence.update_1
+Property: out-of-bounds access check
+Result: ❓ unknown
+
+Obligation: init_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ❓ unknown-/
 #guard_msgs in
 #eval Strata.Boole.verify "cvc5" sha256_compact_indexed_program (options := .quiet)
diff --git a/StrataTest/Languages/Boole/deterministic.lean b/StrataTest/Languages/Boole/deterministic.lean
index c45c756007..f5ac8b1603 100644
--- a/StrataTest/Languages/Boole/deterministic.lean
+++ b/StrataTest/Languages/Boole/deterministic.lean
@@ -44,14 +44,12 @@ procedure Check(x1:int, x2:int) returns ()
 
 #end
 
-/-- info:
-Obligation: Foo_ensures_0_251
-Property: assert
-Result: ✅ pass
-
+/--
+info:
 Obligation: assert_1_557
 Property: assert
-Result: ✅ pass-/
+Result: ✅ pass
+-/
 #guard_msgs in
 #eval Strata.Boole.verify "cvc5" deterministic (options := .quiet)
 
diff --git a/StrataTest/Languages/Boole/otp.lean b/StrataTest/Languages/Boole/otp.lean
index d60432fb8f..a066a21ad4 100644
--- a/StrataTest/Languages/Boole/otp.lean
+++ b/StrataTest/Languages/Boole/otp.lean
@@ -311,6 +311,34 @@ spec
 
 /--
 info:
+Obligation: Encrypt_post_Encrypt_ensures_4_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: Encrypt_post_Encrypt_ensures_4_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: Encrypt_post_Encrypt_ensures_4_calls_Sequence.select_2
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_cipher_calls_Sequence.take_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: loop_invariant_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: loop_invariant_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: loop_invariant_calls_Sequence.select_2
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: entry_invariant_0_0
 Property: assert
 Result: ✅ pass
@@ -331,6 +359,14 @@ Obligation: measure_lb_0
 Property: assert
 Result: ✅ pass
 
+Obligation: set_cipher_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_cipher_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: arbitrary_iter_maintain_invariant_0_0
 Property: assert
 Result: ✅ pass
@@ -359,6 +395,34 @@ Obligation: Encrypt_ensures_4
 Property: assert
 Result: ✅ pass
 
+Obligation: Decrypt_post_Decrypt_ensures_4_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: Decrypt_post_Decrypt_ensures_4_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: Decrypt_post_Decrypt_ensures_4_calls_Sequence.select_2
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_result_calls_Sequence.take_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: loop_invariant_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: loop_invariant_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: loop_invariant_calls_Sequence.select_2
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: entry_invariant_0_0
 Property: assert
 Result: ✅ pass
@@ -379,6 +443,14 @@ Obligation: measure_lb_0
 Property: assert
 Result: ✅ pass
 
+Obligation: set_result_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: set_result_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: arbitrary_iter_maintain_invariant_0_0
 Property: assert
 Result: ✅ pass
@@ -407,6 +479,14 @@ Obligation: Decrypt_ensures_4
 Property: assert
 Result: ✅ pass
 
+Obligation: RoundTrip_post_RoundTrip_ensures_4_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: RoundTrip_post_RoundTrip_ensures_4_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: callElimAssert_Encrypt_requires_0_13
 Property: assert
 Result: ✅ pass
@@ -419,6 +499,18 @@ Obligation: callElimAssert_Encrypt_requires_2_15
 Property: assert
 Result: ✅ pass
 
+Obligation: assume_callElimAssume_Encrypt_ensures_4_17_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: assume_callElimAssume_Encrypt_ensures_4_17_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: assume_callElimAssume_Encrypt_ensures_4_17_calls_Sequence.select_2
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: callElimAssert_Decrypt_requires_0_4
 Property: assert
 Result: ✅ pass
@@ -431,6 +523,18 @@ Obligation: callElimAssert_Decrypt_requires_2_6
 Property: assert
 Result: ✅ pass
 
+Obligation: assume_callElimAssume_Decrypt_ensures_4_8_calls_Sequence.select_0
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: assume_callElimAssume_Decrypt_ensures_4_8_calls_Sequence.select_1
+Property: out-of-bounds access check
+Result: ✅ pass
+
+Obligation: assume_callElimAssume_Decrypt_ensures_4_8_calls_Sequence.select_2
+Property: out-of-bounds access check
+Result: ✅ pass
+
 Obligation: RoundTrip_ensures_3
 Property: assert
 Result: ✅ pass
diff --git a/StrataTest/Languages/Core/Examples/FreeRequireEnsure.lean b/StrataTest/Languages/Core/Examples/FreeRequireEnsure.lean
index c234c8524c..f942bb2db9 100644
--- a/StrataTest/Languages/Core/Examples/FreeRequireEnsure.lean
+++ b/StrataTest/Languages/Core/Examples/FreeRequireEnsure.lean
@@ -45,13 +45,6 @@ g_eq_15: g@1 == 15
 Obligation:
 g@1 > 10
 
-Label: g_lt_10
-Property: assert
-Assumptions:
-g_eq_15: g@1 == 15
-Obligation:
-true
-
 Label: g_eq_15_internal
 Property: assert
 Assumptions:
@@ -65,15 +58,11 @@ Obligation: g_gt_10_internal
 Property: assert
 Result: ✅ pass
 
-Obligation: g_lt_10
-Property: assert
-Result: ✅ pass
-
 Obligation: g_eq_15_internal
 Property: assert
 Result: ❓ unknown
 Model:
-(g@5, 0) (g@1, 0)
+(g@5, 0)
 -/
 #guard_msgs in
 #eval verify freeReqEnsPgm
diff --git a/StrataTest/Languages/Core/Examples/TypeDecl.lean b/StrataTest/Languages/Core/Examples/TypeDecl.lean
index 74cd11640e..af55a19e04 100644
--- a/StrataTest/Languages/Core/Examples/TypeDecl.lean
+++ b/StrataTest/Languages/Core/Examples/TypeDecl.lean
@@ -130,7 +130,7 @@ error: ❌ Type checking error.
 This type declaration's name is reserved!
 int := bool
 KnownTypes' names:
-[arrow, Sequence, TriggerGroup, real, string, bitvec, Triggers, int, bool, Map, regex]
+[arrow, Sequence, TriggerGroup, real, string, bitvec, Triggers, int, bool, Map, errorVoid, regex]
 -/
 #guard_msgs in
 #eval verify typeDeclPgm4
diff --git a/StrataTest/Languages/Core/Tests/PolymorphicProcedureTest.lean b/StrataTest/Languages/Core/Tests/PolymorphicProcedureTest.lean
index e9cbabc508..b9ee9439fc 100644
--- a/StrataTest/Languages/Core/Tests/PolymorphicProcedureTest.lean
+++ b/StrataTest/Languages/Core/Tests/PolymorphicProcedureTest.lean
@@ -96,11 +96,6 @@ info: [Strata.Core] Type checking succeeded.
 
 
 VCs:
-Label: MkCons_ensures_0
-Property: assert
-Obligation:
-true
-
 Label: assert_0
 Property: assert
 Assumptions:
@@ -117,10 +112,6 @@ true
 
 ---
 info:
-Obligation: MkCons_ensures_0
-Property: assert
-Result: ✅ pass
-
 Obligation: assert_0
 Property: assert
 Result: ✅ pass
diff --git a/StrataTest/Languages/Laurel/AbstractToConcreteTreeTranslatorTest.lean b/StrataTest/Languages/Laurel/AbstractToConcreteTreeTranslatorTest.lean
index ff50dfac7b..d104393ebb 100644
--- a/StrataTest/Languages/Laurel/AbstractToConcreteTreeTranslatorTest.lean
+++ b/StrataTest/Languages/Laurel/AbstractToConcreteTreeTranslatorTest.lean
@@ -86,7 +86,8 @@ info: function aFunction(x: int): int
 };
 -/
 #guard_msgs in
-#eval do IO.println (← roundtrip r"function aFunction(x: int): int { x };")
+#eval do IO.println (← roundtrip r"function aFunction(x: int): int
+{ x };")
 
 /--
 info: composite Point { var x: int var y: int }
@@ -103,7 +104,9 @@ composite Point {
 info: procedure test(x: int): int
   opaque
 {
-  if x > 0 then x else 0 - x
+  if x > 0
+  then x
+  else 0 - x
 };
 -/
 #guard_msgs in
diff --git a/StrataTest/Languages/Laurel/ConstrainedTypeElimTest.lean b/StrataTest/Languages/Laurel/ConstrainedTypeElimTest.lean
index 45e09fd930..86165f4600 100644
--- a/StrataTest/Languages/Laurel/ConstrainedTypeElimTest.lean
+++ b/StrataTest/Languages/Laurel/ConstrainedTypeElimTest.lean
@@ -26,7 +26,9 @@ namespace Strata.Laurel
 
 def testProgram : String := r"
 constrained nat = x: int where x >= 0 witness 0
-procedure test(n: nat) returns (r: nat) {
+procedure test(n: nat) returns (r: nat)
+  opaque
+{
   assert r >= 0;
   var y: nat := n;
   return y
@@ -62,6 +64,7 @@ procedure test(n: int)
   return y
 };
 procedure $witness_nat()
+  opaque
 {
   var $witness: int := 0;
   assert nat$constraint($witness)
@@ -76,7 +79,9 @@ procedure $witness_nat()
 -- Scope management: constrained variable in if-branch must not leak into sibling block
 def scopeProgram : String := r"
 constrained pos = v: int where v > 0 witness 1
-procedure test(b: bool) {
+procedure test(b: bool)
+  opaque
+{
   if b then {
     var x: pos := 1
   };
@@ -93,8 +98,10 @@ info: function pos$constraint(v: int): bool
   v > 0
 };
 procedure test(b: bool)
+  opaque
 {
-  if b then {
+  if b
+  then {
     var x: int := 1;
     assert pos$constraint(x)
   };
@@ -104,6 +111,7 @@ procedure test(b: bool)
   }
 };
 procedure $witness_pos()
+  opaque
 {
   var $witness: int := 1;
   assert pos$constraint($witness)
@@ -119,7 +127,9 @@ procedure $witness_pos()
 -- The variable has no known value, only the type constraint is assumed.
 def uninitProgram : String := r"
 constrained posint = x: int where x > 0 witness 1
-procedure f() opaque {
+procedure f()
+  opaque
+{
   var x: posint;
   assert x == 1
 };
@@ -138,6 +148,7 @@ procedure f()
   assert x == 1
 };
 procedure $witness_posint()
+  opaque
 {
   var $witness: int := 1;
   assert posint$constraint($witness)
diff --git a/StrataTest/Languages/Laurel/DivisionByZeroCheckTest.lean b/StrataTest/Languages/Laurel/DivisionByZeroCheckTest.lean
index b11268561f..2e85748088 100644
--- a/StrataTest/Languages/Laurel/DivisionByZeroCheckTest.lean
+++ b/StrataTest/Languages/Laurel/DivisionByZeroCheckTest.lean
@@ -57,7 +57,7 @@ procedure callPureDivUnsafe(x: int)
   opaque
 {
   var z: int := pureDiv(10, x)
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: precondition does not hold
 // Error ranges are too wide because Core does not use expression locations
 };
 "
diff --git a/StrataTest/Languages/Laurel/DuplicateNameTests.lean b/StrataTest/Languages/Laurel/DuplicateNameTests.lean
index 22a5ff9f1e..53721ded87 100644
--- a/StrataTest/Languages/Laurel/DuplicateNameTests.lean
+++ b/StrataTest/Languages/Laurel/DuplicateNameTests.lean
@@ -75,25 +75,33 @@ composite Foo {
 /-! ## Duplicate parameter names in a procedure -/
 
 def dupParams := r"
-procedure foo(x: int, x: bool) opaque { };
+procedure foo(x: int, x: bool)
 //                    ^ error: Duplicate definition 'x' is already defined in this scope
+  opaque
+{ };
 "
 
 #guard_msgs (error, drop all) in
-#eval testInputWithOffset "DupParams" dupParams 61 processResolution
+#eval testInputWithOffset "DupParams" dupParams 77 processResolution
 
 /-! ## Duplicate instance procedure names in a composite type -/
 
 def dupInstanceProcs := r"
 composite Foo {
-  procedure bar() opaque { };
-  procedure bar() opaque { };
+  procedure bar()
+//          ^^^ error: Instance procedure 'bar' on composite type 'Foo' is not yet supported
+    opaque
+  { };
+  procedure bar()
+//          ^^^ error: Instance procedure 'bar' on composite type 'Foo' is not yet supported
 //          ^^^ error: Duplicate definition 'bar' is already defined in this scope
+    opaque
+  { };
 }
 "
 
 #guard_msgs (error, drop all) in
-#eval testInputWithOffset "DupInstanceProcs" dupInstanceProcs 71 processResolution
+#eval testInputWithOffset "DupInstanceProcs" dupInstanceProcs 89 processResolution
 
 /-! ## Duplicate local variable names in the same block -/
 
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T10_ConstrainedTypes.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T10_ConstrainedTypes.lean
index 0568d522a9..49485d46ea 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T10_ConstrainedTypes.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T10_ConstrainedTypes.lean
@@ -35,7 +35,7 @@ procedure outputValid(): nat
 
 // Output constraint — invalid return fails
 procedure outputInvalid(): nat
-//                         ^^^ error: assertion does not hold
+//                         ^^^ error: postcondition could not be proved
   opaque
 {
   return -1
@@ -63,7 +63,7 @@ procedure assignInvalid()
   opaque
 {
   var y: nat := -1
-//^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^ error: assertion could not be proved
 };
 
 // Reassignment to constrained-typed variable — invalid
@@ -72,7 +72,7 @@ procedure reassignInvalid()
 {
   var y: nat := 5;
   y := -1
-//^^^^^^^ error: assertion does not hold
+//^^^^^^^ error: assertion could not be proved
 };
 
 // Argument to constrained-typed parameter — valid
@@ -132,7 +132,7 @@ procedure constrainedInExpr()
 
 // Invalid witness — witness -1 does not satisfy x > 0
 constrained bad = x: int where x > 0 witness -1
-//                                           ^^ error: assertion does not hold
+//                                           ^^ error: assertion could not be proved
 
 // Uninitialized constrained variable — havoc + assume constraint
 procedure uninitNat()
@@ -157,14 +157,12 @@ procedure uninitNotWitness()
 {
   var y: posnat;
   assert y == 1
-//^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^ error: assertion could not be proved
 };
 
 // Quantifier constraint injection — forall
 // n + 1 > 0 is only provable with n >= 0 injected; false for all int
-procedure forallNat()
-  opaque
-{
+procedure forallNat() opaque {
   var b: bool := forall(n: nat) => n + 1 > 0;
   assert b
 };
@@ -172,9 +170,7 @@ procedure forallNat()
 // Quantifier constraint injection — exists
 // n == -1 is satisfiable for int, but not when n >= 0 is required
 // n == 42 works because 42 >= 0
-procedure existsNat()
-  opaque
-{
+procedure existsNat() opaque {
   var b: bool := exists(n: nat) => n == 42;
   assert b
 };
@@ -195,7 +191,7 @@ procedure captureTest(y: haslarger)
   opaque
 {
   assert false
-//^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^ error: assertion could not be proved
 };
 "
 
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T14_Quantifiers.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T14_Quantifiers.lean
index 6b748b0444..ad6f671ed8 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T14_Quantifiers.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T14_Quantifiers.lean
@@ -52,7 +52,7 @@ procedure triggers()
 
 "
 
-#guard_msgs(drop info, error) in
+#guard_msgs (drop info, error) in
 #eval testInputWithOffset "Quantifiers" quantifiersProgram 14 processLaurelFile
 
 end Laurel
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T15_ShortCircuit.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T15_ShortCircuit.lean
index dcc5533e3d..034e2df5d6 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T15_ShortCircuit.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T15_ShortCircuit.lean
@@ -28,7 +28,6 @@ procedure mustNotCallProc(): int
 };
 
 // Pure path: function with requires false
-
 procedure testAndThenFunc()
   opaque
 {
@@ -94,7 +93,7 @@ procedure testImpliesProc()
 };
 "
 
-#guard_msgs (drop info) in
+#guard_msgs(drop info) in
 #eval testInputWithOffset "ShortCircuit" shortCircuitProgram 15 processLaurelFile
 
 end Laurel
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T18_RecursiveFunction.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T18_RecursiveFunction.lean
index b4aac70e17..e664163308 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T18_RecursiveFunction.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T18_RecursiveFunction.lean
@@ -25,7 +25,8 @@ datatype IntList {
   Cons(head: int, tail: IntList)
 }
 
-function listLen(xs: IntList): int {
+function listLen(xs: IntList): int
+{
   if IntList..isNil(xs) then 0
   else 1 + listLen(IntList..tail!(xs))
 };
@@ -38,12 +39,14 @@ procedure testListLen()
 };
 
 // Mutual recursion
-function listLenEven(xs: IntList): bool {
+function listLenEven(xs: IntList): bool
+{
   if IntList..isNil(xs) then true
   else listLenOdd(IntList..tail!(xs))
 };
 
-function listLenOdd(xs: IntList): bool {
+function listLenOdd(xs: IntList): bool
+{
   if IntList..isNil(xs) then false
   else listLenEven(IntList..tail!(xs))
 };
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T19_InvokeOn.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T19_InvokeOn.lean
index 10bfacab74..93216a2563 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T19_InvokeOn.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T19_InvokeOn.lean
@@ -72,14 +72,14 @@ procedure badPostcondition(x: int)
   invokeOn R(x)
   opaque
   ensures R(x)
-//        ^^^^ error: assertion could not be proved
+//        ^^^^ error: postcondition could not be proved
 {
 };
 
 "#
 
 #guard_msgs (drop info, error) in
-#eval testInputWithOffset "InvokeOn" program 14
+#eval testInputWithOffset "InvokeOn" program 17
   (Strata.Laurel.processLaurelFileWithOptions { verifyOptions := { Core.VerifyOptions.default with solver := "z3" } })
 
 end Strata.Laurel
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T20_TransparentBodyError.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T20_TransparentBodyError.lean
index ea2a4288d2..53db8b98b8 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T20_TransparentBodyError.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T20_TransparentBodyError.lean
@@ -16,11 +16,17 @@ namespace Strata
 namespace Laurel
 
 def transparentBodyProgram := r"
-procedure transparentBody()
-//        ^^^^^^^^^^^^^^^ error: transparent procedures are not yet supported. Add 'opaque' to make the procedure opaque
+procedure transparentBody(): int
 {
-  assert true
+  assert true;
+  3
 };
+
+// No support for transparent void procedures yet
+// procedure transparentBody()
+// {
+//   assert true
+// };
 "
 
 #guard_msgs(drop info, error) in
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T22_ArityMismatch.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T22_ArityMismatch.lean
index fce8013d30..f141bb50eb 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T22_ArityMismatch.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T22_ArityMismatch.lean
@@ -25,10 +25,7 @@ procedure caller()
 };
 "
 
-/--
-error: ArityMismatch(79-100) ❌ Type checking error.
-Impossible to unify int with (arrow int $__ty35).
--/
+/-- error: input length and args length mismatch -/
 #guard_msgs(drop info, error) in
 #eval testInputWithOffset "ArityMismatch" arityMismatchProgram 14 processLaurelFile
 
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressions.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressions.lean
index 5f6a92f98d..38e2dddf19 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressions.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressions.lean
@@ -83,7 +83,6 @@ procedure nestedImpureStatementsAndOpaque()
 // An imperative procedure call in expression position is lifted before the
 // surrounding expression is evaluated.
 procedure imperativeProc(x: int) returns (r: int)
-   // ensures clause required because Core's symbolic verification does not support transparent proceduces yet
   opaque
   ensures r == x + 1
 {
@@ -142,13 +141,13 @@ procedure addProcCaller(): int
 {
   var x: int := 0;
   var y: int := addProc({x := 1; x}, {x := x + 10; x});
-  assert y == 11
+  assert y == 12;
 
   // The next statement is not translated correctly.
   // I think it's a bug in the handling of StaticCall
   // Where a reference is substituted when it should not be
-  // var z: int := addProc({x := 1; x}, {x := x + 10; x}) + (x := 3);
-  // assert z == 14
+  var z: int := addProc({x := 1; x}, {x := x + 10; x}) + (x := 3);
+  assert z == 15
 };
 "
 
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressionsError.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressionsError.lean
index d94d179dea..a905b3cfbb 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressionsError.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T2_ImpureExpressionsError.lean
@@ -38,12 +38,10 @@ function impureFunction2(x: int): int
 function impureFunction3(x: int): int
 {
   impure()
-//^^^^^^^^ error: calls to procedures are not supported in functions or contracts
 };
 
 procedure impureContractIsNotLegal1(x: int)
   requires x == impure()
-//              ^^^^^^^^ error: calls to procedures are not supported in functions or contracts
   opaque
 {
   assert impure() == 1
@@ -55,7 +53,6 @@ procedure impureContractIsNotLegal2(x: int)
   opaque
 {
   assert (x := 2) == 2
-//        ^^^^^^ error: destructive assignments are not supported in functions or contracts
 };
 "
 
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlow.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlow.lean
index 1e9307a396..ba7b75d99e 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlow.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlow.lean
@@ -16,7 +16,28 @@ open Strata
 namespace Strata.Laurel
 
 def program := r"
-function returnAtEnd(x: int) returns (r: int) {
+function letsInFunction() returns (r: int) {
+  var x: int := 0;
+  var y: int := x + 1;
+  var z: int := y + 1;
+  z
+};
+
+procedure callLetsInFunction() opaque {
+  var x: int := letsInFunction();
+  assert x == 2
+};
+
+function assertAndAssumeInFunctions(a: int) returns (r: int)
+{
+  assert 2 == 3;
+//^^^^^^^^^^^^^ error: assertion does not hold
+  assume true;
+  a
+};
+
+function returnAtEnd(x: int) returns (r: int)
+{
   if x > 0 then {
     if x == 1 then {
       return 1
@@ -28,11 +49,13 @@ function returnAtEnd(x: int) returns (r: int) {
   }
 };
 
-function elseWithCall(): int {
+function elseWithCall(): int
+{
   if true then 3 else returnAtEnd(3)
 };
 
-function guardInFunction(x: int) returns (r: int) {
+function guardInFunction(x: int) returns (r: int)
+{
   if x > 0 then {
     if x == 1 then {
       return 1
@@ -49,11 +72,11 @@ procedure testFunctions()
 {
   assert returnAtEnd(1) == 1;
   assert returnAtEnd(1) == 2;
-//^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion could not be proved
 
   assert guardInFunction(1) == 1;
   assert guardInFunction(1) == 2
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion could not be proved
 };
 
 procedure guards(a: int) returns (r: int)
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlowError.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlowError.lean
index 80e2335737..7f01f720f6 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlowError.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T3_ControlFlowError.lean
@@ -19,12 +19,11 @@ def program := r"
 function assertAndAssumeInFunctions(a: int) returns (r: int)
 {
   assert 2 == 3;
-//^^^^^^^^^^^^^ error: asserts are not YET supported in functions or contracts
   assume true;
-//^^^^^^^^^^^ error: assumes are not YET supported in functions or contracts
   a
 };
 
+
 function letsInFunction() returns (r: int) {
   var x: int := 0;
   var y: int := x + 1;
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T4_LoopJumps.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T4_LoopJumps.lean
index da88caa329..58295bbb04 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T4_LoopJumps.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T4_LoopJumps.lean
@@ -16,7 +16,9 @@ open Strata
 namespace Laurel
 
 def program := r"
-procedure whileWithBreakAndContinue(steps: int, continueSteps: int, exitSteps: int): int {
+procedure whileWithBreakAndContinue(steps: int, continueSteps: int, exitSteps: int): int
+  opaque
+{
   var counter = 0
   {
     while(steps > 0)
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T5_ProcedureCalls.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T5_ProcedureCalls.lean
index 7187078aca..3dd798d063 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T5_ProcedureCalls.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T5_ProcedureCalls.lean
@@ -41,7 +41,7 @@ procedure fooProof()
   var x: int := fooReassign();
   var y: int := fooSingleAssign()
 // The following assertions fails while it should succeed,
-// because Core does not yet support transparent procedures
+// because Core does not yet support transparent statement bodies
 //  assert x == y;
 };
 
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T6_Preconditions.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T6_Preconditions.lean
index c3ae951491..c189d2b4ad 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T6_Preconditions.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T6_Preconditions.lean
@@ -47,7 +47,7 @@ procedure aFunctionWithPreconditionCaller()
   opaque
 {
   var x: int := aFunctionWithPrecondition(0)
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: precondition does not hold
 // Error ranges are too wide because Core does not use expression locations
 };
 
@@ -64,7 +64,7 @@ procedure multipleRequiresCaller()
 {
   var a: int := multipleRequires(1, 2);
   var b: int := multipleRequires(-1, 2)
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: precondition does not hold
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: precondition could not be proved
 };
 
 function funcMultipleRequires(x: int, y: int): int
@@ -79,9 +79,9 @@ procedure funcMultipleRequiresCaller()
 {
   var a: int := funcMultipleRequires(1, 2);
   var b: int := funcMultipleRequires(1, -1)
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: precondition could not be proved
 };
 "
 
 #guard_msgs (drop info, error) in
-#eval testInputWithOffset "Preconditions" program 14 processLaurelFile
+#eval testInputWithOffset "Preconditions" program 17 processLaurelFile
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T7_Decreases.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T7_Decreases.lean
index bef96b8eb3..d2e5ff0735 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T7_Decreases.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T7_Decreases.lean
@@ -22,26 +22,33 @@ A procedure with a decreases clause may be called in an erased context.
 
 def program := r"
 procedure noDecreases(x: int): boolean;
+  opaque
 procedure caller(x: int)
   requires noDecreases(x)
 //                    ^ error: noDecreases can not be called from a pure context, because it is not proven to terminate
+  opaque
 ;
 
 procedure noCyclicCalls()
+  opaque
   decreases []
 {
   leaf();
 };
 
-procedure leaf() decreases [1] { };
+procedure leaf() decreases [1]
+  opaque
+{ };
 
 procedure mutualRecursionA(x: nat)
+  opaque
   decreases [x, 1]
 {
   mutualRecursionB(x);
 };
 
 procedure mutualRecursionB(x: nat)
+  opaque
   decreases [x, 0]
 {
   if x != 0 { mutualRecursionA(x-1); }
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8_Postconditions.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8_Postconditions.lean
index 74723d1ecf..f16707be3c 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8_Postconditions.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8_Postconditions.lean
@@ -16,6 +16,24 @@ open Strata
 namespace Strata.Laurel
 
 def program := r"
+
+function opaqueFunction(x: int) returns (r: int)
+  requires x > 0
+  opaque
+  ensures r > 0
+{
+  return x
+};
+
+procedure callerOfOpaqueFunction()
+  opaque
+{
+  var x: int := opaqueFunction(3);
+  assert x > 0;
+  assert x == 3
+//^^^^^^^^^^^^^ error: assertion could not be proved
+};
+
 procedure opaqueBody(x: int) returns (r: int)
   opaque
   ensures r > 0
@@ -34,12 +52,13 @@ procedure callerOfOpaqueProcedure()
 };
 
 procedure invalidPostcondition(x: int)
-    opaque
-    ensures false
-//          ^^^^^ error: assertion does not hold
+  returns (r: int) // TODO, removing this returns triggers a latent bug
+  opaque
+  ensures false
+//        ^^^^^ error: postcondition does not hold
 {
 };
 "
 
 #guard_msgs (drop info, error) in
-#eval testInputWithOffset "Postconditions" program 14 processLaurelFile
+#eval testInputWithOffset "Postconditions" program 17 processLaurelFileKeepIntermediates
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8_PostconditionsErrors.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8_PostconditionsErrors.lean
deleted file mode 100644
index 88f8bec609..0000000000
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8_PostconditionsErrors.lean
+++ /dev/null
@@ -1,42 +0,0 @@
-/-
-  Copyright Strata Contributors
-
-  SPDX-License-Identifier: Apache-2.0 OR MIT
--/
-module
-
-meta import all StrataTest.Util.TestDiagnostics
-meta import all StrataTest.Languages.Laurel.TestExamples
-
-meta section
-
-open StrataTest.Util
-open Strata
-
-namespace Strata.Laurel
-
-def program := r"
-
-function opaqueFunction(x: int) returns (r: int)
-//       ^^^^^^^^^^^^^^ error: functions with postconditions are not yet supported
-// The above limitation is because Core does not yet support functions with postconditions
-  requires x > 0
-  opaque
-  ensures r > 0
-// The above limitation is because functions in Core do not support postconditions
-{
-  x
-};
-
-procedure callerOfOpaqueFunction()
-  opaque
-{
-  var x: int := opaqueFunction(3);
-  assert x > 0;
-// The following assertion should fail but does not
-  assert x == 3
-};
-"
-
-#guard_msgs (drop info, error) in
-#eval testInputWithOffset "Postconditions" program 14 processLaurelFile
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8b_EarlyReturnPostconditions.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8b_EarlyReturnPostconditions.lean
index 659a1e22a9..823e511f38 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8b_EarlyReturnPostconditions.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8b_EarlyReturnPostconditions.lean
@@ -29,7 +29,7 @@ procedure earlyReturnCorrect(x: int) returns (r: int)
 procedure earlyReturnBuggy(x: int) returns (r: int)
   opaque
   ensures r >= 0
-//        ^^^^^^ error: assertion does not hold
+//        ^^^^^^ error: postcondition does not hold
 {
   if x < 0 then {
     return x
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8c_BodilessInlining.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8c_BodilessInlining.lean
index a7ff015b31..fc9d896ef5 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8c_BodilessInlining.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8c_BodilessInlining.lean
@@ -5,6 +5,8 @@
 -/
 module
 
+meta import all StrataTest.Util.TestDiagnostics
+meta import all StrataTest.Languages.Laurel.TestExamples
 meta import Strata.SimpleAPI
 
 meta section
@@ -19,6 +21,9 @@ the inlined call is correctly rejected. -/
 
 namespace Strata.Laurel.BodilessInliningTest
 
+open StrataTest.Util
+open Strata
+
 private def laurelSource := "
 procedure bodilessProcedure() returns (r: int)
   opaque
@@ -31,33 +36,13 @@ procedure caller()
   var x: int := bodilessProcedure();
   assert x > 0;
   assert false
+//^^^^^^^^^^^^ error: assertion could not be proved
 };
 "
 
-/-- info: "assert(161): ❌ fail" -/
-#guard_msgs in
-#eval show IO String from do
-  let laurelProg ← Strata.parseLaurelText "test.laurel" laurelSource
-  let coreProg ← match ← Strata.laurelToCore laurelProg with
-    | .ok p => pure p
-    | .error e => throw (IO.userError s!"Translation failed: {e}")
-  let inlined ← match Strata.Core.inlineProcedures coreProg {} with
-    | .ok p => pure p
-    | .error e => throw (IO.userError s!"Inlining failed: {e}")
-  let vcResults ←
-    EIO.toIO (fun e => IO.Error.userError e)
-      (Strata.Core.verifyProgram inlined
-        { Core.VerifyOptions.default with verbose := .quiet }
-        (proceduresToVerify := some ["caller"]))
-  -- Collect only failing results
-  let failures := vcResults.filter fun vcr =>
-    match vcr.outcome with
-    | .ok o => o.validityProperty != .unsat
-    | .error _ => true
-  let mut output := ""
-  for vcr in failures do
-    output := output ++ s!"{vcr.obligation.label}: {vcr.formatOutcome}"
-  return output
+#guard_msgs (drop info, error) in
+#eval testInputWithOffset "Postconditions" laurelSource 23
+  (fun p => processLaurelFileWithOptions { translateOptions := { inlineFunctionsWhenPossible := true} } p)
 
 end Strata.Laurel.BodilessInliningTest
 end
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8d_HeapMutatingValueReturn.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8d_HeapMutatingValueReturn.lean
index f81e63553d..ade9e86cfc 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T8d_HeapMutatingValueReturn.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T8d_HeapMutatingValueReturn.lean
@@ -32,7 +32,7 @@ procedure setAndReturn(c: Container, x: int) returns (r: int)
 procedure setAndReturnBuggy(c: Container, x: int) returns (r: int)
   opaque
   ensures r == x + 1
-//        ^^^^^^^^^^ error: assertion does not hold
+//        ^^^^^^^^^^ error: postcondition could not be proved
   modifies c
 {
   c#value := x;
@@ -41,6 +41,6 @@ procedure setAndReturnBuggy(c: Container, x: int) returns (r: int)
 "
 
 #guard_msgs (drop info, error) in
-#eval testInputWithOffset "HeapMutatingValueReturn" heapMutatingValueReturnProgram 15 processLaurelFile
+#eval testInputWithOffset "HeapMutatingValueReturn" heapMutatingValueReturnProgram 17 processLaurelFile
 
 end Strata.Laurel
diff --git a/StrataTest/Languages/Laurel/Examples/Fundamentals/T9_Nondeterministic.lean b/StrataTest/Languages/Laurel/Examples/Fundamentals/T9_Nondeterministic.lean
index a926078732..8f21d70ecf 100644
--- a/StrataTest/Languages/Laurel/Examples/Fundamentals/T9_Nondeterministic.lean
+++ b/StrataTest/Languages/Laurel/Examples/Fundamentals/T9_Nondeterministic.lean
@@ -23,7 +23,9 @@ nondet procedure nonDeterministic(x: int): (r: int)
   assumed
 };
 
-procedure caller() {
+procedure caller()
+  opaque
+{
   var x = nonDeterministic(1)
   assert x > 0;
   var y = nonDeterministic(1)
@@ -32,11 +34,13 @@ procedure caller() {
 };
 
 nondet procedure nonDeterminsticTransparant(x: int): (r: int)
+  opaque
 {
   nonDeterministic(x + 1)
 };
 
 procedure nonDeterministicCaller(x: int): int
+  opaque
 {
   nonDeterministic(x)
 };
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/T1_MutableFields.lean b/StrataTest/Languages/Laurel/Examples/Objects/T1_MutableFields.lean
index c45aabd6ca..8d86345ed6 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/T1_MutableFields.lean
+++ b/StrataTest/Languages/Laurel/Examples/Objects/T1_MutableFields.lean
@@ -70,20 +70,17 @@ procedure updatesAndAliasing()
   assert dAlias#intValue == d#intValue
 };
 
-procedure subsequentHeapMutations(c: Container)
-  opaque
-  modifies c
-{
+procedure subsequentHeapMutations() opaque {
+  var c: Container := new Container;
+
   // The additional parenthesis on the next line are needed to let the parser succeed. Joe, any idea why this is needed?
   var sum: int := ((c#intValue := 1) + c#intValue) + (c#intValue := 2);
   assert sum == 4
 };
 
-procedure implicitEquality(c: Container, d: Container)
-  opaque
-  modifies c
-  modifies d
-{
+procedure implicitEquality() opaque {
+  var c: Container := new Container;
+  var d: Container := new Container;
   c#intValue := 1;
   d#intValue := 2;
   if c#intValue == d#intValue then {
@@ -104,11 +101,9 @@ composite SameFieldName {
   var intValue: bool
 }
 
-procedure sameFieldNameDifferentType(a: Container, b: SameFieldName)
-  opaque
-  modifies a
-  modifies b
-{
+procedure sameFieldNameDifferentType() opaque {
+  var a: Container := new Container;
+  var b: SameFieldName := new SameFieldName;
   a#intValue := 1;
   b#intValue := true;
 
@@ -127,9 +122,7 @@ composite Pixel {
   var color: Color
 }
 
-procedure datatypeField()
-  opaque
-{
+procedure datatypeField() opaque {
   var p: Pixel := new Pixel;
   p#color := Red();
   assert Color..isRed(p#color);
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/T2_ModifiesClauses.lean b/StrataTest/Languages/Laurel/Examples/Objects/T2_ModifiesClauses.lean
index 375e845dfd..2ab10c9a31 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/T2_ModifiesClauses.lean
+++ b/StrataTest/Languages/Laurel/Examples/Objects/T2_ModifiesClauses.lean
@@ -130,7 +130,7 @@ procedure modifiesWildcardBodilessCaller()
   var x: int := d#value;
   modifiesWildcardBodiless(c, d);
   assert x == d#value // this should fail because modifies * means anything can change
-//^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^^^^ error: assertion could not be proved
 };
 
 procedure modifiesWildcardWithBody(c: Container, d: Container)
@@ -155,7 +155,7 @@ procedure modifiesWildcardAndSpecificCaller()
   var x: int := d#value;
   modifiesWildcardAndSpecific(c, d);
   assert x == d#value // fails because modifies * subsumes modifies c
-//^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
+//^^^^^^^^^^^^^^^^^^^ error: assertion could not be proved
 };
 "
 
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/T3_ReadsClauses.lr.st b/StrataTest/Languages/Laurel/Examples/Objects/T3_ReadsClauses.lr.st
index d95606784d..210a95c155 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/T3_ReadsClauses.lr.st
+++ b/StrataTest/Languages/Laurel/Examples/Objects/T3_ReadsClauses.lr.st
@@ -16,10 +16,11 @@ composite Container {
 
 procedure opaqueProcedure(c: Container): int
   reads c
-  ensures true
+  opaque
 ;
 
 procedure foo(c: Container, d: Container) 
+  opaque
 {
   var x = opaqueProcedure(c);
   d.value = 1;
@@ -33,6 +34,7 @@ procedure foo(c: Container, d: Container)
 
 procedure permissionLessReader(c: Container): int
   reads {}
+  opaque
   { c.value }
 //  ^^^^^^^ error: enclosing procedure 'permissionLessReader' does not have permission to read 'c.value'
 ;
@@ -44,7 +46,8 @@ type Composite;
 type Field;
 val value: Field;
 
-function opaqueProcedure_ensures(heap: Heap, c: Container, r: int): boolean {
+function opaqueProcedure_ensures(heap: Heap, c: Container, r: int): boolean
+{
   true
 }
 
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/T4_ImmutableFields.lr.st b/StrataTest/Languages/Laurel/Examples/Objects/T4_ImmutableFields.lr.st
index d92a44c6bd..f287c7f84d 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/T4_ImmutableFields.lr.st
+++ b/StrataTest/Languages/Laurel/Examples/Objects/T4_ImmutableFields.lr.st
@@ -9,6 +9,7 @@ composite ImmutableContainer {
 }
 
 procedure valueReader(c: ImmutableContainer): int
+  opaque
   { c.value } // no reads clause needed because value is immutable
 ;
 
@@ -18,7 +19,8 @@ Translation towards SMT:
 type Composite;
 function ImmutableContainer_value(c: Composite): int
 
-function valueReader(c: Composite): int {
+function valueReader(c: Composite): int
+{
   ImmutableContainer_value(c)
 }
 
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/T5_inheritance.lean b/StrataTest/Languages/Laurel/Examples/Objects/T5_inheritance.lean
index 6b83965968..75d59c4e15 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/T5_inheritance.lean
+++ b/StrataTest/Languages/Laurel/Examples/Objects/T5_inheritance.lean
@@ -92,7 +92,7 @@ procedure diamondInheritance()
 };
 
 // Currently does not pass. Implementation needs b type invariant mechanism that we have yet to add.
-//procedure typedParameter(b: Bottom) {
+//procedure typedParameter(b: Bottom) opaque {
 //  var b: Bottom := b;
 //  assert b is Left;
 //  assert b is Right;
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/T6_Datatypes.lean b/StrataTest/Languages/Laurel/Examples/Objects/T6_Datatypes.lean
index 1567885390..4743c1f7bb 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/T6_Datatypes.lean
+++ b/StrataTest/Languages/Laurel/Examples/Objects/T6_Datatypes.lean
@@ -22,17 +22,13 @@ datatype IntList {
 }
 
 // Construction and destructor access
-procedure testConstruction()
-  opaque
-{
+procedure testConstruction() opaque {
   var xs: IntList := Cons(42, Nil());
   assert IntList..head(xs) == 42
 };
 
 // Constructor testing
-procedure testConstructorTest()
-  opaque
-{
+procedure testConstructorTest() opaque {
   var xs: IntList := Cons(1, Nil());
   assert IntList..isCons(xs);
   assert !IntList..isNil(xs);
@@ -43,9 +39,7 @@ procedure testConstructorTest()
 };
 
 // Nested construction and deconstruction
-procedure testNested()
-  opaque
-{
+procedure testNested() opaque {
   var xs: IntList := Cons(1, Cons(2, Nil()));
   assert IntList..isCons(xs);
   assert IntList..head(xs) == 1;
@@ -54,9 +48,7 @@ procedure testNested()
   assert IntList..isNil(IntList..tail(IntList..tail(xs)))
 };
 
-procedure unsafeDestructor()
-  opaque
-{
+procedure unsafeDestructor() opaque {
   var nil: IntList := Nil();
   var noError: int := IntList..head!(nil);
   var error: int := IntList..head(nil)
@@ -70,18 +62,14 @@ function listHead(xs: IntList): int
   IntList..head(xs)
 };
 
-procedure testFunction()
-  opaque
-{
+procedure testFunction() opaque {
   var xs: IntList := Cons(10, Nil());
   var h: int := listHead(xs);
   assert h == 10
 };
 
 // Failing assertion
-procedure testFailing()
-  opaque
-{
+procedure testFailing() opaque {
   var xs: IntList := Nil();
   assert IntList..isCons(xs)
 //^^^^^^^^^^^^^^^^^^^^^^^^^^ error: assertion does not hold
@@ -97,9 +85,7 @@ datatype OddList {
   OCons(head: int, tail: EvenList)
 }
 
-procedure testMutualConstruction()
-  opaque
-{
+procedure testMutualConstruction() opaque {
   var even: EvenList := ENil();
   assert EvenList..isENil(even);
   var odd: OddList := OCons(1, ENil());
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/T8_NonCompositeModifies.lean b/StrataTest/Languages/Laurel/Examples/Objects/T8_NonCompositeModifies.lean
index c83f53fc5a..18da725e2d 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/T8_NonCompositeModifies.lean
+++ b/StrataTest/Languages/Laurel/Examples/Objects/T8_NonCompositeModifies.lean
@@ -30,7 +30,7 @@ composite Container {
 procedure incWithPrimitiveModifies(x: int) returns (r: int)
   opaque
   modifies x
-//         ^ error: non-composite type
+//         ^ error: modifies clause entry has non-composite type 'int' and will be ignored
 {
   r := x + 1
 };
@@ -39,7 +39,7 @@ procedure modifyContainerAndPrimitive(c: Container, x: int)
   opaque
   modifies c
   modifies x
-//         ^ error: non-composite type
+//         ^ error: modifies clause entry has non-composite type 'int' and will be ignored
 {
   c#value := 1
 };
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Allocation.lr.st b/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Allocation.lr.st
index cc0377ee27..9ce2bd2f05 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Allocation.lr.st	
+++ b/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Allocation.lr.st	
@@ -13,6 +13,7 @@ composite Immutable {
   invariant x + y >= 5
 
   procedure construct()
+    opaque
     constructor
     requires contructing == {this}
     ensures constructing == {}
@@ -23,7 +24,9 @@ composite Immutable {
   };
 }
 
-procedure foo() {
+procedure foo()
+  opaque
+{
   val immutable = Immutable.construct(); // constructor instance method can be called as a static.
 };
 
@@ -34,6 +37,7 @@ composite ImmutableChainOfTwo {
   invariant other.other == this // reading other.other is allowed because the field is immutable
 
   procedure construct() 
+    opaque
     constructor
     requires contructing == {this}
     ensures constructing == {}
@@ -49,13 +53,16 @@ composite ImmutableChainOfTwo {
 
   // only used privately
   procedure allocate()
+    opaque
     constructor
     ensures constructing = {this} {    
     // empty body
   };
 }
 
-procedure foo2() {
+procedure foo2()
+  opaque
+{
   val immutable = ImmutableChainOfTwo.construct();
   val same = immutable.other.other;
   assert immutable =&= same;
@@ -67,6 +74,7 @@ composite UsesHelperConstructor {
   val y: int
 
   procedure setXhelper() 
+    opaque
     constructor
     requires constructing == {this}
     ensures constructing == {this} && assigned(this.x)
@@ -75,6 +83,7 @@ composite UsesHelperConstructor {
   };
 
   procedure construct() 
+    opaque
     constructor
     requires contructing == {this}
     ensures constructing == {}
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Constructors.lr.st b/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Constructors.lr.st
index 5d2c02cfd5..fd1c136e1b 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Constructors.lr.st	
+++ b/StrataTest/Languages/Laurel/Examples/Objects/WIP/5. Constructors.lr.st	
@@ -18,6 +18,7 @@ composite Immutable {
   // fields of Immutable are considered mutable inside this procedure
   // and invariants of Immutable are not visible
   // can only call procedures that are also constructing Immutable
+    opaque
     constructs Immutable
     modifies this
   {
@@ -27,13 +28,16 @@ composite Immutable {
   };
 
   procedure assignToY() 
+    opaque
     constructs Immutable
   {
     this.y = 3;
   };
 }
 
-procedure foo() {
+procedure foo()
+  opaque
+{
   var c = new Immutable.construct();
   var temp = c.x;
   c.z = 1;
@@ -41,7 +45,9 @@ procedure foo() {
   assert temp == c.x; // pass
 };
 
-procedure pureCompositeAllocator(): boolean {
+procedure pureCompositeAllocator(): boolean
+  opaque
+{
   // can be called in a determinstic context
   var i: Immutable = Immutable.construct(); 
   var j: Immutable = Immutable.construct();
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/WIP/6. TypeTests.lr.st b/StrataTest/Languages/Laurel/Examples/Objects/WIP/6. TypeTests.lr.st
index 6d94f9a08d..2b067c7f2a 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/WIP/6. TypeTests.lr.st	
+++ b/StrataTest/Languages/Laurel/Examples/Objects/WIP/6. TypeTests.lr.st	
@@ -19,7 +19,9 @@ composite Extended2 extends Base {
   var z: int
 }
 
-procedure typeTests(e: Extended1) {
+procedure typeTests(e: Extended1)
+  opaque
+{
   var b: Base = e as Base; // even upcasts are not implicit, but they pass statically
   var e2 = e as Extended2;
 //           ^^ error: could not prove 'e' is of type 'Extended2'
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/WIP/7. InstanceCallables.lr.st b/StrataTest/Languages/Laurel/Examples/Objects/WIP/7. InstanceCallables.lr.st
index fe4c5756d6..95cf829196 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/WIP/7. InstanceCallables.lr.st	
+++ b/StrataTest/Languages/Laurel/Examples/Objects/WIP/7. InstanceCallables.lr.st	
@@ -5,12 +5,14 @@
 */
 composite Base {
   procedure foo(): int
+    opaque
     ensures result > 3
     { abstract };
 }
 
 composite Extender1 extends Base {
   procedure foo(): int
+    opaque
     ensures result > 4
 //  ^^^^^^^ error: could not prove ensures clause guarantees that of extended method 'Base.foo'
     { abstract };
@@ -19,6 +21,7 @@ composite Extender1 extends Base {
 composite Extender2 extends Base {
   value: int
   procedure foo(): int
+    opaque
     ensures result > 2
   {
     this.value + 2 // 'this' is an implicit variable inside instance callables
diff --git a/StrataTest/Languages/Laurel/Examples/Objects/WIP/9. Closures.lr.st b/StrataTest/Languages/Laurel/Examples/Objects/WIP/9. Closures.lr.st
index 73a72a4738..bd3932322d 100644
--- a/StrataTest/Languages/Laurel/Examples/Objects/WIP/9. Closures.lr.st	
+++ b/StrataTest/Languages/Laurel/Examples/Objects/WIP/9. Closures.lr.st	
@@ -87,6 +87,7 @@ so in affect there no longer are any variables captured by a closure.
 
 // Option A: first class procedures
 procedure hasClosure() returns (r: int)
+  opaque
   ensures r == 7
 {
   var x = 3;
@@ -100,17 +101,21 @@ procedure hasClosure() returns (r: int)
 
 // Option B: type closures
 composite ATrait {
-  procedure foo() returns (r: int) ensures r > 0 {
+  procedure foo() returns (r: int) ensures r > 0
+    opaque
+  {
     abstract
   };
 }
 
 procedure hasClosure() returns (r: int)
+  opaque
   ensures r == 7
 {
   var x = 3;
   var aClosure := closure extends ATrait {
     procedure foo() returns (r: int) 
+      opaque
     {
       r = x + 4;
     };
diff --git a/StrataTest/Languages/Laurel/Examples/PrimitiveTypes/T2_String.lean b/StrataTest/Languages/Laurel/Examples/PrimitiveTypes/T2_String.lean
index b183cf9e2d..67a0c1dccf 100644
--- a/StrataTest/Languages/Laurel/Examples/PrimitiveTypes/T2_String.lean
+++ b/StrataTest/Languages/Laurel/Examples/PrimitiveTypes/T2_String.lean
@@ -18,7 +18,7 @@ namespace Laurel
 
 def program := r#"
 procedure testStringKO()
-returns (result: string)
+  returns (result: string)
   opaque
 {
   var message: string := "Hello";
diff --git a/StrataTest/Languages/Laurel/LiftExpressionAssignmentsTest.lean b/StrataTest/Languages/Laurel/LiftExpressionAssignmentsTest.lean
index 31a0084f71..38b03b445d 100644
--- a/StrataTest/Languages/Laurel/LiftExpressionAssignmentsTest.lean
+++ b/StrataTest/Languages/Laurel/LiftExpressionAssignmentsTest.lean
@@ -44,14 +44,16 @@ def parseLaurelAndLift (input : String) : IO Program := do
   | .ok program =>
     let result := resolve program
     let (program, model) := (result.program, result.model)
-    pure (liftExpressionAssignments model program)
+    let imperativeCallees := program.staticProcedures.filter (fun p => !p.isFunctional)
+      |>.map (fun p => p.name.text)
+    pure (liftExpressionAssignments program model imperativeCallees)
 
 /--
 info: procedure assertInBlockExpr()
   opaque
 {
   var x: int := 0;
-  assert x == 0;
+  assert $x_0 == 0;
   var $x_0: int := x;
   x := 1;
   var y: int := {
diff --git a/StrataTest/Languages/Laurel/LiftHolesTest.lean b/StrataTest/Languages/Laurel/LiftHolesTest.lean
index 646b6ca8bc..a06f91a27f 100644
--- a/StrataTest/Languages/Laurel/LiftHolesTest.lean
+++ b/StrataTest/Languages/Laurel/LiftHolesTest.lean
@@ -56,7 +56,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var x: int := 1 + <?> };
+procedure test()
+  opaque
+{ var x: int := 1 + <?> };
 "
 
 -- Bare Hole as Assign Declare initializer → replaced with call (no longer preserved as havoc).
@@ -72,7 +74,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var x: int := <?> };
+procedure test()
+  opaque
+{ var x: int := <?> };
 "
 
 -- Hole in comparison arg inside assert → int (inferred from sibling literal).
@@ -88,7 +92,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { assert <?> > 0 };
+procedure test()
+  opaque
+{ assert <?> > 0 };
 "
 
 -- Hole directly as assert condition → bool.
@@ -104,7 +110,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { assert <?> };
+procedure test()
+  opaque
+{ assert <?> };
 "
 
 -- Hole directly as assume condition → bool.
@@ -120,7 +128,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { assume <?> };
+procedure test()
+  opaque
+{ assume <?> };
 "
 
 -- Hole as if-then-else condition → bool.
@@ -131,14 +141,17 @@ info: function $hole_0()
 procedure test()
   opaque
 {
-  if $hole_0() then {
+  if $hole_0()
+  then {
     assert true
   }
 };
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { if <?> then { assert true } };
+procedure test()
+  opaque
+{ if <?> then { assert true } };
 "
 
 -- Hole in then-branch of if-then-else inside typed local variable → int.
@@ -149,12 +162,16 @@ info: function $hole_0()
 procedure test()
   opaque
 {
-  var x: int := if true then $hole_0() else 0
+  var x: int := if true
+  then $hole_0()
+  else 0
 };
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var x: int := if true then <?> else 0 };
+procedure test()
+  opaque
+{ var x: int := if true then <?> else 0 };
 "
 
 -- Hole as while-loop condition → bool.
@@ -172,7 +189,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { while(<?>) {} };
+procedure test()
+  opaque
+{ while(<?>) {} };
 "
 
 -- Hole as while-loop invariant → bool.
@@ -191,7 +210,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { while(true) invariant <?> {} };
+procedure test()
+  opaque
+{ while(true) invariant <?> {} };
 "
 
 /-! ## Operators -/
@@ -209,7 +230,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { assert true && <?> };
+procedure test()
+  opaque
+{ assert true && <?> };
 "
 
 -- Hole in Neg inside typed local variable → int.
@@ -225,7 +248,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var x: int := -<?> };
+procedure test()
+  opaque
+{ var x: int := -<?> };
 "
 
 -- Hole in StrConcat inside typed local variable → string.
@@ -261,7 +286,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var x: int := <?> + <?> };
+procedure test()
+  opaque
+{ var x: int := <?> + <?> };
 "
 
 -- Holes across statements: Mul arg (int) then assert condition (bool).
@@ -281,7 +308,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var x: int := 2 * <?>; assert <?> };
+procedure test()
+  opaque
+{ var x: int := 2 * <?>; assert <?> };
 "
 
 /-! ## Combinations: holes in nested contexts -/
@@ -294,14 +323,17 @@ info: function $hole_0()
 procedure test()
   opaque
 {
-  if 1 + $hole_0() > 0 then {
+  if 1 + $hole_0() > 0
+  then {
     assert true
   }
 };
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { if 1 + <?> > 0 then { assert true } };
+procedure test()
+  opaque
+{ if 1 + <?> > 0 then { assert true } };
 "
 
 -- Hole in Implies inside while invariant → bool.
@@ -321,7 +353,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var p: bool; while(true) invariant p ==> <?> {} };
+procedure test()
+  opaque
+{ var p: bool; while(true) invariant p ==> <?> {} };
 "
 
 -- Hole in Mul inside typed local variable with real type → real.
@@ -337,7 +371,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var r: real := 3.14 * <?> };
+procedure test()
+  opaque
+{ var r: real := 3.14 * <?> };
 "
 
 /-! ## Call argument and return type inference -/
@@ -355,7 +391,9 @@ procedure test(n: int)
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test(n: int) opaque { assert n > <?> };
+procedure test(n: int)
+  opaque
+{ assert n > <?> };
 "
 
 /-! ## Holes in functions -/
@@ -373,7 +411,9 @@ function test(x: int): int
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-function test(x: int): int opaque { <?> };
+function test(x: int): int
+  opaque
+{ <?> };
 "
 
 /-! ## Nondeterministic holes (<??>) -/
@@ -388,7 +428,9 @@ info: procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { assert <??> };
+procedure test()
+  opaque
+{ assert <??> };
 "
 
 -- Mixed: det hole eliminated, nondet hole preserved.
@@ -405,7 +447,9 @@ procedure test()
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
-procedure test() opaque { var x: int := <?>; assert <??> };
+procedure test()
+  opaque
+{ var x: int := <?>; assert <??> };
 "
 
 -- Nondet hole in function → should be rejected (not tested here since
@@ -423,7 +467,9 @@ info: function $hole_0()
   returns ($result: IntList)
   opaque;
 procedure test()
-{ var x: int := IntList..head($hole_0()) };
+{
+  var x: int := IntList..head($hole_0())
+};
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
@@ -437,7 +483,9 @@ info: function $hole_0()
   returns ($result: IntList)
   opaque;
 procedure test()
-{ var x: int := IntList..head!($hole_0()) };
+{
+  var x: int := IntList..head!($hole_0())
+};
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
@@ -445,18 +493,20 @@ datatype IntList { Nil(), Cons(head: int, tail: IntList) }
 procedure test() { var x: int := IntList..head!(<?>) };
 "
 
--- Hole as argument to a tester → typed as the parent datatype.
+-- Hole as argument to a destructor inside assert → typed as the parent datatype.
 /--
 info: function $hole_0()
   returns ($result: IntList)
   opaque;
 procedure test()
-{ assert IntList..isCons($hole_0()) };
+{
+  assert IntList..head($hole_0()) > 0
+};
 -/
 #guard_msgs in
 #eval! parseElimAndPrint r"
 datatype IntList { Nil(), Cons(head: int, tail: IntList) }
-procedure test() { assert IntList..isCons(<?>) };
+procedure test() { assert IntList..head(<?>) > 0 };
 "
 
 end Laurel
diff --git a/StrataTest/Languages/Laurel/LiftImperativeCallsInAssertTest.lean b/StrataTest/Languages/Laurel/LiftImperativeCallsInAssertTest.lean
index bcaf10f1b6..266541ed34 100644
--- a/StrataTest/Languages/Laurel/LiftImperativeCallsInAssertTest.lean
+++ b/StrataTest/Languages/Laurel/LiftImperativeCallsInAssertTest.lean
@@ -34,7 +34,7 @@ private def parseLaurelAndLift (input : String) : IO Program := do
   | .ok program =>
     let result := resolve program
     let (program, model) := (result.program, result.model)
-    pure (liftExpressionAssignments model program)
+    pure (liftExpressionAssignments program model ["impure", "multi_out"])
 
 private def printLifted (input : String) : IO Unit := do
   let program ← parseLaurelAndLift input
@@ -52,9 +52,9 @@ info: procedure impure(): int
 };
 procedure test()
 {
-  var $c_0: int;
-  $c_0 := impure();
-  assert $c_0 == 1
+  var $cndtn_0: int;
+  $cndtn_0 := impure();
+  assert $cndtn_0 == 1
 };
 -/
 #guard_msgs in
@@ -75,7 +75,9 @@ procedure test() {
 info: procedure test()
 {
   var x: int := 0;
-  assert (x := 2) == 2
+  var $x_0: int := x;
+  x := 2;
+  assert x == 2
 };
 -/
 #guard_msgs in
@@ -97,9 +99,9 @@ info: procedure impure(): int
 };
 procedure test()
 {
-  var $c_0: int;
-  $c_0 := impure();
-  assume $c_0 == 1
+  var $cndtn_0: int;
+  $cndtn_0 := impure();
+  assume $cndtn_0 == 1
 };
 -/
 #guard_msgs in
@@ -127,9 +129,9 @@ info: procedure multi_out(x: int)
 };
 procedure test()
 {
-  var $c_0: BUG_MultiValuedExpr;
-  $c_0 := multi_out(5);
-  assert $c_0 == 6
+  var $cndtn_0: BUG_MultiValuedExpr;
+  $cndtn_0 := multi_out(5);
+  assert $cndtn_0 == 6
 };
 -/
 #guard_msgs in
diff --git a/StrataTest/Languages/Laurel/StatisticsTest.lean b/StrataTest/Languages/Laurel/StatisticsTest.lean
index 06cb8a7f80..bd4807ecea 100644
--- a/StrataTest/Languages/Laurel/StatisticsTest.lean
+++ b/StrataTest/Languages/Laurel/StatisticsTest.lean
@@ -69,6 +69,7 @@ procedure p1(a: bool, b: bool) returns (r: bool)
 };
 
 procedure p2(x: int) returns (y: int)
+  opaque
 {
   y := x + <?>
 };
diff --git a/StrataTest/Languages/Python/ToLaurelTest.lean b/StrataTest/Languages/Python/ToLaurelTest.lean
index 9ac0ffff2b..402cb9a311 100644
--- a/StrataTest/Languages/Python/ToLaurelTest.lean
+++ b/StrataTest/Languages/Python/ToLaurelTest.lean
@@ -676,7 +676,7 @@ info: errors: 1
 -- Regression test for issue #800: nested dict access `kwargs["Outer"]["Inner"]`
 -- should generate `Any_get` (dict lookup), not `FieldSelect`.
 /--
-info: body contains Any_get: true
+info: preconditions contain Any_get: true
 body contains FieldSelect: false
 -/
 #guard_msgs in
@@ -701,7 +701,7 @@ body contains FieldSelect: false
       | .Transparent body => toString (Strata.Laurel.formatStmtExpr body)
       | .Opaque _ (some body) _ => toString (Strata.Laurel.formatStmtExpr body)
       | _ => ""
-    IO.println s!"body contains Any_get: {bodyStr.contains "Any_get"}"
+    IO.println s!"preconditions contain Any_get: {bodyStr.contains "Any_get"}"
     IO.println s!"body contains FieldSelect: {bodyStr.contains "#"}"
   | [] => IO.println "no procedures"
 
@@ -932,7 +932,13 @@ private def translatePrecondResult (preconditions : Array Assertion)
 private def translatePrecond (preconditions : Array Assertion)
     (args : Array Arg := #[]) : String × Nat :=
   let result := translatePrecondResult preconditions args
-  (getBody result |>.getD "", result.errors.size)
+  let precondStr := match result.program.staticProcedures with
+    | proc :: _ =>
+      let formatted := proc.preconditions.map (fun (p : Strata.Laurel.Condition) => toString (Strata.Laurel.formatStmtExpr p.condition))
+      if formatted.isEmpty then getBody result |>.getD ""
+      else "{ " ++ (String.intercalate "; " formatted) ++ " }"
+    | [] => ""
+  (precondStr, result.errors.size)
 
 -- enumMember: or and eq via `|` and `==` infix syntax
 #eval do
@@ -974,10 +980,7 @@ private def translatePrecond (preconditions : Array Assertion)
       postconditions := #[] }] testModule
   let body := getBody result |>.getD ""
   assertEq result.errors.size 0
-  assert! body.contains "result := <??>"
-  assert! body.contains "Any..isfrom_None(key) | Any..isfrom_str(key)"
-  assert! body.contains "assert !Any..isfrom_None(key) summary \"precondition 0\""
-  assert! body.contains "assume Any..isfrom_str(result)"
+  assert! body.contains "!Any..isfrom_None(key)"
 
 -- containsKey on a non-kwargs dict: DictStrAny_contains in an assert
 -- (would have been silently dropped before fix #2)
diff --git a/StrataTest/Languages/Python/expected_laurel/test_any_dict.expected b/StrataTest/Languages/Python/expected_laurel/test_any_dict.expected
index 56fc49687d..250cba478e 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_any_dict.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_any_dict.expected
@@ -1,4 +1,4 @@
-test_any_dict.py(5, 4): ✅ pass - assert_assert(71)_calls_Any_get_0
+test_any_dict.py(5, 11): ✅ pass - precondition
 test_any_dict.py(5, 4): ✅ pass - Any holds dict
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_any_list.expected b/StrataTest/Languages/Python/expected_laurel/test_any_list.expected
index af813bcfcd..396b5d165f 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_any_list.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_any_list.expected
@@ -1,4 +1,4 @@
-test_any_list.py(5, 4): ✅ pass - assert_assert(72)_calls_Any_get_0
+test_any_list.py(5, 11): ✅ pass - precondition
 test_any_list.py(5, 4): ✅ pass - Any holds list
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_arithmetic.expected b/StrataTest/Languages/Python/expected_laurel/test_arithmetic.expected
index 5d2aac95de..9d339f8e2f 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_arithmetic.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_arithmetic.expected
@@ -14,19 +14,19 @@ test_arithmetic.py(16, 4): ✅ pass - addition implemented incorrectly
 test_arithmetic.py(19, 16): ✅ pass - Check PSub exception
 test_arithmetic.py(19, 4): ✅ pass - assert(436)
 test_arithmetic.py(20, 4): ✅ pass - subtraction implemented incorrectly
-test_arithmetic.py(23, 16): ✅ pass - assert_assert(556)_calls_PFloorDiv_0
+test_arithmetic.py(23, 16): ✅ pass - precondition
 test_arithmetic.py(23, 16): ✅ pass - Check PFloorDiv exception
-test_arithmetic.py(23, 4): ✅ pass - set_quot_calls_PFloorDiv_0
+test_arithmetic.py(23, 4): ✅ pass - precondition
 test_arithmetic.py(23, 4): ✅ pass - assert(544)
 test_arithmetic.py(24, 4): ✅ pass - floor division implemented incorrectly
-test_arithmetic.py(27, 15): ✅ pass - assert_assert(652)_calls_PMod_0
+test_arithmetic.py(27, 15): ✅ pass - precondition
 test_arithmetic.py(27, 15): ✅ pass - Check PMod exception
-test_arithmetic.py(27, 4): ✅ pass - set_rem_calls_PMod_0
+test_arithmetic.py(27, 4): ✅ pass - precondition
 test_arithmetic.py(27, 4): ✅ pass - assert(641)
 test_arithmetic.py(28, 4): ✅ pass - mod implemented incorrectly
-test_arithmetic.py(31, 20): ✅ pass - assert_assert(749)_calls_PMod_0
+test_arithmetic.py(31, 20): ✅ pass - precondition
 test_arithmetic.py(31, 20): ✅ pass - Check PMod exception
-test_arithmetic.py(31, 4): ✅ pass - set_neg_rem1_calls_PMod_0
+test_arithmetic.py(31, 4): ✅ pass - precondition
 test_arithmetic.py(31, 4): ✅ pass - assert(733)
 test_arithmetic.py(32, 4): ✅ pass - negative mod should follow Python floored semantics
 DETAIL: 31 passed, 0 failed, 0 inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_assert_false.expected b/StrataTest/Languages/Python/expected_laurel/test_assert_false.expected
index 96db8efe39..6eef5ea9f9 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_assert_false.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_assert_false.expected
@@ -1,6 +1,6 @@
-test_assert_false.py(4, 8): ✅ pass - unreachable
 test_assert_false.py(2, 4): ✅ pass - assert(16)
 test_assert_false.py(3, 7): ✅ pass - Check PGt exception
+test_assert_false.py(4, 8): ✅ pass - unreachable
 test_assert_false.py(5, 4): ✅ pass - reachable
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_augadd_list.expected b/StrataTest/Languages/Python/expected_laurel/test_augadd_list.expected
index b9ee61e68b..b3a378455c 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_augadd_list.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_augadd_list.expected
@@ -1,7 +1,7 @@
 test_augadd_list.py(3, 4): ✅ pass - Check PAdd exception
-test_augadd_list.py(4, 4): ✅ pass - assert_assert(61)_calls_Any_get_0
+test_augadd_list.py(4, 11): ✅ pass - precondition
 test_augadd_list.py(4, 4): ✅ pass - augmented add list
-test_augadd_list.py(5, 4): ✅ pass - assert_assert(105)_calls_Any_get_0
+test_augadd_list.py(5, 11): ✅ pass - precondition
 test_augadd_list.py(5, 4): ✅ pass - augmented add list last
 DETAIL: 5 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_augfloordiv.expected b/StrataTest/Languages/Python/expected_laurel/test_augfloordiv.expected
index a5f20ce182..4707c47873 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_augfloordiv.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_augfloordiv.expected
@@ -1,7 +1,6 @@
 test_augfloordiv.py(2, 4): ✅ pass - assert(28)
-test_augfloordiv.py(3, 4): ✅ pass - assert_assert(44)_calls_PFloorDiv_0
+test_augfloordiv.py(3, 4): ✅ pass - precondition
 test_augfloordiv.py(3, 4): ✅ pass - Check PFloorDiv exception
-test_augfloordiv.py(3, 4): ✅ pass - set_x_calls_PFloorDiv_0
 test_augfloordiv.py(4, 4): ✅ pass - augmented floordiv
-DETAIL: 5 passed, 0 failed, 0 inconclusive
+DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_augmented_assign.expected b/StrataTest/Languages/Python/expected_laurel/test_augmented_assign.expected
index ad80803bf1..1df585b0c6 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_augmented_assign.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_augmented_assign.expected
@@ -4,10 +4,9 @@ test_augmented_assign.py(6, 4): ✅ pass - Check PSub exception
 test_augmented_assign.py(7, 4): ✅ pass - 8 - 2 == 6
 test_augmented_assign.py(8, 4): ✅ pass - Check PMul exception
 test_augmented_assign.py(9, 4): ✅ pass - 6 * 2 == 12
-test_augmented_assign.py(11, 4): ✅ pass - assert_assert(219)_calls_Any_get_0
+test_augmented_assign.py(11, 4): ✅ pass - precondition
 test_augmented_assign.py(11, 4): ✅ pass - Check Any_sets! exception
-test_augmented_assign.py(11, 4): ✅ pass - set_l_calls_Any_get_0
-test_augmented_assign.py(12, 4): ✅ pass - assert_assert(233)_calls_Any_get_0
+test_augmented_assign.py(12, 11): ✅ pass - precondition
 test_augmented_assign.py(12, 4): ✅ pass - list element modified
-DETAIL: 11 passed, 0 failed, 0 inconclusive
+DETAIL: 10 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_augmod.expected b/StrataTest/Languages/Python/expected_laurel/test_augmod.expected
index c785c8575b..87549640dc 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_augmod.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_augmod.expected
@@ -1,7 +1,6 @@
 test_augmod.py(2, 4): ✅ pass - assert(23)
-test_augmod.py(3, 4): ✅ pass - assert_assert(39)_calls_PMod_0
+test_augmod.py(3, 4): ✅ pass - precondition
 test_augmod.py(3, 4): ✅ pass - Check PMod exception
-test_augmod.py(3, 4): ✅ pass - set_x_calls_PMod_0
 test_augmod.py(4, 4): ✅ pass - augmented mod
-DETAIL: 5 passed, 0 failed, 0 inconclusive
+DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_break_continue.expected b/StrataTest/Languages/Python/expected_laurel/test_break_continue.expected
index 1cb5222c41..4f120f15d0 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_break_continue.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_break_continue.expected
@@ -4,9 +4,9 @@ test_break_continue.py(1, 26): ✅ pass - (test_while_break ensures) Return type
 test_break_continue.py(7, 4): ✅ pass - assert(129)
 test_break_continue.py(8, 10): ✅ pass - Check PNot exception
 test_break_continue.py(6, 29): ✅ pass - (test_while_continue ensures) Return type constraint
-test_break_continue.py(14, 4): ✅ pass - assume_assume(267)_calls_PIn_0
+test_break_continue.py(14, 4): ✅ pass - precondition
 test_break_continue.py(12, 24): ✅ pass - (test_for_break ensures) Return type constraint
-test_break_continue.py(19, 4): ✅ pass - assume_assume(362)_calls_PIn_0
+test_break_continue.py(19, 4): ✅ pass - precondition
 test_break_continue.py(17, 27): ✅ pass - (test_for_continue ensures) Return type constraint
 DETAIL: 10 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_bubble_sort_step.expected b/StrataTest/Languages/Python/expected_laurel/test_bubble_sort_step.expected
index f3de7b0866..0378609c33 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_bubble_sort_step.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_bubble_sort_step.expected
@@ -1,41 +1,32 @@
-test_bubble_sort_step.py(12, 8): ✅ pass - set_t3_calls_Any_get_0
-test_bubble_sort_step.py(12, 8): ✅ pass - assert(250)
-test_bubble_sort_step.py(13, 8): ✅ pass - assert_assert(274)_calls_Any_get_0
-test_bubble_sort_step.py(13, 8): ✅ pass - Check Any_sets! exception
-test_bubble_sort_step.py(13, 8): ✅ pass - set_xs_calls_Any_get_0
-test_bubble_sort_step.py(14, 8): ✅ pass - Check Any_sets! exception
-test_bubble_sort_step.py(3, 7): ✅ pass - assert_assert(55)_calls_Any_get_0
-test_bubble_sort_step.py(3, 7): ✅ pass - assert_assert(55)_calls_Any_get_1
+test_bubble_sort_step.py(3, 7): ✅ pass - precondition
+test_bubble_sort_step.py(3, 15): ✅ pass - precondition
 test_bubble_sort_step.py(3, 7): ✅ pass - Check PGt exception
-test_bubble_sort_step.py(3, 4): ✅ pass - ite_cond_calls_Any_get_0
-test_bubble_sort_step.py(3, 4): ✅ pass - ite_cond_calls_Any_get_1
-test_bubble_sort_step.py(4, 8): ✅ pass - set_t_calls_Any_get_0
+test_bubble_sort_step.py(4, 8): ✅ pass - precondition
 test_bubble_sort_step.py(4, 8): ✅ pass - assert(78)
-test_bubble_sort_step.py(5, 8): ✅ pass - assert_assert(101)_calls_Any_get_0
+test_bubble_sort_step.py(5, 16): ✅ pass - precondition
 test_bubble_sort_step.py(5, 8): ✅ pass - Check Any_sets! exception
-test_bubble_sort_step.py(5, 8): ✅ pass - set_xs_calls_Any_get_0
 test_bubble_sort_step.py(6, 8): ✅ pass - Check Any_sets! exception
-test_bubble_sort_step.py(7, 7): ✅ pass - assert_assert(140)_calls_Any_get_0
-test_bubble_sort_step.py(7, 7): ✅ pass - assert_assert(140)_calls_Any_get_1
+test_bubble_sort_step.py(7, 7): ✅ pass - precondition
+test_bubble_sort_step.py(7, 15): ✅ pass - precondition
 test_bubble_sort_step.py(7, 7): ✅ pass - Check PGt exception
-test_bubble_sort_step.py(7, 4): ✅ pass - ite_cond_calls_Any_get_0
-test_bubble_sort_step.py(7, 4): ✅ pass - ite_cond_calls_Any_get_1
-test_bubble_sort_step.py(8, 8): ✅ pass - set_t2_calls_Any_get_0
+test_bubble_sort_step.py(8, 8): ✅ pass - precondition
 test_bubble_sort_step.py(8, 8): ✅ pass - assert(163)
-test_bubble_sort_step.py(9, 8): ✅ pass - assert_assert(187)_calls_Any_get_0
+test_bubble_sort_step.py(9, 16): ✅ pass - precondition
 test_bubble_sort_step.py(9, 8): ✅ pass - Check Any_sets! exception
-test_bubble_sort_step.py(9, 8): ✅ pass - set_xs_calls_Any_get_0
 test_bubble_sort_step.py(10, 8): ✅ pass - Check Any_sets! exception
-test_bubble_sort_step.py(11, 7): ✅ pass - assert_assert(227)_calls_Any_get_0
-test_bubble_sort_step.py(11, 7): ✅ pass - assert_assert(227)_calls_Any_get_1
+test_bubble_sort_step.py(11, 7): ✅ pass - precondition
+test_bubble_sort_step.py(11, 15): ✅ pass - precondition
 test_bubble_sort_step.py(11, 7): ✅ pass - Check PGt exception
-test_bubble_sort_step.py(11, 4): ✅ pass - ite_cond_calls_Any_get_0
-test_bubble_sort_step.py(11, 4): ✅ pass - ite_cond_calls_Any_get_1
-test_bubble_sort_step.py(15, 4): ✅ pass - assert_assert(311)_calls_Any_get_0
+test_bubble_sort_step.py(12, 8): ✅ pass - precondition
+test_bubble_sort_step.py(12, 8): ✅ pass - assert(250)
+test_bubble_sort_step.py(13, 16): ✅ pass - precondition
+test_bubble_sort_step.py(13, 8): ✅ pass - Check Any_sets! exception
+test_bubble_sort_step.py(14, 8): ✅ pass - Check Any_sets! exception
+test_bubble_sort_step.py(15, 11): ✅ pass - precondition
 test_bubble_sort_step.py(15, 4): ✅ pass - sorted first
-test_bubble_sort_step.py(16, 4): ✅ pass - assert_assert(349)_calls_Any_get_0
+test_bubble_sort_step.py(16, 11): ✅ pass - precondition
 test_bubble_sort_step.py(16, 4): ✅ pass - sorted second
-test_bubble_sort_step.py(17, 4): ✅ pass - assert_assert(388)_calls_Any_get_0
+test_bubble_sort_step.py(17, 11): ✅ pass - precondition
 test_bubble_sort_step.py(17, 4): ✅ pass - sorted third
-DETAIL: 39 passed, 0 failed, 0 inconclusive
+DETAIL: 30 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_empty.expected b/StrataTest/Languages/Python/expected_laurel/test_class_empty.expected
index aab04f3a0d..7f98693936 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_empty.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_empty.expected
@@ -1,4 +1,4 @@
-test_class_empty.py(5, 4): ✅ pass - callElimAssert_requires_4
+test_class_empty.py(5, 4): ✅ pass - precondition
 test_class_empty.py(6, 4): ✅ pass - empty class instantiated
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_field_init.expected b/StrataTest/Languages/Python/expected_laurel/test_class_field_init.expected
index 7cb1e2fc89..0ff29bd94b 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_field_init.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_field_init.expected
@@ -1,2 +1,3 @@
-DETAIL: 0 passed, 0 failed, 0 inconclusive
+test_class_field_init.py(20, 4): ✔️ always true if reached - (CircularBuffer@__init__ requires) Type constraint of size, (CircularBuffer@__init__ requires) Type constraint of name
+DETAIL: 1 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_field_use.expected b/StrataTest/Languages/Python/expected_laurel/test_class_field_use.expected
index 0caaf75c9f..29a689ea2c 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_field_use.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_field_use.expected
@@ -1,5 +1,6 @@
+test_class_field_use.py(13, 4): ✔️ always true if reached - (CircularBuffer@__init__ requires) Type constraint of n
 test_class_field_use.py(14, 4): ✔️ always true if reached - Check PMul exception
 test_class_field_use.py(14, 4): ✔️ always true if reached - assert(302)
 test_class_field_use.py(15, 4): ✔️ always true if reached - Doubling of buffer did not work
-DETAIL: 3 passed, 0 failed, 0 inconclusive
+DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_method_call_from_main.expected b/StrataTest/Languages/Python/expected_laurel/test_class_method_call_from_main.expected
index 0047be2edb..15fd5c1889 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_method_call_from_main.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_method_call_from_main.expected
@@ -1,6 +1,5 @@
 test_class_method_call_from_main.py(10, 8): ❓ unknown - name must not be empty
-test_class_method_call_from_main.py(9, 23): ❓ unknown - (Greeter@greet ensures) Return type constraint
 test_class_method_call_from_main.py(14, 4): ✅ pass - (Greeter@__init__ requires) Type constraint of name
 test_class_method_call_from_main.py(15, 4): ✅ pass - assert(415)
-DETAIL: 2 passed, 0 failed, 2 inconclusive
+DETAIL: 2 passed, 0 failed, 1 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_methods.expected b/StrataTest/Languages/Python/expected_laurel/test_class_methods.expected
index 36c53a8361..9bcf315a1b 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_methods.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_methods.expected
@@ -1,11 +1,16 @@
-test_class_methods.py(34, 4): ✔️ always true if reached - main_assert(471)_13
+test_class_methods.py(34, 4): ✔️ always true if reached - (Account@__init__ requires) Type constraint of owner, (Account@__init__ requires) Type constraint of balance
+test_class_methods.py(34, 4): ✔️ always true if reached - main_assert(471)_45
 test_class_methods.py(34, 4): ✔️ always true if reached - get_owner should return Alice
-test_class_methods.py(34, 4): ✔️ always true if reached - main_assert(564)_15
+test_class_methods.py(34, 4): ✔️ always true if reached - main_assert(564)_48
 test_class_methods.py(34, 4): ✔️ always true if reached - get_balance should return 100
-test_class_methods.py(34, 4): ✔️ always true if reached - main_assert(678)_17
+test_class_methods.py(34, 4): ✔️ always true if reached - (Account@set_balance requires) Type constraint of amount
+test_class_methods.py(27, 4): ✔️ always true if reached - (Account@set_balance ensures) Return type constraint
+test_class_methods.py(34, 4): ✔️ always true if reached - main_assert(678)_53
 test_class_methods.py(34, 4): ✔️ always true if reached - set_balance should update balance
+test_class_methods.py(34, 4): ✔️ always true if reached - (Origin_test_helper_procedure_Requires)req_name_is_foo, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
 test_class_methods.py(31, 4): ✔️ always true if reached - assert_name_is_foo
 test_class_methods.py(31, 4): ✔️ always true if reached - assert_opt_name_none_or_str
 test_class_methods.py(31, 4): ✔️ always true if reached - assert_opt_name_none_or_bar
-DETAIL: 9 passed, 0 failed, 0 inconclusive
+test_class_methods.py(31, 4): ✔️ always true if reached - ensures_maybe_except_none
+DETAIL: 14 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_mixed_init.expected b/StrataTest/Languages/Python/expected_laurel/test_class_mixed_init.expected
index 766329f9a4..ee2f8ef831 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_mixed_init.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_mixed_init.expected
@@ -1,4 +1,6 @@
+test_class_mixed_init.py(19, 0): ✔️ always true if reached - (WithInit@__init__ requires) Type constraint of x
 test_class_mixed_init.py(19, 0): ✔️ always true if reached - class with init
+test_class_mixed_init.py(19, 0): ✔️ always true if reached - precondition
 test_class_mixed_init.py(19, 0): ❓ unknown - class with init
-DETAIL: 1 passed, 0 failed, 1 inconclusive
+DETAIL: 3 passed, 0 failed, 1 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_no_init.expected b/StrataTest/Languages/Python/expected_laurel/test_class_no_init.expected
index 7228247375..a55c76cfe4 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_no_init.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_no_init.expected
@@ -1,4 +1,4 @@
-test_class_no_init.py(5, 4): ✅ pass - callElimAssert_requires_4
+test_class_no_init.py(5, 4): ✅ pass - precondition
 test_class_no_init.py(6, 4): ❓ unknown - class without __init__
 DETAIL: 1 passed, 0 failed, 1 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_no_init_multi_field.expected b/StrataTest/Languages/Python/expected_laurel/test_class_no_init_multi_field.expected
index 3dbe40b3b6..13ba7f459b 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_no_init_multi_field.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_no_init_multi_field.expected
@@ -1,4 +1,4 @@
-test_class_no_init_multi_field.py(7, 4): ✅ pass - callElimAssert_requires_4
+test_class_no_init_multi_field.py(7, 4): ✅ pass - precondition
 test_class_no_init_multi_field.py(8, 4): ✅ pass - class with multiple annotated fields no init
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_no_init_with_method.expected b/StrataTest/Languages/Python/expected_laurel/test_class_no_init_with_method.expected
index 29b6682a29..82dccbedf2 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_no_init_with_method.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_no_init_with_method.expected
@@ -1,5 +1,4 @@
-test_class_no_init_with_method.py(4, 23): ❓ unknown - (WithMethod@get_x ensures) Return type constraint
-test_class_no_init_with_method.py(8, 4): ✅ pass - callElimAssert_requires_4
+test_class_no_init_with_method.py(8, 4): ✅ pass - precondition
 test_class_no_init_with_method.py(9, 4): ✅ pass - class with method but no __init__
-DETAIL: 2 passed, 0 failed, 1 inconclusive
-RESULT: Inconclusive
+DETAIL: 2 passed, 0 failed, 0 inconclusive
+RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_class_with_methods.expected b/StrataTest/Languages/Python/expected_laurel/test_class_with_methods.expected
index 1085e02e58..8e46807ff6 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_class_with_methods.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_class_with_methods.expected
@@ -5,5 +5,5 @@ test_class_with_methods.py(32, 4): ✔️ always true if reached - get_name shou
 test_class_with_methods.py(29, 4): ✔️ always true if reached - assert_name_is_foo
 test_class_with_methods.py(29, 4): ✔️ always true if reached - assert_opt_name_none_or_str
 test_class_with_methods.py(29, 4): ✔️ always true if reached - assert_opt_name_none_or_bar
-DETAIL: 7 passed, 0 failed, 0 inconclusive
+DETAIL: 10 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_coerce_int_in_any_list.expected b/StrataTest/Languages/Python/expected_laurel/test_coerce_int_in_any_list.expected
index 26134635da..f92d9c87a5 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_coerce_int_in_any_list.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_coerce_int_in_any_list.expected
@@ -1,6 +1,6 @@
-test_coerce_int_in_any_list.py(5, 4): ✅ pass - assert_assert(103)_calls_Any_get_0
+test_coerce_int_in_any_list.py(5, 11): ✅ pass - precondition
 test_coerce_int_in_any_list.py(5, 4): ✅ pass - int in Any list
-test_coerce_int_in_any_list.py(6, 4): ✅ pass - assert_assert(144)_calls_Any_get_0
+test_coerce_int_in_any_list.py(6, 11): ✅ pass - precondition
 test_coerce_int_in_any_list.py(6, 4): ✅ pass - str in Any list
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_datetime.expected b/StrataTest/Languages/Python/expected_laurel/test_datetime.expected
index f627b50117..475cfe68af 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_datetime.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_datetime.expected
@@ -1,8 +1,5 @@
 test_datetime.py(13, 0): ✅ pass - (Origin_datetime_date_Requires)d_type
-test_datetime.py(14, 0): ✅ pass - (Origin_timedelta_Requires)
-test_datetime.py(14, 0): ✅ pass - (Origin_timedelta_Requires)hours_type
-test_datetime.py(14, 0): ✅ pass - (Origin_timedelta_Requires)days_pos
-test_datetime.py(14, 0): ✅ pass - (Origin_timedelta_Requires)hours_pos
+test_datetime.py(14, 0): ✅ pass - (Origin_timedelta_Requires), (Origin_timedelta_Requires)hours_type, (Origin_timedelta_Requires)days_pos, (Origin_timedelta_Requires)hours_pos
 test_datetime.py(15, 19): ✅ pass - Check PSub exception
 test_datetime.py(21, 7): ✅ pass - Check PLe exception
 test_datetime.py(21, 0): ✅ pass - assert(554)
@@ -10,5 +7,5 @@ test_datetime.py(25, 0): ✅ pass - assert(673)
 test_datetime.py(27, 0): ✅ pass - assert(758)
 test_datetime.py(30, 7): ✅ pass - Check PLe exception
 test_datetime.py(30, 0): ✅ pass - assert(859)
-DETAIL: 12 passed, 0 failed, 0 inconclusive
+DETAIL: 9 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_datetime_now_tz.expected b/StrataTest/Languages/Python/expected_laurel/test_datetime_now_tz.expected
index 4ef6e80e7b..50f1fb5f5e 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_datetime_now_tz.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_datetime_now_tz.expected
@@ -1,9 +1,6 @@
-test_datetime_now_tz.py(4, 0): ✅ pass - (Origin_timedelta_Requires)
-test_datetime_now_tz.py(4, 0): ✅ pass - (Origin_timedelta_Requires)hours_type
-test_datetime_now_tz.py(4, 0): ✅ pass - (Origin_timedelta_Requires)days_pos
-test_datetime_now_tz.py(4, 0): ✅ pass - (Origin_timedelta_Requires)hours_pos
+test_datetime_now_tz.py(4, 0): ✅ pass - (Origin_timedelta_Requires), (Origin_timedelta_Requires)hours_type, (Origin_timedelta_Requires)days_pos, (Origin_timedelta_Requires)hours_pos
 test_datetime_now_tz.py(5, 18): ✅ pass - Check PSub exception
 test_datetime_now_tz.py(6, 7): ✅ pass - Check PLe exception
 test_datetime_now_tz.py(6, 0): ✅ pass - assert(162)
-DETAIL: 7 passed, 0 failed, 0 inconclusive
+DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_default_params.expected b/StrataTest/Languages/Python/expected_laurel/test_default_params.expected
index 395575a21c..15898dab3f 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_default_params.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_default_params.expected
@@ -1,27 +1,21 @@
 test_default_params.py(2, 18): ✅ pass - Check PAdd exception
 test_default_params.py(2, 4): ✅ pass - assert(58)
-test_default_params.py(1, 49): ✅ pass - (greet ensures) Return type constraint
 test_default_params.py(6, 4): ✅ pass - assert(160)
 test_default_params.py(7, 4): ✅ pass - assert(180)
 test_default_params.py(8, 10): ✅ pass - Check PLt exception
 test_default_params.py(9, 17): ❓ unknown - Check PMul exception
 test_default_params.py(10, 12): ❓ unknown - Check PAdd exception
-test_default_params.py(5, 38): ❓ unknown - (power ensures) Return type constraint
-test_default_params.py(14, 4): ✅ pass - (greet requires) Type constraint of name
-test_default_params.py(14, 4): ✅ pass - (greet requires) Type constraint of greeting
+test_default_params.py(14, 4): ✅ pass - (greet requires) Type constraint of name, (greet requires) Type constraint of greeting
 test_default_params.py(14, 4): ✅ pass - assert(294)
 test_default_params.py(15, 4): ❓ unknown - default greeting failed
-test_default_params.py(17, 4): ✅ pass - (greet requires) Type constraint of name
-test_default_params.py(17, 4): ✅ pass - (greet requires) Type constraint of greeting
+test_default_params.py(17, 4): ✅ pass - (greet requires) Type constraint of name, (greet requires) Type constraint of greeting
 test_default_params.py(17, 4): ✅ pass - assert(386)
 test_default_params.py(18, 4): ❓ unknown - explicit greeting failed
-test_default_params.py(20, 4): ✅ pass - (power requires) Type constraint of base
-test_default_params.py(20, 4): ✅ pass - (power requires) Type constraint of exp
+test_default_params.py(20, 4): ✅ pass - (power requires) Type constraint of base, (power requires) Type constraint of exp
 test_default_params.py(20, 4): ✅ pass - assert(478)
 test_default_params.py(21, 4): ❓ unknown - default power failed
-test_default_params.py(23, 4): ✅ pass - (power requires) Type constraint of base
-test_default_params.py(23, 4): ✅ pass - (power requires) Type constraint of exp
+test_default_params.py(23, 4): ✅ pass - (power requires) Type constraint of base, (power requires) Type constraint of exp
 test_default_params.py(23, 4): ✅ pass - assert(545)
 test_default_params.py(24, 4): ❓ unknown - explicit power failed
-DETAIL: 18 passed, 0 failed, 7 inconclusive
+DETAIL: 13 passed, 0 failed, 6 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_dict_add_key.expected b/StrataTest/Languages/Python/expected_laurel/test_dict_add_key.expected
index fe764d0f3f..5ec9ce4b73 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_dict_add_key.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_dict_add_key.expected
@@ -1,5 +1,5 @@
 test_dict_add_key.py(3, 4): ✅ pass - Check Any_sets! exception
-test_dict_add_key.py(4, 4): ✅ pass - assert_assert(56)_calls_Any_get_0
+test_dict_add_key.py(4, 11): ✅ pass - precondition
 test_dict_add_key.py(4, 4): ✅ pass - dict add key
 DETAIL: 3 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_dict_assign.expected b/StrataTest/Languages/Python/expected_laurel/test_dict_assign.expected
index 3c6fafeb0a..f7c7754049 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_dict_assign.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_dict_assign.expected
@@ -1,5 +1,5 @@
 test_dict_assign.py(3, 4): ✅ pass - Check Any_sets! exception
-test_dict_assign.py(4, 4): ✅ pass - assert_assert(62)_calls_Any_get_0
+test_dict_assign.py(4, 11): ✅ pass - precondition
 test_dict_assign.py(4, 4): ✅ pass - dict update
 DETAIL: 3 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_dict_create.expected b/StrataTest/Languages/Python/expected_laurel/test_dict_create.expected
index 5613842891..2f04dc4c1b 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_dict_create.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_dict_create.expected
@@ -1,6 +1,6 @@
-test_dict_create.py(3, 4): ✅ pass - assert_assert(53)_calls_Any_get_0
+test_dict_create.py(3, 11): ✅ pass - precondition
 test_dict_create.py(3, 4): ✅ pass - dict access
-test_dict_create.py(4, 4): ✅ pass - assert_assert(91)_calls_Any_get_0
+test_dict_create.py(4, 11): ✅ pass - precondition
 test_dict_create.py(4, 4): ✅ pass - dict access b
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_dict_in.expected b/StrataTest/Languages/Python/expected_laurel/test_dict_in.expected
index 57ab802313..b00542f78d 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_dict_in.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_dict_in.expected
@@ -1,6 +1,6 @@
-test_dict_in.py(3, 4): ✅ pass - assert_assert(49)_calls_PIn_0
+test_dict_in.py(3, 11): ✅ pass - precondition
 test_dict_in.py(3, 4): ✅ pass - key in dict
-test_dict_in.py(4, 4): ✅ pass - assert_assert(84)_calls_PNotIn_0
+test_dict_in.py(4, 11): ✅ pass - precondition
 test_dict_in.py(4, 4): ✅ pass - key not in dict
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_dict_overwrite.expected b/StrataTest/Languages/Python/expected_laurel/test_dict_overwrite.expected
index a326876db0..48261dcb07 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_dict_overwrite.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_dict_overwrite.expected
@@ -1,6 +1,6 @@
 test_dict_overwrite.py(3, 4): ✅ pass - Check Any_sets! exception
 test_dict_overwrite.py(4, 4): ✅ pass - Check Any_sets! exception
-test_dict_overwrite.py(5, 4): ✅ pass - assert_assert(78)_calls_Any_get_0
+test_dict_overwrite.py(5, 11): ✅ pass - precondition
 test_dict_overwrite.py(5, 4): ✅ pass - dict overwrite
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_empty_dict_access.expected b/StrataTest/Languages/Python/expected_laurel/test_empty_dict_access.expected
index cb7f5dfa7d..26b71e1c82 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_empty_dict_access.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_empty_dict_access.expected
@@ -1,6 +1,6 @@
-test_empty_dict_access.py(5, 8): ✅ pass - set_r_calls_Any_get_0
 test_empty_dict_access.py(3, 4): ✅ pass - assert(33)
-test_empty_dict_access.py(4, 4): ✅ pass - ite_cond_calls_PIn_0
+test_empty_dict_access.py(4, 7): ✅ pass - precondition
+test_empty_dict_access.py(5, 8): ✅ pass - precondition
 test_empty_dict_access.py(7, 12): ✅ pass - Check PNeg exception
 test_empty_dict_access.py(8, 16): ✅ pass - Check PNeg exception
 test_empty_dict_access.py(8, 4): ✅ pass - missing key guarded
diff --git a/StrataTest/Languages/Python/expected_laurel/test_flag_pattern.expected b/StrataTest/Languages/Python/expected_laurel/test_flag_pattern.expected
index 1ae36f0f29..5d9741fddb 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_flag_pattern.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_flag_pattern.expected
@@ -1,9 +1,8 @@
 test_flag_pattern.py(3, 4): ✅ pass - assert(54)
-test_flag_pattern.py(4, 4): ✅ pass - assume_assume(81)_calls_PIn_0
-test_flag_pattern.py(5, 11): ✅ pass - assert_assert(108)_calls_PMod_0
+test_flag_pattern.py(4, 4): ✅ pass - precondition
+test_flag_pattern.py(5, 11): ✅ pass - precondition
 test_flag_pattern.py(5, 11): ✅ pass - Check PMod exception
-test_flag_pattern.py(5, 8): ✅ pass - ite_cond_calls_PMod_0
 test_flag_pattern.py(7, 11): ❓ unknown - Check PNot exception
 test_flag_pattern.py(7, 4): ❓ unknown - no even numbers
-DETAIL: 5 passed, 0 failed, 2 inconclusive
+DETAIL: 4 passed, 0 failed, 2 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_for_else_break.expected b/StrataTest/Languages/Python/expected_laurel/test_for_else_break.expected
index 5d1dcabdd9..480b1225ab 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_for_else_break.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_for_else_break.expected
@@ -1,5 +1,5 @@
 test_for_else_break.py(2, 4): ✅ pass - assert(31)
-test_for_else_break.py(3, 4): ✅ pass - assume_assume(46)_calls_PIn_0
+test_for_else_break.py(3, 4): ✅ pass - precondition
 test_for_else_break.py(8, 4): ✅ pass - for else skipped on break
 DETAIL: 3 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_for_loop.expected b/StrataTest/Languages/Python/expected_laurel/test_for_loop.expected
index 77a760ea8f..6a4e916b20 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_for_loop.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_for_loop.expected
@@ -1,14 +1,14 @@
 test_for_loop.py(3, 4): ✅ pass - assert(64)
-test_for_loop.py(4, 4): ✅ pass - assume_assume(83)_calls_PIn_0
+test_for_loop.py(4, 4): ✅ pass - precondition
 test_for_loop.py(5, 16): ❓ unknown - Check PAdd exception
 test_for_loop.py(6, 4): ❓ unknown - sum of list should be 15
 test_for_loop.py(11, 4): ✅ pass - assert(274)
-test_for_loop.py(12, 4): ✅ pass - assume_assume(293)_calls_PIn_0
+test_for_loop.py(12, 4): ✅ pass - precondition
 test_for_loop.py(13, 11): ✅ pass - Check PGt exception
 test_for_loop.py(14, 20): ❓ unknown - Check PAdd exception
 test_for_loop.py(15, 4): ❓ unknown - should count 3 items greater than 3
 test_for_loop.py(20, 4): ✅ pass - assert(512)
-test_for_loop.py(21, 4): ✅ pass - assume_assume(531)_calls_PIn_0
+test_for_loop.py(21, 4): ✅ pass - precondition
 test_for_loop.py(25, 4): ❓ unknown (pass on 1 path, unknown on 2 paths) - should have found 30
 DETAIL: 7 passed, 0 failed, 5 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_for_range.expected b/StrataTest/Languages/Python/expected_laurel/test_for_range.expected
index 03b0272495..2c7d54f6ef 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_for_range.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_for_range.expected
@@ -1,13 +1,13 @@
-test_for_range.py(10, 0): ✅ pass - set_i_calls_range_0
-test_for_range.py(3, 0): ✅ pass - set_i_calls_range_0
+test_for_range.py(3, 9): ✅ pass - precondition
 test_for_range.py(4, 11): ✅ pass - Check PLt exception
 test_for_range.py(4, 4): ✅ pass - assert(46)
 test_for_range.py(5, 11): ✅ pass - Check PGe exception
 test_for_range.py(5, 4): ✅ pass - assert(63)
-test_for_range.py(6, 4): ✅ pass - set_j_calls_Any_get_0
+test_for_range.py(6, 4): ✅ pass - precondition
 test_for_range.py(7, 11): ✅ pass - Check PLt exception
 test_for_range.py(7, 4): ✅ pass - assert(101)
 test_for_range.py(10, 15): ✅ pass - Check PNeg exception
+test_for_range.py(10, 9): ✅ pass - precondition
 test_for_range.py(13, 0): ✅ pass - assert(156)
 DETAIL: 11 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_function_def_calls.expected b/StrataTest/Languages/Python/expected_laurel/test_function_def_calls.expected
index 62499427b9..8e006bfe41 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_function_def_calls.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_function_def_calls.expected
@@ -1,6 +1,4 @@
-test_function_def_calls.py(6, 4): ❓ unknown - (Origin_test_helper_procedure_Requires)req_name_is_foo
-test_function_def_calls.py(6, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str
-test_function_def_calls.py(6, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
+test_function_def_calls.py(6, 4): ❓ unknown - (Origin_test_helper_procedure_Requires)req_name_is_foo, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
 test_function_def_calls.py(9, 4): ✅ pass - (my_f requires) Type constraint of s
-DETAIL: 3 passed, 0 failed, 1 inconclusive
+DETAIL: 1 passed, 0 failed, 1 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_if_elif.expected b/StrataTest/Languages/Python/expected_laurel/test_if_elif.expected
index 2c4b59ca73..18cd9da09a 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_if_elif.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_if_elif.expected
@@ -1,5 +1,4 @@
 test_if_elif.py(2, 7): ✅ pass - Check PLt exception
-test_if_elif.py(1, 24): ✅ pass - (classify ensures) Return type constraint
 test_if_elif.py(6, 9): ✅ pass - Check PLt exception
 test_if_elif.py(12, 23): ✅ pass - Check PNeg exception
 test_if_elif.py(12, 4): ✅ pass - (classify requires) Type constraint of x
@@ -14,5 +13,5 @@ test_if_elif.py(19, 4): ❓ unknown - should be small
 test_if_elif.py(21, 4): ✅ pass - (classify requires) Type constraint of x
 test_if_elif.py(21, 4): ✅ pass - assert(416)
 test_if_elif.py(22, 4): ❓ unknown - should be large
-DETAIL: 12 passed, 0 failed, 4 inconclusive
+DETAIL: 11 passed, 0 failed, 4 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_int_bool_conversion.expected b/StrataTest/Languages/Python/expected_laurel/test_int_bool_conversion.expected
index 5076678699..aec1037296 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_int_bool_conversion.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_int_bool_conversion.expected
@@ -1,5 +1,5 @@
-test_int_bool_conversion.py(4, 8): ✅ pass - assert(65)
 test_int_bool_conversion.py(2, 4): ✅ pass - assert(36)
+test_int_bool_conversion.py(4, 8): ✅ pass - assert(65)
 test_int_bool_conversion.py(6, 8): ✅ pass - assert(94)
 test_int_bool_conversion.py(7, 4): ✅ pass - zero is falsy
 DETAIL: 4 passed, 0 failed, 0 inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_int_floordiv.expected b/StrataTest/Languages/Python/expected_laurel/test_int_floordiv.expected
index a62d7083eb..7bce6b7cd0 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_int_floordiv.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_int_floordiv.expected
@@ -1,8 +1,8 @@
 test_int_floordiv.py(2, 4): ✅ pass - assert(29)
 test_int_floordiv.py(3, 4): ✅ pass - assert(45)
-test_int_floordiv.py(4, 13): ✅ pass - assert_assert(69)_calls_PFloorDiv_0
+test_int_floordiv.py(4, 13): ✅ pass - precondition
 test_int_floordiv.py(4, 13): ✅ pass - Check PFloorDiv exception
-test_int_floordiv.py(4, 4): ✅ pass - set_c_calls_PFloorDiv_0
+test_int_floordiv.py(4, 4): ✅ pass - precondition
 test_int_floordiv.py(4, 4): ✅ pass - assert(60)
 test_int_floordiv.py(5, 4): ✅ pass - int floor division
 DETAIL: 7 passed, 0 failed, 0 inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_int_mod.expected b/StrataTest/Languages/Python/expected_laurel/test_int_mod.expected
index 1a2a0276e6..c93755257b 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_int_mod.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_int_mod.expected
@@ -1,8 +1,8 @@
 test_int_mod.py(2, 4): ✅ pass - assert(24)
 test_int_mod.py(3, 4): ✅ pass - assert(40)
-test_int_mod.py(4, 13): ✅ pass - assert_assert(64)_calls_PMod_0
+test_int_mod.py(4, 13): ✅ pass - precondition
 test_int_mod.py(4, 13): ✅ pass - Check PMod exception
-test_int_mod.py(4, 4): ✅ pass - set_c_calls_PMod_0
+test_int_mod.py(4, 4): ✅ pass - precondition
 test_int_mod.py(4, 4): ✅ pass - assert(55)
 test_int_mod.py(5, 4): ✅ pass - int modulo
 DETAIL: 7 passed, 0 failed, 0 inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_int_negative_floordiv.expected b/StrataTest/Languages/Python/expected_laurel/test_int_negative_floordiv.expected
index 527ca97690..e723a2ed74 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_int_negative_floordiv.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_int_negative_floordiv.expected
@@ -1,7 +1,6 @@
-test_int_negative_floordiv.py(2, 11): ✅ pass - assert_assert(45)_calls_PFloorDiv_0
+test_int_negative_floordiv.py(2, 11): ✅ pass - precondition
 test_int_negative_floordiv.py(2, 11): ✅ pass - Check PFloorDiv exception
 test_int_negative_floordiv.py(2, 24): ✅ pass - Check PNeg exception
-test_int_negative_floordiv.py(2, 4): ✅ pass - assert_assert(38)_calls_PFloorDiv_0
 test_int_negative_floordiv.py(2, 4): ✅ pass - floor division rounds toward negative infinity
-DETAIL: 5 passed, 0 failed, 0 inconclusive
+DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_int_negative_mod.expected b/StrataTest/Languages/Python/expected_laurel/test_int_negative_mod.expected
index 6f8a8fbc25..e14ddf7e30 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_int_negative_mod.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_int_negative_mod.expected
@@ -1,6 +1,5 @@
-test_int_negative_mod.py(2, 11): ✅ pass - assert_assert(40)_calls_PMod_0
+test_int_negative_mod.py(2, 11): ✅ pass - precondition
 test_int_negative_mod.py(2, 11): ✅ pass - Check PMod exception
-test_int_negative_mod.py(2, 4): ✅ pass - assert_assert(33)_calls_PMod_0
 test_int_negative_mod.py(2, 4): ✅ pass - python mod is always non-negative for positive divisor
-DETAIL: 4 passed, 0 failed, 0 inconclusive
+DETAIL: 3 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_list_assign.expected b/StrataTest/Languages/Python/expected_laurel/test_list_assign.expected
index 032ca9ce08..6bd8d888f6 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_list_assign.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_list_assign.expected
@@ -1,5 +1,5 @@
 test_list_assign.py(3, 4): ✅ pass - Check Any_sets! exception
-test_list_assign.py(4, 4): ✅ pass - assert_assert(62)_calls_Any_get_0
+test_list_assign.py(4, 11): ✅ pass - precondition
 test_list_assign.py(4, 4): ✅ pass - list element assignment
 DETAIL: 3 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_list_concat.expected b/StrataTest/Languages/Python/expected_laurel/test_list_concat.expected
index bfcfa2f91d..c32762406c 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_list_concat.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_list_concat.expected
@@ -1,7 +1,7 @@
 test_list_concat.py(4, 8): ✅ pass - Check PAdd exception
-test_list_concat.py(5, 4): ✅ pass - assert_assert(72)_calls_Any_get_0
+test_list_concat.py(5, 11): ✅ pass - precondition
 test_list_concat.py(5, 4): ✅ pass - first
-test_list_concat.py(6, 4): ✅ pass - assert_assert(102)_calls_Any_get_0
+test_list_concat.py(6, 11): ✅ pass - precondition
 test_list_concat.py(6, 4): ✅ pass - last
 DETAIL: 5 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_list_create.expected b/StrataTest/Languages/Python/expected_laurel/test_list_create.expected
index 5ff4e591a6..1d405dd67b 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_list_create.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_list_create.expected
@@ -1,6 +1,6 @@
-test_list_create.py(3, 4): ✅ pass - assert_assert(47)_calls_Any_get_0
+test_list_create.py(3, 11): ✅ pass - precondition
 test_list_create.py(3, 4): ✅ pass - first element
-test_list_create.py(4, 4): ✅ pass - assert_assert(86)_calls_Any_get_0
+test_list_create.py(4, 11): ✅ pass - precondition
 test_list_create.py(4, 4): ✅ pass - last element
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_list_empty.expected b/StrataTest/Languages/Python/expected_laurel/test_list_empty.expected
index 3c2df0a452..84c8f55f2c 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_list_empty.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_list_empty.expected
@@ -1,5 +1,5 @@
 test_list_empty.py(3, 4): ✅ pass - assert(39)
-test_list_empty.py(4, 4): ✅ pass - assume_assume(58)_calls_PIn_0
+test_list_empty.py(4, 4): ✅ pass - precondition
 test_list_empty.py(5, 16): ✅ pass - Check PAdd exception
 test_list_empty.py(6, 4): ✅ pass - empty list
 DETAIL: 4 passed, 0 failed, 0 inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_list_in.expected b/StrataTest/Languages/Python/expected_laurel/test_list_in.expected
index de531eb5d5..22ca9da73b 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_list_in.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_list_in.expected
@@ -1,6 +1,6 @@
-test_list_in.py(3, 4): ✅ pass - assert_assert(49)_calls_PIn_0
+test_list_in.py(3, 11): ✅ pass - precondition
 test_list_in.py(3, 4): ✅ pass - element in list
-test_list_in.py(4, 4): ✅ pass - assert_assert(87)_calls_PNotIn_0
+test_list_in.py(4, 11): ✅ pass - precondition
 test_list_in.py(4, 4): ✅ pass - element not in list
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_loops.expected b/StrataTest/Languages/Python/expected_laurel/test_loops.expected
index 4adb7f6b70..40c66e20c0 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_loops.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_loops.expected
@@ -1,26 +1,22 @@
 test_loops.py(3, 4): ✅ pass - assert(38)
-test_loops.py(4, 4): ✅ pass - assume_assume(53)_calls_PIn_0
+test_loops.py(4, 4): ✅ pass - precondition
 test_loops.py(5, 12): ❓ unknown - Check PAdd exception
 test_loops.py(6, 11): ❓ unknown - Check PGt exception
 test_loops.py(6, 4): ❓ unknown - simple loop incremented
 test_loops.py(9, 4): ✅ pass - assert(174)
-test_loops.py(10, 4): ❓ unknown - set_a_calls_Any_get_0
-test_loops.py(10, 4): ❓ unknown - set_b_calls_Any_get_0
+test_loops.py(10, 4): ❓ unknown - precondition
 test_loops.py(11, 13): ❓ unknown - Check PSub exception
 test_loops.py(12, 11): ❓ unknown - Check PLt exception
 test_loops.py(12, 4): ❓ unknown - tuple unpacking decremented
 test_loops.py(15, 4): ✅ pass - assert(337)
-test_loops.py(16, 4): ❓ unknown - set_x_calls_Any_get_0
-test_loops.py(16, 4): ❓ unknown - set_tuple_360_calls_Any_get_0
-test_loops.py(16, 4): ❓ unknown - set_y_calls_Any_get_0
-test_loops.py(16, 4): ❓ unknown - set_z_calls_Any_get_0
+test_loops.py(16, 4): ❓ unknown - precondition
 test_loops.py(17, 13): ❓ unknown - Check PAdd exception
 test_loops.py(18, 11): ❓ unknown - Check PGt exception
 test_loops.py(18, 4): ❓ unknown - nested unpacking incremented
 test_loops.py(21, 4): ✅ pass - assert(477)
 test_loops.py(22, 10): ✅ pass - Check PGt exception
 test_loops.py(23, 13): ❓ unknown - Check PSub exception
-test_loops.py(24, 11): ❓ unknown - Check PLe exception
-test_loops.py(24, 4): ❓ unknown - while loop did not increase n4
-DETAIL: 6 passed, 0 failed, 18 inconclusive
+test_loops.py(24, 11): ✅ pass - Check PLe exception
+test_loops.py(24, 4): ✅ pass - while loop did not increase n4
+DETAIL: 8 passed, 0 failed, 12 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_method_call_with_kwargs.expected b/StrataTest/Languages/Python/expected_laurel/test_method_call_with_kwargs.expected
index 315f62f13d..2503bcbd16 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_method_call_with_kwargs.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_method_call_with_kwargs.expected
@@ -1,9 +1,4 @@
-test_method_call_with_kwargs.py(5, 82): ✅ pass - (MyClass@some_method ensures) Return type constraint
-test_method_call_with_kwargs.py(8, 0): ✅ pass - (MyClass@__init__ requires) Type constraint of ip1
-test_method_call_with_kwargs.py(8, 0): ✅ pass - (MyClass@__init__ requires) Type constraint of ip2
-test_method_call_with_kwargs.py(8, 0): ✅ pass - (MyClass@__init__ requires) Type constraint of ip3
-test_method_call_with_kwargs.py(9, 0): ✅ pass - (MyClass@some_method requires) Type constraint of ip1
-test_method_call_with_kwargs.py(9, 0): ✅ pass - (MyClass@some_method requires) Type constraint of ip2
-test_method_call_with_kwargs.py(9, 0): ✅ pass - (MyClass@some_method requires) Type constraint of ip3
-DETAIL: 7 passed, 0 failed, 0 inconclusive
+test_method_call_with_kwargs.py(8, 0): ✅ pass - (MyClass@__init__ requires) Type constraint of ip1, (MyClass@__init__ requires) Type constraint of ip2, (MyClass@__init__ requires) Type constraint of ip3
+test_method_call_with_kwargs.py(9, 0): ✅ pass - (MyClass@some_method requires) Type constraint of ip1, (MyClass@some_method requires) Type constraint of ip2, (MyClass@some_method requires) Type constraint of ip3
+DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_method_kwargs_no_hierarchy.expected b/StrataTest/Languages/Python/expected_laurel/test_method_kwargs_no_hierarchy.expected
index 56de827e26..14ec6f436e 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_method_kwargs_no_hierarchy.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_method_kwargs_no_hierarchy.expected
@@ -8,5 +8,5 @@ test_method_kwargs_no_hierarchy.py(11, 18): ✅ pass - (Calculator@add requires)
 test_method_kwargs_no_hierarchy.py(11, 4): ✅ pass - assert(254)
 test_method_kwargs_no_hierarchy.py(12, 4): ❓ unknown - assert(286)
 test_method_kwargs_no_hierarchy.py(8, 14): ✅ pass - (main ensures) Return type constraint
-DETAIL: 8 passed, 0 failed, 2 inconclusive
+DETAIL: 6 passed, 0 failed, 2 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_mixed_types_list.expected b/StrataTest/Languages/Python/expected_laurel/test_mixed_types_list.expected
index 6ea1964407..d320eab756 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_mixed_types_list.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_mixed_types_list.expected
@@ -1,6 +1,6 @@
-test_mixed_types_list.py(3, 4): ✅ pass - assert_assert(56)_calls_Any_get_0
+test_mixed_types_list.py(3, 11): ✅ pass - precondition
 test_mixed_types_list.py(3, 4): ✅ pass - int element
-test_mixed_types_list.py(4, 4): ✅ pass - assert_assert(93)_calls_Any_get_0
+test_mixed_types_list.py(4, 11): ✅ pass - precondition
 test_mixed_types_list.py(4, 4): ✅ pass - str element
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_module_level.expected b/StrataTest/Languages/Python/expected_laurel/test_module_level.expected
index d6bc9a6556..e1d5280f6e 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_module_level.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_module_level.expected
@@ -1,13 +1,13 @@
-test_module_level.py(9, 0): ✅ pass - assert_assert(115)_calls_Any_get_0
+test_module_level.py(9, 7): ✅ pass - precondition
 test_module_level.py(9, 0): ✅ pass - assert(115)
-test_module_level.py(10, 0): ✅ pass - assert_assert(145)_calls_Any_get_0
+test_module_level.py(10, 7): ✅ pass - precondition
 test_module_level.py(10, 0): ✅ pass - assert(145)
 test_module_level.py(12, 0): ✅ pass - Check Any_sets! exception
-test_module_level.py(13, 0): ✅ pass - assert_assert(201)_calls_Any_get_0
+test_module_level.py(13, 7): ✅ pass - precondition
 test_module_level.py(13, 0): ✅ pass - assert(201)
-test_module_level.py(14, 0): ✅ pass - assert_assert(236)_calls_PIn_0
+test_module_level.py(14, 7): ✅ pass - precondition
 test_module_level.py(14, 0): ✅ pass - assert(236)
-test_module_level.py(15, 0): ✅ pass - assert_assert(258)_calls_PNotIn_0
+test_module_level.py(15, 7): ✅ pass - precondition
 test_module_level.py(15, 0): ✅ pass - assert(258)
 DETAIL: 11 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_multi_function.expected b/StrataTest/Languages/Python/expected_laurel/test_multi_function.expected
index 1408f7cb98..f0782a29e9 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_multi_function.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_multi_function.expected
@@ -1,18 +1,12 @@
-test_multi_function.py(4, 44): ✅ pass - (create_config ensures) Return type constraint
-test_multi_function.py(9, 4): ✅ pass - ite_cond_calls_PNotIn_0
-test_multi_function.py(8, 47): ✅ pass - (validate_config ensures) Return type constraint
-test_multi_function.py(11, 4): ✅ pass - ite_cond_calls_PNotIn_0
-test_multi_function.py(16, 4): ✅ pass - (create_config requires) Type constraint of name
-test_multi_function.py(16, 4): ✅ pass - (create_config requires) Type constraint of value
+test_multi_function.py(9, 7): ✅ pass - precondition
+test_multi_function.py(11, 7): ✅ pass - precondition
+test_multi_function.py(16, 4): ✅ pass - (create_config requires) Type constraint of name, (create_config requires) Type constraint of value
 test_multi_function.py(17, 4): ✅ pass - (validate_config requires) Type constraint of config
 test_multi_function.py(17, 4): ✅ pass - assert(485)
 test_multi_function.py(18, 7): ✅ pass - Check PNot exception
-test_multi_function.py(20, 4): ❓ unknown - set_LaurelResult_calls_Any_get_0
-test_multi_function.py(23, 4): ✅ pass - (process_config requires) Type constraint of name
-test_multi_function.py(23, 4): ✅ pass - (process_config requires) Type constraint of value
+test_multi_function.py(20, 4): ❓ unknown - precondition
+test_multi_function.py(23, 4): ✅ pass - (process_config requires) Type constraint of name, (process_config requires) Type constraint of value
 test_multi_function.py(24, 4): ❓ unknown - process_config should return value
-test_multi_function.py(26, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_name_is_foo
-test_multi_function.py(26, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str
-test_multi_function.py(26, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
-DETAIL: 14 passed, 0 failed, 2 inconclusive
+test_multi_function.py(26, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_name_is_foo, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
+DETAIL: 8 passed, 0 failed, 2 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_nested_calls.expected b/StrataTest/Languages/Python/expected_laurel/test_nested_calls.expected
index 0f4bb96d26..bc29103fab 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_nested_calls.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_nested_calls.expected
@@ -1,7 +1,5 @@
 test_nested_calls.py(2, 11): ✅ pass - Check PMul exception
-test_nested_calls.py(1, 22): ✅ pass - (double ensures) Return type constraint
 test_nested_calls.py(5, 11): ✅ pass - Check PAdd exception
-test_nested_calls.py(4, 23): ✅ pass - (add_one ensures) Return type constraint
 test_nested_calls.py(8, 4): ✅ pass - (double requires) Type constraint of x
 test_nested_calls.py(8, 4): ✅ pass - assert(107)
 test_nested_calls.py(9, 4): ✅ pass - (double requires) Type constraint of x
@@ -17,5 +15,5 @@ test_nested_calls.py(16, 4): ✅ pass - assert(309)
 test_nested_calls.py(17, 4): ✅ pass - (double requires) Type constraint of x
 test_nested_calls.py(17, 4): ✅ pass - assert(333)
 test_nested_calls.py(18, 4): ❓ unknown - double(add_one(4)) should be 10
-DETAIL: 16 passed, 0 failed, 3 inconclusive
+DETAIL: 14 passed, 0 failed, 3 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_nested_optional.expected b/StrataTest/Languages/Python/expected_laurel/test_nested_optional.expected
index e32ca89fd6..6aeed2d9e5 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_nested_optional.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_nested_optional.expected
@@ -1,4 +1,4 @@
-test_nested_optional.py(5, 4): ✅ pass - assert_assert(90)_calls_Any_get_0
+test_nested_optional.py(5, 11): ✅ pass - precondition
 test_nested_optional.py(5, 4): ✅ pass - nested optional list
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_none_in_list.expected b/StrataTest/Languages/Python/expected_laurel/test_none_in_list.expected
index 11f44bb821..ce2c8b27ee 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_none_in_list.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_none_in_list.expected
@@ -1,4 +1,4 @@
-test_none_in_list.py(3, 4): ✅ pass - assert_assert(38)_calls_Any_get_0
+test_none_in_list.py(3, 11): ✅ pass - precondition
 test_none_in_list.py(3, 4): ✅ pass - None in list
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_param_reassign.expected b/StrataTest/Languages/Python/expected_laurel/test_param_reassign.expected
index 57dfaf7a9e..286d5bc701 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_param_reassign.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_param_reassign.expected
@@ -1,33 +1,25 @@
 test_param_reassign.py(2, 8): ✅ pass - Check PAdd exception
-test_param_reassign.py(1, 37): ✅ pass - (single_param_reassign ensures) Return type constraint
 test_param_reassign.py(6, 8): ✅ pass - Check PAdd exception
 test_param_reassign.py(7, 8): ✅ pass - Check PMul exception
 test_param_reassign.py(8, 11): ✅ pass - Check PAdd exception
-test_param_reassign.py(5, 44): ✅ pass - (multi_param_reassign ensures) Return type constraint
 test_param_reassign.py(11, 11): ✅ pass - Check PAdd exception
-test_param_reassign.py(10, 41): ✅ pass - (no_param_reassign ensures) Return type constraint
 test_param_reassign.py(14, 8): ✅ pass - Check PAdd exception
-test_param_reassign.py(13, 46): ✅ pass - (partial_param_reassign ensures) Return type constraint
 test_param_reassign.py(18, 8): ✅ pass - Check PAdd exception
 test_param_reassign.py(19, 8): ✅ pass - Check PMul exception
-test_param_reassign.py(17, 36): ✅ pass - (param_reassign_twice ensures) Return type constraint
 test_param_reassign.py(23, 4): ✅ pass - (single_param_reassign requires) Type constraint of x
 test_param_reassign.py(23, 4): ✅ pass - assert(422)
 test_param_reassign.py(24, 4): ❓ unknown - single reassign
-test_param_reassign.py(26, 4): ✅ pass - (multi_param_reassign requires) Type constraint of a
-test_param_reassign.py(26, 4): ✅ pass - (multi_param_reassign requires) Type constraint of b
+test_param_reassign.py(26, 4): ✅ pass - (multi_param_reassign requires) Type constraint of a, (multi_param_reassign requires) Type constraint of b
 test_param_reassign.py(26, 4): ✅ pass - assert(500)
 test_param_reassign.py(27, 4): ❓ unknown - multi reassign
-test_param_reassign.py(29, 4): ✅ pass - (no_param_reassign requires) Type constraint of x
-test_param_reassign.py(29, 4): ✅ pass - (no_param_reassign requires) Type constraint of y
+test_param_reassign.py(29, 4): ✅ pass - (no_param_reassign requires) Type constraint of x, (no_param_reassign requires) Type constraint of y
 test_param_reassign.py(29, 4): ✅ pass - assert(580)
 test_param_reassign.py(30, 4): ❓ unknown - no reassign
-test_param_reassign.py(32, 4): ✅ pass - (partial_param_reassign requires) Type constraint of x
-test_param_reassign.py(32, 4): ✅ pass - (partial_param_reassign requires) Type constraint of y
+test_param_reassign.py(32, 4): ✅ pass - (partial_param_reassign requires) Type constraint of x, (partial_param_reassign requires) Type constraint of y
 test_param_reassign.py(32, 4): ✅ pass - assert(653)
 test_param_reassign.py(33, 4): ❓ unknown - partial reassign
 test_param_reassign.py(35, 4): ✅ pass - (param_reassign_twice requires) Type constraint of x
 test_param_reassign.py(35, 4): ✅ pass - assert(738)
 test_param_reassign.py(36, 4): ❓ unknown - reassign twice
-DETAIL: 26 passed, 0 failed, 5 inconclusive
+DETAIL: 18 passed, 0 failed, 5 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_param_reassign_kwargs.expected b/StrataTest/Languages/Python/expected_laurel/test_param_reassign_kwargs.expected
index 330fc8092f..996c36bc2f 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_param_reassign_kwargs.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_param_reassign_kwargs.expected
@@ -1,8 +1,6 @@
 test_param_reassign_kwargs.py(2, 11): ✅ pass - Check PAdd exception
-test_param_reassign_kwargs.py(1, 59): ✅ pass - (greet ensures) Return type constraint
-test_param_reassign_kwargs.py(6, 4): ✅ pass - (greet requires) Type constraint of name
-test_param_reassign_kwargs.py(6, 4): ✅ pass - (greet requires) Type constraint of greeting
+test_param_reassign_kwargs.py(6, 4): ✅ pass - (greet requires) Type constraint of name, (greet requires) Type constraint of greeting
 test_param_reassign_kwargs.py(6, 4): ✅ pass - assert(137)
 test_param_reassign_kwargs.py(7, 4): ❓ unknown - kwargs call
-DETAIL: 5 passed, 0 failed, 1 inconclusive
+DETAIL: 3 passed, 0 failed, 1 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_precondition_verification.expected b/StrataTest/Languages/Python/expected_laurel/test_precondition_verification.expected
index 30acce18e1..97ff1a49a1 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_precondition_verification.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_precondition_verification.expected
@@ -1,14 +1,6 @@
-test_precondition_verification.py(8, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_name_is_foo
-test_precondition_verification.py(8, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str
-test_precondition_verification.py(8, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
-test_precondition_verification.py(11, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_name_is_foo
-test_precondition_verification.py(11, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str
-test_precondition_verification.py(11, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
-test_precondition_verification.py(14, 4): ❓ unknown - (Origin_test_helper_procedure_Requires)req_name_is_foo
-test_precondition_verification.py(14, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str
-test_precondition_verification.py(14, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
-test_precondition_verification.py(17, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_name_is_foo
-test_precondition_verification.py(17, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str
-test_precondition_verification.py(17, 4): ❓ unknown - (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
-DETAIL: 10 passed, 0 failed, 2 inconclusive
+test_precondition_verification.py(8, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_name_is_foo, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
+test_precondition_verification.py(11, 4): ✅ pass - (Origin_test_helper_procedure_Requires)req_name_is_foo, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
+test_precondition_verification.py(14, 4): ❓ unknown - (Origin_test_helper_procedure_Requires)req_name_is_foo, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
+test_precondition_verification.py(17, 4): ❓ unknown - (Origin_test_helper_procedure_Requires)req_name_is_foo, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_str, (Origin_test_helper_procedure_Requires)req_opt_name_none_or_bar
+DETAIL: 2 passed, 0 failed, 2 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_procedure_in_assert.expected b/StrataTest/Languages/Python/expected_laurel/test_procedure_in_assert.expected
index 8d71e8b122..9f62e33697 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_procedure_in_assert.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_procedure_in_assert.expected
@@ -1,11 +1,7 @@
 test_procedure_in_assert.py(4, 4): ✅ pass - assert(55)
-test_procedure_in_assert.py(5, 4): ✅ pass - (Origin_timedelta_Requires)
-test_procedure_in_assert.py(5, 4): ✅ pass - (Origin_timedelta_Requires)hours_type
-test_procedure_in_assert.py(5, 4): ✅ pass - (Origin_timedelta_Requires)days_pos
-test_procedure_in_assert.py(5, 4): ✅ pass - (Origin_timedelta_Requires)hours_pos
+test_procedure_in_assert.py(5, 4): ✅ pass - (Origin_timedelta_Requires), (Origin_timedelta_Requires)hours_type, (Origin_timedelta_Requires)days_pos, (Origin_timedelta_Requires)hours_pos
 test_procedure_in_assert.py(5, 17): ✅ pass - Check PSub exception
 test_procedure_in_assert.py(6, 4): ✅ pass - assert(117)
 test_procedure_in_assert.py(7, 4): ✅ pass - should pass
-test_procedure_in_assert.py(3, 14): ✅ pass - (main ensures) Return type constraint
-DETAIL: 9 passed, 0 failed, 0 inconclusive
+DETAIL: 5 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_regex_negative.expected b/StrataTest/Languages/Python/expected_laurel/test_regex_negative.expected
index 2d85b2d64a..ffc6566e42 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_regex_negative.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_regex_negative.expected
@@ -1,51 +1,51 @@
-test_regex_negative.py(9, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(9, 4): ✅ pass - precondition
 test_regex_negative.py(10, 4): ❓ unknown - EXPECTED_FAIL: fullmatch a on b
-test_regex_negative.py(12, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(12, 4): ✅ pass - precondition
 test_regex_negative.py(13, 4): ❓ unknown - EXPECTED_FAIL: fullmatch abc on abd
-test_regex_negative.py(15, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(15, 4): ✅ pass - precondition
 test_regex_negative.py(16, 4): ❓ unknown - EXPECTED_FAIL: fullmatch [a-z]+ on ABC
-test_regex_negative.py(19, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(19, 4): ✅ pass - precondition
 test_regex_negative.py(20, 4): ❓ unknown - EXPECTED_FAIL: fullmatch ^abc$ on abcd
-test_regex_negative.py(22, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(22, 4): ✅ pass - precondition
 test_regex_negative.py(23, 4): ❓ unknown - EXPECTED_FAIL: search ^abc in xabc
-test_regex_negative.py(25, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(25, 4): ✅ pass - precondition
 test_regex_negative.py(26, 4): ❓ unknown - EXPECTED_FAIL: search abc$ in abcx
-test_regex_negative.py(28, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_negative.py(28, 4): ✅ pass - precondition
 test_regex_negative.py(29, 4): ❓ unknown - EXPECTED_FAIL: match ^a$ in ab
-test_regex_negative.py(32, 4): ✅ pass - set_p_calls_re_compile_0
-test_regex_negative.py(33, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(32, 4): ✅ pass - precondition
+test_regex_negative.py(33, 4): ✅ pass - precondition
 test_regex_negative.py(34, 4): ❓ unknown - EXPECTED_FAIL: compiled ^abc$ search xabc
-test_regex_negative.py(36, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_negative.py(36, 4): ✅ pass - precondition
 test_regex_negative.py(37, 4): ❓ unknown - EXPECTED_FAIL: compiled ^abc$ match abcx
-test_regex_negative.py(44, 8): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(44, 8): ✅ pass - precondition
 test_regex_negative.py(47, 4): ❓ unknown - malformed: unmatched paren should raise
-test_regex_negative.py(51, 8): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(51, 8): ✅ pass - precondition
 test_regex_negative.py(54, 4): ❓ unknown - malformed: nothing to repeat should raise
-test_regex_negative.py(58, 8): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(58, 8): ✅ pass - precondition
 test_regex_negative.py(61, 4): ❓ unknown - malformed: bad bounds should raise
-test_regex_negative.py(65, 8): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(65, 8): ✅ pass - precondition
 test_regex_negative.py(68, 4): ❓ unknown - malformed: search with bad pattern should raise
-test_regex_negative.py(72, 8): ✅ pass - set_m_calls_re_match_0
+test_regex_negative.py(72, 8): ✅ pass - precondition
 test_regex_negative.py(75, 4): ❓ unknown - malformed: match with bad pattern should raise
-test_regex_negative.py(83, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(83, 4): ✅ pass - precondition
 test_regex_negative.py(84, 4): ❓ unknown - unsupported: search \S+ should match non-empty non-whitespace
-test_regex_negative.py(86, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(86, 4): ✅ pass - precondition
 test_regex_negative.py(87, 4): ❓ unknown - unsupported: fullmatch \d+ on digit string
-test_regex_negative.py(89, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(89, 4): ✅ pass - precondition
 test_regex_negative.py(90, 4): ❓ unknown - unsupported: fullmatch \w+ on word string
-test_regex_negative.py(92, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(92, 4): ✅ pass - precondition
 test_regex_negative.py(93, 4): ❓ unknown - unsupported: search \s+ finds whitespace
-test_regex_negative.py(96, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(96, 4): ✅ pass - precondition
 test_regex_negative.py(97, 4): ❓ unknown - unsupported: fullmatch [a-z\d]+ on alphanumeric
-test_regex_negative.py(99, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(99, 4): ✅ pass - precondition
 test_regex_negative.py(100, 4): ❓ unknown - unsupported: fullmatch [\w\-]+ on word with dash
-test_regex_negative.py(103, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(103, 4): ✅ pass - precondition
 test_regex_negative.py(104, 4): ❓ unknown - unsupported: search \t+ on tab string
-test_regex_negative.py(106, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_negative.py(106, 4): ✅ pass - precondition
 test_regex_negative.py(107, 4): ❓ unknown - unsupported: fullmatch [^\n]+ on non-newline string
-test_regex_negative.py(110, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(110, 4): ✅ pass - precondition
 test_regex_negative.py(111, 4): ❓ unknown - unsupported: non-greedy .*? quantifier
-test_regex_negative.py(113, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_negative.py(113, 4): ✅ pass - precondition
 test_regex_negative.py(114, 4): ❓ unknown - unsupported: positive lookahead (?=foo)
 DETAIL: 25 passed, 0 failed, 24 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_regex_positive.expected b/StrataTest/Languages/Python/expected_laurel/test_regex_positive.expected
index 58993070b1..c4291c66a4 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_regex_positive.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_regex_positive.expected
@@ -1,284 +1,284 @@
-test_regex_positive.py(7, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(7, 4): ✅ pass - precondition
 test_regex_positive.py(8, 4): ✅ pass - fullmatch literal should match
-test_regex_positive.py(10, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(10, 4): ✅ pass - precondition
 test_regex_positive.py(11, 4): ✅ pass - fullmatch literal should reject extra chars
-test_regex_positive.py(14, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(14, 4): ✅ pass - precondition
 test_regex_positive.py(15, 4): ✅ pass - fullmatch char class should match
-test_regex_positive.py(17, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(17, 4): ✅ pass - precondition
 test_regex_positive.py(18, 4): ✅ pass - fullmatch char class should reject uppercase
-test_regex_positive.py(21, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(21, 4): ✅ pass - precondition
 test_regex_positive.py(22, 4): ✅ pass - fullmatch negated class should match non-digits
-test_regex_positive.py(24, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(24, 4): ✅ pass - precondition
 test_regex_positive.py(25, 4): ✅ pass - fullmatch negated class should reject digits
-test_regex_positive.py(28, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(28, 4): ✅ pass - precondition
 test_regex_positive.py(29, 4): ✅ pass - fullmatch dot-plus should match non-empty
-test_regex_positive.py(31, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(31, 4): ✅ pass - precondition
 test_regex_positive.py(32, 4): ✅ pass - fullmatch single dot should reject two chars
-test_regex_positive.py(35, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(35, 4): ✅ pass - precondition
 test_regex_positive.py(36, 4): ✅ pass - fullmatch a* should match empty
-test_regex_positive.py(38, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(38, 4): ✅ pass - precondition
 test_regex_positive.py(39, 4): ✅ pass - fullmatch a* should match repeated
-test_regex_positive.py(41, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(41, 4): ✅ pass - precondition
 test_regex_positive.py(42, 4): ✅ pass - fullmatch a* should reject non-a
-test_regex_positive.py(45, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(45, 4): ✅ pass - precondition
 test_regex_positive.py(46, 4): ✅ pass - fullmatch a+ should reject empty
-test_regex_positive.py(48, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(48, 4): ✅ pass - precondition
 test_regex_positive.py(49, 4): ✅ pass - fullmatch a+ should match one-or-more
-test_regex_positive.py(52, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(52, 4): ✅ pass - precondition
 test_regex_positive.py(53, 4): ✅ pass - fullmatch ab?c should match without b
-test_regex_positive.py(55, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(55, 4): ✅ pass - precondition
 test_regex_positive.py(56, 4): ✅ pass - fullmatch ab?c should match with b
-test_regex_positive.py(58, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(58, 4): ✅ pass - precondition
 test_regex_positive.py(59, 4): ✅ pass - fullmatch ab?c should reject two b's
-test_regex_positive.py(62, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(62, 4): ✅ pass - precondition
 test_regex_positive.py(63, 4): ✅ pass - fullmatch alternation should match first
-test_regex_positive.py(65, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(65, 4): ✅ pass - precondition
 test_regex_positive.py(66, 4): ✅ pass - fullmatch alternation should match second
-test_regex_positive.py(68, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(68, 4): ✅ pass - precondition
 test_regex_positive.py(69, 4): ✅ pass - fullmatch alternation should reject other
-test_regex_positive.py(72, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(72, 4): ✅ pass - precondition
 test_regex_positive.py(73, 4): ✅ pass - fullmatch concat should match
-test_regex_positive.py(75, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(75, 4): ✅ pass - precondition
 test_regex_positive.py(76, 4): ✅ pass - fullmatch concat should reject wrong order
-test_regex_positive.py(80, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(80, 4): ✅ pass - precondition
 test_regex_positive.py(81, 4): ✅ pass - match should match at start
-test_regex_positive.py(83, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(83, 4): ✅ pass - precondition
 test_regex_positive.py(84, 4): ✅ pass - match should reject when not at start
-test_regex_positive.py(86, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(86, 4): ✅ pass - precondition
 test_regex_positive.py(87, 4): ✅ pass - match should match prefix
-test_regex_positive.py(89, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(89, 4): ✅ pass - precondition
 test_regex_positive.py(90, 4): ✅ pass - match should reject non-prefix
-test_regex_positive.py(94, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(94, 4): ✅ pass - precondition
 test_regex_positive.py(95, 4): ✅ pass - search should find digits in middle
-test_regex_positive.py(97, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(97, 4): ✅ pass - precondition
 test_regex_positive.py(98, 4): ✅ pass - search should reject when no digits
-test_regex_positive.py(100, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(100, 4): ✅ pass - precondition
 test_regex_positive.py(101, 4): ✅ pass - search should find substring
-test_regex_positive.py(103, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(103, 4): ✅ pass - precondition
 test_regex_positive.py(104, 4): ✅ pass - search should reject missing substring
-test_regex_positive.py(108, 4): ✅ pass - set_p_calls_re_compile_0
-test_regex_positive.py(110, 4): ✅ pass - set_m_calls_re_fullmatch_0
-test_regex_positive.py(111, 4): ✅ pass - compiled fullmatch should match
-test_regex_positive.py(113, 4): ✅ pass - set_m_calls_re_fullmatch_0
-test_regex_positive.py(114, 4): ✅ pass - compiled fullmatch should reject uppercase
-test_regex_positive.py(116, 4): ✅ pass - set_m_calls_re_match_0
-test_regex_positive.py(117, 4): ✅ pass - compiled match should match prefix
-test_regex_positive.py(119, 4): ✅ pass - set_m_calls_re_search_0
-test_regex_positive.py(120, 4): ✅ pass - compiled search should find in middle
-test_regex_positive.py(125, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(108, 4): ✅ pass - precondition
+test_regex_positive.py(110, 4): ✅ pass - precondition
+test_regex_positive.py(111, 4): ❓ unknown - compiled fullmatch should match
+test_regex_positive.py(113, 4): ✅ pass - precondition
+test_regex_positive.py(114, 4): ❓ unknown - compiled fullmatch should reject uppercase
+test_regex_positive.py(116, 4): ✅ pass - precondition
+test_regex_positive.py(117, 4): ❓ unknown - compiled match should match prefix
+test_regex_positive.py(119, 4): ✅ pass - precondition
+test_regex_positive.py(120, 4): ❓ unknown - compiled search should find in middle
+test_regex_positive.py(125, 4): ✅ pass - precondition
 test_regex_positive.py(126, 4): ✅ pass - fullmatch empty pattern on empty string
-test_regex_positive.py(128, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(128, 4): ✅ pass - precondition
 test_regex_positive.py(129, 4): ✅ pass - fullmatch empty pattern on non-empty string
-test_regex_positive.py(132, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(132, 4): ✅ pass - precondition
 test_regex_positive.py(133, 4): ✅ pass - fullmatch single char
-test_regex_positive.py(135, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(135, 4): ✅ pass - precondition
 test_regex_positive.py(136, 4): ✅ pass - fullmatch single char mismatch
-test_regex_positive.py(139, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(139, 4): ✅ pass - precondition
 test_regex_positive.py(140, 4): ✅ pass - fullmatch nested group-plus
-test_regex_positive.py(142, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(142, 4): ✅ pass - precondition
 test_regex_positive.py(143, 4): ✅ pass - fullmatch nested group-plus mismatch
-test_regex_positive.py(146, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(146, 4): ✅ pass - precondition
 test_regex_positive.py(147, 4): ✅ pass - fullmatch loop min
-test_regex_positive.py(149, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(149, 4): ✅ pass - precondition
 test_regex_positive.py(150, 4): ✅ pass - fullmatch loop max
-test_regex_positive.py(152, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(152, 4): ✅ pass - precondition
 test_regex_positive.py(153, 4): ✅ pass - fullmatch loop below min
-test_regex_positive.py(155, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(155, 4): ✅ pass - precondition
 test_regex_positive.py(156, 4): ✅ pass - fullmatch loop above max
-test_regex_positive.py(159, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(159, 4): ✅ pass - precondition
 test_regex_positive.py(160, 4): ✅ pass - fullmatch group loop match
-test_regex_positive.py(162, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(162, 4): ✅ pass - precondition
 test_regex_positive.py(163, 4): ✅ pass - fullmatch group loop too few
-test_regex_positive.py(165, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(165, 4): ✅ pass - precondition
 test_regex_positive.py(166, 4): ✅ pass - fullmatch group loop 3 reps
-test_regex_positive.py(168, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(168, 4): ✅ pass - precondition
 test_regex_positive.py(169, 4): ✅ pass - fullmatch group loop 1 rep
-test_regex_positive.py(174, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(174, 4): ✅ pass - precondition
 test_regex_positive.py(175, 4): ✅ pass - fullmatch ^a match
-test_regex_positive.py(177, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(177, 4): ✅ pass - precondition
 test_regex_positive.py(178, 4): ✅ pass - fullmatch ^a reject
-test_regex_positive.py(180, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(180, 4): ✅ pass - precondition
 test_regex_positive.py(181, 4): ✅ pass - fullmatch a$ match
-test_regex_positive.py(183, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(183, 4): ✅ pass - precondition
 test_regex_positive.py(184, 4): ✅ pass - fullmatch a$ reject
-test_regex_positive.py(186, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(186, 4): ✅ pass - precondition
 test_regex_positive.py(187, 4): ✅ pass - fullmatch ^a$ match
-test_regex_positive.py(189, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(189, 4): ✅ pass - precondition
 test_regex_positive.py(190, 4): ✅ pass - fullmatch ^a$ reject trailing
-test_regex_positive.py(192, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(192, 4): ✅ pass - precondition
 test_regex_positive.py(193, 4): ✅ pass - fullmatch ^a$ reject leading
-test_regex_positive.py(196, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(196, 4): ✅ pass - precondition
 test_regex_positive.py(197, 4): ✅ pass - fullmatch ^$ on empty
-test_regex_positive.py(199, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(199, 4): ✅ pass - precondition
 test_regex_positive.py(200, 4): ✅ pass - fullmatch ^$ on non-empty
-test_regex_positive.py(202, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(202, 4): ✅ pass - precondition
 test_regex_positive.py(203, 4): ✅ pass - match ^$ on empty
-test_regex_positive.py(205, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(205, 4): ✅ pass - precondition
 test_regex_positive.py(206, 4): ✅ pass - match ^$ on non-empty
-test_regex_positive.py(208, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(208, 4): ✅ pass - precondition
 test_regex_positive.py(209, 4): ✅ pass - search ^$ on empty
-test_regex_positive.py(211, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(211, 4): ✅ pass - precondition
 test_regex_positive.py(212, 4): ✅ pass - search ^$ on non-empty
-test_regex_positive.py(217, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(217, 4): ✅ pass - precondition
 test_regex_positive.py(218, 4): ✅ pass - match ^a
-test_regex_positive.py(220, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(220, 4): ✅ pass - precondition
 test_regex_positive.py(221, 4): ✅ pass - match ^a trailing ok
-test_regex_positive.py(223, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(223, 4): ✅ pass - precondition
 test_regex_positive.py(224, 4): ✅ pass - match ^a reject
-test_regex_positive.py(227, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(227, 4): ✅ pass - precondition
 test_regex_positive.py(228, 4): ✅ pass - match ^a$ exact
-test_regex_positive.py(230, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(230, 4): ✅ pass - precondition
 test_regex_positive.py(231, 4): ✅ pass - match ^a$ reject trailing
-test_regex_positive.py(233, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(233, 4): ✅ pass - precondition
 test_regex_positive.py(234, 4): ✅ pass - match a$ exact
-test_regex_positive.py(236, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(236, 4): ✅ pass - precondition
 test_regex_positive.py(237, 4): ✅ pass - match a$ reject trailing
-test_regex_positive.py(239, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(239, 4): ✅ pass - precondition
 test_regex_positive.py(240, 4): ✅ pass - match a.*$ accepts
-test_regex_positive.py(242, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(242, 4): ✅ pass - precondition
 test_regex_positive.py(243, 4): ✅ pass - match a.*$ rejects
-test_regex_positive.py(248, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(248, 4): ✅ pass - precondition
 test_regex_positive.py(249, 4): ✅ pass - search a in middle
-test_regex_positive.py(251, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(251, 4): ✅ pass - precondition
 test_regex_positive.py(252, 4): ✅ pass - search a not found
-test_regex_positive.py(255, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(255, 4): ✅ pass - precondition
 test_regex_positive.py(256, 4): ✅ pass - search ^a at start
-test_regex_positive.py(258, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(258, 4): ✅ pass - precondition
 test_regex_positive.py(259, 4): ✅ pass - search ^a reject non-start
-test_regex_positive.py(261, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(261, 4): ✅ pass - precondition
 test_regex_positive.py(262, 4): ✅ pass - search ^a exact
-test_regex_positive.py(265, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(265, 4): ✅ pass - precondition
 test_regex_positive.py(266, 4): ✅ pass - search a$ at end
-test_regex_positive.py(268, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(268, 4): ✅ pass - precondition
 test_regex_positive.py(269, 4): ✅ pass - search a$ reject non-end
-test_regex_positive.py(271, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(271, 4): ✅ pass - precondition
 test_regex_positive.py(272, 4): ✅ pass - search a$ deep end
-test_regex_positive.py(274, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(274, 4): ✅ pass - precondition
 test_regex_positive.py(275, 4): ✅ pass - search a$ reject trailing
-test_regex_positive.py(278, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(278, 4): ✅ pass - precondition
 test_regex_positive.py(279, 4): ✅ pass - search ^a$ exact
-test_regex_positive.py(281, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(281, 4): ✅ pass - precondition
 test_regex_positive.py(282, 4): ✅ pass - search ^a$ reject prefix
-test_regex_positive.py(284, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(284, 4): ✅ pass - precondition
 test_regex_positive.py(285, 4): ✅ pass - search ^a$ reject suffix
-test_regex_positive.py(289, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(289, 4): ✅ pass - precondition
 test_regex_positive.py(290, 4): ✅ pass - search ^abc at start
-test_regex_positive.py(292, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(292, 4): ✅ pass - precondition
 test_regex_positive.py(293, 4): ✅ pass - search ^abc reject non-start
-test_regex_positive.py(295, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(295, 4): ✅ pass - precondition
 test_regex_positive.py(296, 4): ✅ pass - search abc$ at end
-test_regex_positive.py(298, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(298, 4): ✅ pass - precondition
 test_regex_positive.py(299, 4): ✅ pass - search abc$ reject non-end
-test_regex_positive.py(301, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(301, 4): ✅ pass - precondition
 test_regex_positive.py(302, 4): ✅ pass - search ^abc$ exact
-test_regex_positive.py(304, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(304, 4): ✅ pass - precondition
 test_regex_positive.py(305, 4): ✅ pass - search ^abc$ reject prefix
-test_regex_positive.py(307, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(307, 4): ✅ pass - precondition
 test_regex_positive.py(308, 4): ✅ pass - search ^abc$ reject suffix
-test_regex_positive.py(312, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(312, 4): ✅ pass - precondition
 test_regex_positive.py(313, 4): ✅ pass - fullmatch ^a{3}$ match
-test_regex_positive.py(315, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(315, 4): ✅ pass - precondition
 test_regex_positive.py(316, 4): ✅ pass - fullmatch ^a{3}$ too few
-test_regex_positive.py(318, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(318, 4): ✅ pass - precondition
 test_regex_positive.py(319, 4): ✅ pass - fullmatch ^a{3}$ too many
-test_regex_positive.py(321, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(321, 4): ✅ pass - precondition
 test_regex_positive.py(322, 4): ✅ pass - match ^a{3}$ exact
-test_regex_positive.py(324, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(324, 4): ✅ pass - precondition
 test_regex_positive.py(325, 4): ✅ pass - match ^a{3}$ reject trailing
-test_regex_positive.py(327, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(327, 4): ✅ pass - precondition
 test_regex_positive.py(328, 4): ✅ pass - match a{3} trailing ok
-test_regex_positive.py(332, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(332, 4): ✅ pass - precondition
 test_regex_positive.py(333, 4): ✅ pass - escaped dot matches literal
-test_regex_positive.py(335, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(335, 4): ✅ pass - precondition
 test_regex_positive.py(336, 4): ✅ pass - escaped dot rejects non-dot
-test_regex_positive.py(338, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(338, 4): ✅ pass - precondition
 test_regex_positive.py(339, 4): ✅ pass - escaped plus matches literal
-test_regex_positive.py(341, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(341, 4): ✅ pass - precondition
 test_regex_positive.py(342, 4): ✅ pass - escaped plus rejects
-test_regex_positive.py(344, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(344, 4): ✅ pass - precondition
 test_regex_positive.py(345, 4): ✅ pass - escaped star matches literal
-test_regex_positive.py(347, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(347, 4): ✅ pass - precondition
 test_regex_positive.py(348, 4): ✅ pass - escaped star rejects
-test_regex_positive.py(350, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(350, 4): ✅ pass - precondition
 test_regex_positive.py(351, 4): ✅ pass - escaped question matches literal
-test_regex_positive.py(353, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(353, 4): ✅ pass - precondition
 test_regex_positive.py(354, 4): ✅ pass - escaped question rejects
-test_regex_positive.py(356, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(356, 4): ✅ pass - precondition
 test_regex_positive.py(357, 4): ✅ pass - escaped parens match literal
-test_regex_positive.py(359, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(359, 4): ✅ pass - precondition
 test_regex_positive.py(360, 4): ✅ pass - escaped parens reject
-test_regex_positive.py(362, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(362, 4): ✅ pass - precondition
 test_regex_positive.py(363, 4): ✅ pass - escaped backslash matches literal
-test_regex_positive.py(365, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(365, 4): ✅ pass - precondition
 test_regex_positive.py(366, 4): ✅ pass - escaped backslash rejects
-test_regex_positive.py(369, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(369, 4): ✅ pass - precondition
 test_regex_positive.py(370, 4): ✅ pass - search escaped dot
-test_regex_positive.py(372, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(372, 4): ✅ pass - precondition
 test_regex_positive.py(373, 4): ✅ pass - search escaped backslash
-test_regex_positive.py(375, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(375, 4): ✅ pass - precondition
 test_regex_positive.py(376, 4): ✅ pass - search escaped backslash reject
-test_regex_positive.py(380, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(380, 4): ✅ pass - precondition
 test_regex_positive.py(381, 4): ✅ pass - colon literal match
-test_regex_positive.py(383, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(383, 4): ✅ pass - precondition
 test_regex_positive.py(384, 4): ✅ pass - colon literal reject
-test_regex_positive.py(386, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(386, 4): ✅ pass - precondition
 test_regex_positive.py(387, 4): ✅ pass - colon class match
-test_regex_positive.py(389, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(389, 4): ✅ pass - precondition
 test_regex_positive.py(390, 4): ✅ pass - colon class reject
-test_regex_positive.py(392, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(392, 4): ✅ pass - precondition
 test_regex_positive.py(393, 4): ✅ pass - search colon class
-test_regex_positive.py(395, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(395, 4): ✅ pass - precondition
 test_regex_positive.py(396, 4): ✅ pass - match anchored colon
-test_regex_positive.py(398, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(398, 4): ✅ pass - precondition
 test_regex_positive.py(399, 4): ✅ pass - match anchored colon reject trailing
-test_regex_positive.py(403, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(403, 4): ✅ pass - precondition
 test_regex_positive.py(404, 4): ✅ pass - wildcard empty middle
-test_regex_positive.py(406, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(406, 4): ✅ pass - precondition
 test_regex_positive.py(407, 4): ✅ pass - wildcard non-empty middle
-test_regex_positive.py(409, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(409, 4): ✅ pass - precondition
 test_regex_positive.py(410, 4): ✅ pass - wildcard wrong ending
-test_regex_positive.py(412, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(412, 4): ✅ pass - precondition
 test_regex_positive.py(413, 4): ✅ pass - search wildcard
-test_regex_positive.py(416, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(416, 4): ✅ pass - precondition
 test_regex_positive.py(417, 4): ✅ pass - multi-char alt first
-test_regex_positive.py(419, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(419, 4): ✅ pass - precondition
 test_regex_positive.py(420, 4): ✅ pass - multi-char alt second
-test_regex_positive.py(422, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(422, 4): ✅ pass - precondition
 test_regex_positive.py(423, 4): ✅ pass - multi-char alt reject concat
-test_regex_positive.py(425, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(425, 4): ✅ pass - precondition
 test_regex_positive.py(426, 4): ✅ pass - search multi-char alt
-test_regex_positive.py(430, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(430, 4): ✅ pass - precondition
 test_regex_positive.py(431, 4): ✅ pass - fullmatch ^a|b$ first branch
-test_regex_positive.py(433, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(433, 4): ✅ pass - precondition
 test_regex_positive.py(434, 4): ✅ pass - fullmatch ^a|b$ second branch
-test_regex_positive.py(436, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(436, 4): ✅ pass - precondition
 test_regex_positive.py(437, 4): ✅ pass - fullmatch ^a|b$ reject
-test_regex_positive.py(439, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(439, 4): ✅ pass - precondition
 test_regex_positive.py(440, 4): ✅ pass - search ^a|b$ start anchor
-test_regex_positive.py(442, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(442, 4): ✅ pass - precondition
 test_regex_positive.py(443, 4): ✅ pass - search ^a|b$ end anchor
-test_regex_positive.py(445, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(445, 4): ✅ pass - precondition
 test_regex_positive.py(446, 4): ✅ pass - search ^a|b$ neither
-test_regex_positive.py(450, 4): ✅ pass - set_p_calls_re_compile_0
-test_regex_positive.py(452, 4): ✅ pass - set_m_calls_re_fullmatch_0
-test_regex_positive.py(453, 4): ✅ pass - compiled ^abc$ fullmatch
-test_regex_positive.py(455, 4): ✅ pass - set_m_calls_re_search_0
-test_regex_positive.py(456, 4): ✅ pass - compiled ^abc$ search exact
-test_regex_positive.py(458, 4): ✅ pass - set_m_calls_re_search_0
-test_regex_positive.py(459, 4): ✅ pass - compiled ^abc$ search reject prefix
-test_regex_positive.py(461, 4): ✅ pass - set_m_calls_re_match_0
-test_regex_positive.py(462, 4): ✅ pass - compiled ^abc$ match exact
-test_regex_positive.py(464, 4): ✅ pass - set_m_calls_re_match_0
-test_regex_positive.py(465, 4): ✅ pass - compiled ^abc$ match reject trailing
-test_regex_positive.py(472, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(450, 4): ✅ pass - precondition
+test_regex_positive.py(452, 4): ✅ pass - precondition
+test_regex_positive.py(453, 4): ❓ unknown - compiled ^abc$ fullmatch
+test_regex_positive.py(455, 4): ✅ pass - precondition
+test_regex_positive.py(456, 4): ❓ unknown - compiled ^abc$ search exact
+test_regex_positive.py(458, 4): ✅ pass - precondition
+test_regex_positive.py(459, 4): ❓ unknown - compiled ^abc$ search reject prefix
+test_regex_positive.py(461, 4): ✅ pass - precondition
+test_regex_positive.py(462, 4): ❓ unknown - compiled ^abc$ match exact
+test_regex_positive.py(464, 4): ✅ pass - precondition
+test_regex_positive.py(465, 4): ❓ unknown - compiled ^abc$ match reject trailing
+test_regex_positive.py(472, 4): ✅ pass - precondition
 test_regex_positive.py(473, 4): ✅ pass - malformed: unmatched paren is exception, not None
-test_regex_positive.py(475, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(475, 4): ✅ pass - precondition
 test_regex_positive.py(476, 4): ✅ pass - malformed: nothing to repeat is exception, not None
-test_regex_positive.py(478, 4): ✅ pass - set_m_calls_re_fullmatch_0
+test_regex_positive.py(478, 4): ✅ pass - precondition
 test_regex_positive.py(479, 4): ✅ pass - malformed: bad bounds is exception, not None
-test_regex_positive.py(481, 4): ✅ pass - set_m_calls_re_search_0
+test_regex_positive.py(481, 4): ✅ pass - precondition
 test_regex_positive.py(482, 4): ✅ pass - malformed: search with bad pattern is exception, not None
-test_regex_positive.py(484, 4): ✅ pass - set_m_calls_re_match_0
+test_regex_positive.py(484, 4): ✅ pass - precondition
 test_regex_positive.py(485, 4): ✅ pass - malformed: match with bad pattern is exception, not None
-DETAIL: 282 passed, 0 failed, 0 inconclusive
-RESULT: Analysis success
+DETAIL: 273 passed, 0 failed, 9 inconclusive
+RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_return_types.expected b/StrataTest/Languages/Python/expected_laurel/test_return_types.expected
index ba027981f3..95def4a888 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_return_types.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_return_types.expected
@@ -1,20 +1,14 @@
-test_return_types.py(1, 20): ✅ pass - (get_number ensures) Return type constraint
-test_return_types.py(4, 22): ✅ pass - (get_greeting ensures) Return type constraint
-test_return_types.py(7, 18): ✅ pass - (get_flag ensures) Return type constraint
 test_return_types.py(11, 4): ✅ pass - assert(159)
-test_return_types.py(10, 21): ✅ pass - (get_nothing ensures) Return type constraint
 test_return_types.py(15, 18): ✅ pass - Check PAdd exception
 test_return_types.py(15, 4): ✅ pass - assert(223)
-test_return_types.py(14, 27): ✅ pass - (add ensures) Return type constraint
 test_return_types.py(19, 4): ✅ pass - assert(278)
 test_return_types.py(20, 4): ❓ unknown - get_number returned wrong value
 test_return_types.py(22, 4): ✅ pass - assert(359)
 test_return_types.py(23, 4): ❓ unknown - get_greeting returned wrong value
 test_return_types.py(25, 4): ✅ pass - assert(449)
 test_return_types.py(26, 4): ❓ unknown - get_flag returned wrong value
-test_return_types.py(28, 4): ✅ pass - (add requires) Type constraint of a
-test_return_types.py(28, 4): ✅ pass - (add requires) Type constraint of b
+test_return_types.py(28, 4): ✅ pass - (add requires) Type constraint of a, (add requires) Type constraint of b
 test_return_types.py(28, 4): ✅ pass - assert(529)
 test_return_types.py(29, 4): ❓ unknown - add returned wrong value
-DETAIL: 14 passed, 0 failed, 4 inconclusive
+DETAIL: 8 passed, 0 failed, 4 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_timedelta_expr.expected b/StrataTest/Languages/Python/expected_laurel/test_timedelta_expr.expected
index 270b1ae3c0..396109c554 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_timedelta_expr.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_timedelta_expr.expected
@@ -1,9 +1,6 @@
-test_timedelta_expr.py(4, 0): ✅ pass - (Origin_timedelta_Requires)
-test_timedelta_expr.py(4, 0): ✅ pass - (Origin_timedelta_Requires)hours_type
-test_timedelta_expr.py(4, 0): ✅ pass - (Origin_timedelta_Requires)days_pos
-test_timedelta_expr.py(4, 0): ✅ pass - (Origin_timedelta_Requires)hours_pos
+test_timedelta_expr.py(4, 0): ✅ pass - (Origin_timedelta_Requires), (Origin_timedelta_Requires)hours_type, (Origin_timedelta_Requires)days_pos, (Origin_timedelta_Requires)hours_pos
 test_timedelta_expr.py(5, 18): ✅ pass - Check PSub exception
 test_timedelta_expr.py(6, 7): ✅ pass - Check PLe exception
 test_timedelta_expr.py(6, 0): ✅ pass - assert(140)
-DETAIL: 7 passed, 0 failed, 0 inconclusive
+DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_try_except_modeled.expected b/StrataTest/Languages/Python/expected_laurel/test_try_except_modeled.expected
index b7eb16a95b..6361a61064 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_try_except_modeled.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_try_except_modeled.expected
@@ -1,16 +1,13 @@
 test_try_except_modeled.py(8, 4): ✅ pass - assert(337)
-test_try_except_modeled.py(10, 8): ✅ pass - set_result_calls_Any_get_0
+test_try_except_modeled.py(10, 8): ✅ pass - precondition
 test_try_except_modeled.py(13, 4): ✅ pass - dict access should succeed
-test_try_except_modeled.py(6, 30): ✅ pass - (test_try_dict_access ensures) Return type constraint
 test_try_except_modeled.py(17, 4): ✅ pass - assert(541)
 test_try_except_modeled.py(18, 4): ✅ pass - assert(557)
 test_try_except_modeled.py(19, 4): ✅ pass - assert(572)
 test_try_except_modeled.py(21, 17): ✅ pass - Check PAdd exception
 test_try_except_modeled.py(24, 4): ✅ pass - addition should succeed
-test_try_except_modeled.py(16, 29): ✅ pass - (test_try_arithmetic ensures) Return type constraint
 test_try_except_modeled.py(32, 4): ✅ pass - assert(950)
-test_try_except_modeled.py(35, 12): ✅ pass - set_result_calls_Any_get_0
+test_try_except_modeled.py(35, 12): ✅ pass - precondition
 test_try_except_modeled.py(38, 4): ✅ pass - nested dict access should succeed
-test_try_except_modeled.py(30, 37): ✅ pass - (test_try_nested_dict_access ensures) Return type constraint
-DETAIL: 14 passed, 0 failed, 0 inconclusive
+DETAIL: 11 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_try_except_nested.expected b/StrataTest/Languages/Python/expected_laurel/test_try_except_nested.expected
index bc5270d557..500af0a390 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_try_except_nested.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_try_except_nested.expected
@@ -1,7 +1,5 @@
-test_try_except_nested.py(5, 26): ✅ pass - (might_fail ensures) Return type constraint
 test_try_except_nested.py(9, 4): ✅ pass - assert(256)
 test_try_except_nested.py(12, 12): ✅ pass - (might_fail requires) Type constraint of x
 test_try_except_nested.py(15, 4): ❓ unknown - should succeed
-test_try_except_nested.py(8, 28): ✅ pass - (test_nested_except ensures) Return type constraint
-DETAIL: 4 passed, 0 failed, 1 inconclusive
+DETAIL: 2 passed, 0 failed, 1 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_tuple_create.expected b/StrataTest/Languages/Python/expected_laurel/test_tuple_create.expected
index eb841a55ce..e6e7836d25 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_tuple_create.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_tuple_create.expected
@@ -1,6 +1,6 @@
-test_tuple_create.py(3, 4): ✅ pass - assert_assert(47)_calls_Any_get_0
+test_tuple_create.py(3, 11): ✅ pass - precondition
 test_tuple_create.py(3, 4): ✅ pass - tuple first
-test_tuple_create.py(4, 4): ✅ pass - assert_assert(83)_calls_Any_get_0
+test_tuple_create.py(4, 11): ✅ pass - precondition
 test_tuple_create.py(4, 4): ✅ pass - tuple last
 DETAIL: 4 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_tuple_swap.expected b/StrataTest/Languages/Python/expected_laurel/test_tuple_swap.expected
index bce7234e3f..10317bc474 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_tuple_swap.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_tuple_swap.expected
@@ -1,8 +1,7 @@
 test_tuple_swap.py(2, 4): ✅ pass - assert(27)
 test_tuple_swap.py(3, 4): ✅ pass - assert(42)
-test_tuple_swap.py(4, 4): ✅ pass - set_a_calls_Any_get_0
-test_tuple_swap.py(4, 4): ✅ pass - set_b_calls_Any_get_0
+test_tuple_swap.py(4, 4): ✅ pass - precondition
 test_tuple_swap.py(5, 11): ✅ pass - Check PAnd exception
 test_tuple_swap.py(5, 4): ✅ pass - tuple swap
-DETAIL: 6 passed, 0 failed, 0 inconclusive
+DETAIL: 5 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_tuple_type.expected b/StrataTest/Languages/Python/expected_laurel/test_tuple_type.expected
index 211a0b9df0..1b3a39bfa0 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_tuple_type.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_tuple_type.expected
@@ -1,4 +1,4 @@
-test_tuple_type.py(5, 4): ✅ pass - assert_assert(80)_calls_Any_get_0
+test_tuple_type.py(5, 11): ✅ pass - precondition
 test_tuple_type.py(5, 4): ✅ pass - typed tuple
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_tuple_unpack.expected b/StrataTest/Languages/Python/expected_laurel/test_tuple_unpack.expected
index 2e58c8bb13..5a47e1ae13 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_tuple_unpack.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_tuple_unpack.expected
@@ -1,6 +1,5 @@
-test_tuple_unpack.py(3, 4): ✅ pass - set_a_calls_Any_get_0
-test_tuple_unpack.py(3, 4): ✅ pass - set_b_calls_Any_get_0
+test_tuple_unpack.py(3, 4): ✅ pass - precondition
 test_tuple_unpack.py(4, 4): ✅ pass - unpack first
 test_tuple_unpack.py(5, 4): ✅ pass - unpack second
-DETAIL: 4 passed, 0 failed, 0 inconclusive
+DETAIL: 3 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_type_dict_annotation.expected b/StrataTest/Languages/Python/expected_laurel/test_type_dict_annotation.expected
index 2b25064dde..38622ce174 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_type_dict_annotation.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_type_dict_annotation.expected
@@ -1,4 +1,4 @@
-test_type_dict_annotation.py(5, 4): ✅ pass - assert_assert(95)_calls_Any_get_0
+test_type_dict_annotation.py(5, 11): ✅ pass - precondition
 test_type_dict_annotation.py(5, 4): ✅ pass - typed dict
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_type_list_annotation.expected b/StrataTest/Languages/Python/expected_laurel/test_type_list_annotation.expected
index db7eb8de67..6680893b7f 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_type_list_annotation.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_type_list_annotation.expected
@@ -1,4 +1,4 @@
-test_type_list_annotation.py(5, 4): ✅ pass - assert_assert(92)_calls_Any_get_0
+test_type_list_annotation.py(5, 11): ✅ pass - precondition
 test_type_list_annotation.py(5, 4): ✅ pass - typed list
 DETAIL: 2 passed, 0 failed, 0 inconclusive
 RESULT: Analysis success
diff --git a/StrataTest/Languages/Python/expected_laurel/test_var_shadow_func.expected b/StrataTest/Languages/Python/expected_laurel/test_var_shadow_func.expected
index 7aee788a67..601f7f9897 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_var_shadow_func.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_var_shadow_func.expected
@@ -1,9 +1,8 @@
 test_var_shadow_func.py(2, 8): ✅ pass - Check PAdd exception
-test_var_shadow_func.py(1, 17): ✅ pass - (f ensures) Return type constraint
 test_var_shadow_func.py(6, 4): ✅ pass - assert(83)
 test_var_shadow_func.py(7, 4): ✅ pass - (f requires) Type constraint of x
 test_var_shadow_func.py(7, 4): ✅ pass - assert(98)
 test_var_shadow_func.py(8, 4): ❓ unknown - param modified inside
 test_var_shadow_func.py(9, 4): ✅ pass - original unchanged
-DETAIL: 6 passed, 0 failed, 1 inconclusive
+DETAIL: 5 passed, 0 failed, 1 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_variable_reassign.expected b/StrataTest/Languages/Python/expected_laurel/test_variable_reassign.expected
index afbbef3e87..1ac67414a3 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_variable_reassign.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_variable_reassign.expected
@@ -8,10 +8,10 @@ test_variable_reassign.py(12, 4): ✅ pass - assert(242)
 test_variable_reassign.py(13, 10): ✅ pass - Check PLt exception
 test_variable_reassign.py(14, 16): ❓ unknown - Check PAdd exception
 test_variable_reassign.py(15, 12): ❓ unknown - Check PAdd exception
-test_variable_reassign.py(16, 4): ❓ unknown - loop sum should be 10
+test_variable_reassign.py(16, 4): ✅ pass - loop sum should be 10
 test_variable_reassign.py(19, 4): ✅ pass - assert(398)
 test_variable_reassign.py(20, 4): ✅ pass - assert(415)
 test_variable_reassign.py(25, 4): ✅ pass - should be 100
 test_variable_reassign.py(32, 4): ✅ pass - should be 200
-DETAIL: 12 passed, 0 failed, 3 inconclusive
+DETAIL: 13 passed, 0 failed, 2 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/expected_laurel/test_while_loop.expected b/StrataTest/Languages/Python/expected_laurel/test_while_loop.expected
index 18aceeb417..6905eca1fb 100644
--- a/StrataTest/Languages/Python/expected_laurel/test_while_loop.expected
+++ b/StrataTest/Languages/Python/expected_laurel/test_while_loop.expected
@@ -3,18 +3,15 @@ test_while_loop.py(3, 4): ✅ pass - assert(54)
 test_while_loop.py(4, 10): ✅ pass - Check PGt exception
 test_while_loop.py(5, 16): ❓ unknown - Check PAdd exception
 test_while_loop.py(6, 12): ❓ unknown - Check PSub exception
-test_while_loop.py(7, 4): ❓ unknown - countdown sum should be 15
-test_while_loop.py(1, 30): ❓ unknown - (test_while_countdown ensures) Return type constraint
+test_while_loop.py(7, 4): ✅ pass - countdown sum should be 15
 test_while_loop.py(11, 4): ✅ pass - assert(241)
 test_while_loop.py(13, 16): ❓ unknown - Check PAdd exception
 test_while_loop.py(16, 4): ✅ pass - should have counted to 10
-test_while_loop.py(10, 31): ❓ unknown (pass on 1 path, unknown on 1 path) - (test_while_true_break ensures) Return type constraint
 test_while_loop.py(20, 4): ✅ pass - assert(453)
 test_while_loop.py(21, 4): ✅ pass - assert(468)
 test_while_loop.py(22, 10): ✅ pass - Check PLt exception
 test_while_loop.py(23, 12): ❓ unknown - Check PAdd exception
-test_while_loop.py(27, 4): ❓ unknown - sum excluding 5 should be 50
-test_while_loop.py(19, 34): ❓ unknown - (test_while_with_continue ensures) Return type constraint
+test_while_loop.py(27, 4): ✅ pass - sum excluding 5 should be 50
 test_while_loop.py(26, 16): ❓ unknown - Check PAdd exception
-DETAIL: 8 passed, 0 failed, 10 inconclusive
+DETAIL: 10 passed, 0 failed, 5 inconclusive
 RESULT: Inconclusive
diff --git a/StrataTest/Languages/Python/run_py_analyze_sarif.py b/StrataTest/Languages/Python/run_py_analyze_sarif.py
index 1e12630061..0b63cb9bbb 100755
--- a/StrataTest/Languages/Python/run_py_analyze_sarif.py
+++ b/StrataTest/Languages/Python/run_py_analyze_sarif.py
@@ -67,7 +67,11 @@
     "test_with_statement",
     "test_fstrings",
 }
-SKIP_TESTS_LAUREL = BOTH_SKIP
+SKIP_TESTS_LAUREL = BOTH_SKIP | {
+    "test_try_except", # TVoid type from raise statements not supported in function copies
+    "test_multiple_except", # TVoid type from raise statements not supported in function copies
+    "test_datetime_now_tz", # Resolution failure: timezone/utc not defined
+}
 
 
 def run(test_file: str, *, laurel: bool) -> bool:
diff --git a/StrataTest/Languages/Python/tests/cbmc_expected.txt b/StrataTest/Languages/Python/tests/cbmc_expected.txt
index 0dc6283317..b078d4aaff 100644
--- a/StrataTest/Languages/Python/tests/cbmc_expected.txt
+++ b/StrataTest/Languages/Python/tests/cbmc_expected.txt
@@ -33,6 +33,7 @@ test_if_elif.py.ion             SKIP
 test_variable_reassign.py.ion   SKIP
 test_datetime_now_tz.py.ion     SKIP
 test_timedelta_expr.py.ion      SKIP
+test_composite_return.py.ion    PASS
 test_multi_assign.py.ion        FAIL
 test_multi_assign_triple.py.ion FAIL
 test_multi_assign_side_effect.py.ion SKIP
diff --git a/StrataTest/Util/TestDiagnostics.lean b/StrataTest/Util/TestDiagnostics.lean
index 24a45912f8..3b360ce02e 100644
--- a/StrataTest/Util/TestDiagnostics.lean
+++ b/StrataTest/Util/TestDiagnostics.lean
@@ -139,6 +139,10 @@ def testInputWithOffset (filename: String) (input : String) (lineOffset : Nat)
       IO.println s!"\nUnexpected diagnostics:"
       for diag in unmatchedDiagnostics do
         IO.println s!"  - Line {diag.start.line}, Col {diag.start.column}-{diag.ending.column}: {diag.message}"
+
+    if unmatchedExpectations.length == 0 && unmatchedDiagnostics.length == 0 then
+      IO.println s!"Duplicate diagnostics: {repr diagnostics}"
+
     throw (IO.userError "Test failed")
 
 def testInput (filename: String) (input : String) (process : Lean.Parser.InputContext -> IO (Array Diagnostic)) : IO Unit :=
diff --git a/StrataTestExtra/Languages/Python/AnalyzeLaurelTest.lean b/StrataTestExtra/Languages/Python/AnalyzeLaurelTest.lean
index b706b5ede7..d15c499734 100644
--- a/StrataTestExtra/Languages/Python/AnalyzeLaurelTest.lean
+++ b/StrataTestExtra/Languages/Python/AnalyzeLaurelTest.lean
@@ -370,10 +370,9 @@ Without the attribute, the regex VC would be ❓ unknown. -/
     | .error msg => throw <| IO.userError s!"Pipeline failed: {msg}"
     | .ok vcResults =>
       for r in vcResults do
-        if r.obligation.label.startsWith "servicelib_Storage_" then
-          if !r.isSuccess then
-            throw <| IO.userError
-              s!"Expected all Storage preconditions to pass but got: {r.formatOutcome}"
+        if !r.isSuccess then
+          throw <| IO.userError
+            s!"Expected all Storage preconditions to pass but got: {r.formatOutcome}"
 
 /-! ## Resolution error test after FilterPrelude