diff --git a/src/ir/expr_typer.zig b/src/ir/expr_typer.zig
index efd02e2e..59b6bd8e 100644
--- a/src/ir/expr_typer.zig
+++ b/src/ir/expr_typer.zig
@@ -12,8 +12,8 @@ const Lowering = lower.Lowering;
 /// literals, unary / binary ops, `try` / `catch`, `if`, block, field access,
 /// identifier / type-name, struct / tuple literals, index / slice / deref,
 /// null-coalesce, and the statement shapes that produce no value. Call result
-/// typing stays in `Lowering` for this step; it converges into `CallResolver`
-/// in A3.2.
+/// typing is owned by `CallResolver` (`calls.zig`); a call node reaching here is
+/// routed to it via `Lowering.inferExprType`.
 ///
 /// A `*Lowering` facade (Principle 5), like `PackResolver`: expression typing
 /// reads live lexical-scope / pack / target-type state and dozens of resolver
@@ -28,9 +28,9 @@ pub const ExprTyper = struct {
     /// by its one owner.
     pub fn inferType(self: ExprTyper, node: *const Node) TypeId {
         return switch (node.data) {
-            // Call result typing stays in `Lowering` (A3.2 converges it into
-            // `CallResolver`); delegate so a call node reaching here is handled
-            // by the single owner rather than mistyped as `.unresolved`.
+            // Call result typing is owned by `CallResolver` (`calls.zig`);
+            // delegate through `Lowering.inferExprType` so a call node reaching
+            // here is typed by that single owner, not mistyped as `.unresolved`.
             .call => self.l.inferExprType(node),
             .string_literal => .string,
             .int_literal => .s64,