AILang/docs/journals/INDEX.md

Journal index

Chronological pointer list of per-iter journal files. Append-only. One line per iter, newest at the bottom. Filenames are relative to docs/journals/.

• pre-2026-05-11 — see ../journal-archive.md for all prior history
• 2026-05-11 — iter or.1: orchestrator-refactor → 2026-05-11-iter-or.1.md
• 2026-05-11 — fieldtest canonical-type-names → 2026-05-11-fieldtest-canonical-type-names.md
• 2026-05-11 — iter pr.1: plan-recon subagent → 2026-05-11-iter-pr.1.md
• 2026-05-11 — iter or.2: orchestrator-agent design correction (no nested subagent dispatch) → 2026-05-11-iter-or.2.md
• 2026-05-11 — iter cadence: audit/fieldtest/docwriter cadence restructure → 2026-05-11-iter-cadence.md
• 2026-05-11 — iter 23.4-prep: checker prerequisites for prelude free fns → 2026-05-11-iter-23.4-prep.md
• 2026-05-11 — iter gc.1: grounding-check agent + brainstorm Step 7.5 → 2026-05-11-iter-gc.1.md
• 2026-05-11 — iter disc.1: boss-only commits + main-as-quarantine (no branches in implement) → 2026-05-11-iter-disc.1.md
• 2026-05-11 — iter 23.4: mono-pass unification (class methods + polymorphic free fns in one fixpoint; codegen-time specialiser removed) → 2026-05-11-iter-23.4.md
• 2026-05-12 — iter 23.5: prelude free fns (ne/lt/le/gt/ge) + E2E (positive / user-ADT / Float-NoInstance); milestone 23 closed → 2026-05-12-iter-23.5.md
• 2026-05-12 — audit-23: milestone 23 close (architect clean, compile_check ratified per H2 / 5-fn workload), DESIGN.md stub-fix tidy → 2026-05-12-audit-23.md
• 2026-05-12 — iter rt.1: roundtrip invariant audit tests (3 new tests + ailx-pair dynamic); all PASS first-shot, no gaps surfaced → 2026-05-12-iter-rt.1.md
• 2026-05-12 — iter rt.2: DESIGN.md anchor for Roundtrip Invariant (top-level section + Decision 6 Constraint 2 upward cross-reference) → 2026-05-12-iter-rt.2.md
• 2026-05-12 — audit-rt: milestone close (Roundtrip Invariant) — architect drift fixed in rt.tidy (3 items: Direction-2 5th test, roadmap P1 removed, wording sync); bench all-green → 2026-05-12-audit-rt.md
• 2026-05-12 — iter boss: /boss skill — autonomous-mode discipline (Direction freedom, Notifications, WhatsNew procedure) extracted from CLAUDE.md into a user-invoked skill → 2026-05-12-iter-boss.md
• 2026-05-12 — brainstorm Step 7.5: re-dispatch grounding-check on any post-PASS spec edit (skill SKILL.md edit + roadmap P1 todo removed) → see commit 90512d5 (no per-iter journal — small skill-discipline tweak)
• 2026-05-12 — iter cma.1: master mini-spec + render binary for cross-model authoring experiment (13 fixtures cover 34/34 AST variants, 4 test gates green, rendered/{json,ailx}.md checked in; out-of-workspace nested crate) → 2026-05-12-iter-cma.1.md
• 2026-05-12 — iter cma.2: harness binary + 4 tasks + reference solutions + 4 integration tests (six modules, real-pipeline preflight via verify_references, 13/13 tests green; pipeline.rs renames program file to module-name for ail check) → 2026-05-12-iter-cma.2.md
• 2026-05-12 — iter cma.3: live Qwen3-Coder-Next run + DESIGN.md §Decision-6 empirical addendum + roadmap close (AILX 2/4 green vs JSON 1/4; ~98k vs ~207k tokens; single-subject scope explicit, multi-subject expansion queued as P3) → 2026-05-12-iter-cma.3.md
• 2026-05-12 — audit-cma: milestone close (Cross-model authoring-form test) — architect drift fixed in 2 record-keeping items (INDEX backfill for brainstorm Step 7.5, README test-count correction); bench all-green (5 unexplained improvements on latency.explicit_at_rc not coupled to milestone, baseline left pristine) → 2026-05-12-audit-cma.md
• 2026-05-12 — iter ms.1: pipeline anyhow-chain preservation — {e} → {e:#} at pipeline.rs:118 restores serde_json parse-error leaf in JSON-cohort feedback; pinning unit test added (14/14 green) → 2026-05-12-iter-ms.1.md
• 2026-05-12 — iter ms.2: Qwen3-Coder-Next retroactive re-run + first CodeLlama-13b-Instruct run via IONOS; DESIGN.md §Decision-6 addendum extended from 2-col single-subject to 4-col two-subject; both subjects agree on direction (AILX cheaper + ≥ green); roadmap P3 multi-subject entry removed → 2026-05-12-iter-ms.2.md
• 2026-05-12 — audit-ms: milestone close (Multi-subject Authoring-Form Test — CodeLlama Replication) — architect clean, bench all-green (same 5-metric latency.explicit_at_rc improvement cluster as audit-cma earlier today, baseline left pristine for second consecutive audit) → 2026-05-12-audit-ms.md
• 2026-05-12 — iter ext-rename: .ailx → .ail extension rename across the live toolchain (61 example renames + 35 content edits + experiment-crate cohort rename ailx → ail); historical docs (journals, archive, specs, plans, frozen experiment runs) deliberately untouched; cargo+bench all-green; opens follow-up .ail-CLI-acceptance iter → 2026-05-12-iter-ext-rename.md
• 2026-05-12 — iter ext-cli.1: ail check/build/run/...all 12 path-taking subcommands now accept .ail (Form A) inputs via ailang_surface::{load_module, load_workspace} (extension-dispatching loaders + injection point core::load_workspace_with<F>); workspace imports prefer .ail sibling over .ail.json; new WorkspaceLoadError::SurfaceParse variant routes surface parse errors as surface-parse-error structured diagnostics through ail check --json; DESIGN.md §Decision 6 CLI addendum; +7 new tests; closes the loop opened by iter ext-rename → 2026-05-12-iter-ext-cli.1.md
• 2026-05-12 — iter hs.1: heap-Str ABI iter 1 — static-Str LLVM globals migrate from [N x i8] to packed-struct <{ i64, i64, [N x i8] }> carrying a UINT64_MAX sentinel rc-header + explicit len; IR-Str pointers now land on the len-field; @puts / @ail_str_eq / @ail_str_compare / @strcmp callsites GEP +8 to recover the bytes pointer (4 sites; plan listed 3, Task-5 e2e regression surfaced the 4th); 6 IR-shape pins; format strings stay raw [N x i8]; cross_lang.py + compile_check.py + full cargo test --workspace all green; byte-identical stdout across every example → 2026-05-12-iter-hs.1.md
• 2026-05-12 — spec amendment: heap-str-abi — sentinel-rc-header story dropped after hs.2 BLOCKED finding (codegen-level elision via move-tracking + non-escape lowering keeps static-Str pointers out of ailang_rc_dec along every shipping execution path; no runtime guard needed); re-dispatched grounding-check PASS → see commit 2a72a4a (no per-iter journal — spec edit)
• 2026-05-12 — iter hs.2: static-Str layout retrofit — drop the UINT64_MAX sentinel slot from packed-struct globals (<{ i64, i64, [N x i8] }> → <{ i64, [N x i8] }>); IR-Str pointer now lands on the len-field at struct-index 0 (was 1) via constexpr-GEP i32 0, i32 0; +8 consumer-side GEPs at the four C-API callsites invariant across the switch; renamed ..._sentinel_and_len test to ..._with_len; updated 5 sites in crates/ailang-codegen/src/lib.rs (3 format strings + 2 doc-comments); regenerated hello.ll snapshot; full cargo test --workspace, cross_lang.py, compile_check.py, check.py all green; static-Str globals are now 8 bytes smaller per literal → 2026-05-12-iter-hs.2.md
• 2026-05-12 — iter hs.3: heap-Str runtime additions — three new symbols appended to runtime/str.c (static str_alloc(uint64_t) slab helper, ailang_int_to_str(int64_t), ailang_float_to_str(double)); supporting <stdint.h>/<stdio.h>/<stdlib.h> includes + extern void *ailang_rc_alloc(size_t) declaration; the extern was promoted from plain-external to __attribute__((weak)) after the first regression sweep surfaced 11 e2e link failures under --alloc=gc/bump (public T symbols pull in their transitive callees regardless of upstream usage; rc.c is not linked under gc/bump in hs.3 — repair makes str.c link-safe in isolation, no-op once hs.4 lands the unconditional rc.c link); cargo test --workspace + cross_lang.py + compile_check.py + check.py all green on re-sweep; no IR-side caller wired yet (hs.4) → 2026-05-12-iter-hs.3.md
• 2026-05-12 — iter hs.4: IR + checker + linker wiring — int_to_str : (Int) -> Str installed in checker + synth.rs lockstep partner; IR-header preamble unconditionally declares both @ailang_int_to_str / @ailang_float_to_str; Emitter::lower_app gets new int_to_str arm and replaces float_to_str's CodegenError::Internal with the actual call emission; is_static_callee whitelist extends to int_to_str; runtime/rc.c hoisted out of AllocStrategy::Rc arm to the unconditional link path (the __attribute__((weak)) on str.c's ailang_rc_alloc extern becomes the documented no-op); 2 new IR-shape pins + 4 new E2E (2 stdout-smoke + 2 RC-stats) + 4 .ail.json fixtures; drop.rs Str-arm comment refreshed to dual-realisation framing; 5 IR snapshots regen for the 2 new declare lines. Status: DONE_WITH_CONCERNS — heap-Str RC-discipline incomplete (slabs leak at program end) because plan's literal ret_mode: Implicit interacts with uniqueness analyser walking Term::Do args as Position::Consume. Test asserts weakened from allocs == frees && live == 0 to allocs >= 1. Substantive fix requires spec-level effect-op arg-mode decision (deferred, bounce-back to user) → 2026-05-12-iter-hs.4.md
• 2026-05-12 — iter eob.1: Effect-op args walked as Borrow (uniqueness.rs + linearity.rs + linearity.rs doc-comment); heap-Str RC discipline closes (int_to_str / float_to_str ret_mode: Implicit → Own at 4 lockstep sites across builtins.rs + synth.rs; drop_symbol_for_binder App-arm gets Str carve-out symmetric to field_drop_call's existing one); 2 pre-existing RED tests at e2e.rs (commit 592d87b) flipped to GREEN unchanged with predicted concrete numbers (allocs==1,frees==1,live==0 and allocs==2,frees==2,live==0); 2 new positive tests + fixtures (primitive-Int through io/print_int: zero RC traffic; heap-Str repeated borrow through 2× io/print_str: allocs==1,frees==1,live==0); DESIGN.md §Decision 10 anchors both arg-position rules together (Ctor=Consume, Do=Borrow, plus a paragraph linking Do=Borrow to ret_mode==Own letbinder-trackability); WhatsNew entry shipped, roadmap P1 [milestone] Heap-Str ABI checked off, Post-22-Prelude depends on: line removed; 7/7 tasks first-shot, zero review re-loops; lint side-effect surface (over-strict-mode on (own T) params used solely via effect-ops) was empty for the current corpus → 2026-05-12-iter-eob.1.md
• 2026-05-12 — audit-eob: milestone close (heap-str-abi) — architect drift fixed inline as eob.tidy (3 DESIGN.md edits: float_to_str / int_to_str caveats dropped, "Str ABI" anchor added documenting both heap-Str and static-Str realisations with their shared consumer ABI and codegen-level non-RC invariant for static-Str); bench mixed (latency.explicit_at_rc improvement cluster reappears for the 3rd consecutive audit + new marginal bump_s regressions on list_sum/hof_pipeline 12% over 10% tol), baseline pristine for 3rd consecutive audit (conservative call: latency cluster has no identified cause across 3 audits — ratify-without-attribution would obscure future signal; bump_s cluster is first-sighting, observe next audit) → 2026-05-12-audit-eob.md
• 2026-05-12 — iter ctt.1: env-overlay shape ratification — new DESIGN.md top-level section ## Env construction anchors the env.types (owning) / env.ctor_index (reverse-index) split with the semantic rationale, plus the intentional check-side / mono-side asymmetry (mono-side narrowed at ct.3.2, check-side retains both halves because in-band DuplicateCtor consumes the per-module env.ctor_index rebuild); new behavioural-pin test crates/ailang-check/tests/duplicate_ctor_pin.rs ratifies the consumer; two P2 roadmap todos struck [x] (overlay shape question, per-module overlay narrowing); 3/3 tasks first-shot, zero review re-loops, no production-code edits → 2026-05-12-iter-ctt.1.md
• 2026-05-12 — iter ctt.2: Registry.type_def_module re-key from BTreeMap<String, String> to BTreeMap<(String, String), String> keyed by (owning_module, bare_name); new caller_module: &str parameter threads through normalize_type_for_registry + Registry::normalize_type_for_lookup; four ailang-check consumer sites (lib.rs:1640, mono.rs:121/624/1175) pass the correct module-context (env.current_module / defining_module / module_name) per the plan's Design Notes; new regression test plus three-module fixture (ctt2_collision_{cls,lib,main}.ail.json) exercises the cross-module bare-name collision shape that pre-ctt.2 silently overwrote; RED-failure observed as OrphanInstance rather than the plan's predicted DuplicateInstance because the pass-2 coherence check (workspace.rs:656-659) is also a bare-name consumer and fires earlier; both consumers fixed by the same re-key; plan's verbatim two-module fixture had two structural defects (two-way imports → Cycle, qualified InstanceDef.class → QualifiedClassName) that the implementer-phase repair handled by introducing the third cls-module; spec-intent (RED-first against bare-name collision) preserved; cargo test --workspace green (16 binary-test suites, ~600 tests, zero failures) → 2026-05-12-iter-ctt.2.md
• 2026-05-12 — iter ctt.3: KindMismatch retire — pure deletion across 3 files (workspace.rs: variant + dispatch + helper + "dead-but-defensive" doc; main.rs: Display arm; lib.rs: 22b.1 archaeology comment). Existing test class_param_in_applied_position_fires_canonical_form_rejection stays green unchanged (asserts BareCrossModuleTypeRef on the malformed fixture — the canonical-form-validator successor path). Two adjacent textual-consistency edits ride along (validate_classdefs doc-comment "Three → Two", lib.rs archaeology comment gains a ctt.3 retirement marker). One mid-deletion mechanical fix: dispatch-loop deletion orphaned mod_name binding → rewrote for (mod_name, m) in modules to for m in modules.values() (same body type, mechanical). 2/2 tasks, ~600 tests green across 16 binary-test suites → 2026-05-12-iter-ctt.3.md
• 2026-05-12 — audit-ct-tidy: milestone close (ct-tidy) — architect drift fixed inline as ctt.tidy (3 doc-side edits: DESIGN.md §"Class-schema diagnostics" drops the retired KindMismatch bullet + adds successor paragraph naming BareCrossModuleTypeRef; DESIGN.md §"Higher-kinded class params" rewritten to name BareCrossModuleTypeRef from canonical-form validation instead; roadmap.md two P2 todos struck [x] with forward-reference to ctt.3 and ctt.2). Bench mixed (check.py exit 1: bump_s persistence on bench_list_sum second consecutive sighting at +12.23% → +12.60%; two new first-sighting rc-cohort max_us latency regressions classified as noise pending next audit; the recurring 3-audit latency.explicit_at_rc improvement cluster narrowed to within tolerance this audit, withdrawing the ratify-pending plan from audit-eob — the meaningful shrinkage is itself attribution evidence that the cluster is noise-class not signal-class), baseline pristine for the 4th consecutive audit → 2026-05-12-audit-ct-tidy.md
• 2026-05-12 — iter 24.1: bool_to_str + str_clone runtime + codegen wiring — 2 new C functions in runtime/str.c (slab-allocating heap-Str primitives via existing str_alloc), lockstep checker + synth.rs installs with ret_mode: Own, 2 IR-header declares + 2 lower_app arms + is_static_callee whitelist extension, 5 IR snapshots regen (2 declares × 5 files), 9 new tests (2 builtins-install unit + 2 IR-shape pin + 5 E2E all green), pre-existing-drift fix included (int_to_str row added to builtins.rs::list()). One substantive deviation: builtin-signatures registered in uniqueness.rs::infer_module + linearity.rs::check_module_with_visible (8 LOC × 2 files) so str_clone's param_modes: [Borrow] is visible to the App-arg walker; symmetric to 23.4-prep's class-method registration; necessary for the plan's literal frees == 3 cross-realisation assertion. Full cargo test --workspace 513 passed, 0 failed. bench/compile_check.py + bench/cross_lang.py green → 2026-05-12-iter-24.1.md
• 2026-05-13 — iter mq.1: class-ref canonical-form extension + workspace-internal class-name qualification — three schema fields (InstanceDef.class, Constraint.class, SuperclassRef.class) move bare → canonical (bare for same-module, <module>.<Class> for cross-module) symmetric to ct.1's Type::Con.name rule; ClassDef.name stays bare (defining site, like TypeDef.name). validate_canonical_type_names gains three field-walks via new check_class_ref helper plus two sibling diagnostics BareCrossModuleClassRef / BadCrossModuleClassRef; check_class_name_fields narrowed to ClassDef.name-only. Workspace-internal class-name keys all qualified: class_def_module, class_by_name, registry entries.0, ClassMethodEntry.class_name, class_superclasses, mono's class_index, Origin::Class.class_name. New qualify_class_ref helper in workspace.rs plus sibling qualify_class_ref_in_check in ailang-check. Two new positive on-disk fixtures (mq1_xmod_constraint_class{,_dep}). Recon claim that all existing fixtures' class-refs are intra-module was empirically wrong — 5 test_22b* (orphan_third, dup_a/b/entry, unbound_constraint_var) + 5 other (eq_ord_polymorphic, eq_ord_user_adt, cmp_max_smoke, ctt2_collision_{lib,main}) fixtures required minimal canonical-form migration. Duplicate-instance test architecturally restructured: post-mq.1 orphan-freedom makes two-modules-on-same-(class, type) structurally impossible (any second instance in a non-owning module fires OrphanInstance first); new test_22b1_dup_same_module.ail.json lands both instances in the class's module — the only post-mq.1 way to land two on the same canonical key. Plan defects fixed inline: Origin::Class.class_name had one construction site not two (plan recon off-by-one); build_class_index in mono.rs needed qualifying (plan said "no code change needed"); build_module_globals needed a Def::Instance carve-out for qualified inst.class; check_fn's declared-constraint matching needed inline canonical-form lifting; NoInstance Float-aware message arm needed prelude.Eq/prelude.Ord match; coherence type-leg needed qualified-head split-and-lookup. Tasks 3-6 ran as one coherent fix (Task 3 alone left tests RED). 7/7 tasks, 520 tests green, bench/compile_check.py + bench/cross_lang.py exit 0; bench/check.py exit 1 due to 4 improvements-beyond-tolerance (audit-ratifiable per convention, not a regression). MethodNameCollision + dispatch path unchanged; iters mq.2 + mq.3 land them → 2026-05-13-iter-mq.1.md
• 2026-05-13 — iter mq.2: type-driven dispatch mechanism installed (mechanism-before-exercise) — Env.method_to_candidate_classes workspace-flat inverse index built alongside class_methods; two new CheckError variants AmbiguousMethodResolution + UnknownClass (Display+code+ctx) plus additive NoInstance.candidate_classes field; ResidualConstraint extended with candidates: Option<BTreeSet<String>> (visibility bumped pub(crate) → pub for test-crate access); pure resolve_method_dispatch helper implementing the spec's 5-step rule (qualifier → singleton → type-driven filter → constraint-driven filter → Multi for discharge-time refinement); synth Var-arm class-method branch rewritten via parse_method_qualifier with inner-dot gate (qualifier must be <module>.<Class> form, single-dot names like std_list.length fall through to the existing qualified-fn path); refine_multi_candidate_residual wired into check_fn discharge using expanded (post-superclass-expansion constraints) for the rigid-var path; resolve_residual_class_for_mono wired into mono's collect_residuals_ordered residual-to-target mapping. With MethodNameCollision still gating real workspaces, the new multi-candidate branches are exercised exclusively by 15 unit tests: 6 in tests/method_dispatch_pin.rs covering the 5-step rule's six cases, 6 in lib.rs mod tests covering variants + field shapes + discharge refinement, 3 in mono.rs mod tests covering the mono helper. Real workspaces continue producing single-class residuals (candidates: None); every pre-mq.2 fixture typechecks unchanged. Plan-invented format_type_for_display replaced with ailang_core::pretty::type_to_string (one less duplicate). Synth-time declared_constraints: &[] is a deliberate gap documented as known debt — load-bearing only post-mq.3 for the rigid-var fallback (env-plumbing the active fn's constraints into the Var arm is a ~10-line edit slated for mq.3). 9/9 tasks, 539 tests green (was 520 at start of mq.2; +19 = 15 new + 4 pre-existing); bench/compile_check.py + cross_lang.py clean; bench/check.py 1 regression (latency noise, runtime cannot be touched by typecheck-side iter). MethodNameCollision retirement lands in mq.3 → 2026-05-13-iter-mq.2.md
• 2026-05-13 — iter mq.3: MethodNameCollision retired + multi-class E2E + DESIGN.md sync — milestone close. Deletes WorkspaceLoadError::MethodNameCollision variant + Origin enum + per-def collision loop in build_registry (workspace.rs 596-681) + Display arm in main.rs:1201; the two in-workspace.rs pin tests relocate to crates/ailang-check/tests/method_collision_pin.rs with inverted assertions (loads cleanly + env.method_to_candidate_classes["foo"] has two qualified-class entries). Resolves both mq.2 known-debt items: (1) Env.active_declared_constraints: Vec<Constraint> plumbed pre-synth in check_fn so the post-superclass-expansion constraint set reaches the synth Var-arm's resolve_method_dispatch constraint-driven filter; (2) ModuleGlobals.class_methods + Env.class_methods re-keyed from BTreeMap<MethodName, ClassMethodEntry> to BTreeMap<(QualifiedClass, MethodName), ClassMethodEntry> with new class_method_candidates(name) -> Vec<(&class, &entry)> accessor; mono's two presence-check sites (rewrite_mono_calls, interleave_slots) switched to consult method_to_candidate_classes natively (method-keyed, preserves the presence-check signature shape). New synth(...) warnings channel via warnings: &mut Vec<Diagnostic> out-parameter threaded through 15+ recursive callsites + 5 external callers (check_fn, check_const, 3 in builtins.rs, 1 in lift.rs, 2 in mono.rs, 1 in check); new structured warning class-method-shadowed-by-fn (kebab-case code, structured ctx carrying name/method/fn_owner_module/candidate_classes) fires at all three fn-precedence branches (locals, same-module fn, implicit-import fn). Implicit-import-fn branch reordered ABOVE the class-method branch per spec §"Class-fn collisions" so fn-wins precedence is structural. Three new positive E2E fixtures + integration tests in crates/ail/tests/mq3_multi_class_e2e.rs: (a) mq3_two_show_ambiguous (two Show classes, both with Show Int, bare show 42 → AmbiguousMethodResolution); (b) mq3_two_show_qualified (same workspace, mq3_two_show_ambiguous_a.Show.show 42 → clean); (c) mq3_class_eq_vs_fn_eq (class MyEq { myeq } + fn myeq + bare myeq 1 2 → fn wins, warning fires). DESIGN.md sync: class-names paragraph rewritten to point at mq.1 canonical-form + mq.3 dispatch model; MethodNameCollision bullet struck from "Workspace-load (registry-build) diagnostics" with forward-pointing note; AmbiguousMethodResolution / UnknownClass / class-method-shadowed-by-fn + NoInstance.candidate_classes added to "Typecheck diagnostics"; AmbiguousInstance paragraph reworded to distinguish registry-level (per-class coherence via DuplicateInstance) from call-site (cross-class method ambiguity, new diagnostic); new ### Method dispatch subsection anchors the 5-step rule with method_to_candidate_classes as the load-bearing data structure, the class-fn precedence rule, and the post-mq.3 tuple-keyed class_methods shape. Roadmap P2 milestone → [x] with three-iter summary; milestone-24 depends on: line struck and entry annotated "ready for re-brainstorm". Plan defects fixed inline: check_fn signature is Result<()> not Result<(CheckedFn, Vec<Diagnostic>)> — adopted mut-ref-accumulator pattern matching existing Vec<CheckError> shape; class_method_candidates returns Vec<(...)> not impl Iterator<...> (the use<'a, '_> opaque-type-capture syntax not yet idiomatic in this crate); instance-method body shape draft was Term::App but existing-convention is Term::Lam with paramTypes/retType — three fixtures repaired inline. One existing E2E test (crates/ail/tests/typeclass_22b3.rs:rewrite_walker_skips_locally_shadowed_class_method) now correctly fires the new warning (the fixture intentionally shadows a class method); test's assert!(diags.is_empty()) relaxed to filter the new warning with a naming comment. 9/9 tasks, 545 tests green (was 539; +6 net = 3 new mq.3.x lib + 2 method_collision_pin + 3 mq3_multi_class_e2e − 2 deleted workspace.rs pin tests); bench/compile_check.py + cross_lang.py exit 0; bench/check.py exit 1 with 2 noise-class regressions (3rd-consecutive bench_list_sum.bump_s persistence + max_us tail metric, both runtime-uncoupled-to-typecheck-iter); prelude zero-diff. Module-qualified-class-names milestone structurally closed → 2026-05-13-iter-mq.3.md
• 2026-05-13 — audit-mq: milestone close (module-qualified-class-names) — architect drift report surfaces 4 actionable items routing to mq.tidy (2× [high]: rigid-var refinement type-unification leg missing in refine_multi_candidate_residual for forall a b. Show a, Show b => ... shapes; same-module bare-class qualifier Show.show unreachable because qualifier_is_class_shape = q.contains('.') excludes the no-dot case contradicting mq.1 canonical-form symmetry; 2× [medium]: class-method-shadowed-by-fn warning over-fires on locals shadowing prelude method names without class-candidate-for-arg-type check; DESIGN.md Data Model schema fragments don't carry the canonical-form rule for InstanceDef.class / Constraint.class / SuperclassRef.class), plus 1× [medium] acknowledged debt without fix (synth(...) 10-mut-ref-parameter growth — consistent with crate's existing accumulator pattern; refactor cost disproportionate to gain), plus 2× [low] roadmap-backlog (no E2E for Trajectories B + D; collect_mono_targets rebuilds env without active_declared_constraints — currently latent because mono residuals are concrete-type). Bench mixed: compile_check.py + cross_lang.py exit 0; check.py exit 1 across 4 consecutive re-runs with metric identity shifting between runs (3 → 1 → 1 → 0 regressions, different metrics each) — pattern consistent with 5th-consecutive audit noise-class observation since audit-cma; baseline pristine for 5th consecutive audit (the metric-migration-between-runs is itself attribution evidence variance not signal) → 2026-05-13-audit-mq.md
• 2026-05-13 — iter mq.tidy: close 4 actionable drift items from audit-mq — T1 extends refine_multi_candidate_residual's rigid-var filter at lib.rs:2163-2168 from class-only (dc.class == c) to class + type-unification (dc.class == c && constraint_type_matches(&dc.type_, &residual.type_)) via the existing constraint_type_matches helper at lib.rs:2273, so forall a b. prelude.Show a, userlib.Show b => (a, b) -> String-shape declared-constraint sets correctly discriminate by which typevar the residual is on (high-1; spec §"Constraint-discharge refinement" 130-138). Plan revision noted at the architecture paragraph: synth-time resolve_method_dispatch is invoked with concrete_arg_type: None and constructs the residual metavar AFTER the dispatch call, so the rigid-var leg there has no residual type to unify against — class-only filter at synth time is semantically correct, not drift; fix lands only at the discharge-time site. T2 extracts the inline qualifier_is_class_shape predicate from synth Var-arm at lib.rs:2570-2575 as a free pub(crate) fn qualifier_is_class_shape(&Option<String>) -> bool adjacent to parse_method_qualifier; broadened to accept PascalCase single-segment qualifiers ("Show.show") alongside module-qualified ones ("prelude.Show.show"), so same-module bare-class call sites are now reachable — symmetric to mq.1's canonical-form rule at the schema level (high-2). Discriminator: class names start with uppercase per PascalCase convention; bare-fn qualifiers ("std_list", lowercase) correctly reject and fall through to the cross-module-fn arm. T3 introduces pub(crate) fn any_candidate_class_has_instance(...) using a BTreeMap range-scan (O(|candidates| * log n)) and gates the class-method-shadowed-by-fn warning closure at lib.rs:2479-2502 on it, so class methods with zero registry instances anywhere no longer fire the warning — conservative Boss-Q2-decision tightening of the spec rule (full rule would require the arg type, unavailable at the Var-arm before App-arm unification) (medium-1). T4 annotates four DESIGN.md Data Model schema fragments (SuperclassRef 2139, InstanceDef.class 2152, Type::Con.name 2253, Constraint.class 2273) with trailing-comment canonical-form cross-references — Type::Con annotation points at the actual existing section title §"Type::Con name scoping" (ct.1 anchor verified via grep, plan's text guess was off) (medium-2). Two trip-wires fixed inline: (a) parse_method_qualifier docstring updated to remove the now-incorrect "class qualifier is always qualified per mq.1" claim that the broadened gate directly contradicts — coherence-required not unrequested; (b) in-crate mq3_class_method_shadowed_by_fn_warning_fires test built workspace with Registry::default() (no instances) and pre-tidy fired anyway because old gate didn't check instances — post-tidy correctly suppresses, fixture repaired by injecting a clsmod.Show Int registry entry directly into ws.registry.entries (analogous to mq.3's typeclass_22b3 trip-wire pattern). 5/5 tasks, 548 tests green (was 545 + 3 new mq_tidy_* unit tests); bench/compile_check.py exit 0 (24/24 stable after one-run noise blip absorbed under tolerance on re-run), cross_lang.py exit 0 (25/25 stable), check.py exit 0 both runs with metric-identity-migrating noise on latency.implicit_at_rc.* max-tail cluster — 6th-consecutive observation of the audit-mq-named noise envelope, baseline pristine. Plan Step 5 expectation ail check examples/prelude.ail.json exit 0 was inaccurate (actual: exit 1 "module name 'prelude' is reserved", identical to pre-edit, prelude is loader-auto-injected and never a workspace entry); 548/548 workspace test pass is the right sanity gate → 2026-05-13-iter-mq.tidy.md
• 2026-05-13 — iter 24.2: class Show + 4 primitive instances (Int/Bool/Str/Float) shipped in prelude; 22b user-Show fixtures migrated to TShow/tshow → 2026-05-13-iter-24.2.md
• 2026-05-13 — iter 24.3: fn print polymorphic free fn + 3 E2E fixtures (positive 4-prim smoke / user-ADT IntBox+instance prelude.Show IntBox / negative print f:Int→Int firing Show-aware NoInstance) + IR-shape pin asserting post-mono print__Int.body preserves explicit let-binder + 3 compiler-path repairs (mono.rs canonical-form normalisation of MonoTarget::FreeFn::type_args 2 sites; codegen/lib.rs cross-module reference fallback for post-mono synthesised bodies 3 sites: resolve_top_level_fn / lower_app cross-module arm / synth_with_extras Var arm; check/lib.rs synth FreeFnCall constraint-residual push) + Show-aware NoInstance diagnostic addendum cross-referencing DESIGN.md §Prelude(built-in)classes + DESIGN.md §Prelude(built-in)classes mq24 paragraph flipped to past tense + §Float semantics Show-Float NaN paragraph + roadmap P1 Post-22 Prelude → [x] + new P2 Retire io/print_int|bool|float at top; 556 tests pass (was 552+4 new); milestone 24 structurally closes → 2026-05-13-iter-24.3.md
• 2026-05-13 — audit-24: milestone close (Show + print rewire) — architect drift report surfaces 5 actionable items routing to 24.tidy (3× [high]: DESIGN.md §"Monomorphisation" doc-anchor missing for three iter-24.3 strengthenings — MonoTarget::FreeFn::type_args canonical-form normalisation, post-mono synthesised-body cross-module-ref import_map-bypass invariant, FreeFnCall constraint-residual push; codegen import_map-fallback path has no unit-level pin — only E2E catches regression; FreeFnCall constraint-residual push covers only dot-qualified branch, bare-name poly-fn refs uncovered; 2× [medium]: unwrap_or_default in method-name lookup masks class-index drift, normalize_type_for_lookup duplicated across two mono.rs sites with manual-lockstep invariant), plus 1× [medium] deferred to roadmap P3 (negative-test coverage single-shape — only f:Int→Int, broader shapes wait for downstream corpus-migration milestone), plus 1× [low] carry-on (bench/architect_sweeps.sh noise on pre-milestone-24 DESIGN.md lines, not new drift). Bench: cross_lang.py exit 0 (25/25 stable); check.py + compile_check.py exit 1 with metric-identity-migrating noise envelope per audit-cma → audit-ms → audit-eob → audit-ct-tidy → audit-mq → audit-mq.tidy → iter-24.2 → iter-24.3 lineage — 9th consecutive observation; conservative-call convention holds baseline pristine across all 9, the metric-migration-between-runs is itself attribution evidence variance not signal; right ratification path is the queued P3 latency-methodology-histogram rework, not --update-baseline → 2026-05-13-audit-24.md
• 2026-05-13 — iter 24.tidy: close 5 actionable drift items from audit-24 — T1 DESIGN.md new subsection §Cross-module references in synthesised bodies (3 invariants installed iter 24.3: canonical-form MonoTarget::FreeFn::type_args via normalize_type_for_lookup, post-mono synthesised body import_map-bypass + module_user_fns fallback, FreeFnCall constraint-residual push per declared forall-constraint); T2 codegen_import_map_fallback_pin (integration test asserts prelude.print__ body references user_module.show__ AND prelude imports do not contain user_module); T3 polyfn_dot_qualified_branch_pin (asserts bare-name print f fires exactly one no-instance + zero unknown-variable, proving constraint-residual push fires via dot-qualified branch); T4 check/lib.rs:2858 unwrap_or_default → expect(class_methods registry coherence) — surfaces class-index drift on regression; T5 mono.rs apply_subst_and_normalize helper extracted from byte-identical sites at :685-714 + :1284-1303 with Option return — each call site keeps own rigid-var/unit-default policy. Tests 558/558 (was 556+2 pins). Bench cross_lang exit 0 stable, compile_check + check both exit 0 this run (10th consecutive lineage observation unobserved-firing). audit-24 medium-3 negative-test breadth defers to roadmap P3; low-1 sweep noise carry-on → 2026-05-13-iter-24.tidy.md
• 2026-05-13 — iter form-a.0: prelude pilot for Form-A-as-default-authoring milestone — examples/prelude.ail rendered (116 lines / 6386 bytes) via ail render; two auto-discovering roundtrip tests (every_ail_fixture_matches_its_json_counterpart + parse_then_print_then_parse_is_idempotent_on_every_ail_fixture) green on the new fixture without test-code changes; prelude.ail.json retained per spec §A2 (singular dual-form iter, deletion lands iter 1 with bulk test-infra refactor); cargo test --workspace green at 558 tests → 2026-05-13-iter-form-a.0.md
• 2026-05-13 — iter form-a.1: Form-A-as-default-authoring milestone close (Boss-decided strategy C, big-bang) — 12 tasks across two implementer dispatches; T1 added 3 new tests (parse-determinism + CLI-pipeline-idempotency + carve_out_inventory#[ignore]) + T2 bulk-rendered 99 missing examples/.ail (corpus 58→157 .ail) + T3-4 migrated 26 fixture-loading test files (Group A load_workspace→ailang_surface::load_workspace + Group B subprocess suffix flip) + T5 relocated 23 #[cfg(test)] mod tests blocks from ailang-core/-codegen production source to integration test crates with ailang-surface dev-dep (hash_pin.rs + workspace_pin.rs + eq_primitives_pin.rs + prose snapshot migration) + T6 bench-driver suffix flips (4 Python + run.sh, both compile_check.py + cross_lang.py exit 0) + T7 re-authored 4 raw-JSON-inspect e2e tests via ail parse-derived tempfiles + retired 1 (render_parse_round_trip_canonical subsumed by T1) + T8 deleted 156 non-carve-out .ail.json (inventory 8 carve-outs + 157 .ail post-T8, alphabetical: broken_unbound + prelude + 3× test_22b2_* + 3× test_ct1_*) + 20 forward-pulled stale-.ail.json-ref repairs missed by T1-5 recon + T9 retired 3 obsolete roundtrip tests (print_then_parse_round_trips_every_fixture + every_ail_fixture_matches_its_json_counterpart + cli_render_then_parse_preserves_canonical_bytes_on_every_fixture) + dead helpers (list_json_fixtures ×2, round_trip_one, strip_trailing_newlines) + flipped schema_coverage corpus to .ail (forward-pulled into T8 for green-gate) + T10 §C3 DESIGN.md §Roundtrip Invariant restated with parse-determinism + idempotency + CLI-pipeline-idempotency + carve-out-anchor framing (5 surviving enforcement tests named) + T11 §A4 CLAUDE.md + DESIGN.md doctrine sentences replaced (canonical form is JSON-AST; authoring form is .ail) + T12 WhatsNew milestone-close entry + roadmap [milestone] form-a struck [x] (Closed 2026-05-13 by iter form-a.1). 4 carve-outs added beyond the original 7 §C4(a): only 1 — prelude.ail.json — landed as §C4(b) compile-time-embed (rationale: include_str! at workspace.rs:417 + main.rs:474; resolution queued as separate milestone Prelude embed: Form-A as compile-time source). Spec amendment + grounding-recheck PASS at 9fcda8b. Final tests: 557 green + 3 ignored (561 from T1 − 4 retired = 557); bench compile_check.py + cross_lang.py exit 0; check.py noise envelope continues 11th consecutive audit, baseline pristine. Milestone structurally closed → 2026-05-13-iter-form-a.1.md
• 2026-05-13 — audit-form-a: milestone close (Form-A as the default authoring surface) — architect status drift_found with 4 documentary-only items (2× [medium] spec + plan "seven carve-outs" orphans contradicting the §C4(b) amendment commit 9fcda8b — the implementation is eight-carve-out-correct; 2× [low] hash.rs:57 empty mod tests {} placeholder after T5 relocation + round_trip.rs:16 stale "Direction 2" docstring contradicting T10's framing rewrite); architect explicit recommendation carry-on — no form-a.tidy queued, drift deferred to documentary cleanup at next opportunity (architect verbatim: "the implementation is correct and the spec orphans are post-hoc retro-clean-up, not active drift"). Bench: all 3 scripts exit 0, baseline pristine for the 12th consecutive audit. check.py 2 regressions in tail-latency max_us (latency.explicit_at_rc + latency.implicit_at_rc, both >120% over baseline, both paired with p99 improvements on same metric stem) — 12th consecutive observation of the metric-identity-migrating noise envelope since audit-cma; compile_check.py 2 regressions in sub-millisecond check_ms on hello + borrow_own_demo — timing-jitter on the corpus's two smallest fixtures, iter form-a.1 T6 already flagged the same pair as transient; cross_lang.py 25/25 stable, bench_tree_walk.rc_over_c improved 2.74→2.59 still inside noise. What holds (verified): §C3 §Roundtrip Invariant restated with 4 properties + 5 surviving enforcement tests named verbatim; §A4 CLAUDE.md + DESIGN.md doctrine reworded per spec; 8-carve-out inventory matches spec post-amendment (alphabetical: broken_unbound + prelude + 3× test_22b2_* + 3× test_ct1_*); 156 non-carve-out .ail.json deleted; 157 .ail post-iter; cargo test --workspace 557 green + 3 ignored; WhatsNew editorial-clean (user-facing); roadmap milestone struck [x] with close attribution + follow-up [Prelude embed] milestone present with motivation + 3 resolution options. Milestone fully closed → 2026-05-13-audit-form-a.md
• 2026-05-13 — fieldtest-form-a: 4 hand-authored .ail fixtures (factorial smoke, Show user-ADT, user-class Describe with two instances, two-module workspace) + spec report. Findings: 1 bug (instance-method-body unbound-var bypasses ail check; surfaces at mono with degraded "monomorphise_workspace: unknown identifier" diagnostic — ail check should fire [unbound-var] like at fn-body level → debug RED-first), 1 friction (str_concat primitive missing — first attempt at user-Show body wanted "prefix=" ++ int_to_str-style concatenation, repaired by dropping prefix → planner tidy symmetric to str_clone/int_to_str wiring), 2 spec_gaps (form_a.md has zero class/instance/constraint/method sections — the form-a milestone made .ail the authoring form but the form_a spec doc still only covers pre-22 surface; canonical-form rule for (instance (class X)) class-qualifier not in form_a — class X vs class some_module.X reading is ambiguous from the spec, observed canonical reading via examples corpus). Plus 3 working (4 fixtures, 3 first-shot-clean + 1 first-attempt-bug-then-clean). Boss-side cleanup at commit time: deleted 8 stale .ail.json sidecars in examples/fieldtest/ (4 forma_* derived by fieldtester per old workflow, 4 pre-existing floats_* from prior milestone that T8 missed because the bash deletion loop globbed only examples/*.ail.json direct children); plus updated skills/fieldtest/agents/ailang-fieldtester.md Phase 3 to remove the now-obsolete "generate canonical JSON" step (the agent was calibrated to dual-form pre-form-a; post-form-a .ail is the sole authoring form). Findings deferred to follow-up iters: bug → next debug dispatch, friction → small planner tidy, spec_gaps → form_a.md tightening pass → 2026-05-13-fieldtest-form-a.md
• 2026-05-13 — iter bugfix-instance-body-unbound-var: instance method bodies now walk through check_fn — check_def's Def::Class(_) | Def::Instance(_) arm at crates/ailang-check/src/lib.rs:1574-1595 was early-returning Ok(()) for both variants (the comment claimed iter 22b.2 landed instance-body typechecking; the wiring was never implemented), so an unbound identifier inside an instance-method lambda body slipped past ail check (false-OK exit 0 with ok (N symbols across M modules)) and surfaced only at ail build as the degraded internal-error diagnostic monomorphise_workspace: unknown identifier: <name> without source location, symbol kind, or "did you mean" candidates. Fix: split the combined arm so Def::Class(_) stays schema-only at this layer while Def::Instance(inst) routes through a new helper check_instance that, for each InstanceMethod, lifts the body Term::Lam into a synthetic FnDef and applies class-method substitution (class param → instance type via the existing substitute_rigids / substitute_rigids_in_term helpers — looked up in env.class_methods[(qualify_class_ref_in_check(&inst.class, &env.current_module), im.name)] for the class's param name) before handing to check_fn. The reuse of check_fn is what gets the body walked through the same identifier-resolution path as fn bodies, so an unbound name fires [unbound-var] at ail check with exit 1 and the standard structured diagnostic. RED: 2 tests in crates/ail/tests/unbound_in_instance_method_pin.rs (text-mode + --json shape, both committed in 72f3f65 ahead of the GREEN side per the audit-trail flow). GREEN: 557+2 = 559 green; both pins PASS; fn-body-level unbound-var path stays green; all 8 carve-out fixtures classify unchanged. Known debt (out of scope per "minimal fix" constraint, recorded in journal): check_instance does not yet cross-check the substituted method signature against the class's ClassMethodEntry.method_ty — a malformed instance declaring wrong types in its Lam would still typecheck cleanly. Closes the bug finding from fieldtest-form-a → 2026-05-13-iter-bugfix-instance-body-unbound-var.md
• 2026-05-13 — iter form-a.tidy: post-fieldtest documentary tidy — 6 tasks; closes 2/3 fieldtest-form-a spec_gaps + 3/4 audit-form-a drift items. T1-T3 add three new sections to crates/ailang-core/specs/form_a.md: ### Class — (class ...) (EBNF with optional (superclass …)? schema-matched cardinality + abstract-required vs default-bearing method clauses, anchored to examples/test_22c_user_class_e2e.ail ok 24/2), ### Instance — (instance ...) (EBNF with canonical-form CLASS-REF rule explicitly stated + same-module bare example abbreviated from mq3_class_eq_vs_fn_eq_classmod.ail + cross-module qualified example from show_user_adt.ail + bare-cross-module-class-ref diagnostic anchor), and (forall ...) extension with optional (constraints (constraint CLASS-REF TYPE)+)? clause + no-instance diagnostic anchor + fifth Examples-block entry anchored to cmp_max_smoke.ail ok 22/2. §Definitions intro flipped Three kinds → Five kinds. T4 fixes 6 contradictory "seven carve-outs" sites in docs/specs/2026-05-13-form-a-default-authoring.md (preamble + §C1 + §C2 + §C3 + §"Data flow" two sites) to match the §C4(b) amendment commit 9fcda8b; post-edit grep returns 4 correctly-scoped surviving "seven" mentions (lines 233, 238, 463, 469 — all §C4(a)-scope or arithmetic/future-state). T5 deletes empty #[cfg(test)] mod tests {} placeholder + 6-line relocation-comment block from crates/ailang-core/src/hash.rs:50-57 (the unit tests live in crates/ailang-core/tests/hash_pin.rs since form-a.1 T5 relocation; placeholder served no purpose). T6 rewrites crates/ailang-surface/tests/round_trip.rs module-level //! (lines 1-26) and inner /// (lines 63-72) docstrings to the post-T10 four-property framing (parse-determinism + idempotency-under-print + CLI-pipeline-idempotency + carve-out-anchor) instead of retired Direction-1/Direction-2 framing, with sibling-crate breadcrumbs pointing at the other two enforcement points (crates/ail/tests/roundtrip_cli.rs::cli_parse_then_render_then_parse_is_idempotent for CLI-pipeline-idempotency, crates/ailang-core/tests/carve_out_inventory.rs::examples_ail_json_inventory_matches_carve_outs for carve-out-anchor). Drift item B2 ("plan-file seven-orphans, two sites" per audit-form-a) dropped from the iter: recon verified docs/plans/2026-05-13-iter-form-a.1.md contains zero defective seven mentions; all four hits are internally scoped to §C4(a), arithmetic, or future-state — the audit-form-a journal's "two sites" claim against the plan file did not match its contents at HEAD; decision recorded in journal §"Decision recorded — Drift item B2". Tests 559 green at every per-task gate (no test-file changes; T5 deletes a no-op mod tests {}). Pure-documentary iter, Phase 3 deliberately skipped per carrier; verification was per-task cargo test --workspace + ail check on the four corpus fixtures cited in T1-T3. Remaining open from form-a fieldtest queue: friction (no str_concat primitive — symmetric tidy iter queued) → 2026-05-13-iter-form-a.tidy.md
• 2026-05-13 — iter str-concat: str_concat : (borrow Str, borrow Str) -> Str heap-Str concatenation primitive shipped in four-site lockstep, closing fieldtest-form-a friction finding #4. T1 RED-pin crates/ail/tests/str_concat_e2e.rs + new corpus fixture examples/show_user_adt_with_label.ail (Show user-ADT body using (app str_concat "Item " (app int_to_str n)) through prelude print; ok 23/2). T2 runtime/str.c C helper ailang_str_concat(a, b) appended after ailang_str_clone: reads len headers from both source payloads, str_alloc(la+lb), memcpys both bytes, NUL-terminates. T3 crates/ailang-check/src/builtins.rs install entry (Type::Fn arity-2 Borrow-Borrow params, Own return, effects empty) + list() row + install_str_concat_signature unit test reaching into env.globals directly (deeper than synth_in_builtins_env-based siblings because first builtin with arity-2 Borrow params). T4 crates/ailang-codegen/src/lib.rs four-site lockstep: extern declare ptr @ailang_str_concat(ptr, ptr) after str_clone declare + lower_app arm after str_clone arm (arity-2 check + two lower_term + fresh_ssa + body push) + is_builtin_callable match-list extended with "str_concat" + IR-pin unit test str_concat_emits_call_to_ailang_str_concat asserting both extern declaration AND call instruction in emitted IR. Five IR snapshots regenerated (hello.ll, list.ll, max3.ll, sum.ll, ws_main.ll) to absorb the new unconditional declare line in IR header — same upkeep pattern as hs.4 (sole diff verified at IR line 17 across all snapshots). T5 lockstep-collision repair: examples/bug_unbound_in_instance_method.ail had used str_concat as the literal UNBOUND name (because that was the fieldtester's LLM-natural repro); renamed to format_label (LLM-author-realistic helper name that will never become a builtin) and updated crates/ail/tests/unbound_in_instance_method_pin.rs (replace_all on str_concat → format_label, including one test name flipped to check_fires_unbound_var_for_format_label_in_instance_method_body), preserving the regression guard's intent (instance-method-body walked through unbound-var check) while substituting a name with stable unbound semantics. T6 docs/DESIGN.md new §"Heap-Str primitives" subsection (line 1994) between the milestone-24 Show-backer enumeration and the existing Primitive output goes through ... paragraph, cataloguing all five heap-Str primitives (int_to_str, bool_to_str, float_to_str, str_clone, str_concat) with type signatures, iter origins, and the user-visible-vs-prelude-internal distinction; Show-backer block unchanged. T7 docs/roadmap.md struck [x] [feature] str_concat line at end of P2 cluster. Two minor plan-vs-actual discrepancies recorded in journal Concerns: (a) T3 Step 5 test-count prediction passed: 560 failed: 1 was actual passed: 558 failed: 3 because the unbound_in_instance_method_pin tests turn RED at checker registration not at codegen (assertion is on the [unbound-var] diagnostic which depends only on the checker registry) — implementation correct, T5 fully repairs; (b) IR snapshot regen for T4 was not explicitly scripted in the plan but follows hs.4 precedent. Final iter state: 562/562 green (559 baseline + 3 new pins), zero re-loops across all 7 tasks. Bench impact none (no new code paths touched by bench corpus; bench fixtures use int_to_str / bool_to_str only). Closes fieldtest-form-a queue: bug (closed bugfix-instance-body-unbound-var), spec_gaps 2+3 (closed form-a.tidy), friction (closed here). Remaining open: spec_gap 1 dropped per recon (audit-form-a "plan two sites" claim did not match HEAD) → 2026-05-13-iter-str-concat.md
• 2026-05-13 — iter rustdoc-sweep: cleared all 23 cargo doc --workspace --no-deps warnings (17 in ailang-check + 4 in ailang-core + 2 in ailang-surface). Two warning classes: (a) pub doc-comments that linked-via-brackets to pub(crate)/private items (15 hits) — replaced [`fn`] with plain backtick-code-span `fn` so the identifier stays readable but rustdoc no longer tries to resolve the link; (b) unresolved/ambiguous links (8 hits) — mono.rs [Registry]/[Registry::entries] ×3 fully-qualified to [ailang_core::workspace::Registry…]; loader.rs [crate::parse] ×2 (ambiguous between fn + mod) disambiguated to [crate::parse()]; lib.rs metas[i] (parsed as a link) escaped to metas\[i\]. Tests 562 → 562, no behaviour change → 2026-05-13-iter-rustdoc-sweep.md
• 2026-05-13 — iter drift-test-narrowing: crates/ailang-core/tests/design_schema_drift.rs now scans §"Data model" only, not the whole DESIGN.md. New helper data_model_section() slices DESIGN_MD from ## Data model to the next top-level ## header; all 7 anchor-presence tests switched from DESIGN_MD.contains(anchor) to data_model_section().contains(anchor). Closes the audit-form-a-precursor [high] "anchors-elsewhere-pass-silently" failure mode (an anchor present only in §"Decision 11" or another discussion section was previously treated as documented). All 38 anchors verified pre-edit to live in §"Data model" so the tightening doesn't regress to red. New pin data_model_section_is_bounded (starts-with ## Data model, no bleed past \n## Pipeline, > 1 KB) guards the extractor itself against silent regression to whole-document scanning. Tests 562 → 563 (+1) → 2026-05-13-iter-drift-test-narrowing.md
• 2026-05-14 — iter clippy-sweep: cleared all 61 cargo clippy --workspace --all-targets warnings across 12 lint classes. Bulk: 32× doc_lazy_continuation + 4× empty_line_after_doc_comments (8 orphan /// blocks in workspace.rs left by form-a.1 T5 relocation converted to plain //) — pure documentation hygiene. Idiomatic refactors: 5× err_expect (.err().expect() → .expect_err()), 3× useless_conversion, 2× redundant_closure, 2× collapsible_match, 1× single_char_add_str, 1× trim_split_whitespace. Two derivable_impls (manual Default for ParamMode + AllocStrategy flipped to #[derive(Default)] + #[default]). One blocks_in_conditions extracted to a new helper is_class_method_dispatch(name, env) next to qualifier_is_class_shape in check/src/lib.rs. Three #[allow]s with inline rationale: only_used_in_recursion on walk_pattern (preserves the 5-fn walker-framework signature uniformity), 2× if_same_then_else on qualify_local_types shapes (check/src/lib.rs:3457 + codegen/src/subst.rs:165 — the two name.clone() branches encode semantically distinct disqualification reasons), too_many_arguments on Emitter::new (8 workspace-flat tables; bundling would just rename boilerplate). Tests 563 → 563 (no behavior change); cargo doc stays at 0 warnings (rustdoc-sweep baseline holds); all 3 bench scripts exit 0 against existing baselines (free stability check that the sweep touched no semantics) → 2026-05-14-iter-clippy-sweep.md
• 2026-05-14 — iter bugfix-mono-cursor-print-with-class-method-arg: mono cursor advance by 1+N at poly-free-fn Var with class-constrained Forall → 2026-05-14-iter-bugfix-mono-cursor-print-with-class-method-arg.md
• 2026-05-14 — iter bugfix-print-leak-show-ret-mode: prelude Show.show ret_mode + substitute_rigids preserves param_modes/ret_mode → 2026-05-14-iter-bugfix-print-leak-show-ret-mode.md
• 2026-05-14 — iter rpe.1: retire per-type io/print_int|bool|float; corpus migrated to polymorphic print → 2026-05-14-iter-rpe.1.md
• 2026-05-14 — iter rpe.1.tidy: subst.rs preserves Type::Fn modes through rebuild → 2026-05-14-iter-rpe.1.tidy.md
• 2026-05-14 — iter cli-diag-human: WorkspaceLoadError thru diagnostic in non-JSON CLI path → 2026-05-14-iter-cli-diag-human.md
• 2026-05-14 — iter pd.1: core API split — load_modules_with + build_workspace + implicit_imports threading; load_workspace_with kept as 3-line shim so surface unchanged; production literal-"prelude" count in workspace.rs dropped 8→4 → 2026-05-14-iter-pd.1.md