Skip to content
TheChatArchiveThe Chat Archive
GLMz-ai/glm-5.2· unknownHugging Face ibragim-bad/swe_rebench_07_2026_trajectories

ISSUE DESCRIPTION unused-class-members FP: methods called only from Svelte <template>…

  1. User

    ISSUE DESCRIPTION

    unused-class-members FP: methods called only from Svelte member expressions False positive on 2.84.0. Class methods called only from a Svelte <template> via a member expression (for example resultState.pin(...) in markup) are reported as unused-class-member. Fallow tracks template-visible identifiers but not member-expression method calls on a bound instance inside Svelte markup.

    Repro (2.84.0): asciimoo/hister. ResultState.onOpen, .pin, .updateLabel, and .addSkipRule are each invoked from .svelte templates (resultState.pin(...) in ResultActionsMenu.svelte) yet reported unused. The repo currently sets rules.unused-class-members: "off" to work around it.

    Expected: credit a method called as <local>.<method>(...) inside a Svelte <template> when <local> resolves to an instance of the class, parallel to the existing Vue/Angular template member-access tracking.

    Interface

    No new interfaces are introduced.

    ADDITIONAL ADVICE

    Since you are given a git repository, you can use git commands to simplify your work. For example, if you made a mistake and want to revert your changes, you can use git checkout <file> to restore the file to its original state. You can also reset all changes in the repository using git reset --hard command. Additionally, you can use git stash and git stash pop to temporarily save your changes and restore them later. Finally, you can see the changes that you've made (which will be submitted when you call submit) using git status or git diff commands. However you don't need to use git add or git commit before submitting your changes. In fact, submit only submits currently unstaged changes because it uses git diff to get the changes that need to be submitted.

    CHECKLIST

    Before submitting your solution, please go over the following checklist and make sure you've done everything:

    • If an error was reported in the issue description, I have successfully reproduced it.
    • If an error was reported in the issue description, I have confirmed that my fix resolves the error.
    • I have thought about edge cases and made sure my fix handles them as well.
    • I have run existing tests in the repository that might have been affected by the change I made and confirmed that they pass. I want you to list every bullet from this checklist and write your reasoning for why you think you did it or didn't need to.

    Repository has been uploaded and your shell is currently at the repository root. Time to solve the issue!

    (Current directory: /fallow, current file: none) bash-$

  2. GLM Assistant

    Let me start by exploring the repository structure to understand what we're working with.

  3. GLM Assistant

    This is a Rust project (oxlint-like tool called "fallow"). Let me explore the structure more.

  4. GLM Assistant

    Let me look at the structure of the unused_members.rs file to understand how it works, particularly how Angular/Vue templates are handled.

  5. GLM Assistant

    Let me look at the Angular template handling in unused_members.rs more carefully.

  6. GLM Assistant

    Let me search for where ANGULAR_TPL_SENTINEL and HTML template scanners are defined.

  7. GLM Assistant

    Let me look at the extract crate's structure and find where template scanning happens (Vue/Svelte).

  8. GLM Assistant

    Now let me look at the svelte.rs scanner and the template_usage.rs to understand how member_accesses are collected. Let me look at the TemplateUsage struct.

  9. GLM Assistant

    Let me look at the svelte.rs scanner to understand collect_template_usage_with_bound_targets.

  10. GLM Assistant

    Now let me look at sfc.rs which builds the per-SFC pipeline, and how the template usage flows into the analysis phase.

  11. GLM Assistant

    Now let me look at binding_target_names in the visitor to understand what it captures.

  12. GLM Assistant

    Let me understand how binding_target_names is populated for new expressions.

  13. GLM Assistant

    Let me look at where new Foo() is recorded to binding_target_names.

  14. GLM Assistant

    Let me find where const x = new Foo() registers the binding target. Let me look at the declarations visitor where variable declarations are processed.

  15. GLM Assistant

    Now let me find where the variable declarations are processed for const x = new Foo(). Let me search for variable declarator handling.

  16. GLM Assistant

    Let me search for where new expressions create binding_target_names from variable declarators.

  17. GLM Assistant

    Let me look at how member_accesses get translated into accessed_members in the analyze phase.

  18. GLM Assistant

    Let me look at the general member access processing pipeline around line 900-1000.

  19. GLM Assistant

    Let me find the main pipeline function that builds accessed_members from regular member accesses.

  20. GLM Assistant

    Let me look at the Svelte scanner's merge functions in detail.

  21. GLM Assistant

    Now let me look at the shared merge functions to see how member_accesses are emitted with bound_targets.

  22. GLM Assistant

    Let me look at the visitor's visit_static_member_expression and member access recording to understand the guards.

  23. GLM Assistant

    Let me check static_member_object_name helper.

  24. GLM Assistant

    Let me look at existing tests for Svelte member access in the analyze layer to understand the test setup.

  25. GLM Assistant

    No svelte tests in unused_members.rs. Let me check the integration tests for svelte.

  26. GLM Assistant

    Let me look at the sfc_parsing.rs test to understand how svelte tests are set up.

  27. GLM Assistant

    There's an existing test vue_template_event_handlers_mark_class_members_used. Let me look at the vue-project fixture to see how Vue handles Counter.bump — this likely uses a bound instance similar to the Svelte case.

  28. GLM Assistant

    Let me check existing svelte fixtures and the Vue scanner's handling to compare with Svelte.

  29. GLM Assistant

    The svelte-project fixture has const counter = new Counter() and counter.bump(). Let me find the existing test that checks Counter.bump for svelte.

  30. GLM Assistant

    Let me look at the rest of apply_tag in svelte.rs to find the plain expression case.

  31. GLM Assistant

    Let me look at the CLI to see if I can run analyze on a fixture directly.

  32. GLM Assistant

    Let me create a reproduction fixture mirroring the issue (a Svelte component calling a class method via a member expression in markup).

  33. GLM Assistant

    Now let me create a temporary test to reproduce the issue.

  34. GLM Assistant

    Let me check how the integration test module is organized - is it a single mod with submodules? Let me check the common module and how to include the temp file.

  35. GLM Assistant

    I need to add a mod declaration for my temp test file. Let me append it.

  36. GLM Assistant

    Now let me run the reproduction test.

  37. GLM Assistant

    The simple reproduction passed. Let me investigate more carefully — the real scenario may differ. Let me check the git log and CHANGELOG for context, and debug what member_accesses are produced.

  38. GLM Assistant

    The CHANGELOG confirms the local new Counter() case was already fixed. So the gap must be a different scenario. The issue says "<local> resolves to an instance of the class" — suggesting resolution through the module graph (instance created elsewhere, imported). Let me test the imported-instance scenario.

  39. GLM Assistant

    The imported-instance case ALSO passes! So ResultState.pin is credited even when constructed elsewhere. I need to understand the actual gap. Let me look at where INSTANCE_EXPORT_SENTINEL is emitted and how the analyze resolves exported instances.

  40. GLM Assistant

    Now I understand — the imported-instance case works via record_exported_instance_bindings + propagate_accesses_through_instance_exports. The gap must be Svelte-specific syntax. Let me examine the Svelte scanner's attribute/event-handler handling, especially on:click (Svelte 4) vs onclick (Svelte 5).

  41. GLM Assistant

    Let me check whether the unused-class-members rule considers non-exported (private) classes, and test the private-class + exported-instance scenario.

  42. GLM Assistant

    Let me re-read apply_template_usage in sfc.rs to see when it runs and what it passes.

  43. GLM Assistant

    Let me reconsider — perhaps the real scenario uses Svelte 5 runes ($state). Let me check whether the visitor handles $state(new ResultState()).

  44. GLM Assistant

    Let me test the Svelte 5 $state rune scenario, which the visitor doesn't capture as a bound target.

  45. GLM Assistant

    I reproduced the FP with the Svelte 5 $state rune scenario. But I need to confirm the actual hister scenario. Let me inspect the member_accesses emitted for the svelte file directly via the extract crate to understand the mechanism precisely.

  46. GLM Assistant

    Let me write a quick standalone test in the extract crate to inspect member_accesses for various svelte binding forms.

  47. GLM Assistant

    No tests dir for extract. Let me create a test in the extract crate's existing test module, or use an example. Let me check if there's an examples dir or if I can add a [[bin]]. Actually, the simplest is to add a #[test] in the lib.rs tests module, or create a tests dir. Let me create the tests dir with the file.

    Actually, let me just create the directory and the file.

  48. GLM Assistant

    Now I have a clear picture. The gaps are:

    • STATE-RUNE ($state(new ResultState())): emits nothing — resultState.pin() not tracked.
    • OBJ-DESTRUCTURE-PROP ($props() destructure with type): emits nothing.

    Let me reproduce the shared-singleton scenario (state module creates instance via $state, imported by svelte) which is likely the hister case.

  49. GLM Assistant

    The $state singleton + import reproduces the FP. Let me look at how React factory wrappers (useState(() => new Class())) are handled, to mirror for Svelte runes.

  50. GLM Assistant

    Let me search the codebase for any reference to hister or the specific class/method names, and check a few more binding variations.

  51. GLM Assistant

    Let me examine the Vue scanner to compare its member-access tracking with Svelte's.

  52. GLM Assistant

    Let me check if I can access the hister repo to confirm the exact scenario.

  53. GLM Assistant

    I have network access. Let me clone the hister repo to inspect the exact scenario.

  54. GLM Assistant

    I found it. Let me examine the actual hister files.

  55. GLM Assistant

    Now let me see how resultState is instantiated and used in the svelte files.

  56. GLM Assistant

    This is the exact scenario. resultState is a PROP destructured from $props() typed via an interface Props. Let me confirm where ResultState is instantiated in +page.svelte.

  57. GLM Assistant

    This is the exact scenario: resultState is a prop typed as ResultState via an interface Props, and ResultState is a type-only import in ResultActionsMenu.svelte. Let me check whether build_local_to_export_keys includes type-only imports.

  58. GLM Assistant

    Let me check whether all_resolved_imports includes type-only imports.

  59. GLM Assistant

    Let me check whether type-only imports are included in resolved_imports.

  60. GLM Assistant

    So type-only imports ARE pushed to resolved_imports (with is_type_only: true). Let me confirm static imports include type-only. Let me look at the static import resolution.

  61. GLM Assistant

    Type-only imports ARE in local_to_export_keys. So if the scanner emits ResultState.pin, the analyze phase will credit the class. The gap is that resultState (a prop typed via interface Props) isn't captured in binding_target_names. Let me check if the visitor collects interface declarations to resolve prop types.

  62. GLM Assistant

    Let me look at the visitor's finalize steps at the end of visit_program.

  63. GLM Assistant

    The finalize steps run after binding_target_names() is read in sfc.rs. So I need to populate the ObjectPattern bindings during the walk. Let me look at visit_program to add a pre-scan for interface property types.

  64. GLM Assistant

    So the visitor uses the default Visit::visit_program (no override). The walk starts at visit_program which walks the body. Let me check whether there's an override somewhere. The oxc_ast_visit::Visit::visit_program default walks statements. Since there's no override, the default walks the program body via visit_statements.

    So to do a pre-scan, I'd need to override visit_program. Let me check if there's an override pattern. Actually, let me look at how the visitor is implemented — is it the oxc Visit trait? Let me check.

  65. GLM Assistant

    Let me look at the visit_declaration for TSInterfaceDeclaration and TSTypeAliasDeclaration.

  66. GLM Assistant

    Let me check the walk::walk_program API and how the default visit_program walks.

  67. GLM Assistant

    I can override visit_program to pre-scan interface/type-alias property types. Let me look at the existing type-extraction helpers.

  68. GLM Assistant

    Let me look at extract_class_instance_bindings and the interface body AST structure.

  69. GLM Assistant

    Let me check the oxc AST for TSInterfaceBody and TSSignature.

  70. GLM Assistant

    Let me verify fallow handles .svelte.ts files (parses them as TS, not SFC).

  71. GLM Assistant

    is_sfc_file checks only the last extension, so .svelte.ts is parsed as regular TS. Now let me build a fixture that exactly mirrors the hister scenario and confirm the FP reproduces BEFORE the fix.

  72. GLM Assistant

    I've reproduced the exact hister FP. Now let me implement the fix. First, let me look at the ModuleInfoExtractor struct fields.

  73. GLM Assistant

    Let me look at the new() constructor and the imports in mod.rs and visit_impl.rs.

  74. GLM Assistant

    Let me check the imports in visit_impl.rs to know what AST types are available.

  75. GLM Assistant

    I have all the context. Let me check the BindingProperty and PropertyKey AST and get_binding_identifiers.

  76. GLM Assistant

    Now I have everything. Let me check get_binding_identifiers on BindingPattern. Let me confirm it exists on BindingPattern. Line 1322 is in js.rs. Let me check what self is there.

  77. GLM Assistant

    I have everything I need. Let me check helpers.rs imports to add the helper function.

  78. GLM Assistant

    I have all the AST knowledge. Now let me implement the fix. First, add a helper function in helpers.rs to collect property types from a TypeScript object-type signature list.

  79. GLM Assistant

    Now let me add the helper function after extract_nested_type_bindings.

  80. GLM Assistant

    Let me verify the helpers.rs patch didn't duplicate.

  81. GLM Assistant

    Good, no duplication. Now let me add the interface_property_types field to the struct in mod.rs.

  82. GLM Assistant

    Let me confirm the struct derives Default so the new field initializes correctly.

  83. GLM Assistant

    Good, #[derive(Default)] so the new field initializes empty. Now let me add the visit_program override with the pre-scan, and the record_typed_destructure handling. Let me look at the visit_variable_declaration location for BindingIdentifier handling to add the ObjectPattern case right after.

  84. GLM Assistant

    Now let me add the ObjectPattern typed-binding handling right after the BindingIdentifier typed-binding block.

  85. GLM Assistant

    Now let me add the visit_program override (pre-scan) and the record_typed_destructure + resolve_destructure_property_types methods. Let me add visit_program right after the impl Visit for ModuleInfoExtractor opening.

  86. GLM Assistant

    Now let me add the helper methods near record_typed_binding. Let me find it.

  87. GLM Assistant

    Let me add the new methods right after record_typed_binding (before resolve_class_type_param).

  88. GLM Assistant

    I referenced a helper static_binding_identifier_name. Let me add it as a free function near static_member_object_name.

  89. GLM Assistant

    Let me verify the helpers module visibility and the function visibility.

  90. GLM Assistant

    Now let me build to check for compile errors.

  91. GLM Assistant

    oxc uses its own allocator Vec. Let me see all the errors.

  92. GLM Assistant

    Two issues: lifetime 'a in inherent methods, and the Statement::Declaration variant name. Let me check the context of record_typed_binding and the oxc Statement enum.

  93. GLM Assistant

    Let me find the oxc Statement enum variants.

  94. GLM Assistant

    Statement inherits Declaration variants directly. Let me check how existing code matches declarations in statements.

  95. GLM Assistant

    Let me check the Declaration enum variants to use the correct pattern.

  96. GLM Assistant

    Statement inherits Declaration variants directly, and my methods are inherent (no 'a in scope). Let me rewrite the methods block correctly. First let me see what I currently inserted.

  97. GLM Assistant

    Let me rewrite the methods block. First, get exact line numbers.

  98. GLM Assistant

    Now let me replace the whole block (lines 848-950) with corrected code:

  99. GLM Assistant

    Now let me build to check for remaining errors.

  100. GLM Assistant

    It compiled. Now let me run the repro test to confirm the fix resolves the FP.

  101. GLM Assistant

    The fix works. Now let me verify against the real hister repo. Let me check its fallow config and run fallow on it.

  102. GLM Assistant

    The hister config disables the rule. Let me build the CLI and run fallow on hister with the rule enabled to verify the real-world fix.

  103. GLM Assistant

    Let me check how to override a rule via the CLI, or just temporarily enable the rule in hister's config.

  104. GLM Assistant

    Let me temporarily enable the rule in hister's config and run fallow to check for the ResultState FP.

  105. GLM Assistant

    With the fix, hister has only 1 unused class member total and NO ResultState findings. Let me confirm what that 1 finding is and that no ResultState members appear.

  106. GLM Assistant

    Let me check the actual field name and that 1 finding (if any) to confirm it's not a ResultState FP.

  107. GLM Assistant

    The only finding is WebSocketManager.isOpen (unrelated to ResultState). Let me verify this finding is NOT newly introduced by my change by comparing against the unfixed version.

  108. GLM Assistant

    Interesting — with the original code, hister reports only WebSocketManager.isOpen, NOT ResultState methods. Let me investigate why. Let me check if +page.svelte calls the methods directly (crediting them via another path).

  109. GLM Assistant

    Let me check the original-code output for any result-state findings (unused file/export) which would skip member analysis.

  110. GLM Assistant

    No result-state findings at all in original code — so the original code IS crediting them somehow. Let me find all template calls to these methods across hister.

  111. GLM Assistant

    Let me check whether $lib imports resolve in hister (if unresolved, ResultState export has no references and member analysis is skipped).

  112. GLM Assistant

    The original code doesn't reproduce the FP on hister HEAD — it credits the methods somehow. Let me restore my fix and investigate the exact credit path by inspecting the actual hister files' extraction.

  113. GLM Assistant

    Let me update my inspect test to read the actual hister files and print member_accesses, to find the credit path.

  114. GLM Assistant

    The original code emits nothing for resultState.X in ResultActionsMenu, yet doesn't report them. So member analysis must be skipped or they're credited. Let me add a temporary debug in the analyze phase to see what happens for the ResultState export.

  115. GLM Assistant

    No DEBUG output — so the module is either skipped early (entry point/unreachable) or not in the analyzed set. Let me add an earlier debug.

  116. GLM Assistant

    Still no DEBUG output. Let me check the full stderr and whether result-state.svelte.ts is even discovered.

  117. GLM Assistant

    Key finding: hister's .svelte-kit/tsconfig.json is missing (repo not built), so the $lib alias is broken and result-state.svelte.ts is unreachable — that's why no findings. Let me check how the SvelteKit plugin maps $lib.

  118. GLM Assistant

    The SvelteKit plugin maps $lib->src/lib, but it only activates when @sveltejs/kit is found (no node_modules here). Let me force-enable it via config and re-verify on hister.

  119. GLM Assistant

    Let me check how plugins activate (from package.json deps or node_modules) and whether hister's app declares @sveltejs/kit.

  120. GLM Assistant

    Let me check whether .svelte.ts files are discovered at all in hister, and inspect the list files output for the lib directory.

  121. GLM Assistant

    list files returns 0 (different output). Let me check active plugins and whether $lib resolves for hister.

  122. GLM Assistant

    The hister environment can't fully resolve $lib here, but my fixture faithfully mirrors hister's exact code structure and confirms the fix. Let me now remove the debug code I added to unused_members.rs.

  123. GLM Assistant

    Let me try to make hister's $lib resolve so I can do a real-world verification. Let me check hister's tsconfig setup.

  124. GLM Assistant

    Let me check the list command usage and whether the SvelteKit plugin activates for hister.

  125. GLM Assistant

    list --files shows result-state.svelte.ts IS discovered. Let me re-add a focused debug and run with the FIXED code to see whether ResultState's members are credited (accessed_members) or analysis is skipped.

  126. GLM Assistant

    With the fix, ResultState's methods (onOpen, pin, updateLabel, addSkipRule) ARE in accessed_members! Let me confirm the original code does NOT credit them (the FP) by running with the stashed original.

  127. GLM Assistant

    The stash reverted the debug too. Let me revert only the extract files to original (keeping the core debug) to compare accessed_members with the original code.

  128. GLM Assistant

    Surprising — the ORIGINAL code ALSO credits the methods on hister! So the FP doesn't reproduce on current hister HEAD. Let me find the credit path. Let me inspect +page.svelte's member_accesses.

  129. GLM Assistant

    The original code credits the methods via some path my fixture lacks. Let me find all ResultState. static accesses and method calls across hister.

  130. GLM Assistant

    The original code credits the methods on hister via some path my fixture lacks. Let me find which access contributes by adding a debug in the main accessed_members-building loop.

  131. GLM Assistant

    Let me find the main loop that builds accessed_members from member_accesses (the one with local_to_export_keys.get(access.object.as_str())). That's around line 1530-1575. Let me add a debug there that prints when an access resolves to the ResultState export key.

    Actually, let me find the ResultState export key's file_id first. The result-state.svelte.ts file_id. I can't easily know it. Let me instead print, for each access where the object resolves to an export whose name is "ResultState" AND the file path contains "result-state", the source module path and the access.

    Let me find the main loop.

  132. GLM Assistant

    The full analysis shows ResultActionsMenu emits object=ResultState even with original extract code — but my single-file inspect test showed nothing. Let me check whether parse_source_to_module runs the SFC apply_template_usage pipeline differently.

  133. GLM Assistant

    The single-file inspect and full analysis disagree. Let me re-run the ResultActionsMenu inspect with the current (original-extract) code to recheck.

  134. GLM Assistant

    The discrepancy is likely a stale cache (my fix didn't bump CACHE_VERSION, so the original-code run read cached FIXED results). Let me find and clear the cache, then re-run with original extract.

  135. GLM Assistant

    There's a cache at /tmp/hister/.fallow/cache.bin. Let me clear it and re-run with original extract.

  136. GLM Assistant

    The FP IS reproduced on hister with original code + clean cache (accessed=None, methods reported unused). My earlier "no FP" was stale cache. Now I need to re-apply my extract fix (I discarded it with git checkout). Let me verify current state and re-apply.

  137. GLM Assistant

    Let me revert the core debug, then re-apply the extract fix cleanly.

  138. GLM Assistant

    Now let me re-apply the extract fix. First, the helper function in helpers.rs.

  139. GLM Assistant

    Now re-apply the visit_impl.rs changes: visit_program override, the record_typed_destructure call, the helper methods, and static_binding_identifier_name.

  140. GLM Assistant

    Compiled. Let me run my repro test to confirm the fix works again.

  141. GLM Assistant

    Now let me rebuild the CLI and verify on hister with a clean cache (the definitive real-world test).

  142. GLM Assistant

    The fix resolves the real-world hister FP (only WebSocketManager.isOpen remains). Now I must bump the extraction cache version so warm caches re-extract. Let me find the CACHE_VERSION.

  143. GLM Assistant

    Let me check for tests that assert the cache version value, which the bump might affect.

  144. GLM Assistant

    No test asserts the exact value. Let me build everything and run the cache tests + relevant extract tests.

  145. GLM Assistant

    All 1638 extract lib tests pass. Let me run the relevant core integration tests (sfc_parsing, angular_template_members, member_detection).

  146. GLM Assistant

    All pass. Now let me run the full core integration test suite to ensure no regressions.

  147. GLM Assistant

    All 524 core integration tests pass. Let me run the CLI snapshot tests (they may reflect changed unused-class-member output) and graph tests.

  148. GLM Assistant

    One CLI test failed (fix_batch_aborts_when_a_target_directory_is_read_only) — likely environment-related (running as root makes "read-only" dirs writable). Let me verify it fails WITHOUT my changes too.

  149. GLM Assistant

    The read-only test fails without my changes too (pre-existing, root-related). Let me confirm the snapshot/check tests pass (they cover unused-class-member output).

  150. GLM Assistant

    All snapshot/check tests pass. Let me run the graph crate tests too, since the extract change feeds into the graph.

  151. GLM Assistant

    Let me run the extract cache tests (since I bumped the cache version).

  152. GLM Assistant

    All tests pass (the one CLI failure is pre-existing and root-related). The fix is verified on both my fixture and the real hister repo. Now let me clean up all temporary test files and fixtures. First, remove the temp mod from integration_test.rs.

  153. GLM Assistant

    Let me verify integration_test.rs is back to its original state (only the temp mod was added).

  154. GLM Assistant

    Let me revert integration_test.rs to its original state (it shouldn't be modified).

  155. GLM Assistant

    Let me confirm no untracked/temp files remain.

  156. GLM Assistant

    Clean — only the 4 source files are modified. Let me do a final review of the complete diff.

  157. GLM Assistant

    The diff is clean and correct. Let me run the core lib unit tests to be thorough.

  158. GLM Assistant

    All 2415 core lib tests pass. Let me check the CHANGELOG structure to add a consistent entry for this fix.

  159. GLM Assistant

    Let me add a CHANGELOG entry under the [Unreleased] / ### Fixed section, consistent with the repo's style.

  160. GLM Assistant

    Let me do a final build and re-verify on hister with a clean cache.

  161. GLM Assistant

    The fix is confirmed on the real hister repo. Let me restore hister's config (I temporarily modified it) and do a final check of the complete diff.

  162. GLM Assistant

    All clean. Let me run clippy to ensure no lint warnings (the repo uses strict clippy settings).

  163. GLM Assistant

    No clippy warnings. Let me verify the CHANGELOG diff is well-formed.

  164. GLM Assistant

    The CHANGELOG entry is well-formed. Let me do a final full workspace build and a combined test run of the affected crates to confirm everything is green.

  165. GLM Assistant

    All green (workspace builds; extract lib 1638 passed; core integration 523 passed — back to original count after removing the temp test). Let me do a final review of the helpers.rs and mod.rs diffs.

  166. GLM Assistant

    Everything is clean and correct. Let me do a final status check before submitting.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.