Files

T

Brummel dbd76e5503 fix(ail-embed): GREEN — build.rs tracks runtime/ as rerun-if-changed; M5 swarm leak-proof armed & deterministic

bugfix-swarm-rc-alloc-undercount, GREEN stage. RED is the separate
audit-trail commit 483117d.

Root cause of the m5.2-resume-attempt residual: ail-embed/build.rs
declared cargo:rerun-if-changed only for the kernel .ail + build.rs
itself — NOT the runtime/ C sources ail build --emit=staticlib
compiles into libailang_rt.a. Cargo never re-ran build.rs after the
atomic-counter fix 7bfa11e, so ail-embed kept linking a stale
pre-7bfa11e non-atomic libailang_rt.a; the swarm's concurrent
TLS-NULL host allocs raced the stale non-atomic g_rc_alloc_count++
(frees-stable/allocs-jitter). NOT a second runtime bug and NOT
test-methodology unsoundness — runtime/rc.c at HEAD is correct; the
isolated crates/ail RED was green only because it rebuilds the
staticlib fresh per run.

Fix (ail-embed/build.rs, +7 lines): directory-level
cargo:rerun-if-changed=<repo>/runtime (Cargo recurses mtimes under
the dir). Preferred over a per-file list — the implementer inspected
crates/ail build_staticlib (libailang_rt.a = ar(rc.o, str.o), both
under runtime/) and chose the directory mechanism so any future
runtime source cannot silently re-introduce the same staleness.
Existing kernel/build.rs/AIL_BIN rerun-if-changed lines kept.

Cohesive consequence (in-scope): symbol_fan_swarm_leak_free
un-#[ignore]d — the test BODY is byte-for-byte unchanged (it was
quarantined, never weakened); the module-doc + fn-doc breadcrumbs
rewritten to the resolved build-dep-staleness rationale. It is now
the integration-level acceptance of both 7bfa11e and this fix. Boss
also removed a pre-existing unused `DataFormat` import in swarm.rs
inline (trivial; the file is committed this iter regardless;
warning-clean after).

Boss-verified independently: RED rt_archive_freshness -> GREEN;
swarm determinism 5/5 (symbol_fan_swarm_leak_free +
symbol_fan_swarm_bit_exact GREEN every run, 0 ignored, jitter gone,
Sallocs==Sfrees==12000003); isolated embed_rc_global_stats_race
still GREEN (untouched, runtime untouched); Invariant 1 data-server
count 0; scope = ail-embed/build.rs + ail-embed/tests/swarm.rs +
journal + stats only.

The M5 swarm leak-proof bounce-back is fully resolved end-to-end.
M5 stays open [~]; m5.3 (time-shard + friction-harvest + close-out)
remains. Includes the per-iter journal, stats, and INDEX.md line.

2026-05-19 02:21:47 +02:00

155 KiB

Raw Blame History

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
2026-05-14 — iter pd.2: surface owns prelude embed (PRELUDE_AIL + parse_prelude in ailang-surface); pd.1 shim load_workspace_with retired along with PRELUDE_JSON / load_prelude / load_one; cross-form-identity preflight PASSED at module_hash 3abe0d3fa3c11c99; production literal-"prelude" in core/src/ now zero → 2026-05-14-iter-pd.2.md
2026-05-14 — iter pd.3: prelude.ail.json deleted from working tree; cross-form-identity preflight + supporting bytes deleted from prelude_module_hash_pin (purpose discharged); migrate-bare-cross-module-refs defensive include + lockstep skip-branch deleted; carve_out_inventory.rs §C4(b) row dropped (8→7); form-a-default-authoring spec §C4(b) RETIRED status marker added; new prelude_decouple_carve_out_pin.rs asserts JSON file does not exist; milestone prelude-decouple closed → 2026-05-14-iter-pd.3.md
2026-05-14 — audit-pd: milestone close (prelude-decouple) — architect drift fixed inline as audit-pd-tidy (DESIGN.md §"Roundtrip Invariant" carve-out count 8→7 + main.rs migrate-subcommand dead prelude fallback removed); bench mixed (check.py + compile_check.py established noise envelope, 15th consecutive observation, baseline pristine; cross_lang clean) → 2026-05-14-audit-pd.md
2026-05-15 — iter mut.1: AST extension Term::Mut + Term::Assign + MutVar struct; Form A (mut ...) / (var ...) / (assign ...) productions parse + print + round-trip; ~25 substantive Term-walker arms across the codebase; dispatch stubs in synth (typecheck) + lower_term (codegen) return CheckError::Internal / CodegenError::Internal per the spec's out-of-iteration boundary; examples/mut.ail six-fn fixture (Int/Float/Bool/Unit + empty + nested-shadow); drift + coverage + spec-drift tests + DESIGN.md §"Term (expression)" + crates/ailang-core/specs/form_a.md amendments; tests 564 → 579 → 2026-05-15-iter-mut.1.md
2026-05-15 — iter mut.2: typecheck for Term::Mut + Term::Assign replacing the iter mut.1 dispatch stubs; three new CheckError variants (MutAssignOutOfScope, AssignTypeMismatch, UnsupportedMutVarType) with bracketed-[code]: Display + code() + ctx() arms; synth signature threads mut_scope_stack: &mut Vec<IndexMap<String, Type>> after locals, propagated through all recursive call sites in lib.rs plus mono.rs:712/1337 + lift.rs:723 + builtins.rs test helpers + the mq.3 in-test helper at lib.rs:6663; Term::Var resolution prepended with innermost-first mut-scope lookup; Term::Mut arm gates var types to {Int,Float,Bool,Unit} and push/pops a fresh frame; Term::Assign arm walks the stack innermost-first, emits AssignTypeMismatch on type mismatch and MutAssignOutOfScope (with available flattened across all frames) on miss; five .ail.json fixtures under examples/ (four negative + one positive nested-shadow) + driver crates/ailang-check/tests/mut_typecheck_pin.rs; carve_out_inventory.rs EXPECTED extended 7→12 for the new negative-fixture set; examples/mut.ail typechecks clean (ok (26 symbols across 2 modules)); tests 579 → 592 → 2026-05-15-iter-mut.2.md
2026-05-15 — iter mut.3: codegen + e2e for Term::Mut + Term::Assign closing the mut-local milestone end-to-end; mut-var allocas hoisted to fn entry block via a per-Emitter side buffer pending_entry_allocas: String + a captured entry_block_end_marker: Option<usize> byte position spliced via String::insert_str at the end of emit_fn; Term::Mut arm in lower_term emits one alloca per var into the side buffer, lowers each init at the current position, emits a store to bind, push/pops a per-block save stack for proper shadowing of outer mut-vars; Term::Assign arm emits store <ty> <value_ssa>, ptr <alloca> and yields the canonical Unit SSA; Term::Var arm prepends mut-var lookup with a load emission. Two beyond-plan adjustments: (1) synth_with_extras's parallel Term::Var arm needed the same mut-var lookup precedence as lower_term, (2) lambda.rs thunk emission needed save/restore of all three new Emitter fields across the lambda-body boundary plus an in-thunk splice at the lambda's own entry marker so mut-blocks inside a closure body hoist to the closure's entry not the outer fn's. Two e2e fixtures examples/mut_counter.ail (Int) + examples/mut_sum_floats.ail (Float); both run end-to-end and print 55. DESIGN.md "What is supported" subsection gains a "Local mutable state" bullet. mut-local milestone end-to-end closed. Tests 592 → 594 → 2026-05-15-iter-mut.3.md
2026-05-15 — iter mut.4-tidy: close mut-local audit drift. Architect's two [high] items addressed — new CheckError::MutVarCapturedByLambda rejects any lambda whose body's free vars hit the enclosing mut_scope_stack (via the existing desugar::free_vars_in_term helper, gated on non-empty stack), and codegen/lambda.rs's blame-typechecker Internal path becomes unreachable! once typecheck is the gate. Two [medium] stale-history comments cleaned in DESIGN.md §"Term (expression)" and ailang-codegen/src/lib.rs. New negative fixture examples/test_mut_var_captured_by_lambda.ail.json + driver test extension; carve_out_inventory.rs EXPECTED 12→13. Spec §"Out of scope" amended with the lambda-capture rejection bullet. Bench: compile_check.py check_ms showed a uniform ~30-50% regression across the suite traced to a fixed-cost startup tax (mut-* added ~1400 lines of typecheck/codegen surface; the short-circuit on empty mut_scope_stack walk in Term::Var did not move the needle, falsifying the hot-path hypothesis); ratified as a feature tax with paired baseline update on bench/baseline_compile.json. check.py tail-noise envelope continues the audit-pd carve-out (no ratify needed). cross_lang.py clean. Tests 594 → 598. mut-local milestone audit closed → 2026-05-15-iter-mut.4-tidy.md
2026-05-15 — bugfix mut-diag-double-code: fieldtest F2 — the four mut-local CheckError variants embedded [<code>] in their #[error] Display body while the non-JSON CLI formatter also prepends [code], doubling it in human stderr; dropped the embedded prefix from the four strings, bringing them in line with all non-mut variants; RED-first via debug (ct1_check_cli.rs::check_human_mode_renders_mut_diagnostic_code_exactly_once), GREEN applied inline as a trivial mechanical edit; tests 598 → 599 → 2026-05-15-bugfix-mut-diag-double-code.md
2026-05-15 — iter it.1: iteration-discipline milestone (1 of 3) — Term::Loop / Term::Recur / LoopBinder added as strictly-additive first-class AST nodes end-to-end: Form-A parse_loop/parse_recur + print + prose render/free-var/subst lockstep + canonical-JSON serde/round-trip + schema/spec-drift/schema-coverage/carve-out lockstep (13→17) + typecheck (binder typing + recur arity/type unification via loop_stack: &mut Vec<Vec<Type>> threaded exactly as mut.2's mut_scope_stack; recur-tail-position via a new private verify_loop_body, verify_tail_positions public signature unchanged) + codegen (loop-header block, one phi per binder, recur back-edge br with a NEW parallel block_terminated setter, lambda-boundary loop_frames save/restore mirroring mut.3). Four new CheckError variants Recur{OutsideLoop,ArityMismatch,TypeMismatch,NotInTailPosition} (bracket-[code]-free Display per the F2 convention). Strictly additive verified — zero deletions touch tail-app/tail-do, verify_tail_positions' tail-app role, or the seven existing codegen block_terminated sites (the 32 within-iter deletions are exclusively DD-3 stub-then-fill replacements). Term::Recur synth returns a fresh metavar (resolves the plan's flagged Type::unit() open risk: recur appears in if branches that must unify with the sibling type). loop_counter.ail→55, loop_in_lambda_e2e.ail→49, four negatives fire exact codes, tail-app fixtures byte-identical, zero IR/prose snapshot drift; cargo test --workspace green. Two mut.1-class plan-pseudo-vs-reality substitutions recorded (prose round-trip asserting AST-equality is impossible — no Form-B parser by design; the diagnostic.rs doc-list premise was false) → 2026-05-15-iter-it.1.md
2026-05-15 — iter it.2: iteration-discipline milestone (2 of 3) — structural-recursion guardedness checker + first real Diverge effect, strictly additive (nothing tail-related removed; that is it.3). New whole-body pass verify_structural_recursion runs as a sibling of verify_tail_positions in check_fn's post-synth region (DD-1): the smaller-set algorithm with implicit candidate-position inference + unconstrained accumulator positions (DD-2 — foldl-shape accumulator classifies as structural recursion, pure+total), self/mutual identification with an inline ADT-family connected-components union-find (DD-3), and the it.2-only tail==false grandfather. CheckError::NonStructuralRecursion {callee,arg} (bracket-[code]-free Display per F2). term_contains_loop (stops at Term::Lam boundaries, DD-4) injects "Diverge" into the raised effect set so the existing UndeclaredEffect machinery enforces it with no new diagnostic variant; lam-arrow + Term::LetRec sub-effect sites wired (loop behind a lam edge carries !Diverge on the lam's arrow, propagating via the free callee-effect path, not leaking to the enclosing fn — exactly as !IO scopes). DESIGN.md Decision 3 + §Data-model hook synced present-tense. Four it.1 loop fixtures gained !Diverge. Two spec-premise boundary defects surfaced and resolved inside the task's invariants (corpus clean, check not weakened): (§1) the spec's "21 tail-app fixtures" grandfather premise under-counts the corpus — no-ADT-candidate counter recursions (~18, e.g. build_tree(depth:Int)) have no structural position to verify and are deferred to it.3 migration; (§2) two RC-regression fixtures (rc_pin_recurse_implicit, rc_let_alias_implicit_param) hold an ADT param constant while decrementing an Int — genuinely non-structural, joined the spec's transitional tail-app grandfather exactly as the other 20 corpus fixtures do (their RC==GC regression guards verified still green; the regression lives in the unchanged pin/pin_aliased bodies). Both recorded as corrected it.3 corpus-migration scope. cargo test --workspace 622 green / 0 red; all 9 acceptance pins non-vacuous (negatives .contains(code)); struct_rec_sum→15, loop_needs_diverge→55, the it.1 55/49 e2e still green → 2026-05-15-iter-it.2.md
2026-05-15 — iter it.3 (BLOCKED, bounce-back): destructive terminal iteration of iteration-discipline. Task 1 (non-destructive: pre-migration oracle + the spec-delegated class-(b) live sweep) ran complete — 40 recursive corpus fixtures classified + oracled under bench/it3-oracle/; zero production code changed; HEAD clean at c992eb9. The mandated Task-1.3 sweep surfaced a fundamental milestone-design flaw, not a migration nuisance: 6 fixtures contain build(d: Int) = if d==0 then Leaf else Node(1, build(d-1), build(d-1)) — a terminating, maximally-LLM-natural, non-structural (Int param, no ADT-candidate) non-tail BRANCHING (double) recursion that the milestone's totality dichotomy ("structural-over-ADT OR loop/recur, else error") makes inexpressible: not ADT-structural, and not recur-able (branching ≠ single tail back-edge). Post-it.3 it is a hard NonStructuralRecursion with no expressible alternative — the milestone as-specified would fail its own feature-acceptance criterion (clause 1: the LLM reaches for build(d-1),build(d-1); clause 2: the milestone would remove expressivity). The orchestrator correctly refused a 4th plan-patch and bounced (feedback_spec_over_plan_patches). Boss verdict: the totality story overlooked a second canonical total-by-construction scheme — well-founded recursion on a strictly-decreasing non-negative Int measure. Resolution requires a new additive iteration it.2b (widen the it.2 guardedness checker to accept Int-bounded recursion incl. branching) BEFORE it.3 re-dispatches; the purity sub-fork (Int≠Nat: total only for non-negative entry) touches the user-co-designed purity pillar → user design decision, recommended option A1 (accept with a documented non-negative-entry obligation, analogous to array-bounds). Notify sent; loop stopped. The RC-RSS/18g.1 load-bearing risk (it.3 Task 5.5/5b) was NOT reached and must NOT be treated as resolved by the milestone-close audit → 2026-05-15-iter-it.3.md
2026-05-16 — iter revert: Iteration-discipline milestone (it.1 96db54d + it.2 a4be1e5) fully backed out by one forward iteration (main sacrosanct — never rewound; 1ff7e81, the pre-9973546 commit, is the per-region byte oracle). Root cause: the milestone was an over-escalation of fieldtest finding F1 (a [friction] item whose own minimal recommendation was a DESIGN.md note); its totality dichotomy made the maximally-LLM-natural build(d:Int)=Node(1,build(d-1),build(d-1)) inexpressible (it.3 BLOCKED), and the only in-thesis escape (A1/it.2b) conceded the language's first documented-unenforced totality precondition — a purity-pillar dilution the user rejected. Term::Loop/Term::Recur/LoopBinder, the verify_structural_recursion guardedness pass + term_contains_loop + Diverge-injection + the transitively-it.2 module_fns plumbing, the five Recur*/NonStructuralRecursion CheckError variants (+ code() + 3 dedicated ctx() arms), the it.1 codegen loop-header/phi/back-edge + parallel block_terminated setter, and all walker arms are removed — crates/ailang-check/src/lib.rs and every reverted source/test file byte-identical to 1ff7e81. Surgical keeps: feature-acceptance clause 3 (DESIGN.md + brainstorm SKILL.md, worked example de-claimed "shipped"→hypothetical) and the F3 P2 todo. Sole net addition: an honest F1/F4 documented-idiom note (tail-recursive accumulator fallback; examples/mut_counter.ail) guarded by a doc-presence test. 16 it.1/it.2 fixtures + 2 pin files + bench/it3-oracle/ deleted; 2 RC fixtures restored to 1ff7e81; bench/orchestrator-stats/2026-05-15-iter-it.{1,2,3}.json kept (historical record). Roadmap: Iteration-discipline block + blocking-fork section removed; the genuine total-Int-recursion ambition preserved as a deferred P2 milestone sequenced behind a future Nat/refinement-types milestone (not abandoned — correctly sequenced). Correctness gate PRISTINE: 164 surviving 1ff7e81-era fixtures ail check/ail run byte-identical to pre-milestone behaviour (1ff7e81 worktree reference compiler, zero drift); cargo test --workspace 600/0; zero residual it.1/it.2 production surface. The old it.* journals/plans + the superseded-headered 2026-05-15-iteration-discipline.md stay as historical record → 2026-05-16-iter-revert.md
2026-05-16 — audit iteration-discipline-revert (milestone close, clean): architect confirmed the revert byte-pristine (18 src + 5 test files byte-identical to 1ff7e81, zero residual it.1/it.2 production surface, DESIGN.md coherent, roadmap/spec hygiene correct); one [medium] drift — a dangling loop/recur cross-reference into the reverted milestone inside the live Stateful-islands roadmap scope bullet — fixed inline (Boss doc-hygiene; reworded to keep the real "no while; repetition stays recursion" scope guard, drop the reverted-milestone reference). Bench: compile_check.py/cross_lang.py exit 0; check.py exit 1 on the single metric bench_list_sum.bump_s +12.71%. Bencher localisation: HEAD and 1ff7e81 bump binaries cmp-identical, interleaved 3×60-run measurement shows head−oracle delta ~0 (±1.5% stdev) with both ~+11% over the 2026-05-09 baseline → environmental/hardware drift, NOT a revert regression (third independent proof codegen == 1ff7e81). Resolution: carry-on, baseline NOT ratified (Iron Law — nothing intentionally moved the metric; byte-identical codegen must not move the baseline; the spec's PRISTINE mandate is satisfied because pristine = "no regression introduced", proven). Pre-existing *.bump_s baseline-vs-hardware staleness (the 1ff7e81 oracle trips the same +11%) filed forward as a separate P2 [todo] (bench-harness recalibration, no language change), not mis-attributed to the revert. Fieldtest skipped (revert restores the already-field-tested pre-9973546 surface; Task-11 164-fixture byte-equivalence is the stronger proof). Milestone closed clean → 2026-05-16-audit-iteration-discipline-revert.md
2026-05-16 — iter effect-doc-honesty: standalone documentation-honesty tidy (split out from the retired effect-op-arg-modes bundle — user rejected bundling a real DESIGN.md fix with speculative build-ahead infra). Corrected three false effect-system claims the recon surfaced: DESIGN.md Decision 3 "row-polymorphic (![IO | r])" (no EffectRow/row var exists — effect sets are flat closed sets unified by set-equality) + "IO and Diverge … are wired up" (Diverge is 100% vapour: zero code in any crate) → reconciled to IO-only/Diverge-reserved-unimplemented (modelled on Decision 4's reserved-refinements precedent); DESIGN.md §"What is not supported" "IO and Diverge ops" bullet; ast.rs Term::Do doc-comment "resolved against the effect-handler table at link time" → the real mechanism (typecheck Env::effect_ops lookup + lower_effect_op literal codegen match, no handler table). Satellite lockstep: form_a.md:226 + rule-3, main.rs:289 merge-prose CONTRACT example. Guarded by a new 4-test doc-presence pin crates/ailang-core/tests/effect_doc_honesty_pin.rs (fiction-absent + corrected-anchor-present, single-line substrings — wrap-robust). No language/checker/codegen change; ail check/run byte-unchanged by construction. cargo test --workspace 600 → 604; drift/coverage trio (design_schema_drift/spec_drift/schema_coverage) green, empirically confirming none scans the effect-prose region. One concern: the plan's Task-2 replacement body soft-wrapped a phrase the single-line pin asserts; orchestrator resolved correctly (exact wording + exact pin preserved, wrap column moved) — recurring-class planner gap, fixed forward by a Step-5 self-review tightening → 2026-05-16-iter-effect-doc-honesty.md
2026-05-17 — iter loop-recur.1: standalone-loop/recur milestone (1 of 3) — the strictly-additive AST-node foundation. Term::Loop { binders: Vec<LoopBinder>, body } / Term::Recur { args } / struct LoopBinder (mirrors MutVar's (name,type,init) triple; binders no skip_serializing_if) added end-to-end across all six crates' no-_-wildcard exhaustive Term matches (~30 sites incl. one recon-undercount integration-test pin): Form-A parse_loop/parse_recur (binder/body boundary disambiguated by an is_term_head_kw guard — the plan's flagged sole parser judgement) + print + form_a.md grammar/notes + prose render/free-var/subst lockstep + canonical-JSON serde/round-trip + DESIGN.md §Data-model "t":"loop"/"t":"recur" blocks + design_schema_drift/spec_drift/schema_coverage anchors + a new loop_recur hash pin (additivity proven: iter13a + new pin both green, pre-existing canonical-JSON bytes byte-stable) + examples/loop_sum_to.ail round-trip fixture. NO typecheck semantics + NO real codegen by design: the two semantic dispatch points stubbed synth→CheckError::Internal / lower_term→CodegenError::Internal exactly as mut.1; pure analysis walkers (escape/lambda/synth_with_extras) get real structural pass-through. Two binding Boss design calls (mirrored into the journal): (1) verify_tail_positions "byte-unchanged" = tail-app role unchanged not source-frozen — it is an exhaustive no-wildcard match so two additive descent-only arms are mandatory; acceptance evidence is the tail-app non-regression test (all tail-filtered tests byte-identical), mut.1 set the precedent; (2) codegen IS iter-1 scope as stubs/pass-throughs (no real loop-header/phi/back-edge — that is iter 3). Three plan-pseudo-vs-reality substitutions, all intent-preserving, recurring feedback_specs_need_concrete_code/feedback_plan_pseudo_vs_reality class: serde Type::Con literal {"t":"con",…,"args":[]}→real {"k":"con","name":"Int"}; bare Int→(con Int) in binder triples (bare Int parses as Type::Var); ailang_core::ast::LoopBinder→unqualified inside ailang-core. Boss forward-fix folded in: Concern 2 surfaced that the committed specs themselves (2026-05-17-loop-recur.md headline + bad_recur, 2026-05-17-llm-surface-discipline.md §5) wrote bare Int — corrected all three snippets to (con Int) (doc-honesty, same class as the mono.rs header; no design/schema/assumption change, no re-brainstorm). cargo test --workspace 600→608 / 0 red (Boss-reran independently). Component 4 (typecheck) = iter 2; Component 5 (codegen) + positive/deep-n E2E = iter 3 → 2026-05-17-iter-loop-recur.1.md
2026-05-17 — iter loop-recur.2: standalone-loop/recur milestone (2 of 3) — Component 4 typecheck semantics. The iter-1 synth CheckError::Internal stub for Term::Loop/Term::Recur is replaced with real binder typing (each init synthed in outer scope + already-declared binder names of THIS loop via ordinary locals save/restore mirroring Term::Let verbatim; loop's static type = body type) + positional recur arity/per-arg-type checking via a new loop_stack: &mut Vec<Vec<Type>> frame threaded exactly as mut.2's mut_scope_stack (every recursive + cross-module + test synth caller, compile-swept). New private verify_loop_body(t,in_loop_tail) pass — a SIBLING of the byte-frozen verify_tail_positions (0 deletions, tail-app role untouched), invoked in check_fn after it so synth-raised codes take precedence by pass ordering. Four Recur* CheckError variants (RecurOutsideLoop, RecurArityMismatch{expected,got}, RecurTypeMismatch{position,expected,got}, RecurNotInTailPosition) + code() + 2 ctx() arms, bracket-[code]-free Display (F2); four negative .ail.json fixtures fire their codes point-exactly (assert_eq!, non-vacuous) via a new loop_recur_typecheck_pin.rs (7 tests) + a ct1 F2 human-mode sibling; carve_out_inventory 13→17 with the pre-existing mut.4-tidy "Twelve"-vs-13 stale-header drift corrected in passing. iter-1's loop_sum_to.ail round-trip fixture now ALSO typechecks clean (one fixture, two properties — no near-duplicate); loop_forever.ail (loop whose only path is recur) typechecks clean, asserting the spec "no termination claim is made or enforced". Three binding Boss design calls (mirrored into the journal): (1) RecurTypeMismatch is an Assign-style subst.apply-both-then-structural-!= pre-check, NOT a unify-propagate (a propagate would surface generic type-mismatch and fail the point-exact-code acceptance); (2) loop_stack element type is positional Vec<Type> NOT name-keyed IndexMap (recur rebinds by position; binder names live in locals); (3) diagnostic-code precedence is by pass ordering (synth before verify_loop_body), no explicit logic. NO codegen (iter-1 lower_term CodegenError::Internal stub stays — iter 3); NO Diverge/verify_structural_recursion/guardedness (spec deliberate boundary). Two DONE_WITH_CONCERNS, both Task 2, both journalled: (a) a plan-ordering defect — Task 2's cargo build 0-errors gate is unsatisfiable while check_fn (deferred by the plan to Task 4) is an unthreaded caller; orchestrator pulled the byte-identical declaration+threading forward to Task 2, left only the verify_loop_body invocation in Task 4 (no semantic change, only sequencing); (b) recon-undercount of cross-module synth callers (builtins.rs×2, lift.rs:746, mono.rs:720/:1361), the recurring mut.2-class, resolved via the plan's own designated compile-sweep oracle. Boss systemic fix folded into this commit: planner SKILL.md Step-5 self-review gains item 7 (compile-gate vs. deferred-caller ordering) so the Concern-(a) class is scrubbed at plan time, not discovered at execution. cargo test --workspace 608→616 / 0 red (Boss-reran independently); verify_tail_positions/tail-app byte-frozen confirmed by diff-hunk inspection. Component 5 (codegen loop-header/phi/back-edge) + the positive RUN-to-value / deep-n E2E = iteration 3 → 2026-05-17-iter-loop-recur.2.md
2026-05-17 — iter loop-recur.3: standalone-loop/recur milestone (3 of 3, TERMINAL) — Component 5 codegen + run-to-value E2E. The iter-1 lower_term CodegenError::Internal stub for Term::Loop/Term::Recur is replaced with real LLVM-IR lowering: loop binders are loop-carried values lowered as entry-block allocas (the mut.3 pending_entry_allocas mechanism) registered in the EXISTING mut_var_allocas map so the EXISTING Term::Var load path resolves them with zero new Var code (representation-sharing only — Var-lowering byte-unchanged); a fresh loop.header.<id> block reached by an unconditional br from the pre-header; recur lowers ALL args to SSA BEFORE any store (simultaneous positional rebind), stores into the binder allocas, back-edges br to the header, and sets the SINGLE existing block_terminated field at its OWN new emit site (a parallel SET call-site) so the loop's exit value is the emergent product of the existing if/match join — no separate loop-result phi/exit-block. A new loop_frames codegen stack lets recur find its target header+slots; saved/reset/restored at the single lambda-lowering boundary exactly as mut.3's mut_var_allocas triple. clang -O2 mem2reg promotes the binder allocas to the phi nodes the spec's secondary implementation-shape describes. Four binding Boss design calls (mirrored into the journal), all on architectural-consistency / spec-pinned-invariant grounds (NOT effort): (1) alloca+mem2reg NOT hand-emitted phi (the linear-emit architecture has no phi-with-body-discovered-back-edge-predecessor precedent; the if arm sidesteps by opening its join last — a loop header cannot be opened last; mem2reg yields identical optimized output; spec's "phi" is the explicitly-secondary impl-shape the spec subordinates to the planner's exact-bytes authority); (2) reuse mut_var_allocas + the existing Term::Var load path (byte-unchanged; representation-sharing, the iter-2 AST/typecheck binder distinction is post-typecheck-irrelevant to codegen); (3) emergent loop-exit via the existing if/match join once recur terminates its block, no separate result phi; (4) reuse the single block_terminated field, recur sets it at its own emit site, ZERO edits to any existing SET/READ site (a second field would force editing every READ site — the opposite of the spec-pinned "tail-app's use byte-unchanged"). Diff confirmed surgical by hunk-header inspection: codegen/lib.rs = exactly 3 hunks (field + init + the stub→2-arms replacement), codegen/lambda.rs = exactly 2 hunks (save + restore); NO hunk at any existing block_terminated SET/READ site, at tail-app/tail-do lowering, or at verify_tail_positions. Three new .ail fixtures: loop_sum_to_run.ail→55 (run-to-value), loop_sum_to_deep.ail→500000500000 (1e6 iterations via the back-edge, no stack growth — the spec clause-2 correctness claim made executable), loop_forever_build.ail (infinite loop, no non-recur exit, ail build exit 0 — "typechecks AND compiles, no termination claim"; never executed). Codegen-ONLY iteration: no schema/AST/serde/typecheck change; hash pins (loop_recur + iter13a) + drift trio + carve_out_inventory confirmed green UNTOUCHED (not modified); the 3 new .ail fixtures are round-trip-auto-covered, NOT carve-outs. One DONE_WITH_CONCERNS (T3): the plan's literal cargo test --workspace tail filter resolves to ZERO tests (real guards are *_tail_position_*/*musttail*); orchestrator ran the gate via real names + the authoritative full-suite 619/0 which subsumes it — recurring feedback_plan_pseudo_vs_reality class, no behaviour change. Boss systemic fix folded into this commit: planner SKILL.md Step-5 gains item 8 (verification-command filter strings must resolve to ≥1 named test, or use the unfiltered suite + a count assertion) — the SECOND planner-meta-gap this milestone surfaced (iter-2 added item 7). cargo test --workspace 616→619 / 0 red (Boss-reran independently); the 3 loop/recur e2e explicitly green (55 / 500000500000 / infinite-compiles). All three components shipped — the loop/recur milestone is structurally complete; milestone-close (mandatory audit, then fieldtest since loop/recur is user-visible Form-A surface) is the Boss's next pipeline step. → 2026-05-17-iter-loop-recur.3.md
2026-05-18 — iter loop-recur.tidy: milestone-close audit resolution (RED 39380d3 + this GREEN). Architect drift review found a [high] correctness defect: a (lam ...) body capturing an enclosing Term::Loop binder passed ail check (exit 0) then panicked unreachable!() at crates/ailang-codegen/src/lambda.rs:102 on type-correct input — a DESIGN.md "Robustness against hallucinations" violation. Root cause (debugger-confirmed RED-first): the Term::Lam escape guard at crates/ailang-check/src/lib.rs:3608 iterated only mut_scope_stack; loop binders live in the ordinary locals (iter-2 design) and never entered any escape-checked scope, so the mut.4-tidy MutVarCapturedByLambda-class rejection had no loop-binder counterpart. Fix (GREEN, implement mini-mode): new CheckError::LoopBinderCapturedByLambda { name } (bracket-[code]-free F2 Display) + code() loop-binder-captured-by-lambda + ctx() {name}, symmetric to MutVarCapturedByLambda; the Term::Lam escape guard gained a parallel pass over loop_stack (gate widened to !mut_scope_stack.is_empty() || !loop_stack.is_empty()). Minimal-mechanism design call: loop_stack's frame element extended Vec<Type> → Vec<(String, Type)> so the already-threaded per-loop scope frame also carries binder names (Term::Recur still reads .1 BY POSITION — Boss-call-2's positional-recur invariant preserved verbatim, the name is a second field consumed only by the escape guard, a consumer iter-2 did not anticipate; the parallel-stack alternative would touch all 35 synth call sites, strictly larger). Codegen byte-unchanged (typecheck-only fix; the lambda.rs:102 unreachable!() is now genuinely unreachable, kept as a defensive assertion). Two mut.4-tidy-mirrored in-source unit tests; lockstep carve_out_inventory 17→18 + ct1_check_cli mut-F2 sibling cases; DESIGN.md one-line symmetric-rule note. Boss folded into this GREEN commit: the two [medium] doc-honesty edits the audit also surfaced (mut_var_allocas rustdoc now states its mut-var+loop-binder dual use truthfully; Term::Loop doc-comment now describes the real shipped iter-2/3 typecheck+alloca+mem2reg state, not iter-1's stale "per-binder phi" stub forward-look) + a [low] P2 roadmap [todo] (the recon-undercount 3×-pattern → an ailang-plan-recon agent-definition countermeasure; pairs with planner Step-5 items 7+8). Bench gate (audit Step 2): check.py/compile_check.py/cross_lang.py all exit 0, 25 metrics 0 regressed — pristine (strictly-additive surface, no hot-path; the pre-existing P2 *.bump_s hardware-staleness drift did not trip) → carry-on, no baseline/ratify. cargo test --workspace 619→622 / 0 red (Boss-reran independently incl. hash_pin 11/0 — the ast.rs/codegen doc-comment edits moved no canonical-JSON hash). The loop/recur milestone is audit-clean — architect drift cleared, bench pristine; the only remaining pipeline step before full close is fieldtest (loop/recur is user-visible Form-A surface) → 2026-05-17-iter-loop-recur.tidy.md
2026-05-18 — fieldtest loop-recur (milestone CLOSE, clean on all milestone axes): post-audit downstream-LLM-author field test of the shipped loop/recur surface. The fieldtester (DESIGN.md + public examples only, never compiler source) wrote 3 real iterative programs — integer Newton sqrt (multi-binder, recur buried in if/let/if, loop result into let/seq), Collatz length (recur in match-arm tails), Euclidean gcd (loop as a value sub-expression in argument position) — plus 5 plausible-mistake negatives and 2 no-termination probes, all run through the public ail CLI. 0 bugs; 4 working findings, all on the milestone's own axes: the five rejection diagnostics (recur-outside-loop / -arity / -type / -not-in-tail / loop-binder-captured-by-lambda) are point-exact AND self-fixing (name the fn, describe the fix, no false positives, no crash — the clause-2 silent-failure-class-becomes-compile-error claim made real); recur tail-position threads correctly through match-arm/let/outer-if (the spec only demonstrated if — generalises exactly as an author assumes); loop composes as a value sub-expression everywhere + every loop/recur fixture is ail parse|render|parse byte-identical (Roundtrip Invariant holds in practice); the no-termination boundary is exactly as specified (infinite loop check+build clean, zero spurious diagnostics — the precise difference from the reverted Iteration-discipline milestone). This empirically substantiates the milestone's "an LLM author can now write iterative programs with loop/recur" claim — the gate fieldtest exists to provide. Two ORTHOGONAL non-blocking findings surfaced incidentally while probing the no-termination/negative axes, neither in loop/recur scope, both routed to P2 todos (not a loop/recur tidy — refusing the scope creep): (spec_gap) niladic (app f) is unrepresentable in Form A and DESIGN.md's Term::App args:[Term...] states no minimum — INDEPENDENTLY re-confirms the existing mut-local-F3 roadmap todo (two fieldtests now hit it; the accept-(app f)-vs-ratify-DESIGN.md decision is a genuine design fork deliberately NOT auto-ratified under autonomous /boss — parked, priority-strengthened); (friction) the module-level (doc …) rejection lists valid def heads but omits that doc attaches inside fn/data — a one-line diagnostic-hint tidy. Independent Boss verification: loop_recur_4_gcd_value_pos.ail re-run → stdout 27; loop_recur_3a re-run → ail check exit 1 [recur-outside-loop] countdown: …. The standalone loop/recur milestone is fully ratified and CLOSED: 3 iterations + a tidy shipped, audit clean (architect drift resolved, bench pristine carry-on), fieldtest clean on every milestone axis. Fixtures examples/fieldtest/loop_recur_*.ail + spec docs/specs/2026-05-18-fieldtest-loop-recur.md committed; roadmap P0 entry marked closed; the two orthogonal findings tracked as P2 todos → 2026-05-18-fieldtest-loop-recur.md
2026-05-18 — iter prose-loop-binders.1 (single-iteration milestone, DONE): Form-B prose loop now renders binders as a parenthesised init-list on the keyword line — loop(acc = 0, i = 1) { … } — instead of bare name = init; statements inside the body block, which had implied C/Rust re-init-every-iteration semantics. Projection-only single-arm rewrite of the Term::Loop case of write_term (crates/ailang-prose/src/lib.rs); init exprs render at level (keyword line, not the indented block), mirroring the untouched adjacent Term::Recur enumerate()+", " idiom — making the binder list positionally isomorphic to recur(...), which teaches the correct "recur re-binds these positionally" model instead of obscuring it. RED-first via the existing stem-explicit check_snapshot harness: two new committed examples/{loop_sum_to_run,loop_forever_build}.prose.txt whole-file byte-equality fixtures + two snapshot_loop_* #[test] fns, verified 0 passed; 2 failed against the old renderer before the arm rewrite turned them green. Loop/recur AST, Form-A, JSON-AST, typecheck, codegen and the Form-A↔JSON round-trip invariant untouched by construction (no signature change, no caller touched, prose is a one-way lossy projection off the round-trip path — spec §Architecture states this explicitly so milestone-close audit does not chase a phantom). Full ailang-prose suite 10/0; both ail prose | diff live-CLI byte-matches MATCH; post-cleanup porcelain exactly the expected paths. Surfaced from the 2026-05-18 user prose review of the just-closed loop/recur milestone; brainstorm spec docs/specs/2026-05-18-prose-loop-binders.md (Step-7.5 grounding-check PASS), plan docs/plans/prose-loop-binders.1.md. Both implement review phases first-pass, 0 re-loops. Milestone-close audit is the Boss's next pipeline step (projection-only, no Form-A surface change → no fieldtest). → 2026-05-18-iter-prose-loop-binders.1.md
2026-05-18 — audit prose-loop-binders (milestone CLOSE, clean / carry-on): milestone-close tidy for the single-iteration prose-loop-binders milestone (range 6cbd0fe..c9355d7). Architect drift review clean — zero drift, zero debt, verified against the diff not journal trust: single Term::Loop write_term hunk in crates/ailang-prose/src/lib.rs, the two non-render Term::Loop sites + all Term::Recur arms absent from the diff, DESIGN.md/PROSE_ROUNDTRIP.md make no claim about prose loop rendering (so the spec's "no doc edit needed" is correct not a skipped obligation), no carve-out/hash-pin/round-trip lockstep bypassed (prose is off the Form-A↔JSON round-trip path by construction). Bench: compile_check.py 0/24 + cross_lang.py 0/25 both exit 0 (cross_lang's independent ail_bump_s +1.50% ±15% ok corroborates check.py's bump_s firing is baseline-staleness not a real regression); check.py exit 1, first run 3 regressed but a confirmatory identical re-run (no code change) returned latency.implicit_at_rc.p99_9_us +37.30%→+10.22% ok and .max_us +114.14%→+22.17% ok (median/p99 within tol both runs) — the two latency-tail firings proven single-sample 5-run RC-mode jitter by re-run; bench_list_sum.bump_s persisted ~+12% = the already-tracked P2 roadmap todo (byte-oracle-proven environmental at the 2026-05-16 iteration-discipline-revert audit, causally impossible to attribute to a projection-only ailang-prose change). All items carry-on: no fix iteration, no baseline ratify — explicitly NOT bumping the *.bump_s baseline opportunistically inside an unrelated projection-only milestone (the P2 todo owns a holistic recapture; piecemeal bump is the "regression is expected" rationalisation the Iron Law forbids). Fieldtest not applicable / not dispatched: projection-only change to the Form-B reading surface; the fieldtester authors .ail Form-A and would not exercise the prose-render change (no friction/bug/spec-gap axis); the two whole-file byte-equality .prose.txt snapshots + live-CLI ail prose|diff checks are the projection-only E2E gate. Milestone CLOSED clean; roadmap P0 entry flipped [~]→[x], WhatsNew.md user-facing entry appended (user present → no notify.sh fired per notification policy). → 2026-05-18-audit-prose-loop-binders.md
2026-05-18 — iter remove-mut-var-assign.1 (single terminal iteration, DONE): mut/var/assign removed from AILang entirely and atomically — Term::Mut/Term::Assign/struct MutVar, the three Form-A keywords + parse_mut/parse_assign + grammar EBNF, the 4 mut CheckError variants, the mut_scope_stack synth threading (param dropped from synth + every internal/external/test caller), the two lower_term arms, and every exhaustive no-_ Term::Mut/Term::Assign match arm across 17 source files — cut in lockstep with DESIGN.md + fixtures + drift trio + carve-out + roadmap so the schema is honest at every commit (no _ => wildcard introduced — Boss-verified). loop/recur + let/if are the surviving forms. Shared codegen alloca machinery survives (loop reuses it): mut_var_allocas→binder_allocas (representation-only, loop codegen byte-identical) and the shared Term::Lam escape guard simplified to !loop_stack.is_empty() with the loop half (LoopBinderCapturedByLambda) kept byte-equivalent. Feature-acceptance applied inverted (removed feature fails clause 2 redundant + clause 3 IS the iterated-mutable-state bug class). Behaviour-preservation proof executable: mut_counter/mut_sum_floats still print 55 after the faithful let/if rewrite (factorial→120, horner→18, classify 22→2, has_small_factor 91→true); the "removal made executable" gate is the new mut_removed_pin.rs (4 must-fail pins: mut/assign keyword rejected, {"t":"mut"}/{"t":"assign"} serde unknown-variant). Independent Boss verification: full cargo test --workspace 605/0, zero residual mut symbols in any crate source, loop/recur non-regression all green (55 / 500000500000 / infinite-compiles / lambda_capturing_loop_binder pin), roundtrip_cli PASS. One systemic DONE_WITH_CONCERNS — 4th recurrence of the recon-undercount feedback_plan_pseudo_vs_reality class (in-source mod tests fns + a drift-pin fn + 5 orphaned mut .ail.json carve-outs + a non-enumerated codegen_import_map_fallback_pin.rs E0599 the recon missed; all resolved within implementer remit via Task-3's identical whole-file-deletion rationale, no behaviour change, e2e bodies preserved per plan) — worth a planner/recon-agent countermeasure, pairs with the existing loop-recur.tidy P2 todo. Milestone-close audit then fieldtest (surface-touching) are the Boss's next pipeline steps. spec docs/specs/2026-05-18-remove-mut-var-assign.md (grounding-check PASS), plan docs/plans/remove-mut-var-assign.1.md → 2026-05-18-iter-remove-mut-var-assign.1.md
2026-05-18 — audit remove-mut-var-assign (milestone close, CLEAN after one inline .tidy): scope 48e7774..07f0802. Architect drift: one [high] — crates/ailang-core/specs/form_a.md (live in-tree Form-A grammar still documented the full mut/var/assign construct: EBNF 286-288, prose 308-328, dangling like mut at 332); the spec named it for deletion, the iter missed it. Root cause = recon-undercount class 4th recurrence + a Boss error: a plan-time grep checked only docs/form_a.md (dir-scoped), got "No such file", and the Boss propagated that unverified non-existence claim into the recon brief — the real file is crates/ailang-core/specs/form_a.md, actively maintained, and a stale doc never produces a compile error so the implement compile-sweep could not catch it. Fixed inline as a Boss .tidy (CLAUDE.md context-already-loaded carve-out; full review discipline kept — tree-wide verified zero construct residue except the roadmap entry that names the milestone itself; grammar reads coherently reuse-as→loop→recur). One [medium] process-drift: escalated the existing loop-recur.tidy ailang-plan-recon P2 in place — broadened from cross-crate-caller to a structural recon-contract defect with two named gaps (non-compile-checked spec-named sites; unverified "X does not exist" claims inheriting into a recon brief) + a concrete fix (compile-driven enumeration as authoritative code-site set PLUS an ls-verified spec-named-path existence table). Bench: compile_check.py 0/24 + cross_lang.py 0/25 exit 0; check.py exit 1 (3 firings: bench_list_sum.bump_s +12.51%, latency.{explicit,implicit}_at_rc.max_us +108%/+66%). Bencher causal exoneration decisive: HEAD vs 48e7774 list_sum_bump/lat_expl_rc/lat_impl_rc binaries cmp-byte-identical — the −2520-line removal alters zero bytes of these fixtures' machine code, no causal mechanism; bump_s = the tracked P2 environmental staleness, both *.max_us = single-sample -n 5 jitter (explicit_at_rc.max_us +108%→-2.30% ok on identical-code rerun, medians held). PRISTINE met on the merits; NO baseline ratify (Iron Law forbids ratifying noise, spec forecloses it). Filed a NEW distinct P2 (separate from *.bump_s staleness): check.py RC-latency *.max_us at -n 5 is a 3-for-3 structural false-positive on no-runtime-change milestones → drop from gating / raise -n / cpuset-pin. Milestone audit CLEAN; only fieldtest (surface-touching) remains before close → 2026-05-18-audit-remove-mut-var-assign.md
2026-05-18 — fieldtest remove-mut-var-assign (milestone CLOSE, clean — removal thesis empirically confirmed): post-audit downstream-LLM-author field test of the post-removal Form-A surface. The fieldtester (DESIGN.md + form_a.md + public examples only, never compiler source) wrote 4 FRESH real-world programs an imperative-trained author would instinctively reach for a mutable local for — running sum-of-squares accumulator (loop/recur, 2 binders → 385), grade-classification cascade (let-threaded flag through 4 if → 4/2/0), Horner polynomial straight-line build-up (5 let acc shadows → 73), multi-state bracket-balance scanner threading (rest,depth,ok) by tail recursion → true/false) plus an out-of-tree mut-keyword rejection probe. 0 bugs, 0 friction, 0 spec_gap, 4 working: every task expressed cleanly and correctly on the FIRST try with only let/if/loop/recur; all 4 ail parse|render|parse byte-identical. The closest-to-friction case (the multi-state machine must restate the full state tuple at every tail-call even when a branch changes one component) was carefully classified working not spec_gap — that explicit-dataflow cost IS the local-reasoning pillar working as designed, and mut's implicit cross-iteration persistence of un-restated state is precisely the clause-3 failure the removal eliminates; the fieldtester explicitly noted the only conceivable sugar (a record to bundle state) is an orthogonal additive future question, NOT evidence against the removal (refused the scope-creep). The mut rejection is fail-closed with an actively-guiding diagnostic that enumerates the surviving term heads incl. loop/recur/let (no tombstone, no-nostalgia, as spec'd). Independent Boss verification: all 4 fixtures re-run → 385/4 2 0/73/true false, zero mut/var/assign construct tokens in any fixture (a doc-faithful author did not produce the removed construct — the affirmative clause-1 evidence). Verdict: the removal thesis is confirmed — mut was redundant with let/if/loop/recur in 100% of the fresh real tasks; no expressivity lost. The remove-mut-var-assign milestone is fully ratified and CLOSED: spec+plan+iter, audit clean (architect [high] form_a.md fixed in .tidy, bench causally exonerated), fieldtest clean on the removal axis. Fixtures examples/fieldtest/remove-mut_*.ail + spec docs/specs/2026-05-18-fieldtest-remove-mut-var-assign.md; roadmap P0 flipped [~]→[x], WhatsNew.md user-facing entry appended; next queue item (DESIGN.md/docs honesty-lint) is a NEW milestone = a /boss new-milestone bounce-back (not auto-started) → 2026-05-18-fieldtest-remove-mut-var-assign.md
2026-05-18 — iter docs-honesty-lint.1 (single-iteration milestone, DONE): canonical docs made present-tense-honest. Stripped Wunschdenken (forward intent stated as fact) + non-citation post-mortem/doc-archaeology from docs/DESIGN.md (14 corrections: L484 iter-anchor, L503/L1318/L1504/L2027/L2065/L2135 post-mortem, L650 malformed-Wunschdenken, L655 dated-heading, L1513/L1837/L2046/L2519 Wunschdenken, + the Task-4-Step-14 procedural-catch-all FIX at the Form-B prose-projection bullet "was deferred from milestone 22 entirely … A future iter ships" — a soft-wrapped site the spec's illustrative regex would have missed, the procedural enumeration working exactly as designed) + docs/PROSE_ROUNDTRIP.md (tool-use/MCP paragraph); genuine forward intent (LLM tool-use/MCP/LSP) relocated to roadmap P3. Codified the two-pronged tense+modality discriminator as a present-tense ### What this document is — and the honesty rule it holds itself to meta-subsection in DESIGN.md §"Project ecosystem". Anti-regrowth two ways: wrap-robust enumerated absent/present pin crates/ailang-core/tests/docs_honesty_pin.rs (a norm() whitespace-collapse helper structurally discharges the recurring grep/contains line-wrap failure family — strictly better than the effect-doc-honesty "keep-on-one-line" precedent; resolves spec Testing-item 0 + planner self-review item 6 at once) + wrap-robust advisory Sweep 5 in bench/architect_sweeps.sh (contiguous-fragment regex, since DESIGN.md is hard-wrapped ~70col) with full sweep-count lockstep (header + "All four"→"All five" tail + ailang-architect.md "four"→"five sweeps") + a new ailang-architect.md "DESIGN.md honesty drift" bullet citing the meta-subsection. Protected-exception KEEPs preserved + pinned-present (Diverge-reserved, regions-considered-and-rejected, the self-labelled "tiebreaker, not a rationale"); form_a.md correctly left untouched/unpinned. One plan-internal DONE_WITH_CONCERNS (Task-1 pin string omitted a **…** bold the Task-3 body added; resolved by dropping the non-load-bearing emphasis, pin is the contract) — planner self-review-item-3 calibration note. Independent Boss verification: pin 4/4 GREEN, full cargo test --workspace 0 failures (delta = +4 pin tests only), sentinel trio (design_schema_drift/spec_drift/schema_coverage) green, cargo build --workspace clean, scope = ONLY THE PIN in crates/ (zero language/checker/codegen/runtime change, ail check/run/build byte-unchanged by construction). Post-iter sweep residue = only the 3 documented deliberate KEEPs (Sweep-1 L50 doc-roles-pointer date + L2060 true (iter str-concat) provenance; Sweep-5 L62 self-referential discriminator-catalogue), EXIT=1 architect-adjudicated-expected. Milestone-close audit is the next pipeline step (no fieldtest — zero authoring-surface change). spec docs/specs/2026-05-18-docs-honesty-lint.md (grounding-check PASS 10/10), plan docs/plans/docs-honesty-lint.1.md → 2026-05-18-iter-docs-honesty-lint.1.md
2026-05-18 — audit docs-honesty-lint (milestone close, CLEAN — carry-on, NO ratify): scope 928e1c0..e50b400. Architect clean: scope claim exact (zero crates/**/src/** + runtime/; sole crates/ change the additive RED-first-now-GREEN docs_honesty_pin.rs; lockstep pairs untouched), all 14 DESIGN.md corrections genuinely present-tense with the 4 protected KEEPs (Diverge-reserved/Regions-rejected/tiebreaker/No deriving) un-stripped, agent-def "four→five" lockstep complete, sweep residue exactly the 3 documented deliberate KEEPs. One [medium] standing advisory wart — Sweep 5's regex self-matches the discriminator subsection's own forbidden-phrasing catalogue (DESIGN.md L62) forever (architect-flagged; orchestrator-adjudicated → filed as a P3 todo, NOT a fix iteration — not a new failure mode since the script is advisory-with-residue by design). Bench: compile_check.py 0/24 + cross_lang.py 0/25 EXIT 0 (cross_lang independently reads the same bench_list_sum bump path +5.95% within tol); check.py EXIT 1, 3 firings (bench_list_sum.bump_s +13.42%, latency.implicit_at_rc.{p99_9,max}_us +37.65%/+134.70%). Bencher causal exoneration decisive: HEAD vs 5bb7211 vs de66eb7 — all 5 firing bench binaries cmp-byte-identical, ail sha256 identical at all three commits ⇒ zero causal mechanism; *.max_us = tracked-P2 -n 5 tail-jitter (4th occurrence on a zero-runtime-change milestone, median/p99 rock-steady), *.bump_s = tracked-P2 environmental-anchor-staleness (persistent ~+15%, stale 0.046s anchor). EXONERATED, NO baseline ratify (Iron Law forbids ratifying noise; spec forecloses a zero-codegen baseline bump). Two pre-existing standing P2 items kept orchestrator-owned, explicitly NOT bundled into this close (bencher recommendation honoured). Milestone audit CLEAN; no fieldtest (zero authoring-surface change — the wrap-robust pin + Sweep 5 ARE the regression coverage). docs-honesty-lint fully ratified and CLOSED: spec (grounding-check PASS 10/10) + plan + single iter + audit clean; roadmap P0 flipped [~]→[x], WhatsNew.md user-facing entry appended → 2026-05-18-audit-docs-honesty-lint.md
2026-05-18 — iter embedding-abi-m1.1 (Embedding-ABI M1, DONE across 2 dispatches + a Boss plan Repair): a compiled AILang scalar fn is now callable in-process from a C/Rust host. Five pipeline layers shipped: additive FnDef.export: Option<String> (serde default+skip_serializing_if, modelled on FnDef.doc, ~85-site compile-driven thread incl. all in-source #[cfg(test)]/drift/hash literals, hash-stable golden b4662aa70839f60b); Form-A (export "<sym>") modifier (parse/print/form_a.md lockstep, byte-identical round-trip); check-side scalar-only+effect-free export gate — two new CheckError Error variants export-non-scalar-signature/export-has-effects, params→ret→effects first-violation-wins, unconditional on f.export.is_some() (the feature-acceptance clause-3 discriminator in code); codegen Target::StaticLib (suppresses @main+MissingEntryMain, emits one external @<sym> forwarder per export to @ail_<module>_<fn>); CLI ail build --emit=staticlib (build_staticlib: libembed_backtest_step.a program-only + separate libailang_rt.a). Coherent stop PROVEN: embed_e2e.rs cc-links both archives, backtest_step(0,3)=9/(9,4)=25, s==25, exit 0. Task 1 (fixed-first CLI MissingEntryMain baseline pin) green before any staticlib code. Process: Task 4 BLOCKED on the first dispatch — a Boss plan-defect (gate/headline fixtures declared module ≠ file-stem; the loader hard-enforces module==stem at workspace.rs:438, so ail check panicked on load before the gate). Boss verified, chose Option 2 over the orchestrator-recommended Option 1 (keep descriptive embed_* filenames, rename fixture modules to their stems — the C symbol backtest_step stays via (export …), demonstrating spec Decision 2's mangling-decoupling rather than violating it; archive→libembed_backtest_step.a, internal→@ail_embed_backtest_step_step, host.c unchanged), Repaired the plan (Design-decision 6 + Task-4 module==stem + Task-5/6/7 dependent strings + folded the no-*.-Float-head and content_hash_fn→def_hash concerns), committed Tasks 1–3 as a verified known-good partial (818177d), re-dispatched [4,7]. Independent Boss verification post-completion: E2E 1/1, gate 6/6, lowering 2/2, CLI 2/2, full cargo test --workspace 0 failures, roundtrip_cli+design_schema_drift+spec_drift green, Invariant 1 holds (no new dep in ailang-core/ailang-codegen/runtime). 3 behaviour-neutral plan pseudo-vs-reality concerns recorded (emit_ir routes via lower_workspace; dead Path import dropped; ## vs ### heading). Bench: compile_check.py/cross_lang.py exit 0; check.py exit 1 = tracked-P2 *.bump_s/*.max_us known-noise (default-exe codegen/runtime byte-unchanged — audit-adjudicated, not a plan gate). spec docs/specs/2026-05-18-embedding-abi-m1.md (grounding-check PASS) → plan docs/plans/embedding-abi-m1.1.md (Repaired) → commits 818177d (partial 1–3) + this completion. Milestone-close audit then fieldtest (surface-touching — (export …) is new authoring surface) are the next pipeline steps. → 2026-05-18-iter-embedding-abi-m1.1.md
2026-05-18 — audit embedding-abi-m1 (milestone close, CLEAN — carry-on, NO ratify): scope 064599e..e406d07. Architect clean — Invariant 1 (clean core) holds semantically (no finance/data-server vocab/logic/dep in ailang-core/ailang-codegen/runtime; backtest_step is an opaque author string through generic FnDef.export; AILang↔host meeting point correctly M5-deferred), DESIGN.md honesty satisfied (§"Embedding ABI (M1)" + fn-JSON "export" + field rustdoc present-tense; "provisional until M3"/"M2 changes the C sig" correctly labelled reserved-unimplemented), lockstep intact (FnDef↔fn-JSON↔drift/spec-drift carry the field; @<sym> forwarder additive raw-IR beside unchanged @ail_<module>_<fn> mangling — not through lower_app; schema exhaustively-constructed, no _=>/..Default; in-source missing_entry_main_is_error byte-unchanged; _adapter/_clos untouched), Design-decision 6 confirmed correct (fixture module==stem differs from the spec's illustrative (module backtest)/(module bad) by the loader invariant + spec Decision 2 — the fixtures demonstrate the C-symbol decoupling, not violate the spec). One [low] — ~85 export: None, lines brace-column-indented (rustfmt-divergent) — orchestrator-adjudicated carry-on on evidence (not pending, not ignored): cargo fmt --all --check shows 1137 fmt-divergent locations tree-wide predating M1, so rustfmt is demonstrably not a project convention and the architect's "cargo fmt would churn later" premise is moot; selectively aligning 85/1137 would impose an absent standard (noise, not tidy). Bench: compile_check.py 0/24 + cross_lang.py 0/25 EXIT 0; check.py EXIT 1, 7 firings (*.bump_s trio +12–14%; explicit_at_rc/implicit_at_rc p99_9/max_us +36–124%). Bencher causal exoneration decisive: 21/21 bench binaries cmp-byte-identical 064599e↔e406d07 (bench_list_sum_bump sha dce18c288904c9f0 both) — M1's Target::Executable default leaves every bench fixture's emitted machine code unchanged ⇒ zero causal mechanism; RC-latency tails reproduce on the byte-identical oracle itself (3× run-to-run swing, median/p99 steady = -n 5 single-sample jitter); fresh re-run collapsed 6/7 firings to ok. Both families map (confirmed) onto the two pre-existing roadmap-P2 tracked items (~4th zero-runtime-change milestone they fire+collapse on). EXONERATED, NO baseline ratify (Iron Law forbids ratifying noise against a zero-default-path-byte iter; spec forecloses a zero-codegen baseline bump); the two P2 bench-harness-recalibration items stay orchestrator-owned, NOT bundled (bencher recommendation honoured). M1 milestone audit CLEAN; fieldtest (surface-touching — (export "<sym>") is new authoring surface) is the next pipeline step before close → 2026-05-18-audit-embedding-abi-m1.md
2026-05-18 — fieldtest embedding-abi-m1 (milestone CLOSE, surface-touch — thesis substantiated, 3 non-blocking follow-ups routed): post-audit downstream-LLM-author field test of M1's (export "<sym>") + ail build --emit=staticlib + scalar/effect-free gate, DESIGN.md + public examples only (never compiler source). 4 fresh programs: Int fixed-point EMA (State,Sample)->State fold + Float leaky integrator (both author→--emit=staticlib→C-host link→typed scalar return, s==67/s==1.875, exit 0 — clause-1 confirmed first-try), IntList-param export (correctly rejected export-non-scalar-signature), !IO scalar-clean export (correctly rejected export-has-effects) — clause-3 confirmed, both diagnostics precise+self-correcting. 0 bugs; the M1 capability + gate are sound and the milestone thesis ("an LLM author makes a scalar fold callable") is empirically substantiated. 3 working + 1 friction + 2 spec_gap. The friction + spec_gap#1 share a root: crates/ailang-core/specs/form_a.md "Schema invariants" item 1 + Pitfalls state an unconditional "every fn param MUST be (own/borrow T)" but scalars require bare (con Int) ((own (con Int))→use-after-consume, (borrow)→consume-while-borrowed); the doc the LLM reads first misdirects M1's headline task into a body-pointing linearity diagnostic — a pre-existing form_a.md docs-honesty defect M1 made acute, not introduced (the positive examples only succeeded because the fieldtester imitated the public embed_* corpus over the form_a.md prose rule). spec_gap#2: no public emit-ir --emit=staticlib though Decision 5 makes kernel-IR readability load-bearing. Boss independently re-verified via the public CLI (positive E2E builds both archives; both rejections fire the documented codes). Orchestrator routing (own judgement, not the fieldtester's recommended-action column): friction+spec_gap#1 → ONE P1 [todo] docs-honesty tidy (form_a.md scalar-param carve-out symmetric with the existing return-type carve-out + DESIGN.md mirror; behaviour settled → tidy, no brainstorm; ahead of M2 because it undermines the clause-1 ergonomics of the surface M2–M5 extend); spec_gap#2 → P1 [feature] add --emit=staticlib to ail emit-ir (restore the affordance, NOT narrow DESIGN.md). None are bugs (no debug); none M1-blocking. embedding-abi-m1 fully ratified and CLOSED: spec (grounding-check PASS) + plan (Boss-Repaired) + iter (818177d partial+Repair / e406d07 DONE) + audit 425c4eb CLEAN + fieldtest thesis-substantiated; roadmap P1 [~]→[x], 2 follow-ups added P1-ahead-of-M2. Next milestone is Embedding ABI — M2 (no spec) = a /boss new-milestone bounce-back (not auto-started); the 2 P1 follow-ups are autonomous-eligible tidies/feature but the session is context-deep — surfaced to the user for the session-shape/next-item call. → 2026-05-18-fieldtest-embedding-abi-m1.md
2026-05-18 — iter form-a-scalar-param-mode-carveout (M1-fieldtest follow-up #1, docs-honesty tidy in the docs-honesty-lint class, DONE): resolved the M1 fieldtest [friction] + [spec_gap]#1 shared root. crates/ailang-core/specs/form_a.md stated an unconditional "every (fn ...) param MUST carry an (own/borrow) mode" rule in four places (### Function prose L97, grammar-block comment L230, "Schema invariants" item 1 L347, Pitfalls bullet L382) that contradicts shipped checker behaviour — scalar Int/Bool/Unit/Str params take and require bare (con Int) (a mode on a scalar makes the linearity pass hold the primitive to linear discipline → body-pointing use-after-consume/consume-while-borrowed, the exact fieldtest misdirection). All four sites rewritten symmetric to the pre-existing return-type carve-out; site 5 (L521 few-shot annotation) already correct, left verbatim by design (carve-out reuses its heap-shaped/primitive vocabulary for end-to-end internal consistency). docs/DESIGN.md §"Embedding ABI (M1)" gained the bare-scalar export-param rule + a corpus-grounded step Form-A snippet (byte-identical to examples/embed_backtest_step.ail:3-11). RED-first anti-regrowth pin form_a_scalar_param_carveout_present_and_old_rule_absent in crates/ailang-core/tests/docs_honesty_pin.rs (reads the canonical ailang_core::FORM_A_SPEC include_str! const — single-source, compile-checked — + read("docs/DESIGN.md"); norm() whitespace-collapse structurally discharges the grep/contains line-wrap family; 4 ABSENT + 4 PRESENT form_a + 1 PRESENT DESIGN). Boss scope calls: 4 form_a sites not 2 (internal-consistency, on the merits — a tidy whose thesis is "consistent current-state mirror" cannot fix some and leave others contradicting); pin idiom = FORM_A_SPEC const (semantic single-source, not effort). spec_drift.rs recon-confirmed NOT a lockstep partner (anchors are short keyword tokens; (own/(borrow survive an additive carve-out). Zero language/checker/codegen change by construction; independent Boss verification: docs_honesty_pin 5/0, spec_drift 8/8, ailang-core 112/0, workspace 622→623 (+1 = the pin), zero crates/**/src/** diff. spec carrier docs/specs/2026-05-18-fieldtest-embedding-abi-m1.md + roadmap P1 entry → plan docs/plans/form-a-scalar-param-mode-carveout.md (4c266a6). Pure docs+pin tidy — no audit/fieldtest gate (zero authoring-behaviour change; the pin IS the regression coverage). → 2026-05-18-iter-form-a-scalar-param-mode-carveout.md
2026-05-18 — iter emit-ir-staticlib (M1-fieldtest follow-up #2, scoped [feature], DONE): resolved M1 fieldtest [spec_gap]#2 — ail emit-ir had no --emit=staticlib (only ail build did) and on a main-free kernel hit the executable-path MissingEntryMain rejection, so an author could not read the generated @<sym> forwarder for an exported kernel — the exact Decision-5 IR-readability affordance, for the exact artefact M1 introduced. Added a one-line symmetric codegen convenience lower_workspace_staticlib(ws) (mirrors lower_workspace: --emit=exe↔lower_workspace, --emit=staticlib↔lower_workspace_staticlib; delegates to the M1-audited unchanged Target::StaticLib forwarder path), an emit: String clap field on Cmd::EmitIr symmetric with Cmd::Build's, and a zero-export guard byte-identical to build_staticlib's (so the error is symmetric across both subcommands and the existing embed_staticlib_cli.rs substring assertion holds for both). Recon resolved the only integration risk negative (both codegen entrypoints return Result<String>, the emit-ir printer already consumes String — no adapter). DESIGN.md widened not narrowed (roadmap resolution honoured): a present-tense affordance sentence in §"Embedding ABI (M1)" + a CLI-synopsis correction that also discharges a pre-existing M1 omission (ail build --emit=staticlib was never in the synopsis). Boss editorial calls: synopsis fixes BOTH lines (docs-as-current-state-mirror consistency, on the merits); NO new docs pin (the E2E pins behaviour; the architect's mandatory DESIGN.md read at milestone close catches stale prose — pinning every feature sentence is noise); Decision-5 prose left untouched (already present-tense correct). New E2E crates/ail/tests/emit_ir_staticlib_cli.rs (3 tests: positive — IR contains external @backtest_step( + internal @ail_embed_backtest_step_step, NOT @main(, NOT has no main def; zero-export guard symmetric with build's, reusing the identical embed_noentry_baseline.ail fixture; default-exe regression — --emit defaults to exe, a main-free kernel without the flag still hits MissingEntryMain, so the new branch cannot silently reroute the default path). RED-first observed exactly ("1 passed; 2 failed" pre-edit — the default-exe test passes because that IS the spec_gap behaviour). Independent Boss verification: the 3 new tests 3/0, embed_staticlib_cli 2/0 (build-side untouched), docs_honesty_pin 5/0 (no regression), ail suite 186/0, workspace 623→626 (+3 = exactly the new tests), zero diff outside the 4 in-scope paths, no fixture minted. Functional spot-check from the user-facing CLI: ail emit-ir examples/embed_backtest_step.ail --emit=staticlib emits define i64 @backtest_step(...) (the readable external forwarder) + @ail_embed_backtest_step_step (internal), no @main — the affordance is genuinely delivered. spec carrier docs/specs/2026-05-18-fieldtest-embedding-abi-m1.md [spec_gap]#2 + roadmap P1 entry → plan docs/plans/emit-ir-staticlib.md (03493c9) → iter this commit. Scoped feature, no audit/fieldtest gate (the E2E is the coverage; no authoring-surface or invariant change — reuses the M1-audited codegen path). → 2026-05-18-iter-emit-ir-staticlib.md
2026-05-18 — iter embedding-abi-m2.1 (Embedding ABI — M2, DONE 9/9 across one Boss-repaired split dispatch): per-thread runtime context + concurrency safety. No authoring-surface change (the .ail is byte-identical to M1); the deliverable is a swarm-safe generated C ABI + de-globalised runtime, sanitiser-verified. Shipped: runtime/rc.c gains ailang_ctx_t {alloc_count,free_count} + ailang_ctx_new/_free + __thread __ail_tls_ctx, the two increment sites become if (_ctx) _ctx->… else g_rc_… (the g_rc_* statics + ailang_rc_stats_atexit + constructor RETAINED VERBATIM as the null-ctx single-threaded executable fallback — print_no_leak_pin/e2e rc_stats stay green unmodified); codegen Target::StaticLib forwarder gains a mandatory leading ptr %ctx + one @__ail_tls_ctx = external thread_local global ptr decl + TLS save/store/restore around the BYTE-UNCHANGED internal @ail_<mod>_<fn> call (_adapter/_clos + internal arg vector untouched — M1 decision held; the frozen-at-M3 surface is the C @<sym>(ctx,…) signature, internal convention free); build_staticlib rejects --alloc != rc (RC-only swarm artefact, no shared Boehm collector by construction; default already rc; P2 Boehm-retirement untouched); DESIGN.md §"Embedding ABI (M1)" updated to post-M2 current state (provisional-until-M3 narrowed to the value/record layout; Decision-10 per-thread-ctx atomicity note) with the docs_honesty-pinned "Export parameters are written bare…" sentence + (con Int) snippet preserved verbatim; M1 host.c/embed_e2e migrated to the ctx ABI (s==25 holds). Coherent stop sanitiser-verified by the Boss directly (not inferred): per-thread-ctx scalar swarm -fsanitize=thread-clean with every thread == serial oracle (capability demo); direct rc-accounting per-ctx exit 0 / 0 tsan warnings (de-globalisation positive); shared-ctx negative control a genuine ThreadSanitizer: data race at rc.c:157 (_ctx->alloc_count++ in ailang_rc_alloc) + rc.c:208 (_ctx->free_count++ in ailang_rc_dec), exit 66 — teeth non-vacuous, precisely targeting the de-globalised counters. Process note: the first dispatch (Tasks 1–4 clean, committed c9a84b3 as the known-good subset) correctly BLOCKED on Task 5 having surfaced a genuine spec defect — the original Task 5 paired a -DSHARED_CTX negative control onto swarm.c, structurally impossible because a non-allocating scalar kernel writes no ctx field and __ail_tls_ctx is __thread (the spec's OWN item-1 honesty point). Boss adjudication (not a brainstorm bounce — a consistency-repair of an internally-contradictory clause whose intent is already realised by item 1): spec amended in lockstep (Goal coherent-stop, must-fail-axis item 2, Testing item 3, Acceptance) so the negative-control teeth are item-1's by the de-globalisation-proof / capability-demo split; plan Task 5 restructured (swarm.c per-ctx capability demo only; negative control relocated into the item-1 rc_accounting harness driver) + Task-3 plan-transcription error corrected (@ail_backtest_step→@ail_embed_backtest_step_step); re-dispatch [5,9] DONE. spec docs/specs/2026-05-18-embedding-abi-m2.md (user-approved, grounding-check PASS 9/9, 1c58055) → plan docs/plans/embedding-abi-m2.1.md (b3388c8, Boss-corrected) → iter c9a84b3 (PARTIAL 4/9 + Boss repair) + this commit (DONE 5–9). Known debt routed: DESIGN.md ## Embedding ABI (M1) section header still says "(M1)" while the body now mirrors M2 — out of Task 7's scope-limited edit regions by design (preserve the docs_honesty_pin), a post-audit doc-honesty tidy candidate. Milestone-close audit next. → 2026-05-18-iter-embedding-abi-m2.1.md
2026-05-18 — audit embedding-abi-m2 (milestone close — DRIFT: one [medium]+[low] doc-honesty item → tidy; bench exit 1 causally exonerated, NO ratify): architect drift_found — no DESIGN.md/spec-contract drift, Invariant 1 intact, internal-convention byte-invariant, Decision-10 atomicity note present-tense-correct (sanitiser-verified), lockstep complete, docs_honesty_pin green, no unrequested extras, Boss spec-defect repair correctly reflected; the ONE actionable item is [medium] DESIGN.md:2266 — section header still ## Embedding ABI (M1) while the body now mirrors the post-M2 ctx ABI present-tense (current-state-mirror honesty mismatch; NOT a Sweep-5 catch — header/body desync only a read finds; iter-journal Known-debt flagged it truthfully, Task-7-scope-deferred to preserve the docs_honesty_pin:135 verbatim sentence) + coupled [low] DESIGN.md:2354 stale see §"Embedding ABI (M1)" xref. Bench: check.py exit 1 (3 regressed: bench_list_sum.bump_s +13.57%, latency.explicit_at_rc.max_us +81.96%, latency.implicit_at_rc.max_us +38.57%), compile_check/cross_lang exit 0 clean (every rc_over_c ratio within tol). M2 genuinely changed the benched runtime path (rc.c null-ctx-fallback branch), so byte-identical exoneration did NOT apply → ailang-bencher dispatched: swapped only rc.c pre-M2↔HEAD, disassembled the delta (3 branchless insns mov %fs/test/cmovne), interleaved core-pinned A/B — H0 refuted, all 3 firings tracked-noise causally-exonerated: bump_s causally impossible from M2 (bump_malloc 0 rc-counter refs; reproduces +12% on M2-inert code = P2 *.bump_s stale-baseline), the rc.c hunk compiled branchless + measured free (HEAD −0.63% median), max_us median/p99 flat across rc.c variants + non-reproducible within a fixed binary (3.2× spread) = P2 *.max_us -n5 structural false-positive (4th consecutive null-attributable firing). NO baseline ratified (not M2 artefacts; P2 items stay separately tracked). Resolution: [medium]+[low] → tidy iter embedding-abi-m2.tidy (header rename + :2354 xref + docs_honesty_pin.rs:134–136 (M1)-token lockstep; the pinned :135 substring stays verbatim); bench → carry-on. Milestone substantively closed + sound (capability sanitiser-verified, all contract invariants held); roadmap []→[x] follows the tidy landing clean. → 2026-05-18-audit-embedding-abi-m2.md
2026-05-18 — iter embedding-abi-m2.tidy (M2 audit [medium]+[low] doc-honesty fix, DONE 1/1, zero re-loops): lockstep-renamed the DESIGN.md section ## Embedding ABI (M1) → ## Embedding ABI (current-state-mirror — the body had described the post-M2 ctx ABI present-tense while the header still carried the milestone tag) across all 5 live-coupling sites: docs/DESIGN.md:2266 (header) + :2354 (schema-block see §"Embedding ABI" xref), crates/ailang-core/tests/docs_honesty_pin.rs:134 (comment) + :136 (assert-message), and the Boss-added 5th site crates/ailang-core/specs/form_a.md:89 (a live forward-xref into the renamed section in the compiled-in FORM_A_SPEC — same dangling-xref class as :2354, surfaced by the plan-recon-undercount countermeasure, NOT in the architect's named 3-site scope; Boss folded it in on the merits because leaving it stale is a half-rename contradicting the tidy's own thesis). The docs_honesty_pin.rs:135 asserted substring (the DESIGN.md body sentence "Export parameters are written bare…", 31 lines below the header, section-name-free, file-wide d.contains) is rename-immune and stayed byte-verbatim untouched — recon proved this definitively pre-plan; the diff confirms :135 is unchanged context between the :134/:136 hunks. Committed append-only history (journals/specs/plans/orchestrator-stats) NOT falsified — Boss-verified the diff footprint is exactly the 3 content files + journal + stats, zero history files. Pure docs/test-string tidy, zero language/checker/codegen/schema change; no audit/fieldtest gate (the docs_honesty_pin IS the regression guard — Boss-verified 5/0 before AND after, design_schema_drift 8/0, the :2354 edit moved no JSON-schema drift anchor). Recon also corrected an audit inaccuracy (the :2354 xref IS inside the ## Data model window :2319–2558, not outside — non-blocking, the xref string is not a drift anchor). audit source docs/journals/2026-05-18-audit-embedding-abi-m2.md (ad88dec) → plan docs/plans/embedding-abi-m2.tidy.md (d1241b1) → iter this commit. → 2026-05-18-iter-embedding-abi-m2.tidy.md
2026-05-18 — iter embedding-abi-m3.1 (Embedding ABI — M3, DONE 7/7 across one Boss-repaired split dispatch): freeze the value layout + a single-constructor record of Int/Float fields crosses the C ABI in and out, ownership following the declared own/borrow mode. No authoring-surface / schema / Form-A / CheckError change (M2-style — the .ail is the minimal evolution of the M1/M2 scalar kernel into a record State, existing data+(own (con T))+(export …)). Shipped: the export-gate scalar predicate is_c_scalar widened to a two-level is_c_abi_type (a bare Int/Float, OR a Type::Con resolving via the in-scope env.types to a single-constructor data whose every field is a bare Int/Float — NOT deep: a record-typed field stays rejected = M4; multi-ctor sums / Str / List / effectful stay RED; the M1 embed_export_adt_ret_rejected.ail must-fail RE-POINTED from the now-M3-valid single-ctor Pair to a genuinely-still-rejected multi-ctor+Str Reading, the pin's meaning sharpened not silently inverted; gate suite 10/10); codegen llvm_scalar maps a gate-guaranteed record Type::Con → ptr (the M2 Target::StaticLib forwarder body BYTE-UNCHANGED — a record crosses as a bare ptr, no sret/byval; all mode-driven RC stays in the byte-unchanged internal @ail_<mod>_<fn>; 3/3 staticlib-lowering pins, no fn_scalar_sig signature change so no caller ripple); the record memory layout FROZEN as a one-way commitment — DESIGN.md §"Embedding ABI" gains a ### Frozen value layout (M3 — one-way commitment) SSOT subsection (header@p-8 / i64 tag@0 / fields i64-strided@8+i8 / size=8+n8 / ailang_rc_alloc construction MUST / ailang_rc_dec host-free leak-free because scalar-field / ownership follows the declared mode), the two "provisional until M3" sentences rewritten to one-way-freeze wording, lockstep // FROZEN ABI pointers added at the three independent encoders (runtime/rc.c, match_lower.rs lower_ctor, drop.rs), 3 stale rustdocs fixed (codegen/lib.rs, core/ast.rs, the Concerns-carry check/lib.rs:448-450 variant doc) + the Boss-caught stale // gate-comment block (check/lib.rs:1917-1922, "M1/scalar-only" → "M1/M2/M3 / C-ABI-permitted incl. single-ctor record"); a new @ailang_rc_alloc heap-box byte-pin (embed_record_layout_pin.rs) proven RED-on-offset-perturbation / GREEN-on-restore (the freeze made enforceable, not aspirational); the (State,Float)->State record fold E2E round-trip proven globally leak-free for BOTH own and borrow. Process note: the first dispatch (Tasks 1–4 clean) correctly BLOCKED on Task 5 having surfaced a genuine spec defect — the spec's proof instrument asserted the single ailang_ctx_free ctx readback shows allocs==frees, structurally unsatisfiable for borrow (and only coincidentally passing for own) because M2's __ail_tls_ctx is bound only for the synchronous forwarder call, so host-side ailang_rc_decs land on g_rc_* not ctx. Boss adjudication (M2.1-precedent class — genuine spec defect, deliverable+invariant sound, only verification mechanics mis-specified, first BLOCKED task not 2+-in-family ⇒ consistency-repair not a brainstorm bounce): Boss independently rebuilt+ran both modes and confirmed globally leak-free + value-correct (own ctx live=0/g_rc live=0; borrow ctx live=+N/g_rc live=−N, Σlive=0; exit 0 both); spec amended (dated repair note + §"Testing strategy" 3/4 + §"Coherent stop" → global-leak-freedom proof model, the M2-TLS cross-attribution documented as correct behaviour) + plan amended (harness sums ALL ailang_rc_stats: lines) + the mechanical code repair applied; partial committed d5c565d (PARTIAL 5/7 + Boss spec-defect repair); re-dispatch task_range:[6,7] DONE. No fresh grounding-check (the repair removes an over-strong measurement assumption, adds none about compiler behaviour). Independent Boss verification: workspace 639/0, embed_record_e2e 2/2 (own+borrow global model), byte-pin 1/1, gate 10/10, forwarder 3/3, docs_honesty_pin 5/5 pin-safe (the freeze rewrite kept the pinned "Export parameters are written bare…" sentence byte-verbatim+contiguous, shifted :2297→:2299, content-asserted), design_schema_drift/embed_export_hash_stable/embed_e2e/M2 swarm regression-green-unmodified. spec docs/specs/2026-05-18-embedding-abi-m3.md (user-approved, grounding-check PASS 8/8, 1fbb9c4) → plan docs/plans/embedding-abi-m3.1.md (15ee3c5, Boss-amended) → iter d5c565d (PARTIAL 5/7 + Boss repair) + this commit (DONE 6–7). Milestone-close audit next (architect Invariant 1 + bench trio — spec Testing items 8/9, explicitly NOT the implement run's job). → 2026-05-18-iter-embedding-abi-m3.1.md
2026-05-18 — audit embedding-abi-m3 (Embedding ABI — M3 milestone close — DRIFT: one [medium]+[low] doc-honesty → one tidy; bench check.py exit 1 decisively causally exonerated, NO ratify): architect drift_found — Invariant 1 clean (zero Cargo/runtime dep change; core/codegen/runtime touches only the spec-scoped widen + lockstep comments + pins; no data-server/finance knowledge), the M1/M2 internal-convention byte-invariant held (M2 forwarder body + @ail__/_adapter/clos absent from the diff — the spec's load-bearing "transparent ptr pass-through" claim verified), the frozen-layout SSOT (DESIGN.md ### Frozen value layout :2321-2359) present-tense + matching match_lower.rs lower_ctor (size=8+n8/tag@0/fields@8+i8) AND the enforcing byte-pin (@ailang_rc_alloc(i64 24)/tag@0/@8/@16), all three // FROZEN ABI lockstep pointers aimed at the SSOT, the Boss spec-consistency repair note + Testing 3/4 + journal Boss-adjudication/Re-dispatch mutually consistent and honest about the M2-TLS cross-attribution (correct behaviour, not a leak), no new CheckError/schema/Form-A (M2-style honoured). Two residual doc-honesty drift items, both milestone-owned: [medium] DESIGN.md:2299-2302 — a surviving M1-era paragraph asserts modes "apply only to heap-shaped types, which the scalar-only rule above forbids at an export boundary anyway", now self-contradicting the section's own freeze (:2280-2284 was rewritten to accept a single-ctor record — there is no scalar-only rule) and the (own/borrow (con State)) mode contract at :2345-2351 → fix (docs-honesty tidy); [low] crates/ailang-codegen/src/lib.rs:608-610 — forwarder-body comment still says the gate "guarantees Int/Float; map Int→i64 Float→double", now false (records→ptr), classified by the architect "carried debt, not a scope miss" (the body is contractually byte-frozen so the comment was outside any M3 edit region; comment-only, no emitted-IR change) → fix, folded into the same tidy. (The Boss had already caught+fixed one sibling stale // gate-comment block at check/lib.rs:1917-1922 during the DONE inspect; architect found no further siblings.) Bench: check.py exit 1 (3 regressed: throughput.bench_list_sum.bump_s +12.62%/tol10; latency.implicit_at_rc.p99_9_us +28.45%/tol25; .max_us +35.18%/tol30), compile_check exit 0 (24/0), cross_lang exit 0 (25/0, every rc_over_c within tol). The 3 firings are the two standing tracked P2 noise families (the *.bump_s ~+5-13% stale-baseline + the *.max_us/p99_9 -n5 tail-jitter structural false-positive — signature: same bench median +5.11% ok / p99 +15.08% ok, only the extreme tail quantiles fire). DECISIVE causal exoneration (M2-audit method, not hand-waved): M3 changed no executable-path codegen (the llvm_scalar record→ptr arm is reachable only for an (export) single-ctor record; no bench* program has an (export)), so built ail at HEAD and at pre-M3 9a609ae in an isolated worktree and cmp'd the GENERATED IR — byte-identical for bench_list_sum, bench_list_sum_explicit, bench_latency_implicit, bench_tree_walk; the IR is what is handed to deterministic clang -O2, so the bench binaries are byte-identical and M3 causation is logically impossible. NO baseline ratify (not M3 artefacts; the two P2 todos stay separately tracked). Resolution: [medium]+[low] → one docs-honesty tidy iter embedding-abi-m3.tidy (pin-safe re docs_honesty_pin.rs:135, planner Step-5 item-6 / M2.tidy precedent), routed planner→implement; bench → carry-on. Milestone substantively closed + sound; roadmap [~]→[x] follows the tidy landing clean. → 2026-05-18-audit-embedding-abi-m3.md
2026-05-18 — iter embedding-abi-m3.tidy (M3 audit [medium]+[low] doc-honesty fix, DONE 3/3, pin-safe): closed the two DRIFT items the M3 milestone-close audit routed here (M2.tidy [medium]+[low] doc-honesty → tidy precedent). [medium] docs/DESIGN.md §"Embedding ABI" — surgically replaced ONLY the contradicted M1-era parenthetical "(modes apply only to heap-shaped types, which the scalar-only rule above forbids at an export boundary anyway)" with the present-tense truth "(a single-constructor record export parameter, by contrast, carries own/borrow — the ownership contract the frozen value layout below specifies)"; the parenthetical shared physical line :2300 with the docs_honesty_pin.rs:135 pinned bare-scalar sentence ("Export parameters are written bare: a scalar type carries no own/borrow mode", norm()-whitespace-collapsed, fn form_a_scalar_param_carveout_present_and_old_rule_absent) — the edit kept every pinned word (line :2299 + the own/borrow modecontinuation untouched), the planner Step-5 item-6 presence-pin-vs-verbatim-edit collision the M2.tidy precedent ran. [low] crates/ailang-codegen/src/lib.rs:608-610 — comment-only honesty fix ("gate guarantees Int/Float; map Int→i64,Float→double" → "...Int/Float or a single-constructor record of those (M3); map Int→i64, Float→double, a record → ptr"); tree-wide-grep-confirmed no test pins the comment text; the byte-pin (embed_record_layout_pin) + forwarder-IR pin (embed_staticlib_lowering) assert generated IR not source comments → byte-identical before/after (the guard that no codegen moved). Boss-verified independently: both stale fragments grep-ABSENT; the 4 standing pins green at the exact recon baseline (docs_honesty_pin 5/0 ⇒ pin-safety held, design_schema_drift 8/0, embed_record_layout_pin 1/0, embed_staticlib_lowering 3/0); workspace 639/77 byte-unchanged from the M3-DONE baseline (docs/comment tidy, zero behaviour/test delta); diff exactly 2 files (DESIGN.md 5±, codegen/src/lib.rs 7±). No language/checker/codegen behaviour change; no audit/fieldtest gate (the 4 pins + 639/77 ARE the regression coverage, M2.tidy precedent). One non-gating planner-quality defect recorded in Concerns: Task-3 Step-1'sguarantees every param` verification grep is a substring of the plan's own Task-2 replacement text (non-discriminating) — the orchestrator correctly verified the substantive intent via discriminating fragments instead of bending code (same family as planner Step-5 item-8). bench: already carry-on / NO ratify at the M3 audit (causally exonerated by byte-identical generated IR; this tidy touches no executable path). audit source docs/journals/2026-05-18-audit-embedding-abi-m3.md (b8a60b1) → plan docs/plans/embedding-abi-m3.tidy.md (44ced51) → iter this commit. M3 milestone substantively closed + sound; roadmap [~]→[x] follows. → 2026-05-18-iter-embedding-abi-m3.tidy.md
2026-05-18 — brainstorm embedding-abi-m4 → RETIRED, never speced (premise collapsed under its own feature-acceptance gate during Step-2/3 Q&A; no spec, no grounding-check, no planner handoff — the "problem mis-framed → don't ratify a known-unneeded shape" brainstorm path): /boss picked top-P0 "Embedding ABI — M4: sequence crossing via List"; user green-lit a continue-here brainstorm; recon (ailang-plan-recon) returned a full fact sheet; two user forks resolved in Q&A (own-only List param; List Record-only element) and Approach A (structural list-shaped is_c_abi_type arm, no name-match; B name-anchored / C std_list-SSOT-first rejected on language/scope grounds) recommended — all now moot. Struck on feature-acceptance clause 2: the shipped M3 gate is_c_abi_type (crates/ailang-check/src/lib.rs:1934-1953) is a per-parameter loop accepting a C scalar OR a single-ctor all-scalar record independently per param, and the forwarder's llvm_scalar maps every non-scalar Type::Con→ptr (M3-frozen), so (State, Tick) -> State (both single-ctor all-scalar records) is already gate-accepted + forwarder-supported today — the minimal data-server binding is M3 (shipped) + a host-side per-tick loop; cons-list crossing would add a 2N+1-box-per-chunk host builder + the deferred flat-array perf debt and removes no redundancy, with no named consumer (M5's adapter unrolls each chunk host-side — a clean adapter, the sole data-server↔AILang meeting point per Invariant 1; whole-chunk in-kernel visibility is semantically void since State threads across calls regardless of chunk boundaries). Honest mid-Q&A correction recorded: I had asserted "M5 cannot wire data-server without M4" — false (M5 wires it on M3 + for tick in chunk); re-deriving against the code rather than defending the roadmap I wrote is what surfaced the clause-2 failure ("user suggestions ≠ directives, form own judgment"). Outcome: M4 retired in docs/roadmap.md (struck entry kept one cycle, never [x]); M5 reconciled (depends on: M4→M3 + Tick-coverage todo; adapter unrolls host-side; friction feeds the host-per-tick-FFI-vs-batch P2 perf decision); residual = a new [todo] "Tick-coverage on M3" (E2E+fixture pinning the two-record-param per-tick (State, Tick) -> State shape — capability present today but only E2E-proven for a single record param State; every shipped M3 fixture pushes a scalar Float sample, none a record Tick; test backfill, no brainstorm — the actual "minimal data-server binding"). Forward note: the P2 flat-array item's "1024 cons-cells/chunk" framing is now partly stale (cons-list path dropped) — reconcile when picked up, not now. → 2026-05-18-brainstorm-embedding-abi-m4-retired.md
2026-05-18 — iter bugfix-over-strict-mode-ctor-rebuild-consume (RED→GREEN, debug→implement mini, DONE 1/1): fixed a conservative [over-strict-mode] false-positive surfaced by the Tick-coverage fixtures. The lint's consume-detection (any_sub_binder_consumed_for/pattern_has_consumed_heap_binder, crates/ailang-check/src/linearity.rs) only recognised a consume of an (own (con T)) param when a heap-typed pattern-binder was moved out of match p; when p was destructured into purely primitive fields fed into a Term::Ctor rebuilding p's own ctor, that genuine dismantle+rebuild consume was invisible, so the lint spuriously advised (borrow ...). Real harm: an LLM author "fixing" the spurious warning by flipping an export's declared mode own→borrow would silently invert the ABI ownership contract. RED-first: debugger disproved the carrier's initial nested-match hypothesis (the M3 embed_backtest_step_record.ail is silent only because its implicit-mode scalar Float param disables the lint via the activation gate, linearity.rs:327 — NOT because it handles the rebuild; the defect reproduces single-param, no nesting), wrote the synthetic RED unit over_strict_mode_silent_when_ctor_rebuilt_from_primitive_fields committed as its own audit-trail commit a11cb7c. GREEN (implement mini): added a 2nd recognition path to any_sub_binder_consumed_for — a match p arm that destructures binders out of p's ctor and references any of them (primitive or not) inside a Term::Ctor's args in the arm body genuinely consumes p; two pure helpers (ctor_uses_any_binder + deep term_mentions_any_binder, so (+ acc px)-mediated flow counts), conservative toward NOT suppressing (a ctor ignoring p's payload still warns — negative-control proven), over-strict-only (by-name shadowing imprecision is extra-silence, never under-strict; recorded as Known debt). Both stale doc comments that mis-attributed the FP to nested match corrected for doc-honesty (debugger concern #2, same code region — in-scope, not opportunistic). +166/−20 in linearity.rs only; check-only, zero codegen/runtime/ABI/schema/DESIGN.md change. Boss-verified independently: RED→GREEN, full cargo test -p ailang-check 108/0 lib + every binary 0-failed with NO existing test modified, ail check embed_backtest_step_tick.ail no longer over-strict on st/tick (exit 0), _tick_borrow.ail + M3 embed_backtest_step_record.ail still clean, the already-green embed_tick_e2e + bench posture untouched. No audit/fieldtest gate (lint-precision bugfix; the RED test + the green check-suite ARE the regression coverage). RED a11cb7c → GREEN this commit. → 2026-05-18-iter-bugfix-over-strict-mode-ctor-rebuild-consume.md
2026-05-19 — iter embedding-abi-m5.1 (DONE 3/3): M5 iter 1 — stood up the workspace-excluded ail-embed crate. A zero-dependency embedding core (Rust port of the audited crates/ail/tests/embed/tick_roundtrip.c: extern "C" to the M3-frozen ABI + frozen-layout State/Tick box helpers + a Kernel price fold, raw pointers never escaping the type) links the M3 staticlib via a new build.rs (no in-repo precedent — AIL_BIN env override else nested cargo build -p ail against the parent workspace, separate target dir so no cargo-lock deadlock). Plus a hermetic data-server smoke: a synthetic Pepperstone-format ZIP fixture written via the crate's own public RawTickRecord type (correct-by-construction, mirrors data-server/src/loader.rs:110-124) → real DataServer → Kernel, asserting bit-exact vs a same-order host reference fold and the closed-form 55.0; runs with no /mnt. ail-embed is its own cargo workspace root (empty [workspace] table) so the AILang compiler workspace owes it nothing; data-server is a dev-dependency only ⇒ Invariant 1 holds in the dependency graph, not just on paper. Boss-verified independently: ail-embed suite 2/2 green (kernel_run_sums_prices unit RED-first + hermetic_smoke_data_server_roundtrip integration), full+no-deps cargo metadata on the AILang workspace shows data-server count 0, git status path filter empty (zero diff to crates/ailang-*/crates/ail//runtime//examples/*.ail), src/lib.rs zero code-level data_server, AILang cargo build --workspace still clean. Two toolchain-forced corrections to the plan's verbatim ail-embed/Cargo.toml (added the empty [workspace] table; sibling dev-dep path ../libs→../../libs manifest-relative) — confined to the plan-created manifest, no acceptance gate altered, 0 review re-loops; planner-recon implication recorded in the journal Concerns. Adapter API + thread-swarm explicitly deferred to M5 iter 2+. → 2026-05-19-iter-embedding-abi-m5.1.md
2026-05-19 — iter embedding-abi-m5.2 (PARTIAL 2/3; M5 bounce-back): data-server adapter + symbol-fan swarm; the leak-proof did its job and surfaced a real concurrency finding. Tasks 1+2 landed clean: data-server promoted dev-dep→real dep (Invariant-1 sanctioned — compiler workspace graph still data-server-count 0, zero compiler-surface diff), additive adapter module (tick_to_px/MidPriceStream lazy Iterator/fold_symbol, RED-first), and a swarm_runner [[bin]] whose clean compile is the compile-time per-thread-ctx proof (Ctx: !Send ⇒ a shared-ctx swarm is E0277, cannot build). The real-data symbol-fan swarm runs (EURUSD/GER40/XAUUSD, ~4s) and is bit-exact vs an independent same-order host reference every run (symbol_fan_swarm_bit_exact, GREEN, live). Task 3's Σallocs==Σfrees leak gate is BLOCKED: Boss independently read runtime/rc.c and confirms it is an instrumentation race, not a memory bug — no box crosses a thread (!Send), the real RC is correct (bit-exact green), only the global g_rc_* stat counters (rc.c:90-91,161,212) are non-atomic by rc.c's own documented single-threaded design and lose ++s when 3 worker threads hit the null-__ail_tls_ctx host-side path. M5 is AILang's first concurrent consumer → the deferred "concurrency arrived: atomic-vs-non-atomic" decision rc.c:44-49 names is now due. The leak assertion was Boss-split into symbol_fan_swarm_leak_free (#[ignore], body verbatim — quarantined not weakened; un-ignore = the runtime fix's acceptance) so main stays green and the finding is pinned. Prior claim that embed_swarm_tsan.rs covers this was corrected (it uses the scalar kernel — zero box allocs — never exercised this path). Escalated as a bounce-back (touches M3-frozen runtime/; re-frames M5's "zero runtime change"; multiple substantive options); Boss recommendation on the record = Option A (atomic global-fallback counters only, standalone RED-first runtime micro-iter, M5 framing amended) — user picks the direction. Time-shard + friction-harvest remain m5.3. → 2026-05-19-iter-embedding-abi-m5.2.md
2026-05-19 — iter bugfix-rc-global-stats-race (RED→GREEN, debug→implement mini, DONE 1/1): the M5 iter-2 bounce-back resolution (user-approved Option A). The two null-ctx fallback RC-stats counters g_rc_alloc_count/g_rc_free_count (runtime/rc.c:90-91) were plain static uint64_t with a non-atomic ++ on the __ail_tls_ctx == NULL arm of ailang_rc_alloc (rc.c:161) / the to-zero branch of ailang_rc_dec (rc.c:212); a multi-threaded host driving the global fallback (no ailang_ctx_new) raced the read-modify-write and lost increments, so the AILANG_RC_STATS atexit Σ under-counted non-deterministically — exactly the deferred "concurrency arrived: atomic-vs-non-atomic" decision rc.c's own header (rc.c:44-49) names, M5 being AILang's first concurrent consumer. NOT a memory bug (Ctx: !Send keeps every box on one thread; the real refcount/free is correct; programs bit-exact). RED (debugger, audit-trail commit 427b687): a C host — 8 threads × 2M alloc-then-dec, no ctx so the global path is taken, no box crossing a thread — + integration test asserting the atexit Σ is exact; Boss-verified RED allocs=2141382 expected 16000000, live=-131242 (deterministic-fail under that contention, not flaky). GREEN (implement mini, this commit): the two globals are now _Atomic uint64_t, atomic_fetch_add_explicit(.., memory_order_relaxed) at the two fallback ++ sites, atomic_load_explicit(.., relaxed) in ailang_rc_stats_atexit (its sole reader) — relaxed is correct (pure stats, no happens-before; atexit reader runs post-join). Per-ctx counters + the per-object refcount header left non-atomic BY DESIGN (single-thread-per-ctx; boxes never cross threads) — explicitly out of scope, untouched; frozen value layout / ABI offsets / host-free rule untouched; the genuinely-still-single-threaded drop-worklist doc note correctly left unchanged (a false correction was refused); the two genuinely-stale atomicity doc blocks corrected for honesty. Scope held to runtime/rc.c ONLY (37+/14−). Boss-verified independently: RED→GREEN deterministically 3/3 (jitter gone, allocs==frees==16_000_000), full cargo test -p ail green (every binary 0 failed — the per-ctx tsan harnesses embed_swarm_tsan/embed_rc_accounting_tsan + embed_tick_e2e/embed_record_e2e unaffected since the per-ctx path is untouched; rc.c links into every ail binary so this is the strong regression gate), git-status scope = rc.c + journal + stats only, the RED files unchanged. Unblocks resuming the M5 leak-proof (un-#[ignore] ail-embed's symbol_fan_swarm_leak_free). RED 427b687 → GREEN this commit. → 2026-05-19-iter-bugfix-rc-global-stats-race.md
2026-05-19 — iter embedding-abi-m5.2-resume-attempt (RE-QUARANTINED; honesty fix only): attempted to un-#[ignore] the M5 swarm leak-proof symbol_fan_swarm_leak_free as the integration-level acceptance of the runtime fix 7bfa11e (bugfix-rc-global-stats-race). Boss verification FALSIFIED the sufficiency premise: across 4–6 swarm runs the leak Σ is still non-deterministic — Σfrees stable-exact (12000003) every run, Σallocs short by a jittering ~1600–2260 in ~1/3 of runs (e.g. left:11998383 right:12000003 across 4 stat lines). The atomic-global fix is real, committed, NECESSARY (the isolated 8×2M pure-global RED embed_rc_global_stats_race is deterministically green) but NOT sufficient — a second, distinct alloc-side undercount remains that the isolated RED did not model (frees never lose ⇒ not a per-ctx race; not pure global contention ⇒ RED green; localisation beyond that is where Boss speculation stops per the debug Iron Law). Un-ignore reverted (never committed); the only shipped diff is the three now-stale #[ignore]-rationale breadcrumbs in ail-embed/tests/swarm.rs corrected from "un-ignore when the runtime is atomic" to the accurate necessary-but-insufficient state (a future agent seeing 7bfa11e must NOT un-ignore on that basis — doc-honesty). Test body + the #[ignore] itself unchanged (still quarantined, NOT weakened); symbol_fan_swarm_bit_exact stays live+GREEN (the swarm IS actually correct and leak-free — only the accounting is wrong). Residual handed to a fresh debug RED-first cycle; two framings flagged for it (genuine residual runtime defect vs Σ-over-heterogeneous-global+per-ctx-lines methodology unsoundness — the latter, if so, is a post-root-cause design decision). main green at the honesty-fix commit; M5 stays open [~]; m5.3 remains downstream of a sound leak-proof. → 2026-05-19-iter-embedding-abi-m5.2-resume-attempt.md
2026-05-19 — iter bugfix-swarm-rc-alloc-undercount (RED→GREEN, debug→implement mini, DONE 1/1): root-caused and fixed the m5.2-resume-attempt residual. The M5 swarm leak-proof was still non-deterministic after the atomic-counter runtime fix 7bfa11e — NOT a second runtime bug and NOT test-methodology unsoundness, but a build-dependency staleness gap: ail-embed/build.rs declared cargo:rerun-if-changed only for the kernel .ail + build.rs, NOT the runtime/ C sources ail build --emit=staticlib compiles into libailang_rt.a. So Cargo never re-ran build.rs after 7bfa11e; ail-embed kept linking a stale pre-7bfa11e non-atomic libailang_rt.a whose g_rc_alloc_count++ raced the swarm's concurrent TLS-NULL host allocs (explaining the frees-stable/allocs-jitter asymmetry, and why the isolated crates/ail RED — which rebuilds the staticlib fresh per run — was green while the ail-embed swarm was not). runtime/rc.c at HEAD was always correct; the entire production fix is one directory-level cargo:rerun-if-changed=<repo>/runtime line (preferred over a per-file list — the implementer inspected crates/ail build_staticlib confirming libailang_rt.a = ar(rc.o,str.o), both under runtime/; directory tracking is future-proof against any new runtime source). RED (debugger, audit-trail 483117d): ail-embed/tests/rt_archive_freshness.rs pins the cause deterministically (objdump the linked archive for lock-prefixed atomic increments + a fresh-build cross-check) since the symptom is non-deterministic by construction; Boss-verified RED = 0 lock insns ("STALE"). GREEN (implement mini, this commit): the build.rs fix + the cohesive consequence — symbol_fan_swarm_leak_free un-#[ignore]d (body byte-for-byte verbatim — it was always quarantined, never weakened; the three doc breadcrumbs rewritten to the resolved build-dep-staleness rationale), now the integration-level acceptance of both 7bfa11e and this fix. Boss removed a pre-existing dead DataFormat import in swarm.rs inline (trivial; file committed this iter regardless). Boss-verified independently: RED→GREEN; swarm determinism 5/5 — symbol_fan_swarm_leak_free + symbol_fan_swarm_bit_exact GREEN every run, 0 ignored, jitter gone, Σallocs==Σfrees==12000003; isolated embed_rc_global_stats_race still GREEN (untouched); Invariant 1 data-server count 0; scope = ail-embed/build.rs + ail-embed/tests/swarm.rs + journal + stats only. The M5 swarm leak-proof bounce-back is now fully resolved end-to-end (bounce-back → Option A 7bfa11e → resume-attempt "necessary-but-insufficient" → this build-dep root-cause+fix). RED 483117d → GREEN this commit. M5 stays open [~]; m5.3 (time-shard + friction-harvest + close-out) remains. → 2026-05-19-iter-bugfix-swarm-rc-alloc-undercount.md

155 KiB Raw Blame History Unescape Escape

Journal index

155 KiB

Raw Blame History