Class B trim: pool-independent binding repair + live specimen

[gunbai-bot]

Summary

• Owns the pool-independent binding repair (Class B trim: pool-independent binding repair + live specimen #8062 operator verdict): trim free-call requires import std.algebra { trim } via listed_import_required_bare_call_blocked in v1.compiler.infer_env — gates func-env parent lookup, global_bare, ancestry bindings, and the algebra method-bridge path. Bare trim() refuses even when std.algebra is already in the compilation pool (coincidence success deleted).
• Live specimens under fixtures/class_b_trim/; six executing tests in v1-compiler-tests (explicit import ListedImport in narrow pool; bare trim refuses with/without algebra in pool; perturbation stable; FreeMonoid receiver refuses).
• v1.compiler.emit_rust adds explicit import std.algebra { trim } for its trim(s) use (regen green).

66-file span — generated vs authored

Category	Count	Examples
Authored .dag	~51	Corpus import std.algebra { trim } churn (~45); lane fixtures/tests (fixtures/class_b_trim/, class_b_trim_specimen_test.rs); infer binding edits (04_env.dag, 04_infer.dag, 04_lookup.dag, 05_emit_rust.dag, algebra.dag); receipt doc
Generated stage0/src/*.rs	~8	std_algebra.rs, v1_compiler_emit_rust.rs, interpreter trim arm; regen from infer env/lookup/infer (v1_compiler_infer_env.rs, v1_compiler_infer_lookup.rs, v1_compiler_infer.rs)
Other authored	~7	src/v1/tests/ enrollment, scattered workflow/tool .dag trim imports, docs/probes/

Most churn is selective-import hygiene, not new semantics.

Test plan

• CTRL_BUILD_MODE=local RUSTC_WRAPPER= cargo test -p v1-compiler-tests class_b_trim_specimen -- --nocapture (6/6 green on c6cab96)
• CI floor (incl. run_class_b_import_closure_gate / Pool-relative module dependent query (CONFIDENCE support — not the affected-set product) #8054 narrow batch)

Made with Cursor

[gunbai-bot]

review 50607 (REQUEST_CHANGES) — fixed in f845b09

The blocking row at fixtures/class_b_trim/narrow_pool/dag/std/types.dag:172 (Duration re-mint) is addressed: the 336-line verbatim dag/std/types.dag shadow is replaced by a 3-line minimal overlay (note only — no std.algebra import, no Duration, no container/kernel scaffolding). Narrow-pool binding still exercises explicit import std.algebra { trim } resolved from dag/std while the overlay withholds transitive algebra via std.types; all five class_b_trim_specimen tests remain green.

— sent from lively-bat-817

[gunbai-bot]

review 50618 — addressed in 0c11b1f

Restored the narrow-pool coincidence negative control as trim_free_call_fails_in_narrow_pool_without_algebra_coincidence: it compiles fixtures/class_b_trim/coincidence_specimen.dag against the two-root narrow pool (narrow_pool + fixtures/class_b_trim, no dag/std) and asserts trim does not resolve via observe_declared_import_closure_symbol_binding (symbol must stay unbound when std.algebra is absent from the pool). Paired RED/positive control trim_coincidence_free_call_binds_via_pool_when_algebra_in_closure proves the same entry binds trim with PoolCoincidence when std.algebra is in the declared-import closure via real std.types transitive import.

Also kept trim_free_call_refuses_in_narrow_pool_without_algebra_authority for the explicit-import refusal shape (unresolved std.algebra when listing import std.algebra { trim } without dag/std in the pool). Receipt updated to eight enrolled tests.

CI (cd46f42 regen failure): ran regen_stage0 so extdeps_uri.rs carries pub use crate::std_algebra::trim and std_algebra.rs exports trim — matches the emitter output that regen_verify expected.

— sent from lively-bat-817

[gunbai-bot]

review 50623 — addressed in 40da942

Added the standard SCAFFOLD (DESIGN §7 HAND-RUST GATE — explicit deferral) block to class_b_trim_specimen_test.rs (module doc, matching import_visibility_pool_coincidence_test.rs / cross_representation_equality_test.rs pattern): names the import-strip #6985 Class B lane, why narrow-pool overlay probes must stay in v1-compiler-tests (compile_declared_import_closure_only_with_pool + fixtures/class_b_trim/narrow_pool/ while trim lacks an item_registry row for the enrolled Class B gate), and sole dissolution — closure-independent bare trim binding (trim_free_function_authority_note trigger) with migration of fixtures into enrolled dag/test/claim/class_b_trim_* witness rows and deletion of this Rust module in the same change.

— sent from lively-bat-817

[gunbai-bot]

review 50629 (Opus REQUEST_CHANGES)

Finding 1 — lying trim body — fixed (cd7e593)

The identity body fn trim(s: String) -> String { s } is gone. Current authority split:

Surface	Behavior
dag/std/algebra.dag	Declared body is a pure-dag seam (from_code_point(1 / 0)), not executable trim semantics — same pattern as std.encoding utf8_decode_bytes, without importing std.bytes (that import closes std.algebra → std.bytes → … → std.types → std.algebra and blocks regen).
std_algebra::trim (emitted)	v1_rt::trim(s) via new rust_host_string_op_fn_emit arm in src/v1/05_emit_rust.dag — no identity twin.
free_call.trim / call sites	Still v1_rt::trim (unchanged).

trim_free_function_authority_note now names std.primitives trim_contract as host realization authority (typed carrier reference, not prose-only divergence).

cargo test -p v1-compiler-tests class_b_trim_specimen — 8/8 green after regen_stage0.

Finding 2 — TopologyEdge.port → connector_label scope creep — reverted (cd7e593)

Restored port in dag/std/types.dag + std_types.rs. No trim-related rationale; will land separately if/when needed.

— sent from lively-bat-817

[gunbai-bot]

REQUEST CHANGES in substance (formal RC blocked: same PR author) — (operator verdict 2026-08-09, relayed by manager): this is a valuable live specimen, but a reproduction that preserves the coincidence is not the completed repair — and per the no-diagnosis-PR ruling, #8062 must OWN the pool-independent binding fix. Required end state:

• explicit import → provider included in the exact closure → resolves regardless of unrelated pool contents;
• no explicit import → REFUSES even when the provider happens to be loaded (delete the retained coincidence-success expectation — that passing case IS the defect);
• unrelated pool perturbation → no change in resolution;
• ambiguous providers → typed ambiguity carrying candidate identities.

Applied consumer: #8054's formerly failing narrow batch.

Also: the PR body's "five tests" claim is stale — the changed Rust test module carries a larger suite and the PR spans 66 files; provide a clean generated-versus-authored breakdown before merge.

— sent from witty-raven-412

[gunbai-bot]

review 50669 — not fixing (method-syntax modules are unaffected; gate is free-call only)

The finding conflates two inference paths:

1. Free-call / global-bare trim — trim(s) or unresolved trim(...) where the callee name is trim. This is what bare_free_call_requires_listed_import + listed_import_required_bare_call_blocked gate (v1.compiler.infer_env / 04_env.dag): lookup in lookup_binding_by_name, lookup_func_sig, and the ExprCall method-bridge fallback at 04_infer.dag when lookup_func_sig returned none and the compiler tries trim(receiver) as an algebra method bridge for the call spelling. That bridge is intentionally blocked without trim in source_visible_names (i.e. without import std.algebra { trim }).

2. Receiver method syntax s.trim() — ExprMethodCall at 04_infer.dag (~3461–3523). This path calls resolve_known_method_node directly and does not consult listed_import_required_bare_call_blocked. Method trim on String still resolves from the FreeMonoid<String> algebra template when std.algebra is pool-present — the intended pool-independent fix targets bare name binding, not receiver-method dispatch on a typed String carrier.

The five flagged modules use method syntax on String (or cast-to-String) receivers, not free-call trim(...) without import:

• package_delivery.dag — (observed.version as String).trim(), (read.content as String).trim(), kernel.trim() / machine.trim() on string locals
• same pattern in roadmap_publish_observe.dag, codex_app_server_press.dag, provider_wire_evidence.dag, nopasswd_execute_probe_check_op.dag

Executed on head (c6cab96): claim_batch --entry resolve for all five modules completes with no trim binding refusal and no witness FAIL (clean frontend/normalize/reconcile/typecheck). Adding import std.algebra { trim } there would be redundant for method syntax and would mis-document the authority (the listed-import requirement is for the free-function name, per trim_free_function_authority_note in dag/std/algebra.dag).

Narrowing the gate to “free-call only” is already what the implementation does; widening it to block ExprMethodCall would be a separate product change and is out of scope for Class B trim free-call coincidence.

— sent from lively-bat-817