merge: integrate batch0 implementable test porting

docs/plans/batch_prompts.md

@@ -0,0 +1,929 @@
+# Codex Batch Prompts
+
+Each section below contains the prompt to give Codex for executing a specific batch. Copy the prompt text (between the `~~~` fences) into a Codex session with `sandbox: workspace-write` and `approval-policy: on-failure`.
+
+---
+
+## Batch 0 — Implementable Tests (553 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-0-implementable-tests-plan.md
+
+Your job is to execute this plan task by task, starting from Task 2 (Task 1 is already done). Follow ALL verification protocols described in the plan exactly — the stub detection checks, assertion count checks, per-test verification loops, class-level gates, and checkpoint protocols are all mandatory.
+
+Key points:
+- Work ONE CLASS at a time within each task
+- Port each test individually, run it, verify it passes before moving on
+- Use the PortTracker CLI to look up test details: dotnet run --project tools/NatsNet.PortTracker -- test show <id> --db porting.db
+- Follow the Go-to-.NET translation patterns in AGENTS.md
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Commit after each task as specified in the plan
+- Start with Task 2: Port Account/Auth/Options Cluster (89 tests)
+~~~
+
+---
+
+## Batch 1 — Proto, Const, CipherSuites, NKey, JWT (10 features)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-1-proto-const-ciphersuites-nkey-jwt-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 2 — Parser, Sublist, MemStore Remainders (8 features)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-2-parser-sublist-memstore-remainders-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 3 — SendQ, Service, Client ProxyProto (18 features, 1 test)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-3-sendq-service-client-proxyproto-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 4 — Logging (11 features, 31 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-4-logging-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 5 — JetStream Errors (206 features, 11 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-5-jetstream-errors-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- This is a large batch (206 features) — work methodically through each task
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 6 — Opts Package-Level Functions (67 features, 18 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-6-opts-package-level-functions-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 7 — Opts Class Methods + Reload (25 features, 63 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-7-opts-class-methods-reload-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 8 — Store Interfaces (27 features, 1 test)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-8-store-interfaces-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 9 — Auth, DirStore, OCSP Foundations (36 features, 10 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-9-auth-dirstore-ocsp-foundations-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 10 — OCSP Cache + JS Events (20 features, 38 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-10-ocsp-cache-js-events-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 11 — FileStore Init
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-11-filestore-init-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/filestore.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 12 — FileStore Recovery
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-12-filestore-recovery-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/filestore.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 13 — FileStore Read/Query
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-13-filestore-read-query-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/filestore.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 14 — FileStore Write/Lifecycle
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-14-filestore-write-lifecycle-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/filestore.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 15 — MsgBlock + ConsumerFileStore
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-15-msgblock-consumerfilestore-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/filestore.go (MsgBlock and ConsumerFileStore)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 16 — Client Core First Half (30 features, 1 test)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-16-client-core-first-half-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/client.go (first half)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 17 — Client Core Second Half (60 features, 9 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-17-client-core-second-half-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/client.go (second half)
+- This is a larger batch — work methodically through each task
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 18 — Server Core (10 features, 8 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-18-server-core-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/server.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 19 — Accounts Core (92 features, 9 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-19-accounts-core-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/accounts.go
+- This is a large batch (92 features) — work methodically through each task
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 20 — Accounts Resolvers (38 features, 98 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-20-accounts-resolvers-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/accounts.go (resolver methods)
+- This batch has a high test count (98) — port tests carefully with per-test verification
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 21 — Events + MsgTrace (118 features, 9 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-21-events-msgtrace-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go references for this batch are server/events.go and server/msgtrace.go
+- This is a large batch (118 features) — work methodically through each task
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 22 — Monitoring (70 features, 29 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-22-monitoring-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/monitor.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 23 — Routes (52 features, 5 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-23-routes-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/route.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 24 — Leaf Nodes (67 features, 2 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-24-leaf-nodes-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/leafnode.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 25 — Gateways (86 features, 59 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-25-gateways-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/gateway.go
+- This batch has a high test count (59) — port tests carefully with per-test verification
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 26 — WebSocket (37 features, 86 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-26-websocket-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/websocket.go
+- This batch has a high test count (86) — port tests carefully with per-test verification
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 27 — JetStream Core (82 features, 77 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-27-jetstream-core-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/jetstream.go
+- This is a large batch (82 features + 77 tests) — work methodically through each task
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 28 — JetStream API (55 features, 2 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-28-jetstream-api-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/jetstream_api.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 29 — JetStream Batching (12 features, 3 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-29-jetstream-batching-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/jetstream_batching.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 30 — Raft Part 1
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-30-raft-part-1-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/raft.go
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 31 — Raft Part 2
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-31-raft-part-2-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/raft.go (second part)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 32 — JS Cluster Meta
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-32-js-cluster-meta-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/jetstream_cluster.go (meta/leader methods)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 33 — JS Cluster Streams (58 features, 22 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-33-js-cluster-streams-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/jetstream_cluster.go (stream methods)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 34 — JS Cluster Consumers (58 features, 160 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-34-js-cluster-consumers-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/jetstream_cluster.go (consumer methods)
+- This batch has a very high test count (160) — port tests carefully with per-test verification, work in sub-batches
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 35 — JS Cluster Remaining (57 features, 49 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-35-js-cluster-remaining-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/jetstream_cluster.go (remaining methods)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 36 — Stream Lifecycle (92 features, 53 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-36-stream-lifecycle-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/stream.go (lifecycle methods)
+- This is a large batch (92 features + 53 tests) — work methodically through each task
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 37 — Stream Messages (86 features, 13 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-37-stream-messages-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/stream.go (message handling methods)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 38 — Consumer Lifecycle (96 features, 71 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-38-consumer-lifecycle-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/consumer.go (lifecycle methods)
+- This is a large batch (96 features + 71 tests) — work methodically through each task
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 39 — Consumer Dispatch (93 features, 53 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-39-consumer-dispatch-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/consumer.go (dispatch methods)
+- This is a large batch (93 features + 53 tests) — work methodically through each task
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 40 — MQTT Server/JSA (78 features, 323 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-40-mqtt-server-jsa-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/mqtt.go (server/JSA methods)
+- This batch has a very high test count (323) — port tests carefully with per-test verification, work in sub-batches of ~15
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~
+
+---
+
+## Batch 41 — MQTT Client/IO (74 features, 28 tests)
+
+~~~
+IMPORTANT: Before doing anything else, read the file AGENTS.md in the project root for full project context, build/test commands, and coding standards.
+
+Then read the implementation plan at docs/plans/2026-02-27-batch-41-mqtt-client-io-implementation-plan.md
+
+Your job is to execute this plan task by task. Follow ALL verification protocols described in the plan exactly — evidence-backed status updates, no stubs, and mandatory build/test gates.
+
+Key points:
+- Read the Go source for each feature before writing the .NET port (use: dotnet run --project tools/NatsNet.PortTracker -- feature show <id> --db porting.db)
+- The Go reference for this batch is server/mqtt.go (client/IO methods)
+- Write idiomatic C#, not line-for-line Go translations
+- Use xUnit 3 + Shouldly + NSubstitute (NEVER FluentAssertions or Moq)
+- Run dotnet build dotnet/ after each feature group to confirm compilation
+- Run dotnet test dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ after each task to verify no regressions
+- Update feature/test status via PortTracker CLI with evidence
+- Commit after each task as specified in the plan
+~~~

dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ImplBacklog/AuthCalloutTests.Impltests.cs

@@ -108,20 +108,10 @@ public sealed class AuthCalloutTests
         server.ShouldNotBeNull();
     }
 
-    [Fact] // T:117
+    [Fact(Skip = "DEFERRED: requires full operator-mode auth callout integration runtime")] // T:117
     public void AuthCalloutOperatorModeBasics_ShouldSucceed()
     {
-        var (server, err) = NatsServer.NewServer(new ServerOptions());
-        err.ShouldBeNull();
-
-        var opts = new ServerOptions
-        {
-            TrustedOperators = [new object()],
-            AuthCallout = new AuthCalloutOpts { Account = "AUTH", Issuer = "OP" },
-        };
-
-        Should.Throw<NotImplementedException>(() =>
-            server!.ProcessClientOrLeafAuthentication(CreateClient(1, "h", "u", "p"), opts));
+        // DEFERRED: requires end-to-end operator resolver + auth service runtime setup.
     }
 
     [Fact] // T:120
@@ -228,51 +218,22 @@ public sealed class AuthCalloutTests
         req.ConnectOptions!.Username.ShouldBe("leaf-user");
     }
 
-    [Fact] // T:138
+    [Fact(Skip = "DEFERRED: requires leafnode auth callout integration runtime")] // T:138
     public void AuthCalloutLeafNodeAndConfigMode_ShouldSucceed()
     {
-        var (server, err) = NatsServer.NewServer(new ServerOptions());
-        err.ShouldBeNull();
-
-        var opts = new ServerOptions
-        {
-            AuthCallout = new AuthCalloutOpts { Account = "AUTH" },
-        };
-
-        Should.Throw<NotImplementedException>(() =>
-            server!.ProcessClientOrLeafAuthentication(CreateClient(21, "leaf", kind: ClientKind.Leaf), opts));
+        // DEFERRED: requires multi-server leafnode handshake + callout service.
     }
 
-    [Fact] // T:140
+    [Fact(Skip = "DEFERRED: requires operator-mode credential mismatch integration runtime")] // T:140
     public void AuthCalloutOperatorModeMismatchedCalloutCreds_ShouldSucceed()
     {
-        var (server, err) = NatsServer.NewServer(new ServerOptions());
-        err.ShouldBeNull();
-
-        var opts = new ServerOptions
-        {
-            TrustedOperators = [new object()],
-            AuthCallout = new AuthCalloutOpts { Account = "AUTH", Issuer = "OP", AuthUsers = ["bad-user"] },
-        };
-
-        Should.Throw<NotImplementedException>(() =>
-            server!.ProcessClientOrLeafAuthentication(CreateClient(30, "h", "user", "pass"), opts));
+        // DEFERRED: requires connected external auth service with mismatched user creds.
     }
 
-    [Fact] // T:141
+    [Fact(Skip = "DEFERRED: requires leafnode+operator mismatched credentials integration runtime")] // T:141
     public void AuthCalloutLeafNodeOperatorModeMismatchedCreds_ShouldSucceed()
     {
-        var (server, err) = NatsServer.NewServer(new ServerOptions());
-        err.ShouldBeNull();
-
-        var opts = new ServerOptions
-        {
-            TrustedOperators = [new object()],
-            AuthCallout = new AuthCalloutOpts { Account = "AUTH", Issuer = "OP", AuthUsers = ["leaf-bad"] },
-        };
-
-        Should.Throw<NotImplementedException>(() =>
-            server!.ProcessClientOrLeafAuthentication(CreateClient(31, "leaf", "lu", "lp", kind: ClientKind.Leaf), opts));
+        // DEFERRED: requires multiple servers and live leafnode credential exchange.
     }
 
     private static ClientConnection CreateClient(

dotnet/tests/ZB.MOM.NatsNet.Server.Tests/ImplBacklog/AuthHandlerTests.Impltests.cs

@@ -16,6 +16,9 @@ public sealed class AuthHandlerTests
         };
 
         AuthHandler.ValidateNoAuthUser(opts, "alice").ShouldBeNull();
+        var missingUser = AuthHandler.ValidateNoAuthUser(opts, "bob");
+        missingUser.ShouldNotBeNull();
+        missingUser!.Message.ShouldContain("not present as user or nkey");
     }
 
     [Fact] // T:150
@@ -27,6 +30,7 @@ public sealed class AuthHandlerTests
         };
 
         AuthHandler.ValidateNoAuthUser(opts, "NKEY1").ShouldBeNull();
+        AuthHandler.ValidateNoAuthUser(opts, "NKEY2").ShouldNotBeNull();
     }
 
     [Fact] // T:152

reports/current.md

@@ -1,6 +1,6 @@
 # NATS .NET Porting Status Report
 
-Generated: 2026-02-28 02:41:54 UTC
+Generated: 2026-02-28 10:54:55 UTC
 
 ## Modules (12 total)
 
@@ -21,9 +21,9 @@ Generated: 2026-02-28 02:41:54 UTC
 
 | Status | Count |
 |--------|-------|
-| deferred | 2640 |
+| deferred | 2091 |
 | n_a | 187 |
-| verified | 430 |
+| verified | 979 |
 
 ## Library Mappings (36 total)
 
@@ -34,4 +34,4 @@ Generated: 2026-02-28 02:41:54 UTC
 
 ## Overall Progress
 
-**1924/6942 items complete (27.7%)**
+**2473/6942 items complete (35.6%)**

reports/report_27bbd63.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 09:49:28 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2444 |
+| n_a | 187 |
+| verified | 626 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2120/6942 items complete (30.5%)**

reports/report_44d1f4c.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 10:21:49 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2091 |
+| n_a | 187 |
+| verified | 979 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2473/6942 items complete (35.6%)**

reports/report_564b91d.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 09:39:14 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2555 |
+| n_a | 187 |
+| verified | 515 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2009/6942 items complete (28.9%)**

reports/report_7712b6b.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 10:02:39 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2296 |
+| n_a | 187 |
+| verified | 774 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2268/6942 items complete (32.7%)**

reports/report_9bf1d99.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 10:07:05 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2273 |
+| n_a | 187 |
+| verified | 797 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2291/6942 items complete (33.0%)**

reports/report_a7819ea.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 10:19:52 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2091 |
+| n_a | 187 |
+| verified | 979 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2473/6942 items complete (35.6%)**

reports/report_a7cfcc2.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 09:59:22 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2316 |
+| n_a | 187 |
+| verified | 754 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2248/6942 items complete (32.4%)**

reports/report_ac24c03.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 10:54:55 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2091 |
+| n_a | 187 |
+| verified | 979 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2473/6942 items complete (35.6%)**

reports/report_e279b83.md

@@ -0,0 +1,37 @@
+# NATS .NET Porting Status Report
+
+Generated: 2026-02-28 10:15:00 UTC
+
+## Modules (12 total)
+
+| Status | Count |
+|--------|-------|
+| verified | 12 |
+
+## Features (3673 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2377 |
+| n_a | 24 |
+| stub | 1 |
+| verified | 1271 |
+
+## Unit Tests (3257 total)
+
+| Status | Count |
+|--------|-------|
+| deferred | 2148 |
+| n_a | 187 |
+| verified | 922 |
+
+## Library Mappings (36 total)
+
+| Status | Count |
+|--------|-------|
+| mapped | 36 |
+
+
+## Overall Progress
+
+**2416/6942 items complete (34.8%)**