Enable genuine CI nullable-gate enforcement via per-file #nullable opt-in remediation across UtilitiesCS (epic: utilitiescs-nullable-remediation)

.claude/agent-memory/atomic-executor/MEMORY.md

@@ -1,5 +1,19 @@
 # Atomic Executor Memory Index
 
+- [#376 capstone scope-expansion layers](project_376_capstone_scope_expansion_layers.md) — 5 escalated layers past P2-T17 (ToDoModel CS0618 -> TaskVisualization CS4014/ToDoModel.Test CS0169 -> QuickFiler CS0108/CS0618/CS8600 -> TaskMaster CS8632/CS8767/CS0618 + QuickFiler.Test MSTEST0032 -> TaskMaster.Test/UtilitiesCS.Test CS8632/CS8625/CS0067); all resolved via the 3 authorized patterns, stop-condition never triggered
+- [BOM breaks grep ^ anchor](project_bom_grep_anchor_false_negative.md) — bash/GNU grep's `^#nullable` silently misses BOM-prefixed UtilitiesCS files (400 opted-in via ripgrep, not 156 via bash grep); always use the Grep tool for opt-in/candidate-file classification, never bash grep
+- [#372 email-classifier nullable patterns](project_372_email_classifier_nullable_patterns.md) — engine props set post-ctor=`null!`; factory returns `T?`; Prediction.Class T? cascade=`.Class!`; net481 IsNullOrEmpty no-narrow; `(await Deserialize())!` not `await Deserialize()!`; DTO `= null!` adds a coverage line; measured 30 emitting (not epic ~18)
+- [Timed-out MSTest leaves detached runner](project_timedout_mstest_leaves_detached_runner.md) — a timed-out Invoke-MSTestWithCoverage bash call leaves a detached pwsh runner respawning testhosts; second run contends over user.config (ConfigurationErrorsException in unrelated TaskTree/ToDoModel) and hangs — kill the pwsh runner too, verify 0, then rerun with >=8min timeout
+- [#371 OutlookObjects nullable lessons](project_371_outlookobjects_nullable_lessons.md) — public-signature nullable change regresses OTHER nullable-enabled files in same assembly (DfDeedle) — check TOTAL UtilitiesCS CS86xx per batch, keep public tuples non-null w/ ! at null sites; lazy-field CS8618→Lazy<T>?; ToLazy has class constraint; _item=null! for GetOrLoad ref-match; ForEach commented-but-resolves (grep gate=flag not block)
+- [Sibling-worktree shared-tooling hazard](project_sibling_worktree_shared_tooling_hazard.md) — a concurrent agent in a DIFFERENT worktree crashes your testhost + clobbers /tmp logs via shared global vstest/dotnet-coverage; use session scratchpad for logs, poll for a quiet machine before test runs, trust bash `$?` not log counts, never kill/commit others' processes/memory files
+- [#375 residuals nullable gotchas](project_375_residuals_nullable_gotchas.md) — CS8644 inherited-interface mismatch from oblivious #366 base fixed with a `#nullable disable` island on the class-declaration line (not `!`); full-solution Rebuild cleans SVGControl.dll → isolated gate CS0006, re-run no-TWAE Build first; MeetingItemHelper Lazy<T> classes: bulk `= null!` + `(...)!` getters/lambdas beats widening the API (Python utf-8-sig for CRLF+BOM files)
+- [#364 nullable-gate pre-existing blockers](project_364_nullable_gate_preexisting_blockers.md) — full-solution pragma-only TWAE gate fails at baseline (vendored SVGControl CS0649 + non-HelperClasses CS0618/CS0168); verify CS86xx via isolated UtilitiesCS build w/ BuildProjectReferences=false; analyzer-version drift needs nuget-install into packages/; coverage script single-assembly StrictMode bug
+- [Nullable per-file pragma gate mechanics](project_nullable_pragma_gate_mechanics.md) — solution-wide TWAE aborts on vendored SVGControl CS0649; verify via isolated `UtilitiesCS.csproj -t:Rebuild -p:Platform=AnyCPU -p:BuildProjectReferences=false` + grep CS86xx=0
+- [Analyzer version skew on fresh worktree](project_analyzer_version_skew_fresh_worktree.md) — first analyzer build fails CS0006 (Meziantou 3.0.101/Sonar 10.27/BannedApi 3.3.4 missing); nuget install old versions into gitignored packages/, don't edit 16 csproj
+- [Nullable remediation annotation patterns](project_nullable_remediation_annotation_patterns.md) — net481 no post-condition attrs; EmailRecord struct `= default!`; `.ToString()!` for string cells; IsNullOrEmpty overload gotcha; `x!.M()` for defensive-flow-state
+- [Nullable epic: pragma gate + analyzer restore](project_nullable_epic_pragma_gate_and_analyzer_restore.md) — per-file #nullable children: exact solution TWAE gate is blocked by pre-existing SVGControl CS0649 + UtilitiesCS CS0618/CS0168; use scoped `UtilitiesCS.csproj TWAE /p:WarningsNotAsErrors=CS0649%3BCS0618%3BCS0168`; restore mismatched analyzer pkgs (csproj 3.0.101 vs packages.config 3.0.123) into packages/ first
+- [Nullable pragma-gate net481 mechanics](project_nullable_pragma_gate_net481_mechanics.md) — per-file #nullable gate can't hit EXIT_CODE 0 (stale csproj analyzer paths vs packages.config, vendored SVGControl CS0649, ~14 pre-existing UtilitiesCS CS0168/CS0618 under TWAE); measure CS86xx attributed to ReusableTypeClasses via SVGControl-prebuilt + /p:BuildProjectReferences=false + /p:Platform=AnyCPU
+- [CS8714 does not fire on net481](project_nullable_cs8714_not_on_net481.md) — ConcurrentDictionary-derived unconstrained-TKey types emit 0 CS8714 under #nullable enable because net481 BCL refs lack the notnull constraint; `where TKey : notnull` is forward-looking, not required
 - [#349 breadcrumb WebView2 gotchas](project_349_breadcrumb_webview2_gotchas.md) — retyped Designer field breaks reflection-injected tests (inject a router instead); aggregate async d__ classes for >=90% proofs; QuickFiler.Test is Newtonsoft-free
 
 - [VS18 build/test toolchain paths](project_vs18_build_toolchain_paths.md) — build with VS **18** full-framework msbuild.exe (not Core .dotnet-sdk, which dies on binary resx MSB3822); nuget.exe restore; MSYS_NO_PATHCONV; csharpier v1 subcommands; dotnet-coverage needs `--` separator
@@ -8,6 +22,9 @@
 - [sln/csproj edits: preserve CRLF](project_sln_csproj_edit_crlf_preserve.md) — git-bash `sed -i` strips CRLF from TaskMaster.sln (whole-file churn + BOM loss); use Edit tool or `perl -0777` with explicit `\r\n`; verify with `file` + `git diff --stat`
 - [Swordfish F5 test misclassification](project_swordfish_f5_test_misclassification.md) — #308 plan labeled two F2 clean-base tests as "direct-Swordfish"; only 1 of 3 truly bound Swordfish; verify using/namespace before treating a test removal as Swordfish-only; AC-12 raised #317 for the unique lock-recursion coverage
 - [ScoDictionaryNew needs TryAdd not Add](project_scodictionarynew_tryadd_not_add.md) — retargeting Sco* stand-in tests to ScoDictionaryNew: `.Add(key,value)` won't compile (CS1061); base ConcurrentObservableDictionary exposes `.TryAdd`; swap in the same edit to avoid a build-fail loop
+- [#366 notnull cascades past WrapperScoDictionary](project_366_notnull_cascades_beyond_wrapperscodictionary.md) — the ratified `where TKey : notnull` on the dictionary bases also forces the constraint onto ScoDictionaryConverter (a 2nd #367 file, CS8714 at lines 27/28/40), exceeding the 1-file Option-A waiver; fix = same one-line constraint on ScoDictionaryConverter<TDerived,TKey,TValue>
+- [#366 ScDictionary constraint cascades to a 4th file](project_366_scdictionary_constraint_cascades_to_fourth_file.md) — constraining ScDictionary/WrapperScDictionary cascades CS8714 into ScDictionaryConverter.cs (no 'o', a 4th #367 file beyond the 3-file waiver); STOP + re-escalate, don't widen
+- [#366 Batch7 T? return triggers CS8766](project_366_batch7_tnullable_return_cs8766.md) — annotating a `class`-constrained generic method return as `T?` when it implements an out-of-scope null-oblivious interface member (declared `T`) emits CS8766; conform to `T` + justified `!`, don't edit the interface (scope STOP)
 - [Concurrent executor in same worktree](project_concurrent_executor_same_worktree.md) — two executors on one plan/worktree corrupt shared files; detect via mtime progression during your own turn; STOP, don't stash/race
 
 - [TaskController (#297) unit-test gotchas](project_taskvisualization_taskcontroller_test_gotchas.md) — ApplyChanges hangs over Moq (mark exempt); get-only MailItem.TaskSubject throws MissingMethodException; STA harness needs TableLayoutPanel parenting + NavTips warmup + no DateTimePicker.Text; C# 7.3 test project; tail-piped vstest buffers til exit

.claude/agent-memory/atomic-executor/project_364_nullable_gate_preexisting_blockers.md

@@ -0,0 +1,18 @@
+---
+name: 364-nullable-gate-preexisting-blockers
+description: The full-solution pragma-only nullable gate fails at baseline on the epic-integration branch (vendored SVGControl CS0649 + non-HelperClasses UtilitiesCS CS0618/CS0168); verify CS86xx via isolated UtilitiesCS build. Plus analyzer-version drift and coverage-script single-assembly bug.
+metadata:
+  type: project
+---
+
+Executing the `utilitiescs-nullable-remediation` epic children (e.g. #364 HelperClasses) on branches off `epic/utilitiescs-nullable-remediation-integration`.
+
+**Why:** The recent HEAD commit changed the CI nullable gate from `/t:Build` (a silent no-op) to `/t:Rebuild`, so a genuine recompile now surfaces pre-existing warnings that `/p:TreatWarningsAsErrors=true` promotes to errors — across projects that are OUT of a given child's scope.
+
+**How to apply:**
+
+1. The plan-literal gate `msbuild TaskMaster.sln /t:Rebuild /p:TreatWarningsAsErrors=true` (no `/p:Nullable=enable`) FAILS at baseline, before any edit: vendored `SVGControl/SvgImageSelector.cs` has 2 pre-existing CS0649 (fields never assigned, dating to 2023) that halt the solution build early; and non-HelperClasses `UtilitiesCS` files (EmailIntelligence/, Extensions/) have ~28 CS0618 + 2 CS0168. None are fixable within a HelperClasses-scoped child. Flag them; do not treat as regressions.
+2. Authoritative CS86xx verification for a UtilitiesCS child: first build the solution once WITHOUT TWAE so SVGControl.dll exists, then `msbuild UtilitiesCS/UtilitiesCS.csproj /t:Rebuild /p:Configuration=Debug /p:Platform=AnyCPU /p:BuildProjectReferences=false` (no TWAE) and grep the output for `warning CS86`. CS86xx are severity-independent and arise only from `#nullable enable` files (project default is oblivious — `UtilitiesCS.csproj` has no `<Nullable>`), so zero CS86xx warnings == zero CS86xx errors under TWAE. `BuildProjectReferences=false` avoids re-triggering the SVGControl halt (UtilitiesCS has a project ref to SVGControl).
+3. Analyzer version drift: `UtilitiesCS.csproj`/`VBFunctions.csproj` `<Analyzer Include>` paths pin OLDER analyzer versions (Meziantou 3.0.101, SonarAnalyzer 10.27.0.140913, BannedApiAnalyzers 3.3.4) than `packages.config` (3.0.123 / 10.29.0.143774 / 5.6.0). `main` has the reconciling commit (097f0ba2) but the epic-integration base does not. `Sync-PackageReferences.ps1` only fixes `<HintPath>`, NOT `<Analyzer Include>`, so the analyzer build gets CS0006. Fix without touching tracked files: `nuget.exe install <id> -Version <old> -OutputDirectory packages` for the three csproj-referenced versions (packages/ is gitignored).
+4. `scripts/vscode/Invoke-MSTestWithCoverage.ps1` throws under StrictMode when discovery returns a SINGLE test assembly (`$testAssemblies.Count` on a scalar). To scope coverage to one assembly (e.g. UtilitiesCS.Test), invoke the underlying command directly: `dotnet-coverage collect --output <cobertura> --output-format cobertura --settings coverage.config -- <vstest> UtilitiesCS.Test\bin\Debug\UtilitiesCS.Test.dll /Settings:scripts/vscode/TaskMaster.cli.runsettings /InIsolation /TestCaseFilter:TestCategory!=LiveOutlook`.
+5. Env bootstrap on a fresh worktree: `Invoke-Restore.ps1` (nuget restore, 169 pkgs) then the analyzer install in (3). Global `csharpier` is v1.3.0 (subcommand syntax `csharpier check .` / `csharpier format .`, NOT `--check`); `dotnet tool run csharpier` fails because the repo-local .NET SDK is not installed.

.claude/agent-memory/atomic-executor/project_366_batch7_tnullable_return_cs8766.md

@@ -0,0 +1,12 @@
+---
+name: 366-batch7-tnullable-return-cs8766
+description: On #366 nullable batches, annotating a generic-class method return as T? when it implements an out-of-scope null-oblivious interface member declared T triggers CS8766; conform to T + justified ! instead
+metadata:
+  type: project
+---
+
+On epic child #366 (utilitiescs-nullable-reusabletypes), Batch 7 (SmartSerializable family), the prior agent annotated `SmartSerializable<T>.DeserializeObject` with a `T?` return. Under the isolated per-file pragma gate (`/t:Rebuild /p:TreatWarningsAsErrors=true /p:BuildProjectReferences=false`, no `/p:Nullable=enable`) this emitted `error CS8766` (nullability of return type doesn't match implicitly implemented member) against `ISmartSerializable<T>.DeserializeObject` — which is declared `T` and lives in `UtilitiesCS/Interfaces/IReusableTypeClasses/ISmartSerializable.cs`, OUT OF SCOPE (not one of the 7 Batch 7 ReusableTypeClasses files).
+
+**Why:** CS8766 fires even against a null-oblivious interface when the implementing type parameter is `where T : class` constrained (constrained `T` return is treated as non-null in the nullable-enabled implementation, so `T?` is strictly more nullable than the interface's `T`). Method-level unconstrained `<T>` returns (e.g. `SmartSerializableBase.DeserializeObject<T>`, `SmartSerializableNonTyped.DeserializeObject<T>`) do NOT emit CS8766 with `T?` — only the class-level `class`-constrained `T` case does.
+
+**How to apply:** Do NOT edit the interface (out of scope; would be a SCOPE-CHANGE STOP). Conform the implementation return type to the interface's `T` and return the genuinely-nullable local with a justified `!` + `// why` comment noting the oblivious interface contract is preserved (AC5 signature-compatible). Watch for this same pattern on any remaining child (#367 etc.) that annotates a `class`-constrained generic method implementing an oblivious interface member. Baseline whole-assembly gate decomposition for UtilitiesCS.csproj isolated compile is 28 CS0618 + 2 CS0168 (all pre-existing non-cluster files: Triage, SortEmail, ManagerAsyncLazy, etc.) — same as Batch 6.

.claude/agent-memory/atomic-executor/project_366_notnull_cascades_beyond_wrapperscodictionary.md

@@ -0,0 +1,16 @@
+---
+name: 366-notnull-cascades-beyond-wrapperscodictionary
+description: The #366 `where TKey : notnull` constraint on the dictionary bases cascades past WrapperScoDictionary into a SECOND #367 file (ScoDictionaryConverter), exceeding the bounded Option-A waiver
+metadata:
+  type: project
+---
+
+On epic child #366 (utilitiescs-nullable-reusabletypes), applying the ratified `where TKey : notnull` constraint to `ConcurrentObservableDictionary<TKey,TValue>` forces the same constraint onto every nullable-enabled #367 consumer that passes an UNCONSTRAINED `TKey`. The epic Option-A waiver predicted only `WrapperScoDictionary<TDerived,TKey,TValue>` (`UtilitiesCS/NewtonsoftHelpers/WrapperScoDictionary.cs`, 4 CS8714 sites) and authorized EXACTLY that one file + one clause.
+
+Reality (measured 2026-07-19, VS18 isolated UtilitiesCS.csproj `/t:Rebuild /p:TreatWarningsAsErrors=true /p:BuildProjectReferences=false`): once `WrapperScoDictionary` itself gets the constraint, a SECOND #367 NewtonsoftHelpers file — `ScoDictionaryConverter<TDerived,TKey,TValue>` in `UtilitiesCS/NewtonsoftHelpers/ScoDictionaryConverter.cs` — emits 3 unique CS8714 (lines 27,28,40; double-counted to 6 under recompile) because it constructs `WrapperScoDictionary<TDerived,TKey,TValue>` / `serializer.Deserialize(..., typeof(WrapperScoDictionary<TDerived,TKey,TValue>))` with its own unconstrained `TKey`. Its `where TDerived : ScoDictionaryNew<TKey,TValue>` would independently force the same constraint once ScoDictionaryNew is constrained in Phase 8, so this file needs `where TKey : notnull` regardless.
+
+**Why:** the cascade is inherent to constraining any of the four generic dictionary bases — it propagates to every generic #367 wrapper/converter with an unconstrained TKey, not just the direct WrapperScoDictionary consumer.
+
+**How to apply:** the minimal fix that closes the ScoDictionaryNew/ConcurrentObservableDictionary chain is symmetric — add `where TKey : notnull` to `ScoDictionaryConverter<TDerived,TKey,TValue>` (one line, after its `where TDerived : ...`). Verified-safe non-cascade files: `PeopleScoConverter` references WrapperScoDictionary only in commented-out code and is otherwise concrete (`PeopleScoDictionaryNew`); `WrapperPeopleScoDictionaryNew` uses concrete `ScoDictionaryNew<string,string>` / `ConcurrentObservableDictionary<string,string>` — neither emits CS8714. So a widened waiver of exactly TWO files (WrapperScoDictionary.cs + ScoDictionaryConverter.cs), one `where TKey : notnull` line each, clears the ScoDictionaryNew chain. Under the original one-file bounded waiver this is a hard STOP — do not suppress with `#pragma warning disable`, do not widen unilaterally; report and get the waiver extended. See [[project_scodictionarynew_tryadd_not_add]].
+
+**Batch 8 (#366) discovered a SEPARATE, THIRD chain (2026-07-19):** the ratified `where TKey : notnull` on `ScDictionary<TKey,TValue>` (a plain `ConcurrentDictionary`-based serializable dict, NOT the observable ScoDictionaryNew) cascades into its OWN wrapper `WrapperScDictionary<TDerived,TKey,TValue>` (`UtilitiesCS/NewtonsoftHelpers/WrapperScDictionary.cs`, line 18/19: `where TDerived : ScDictionary<TKey,TValue>`, unconstrained TKey, already `#nullable enable` via merged #367) — 1 unique CS8714 (double-counted to 2 under Rebuild). This file is NOT one of the two Batch-6-waived files, so it is a hard STOP requiring a fresh epic waiver-extension decision. Note: `ScoDictionaryStatic` is listed in the [P6-T2] ratification as one of the "four generic dictionary bases" but is actually a NON-generic `static class` of Type extension methods — the `where TKey : notnull` constraint is mechanically inapplicable there (no TKey). Batch-8 green state = ScoDictionaryNew constrained (required, cascade absorbed by the two waiver files), ScDictionary constraint REVERTED to keep the tree green pending the epic decision. `ScBag` is `ConcurrentBag<T>`-based, no constraint.