feat(v3): T-ImpossibleBugs unhandled diagnostic paths — indexing dead-row removal + quotient/remainder audit/totalization

dsl/extdeps/languages/python/syntax.dag

@@ -39,6 +39,10 @@ data python_item_forms: List<ItemForm> = [
 
 // Python operator precedence (emission-relevant subset).
 // Python uses word operators for boolean (and, or) and // for integer div.
+// The // binding is retained only for the v2 AlgQuotient compatibility bridge
+// consumed by src/v2 language emission tests. It is not v3 algebra authority;
+// delete it with AlgQuotient when v2 Div dispatch is retired or moved behind a
+// v2-local syntax authority.
 // Ref: Python Reference §6.17 "Operator precedence"
 
 data python_operators: List<OperatorSpec> = [
@@ -53,8 +57,8 @@ data python_operators: List<OperatorSpec> = [
   OperatorSpec { symbol: "+", left_bp: 13, right_bp: 14, binop: Add, algebra_field: none },
   OperatorSpec { symbol: "-", left_bp: 13, right_bp: 14, binop: Sub, algebra_field: none },
   OperatorSpec { symbol: "*", left_bp: 15, right_bp: 16, binop: Mul, algebra_field: none },
-  // Div is algebra-aware: Float (Field) → true division "/",
-  // Int (OrderedRing) → integer division "//".
+  // Div is algebra-aware for total reciprocal-shaped Field division and the
+  // v2-only AlgQuotient compatibility selector.
   // Ref: Python Reference §6.7 "Binary arithmetic operations"
   OperatorSpec { symbol: "/", left_bp: 15, right_bp: 16, binop: Div, algebra_field: Some { value: AlgReciprocal } },
   OperatorSpec { symbol: "//", left_bp: 15, right_bp: 16, binop: Div, algebra_field: Some { value: AlgQuotient } },

dsl/std/algebra.dag

@@ -42,7 +42,8 @@
 //   Lattice             | meet ∧ and join ∨ (both idempotent, absorptive)
 //   BoundedLattice      | top (⊤) and bottom (⊥)
 //   BooleanAlgebra      | complement (¬), distributive
-//   FreeMonoid<T>       | concat + empty; Int-indexed length/count + slice/index
+//   FreeMonoid<T>       | concat + empty; total access via List get(...)->T?
+//                       | plus length/count + slice/first/last
 //
 // DENOTATIONAL GROUNDING:
 //
@@ -164,8 +165,8 @@ type Ring<T> {
 // OrderedRing: ring with a total order compatible with addition.
 // Adds: compare(T, T) -> Ordering
 // Derived: less_than, greater_than, min, max, abs
-// Euclidean: quotient(T, T) -> T, remainder(T, T) -> T
-//   satisfying a = quotient(a,b) * b + remainder(a,b)
+// Euclidean quotient/remainder are intentionally absent in v3 until a total
+// Result-shaped surface exists; `/` is the checked division authority.
 //
 // Direct operator fields (sub, div, eq, ne, lt, le, gt, ge) are
 // declared so that v3's §8.9 inhabitance walk can resolve surface
@@ -184,8 +185,6 @@ type OrderedRing<T> {
   div: fn(T, T) -> Result<T, DivError>
   one: T
   compare: fn(T, T) -> Ordering
-  quotient: fn(T, T) -> T
-  remainder: fn(T, T) -> T
   eq: fn(T, T) -> Bool
   ne: fn(T, T) -> Bool
   lt: fn(T, T) -> Bool
@@ -291,8 +290,9 @@ type BooleanAlgebra<T> {
 //
 // Declared surface (receiver-shaped fields — matches the record below):
 //   Monoid: concat(self, other), empty, append(element)
-//   Int-indexed carrier: length(), count(), index(i: Int) -> T, slice(i, j),
-//     first() -> T?, last() -> T?
+//   Indexed carrier: length(), count(), slice(i, j), first() -> T?,
+//     last() -> T?; element lookup is total-only via `get(collection, index) -> T?`
+//     in std/primitives.dag, not a partial algebra field.
 //   map: endomorphic fn(T) -> T -> FreeMonoid<T> (not fn(T)->U with U free)
 //   fold: monoid-shaped on T — init: T plus step fn(T, T) -> T -> T
 //   (Those two stay on T because executable authority here cannot yet name
@@ -303,8 +303,7 @@ type FreeMonoid<T> {
   concat: fn(FreeMonoid<T>, FreeMonoid<T>) -> FreeMonoid<T>
   empty: FreeMonoid<T>
   append: fn(T) -> FreeMonoid<T>
-  // Positional access — falls out of the carrier being Fin(n) → T
-  index: fn(Int) -> T
+  // Positional access — partial direct indexing is intentionally absent.
   slice: fn(Int, Int) -> FreeMonoid<T>
   length: fn() -> Int
   count: fn() -> Int
@@ -476,8 +475,6 @@ fn ordered_ring_templates() -> List<AlgebraFieldTemplate> {
     { name: "mul", param_types: [ReceiverSelf, ReceiverSelf], return_type: ReceiverSelf, size_effect: none, cost_shape: none, callback_element_position: none },
     { name: "one", param_types: [], return_type: ReceiverSelf, size_effect: none, cost_shape: none, callback_element_position: none },
     { name: "compare", param_types: [ReceiverSelf, ReceiverSelf], return_type: NamedTemplate { name: "Ordering" }, size_effect: none, cost_shape: none, callback_element_position: none },
-    { name: "quotient", param_types: [ReceiverSelf, ReceiverSelf], return_type: ReceiverSelf, size_effect: none, cost_shape: none, callback_element_position: none },
-    { name: "remainder", param_types: [ReceiverSelf, ReceiverSelf], return_type: ReceiverSelf, size_effect: none, cost_shape: none, callback_element_position: none },
     { name: "clamp", param_types: [ReceiverSelf, ReceiverSelf, ReceiverSelf], return_type: ReceiverSelf, size_effect: none, cost_shape: Some { value: ShapeConstant }, callback_element_position: none }
   ]
 }

dsl/std/methods.dag

@@ -65,7 +65,7 @@ type MethodDeclaration {
 // ---------------------------------------------------------------------------
 // Method-name registry. One `data` binding per unique method name carried by
 // the seven per-profile algebra template lists in `dsl/std/algebra.dag`.
-// Sorted alphabetically; 63 entries. Each binding is a `MethodDeclaration`
+// Sorted alphabetically. Each binding is a `MethodDeclaration`
 // with the `name` field matching the string used in algebra templates.
 // ---------------------------------------------------------------------------
 
@@ -111,9 +111,7 @@ data member_method: MethodDeclaration = { name: "member" }
 data mul_method: MethodDeclaration = { name: "mul" }
 data negate_method: MethodDeclaration = { name: "negate" }
 data one_method: MethodDeclaration = { name: "one" }
-data quotient_method: MethodDeclaration = { name: "quotient" }
 data reciprocal_method: MethodDeclaration = { name: "reciprocal" }
-data remainder_method: MethodDeclaration = { name: "remainder" }
 data replace_method: MethodDeclaration = { name: "replace" }
 data reverse_method: MethodDeclaration = { name: "reverse" }
 data skip_method: MethodDeclaration = { name: "skip" }

dsl/std/syntax.dag

@@ -74,12 +74,16 @@ type ItemForm {
 
 // -- Algebra field kind -----------------------------------------------
 // Which algebra field an operator dispatches through on the operand type.
-// Variants correspond 1:1 to field names on algebraic structure types
-// in std/algebra.dag (Ring.add, Field.reciprocal, OrderedRing.quotient, etc.).
+// Variants correspond to algebraic field names used by downstream
+// consumers. AlgQuotient/AlgRemainder are a v2-only compatibility bridge for
+// src/v2/00_core.dag + src/v2/04_types.dag Div/Mod dispatch; they are not v3
+// algebra authority because v3 OrderedRing no longer declares quotient or
+// remainder fields in std/algebra.dag. Dissolution trigger: delete these two
+// variants and rows when the v2 Div/Mod algebra-field dispatch is retired or
+// split behind a v2-local syntax authority.
 
 type AlgebraFieldKind
-  = AlgAdd | AlgMul | AlgReciprocal | AlgQuotient | AlgRemainder
-  | AlgCompare | AlgMeet | AlgJoin
+  = AlgAdd | AlgMul | AlgReciprocal | AlgQuotient | AlgRemainder | AlgCompare | AlgMeet | AlgJoin
 
 // Single authority for kind → field name mapping. Both the compiler's
 // child lookup (04_types.dag) and serialization (compile.dag) derive

scripts/slow-test-exemptions.txt

@@ -66,12 +66,13 @@ m2_lens_unused_parameters_migration_test::unused_parameters_dag_runs_end_to_end_
 m2_lens_unused_parameters_migration_test::unused_parameters_dag_self_analysis_reports_zero_findings  # Lane 2 migration harness roundtrip; compile-heavy self-analysis remains explicit until lens migration paydown.
 pb1_bootstrap_full_snapshot_test::full_bootstrap_extends_std_snapshot  # PB-1 shape guard: compares two large generated bootstrap snapshots in-process; cold CI + libtest parallelism can exceed 2s wall while the structural inequality check stays explicit. Paydown trigger: same shared PB-1 compile warming; optional extra win if snapshot compare moves to mmap/streaming (PB-1 lane only).
 
+r1c_e_emit_gates_dag_test::r1c_e_emit_gates_suite_passes_through_runner  # R1C-E emit-gates `.dag` wrapper shells through the runner/binary harness and sits on the 2s CI edge (2166ms on PR #1233); paydown owned by R1C-E emit-gates runner/shared-setup work, not this impossible-bugs row-removal slice.
+
 bootstrap::tests::kernel_bool_path_a_attaches_diagnostic_when_boolean_algebra_unresolvable  # Lane 1e-2b Path A regression: two `Dag::new()` paths + mutation; can exceed 2s wall on cold ubuntu-latest when compiled alongside heavy integration neighbors — keep explicit bootstrap diagnostic coverage. Paydown trigger: when the Bool/`BooleanAlgebra` kernel bootstrap bridge dissolves into `dsl/std/types.dag` (see `bootstrap.rs` + `dsl/std/types.dag` dissolution notes), collapse fixtures and/or adopt shared `Dag::new` warming; re-measure and remove if under 2s.
 
 p0_std_render_repeat_string_test::std_render_repeat_string_and_indent_text_match_interpreter  # ROADMAP P0 (`dsl/std/render.dag` `repeat_string` / `indent_text`): observed 29.7s on PR #595's merge commit. Structural blocker: v2 `compile_to_resolved` + interpreter oracle cold-compile the full resolver for every test; no shared bootstrap cache exists between v2-oracle tests and the v3 integration binary. Named paydown trigger: when a shared v2-oracle bootstrap cache lands (TM-0 shared-bootstrap lane or an earlier TESTING.md §shared-setup pass introducing a `OnceLock<ResolvedPipelineResult>`), re-measure and remove this exemption.
 
 sg1_tokenize_authority_test::tokenize_generated_module_matches_checked_in_snapshot  # SG-1 authority snapshot still regenerates/parses full tokenize projection; tokenize authority lane owns future speedup.
-sg2_parse_authority_test::parse_generated_module_matches_checked_in_snapshot  # SG-2 parser-staging snapshot: in-process authority compile + rustfmt stdout (same paydown class as SG-1 tokenize snapshot gate).
 sg2_parse_authority_test::parse_surface_dag_compiles_cleanly_for_regen_parse  # SG-2 parser-staging: `compile_parse_surface_std_authority_dag` + cold bootstrap work can exceed 2s wall under default libtest parallelism; ROADMAP SG-2 / TESTING.md paydown (same lane as `parse_generated_module_matches_checked_in_snapshot`).
 sg2c1_parse_tables_authority_test::parse_tables_generated_module_matches_checked_in_snapshot  # SG-2c-1 grammar-tables prototype snapshot: in-process authority compile (parse_tables.dag + tokenize.dag) + rustfmt stdout; same paydown class as SG-1 tokenize / SG-2 parse snapshot gates.
 sg6_hand_authored_census_test::sg6_regen_lens_cli_smoke_regenerates_named_entry_without_drift  # SG-6 regen CLI smoke intentionally shells out to regen path; CLI smoke cost is tracked in SG-6, not TM-0.

src/v2/stage0/src/std_algebra.rs

@@ -79,8 +79,6 @@ pub struct OrderedRing<T> {
     pub div: Rc<dyn Fn(T, T) -> Rc<Result<T, DivError>>>,
     pub one: Box<T>,
     pub compare: Rc<dyn Fn(T, T) -> Ordering>,
-    pub quotient: Rc<dyn Fn(T, T) -> T>,
-    pub remainder: Rc<dyn Fn(T, T) -> T>,
     pub eq: Rc<dyn Fn(T, T) -> bool>,
     pub ne: Rc<dyn Fn(T, T) -> bool>,
     pub lt: Rc<dyn Fn(T, T) -> bool>,
@@ -128,7 +126,6 @@ pub struct FreeMonoid<T> {
     pub concat: Rc<dyn Fn(Rc<FreeMonoid<T>>, Rc<FreeMonoid<T>>) -> Rc<FreeMonoid<T>>>,
     pub empty: Rc<FreeMonoid<T>>,
     pub append: Rc<dyn Fn(T) -> Rc<FreeMonoid<T>>>,
-    pub index: Rc<dyn Fn(i64) -> T>,
     pub slice: Rc<dyn Fn(i64, i64) -> Rc<FreeMonoid<T>>>,
     pub length: Rc<dyn Fn() -> i64>,
     pub count: Rc<dyn Fn() -> i64>,
@@ -332,28 +329,6 @@ pub fn ordered_ring_templates() -> Rc<Vec<Rc<AlgebraFieldTemplate>>> {
             cost_shape: None,
             callback_element_position: None,
         }),
-        Rc::new(AlgebraFieldTemplate {
-            name: "quotient".to_string(),
-            param_types: Rc::new(vec![
-                Rc::new(AlgebraTypeTemplate::ReceiverSelf),
-                Rc::new(AlgebraTypeTemplate::ReceiverSelf),
-            ]),
-            return_type: Rc::new(AlgebraTypeTemplate::ReceiverSelf),
-            size_effect: None,
-            cost_shape: None,
-            callback_element_position: None,
-        }),
-        Rc::new(AlgebraFieldTemplate {
-            name: "remainder".to_string(),
-            param_types: Rc::new(vec![
-                Rc::new(AlgebraTypeTemplate::ReceiverSelf),
-                Rc::new(AlgebraTypeTemplate::ReceiverSelf),
-            ]),
-            return_type: Rc::new(AlgebraTypeTemplate::ReceiverSelf),
-            size_effect: None,
-            cost_shape: None,
-            callback_element_position: None,
-        }),
         Rc::new(AlgebraFieldTemplate {
             name: "clamp".to_string(),
             param_types: Rc::new(vec![