@@ -199,6 +199,9 @@ candidate's own URI and carries that catalog into the graph. Two fixture finding
 mint their own `anySlotResource` on a plain [ResourceBase]; and a fixture minted outside the catalog is exactly
 what Decision 8 refuses, so the old fixture asserted the defect. Red set now: the two phase-2 items only.
 
+**Phase 2 complete 2026-09-06.** Red set: the recovery-stack seam alone, which is phase 3's (finding 6, `Result` at
+`recovery_stack.go`).
+
 ### State as of 2026-09-01
 
 
@@ -739,17 +742,22 @@ Two things Phase 1 changed about the plan itself:
   compares only the result's literal digits, read with `UseNumber` so the probe does not re-run the very
   float64 conversion it exists to detect.
 
-### Phase 2: Resolve at the two authorities
+### Phase 2: Resolve at the two authorities -- COMPLETE (2026-09-06)
 
-- [ ] Resolve an enveloped value at the decoder in `graph.go`, so no envelope survives `LoadGraph`. This is
-      what makes a graph with a number in an `any` slot loadable again (finding 5).
-- [ ] Leave bare-literal resolution in `readAgainstField`, reading against the declared type. It must not move
+- [x] Resolve an enveloped value at the decoder in `graph.go`, so no envelope survives `LoadGraph`. This is
+      what makes a graph with a number in an `any` slot loadable again (finding 5). Landed as `readSlotValue` on
+      the assembly path (`assembleUnits` → `assembleNode` → `assembleBindings`), the decoder's own seam.
+- [x] Leave bare-literal resolution in `readAgainstField`, reading against the declared type. It must not move
       to the decoder; that would guess ahead of the field and regress #711.
-- [ ] Turn each of the four pass-through routes into an error rather than a guess, including the [Convert]
+- [x] Turn each of the four pass-through routes into an error rather than a guess, including the [Convert]
       failure that is deferred to dispatch today. The load-time message names the slot, the parameter, and the
-      declared type.
-- [ ] Give `scalarTruthy` a `json.Number` case as defense in depth, so the truthiness inversion cannot recur
-      if a new decoder path appears. The resolution above is the fix; this is the guard rail.
+      declared type. `readAgainstField` returns an error on the three reachable routes (the fourth cannot arise);
+      the framework-slot reader refuses a non-text value the same way. Pinned by
+      `TestLoadGraph_ABareNumberInAnUndeclaredSlotIsRefused` and `TestLoadGraph_ANumberAParameterCannotHoldIsRefusedAtLoad`,
+      both on documents rewritten by hand, since the serializer never writes a bare number where it would be refused.
+- [x] Give `scalarTruthy` a `json.Number` case as defense in depth, so the truthiness inversion cannot recur
+      if a new decoder path appears. The resolution above is the fix; this is the guard rail. `numberTruthy`;
+      the numeric cases moved to `numericTruthy` to keep the switch under the complexity gate.
 
 ### Phase 3: Write the envelope
 
 
@@ -408,3 +408,97 @@ func newAnySlotResource(runtimeEnvironment *RuntimeEnvironment, identity any) (R
 func init() {
 	AnnounceResource(reflect.TypeFor[*anySlotResource](), newAnySlotResource, nil)
 }
+
+// typedSlotFixture carries a method with a declared `bool` parameter, for the load-time refusals of #712 phase 2.
+type typedSlotFixture struct{ ProviderBase }
+
+// Take accepts a flag; the method does nothing with it.
+//
+// Parameters:
+//   - `flag`: the declared-`bool` parameter the refusal tests write a number into.
+//
+// Returns:
+//   - `error`: always nil.
+func (p *typedSlotFixture) Take(flag bool) error { return nil }
+
+func init() {
+	AnnounceProvider(reflect.TypeFor[typedSlotFixture](), NewProviderFlags(SurfaceWorkflow, PlacementQualified),
+		func(runtimeEnvironment *RuntimeEnvironment) (any, error) {
+			return &typedSlotFixture{ProviderBase: NewProviderBase(runtimeEnvironment)}, nil
+		},
+		map[string]MethodMetadata{
+			"Take": {ParameterNames: []string{"flag"}},
+		})
+}
+
+// loadWithSlotRewritten serializes a one-node graph, rewrites one slot's document form by textual replacement, and
+// loads the result. The rewrite stands in for a hand-edited or foreign document, which is the only way a bare
+// number reaches a slot the serializer would have enveloped.
+func loadWithSlotRewritten(t *testing.T, graph *Graph, from, to string) error {
+	t.Helper()
+	document := string(serializeGraph(t, graph, "json"))
+	if !strings.Contains(document, from) {
+		t.Fatalf("the document does not contain %q:\n%s", from, document)
+	}
+	_, err := LoadGraph(formatIdentityEnvironment(t), []byte(strings.Replace(document, from, to, 1)), "json")
+	return err
+}
+
+// TestLoadGraph_ABareNumberInAnUndeclaredSlotIsRefused pins #712 phase 2's second route: a number in a slot no
+// parameter declares has nothing to be read against, and the loader says so rather than handing a decoder
+// artifact forward.
+func TestLoadGraph_ABareNumberInAnUndeclaredSlotIsRefused(t *testing.T) {
+
+	action, err := ReceiverRegistry().BuildAction("anySlotFixture.keep")
+	if err != nil {
+		t.Fatalf("BuildAction: %v", err)
+	}
+	node, err := NewNode(NewNodeSpec().WithID("keep").WithAction(action).
+		WithSlot("value", NewImmediateBinding("kept")).
+		WithSlot("extra", NewImmediateBinding(int64(5))))
+	if err != nil {
+		t.Fatalf("NewNode: %v", err)
+	}
+	graph, err := NewGraph(NewGraphSpec().WithOrigin(NewOriginBase("test", "home", NewAnnotationMap(nil))).WithUnits(node))
+	if err != nil {
+		t.Fatalf("NewGraph: %v", err)
+	}
+
+	err = loadWithSlotRewritten(t, graph, `{"$int64":"5"}`, "5")
+	if err == nil {
+		t.Fatal("LoadGraph accepted a bare number in a slot no parameter declares; want a refusal")
+	}
+	for _, want := range []string{`"extra"`, "keep", "nothing to read it against"} {
+		if !strings.Contains(err.Error(), want) {
+			t.Errorf("refusal %q does not name %s", err, want)
+		}
+	}
+}
+
+// TestLoadGraph_ANumberAParameterCannotHoldIsRefusedAtLoad pins #712 phase 2's third route: a number the declared
+// type cannot hold fails at load, naming the slot, the parameter, and the type -- not at dispatch.
+func TestLoadGraph_ANumberAParameterCannotHoldIsRefusedAtLoad(t *testing.T) {
+
+	action, err := ReceiverRegistry().BuildAction("typedSlotFixture.take")
+	if err != nil {
+		t.Fatalf("BuildAction: %v", err)
+	}
+	node, err := NewNode(NewNodeSpec().WithID("take").WithAction(action).WithSlot("flag", NewImmediateBinding(true)))
+	if err != nil {
+		t.Fatalf("NewNode: %v", err)
+	}
+	graph, err := NewGraph(NewGraphSpec().WithOrigin(NewOriginBase("test", "home", NewAnnotationMap(nil))).WithUnits(node))
+	if err != nil {
+		t.Fatalf("NewGraph: %v", err)
+	}
+
+	err = loadWithSlotRewritten(t, graph, `"value":true`, `"value":5`)
+	if err == nil {
+		t.Fatal("LoadGraph accepted a number in a bool slot; want a refusal at load")
+	}
+	for _, want := range []string{`"flag"`, "Take", "bool"} {
+		if !strings.Contains(err.Error(), want) {
+			t.Errorf("refusal %q does not name %s", err, want)
+		}
+	}
+}
@@ -5,6 +5,7 @@ package op
 
 import (
 	"encoding"
+	"fmt"
 	"reflect"
 )
 
@@ -39,30 +40,30 @@ func frameworkSlotType(name string) (reflect.Type, bool) {
 // readFrameworkSlot parses a bare document value back through a framework slot's declared type.
 //
 // The declared types marshal as text (a policy writes its name), so a string reads back through
-// [encoding.TextUnmarshaler]. A value of any other shape, or a type without a text form, passes through unchanged and
-// fails at its consumer, which names the slot.
+// [encoding.TextUnmarshaler]. Anything else is an error naming the slot and the type: no guessing (#712 phase 2).
 //
 // Parameters:
 //   - `value`: the decoded document value.
 //   - `declared`: the slot's framework-declared type.
 //
 // Returns:
-//   - `any`: the typed value, or `value` unchanged.
-func readFrameworkSlot(value any, declared reflect.Type) any {
+//   - `any`: the typed value.
+//   - `error`: a value that is not text, a declared type without a text form, or text the type refuses.
+func readFrameworkSlot(value any, declared reflect.Type) (any, error) {
 
 	text, isString := value.(string)
 	if !isString {
-		return value
+		return nil, fmt.Errorf("declared %s by the framework, and the document holds a %T, not its text form", declared, value)
 	}
 
 	target := reflect.New(declared)
 	unmarshaler, ok := target.Interface().(encoding.TextUnmarshaler)
 	if !ok {
-		return value
+		return nil, fmt.Errorf("declared %s by the framework, a type with no text form to read %q back through", declared, text)
 	}
 	if err := unmarshaler.UnmarshalText([]byte(text)); err != nil {
-		return value
+		return nil, err
 	}
 
-	return target.Elem().Interface()
+	return target.Elem().Interface(), nil
 }
@@ -371,7 +371,7 @@ func readSlotValue(value any, method *Method, name string, catalog *ResourceCata
 		return decodeTypeWrapper(value, catalog)
 	}
 
-	return readAgainstField(value, method, name), nil
+	return readAgainstField(value, method, name)
 }
 
 // assembleNode constructs a [*Node] from a [nodeData] payload during deserialization.
@@ -440,27 +440,31 @@ func assembleNode(p *nodeData, catalog *ResourceCatalog) (*Node, error) {
 //   - `name`: the slot name, which is the parameter name.
 //
 // Returns:
-//   - `any`: the value read against the field, or the value unchanged.
-func readAgainstField(value any, method *Method, name string) any {
+//   - `any`: the value read against the field; a non-number passes through unchanged.
+//   - `error`: a number with nothing to read it against, or one its parameter's type cannot hold.
+func readAgainstField(value any, method *Method, name string) (any, error) {
 
 	if declared, ok := frameworkSlotType(name); ok {
 		return readFrameworkSlot(value, declared)
 	}
-	if method == nil || !isDecodedNumber(value) {
-		return value
+	if !isDecodedNumber(value) {
+		return value, nil
+	}
+	// From here the value is a decoder artifact -- a number whose type only the field can supply -- and every
+	// route that once handed it forward unchanged is an error instead (#712 phase 2): no guessing.
+	if method == nil {
+		return nil, fmt.Errorf("a number (%T) with no action to declare the slot: nothing to read it against", value)
 	}
-
 	parameter, declared := method.ParameterByName(name)
 	if !declared || parameter.Type == nil {
-		return value
+		return nil, fmt.Errorf("a number (%T) in a slot %s declares no parameter for: nothing to read it against", value, method.Name())
 	}
-
 	converted, err := Convert(nil, value, parameter.Type)
 	if err != nil {
-		return value
+		return nil, fmt.Errorf("parameter %q of %s is declared %s, and the document's number cannot be read as one: %w",
+			parameter.Name, method.Name(), parameter.Type, err)
 	}
-
-	return converted
+	return converted, nil
 }
 
 // isDecodedNumber reports whether a decoded slot value is a number a codec may have mistyped.
 
@@ -3,7 +3,10 @@
 
 package op
 
-import "reflect"
+import (
+	"encoding/json"
+	"reflect"
+)
 
 // IsTruthy reports whether `value` is truthy under Python / Starlark truth semantics.
 //
@@ -56,10 +59,28 @@ func IsTruthy(value any) bool {
 //   - `bool`: the truthiness, when `value` is a built-in scalar.
 //   - `bool`: true when `value` was a built-in scalar.
 func scalarTruthy(value any) (truthy, isScalar bool) {
-
 	switch v := value.(type) {
 	case bool:
 		return v, true
+	case string:
+		return v != "", true
+	case json.Number:
+		return numberTruthy(v)
+	}
+	return numericTruthy(value)
+}
+
+// numericTruthy is [scalarTruthy]'s case for the Go numeric types, exactly typed: a named type with a numeric
+// underlying kind is not a scalar here, as it never was.
+//
+// Parameters:
+//   - `value`: the value under test.
+//
+// Returns:
+//   - `truthy`: whether the number is non-zero.
+//   - `isScalar`: false when `value` is not one of the built-in numeric types.
+func numericTruthy(value any) (truthy, isScalar bool) {
+	switch v := value.(type) {
 	case int:
 		return v != 0, true
 	case int8:
@@ -84,8 +105,28 @@ func scalarTruthy(value any) (truthy, isScalar bool) {
 		return v != 0, true
 	case float64:
 		return v != 0, true
-	case string:
-		return v != "", true
+	}
+	return false, false
+}
+
+// numberTruthy is [scalarTruthy]'s case for a decoder artifact.
+//
+// Defense in depth (#712 phase 2): the decoder should never let a json.Number reach a truthiness check, but if a
+// new path does, a zero is falsy however it was decoded.
+//
+// Parameters:
+//   - `number`: the undecoded number.
+//
+// Returns:
+//   - `truthy`: whether the number is non-zero.
+//   - `isScalar`: false when the number parses as neither an integer nor a float.
+func numberTruthy(number json.Number) (truthy, isScalar bool) {
+
+	if integer, err := number.Int64(); err == nil {
+		return integer != 0, true
+	}
+	if float, err := number.Float64(); err == nil {
+		return float != 0, true
 	}
 
 	return false, false