From be8ba90cba36a886acc2d32c0cc0e9c0e9acbab3 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Tue, 21 Jul 2026 17:10:33 -0700
Subject: [PATCH 01/31] feat: Add `check-todos` task and GitHub workflow

Add a Python script that validates all TODO comments reference an open
GitHub issue. TODOs must use the format `TODO #<number>` inside a comment
marker (// # /* * <!--). The script checks each referenced issue via the
`gh` CLI and reports distinct errors for missing references, invalid IDs,
and closed issues.

- Add `dev/scripts/check_todos.py` with `_find_todos` and `_validate_todos`
- Add `task check-todos` to Taskfile.yml
- Add `.github/workflows/check-todos.yml` CI workflow
- Add TODO resolution checklist item to PR template
- Add `GITHUB_REPO` constant to `dev/scripts/_constants.py`
- Update AGENTS.md quality gates with task commands
- Consolidate DEVELOPER.md lint/format/checks section

Addresses GitHub issue #325

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 .github/pull_request_template.md  |   1 +
 .github/workflows/check-todos.yml |  34 +++++++++
 AGENTS.md                         |  25 +++---
 DEVELOPER.md                      |  44 +++++------
 Taskfile.yml                      |  10 ++-
 dev/scripts/_constants.py         |   2 +
 dev/scripts/check_examples.py     |   5 +-
 dev/scripts/check_todos.py        | 123 ++++++++++++++++++++++++++++++
 8 files changed, 201 insertions(+), 43 deletions(-)
 create mode 100644 .github/workflows/check-todos.yml
 create mode 100644 dev/scripts/check_todos.py

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index f59cd067..f4e09449 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -64,3 +64,4 @@ Not applicable items should be crossed out, not removed.
 - [ ] `CHANGELOG.md`, `README.md`, `DEVELOPER.md`, and other documentation files are updated.
 - [ ] Destination branch is correct - `main` or release
 - [ ] Create merge commit if merging release branch into `main`, squash otherwise.
+- [ ] All TODO comments referencing issue(s) closed by this PR have been resolved.
diff --git a/.github/workflows/check-todos.yml b/.github/workflows/check-todos.yml
new file mode 100644
index 00000000..df41e65c
--- /dev/null
+++ b/.github/workflows/check-todos.yml
@@ -0,0 +1,34 @@
+name: check-todos
+
+on:
+    push:
+        branches:
+            - main
+            - release-*
+    pull_request:
+    workflow_dispatch:
+
+permissions:
+    contents: read
+    issues: read
+
+jobs:
+    check-todos:
+        runs-on: ubuntu-latest
+        timeout-minutes: 10
+
+        steps:
+            - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+
+            - name: Setup Python
+              uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+              with:
+                  python-version: "3.12"
+
+            - name: Install Task
+              uses: go-task/setup-task@01a4adf9db2d14c1de7a560f09170b6e0df736aa # v2.1.0
+
+            - name: Check TODOs
+              run: task check-todos
+              env:
+                  GH_TOKEN: ${{ github.token }}
diff --git a/AGENTS.md b/AGENTS.md
index e0bb496f..380eaa29 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -40,16 +40,6 @@ Common commands:
   - `task test coverage=true` (collect), `task coverage:report` (generate)
   - Coverage results go to `dev/coverage/results/`; reports to `dev/coverage/reports/`
 
-## Lint and Format Rules (Agents)
-
-- Prefer `task` commands for linting and formatting.
-- Lint checks (read-only, fail on issues):
-  - `task lint` (all checks), `task lint:rust`, `task lint:csharp`, `task lint:yaml`, `task lint:actions`, `task lint:markdown`
-- Auto-fix formatting:
-  - `task format` (all languages), `task format:rust`, `task format:csharp`, `task format:yaml`, `task format:markdown`
-- Link checking (separate from lint, slower):
-  - `task check-links`
-
 ## Contribution Requirements
 
 ### Developer Certificate of Origin (DCO) Signoff
@@ -159,12 +149,15 @@ Note: Conventional Commits apply to commit messages only. Do not enforce this fo
 
 ## Quality Gates (Agent Checklist)
 
-- [ ] Build passes
-- [ ] Format passes
-- [ ] Lint passes
-- [ ] All unit tests pass
-- [ ] Relevant integration tests pass
-- [ ] Documentation examples compile
+- [ ] Build passes (`task build`)
+- [ ] All [checks](DEVELOPER.md#formatting-linting-and-other-checks) pass.
+  - [ ] `task format`
+  - [ ] `task lint`
+  - [ ] `task check-examples`
+  - [ ] `task check-links`
+  - [ ] `task check-todos`
+- [ ] All unit tests pass (`task test:unit`)
+- [ ] Relevant integration tests pass (`task test:integration`)
 - [ ] Public API changes respect StackExchange.Redis compatibility.
 - [ ] All commits include DCO signoff.
 
diff --git a/DEVELOPER.md b/DEVELOPER.md
index 5df7e4e7..596bdbd8 100644
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@@ -339,32 +339,30 @@ To run [DNS tests](tests/Valkey.Glide.IntegrationTests/DnsTests.cs) locally:
 
 If the environment variable is not set, DNS tests will be skipped.
 
-## Linting and Formatting
+## Formatting, Linting, and Other Checks
 
-Before making a contribution, ensure that all new user APIs and non-obvious code is well documented, and run the code linters and analyzers.
+Before making a contribution, run automated formatters, linters, and additional checks.
 
 ```bash
-# Run all linters:
-task lint
-
-# Run linters for specific languages:
-task lint:rust      # Run Rust linting
-task lint:csharp    # Run C# linting
-task lint:yaml      # Run YAML linting
-task lint:actions   # Run GitHub Actions linting
-task lint:markdown  # Run Markdown linting
-
-# Run all formatters:
-task format
-
-# Run formatters for specific languages:
-task format:rust
-task format:csharp
-task format:yaml
-task format:markdown
-
-# Check for broken links
-task check-links
+# Formatters
+task format           # Run all formatters
+task format:rust      # Run Rust formatter
+task format:csharp    # Run C# formatter
+task format:yaml      # Run YAML formatter
+task format:markdown  # Run Maarkdown formatter
+
+# Linters
+task lint           # Run all linters
+task lint:rust      # Run Rust linter
+task lint:csharp    # Run C# linter
+task lint:yaml      # Run YAML linter
+task lint:actions   # Run GitHub Actions linter
+task lint:markdown  # Run Markdown linter
+
+# Additional checks:
+task check-examples  # Check C# examples in comments
+task check-links     # Check for broken links
+task check-todos     # Check that TODO comments reference an open GitHub issue
 ```
 
 ## Test framework and Style
diff --git a/Taskfile.yml b/Taskfile.yml
index 0be540fe..5dc6e463 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -167,10 +167,14 @@ tasks:
     # Additional checks
     # --------------------------------------------------------------------------------
 
+    check-examples:
+        desc: "Check C# examples in comments"
+        cmd: python3 dev/scripts/check_examples.py
+
     check-links:
         desc: "Check for broken links"
         cmd: lychee --config lychee.toml .
 
-    check-examples:
-        desc: "Check C# examples in doc comments"
-        cmd: python3 dev/scripts/check_examples.py
+    check-todos:
+        desc: "Check that TODO comments reference an open GitHub issue"
+        cmd: python3 dev/scripts/check_todos.py
diff --git a/dev/scripts/_constants.py b/dev/scripts/_constants.py
index 83a53caf..7275c23b 100644
--- a/dev/scripts/_constants.py
+++ b/dev/scripts/_constants.py
@@ -7,6 +7,8 @@
 # Paths
 # ---------------------------------------------------------------------------
 
+GITHUB_REPO = "valkey-io/valkey-glide-csharp"
+
 SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
 PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPTS_DIR))
 SOURCES_DIR = os.path.join(PROJECT_ROOT, "sources")
diff --git a/dev/scripts/check_examples.py b/dev/scripts/check_examples.py
index 33c7b0c3..b1838a41 100644
--- a/dev/scripts/check_examples.py
+++ b/dev/scripts/check_examples.py
@@ -2,8 +2,11 @@
 
 """Check code examples by extracting and compiling them.
 
+Extracts C# code examples from XML doc comments in the source tree, then
+compiles each against the built Valkey.Glide DLL to verify correctness.
+
 Usage:
-    python scripts/check_examples.py
+    python dev/scripts/check_examples.py
 """
 
 import os
diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
new file mode 100644
index 00000000..d14ef839
--- /dev/null
+++ b/dev/scripts/check_todos.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+
+"""Check that all TODO comments reference an open GitHub issue.
+
+Validation rules:
+  1. Every TODO must include a GitHub issue reference with format `TODO #<number>`.
+  2. The referenced number must correspond to an existing Valkey GLIDE C# GitHub issue.
+  3. The referenced issue must be open.
+
+Usage:
+    python dev/scripts/check_todos.py
+"""
+
+import re
+import subprocess
+import sys
+from typing import NamedTuple
+
+from _constants import GITHUB_REPO, PROJECT_ROOT
+
+
+class _Todo(NamedTuple):
+    """A TODO comment found in the codebase."""
+
+    file: str
+    line: int
+    text: str
+
+
+# Matches a TODO inside a comment, optionally capturing the issue number.
+# A match with no `github_id` capture means the TODO is missing an issue reference.
+_TODO_PATTERN = re.compile(
+    r"(//|#|/\*|\*|<!--).*TODO\b(\s+#(?P<github_id>\d+))?", re.IGNORECASE
+)
+
+
+def _find_todos() -> list[_Todo]:
+    """Find all TODO comments in tracked files using git grep."""
+    result = subprocess.run(
+        ["git", "grep", "-n", "-i", "-P", _TODO_PATTERN.pattern],
+        cwd=PROJECT_ROOT,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode == 1:
+        return []
+    if result.returncode != 0:
+        print(f"Error: git grep failed: {result.stderr.strip()}", file=sys.stderr)
+        sys.exit(1)
+
+    todos = []
+    for line in result.stdout.splitlines():
+        parts = line.split(":", 2)
+        if len(parts) == 3:
+            filepath, line_no, text = parts
+            todos.append(_Todo(filepath, int(line_no), text.strip()))
+
+    return todos
+
+
+def _check_issue(github_id: int) -> str | None:
+    """Check issue state. Returns an error message, or None if the issue is open."""
+    result = subprocess.run(
+        [
+            "gh", "issue", "view", str(github_id),
+            "--repo", GITHUB_REPO,
+            "--json", "state",
+            "--jq", ".state",
+        ],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        return f"#{github_id} is not a valid GitHub issue"
+
+    state = result.stdout.strip()
+    if state == "OPEN":
+        return None
+
+    return f"#{github_id} is not open (state: {state})"
+
+
+def _validate_todos(todos: list[_Todo]) -> dict[_Todo, str]:
+    """Validate TODO format and issue state. Returns a map from failed TODO to the corresponding reason."""
+    failures: dict[_Todo, str] = {}
+    checked_issues: dict[int, str | None] = {}
+
+    for todo in todos:
+        match = _TODO_PATTERN.search(todo.text)
+        github_id = match.group("github_id")
+
+        if not github_id:
+            failures[todo] = "missing GitHub issue reference"
+        else:
+            issue_num = int(github_id)
+            if issue_num not in checked_issues:
+                checked_issues[issue_num] = _check_issue(issue_num)
+            if checked_issues[issue_num]:
+                failures[todo] = checked_issues[issue_num]
+
+    return failures
+
+
+def main():
+    print("Checking TODO comments...\n")
+
+    todos = _find_todos()
+    failures = _validate_todos(todos)
+
+    for todo, reason in failures.items():
+        print(f"  FAIL  {todo.file}:{todo.line}")
+        print(f"        {reason}\n")
+
+    passed = len(todos) - len(failures)
+    print(f"Checked {len(todos)} TODOs: {passed} passed, {len(failures)} failed.")
+
+    sys.exit(1 if failures else 0)
+
+
+if __name__ == "__main__":
+    main()

From 20ef797bbd50f5e84a79c4cf61c45e7c6c180414 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Tue, 21 Jul 2026 17:19:51 -0700
Subject: [PATCH 02/31] refactor: Rename check tasks to use colon convention
 and split docs

- Rename check-examples, check-links, check-todos to check:examples,
  check:links, check:todos (consistent with lint:* and format:*)
- Add `task check` aggregator to run all checks in parallel
- Split DEVELOPER.md section into separate Formatting, Linting, and
  Checks headings
- Update AGENTS.md quality gates with separate section references
- Update workflow files to use new task names

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 .github/workflows/check-examples.yml |  2 +-
 .github/workflows/check-todos.yml    |  2 +-
 AGENTS.md                            |  9 +++-----
 DEVELOPER.md                         | 31 ++++++++++++++++++----------
 Taskfile.yml                         | 13 +++++++++---
 5 files changed, 35 insertions(+), 22 deletions(-)

diff --git a/.github/workflows/check-examples.yml b/.github/workflows/check-examples.yml
index 9831a1f9..14554979 100644
--- a/.github/workflows/check-examples.yml
+++ b/.github/workflows/check-examples.yml
@@ -38,4 +38,4 @@ jobs:
               run: task build target=lib
 
             - name: Check examples
-              run: task check-examples
+              run: task check:examples
diff --git a/.github/workflows/check-todos.yml b/.github/workflows/check-todos.yml
index df41e65c..0504b967 100644
--- a/.github/workflows/check-todos.yml
+++ b/.github/workflows/check-todos.yml
@@ -29,6 +29,6 @@ jobs:
               uses: go-task/setup-task@01a4adf9db2d14c1de7a560f09170b6e0df736aa # v2.1.0
 
             - name: Check TODOs
-              run: task check-todos
+              run: task check:todos
               env:
                   GH_TOKEN: ${{ github.token }}
diff --git a/AGENTS.md b/AGENTS.md
index 380eaa29..c9d42287 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -150,12 +150,9 @@ Note: Conventional Commits apply to commit messages only. Do not enforce this fo
 ## Quality Gates (Agent Checklist)
 
 - [ ] Build passes (`task build`)
-- [ ] All [checks](DEVELOPER.md#formatting-linting-and-other-checks) pass.
-  - [ ] `task format`
-  - [ ] `task lint`
-  - [ ] `task check-examples`
-  - [ ] `task check-links`
-  - [ ] `task check-todos`
+- [ ] [Formatting](DEVELOPER.md#formatting) passes (`task format`)
+- [ ] [Linting](DEVELOPER.md#linting) passes (`task lint`)
+- [ ] [Checks](DEVELOPER.md#checks) pass (`task check`)
 - [ ] All unit tests pass (`task test:unit`)
 - [ ] Relevant integration tests pass (`task test:integration`)
 - [ ] Public API changes respect StackExchange.Redis compatibility.
diff --git a/DEVELOPER.md b/DEVELOPER.md
index 596bdbd8..847f00d7 100644
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@@ -250,8 +250,7 @@ task coverage:clean   # Remove coverage results and reports
 # Linting and formatting
 task lint                   # Run all linters
 task format                 # Run all formatters
-task check-links            # Check for broken links
-
+task check                  # Run all checks
 ```
 
 ## Advanced Testing Options
@@ -339,30 +338,40 @@ To run [DNS tests](tests/Valkey.Glide.IntegrationTests/DnsTests.cs) locally:
 
 If the environment variable is not set, DNS tests will be skipped.
 
-## Formatting, Linting, and Other Checks
+## Formatting
 
-Before making a contribution, run automated formatters, linters, and additional checks.
+Run automated formatters to ensure consistent code style.
 
 ```bash
-# Formatters
 task format           # Run all formatters
 task format:rust      # Run Rust formatter
 task format:csharp    # Run C# formatter
 task format:yaml      # Run YAML formatter
-task format:markdown  # Run Maarkdown formatter
+task format:markdown  # Run Markdown formatter
+```
+
+## Linting
 
-# Linters
+Run linters to catch style issues and static analysis warnings.
+
+```bash
 task lint           # Run all linters
 task lint:rust      # Run Rust linter
 task lint:csharp    # Run C# linter
 task lint:yaml      # Run YAML linter
 task lint:actions   # Run GitHub Actions linter
 task lint:markdown  # Run Markdown linter
+```
+
+## Checks
 
-# Additional checks:
-task check-examples  # Check C# examples in comments
-task check-links     # Check for broken links
-task check-todos     # Check that TODO comments reference an open GitHub issue
+Run checks to validate examples, links, and TODO comments.
+
+```bash
+task check           # Run all checks
+task check:examples  # Check C# examples in comments
+task check:links     # Check for broken links
+task check:todos     # Check that TODO comments reference an open GitHub issue
 ```
 
 ## Test framework and Style
diff --git a/Taskfile.yml b/Taskfile.yml
index 5dc6e463..1a7d6485 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -167,14 +167,21 @@ tasks:
     # Additional checks
     # --------------------------------------------------------------------------------
 
-    check-examples:
+    check:
+        desc: "Run all checks"
+        deps:
+            - check:examples
+            - check:links
+            - check:todos
+
+    check:examples:
         desc: "Check C# examples in comments"
         cmd: python3 dev/scripts/check_examples.py
 
-    check-links:
+    check:links:
         desc: "Check for broken links"
         cmd: lychee --config lychee.toml .
 
-    check-todos:
+    check:todos:
         desc: "Check that TODO comments reference an open GitHub issue"
         cmd: python3 dev/scripts/check_todos.py

From 7fa5147bc345061c12b2797e75b14e042c83e414 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Tue, 21 Jul 2026 17:23:36 -0700
Subject: [PATCH 03/31] fix: Add --yes to npx calls to prevent interactive
 prompts

npx prompts for confirmation when a package isn't cached, which stalls
CI and automated runs. Adding --yes auto-accepts the install.

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 Taskfile.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Taskfile.yml b/Taskfile.yml
index 1a7d6485..6f13feee 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -126,7 +126,7 @@ tasks:
 
     lint:yaml:
         desc: "Run YAML linting"
-        cmd: npx prettier --check "**/*.yml"
+        cmd: npx --yes prettier --check "**/*.yml"
 
     lint:actions:
         desc: "Run GitHub Actions linting"
@@ -134,7 +134,7 @@ tasks:
 
     lint:markdown:
         desc: "Run Markdown linting"
-        cmd: npx markdownlint-cli2 "**/*.md"
+        cmd: npx --yes markdownlint-cli2 "**/*.md"
 
     # Format
     # --------------------------------------------------------------------------------
@@ -158,11 +158,11 @@ tasks:
 
     format:yaml:
         desc: "Run YAML formatting"
-        cmd: npx prettier --write --cache "**/*.yml"
+        cmd: npx --yes prettier --write --cache "**/*.yml"
 
     format:markdown:
         desc: "Run Markdown formatting"
-        cmd: npx markdownlint-cli2 --fix "**/*.md"
+        cmd: npx --yes markdownlint-cli2 --fix "**/*.md"
 
     # Additional checks
     # --------------------------------------------------------------------------------

From 5eb761b48661dcad6bfa53f3c3e63c4eee3a6e87 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Tue, 21 Jul 2026 19:51:31 -0700
Subject: [PATCH 04/31] First batch of TODO comment fixes and removals.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/Database.SetCommands.cs          | 47 ++++--------------
 .../Abstract/Database.SortedSetCommands.cs    | 48 ++++---------------
 sources/Valkey.Glide/Abstract/ValkeyServer.cs | 41 ++++------------
 .../Client/BaseClient.SetCommands.cs          |  8 ++--
 sources/Valkey.Glide/Internals/Helpers.cs     | 18 +++++++
 .../HashCommandTests.cs                       |  1 -
 .../SharedBatchTests.cs                       | 10 ++--
 .../SharedCommandTests.cs                     |  1 -
 tests/Valkey.Glide.IntegrationTests/Skip.cs   | 24 ++++++----
 .../SortedSetCommandTests.cs                  | 25 +++++-----
 .../StandaloneClientTests.cs                  |  2 -
 .../StreamCommandTests.cs                     |  3 --
 12 files changed, 82 insertions(+), 146 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/Database.SetCommands.cs b/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
index 202a6ca0..f19e8733 100644
--- a/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
@@ -138,47 +138,18 @@ public Task<bool> SetMoveAsync(ValkeyKey source, ValkeyKey destination, ValkeyVa
     }
 
     /// <inheritdoc cref="IDatabaseAsync.SetScanAsync(ValkeyKey, ValkeyValue, int, long, int, CommandFlags)"/>
-    public IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ValkeyValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None)
+    public IAsyncEnumerable<ValkeyValue> SetScanAsync(
+        ValkeyKey key,
+        ValkeyValue pattern = default,
+        int pageSize = 250,
+        long cursor = 0,
+        int pageOffset = 0,
+        CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
 
-        // Build ScanOptions from the SER parameters
-        ScanOptions? options = null;
-        if (!pattern.IsNull || pageSize != 250)
-        {
-            options = new ScanOptions();
-            if (!pattern.IsNull)
-            {
-                options.MatchPattern = pattern;
-            }
-            if (pageSize != 250)
-            {
-                options.Count = pageSize;
-            }
-        }
-
-        return SetScanWithOffsetAsync(key, options, cursor, pageOffset);
-    }
-
-    private async IAsyncEnumerable<ValkeyValue> SetScanWithOffsetAsync(ValkeyKey key, ScanOptions? options, long cursor, int pageOffset)
-    {
-        long currentCursor = cursor;
-        int currentOffset = pageOffset;
-
-        do
-        {
-            (long nextCursor, ValkeyValue[] elements) = await Command(Request.SetScanAsync(key, currentCursor, options));
-
-            IEnumerable<ValkeyValue> elementsToYield = currentOffset > 0 ? elements.Skip(currentOffset) : elements;
-
-            foreach (ValkeyValue element in elementsToYield)
-            {
-                yield return element;
-            }
-
-            currentCursor = nextCursor;
-            currentOffset = 0; // Only skip on first iteration
-        } while (currentCursor != 0);
+        var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
+        return SetScanAsync(key, options).SkipAsync(pageOffset);
     }
 
     private async Task<ISet<ValkeyValue>> GetCombineResultAsync(SetOperation operation, IEnumerable<ValkeyKey> keys) => operation switch
diff --git a/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs b/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
index 7b53c715..44f01988 100644
--- a/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
@@ -291,48 +291,18 @@ public Task<long> SortedSetRemoveRangeByScoreAsync(ValkeyKey key, double start,
     }
 
     /// <inheritdoc cref="IDatabaseAsync.SortedSetScanAsync(ValkeyKey, ValkeyValue, int, long, int, CommandFlags)"/>
-    public IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, ValkeyValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None)
+    public IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(
+        ValkeyKey key,
+        ValkeyValue pattern = default,
+        int pageSize = 250,
+        long cursor = 0,
+        int pageOffset = 0,
+        CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
 
-        // TODO - Extract common logic for building ScanOptions from SER arguments.
-        // Build ScanOptions from the SER parameters
-        ScanOptions? options = null;
-        if (!pattern.IsNull || pageSize != 250)
-        {
-            options = new ScanOptions();
-            if (!pattern.IsNull)
-            {
-                options.MatchPattern = pattern;
-            }
-            if (pageSize != 250)
-            {
-                options.Count = pageSize;
-            }
-        }
-
-        return SortedSetScanWithOffsetAsync(key, options, cursor, pageOffset);
-    }
-
-    private async IAsyncEnumerable<SortedSetEntry> SortedSetScanWithOffsetAsync(ValkeyKey key, ScanOptions? options, long cursor, int pageOffset)
-    {
-        long currentCursor = cursor;
-        int currentOffset = pageOffset;
-
-        do
-        {
-            (long nextCursor, SortedSetEntry[] elements) = await Command(Request.SortedSetScanAsync(key, currentCursor, options));
-
-            IEnumerable<SortedSetEntry> elementsToYield = currentOffset > 0 ? elements.Skip(currentOffset) : elements;
-
-            foreach (SortedSetEntry element in elementsToYield)
-            {
-                yield return element;
-            }
-
-            currentCursor = nextCursor;
-            currentOffset = 0; // Only skip on first iteration
-        } while (currentCursor != 0);
+        var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
+        return SortedSetScanAsync(key, options).SkipAsync(pageOffset);
     }
 
     /// <inheritdoc cref="IBaseClient.SortedSetBlockingPopAsync(ValkeyKey, Order, TimeSpan)"/>
diff --git a/sources/Valkey.Glide/Abstract/ValkeyServer.cs b/sources/Valkey.Glide/Abstract/ValkeyServer.cs
index bba0d5c1..6c498560 100644
--- a/sources/Valkey.Glide/Abstract/ValkeyServer.cs
+++ b/sources/Valkey.Glide/Abstract/ValkeyServer.cs
@@ -282,42 +282,17 @@ public async Task ScriptFlushAsync(CommandFlags flags = CommandFlags.None)
     }
 
     /// <inheritdoc/>
-    public async IAsyncEnumerable<ValkeyKey> KeysAsync(ValkeyValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None)
+    public IAsyncEnumerable<ValkeyKey> KeysAsync(
+        ValkeyValue pattern = default,
+        int pageSize = 250,
+        long cursor = 0,
+        int pageOffset = 0,
+        CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
 
-        var options = new ScanOptions();
-        if (!pattern.IsNull)
-        {
-            options.MatchPattern = pattern;
-        }
-
-        // TODO how to handle negative
-        if (pageSize > 0)
-        {
-            options.Count = pageSize;
-        }
-
-        string currentCursor = cursor.ToString();
-        ValkeyKey[] keys;
-        int currentOffset = pageOffset;
-
-        do
-        {
-            (currentCursor, keys) = await _conn.Command(Request.ScanAsync(currentCursor, options));
-
-            if (currentOffset > 0)
-            {
-                keys = [.. keys.Skip(currentOffset)];
-                currentOffset = 0;
-            }
-
-            foreach (ValkeyKey key in keys)
-            {
-                yield return key;
-            }
-
-        } while (currentCursor != "0");
+        var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
+        return _conn.ScanAsync(options).SkipAsync(pageOffset);
     }
 
     /// <inheritdoc/>
diff --git a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
index c9e85e25..902bc828 100644
--- a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
@@ -92,18 +92,18 @@ public async Task<bool> SetMoveAsync(ValkeyKey source, ValkeyKey destination, Va
     /// <inheritdoc cref="IBaseClient.SetScanAsync(ValkeyKey, ScanOptions?)"/>
     public async IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ScanOptions? options = null)
     {
-        long currentCursor = 0;
+        long cursor = 0;
 
         do
         {
-            (long nextCursor, ValkeyValue[] elements) = await Command(Request.SetScanAsync(key, currentCursor, options));
+            (var nextCursor, var elements) = await Command(Request.SetScanAsync(key, cursor, options));
 
             foreach (ValkeyValue element in elements)
             {
                 yield return element;
             }
 
-            currentCursor = nextCursor;
-        } while (currentCursor != 0);
+            cursor = nextCursor;
+        } while (cursor != 0);
     }
 }
diff --git a/sources/Valkey.Glide/Internals/Helpers.cs b/sources/Valkey.Glide/Internals/Helpers.cs
index 4cf012ab..9c0b4bb1 100644
--- a/sources/Valkey.Glide/Internals/Helpers.cs
+++ b/sources/Valkey.Glide/Internals/Helpers.cs
@@ -64,4 +64,22 @@ public static GlideString[] ConvertKeyValuePairsToArray(KeyValuePair<GlideString
         }
         return result;
     }
+
+    /// <summary>
+    /// Skips the first <paramref name="skip"/> elements from an async sequence.
+    /// </summary>
+    public static async IAsyncEnumerable<T> SkipAsync<T>(this IAsyncEnumerable<T> source, int skip)
+    {
+        int skipped = 0;
+        await foreach (T item in source)
+        {
+            if (skipped < skip)
+            {
+                skipped++;
+                continue;
+            }
+
+            yield return item;
+        }
+    }
 }
diff --git a/tests/Valkey.Glide.IntegrationTests/HashCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/HashCommandTests.cs
index e2f94351..b9f3b053 100644
--- a/tests/Valkey.Glide.IntegrationTests/HashCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/HashCommandTests.cs
@@ -8,7 +8,6 @@ namespace Valkey.Glide.IntegrationTests;
 
 public class HashCommandTests(TestConfiguration config)
 {
-    // TODO #280: Cleanup this class
     public TestConfiguration Config { get; } = config;
 
     #region HashSetAsync
diff --git a/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs b/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs
index f3bf6191..1fe7b391 100644
--- a/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs
@@ -9,8 +9,6 @@
 
 namespace Valkey.Glide.IntegrationTests;
 
-// TODO: even though collections aren't executed in parallel, tests in a collection still parallelized
-//       better to run tests in the named collections sequentially
 [Collection(typeof(SharedBatchTests))]
 [CollectionDefinition(DisableParallelization = true)]
 public class SharedBatchTests
@@ -29,8 +27,12 @@ public async Task BatchRaiseOnError(BaseClient client, bool isAtomic)
         string key2 = "{BatchRaiseOnError}" + Guid.NewGuid();
 
         Pipeline.IBatch batch = isCluster ? new ClusterBatch(isAtomic) : new Batch(isAtomic);
-        // TODO replace custom command
-        _ = batch.Set(key1, "hello").CustomCommand(["lpop", key1]).CustomCommand(["del", key1]).CustomCommand(["rename", key1, key2]);
+
+        _ = batch
+            .Set(key1, "hello")
+            .ListLeftPop(key1)
+            .Delete(key1)
+            .Rename(key1, key2);
 
         object?[] res = isCluster
             ? (await ((GlideClusterClient)client).Exec((ClusterBatch)batch, false))!
diff --git a/tests/Valkey.Glide.IntegrationTests/SharedCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/SharedCommandTests.cs
index 77c4cc28..40071b7a 100644
--- a/tests/Valkey.Glide.IntegrationTests/SharedCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/SharedCommandTests.cs
@@ -38,7 +38,6 @@ internal async Task BatchTest(BatchTestData testData)
                 }
                 else
                 {
-                    // TODO use assertDeepEquals
                     Assert.Equivalent(expectedInfo[i].ExpectedValue, actualResult[i]);
                 }
             }
diff --git a/tests/Valkey.Glide.IntegrationTests/Skip.cs b/tests/Valkey.Glide.IntegrationTests/Skip.cs
index e1aa3fbe..4f7b9cb5 100644
--- a/tests/Valkey.Glide.IntegrationTests/Skip.cs
+++ b/tests/Valkey.Glide.IntegrationTests/Skip.cs
@@ -16,12 +16,12 @@ internal static class Skip
     private static readonly Version Valkey9_0 = new("9.0.0");
 
     /// <summary>
-    /// Skips the test if hash field expiry commands are not supported.
+    /// Skips the test if background save cancel commands are not supported.
     /// </summary>
-    public static void IfHashExpireNotSupported()
+    public static void IfBgSaveCancelNotSupported()
         => Assert.SkipWhen(
-            TestConfiguration.SERVER_VERSION < Valkey9_0,
-            "Hash expire commands require Valkey 9.0+");
+            TestConfiguration.SERVER_VERSION < Valkey8_1,
+            "Background save cancel commands require Valkey 8.1+");
 
     /// <summary>
     /// Skips the test if bit index type commands are not supported.
@@ -31,6 +31,14 @@ public static void IfBitIndexTypeNotSupported()
             TestConfiguration.SERVER_VERSION < Valkey7_0,
             "Bit index type commands require Valkey 7.0+");
 
+    /// <summary>
+    /// Skips the test if hash field expiry commands are not supported.
+    /// </summary>
+    public static void IfHashExpireNotSupported()
+        => Assert.SkipWhen(
+            TestConfiguration.SERVER_VERSION < Valkey9_0,
+            "Hash expire commands require Valkey 9.0+");
+
     /// <summary>
     /// Skips the test if set intersection cardinality commands are not supported.
     /// </summary>
@@ -40,12 +48,12 @@ public static void IfSetInterCardNotSupported()
             "Set intersection cardinality commands require Valkey 7.0+");
 
     /// <summary>
-    /// Skips the test if background save cancel commands are not supported.
+    /// Skips the test if sorted set pop commands are not supported.
     /// </summary>
-    public static void IfBgSaveCancelNotSupported()
+    public static void IfSortedSetPopNotSupported()
         => Assert.SkipWhen(
-            TestConfiguration.SERVER_VERSION < Valkey8_1,
-            "Background save cancel commands require Valkey 8.1+");
+            TestConfiguration.SERVER_VERSION < Valkey7_0,
+            "Sorted set pop commands (ZMPOP, BZMPOP, ZINTERCARD) require Valkey 7.0+");
 
     #endregion
     #region Module Checks
diff --git a/tests/Valkey.Glide.IntegrationTests/SortedSetCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/SortedSetCommandTests.cs
index 54cf5280..49440996 100644
--- a/tests/Valkey.Glide.IntegrationTests/SortedSetCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/SortedSetCommandTests.cs
@@ -900,8 +900,8 @@ public async Task TestSortedSetIncrement(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetInterCard(BaseClient client)
     {
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "ZINTERCARD is supported since 7.0.0"
-        );
+        Skip.IfSortedSetPopNotSupported();
+
         string key1 = $"{{sortedSetKey}}-{Guid.NewGuid()}";
         string key2 = $"{{sortedSetKey}}-{Guid.NewGuid()}";
         string key3 = $"{{sortedSetKey}}-{Guid.NewGuid()}";
@@ -988,8 +988,8 @@ public async Task TestSortedSetLexCount(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetPopMultiKey(BaseClient client)
     {
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "ZMPOP is supported since 7.0.0"
-        );
+        Skip.IfSortedSetPopNotSupported();
+
         string key1 = $"{{sortedSetKey}}1-{Guid.NewGuid()}";
         string key2 = $"{{sortedSetKey}}2-{Guid.NewGuid()}";
         string emptyKey = $"{{sortedSetKey}}empty-{Guid.NewGuid()}";
@@ -1066,8 +1066,8 @@ public async Task TestSortedSetScores(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetBlockingPop(BaseClient client)
     {
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "BZMPOP is supported since 7.0.0"
-        );
+        Skip.IfSortedSetPopNotSupported();
+
         string key1 = $"{{testKey}}-{Guid.NewGuid()}";
         string key2 = $"{{testKey}}-{Guid.NewGuid()}";
 
@@ -1119,9 +1119,8 @@ public async Task TestSortedSetBlockingPop(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetBlockingCommands_NonExistentKeys(BaseClient client)
     {
-        // TODO sorted sets
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "BZMPOP is supported since 7.0.0"
-        );
+        Skip.IfSortedSetPopNotSupported();
+
         string key1 = $"{{testKey}}-{Guid.NewGuid()}";
         string key2 = $"{{testKey}}-{Guid.NewGuid()}";
 
@@ -1636,7 +1635,7 @@ public async Task TestSortedSetUnionAndStore(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetPopMinAsync_MultiKey(BaseClient client)
     {
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "ZMPOP is supported since 7.0.0");
+        Skip.IfSortedSetPopNotSupported();
 
         string key1 = $"{{testKey}}-{Guid.NewGuid()}";
         string key2 = $"{{testKey}}-{Guid.NewGuid()}";
@@ -1662,7 +1661,7 @@ public async Task TestSortedSetPopMinAsync_MultiKey(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetPopMaxAsync_MultiKey(BaseClient client)
     {
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "ZMPOP is supported since 7.0.0");
+        Skip.IfSortedSetPopNotSupported();
 
         string key1 = $"{{testKey}}-{Guid.NewGuid()}";
 
@@ -1683,7 +1682,7 @@ public async Task TestSortedSetPopMaxAsync_MultiKey(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetPopMinAsync_MultiKey_WithCount(BaseClient client)
     {
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "ZMPOP is supported since 7.0.0");
+        Skip.IfSortedSetPopNotSupported();
 
         string key1 = $"{{testKey}}-{Guid.NewGuid()}";
         string key2 = $"{{testKey}}-{Guid.NewGuid()}";
@@ -1715,7 +1714,7 @@ public async Task TestSortedSetPopMinAsync_MultiKey_WithCount(BaseClient client)
     [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
     public async Task TestSortedSetPopMaxAsync_MultiKey_WithCount(BaseClient client)
     {
-        Assert.SkipWhen(TestConfiguration.IsVersionLessThan("7.0.0"), "ZMPOP is supported since 7.0.0");
+        Skip.IfSortedSetPopNotSupported();
 
         string key1 = $"{{testKey}}-{Guid.NewGuid()}";
 
diff --git a/tests/Valkey.Glide.IntegrationTests/StandaloneClientTests.cs b/tests/Valkey.Glide.IntegrationTests/StandaloneClientTests.cs
index 5ccc9e14..f2268538 100644
--- a/tests/Valkey.Glide.IntegrationTests/StandaloneClientTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/StandaloneClientTests.cs
@@ -67,8 +67,6 @@ public async Task CanConnectWithDifferentParameters()
 
     [Theory(DisableDiscoveryEnumeration = true)]
     [MemberData(nameof(Config.TestStandaloneClients), MemberType = typeof(TestConfiguration))]
-    // Verify that client can handle complex return types, not just strings
-    // TODO: remove this test once we add tests with these commands
     public async Task CustomCommandWithDifferentReturnTypes(GlideClient client)
     {
         string key1 = Guid.NewGuid().ToString();
diff --git a/tests/Valkey.Glide.IntegrationTests/StreamCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/StreamCommandTests.cs
index abf7d202..63871607 100644
--- a/tests/Valkey.Glide.IntegrationTests/StreamCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/StreamCommandTests.cs
@@ -817,7 +817,6 @@ public async Task StreamRangeAsync_DuplicateFieldNames(BaseClient client)
         Assert.Equal("value3", result[0].Values[2].Value.ToString());
     }
 
-    // // TODO "legacy"
     // [Theory(DisableDiscoveryEnumeration = true)]
     // [MemberData(nameof(TestConfiguration.TestClients), MemberType = typeof(TestConfiguration))]
     // public async Task StreamCreateConsumerGroupAsync_LegacyOverload(BaseClient client)
@@ -827,7 +826,6 @@ public async Task StreamRangeAsync_DuplicateFieldNames(BaseClient client)
     //     _ = await client.StreamCreateConsumerGroupAsync(key, "mygroup", "0");
     // }
 
-    // // TODO "legacy"
     // [Theory(DisableDiscoveryEnumeration = true)]
     // [MemberData(nameof(TestConfiguration.TestClients), MemberType = typeof(TestConfiguration))]
     // public async Task StreamReadGroupAsync_LegacyOverload_SingleStream(BaseClient client)
@@ -839,7 +837,6 @@ public async Task StreamRangeAsync_DuplicateFieldNames(BaseClient client)
     //     _ = Assert.Single(entries);
     // }
 
-    // // TODO "legacy"
     // [Theory(DisableDiscoveryEnumeration = true)]
     // [MemberData(nameof(TestConfiguration.TestClients), MemberType = typeof(TestConfiguration))]
     // public async Task StreamReadGroupAsync_LegacyOverload_MultipleStreams(BaseClient client)

From 35ac7def0da04093814279ab5ff061adb074fad1 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Wed, 22 Jul 2026 15:51:20 -0700
Subject: [PATCH 05/31] Second batch of TODO comment fixes and removals.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/Database.StreamCommands.cs       | 40 ++++++++----
 .../Abstract/IDatabaseAsync.StreamCommands.cs | 14 ++++-
 .../Client/BaseClient.StreamCommands.cs       | 17 +++--
 .../Client/IBaseClient.StreamCommands.cs      | 16 +++--
 .../Commands/Options/ScanOptions.cs           | 52 +++++++++++++++
 sources/Valkey.Glide/Internals/FFI.structs.cs |  2 -
 .../Internals/Request.SetCommands.cs          | 19 +++---
 sources/Valkey.Glide/Internals/Request.cs     | 63 +++++--------------
 tests/Valkey.Glide.UnitTests/CommandTests.cs  |  8 +--
 9 files changed, 138 insertions(+), 93 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
index 2e6719c4..d3014462 100644
--- a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
@@ -200,17 +200,22 @@ public Task<StreamAutoClaimJustIdResult> StreamAutoClaimIdsOnlyAsync(ValkeyKey k
 
     /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, int, bool, CommandFlags)"/>
     public Task<long> StreamTrimAsync(ValkeyKey key, int maxLength, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None)
-    {
-        GuardClauses.ThrowIfCommandFlags(flags);
-        return Command(Request.StreamTrimAsync(key, maxLength, default, useApproximateMaxLength, null));
-    }
+        => StreamTrimAsync(key, maxLength, useApproximateMaxLength);
 
-    /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, long?, bool, long?, StreamTrimMode, CommandFlags)"/>
-    public Task<long> StreamTrimAsync(ValkeyKey key, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
+    /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, long, bool, long?, StreamTrimMode, CommandFlags)"/>
+    public Task<long> StreamTrimAsync(ValkeyKey key, long maxLength, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
         ThrowIfUnsupportedTrimMode(trimMode);
-        return Command(Request.StreamTrimAsync(key, maxLength, default, useApproximateMaxLength, limit));
+
+        var options = new StreamTrimOptions.MaxLen
+        {
+            MaxLength = maxLength,
+            Exact = !useApproximateMaxLength,
+            Limit = limit
+        };
+
+        return StreamTrimAsync(key, options);
     }
 
     /// <inheritdoc cref="IDatabaseAsync.StreamTrimByMinIdAsync(ValkeyKey, ValkeyValue, bool, long?, StreamTrimMode, CommandFlags)"/>
@@ -218,7 +223,15 @@ public Task<long> StreamTrimByMinIdAsync(ValkeyKey key, ValkeyValue minId, bool
     {
         GuardClauses.ThrowIfCommandFlags(flags);
         ThrowIfUnsupportedTrimMode(trimMode);
-        return Command(Request.StreamTrimAsync(key, null, minId, useApproximateMaxLength, limit));
+
+        var options = new StreamTrimOptions.MinId
+        {
+            MinEntryId = minId,
+            Exact = !useApproximateMaxLength,
+            Limit = limit
+        };
+
+        return StreamTrimAsync(key, options);
     }
 
     /// <inheritdoc cref="IDatabaseAsync.StreamInfoAsync(ValkeyKey, CommandFlags)"/>
@@ -248,12 +261,17 @@ public Task<StreamConsumerInfo[]> StreamConsumerInfoAsync(ValkeyKey key, ValkeyV
     /// <summary>
     /// Converts the given arguments to a <see cref="StreamAddOptions"/> instance.
     /// </summary>
-    private static StreamAddOptions ToStreamAddOptions(ValkeyValue? messageId, long? maxLength, bool useApproximateMaxLength, long? limit = null) => new()
+    private static StreamAddOptions ToStreamAddOptions(
+        ValkeyValue? messageId,
+        long? maxLength,
+        bool useApproximateMaxLength,
+        long? limit = null)
+    => new()
     {
         Id = messageId ?? StreamAddOptions.AutoGenerateId,
         Trim = maxLength.HasValue
-            ? new StreamTrimOptions.MaxLen { MaxLength = maxLength.Value, Exact = !useApproximateMaxLength, Limit = limit }
-            : null
+                ? new StreamTrimOptions.MaxLen { MaxLength = maxLength.Value, Exact = !useApproximateMaxLength, Limit = limit }
+                : null
     };
 
     /// <summary>
diff --git a/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs b/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
index a54fccf9..dd09c67f 100644
--- a/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
@@ -344,14 +344,24 @@ public partial interface IDatabaseAsync
     /// <param name="flags">Command flags (currently not supported by GLIDE).</param>
     /// <returns>The number of entries removed.</returns>
     /// <exception cref="NotImplementedException">Thrown if <paramref name="flags"/> is not <see cref="CommandFlags.None"/>.</exception>
-    Task<long> StreamTrimAsync(ValkeyKey key, int maxLength, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None);
+    Task<long> StreamTrimAsync(
+        ValkeyKey key,
+        int maxLength,
+        bool useApproximateMaxLength = false,
+        CommandFlags flags = CommandFlags.None);
 
     /// <inheritdoc cref="StreamTrimAsync(ValkeyKey, int, bool, CommandFlags)" path="/*[not(self::param[@name='maxLength']) and not(self::returns)]"/>
     /// <param name="maxLength">The maximum number of entries to keep.</param>
     /// <param name="limit">The maximum number of entries to evict per call.</param>
     /// <param name="trimMode">The trim mode to use.</param>
     /// <returns>The number of entries removed.</returns>
-    Task<long> StreamTrimAsync(ValkeyKey key, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None);
+    Task<long> StreamTrimAsync(
+        ValkeyKey key,
+        long maxLength,
+        bool useApproximateMaxLength = false,
+        long? limit = null,
+        StreamTrimMode trimMode = StreamTrimMode.KeepReferences,
+        CommandFlags flags = CommandFlags.None);
 
     #endregion
     #region StreamTrimByMinIdAsync
diff --git a/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs b/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs
index 9efe805d..a0598794 100644
--- a/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs
@@ -166,16 +166,13 @@ public Task<bool> StreamDeleteAsync(ValkeyKey key, ValkeyValue messageId)
     //     => await Command(Request.StreamAutoClaimJustIdAsync(key, consumerGroup, claimingConsumer, minIdleTime, startAtId, count));
     // #endregion
 
-    // #region XTRIM
-    // public async Task<long> StreamTrimAsync(ValkeyKey key, int maxLength, bool useApproximateMaxLength)
-    //     => await StreamTrimAsync(key, maxLength, useApproximateMaxLength, null);
-    //
-    // public async Task<long> StreamTrimAsync(ValkeyKey key, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null)
-    //     => await Command(Request.StreamTrimAsync(key, maxLength, default, useApproximateMaxLength, limit));
-    //
-    // public async Task<long> StreamTrimByMinIdAsync(ValkeyKey key, ValkeyValue minId, bool useApproximateMaxLength = false, long? limit = null)
-    //     => await Command(Request.StreamTrimAsync(key, null, minId, useApproximateMaxLength, limit));
-    // #endregion
+    #region StreamTrimAsync
+
+    /// <inheritdoc cref="IBaseClient.StreamTrimAsync(ValkeyKey, StreamTrimOptions)"/>
+    public Task<long> StreamTrimAsync(ValkeyKey key, StreamTrimOptions options)
+        => Command(Request.StreamTrimAsync(key, options));
+
+    #endregion
 
     // #region XINFO
     // public async Task<StreamInfo> StreamInfoAsync(ValkeyKey key)
diff --git a/sources/Valkey.Glide/Client/IBaseClient.StreamCommands.cs b/sources/Valkey.Glide/Client/IBaseClient.StreamCommands.cs
index 577013fa..f09e48cf 100644
--- a/sources/Valkey.Glide/Client/IBaseClient.StreamCommands.cs
+++ b/sources/Valkey.Glide/Client/IBaseClient.StreamCommands.cs
@@ -249,10 +249,18 @@ public partial interface IBaseClient
     // Task<bool> StreamConsumerGroupSetPositionAsync(ValkeyKey key, ValkeyValue groupName, ValkeyValue position, long? entriesRead = null);
     // #endregion
 
-    // #region XTRIM
-    // Task<long> StreamTrimAsync(ValkeyKey key, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null);
-    // Task<long> StreamTrimByMinIdAsync(ValkeyKey key, ValkeyValue minId, bool useApproximateMaxLength = false, long? limit = null);
-    // #endregion
+    #region StreamTrimAsync
+
+    /// <summary>
+    /// Trims the stream stored at <paramref name="key"/>.
+    /// </summary>
+    /// <param name="key">The key of the stream.</param>
+    /// <param name="options">The stream trim options.</param>
+    /// <returns>The number of entries removed from the stream.</returns>
+    /// <seealso href="https://valkey.io/commands/xtrim/">Valkey commands - XTRIM</seealso>
+    Task<long> StreamTrimAsync(ValkeyKey key, StreamTrimOptions options);
+
+    #endregion
 
     // #region XCLAIM
     // Task<StreamEntry[]> StreamClaimAsync(ValkeyKey key, ValkeyValue consumerGroup, ValkeyValue claimingConsumer, TimeSpan minIdleTime, IEnumerable<ValkeyValue> messageIds, StreamClaimOptions options);
diff --git a/sources/Valkey.Glide/Commands/Options/ScanOptions.cs b/sources/Valkey.Glide/Commands/Options/ScanOptions.cs
index ecd4e755..905ff72f 100644
--- a/sources/Valkey.Glide/Commands/Options/ScanOptions.cs
+++ b/sources/Valkey.Glide/Commands/Options/ScanOptions.cs
@@ -5,8 +5,13 @@ namespace Valkey.Glide.Commands.Options;
 /// <summary>
 /// Options for the scan commands.
 /// </summary>
+/// <seealso href="https://valkey.io/commands/scan/">Valkey commands - SCAN</seealso>
+/// <seealso href="https://valkey.io/commands/sscan/">Valkey commands - SSCAN</seealso>
+/// <seealso href="https://valkey.io/commands/zscan/">Valkey commands - ZSCAN</seealso>
 public class ScanOptions
 {
+    #region Public Properties
+
     /// <summary>
     /// Pattern to filter keys against.
     /// </summary>
@@ -21,4 +26,51 @@ public class ScanOptions
     /// Type to filter keys against.
     /// </summary>
     public ValkeyType? Type { get; set; }
+
+    #endregion
+    #region Internal Methods
+
+    /// <summary>
+    /// Converts the options to command arguments.
+    /// </summary>
+    internal GlideString[] ToArgs()
+    {
+        List<GlideString> args = [];
+
+        if (!MatchPattern.IsNull)
+        {
+            args.Add(ValkeyLiterals.MATCH);
+            args.Add(MatchPattern.ToGlideString());
+        }
+
+        if (Count.HasValue)
+        {
+            args.Add(ValkeyLiterals.COUNT);
+            args.Add(Count.Value.ToGlideString());
+        }
+
+        if (Type.HasValue)
+        {
+            args.Add(ValkeyLiterals.TYPE);
+            args.Add(ToType(Type.Value));
+        }
+
+        return [.. args];
+    }
+
+    /// <summary>
+    /// Converts the ValkeyType enum to a string.
+    /// </summary>
+    private static GlideString ToType(ValkeyType type) => type switch
+    {
+        ValkeyType.String => "string",
+        ValkeyType.List => "list",
+        ValkeyType.Set => "set",
+        ValkeyType.SortedSet => "zset",
+        ValkeyType.Hash => "hash",
+        ValkeyType.Stream => "stream",
+        ValkeyType.Unknown or ValkeyType.None or _ => throw new ArgumentException($"Unsupported ValkeyType '{type}'")
+    };
+
+    #endregion
 }
diff --git a/sources/Valkey.Glide/Internals/FFI.structs.cs b/sources/Valkey.Glide/Internals/FFI.structs.cs
index 48d8919f..7c0f52cf 100644
--- a/sources/Valkey.Glide/Internals/FFI.structs.cs
+++ b/sources/Valkey.Glide/Internals/FFI.structs.cs
@@ -1144,8 +1144,6 @@ private struct ConnectionRequest
         [MarshalAs(UnmanagedType.U1)]
         public bool HasClientSideCacheConfig;
         public ClientSideCacheConfig ClientSideCacheConfig;
-
-        // TODO more config params, see ffi.rs
     }
 
     [StructLayout(LayoutKind.Sequential)]
diff --git a/sources/Valkey.Glide/Internals/Request.SetCommands.cs b/sources/Valkey.Glide/Internals/Request.SetCommands.cs
index f62011c1..0c337bc6 100644
--- a/sources/Valkey.Glide/Internals/Request.SetCommands.cs
+++ b/sources/Valkey.Glide/Internals/Request.SetCommands.cs
@@ -70,23 +70,18 @@ public static Cmd<GlideString, ValkeyValue> SetRandomMemberAsync(ValkeyKey key)
         => new(RequestType.SRandMember, [key.ToGlideString()], true, response => response is null ? ValkeyValue.Null : (ValkeyValue)response, allowConverterToHandleNull: true);
 
     public static Cmd<object[], ValkeyValue[]> SetRandomMembersAsync(ValkeyKey key, long count)
-        => new(RequestType.SRandMember, [key.ToGlideString(), count.ToGlideString()], false, arr => [.. arr.Cast<GlideString>().Select(gs => (ValkeyValue)gs)]);
+        => new(RequestType.SRandMember, [key.ToGlideString(), count.ToGlideString()], false, ToValkeyValueArray);
 
     public static Cmd<bool, bool> SetMoveAsync(ValkeyKey source, ValkeyKey destination, ValkeyValue value)
         => Simple<bool>(RequestType.SMove, [source.ToGlideString(), destination.ToGlideString(), value.ToGlideString()]);
 
     public static Cmd<object[], (long, ValkeyValue[])> SetScanAsync(ValkeyKey key, long cursor, ScanOptions? options = null)
-    {
-        List<GlideString> args = [key.ToGlideString(), cursor.ToGlideString()];
-
-        args.AddRange(ToScanArgs(options));
+        => new(RequestType.SScan, [key, cursor.ToGlideString(), .. options?.ToArgs() ?? []], false, ConvertSetScanResponse);
 
-        return new(RequestType.SScan, [.. args], false, arr =>
-        {
-            object[] scanArray = arr;
-            long nextCursor = long.Parse(((GlideString)scanArray[0]).ToString());
-            ValkeyValue[] elements = [.. ((object[])scanArray[1]).Cast<GlideString>().Select(gs => (ValkeyValue)gs)];
-            return (nextCursor, elements);
-        });
+    private static (long cursor, ValkeyValue[] items) ConvertSetScanResponse(object[] response)
+    {
+        var cursor = response[0] is long l ? l : long.Parse(response[0].ToString()!);
+        var items = ToValkeyValueArray((object[])response[1]);
+        return (cursor, items);
     }
 }
diff --git a/sources/Valkey.Glide/Internals/Request.cs b/sources/Valkey.Glide/Internals/Request.cs
index 990a66f3..73359fe9 100644
--- a/sources/Valkey.Glide/Internals/Request.cs
+++ b/sources/Valkey.Glide/Internals/Request.cs
@@ -93,51 +93,6 @@ private static Dictionary<ValkeyKey, long> ToValkeyKeyLongDict(Dictionary<GlideS
         return result;
     }
 
-    // TODO should not be internal. Move all related logic to requests.
-    /// <summary>
-    /// Converts scan options to an array of arguments.
-    /// </summary>
-    internal static GlideString[] ToScanArgs(ScanOptions? options)
-    {
-        if (options is null)
-        {
-            return [];
-        }
-
-        List<GlideString> args = [];
-
-        if (!options.MatchPattern.IsNull)
-        {
-            args.Add(ValkeyLiterals.MATCH);
-            args.Add(options.MatchPattern.ToGlideString());
-        }
-
-        if (options.Count.HasValue)
-        {
-            args.Add(ValkeyLiterals.COUNT);
-            args.Add(options.Count.Value.ToGlideString());
-        }
-
-        if (options.Type.HasValue)
-        {
-            args.Add(ValkeyLiterals.TYPE);
-            args.Add(ToType(options.Type.Value));
-        }
-
-        return [.. args];
-    }
-
-    private static GlideString ToType(ValkeyType type) => type switch
-    {
-        ValkeyType.String => "string",
-        ValkeyType.List => "list",
-        ValkeyType.Set => "set",
-        ValkeyType.SortedSet => "zset",
-        ValkeyType.Hash => "hash",
-        ValkeyType.Stream => "stream",
-        ValkeyType.Unknown or ValkeyType.None or _ => throw new ArgumentException($"Unsupported ValkeyType for SCAN: {type}")
-    };
-
     /// <summary>
     /// Appends SetExpiryOptions arguments (PX/PXAT/KEEPTTL) to the args list.
     /// </summary>
@@ -159,16 +114,28 @@ private static void AddExpiryArgs(List<GlideString> args, SetExpiryOptions optio
         }
     }
 
-    #region Set Converters
+    #region Collection Converters
 
     /// <summary>
-    /// Converts the given objects to an <see cref="ISet{ValkeyKey}"/>.
+    /// Converts the given objects to a <see cref="ValkeyKey"/> array.
+    /// </summary>
+    private static ValkeyKey[] ToValkeyKeyArray(IEnumerable<object> items)
+        => [.. items.Cast<GlideString>().Select(gs => (ValkeyKey)gs.Bytes)];
+
+    /// <summary>
+    /// Converts the given objects to a <see cref="ValkeyKey"/> set.
     /// </summary>
     private static ISet<ValkeyKey> ToValkeyKeySet(IEnumerable<object> items)
         => new HashSet<ValkeyKey>(items.Cast<GlideString>().Select(gs => (ValkeyKey)gs.Bytes));
 
     /// <summary>
-    /// Converts the given objects to an <see cref="ISet{ValkeyValue}"/>.
+    /// Converts the given objects to a <see cref="ValkeyValue"/> array.
+    /// </summary>
+    private static ValkeyValue[] ToValkeyValueArray(object[] items)
+        => [.. items.Cast<GlideString>().Select(gs => (ValkeyValue)gs)];
+
+    /// <summary>
+    /// Converts the given objects to a <see cref="ValkeyValue"/> set.
     /// </summary>
     private static ISet<ValkeyValue> ToValkeyValueSet(IEnumerable<object> items)
         => new HashSet<ValkeyValue>(items.Cast<GlideString>().Select(gs => (ValkeyValue)gs));
diff --git a/tests/Valkey.Glide.UnitTests/CommandTests.cs b/tests/Valkey.Glide.UnitTests/CommandTests.cs
index 2847feee..b1d73b94 100644
--- a/tests/Valkey.Glide.UnitTests/CommandTests.cs
+++ b/tests/Valkey.Glide.UnitTests/CommandTests.cs
@@ -1006,9 +1006,9 @@ public void ValidateStreamCommandArgs()
             () => Assert.Equal(["XDEL", "key", "1-0", "2-0"], Request.StreamDeleteAsync("key", ["1-0", "2-0"]).GetArgs()),
 
             // StreamTrim
-            () => Assert.Equal(["XTRIM", "key", "MAXLEN", "1000"], Request.StreamTrimAsync("key", 1000, default, false, null).GetArgs()),
-            () => Assert.Equal(["XTRIM", "key", "MAXLEN", "~", "1000"], Request.StreamTrimAsync("key", 1000, default, true, null).GetArgs()),
-            () => Assert.Equal(["XTRIM", "key", "MINID", "0-1"], Request.StreamTrimAsync("key", null, "0-1", false, null).GetArgs()),
+            () => Assert.Equal(["XTRIM", "key", "MAXLEN", "1000"], Request.StreamTrimAsync("key", new StreamTrimOptions.MaxLen { MaxLength = 1000 }).GetArgs()),
+            () => Assert.Equal(["XTRIM", "key", "MAXLEN", "~", "1000"], Request.StreamTrimAsync("key", new StreamTrimOptions.MaxLen { MaxLength = 1000, Exact = false }).GetArgs()),
+            () => Assert.Equal(["XTRIM", "key", "MINID", "0-1"], Request.StreamTrimAsync("key", new StreamTrimOptions.MinId { MinEntryId = "0-1" }).GetArgs()),
 
             // StreamCreateConsumerGroup
             () => Assert.Equal(["XGROUPCREATE", "key", "group", "$", "MKSTREAM"], Request.StreamCreateConsumerGroupAsync("key", "group", default, true, null).GetArgs()),
@@ -1095,7 +1095,7 @@ public void ValidateStreamCommandConverters()
             () => Assert.Equal(0L, Request.StreamDeleteAsync("key", ["1-0"]).Converter(0L)),
 
             // StreamTrim
-            () => Assert.Equal(10L, Request.StreamTrimAsync("key", 100, default, false, null).Converter(10L)),
+            () => Assert.Equal(10L, Request.StreamTrimAsync("key", new StreamTrimOptions.MaxLen { MaxLength = 100 }).Converter(10L)),
 
             // StreamCreateConsumerGroup
             () => Assert.True(Request.StreamCreateConsumerGroupAsync("key", "group", default, true, null).Converter("OK")),

From 2e68930400ac3037f537166442d890f46fd225fc Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Wed, 22 Jul 2026 16:13:56 -0700
Subject: [PATCH 06/31] Third batch of TODO comment fixes and removals.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 sources/Valkey.Glide/Client/BaseClient.SetCommands.cs |  7 ++-----
 .../Client/BaseClient.SortedSetCommands.cs            | 11 ++++-------
 sources/Valkey.Glide/Client/GlideClusterClient.cs     |  8 ++++----
 3 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
index 902bc828..726dcdf2 100644
--- a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
@@ -88,7 +88,6 @@ public async Task<ValkeyValue[]> SetRandomMembersAsync(ValkeyKey key, long count
     public async Task<bool> SetMoveAsync(ValkeyKey source, ValkeyKey destination, ValkeyValue value)
         => await Command(Request.SetMoveAsync(source, destination, value));
 
-    // TODO #287
     /// <inheritdoc cref="IBaseClient.SetScanAsync(ValkeyKey, ScanOptions?)"/>
     public async IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ScanOptions? options = null)
     {
@@ -96,14 +95,12 @@ public async IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ScanOptio
 
         do
         {
-            (var nextCursor, var elements) = await Command(Request.SetScanAsync(key, cursor, options));
-
-            foreach (ValkeyValue element in elements)
+            (cursor, var elements) = await Command(Request.SetScanAsync(key, cursor, options));
+            foreach (var element in elements)
             {
                 yield return element;
             }
 
-            cursor = nextCursor;
         } while (cursor != 0);
     }
 }
diff --git a/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs b/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
index c8c6c83a..e1972f85 100644
--- a/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
@@ -248,22 +248,19 @@ public async Task<SortedSetPopResult> SortedSetBlockingPopAsync(IEnumerable<Valk
             ? await SortedSetPopMinAsync(keys, count, timeout)
             : await SortedSetPopMaxAsync(keys, count, timeout);
 
-    // TODO #287
     /// <inheritdoc cref="IBaseClient.SortedSetScanAsync(ValkeyKey, ScanOptions?)"/>
     public async IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, ScanOptions? options = null)
     {
-        long currentCursor = 0;
+        long cursor = 0;
 
         do
         {
-            (long nextCursor, SortedSetEntry[] elements) = await Command(Request.SortedSetScanAsync(key, currentCursor, options));
-
-            foreach (SortedSetEntry element in elements)
+            (cursor, var elements) = await Command(Request.SortedSetScanAsync(key, cursor, options));
+            foreach (var element in elements)
             {
                 yield return element;
             }
 
-            currentCursor = nextCursor;
-        } while (currentCursor != 0);
+        } while (cursor != 0);
     }
 }
diff --git a/sources/Valkey.Glide/Client/GlideClusterClient.cs b/sources/Valkey.Glide/Client/GlideClusterClient.cs
index c510fb63..3514d5ef 100644
--- a/sources/Valkey.Glide/Client/GlideClusterClient.cs
+++ b/sources/Valkey.Glide/Client/GlideClusterClient.cs
@@ -102,10 +102,10 @@ protected override async Task<Version> GetServerVersionAsync()
     /// <param name="cursor">The cursor for the scan iteration.</param>
     /// <param name="args">Additional arguments for the scan command.</param>
     /// <returns>A tuple containing the next cursor and the keys found in this iteration.</returns>
-    private async Task<(string cursor, ValkeyKey[] keys)> ClusterScanCommand(string cursor, string[] args)
+    private async Task<(ClusterScanCursor cursor, ValkeyKey[] keys)> ClusterScanCommand(ClusterScanCursor cursor, string[] args)
     {
         var message = MessageContainer.GetMessageForCall();
-        IntPtr cursorPtr = Marshal.StringToHGlobalAnsi(cursor);
+        IntPtr cursorPtr = Marshal.StringToHGlobalAnsi(cursor.CursorId);
 
         IntPtr[]? argPtrs = null;
         IntPtr argsPtr = IntPtr.Zero;
@@ -140,8 +140,8 @@ protected override async Task<Version> GetServerVersionAsync()
             {
                 var result = HandleResponse(response);
                 var array = (object[])result!;
-                var nextCursor = array[0]!.ToString()!;
-                var keys = ((object[])array[1]!).Select(k => new ValkeyKey(k!.ToString())).ToArray();
+                var nextCursor = new ClusterScanCursor(array[0]!.ToString()!);
+                var keys = ((object[])array[1]!).Cast<GlideString>().Select(gs => (ValkeyKey)gs.Bytes).ToArray();
                 return (nextCursor, keys);
             }
             finally

From ac1376bf17bf3a93bc5a3ebefb49ecd72c38f5e1 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Wed, 22 Jul 2026 16:18:14 -0700
Subject: [PATCH 07/31] feat(check-todos): add ignore file support for TODO
 checker

Add dev/conf/check-todos-ignore to specify files excluded from TODO
validation using fnmatch glob patterns. This prevents the checker from
flagging its own comments.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/conf/check-todos-ignore |  4 ++++
 dev/scripts/check_todos.py  | 29 ++++++++++++++++++++++++++---
 2 files changed, 30 insertions(+), 3 deletions(-)
 create mode 100644 dev/conf/check-todos-ignore

diff --git a/dev/conf/check-todos-ignore b/dev/conf/check-todos-ignore
new file mode 100644
index 00000000..f212fb53
--- /dev/null
+++ b/dev/conf/check-todos-ignore
@@ -0,0 +1,4 @@
+# Files excluded from the TODO checker (dev/scripts/check_todos.py).
+# Patterns use fnmatch-style glob matching against repo-relative paths.
+
+dev/scripts/check_todos.py
diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
index d14ef839..96f7174f 100644
--- a/dev/scripts/check_todos.py
+++ b/dev/scripts/check_todos.py
@@ -11,9 +11,12 @@
     python dev/scripts/check_todos.py
 """
 
+import os
 import re
 import subprocess
 import sys
+from fnmatch import fnmatch
+from pathlib import Path
 from typing import NamedTuple
 
 from _constants import GITHUB_REPO, PROJECT_ROOT
@@ -27,12 +30,29 @@ class _Todo(NamedTuple):
     text: str
 
 
-# Matches a TODO inside a comment, optionally capturing the issue number.
-# A match with no `github_id` capture means the TODO is missing an issue reference.
 _TODO_PATTERN = re.compile(
     r"(//|#|/\*|\*|<!--).*TODO\b(\s+#(?P<github_id>\d+))?", re.IGNORECASE
 )
 
+_IGNORE_FILE = os.path.join(PROJECT_ROOT, "dev", "conf", "check-todos-ignore")
+
+
+def _load_ignore_patterns() -> list[str]:
+    """Load ignore patterns from the check-todos-ignore file."""
+    if not os.path.isfile(_IGNORE_FILE):
+        print(f"Error: ignore file not found: {_IGNORE_FILE}", file=sys.stderr)
+        sys.exit(1)
+
+    return [
+        ignore for line in Path(_IGNORE_FILE).read_text().splitlines()
+        if (ignore := line.strip()) and not ignore.startswith("#")
+    ]
+
+
+def _is_ignored(filepath: str, patterns: list[str]) -> bool:
+    """Check if a filepath matches any exclusion pattern."""
+    return any(fnmatch(filepath, p) for p in patterns)
+
 
 def _find_todos() -> list[_Todo]:
     """Find all TODO comments in tracked files using git grep."""
@@ -49,12 +69,15 @@ def _find_todos() -> list[_Todo]:
         print(f"Error: git grep failed: {result.stderr.strip()}", file=sys.stderr)
         sys.exit(1)
 
+    ignored_patterns = _load_ignore_patterns()
+
     todos = []
     for line in result.stdout.splitlines():
         parts = line.split(":", 2)
         if len(parts) == 3:
             filepath, line_no, text = parts
-            todos.append(_Todo(filepath, int(line_no), text.strip()))
+            if not _is_ignored(filepath, ignored_patterns):
+                todos.append(_Todo(filepath, int(line_no), text.strip()))
 
     return todos
 

From 67fc692f749fe61561ddfd80a0a16b6bbeef835f Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 07:44:09 -0700
Subject: [PATCH 08/31] Fourth batch of TODO comment fixes and removals.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .github/workflows/cd.yml                      |  8 +++--
 DEVELOPER.md                                  |  8 ++---
 dev/conf/check-todos-ignore                   |  1 +
 dev/scripts/get_licenses_from_ort.py          |  1 -
 .../Abstract/ConnectionMultiplexer.cs         |  6 ++--
 sources/Valkey.Glide/Client/GlideClient.cs    | 32 +------------------
 .../Valkey.Glide/Client/GlideClusterClient.cs | 29 ++---------------
 sources/Valkey.Glide/Errors.cs                |  2 --
 sources/Valkey.Glide/GlideString.cs           |  7 ++--
 sources/Valkey.Glide/Internals/FFI.structs.cs |  2 +-
 sources/Valkey.Glide/Internals/Helpers.cs     | 22 -------------
 sources/Valkey.Glide/Valkey.Glide.nuspec      | 11 +++----
 12 files changed, 25 insertions(+), 104 deletions(-)

diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
index b04570ff..bf2e0d6b 100644
--- a/.github/workflows/cd.yml
+++ b/.github/workflows/cd.yml
@@ -158,8 +158,12 @@ jobs:
             - name: Pack the client
               working-directory: sources/Valkey.Glide
               run: |
-                  dotnet build Valkey.Glide.csproj --configuration Release "/property:Version=$RELEASE_VERSION"
-                  dotnet pack Valkey.Glide.csproj --configuration Release "-p:NuspecProperties=version=$RELEASE_VERSION"
+                  dotnet build Valkey.Glide.csproj \
+                    --configuration Release \
+                    "/property:Version=$RELEASE_VERSION"
+                  dotnet pack Valkey.Glide.csproj \
+                    --configuration Release \
+                    "-p:NuspecProperties=version=$RELEASE_VERSION;commit=${{ github.sha }}"
                   tree -h bin/Release
                   unzip -l "bin/Release/Valkey.Glide.$RELEASE_VERSION.nupkg"
                   unzip -l "bin/Release/Valkey.Glide.$RELEASE_VERSION.snupkg"
diff --git a/DEVELOPER.md b/DEVELOPER.md
index 847f00d7..8c5ba406 100644
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@@ -368,10 +368,10 @@ task lint:markdown  # Run Markdown linter
 Run checks to validate examples, links, and TODO comments.
 
 ```bash
-task check           # Run all checks
-task check:examples  # Check C# examples in comments
-task check:links     # Check for broken links
-task check:todos     # Check that TODO comments reference an open GitHub issue
+task check
+task check:examples
+task check:links
+task check:todos
 ```
 
 ## Test framework and Style
diff --git a/dev/conf/check-todos-ignore b/dev/conf/check-todos-ignore
index f212fb53..092e2b09 100644
--- a/dev/conf/check-todos-ignore
+++ b/dev/conf/check-todos-ignore
@@ -1,4 +1,5 @@
 # Files excluded from the TODO checker (dev/scripts/check_todos.py).
 # Patterns use fnmatch-style glob matching against repo-relative paths.
 
+dev/conf/check-todos-ignore
 dev/scripts/check_todos.py
diff --git a/dev/scripts/get_licenses_from_ort.py b/dev/scripts/get_licenses_from_ort.py
index a6a77753..4fdee179 100644
--- a/dev/scripts/get_licenses_from_ort.py
+++ b/dev/scripts/get_licenses_from_ort.py
@@ -10,7 +10,6 @@
 The script outputs a set of licenses identified by the analyzer. GLIDE maintainers should review the returned list to ensure that all licenses are approved.
 """
 
-# TODO: Modify to use logic operations instead of including AND and OR in strings
 APPROVED_LICENSES = [
     "(Apache-2.0 OR MIT) AND Unicode-DFS-2016",
     "Unicode-3.0",
diff --git a/sources/Valkey.Glide/Abstract/ConnectionMultiplexer.cs b/sources/Valkey.Glide/Abstract/ConnectionMultiplexer.cs
index 8555e5f3..cd8e3fc4 100644
--- a/sources/Valkey.Glide/Abstract/ConnectionMultiplexer.cs
+++ b/sources/Valkey.Glide/Abstract/ConnectionMultiplexer.cs
@@ -121,8 +121,6 @@ public IServer GetServer(EndPoint endpoint)
         throw new ArgumentException("The specified endpoint is not defined", nameof(endpoint));
     }
 
-    // TODO currently this returns only primary node on standalone
-    // https://github.com/valkey-io/valkey-glide/issues/4293
     /// <inheritdoc/>
     public IServer[] GetServers()
     {
@@ -134,7 +132,7 @@ public IServer[] GetServers()
         }
         else
         {
-            // due to #4293, core ignores route on standalone and always return a single node response
+            // glide-core ignores route on standalone and always returns a single node response
             string info = _db.Command(Request.Info([]), Route.AllNodes).GetAwaiter().GetResult();
             // and there is no way to get IP address from server, assuming localhost (127.0.0.1)
             // we can try to get port only (in some deployments, this info is also missing)
@@ -375,7 +373,9 @@ internal void RemoveAllSubscriptions()
         lock (_subscriptions)
         {
             foreach (var sub in _subscriptions.Values)
+            {
                 sub.Dispose();
+            }
 
             _subscriptions.Clear();
         }
diff --git a/sources/Valkey.Glide/Client/GlideClient.cs b/sources/Valkey.Glide/Client/GlideClient.cs
index 1bbcfdfa..92700069 100644
--- a/sources/Valkey.Glide/Client/GlideClient.cs
+++ b/sources/Valkey.Glide/Client/GlideClient.cs
@@ -20,40 +20,10 @@ public partial class GlideClient :
 {
     internal GlideClient() { }
 
-    // TODO add pubsub and other params to example and remarks
     /// <summary>
     /// Creates a new <see cref="GlideClient" /> instance and establishes a connection to a standalone Valkey server.
     /// </summary>
-    /// <remarks>
-    /// <b>Remarks:</b>
-    /// Use this static method to create and connect a <see cref="GlideClient" /> to a standalone Valkey server.<br />
-    /// The client will automatically handle connection establishment, including any authentication and TLS configurations.
-    /// <list type="bullet">
-    ///   <item>
-    ///     <b>Authentication</b>: If credentials are provided, the client will attempt to authenticate using the specified username and password.
-    ///   </item>
-    ///   <item>
-    ///     <b>TLS</b>: If <see cref="ClientConfigurationBuilder{T}.UseTls" /> is set to <see langword="true" />, the client will establish a secure connection using <c>TLS</c>.
-    ///   </item>
-    ///   <item>
-    ///     <b>Reconnection Strategy</b>: The <see cref="RetryStrategy" /> settings define how the client will attempt to reconnect in case of disconnections.
-    ///   </item>
-    /// </list>
-    /// <example>
-    /// <code>
-    /// var config = new ConnectionConfiguration.StandaloneClientConfigurationBuilder()
-    ///     .WithAddress("primary.example.com", 6379)
-    ///     .WithAddress("replica1.example.com", 6379)
-    ///     .WithDatabaseId(1)
-    ///     .WithAuthentication("user1", "passwordA")
-    ///     .WithTls()
-    ///     .WithConnectionRetryStrategy(5, 100, 2)
-    ///     .Build();
-    /// await using var client = await GlideClient.CreateClient(config);
-    /// </code>
-    /// </example>
-    /// </remarks>
-    /// <param name="config">The configuration options for the client, including server addresses, authentication credentials, TLS settings, database selection, reconnection strategy, and Pub/Sub subscriptions.</param>
+    /// <param name="config">The configuration options for the client.</param>
     /// <returns>A task that resolves to a connected <see cref="GlideClient" /> instance.</returns>
     public static async Task<GlideClient> CreateClient(StandaloneClientConfiguration config)
         => await CreateClient(config, () => new GlideClient());
diff --git a/sources/Valkey.Glide/Client/GlideClusterClient.cs b/sources/Valkey.Glide/Client/GlideClusterClient.cs
index 3514d5ef..5a350378 100644
--- a/sources/Valkey.Glide/Client/GlideClusterClient.cs
+++ b/sources/Valkey.Glide/Client/GlideClusterClient.cs
@@ -26,36 +26,11 @@ public sealed partial class GlideClusterClient :
 {
     private GlideClusterClient() { }
 
-    // TODO add pubsub and other params to example and remarks
     /// <summary>
     /// Creates a new <see cref="GlideClusterClient" /> instance and establishes a connection to a cluster of Valkey servers.<br />
     /// </summary>
-    /// <remarks>
-    /// <b>Remarks:</b>
-    /// Use this static method to create and connect a <see cref="GlideClusterClient" /> to a Valkey Cluster.<br />
-    /// The client will automatically handle connection establishment, including cluster topology discovery and handling of authentication and TLS configurations.
-    /// <list type="bullet">
-    ///   <item>
-    ///     <b>Authentication</b>: If credentials are provided, the client will attempt to authenticate using the specified username and password.
-    ///   </item>
-    ///   <item>
-    ///     <b>TLS</b>: If <see cref="ClientConfigurationBuilder{T}.UseTls" /> is set to <see langword="true" />, the client will establish a secure connection using <c>TLS</c>.
-    ///   </item>
-    /// </list>
-    /// <example>
-    /// <code>
-    /// var config = new ConnectionConfiguration.ClusterClientConfigurationBuilder()
-    ///     .WithAddress("address1.example.com", 6379)
-    ///     .WithAddress("address2.example.com", 6379)
-    ///     .WithAuthentication("user1", "passwordA")
-    ///     .WithTls()
-    ///     .Build();
-    /// await using var client = await GlideClusterClient.CreateClient(config);
-    /// </code>
-    /// </example>
-    /// </remarks>
-    /// <param name="config">The configuration options for the client, including cluster addresses, authentication credentials, TLS settings, periodic checks, and Pub/Sub subscriptions.</param>
-    /// <returns>A task that resolves to a connected <see cref="GlideClient" /> instance.</returns>
+    /// <param name="config">The configuration options for the client.</param>
+    /// <returns>A task that resolves to a connected <see cref="GlideClusterClient" /> instance.</returns>
     public static async Task<GlideClusterClient> CreateClient(ClusterClientConfiguration config)
         => await CreateClient(config, () => new GlideClusterClient());
 
diff --git a/sources/Valkey.Glide/Errors.cs b/sources/Valkey.Glide/Errors.cs
index 941db9c6..26dfc3e6 100644
--- a/sources/Valkey.Glide/Errors.cs
+++ b/sources/Valkey.Glide/Errors.cs
@@ -164,8 +164,6 @@ public ConnectionException(string message, Exception innerException) : base(mess
     /// </summary>
     public sealed class ConfigurationError : GlideException
     {
-        // TODO set HelpLink with link to wiki
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ConfigurationError"/> class.
         /// </summary>
diff --git a/sources/Valkey.Glide/GlideString.cs b/sources/Valkey.Glide/GlideString.cs
index 1b611c88..ed50e2db 100644
--- a/sources/Valkey.Glide/GlideString.cs
+++ b/sources/Valkey.Glide/GlideString.cs
@@ -291,12 +291,9 @@ public bool CanConvertToString()
                 return (bool)_canConvertToString;
             }
 
-            // TODO find a better way to check this
-            // Detect whether `bytes` could be represented by a UTF-8 string without data corruption
-            string tmpStr = Encoding.UTF8.GetString(Bytes);
-            if (Encoding.UTF8.GetBytes(tmpStr).SequenceEqual(Bytes))
+            if (System.Text.Unicode.Utf8.IsValid(Bytes))
             {
-                Str = tmpStr;
+                Str = Encoding.UTF8.GetString(Bytes);
                 _canConvertToString = true;
                 return true;
             }
diff --git a/sources/Valkey.Glide/Internals/FFI.structs.cs b/sources/Valkey.Glide/Internals/FFI.structs.cs
index 7c0f52cf..d7e08153 100644
--- a/sources/Valkey.Glide/Internals/FFI.structs.cs
+++ b/sources/Valkey.Glide/Internals/FFI.structs.cs
@@ -609,7 +609,7 @@ private struct BatchOptionsInfo
         public IntPtr Route;
     }
 
-    // TODO: generate this with a bindings generator
+    // TODO #472: Auto-generate this enum
     internal enum RequestType : int
     {
         /// Invalid request type
diff --git a/sources/Valkey.Glide/Internals/Helpers.cs b/sources/Valkey.Glide/Internals/Helpers.cs
index 9c0b4bb1..17c856ac 100644
--- a/sources/Valkey.Glide/Internals/Helpers.cs
+++ b/sources/Valkey.Glide/Internals/Helpers.cs
@@ -10,11 +10,6 @@ internal static class Helpers
     public static Dictionary<string, T> DownCastKeys<T>(this Dictionary<GlideString, T> dict)
         => dict.Select(p => (Key: p.Key.ToString(), p.Value)).ToDictionary(p => p.Key, p => p.Value);
 
-    // TODO make recursive?
-    // Downcast dictionary values from `GlideString` to `string`
-    public static Dictionary<T, string> DownCastVals<T>(this Dictionary<T, GlideString> dict) where T : class
-        => dict.Select(p => (p.Key, Value: p.Value.ToString())).ToDictionary(p => p.Key, p => p.Value);
-
     // Convert values in a dictionary from V to T where input dict has type `Dictionary<K, V>` and returns `Dictionary<K, T>`
     public static Dictionary<K, T> ConvertValues<K, V, T>(this Dictionary<K, V> dict, Func<V, T> converter) where K : notnull
         => dict.Select(p => (p.Key, Value: converter(p.Value))).ToDictionary(p => p.Key, p => p.Value);
@@ -48,23 +43,6 @@ public static string GetRealTypeName(this Type t)
         return sb.Append('>').ToString();
     }
 
-    /// <summary>
-    /// Converts a KeyValuePair array to an array of key-value pairs for use with MSet command.
-    /// </summary>
-    /// <param name="values">The key-value pairs to convert.</param>
-    /// <returns>An array where keys and values are interleaved: [key1, value1, key2, value2, ...]</returns>
-    public static GlideString[] ConvertKeyValuePairsToArray(KeyValuePair<GlideString, GlideString>[] values)
-    {
-        GlideString[] result = new GlideString[values.Length * 2];
-        int index = 0;
-        foreach (KeyValuePair<GlideString, GlideString> kvp in values)
-        {
-            result[index++] = kvp.Key;
-            result[index++] = kvp.Value;
-        }
-        return result;
-    }
-
     /// <summary>
     /// Skips the first <paramref name="skip"/> elements from an async sequence.
     /// </summary>
diff --git a/sources/Valkey.Glide/Valkey.Glide.nuspec b/sources/Valkey.Glide/Valkey.Glide.nuspec
index 90e3eb0a..166261f0 100644
--- a/sources/Valkey.Glide/Valkey.Glide.nuspec
+++ b/sources/Valkey.Glide/Valkey.Glide.nuspec
@@ -9,14 +9,12 @@
     <description>General Language Independent Driver for the Enterprise (GLIDE) for Valkey</description>
     <projectUrl>https://github.com/valkey-io/valkey-glide-csharp</projectUrl>
     <license type="expression">Apache-2.0</license>
-    <!-- TODO other fields from schema: https://github.com/NuGet/NuGet.Client/blob/dev/src/NuGet.Core/NuGet.Packaging/compiler/resources/nuspec.xsd -->
     <readme>README.md</readme>
     <icon>icon.png</icon>
-    <repository type="git" url="https://github.com/valkey-io/valkey-glide-csharp" /> <!-- TODO: commit="$GitCommitId$" -->
+    <repository type="git" url="https://github.com/valkey-io/valkey-glide-csharp" commit="$commit$" />
     <tags>open-source performance database csharp key-value fault-tolerance cache reliability pubsub valkey valkey-client</tags>
     <copyright>Copyright © 2025 Valkey GLIDE Maintainers</copyright>
-    <!-- TODO include changelog (as a file or as GH release link) starting from the second release -->
-    <!-- TODO do we need empty dependency blocks? -->
+    <releaseNotes>https://github.com/valkey-io/valkey-glide-csharp/releases</releaseNotes>
     <dependencies>
       <group targetFramework="net8.0" />
     </dependencies>
@@ -29,8 +27,9 @@
     <!-- PDB files and sources are included into symbol package only -->
     <file src="bin\Release\**\Valkey.Glide.pdb" target="lib" />
 
-    <!-- TODO: make binaries optional/conditional, build fails on a dev's PC who doesn't have all files. Alternative: use different nuspec files -->
-    <!-- see runtime IDs in https://learn.microsoft.com/en-us/dotnet/core/rid-catalog -->
+    <!-- Native binaries for each supported platform. These are cross-compiled by the CD
+         workflow and are not available locally — `dotnet pack` will fail without them.
+         See runtime IDs: https://learn.microsoft.com/en-us/dotnet/core/rid-catalog -->
     <file src="../../bin/x86_64-unknown-linux-gnu/libglide_rs.so" target="runtimes/linux-x64/native" />
     <file src="../../bin/aarch64-unknown-linux-gnu/libglide_rs.so" target="runtimes/linux-arm64/native" />
     <file src="../../bin/x86_64-apple-darwin/libglide_rs.dylib" target="runtimes/osx-x64/native" />

From 287825e68722e40e9845d6ef3cf09e028280b42e Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 08:01:02 -0700
Subject: [PATCH 09/31] Add a minimum description length

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/scripts/check_todos.py | 37 ++++++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
index 96f7174f..7130d2f1 100644
--- a/dev/scripts/check_todos.py
+++ b/dev/scripts/check_todos.py
@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 
-"""Check that all TODO comments reference an open GitHub issue.
+"""Check that all TODO comments follow the required format.
 
 Validation rules:
-  1. Every TODO must include a GitHub issue reference with format `TODO #<number>`.
-  2. The referenced number must correspond to an existing Valkey GLIDE C# GitHub issue.
-  3. The referenced issue must be open.
+  1. Every TODO must follow the format `TODO #<number>: <description>`.
+  2. The description should provide a summary of the proposed changes, and must be at least 10 characters long.
+  3. The referenced number must correspond to an open Valkey GLIDE C# GitHub issue.
 
 Usage:
     python dev/scripts/check_todos.py
@@ -30,10 +30,16 @@ class _Todo(NamedTuple):
     text: str
 
 
+# Matches TODO comments and captures GitHub issue ID and description.
 _TODO_PATTERN = re.compile(
-    r"(//|#|/\*|\*|<!--).*TODO\b(\s+#(?P<github_id>\d+))?", re.IGNORECASE
+    r"(//|#|/\*|\*|<!--).*TODO\b(\s+#(?P<github_id>\d+)(:\s+(?P<description>.+))?)?",
+    re.IGNORECASE,
 )
 
+# Minimum length for the description.
+_MIN_DESCRIPTION_LENGTH = 10
+
+# File path patterns to ignore.
 _IGNORE_FILE = os.path.join(PROJECT_ROOT, "dev", "conf", "check-todos-ignore")
 
 
@@ -116,12 +122,21 @@ def _validate_todos(todos: list[_Todo]) -> dict[_Todo, str]:
 
         if not github_id:
             failures[todo] = "missing GitHub issue reference"
-        else:
-            issue_num = int(github_id)
-            if issue_num not in checked_issues:
-                checked_issues[issue_num] = _check_issue(issue_num)
-            if checked_issues[issue_num]:
-                failures[todo] = checked_issues[issue_num]
+            continue
+
+        description = match.group("description")
+        if description is None:
+            failures[todo] = "missing description (expected format: TODO #<number>: <description>)"
+            continue
+        if len(description.strip()) < _MIN_DESCRIPTION_LENGTH:
+            failures[todo] = f"description too short (must be at least {_MIN_DESCRIPTION_LENGTH} characters)"
+            continue
+
+        issue_num = int(github_id)
+        if issue_num not in checked_issues:
+            checked_issues[issue_num] = _check_issue(issue_num)
+        if checked_issues[issue_num]:
+            failures[todo] = checked_issues[issue_num]
 
     return failures
 

From 17a5de93a5d2161c6d5152b659876cf2e98b6b6c Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 08:04:39 -0700
Subject: [PATCH 10/31] refactor: Move coverage config files to dev/conf

Move coverage-baseline.json and .runsettings from dev/coverage/ to
dev/conf/ (renamed to coverage-runsettings.xml) to consolidate config
files. Update all references in CI workflows, scripts, and docs.

Also add TODO format documentation and description validation to the
check-todos script.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .github/workflows/test.yml                       |  4 ++--
 DEVELOPER.md                                     | 15 +++++++++++++++
 dev/{coverage => conf}/coverage-baseline.json    |  0
 .../coverage-runsettings.xml}                    |  0
 dev/scripts/_constants.py                        |  6 ++++--
 docs/coverage.md                                 | 16 +++++++++-------
 6 files changed, 30 insertions(+), 11 deletions(-)
 rename dev/{coverage => conf}/coverage-baseline.json (100%)
 rename dev/{coverage/.runsettings => conf/coverage-runsettings.xml} (100%)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index ffb607e0..c90e165b 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -81,8 +81,8 @@ jobs:
             - name: Determine whether to run with coverage
               shell: bash
               run: |
-                  SERVER_TYPE=$(jq -r '.server_type' dev/coverage/coverage-baseline.json)
-                  SERVER_VERSION=$(jq -r '.server_version' dev/coverage/coverage-baseline.json)
+                  SERVER_TYPE=$(jq -r '.server_type' dev/conf/coverage-baseline.json)
+                  SERVER_VERSION=$(jq -r '.server_version' dev/conf/coverage-baseline.json)
 
                   RUN_COVERAGE=false
                   if [[ "${{ matrix.dotnet }}" == "8.0" \
diff --git a/DEVELOPER.md b/DEVELOPER.md
index 8c5ba406..2299f1b0 100644
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@@ -374,6 +374,21 @@ task check:links
 task check:todos
 ```
 
+### Inline TODOs
+
+All TODO comments must follow the format `TODO #<number>: <description>`, where:
+
+- `<number>` is an open GitHub issue in this repository.
+- `<description>` is a short explanation of what needs to change (at least 10 characters).
+
+Example:
+
+```csharp
+// TODO #472: Auto-generate this enum from the Rust source.
+```
+
+Files can be excluded from validation via `dev/conf/check-todos-ignore` (fnmatch glob patterns, one per line).
+
 ## Test framework and Style
 
 The CSharp Valkey-Glide client uses xUnit v3 for testing code. The test code styles are defined in `.editorconfing` (see `dotnet_diagnostic.xUnit..` rules). The xUnit rules are enforced by the [xUnit analyzers](https://github.com/xunit/xunit.analyzers) referenced in the main xunit.v3 NuGet package. If you choose to use xunit.v3.core instead, you can reference xunit.analyzers explicitly. For additional info, please, refer to <https://xunit.NET> and <https://github.com/xunit/xunit>
diff --git a/dev/coverage/coverage-baseline.json b/dev/conf/coverage-baseline.json
similarity index 100%
rename from dev/coverage/coverage-baseline.json
rename to dev/conf/coverage-baseline.json
diff --git a/dev/coverage/.runsettings b/dev/conf/coverage-runsettings.xml
similarity index 100%
rename from dev/coverage/.runsettings
rename to dev/conf/coverage-runsettings.xml
diff --git a/dev/scripts/_constants.py b/dev/scripts/_constants.py
index 7275c23b..7ff9a407 100644
--- a/dev/scripts/_constants.py
+++ b/dev/scripts/_constants.py
@@ -14,11 +14,13 @@
 SOURCES_DIR = os.path.join(PROJECT_ROOT, "sources")
 LIBRARY_DIR = os.path.join(SOURCES_DIR, "Valkey.Glide")
 
+CONF_DIR = os.path.join(PROJECT_ROOT, "dev", "conf")
+COVERAGE_BASELINE_PATH = os.path.join(CONF_DIR, "coverage-baseline.json")
+COVERAGE_RUNSETTINGS_PATH = os.path.join(CONF_DIR, "coverage-runsettings.xml")
+
 COVERAGE_DIR = os.path.join(PROJECT_ROOT, "dev", "coverage")
 COVERAGE_RESULTS_DIR = os.path.join(COVERAGE_DIR, "results")
 COVERAGE_REPORTS_DIR = os.path.join(COVERAGE_DIR, "reports")
-COVERAGE_BASELINE_PATH = os.path.join(COVERAGE_DIR, "coverage-baseline.json")
-COVERAGE_RUNSETTINGS_PATH = os.path.join(COVERAGE_DIR, ".runsettings")
 
 COVERAGE_REPORTS_COMBINED_DIR = os.path.join(COVERAGE_REPORTS_DIR, "combined")
 COVERAGE_REPORT_COMBINED_INDEX_PATH = os.path.join(
diff --git a/docs/coverage.md b/docs/coverage.md
index c0ce4556..b73bf687 100644
--- a/docs/coverage.md
+++ b/docs/coverage.md
@@ -2,8 +2,8 @@
 
 This project includes support for measuring line and branch coverage, including a coverage baseline and checks to ensure coverage does not decrease.
 
-![Line coverage](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fvalkey-io%2Fvalkey-glide-csharp%2Fmain%2Fdev%2Fcoverage%2Fcoverage-baseline.json&query=%24.line_coverage&suffix=%25&label=Line%20Coverage)
-![Branch coverage](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fvalkey-io%2Fvalkey-glide-csharp%2Fmain%2Fdev%2Fcoverage%2Fcoverage-baseline.json&query=%24.branch_coverage&suffix=%25&label=Branch%20Coverage)
+![Line coverage](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fvalkey-io%2Fvalkey-glide-csharp%2Fmain%2Fdev%2Fconf%2Fcoverage-baseline.json&query=%24.line_coverage&suffix=%25&label=Line%20Coverage)
+![Branch coverage](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fvalkey-io%2Fvalkey-glide-csharp%2Fmain%2Fdev%2Fconf%2Fcoverage-baseline.json&query=%24.branch_coverage&suffix=%25&label=Branch%20Coverage)
 
 ## How It Works
 
@@ -53,13 +53,15 @@ The coverage check passes only when measured coverage **exactly matches** the ba
 ## File Layout
 
 ```text
+dev/conf/
+├── coverage-baseline.json     # Coverage baseline
+└── coverage-runsettings.xml   # Coverlet configuration
+
 dev/coverage/
-├── coverage-baseline.json   # Coverage baseline
-├── .runsettings             # Coverlet configuration
-├── results/                 # Raw .cobertura.xml coverage results
+├── results/                   # Raw .cobertura.xml coverage results (gitignored)
 │   ├── unit/
 │   └── integration/
-└── reports/                 # Generated HTML/JSON reports
+└── reports/                   # Generated HTML/JSON reports (gitignored)
     ├── unit/
     ├── integration/
     └── combined/
@@ -67,7 +69,7 @@ dev/coverage/
 
 ## Baseline File
 
-The coverage baseline file (`dev/coverage/coverage-baseline.json`) stores the coverage baseline and the server configuration used to collect it.
+The coverage baseline file (`dev/conf/coverage-baseline.json`) stores the coverage baseline and the server configuration used to collect it.
 
 Example:
 

From 6842f368e1b43417058e0d40a983897f9b60b436 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 09:25:13 -0700
Subject: [PATCH 11/31] refactor: Simplify scan methods to delegate to GLIDE
 internals

- Add protected cursor-accepting overloads to BaseClient for
  SetScanAsync and SortedSetScanAsync
- Add internal ScanKeysAsync to GlideClient for key scanning
- SER scan methods now delegate to GLIDE methods with SkipAsync
  for pageOffset support
- ValkeyServer.KeysAsync uses private ScanWithRouteAsync to
  preserve per-node routing via MakeRoute()

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/Database.SetCommands.cs            |  2 +-
 .../Abstract/Database.SortedSetCommands.cs      |  2 +-
 sources/Valkey.Glide/Abstract/ValkeyServer.cs   | 16 +++++++++++++++-
 .../Client/BaseClient.SetCommands.cs            | 15 ++++++++++++---
 .../Client/BaseClient.SortedSetCommands.cs      | 15 ++++++++++++---
 .../Client/GlideClient.GenericCommands.cs       | 17 ++++++++---------
 sources/Valkey.Glide/Client/GlideClient.cs      |  2 ++
 7 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/Database.SetCommands.cs b/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
index f19e8733..663c235a 100644
--- a/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
@@ -149,7 +149,7 @@ public IAsyncEnumerable<ValkeyValue> SetScanAsync(
         GuardClauses.ThrowIfCommandFlags(flags);
 
         var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
-        return SetScanAsync(key, options).SkipAsync(pageOffset);
+        return SetScanAsync(key, cursor, options).SkipAsync(pageOffset);
     }
 
     private async Task<ISet<ValkeyValue>> GetCombineResultAsync(SetOperation operation, IEnumerable<ValkeyKey> keys) => operation switch
diff --git a/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs b/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
index 44f01988..72e18735 100644
--- a/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
@@ -302,7 +302,7 @@ public IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(
         GuardClauses.ThrowIfCommandFlags(flags);
 
         var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
-        return SortedSetScanAsync(key, options).SkipAsync(pageOffset);
+        return SortedSetScanAsync(key, cursor, options).SkipAsync(pageOffset);
     }
 
     /// <inheritdoc cref="IBaseClient.SortedSetBlockingPopAsync(ValkeyKey, Order, TimeSpan)"/>
diff --git a/sources/Valkey.Glide/Abstract/ValkeyServer.cs b/sources/Valkey.Glide/Abstract/ValkeyServer.cs
index 6c498560..392571d7 100644
--- a/sources/Valkey.Glide/Abstract/ValkeyServer.cs
+++ b/sources/Valkey.Glide/Abstract/ValkeyServer.cs
@@ -292,7 +292,7 @@ public IAsyncEnumerable<ValkeyKey> KeysAsync(
         GuardClauses.ThrowIfCommandFlags(flags);
 
         var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
-        return _conn.ScanAsync(options).SkipAsync(pageOffset);
+        return ScanAsync(cursor.ToString(), options).SkipAsync(pageOffset);
     }
 
     /// <inheritdoc/>
@@ -320,5 +320,19 @@ private Route MakeRoute()
         return new ByAddressRoute(host, port);
     }
 
+    private async IAsyncEnumerable<ValkeyKey> ScanAsync(string cursor, ScanOptions options)
+    {
+        var route = MakeRoute();
+
+        do
+        {
+            (cursor, ValkeyKey[] keys) = await _conn.Command(Request.ScanAsync(cursor, options), route);
+            foreach (ValkeyKey key in keys)
+            {
+                yield return key;
+            }
+        } while (cursor != "0");
+    }
+
     #endregion
 }
diff --git a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
index 726dcdf2..6adf5567 100644
--- a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
@@ -8,6 +8,8 @@ namespace Valkey.Glide;
 
 public abstract partial class BaseClient
 {
+    #region Public Methods
+
     /// <inheritdoc cref="ISetBaseCommands.SetAddAsync(ValkeyKey, ValkeyValue)"/>
     public async Task<bool> SetAddAsync(ValkeyKey key, ValkeyValue value)
         => await Command(Request.SetAddAsync(key, value));
@@ -89,10 +91,15 @@ public async Task<bool> SetMoveAsync(ValkeyKey source, ValkeyKey destination, Va
         => await Command(Request.SetMoveAsync(source, destination, value));
 
     /// <inheritdoc cref="IBaseClient.SetScanAsync(ValkeyKey, ScanOptions?)"/>
-    public async IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ScanOptions? options = null)
-    {
-        long cursor = 0;
+    public IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ScanOptions? options = null)
+        => SetScanAsync(key, 0, options);
+
+    #endregion
+    #region Internal Methods
 
+    /// <inheritdoc cref="IBaseClient.SetScanAsync(ValkeyKey, ScanOptions?)"/>
+    protected async IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, long cursor, ScanOptions? options)
+    {
         do
         {
             (cursor, var elements) = await Command(Request.SetScanAsync(key, cursor, options));
@@ -103,4 +110,6 @@ public async IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ScanOptio
 
         } while (cursor != 0);
     }
+
+    #endregion
 }
diff --git a/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs b/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
index e1972f85..a39d22b6 100644
--- a/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
@@ -8,6 +8,8 @@ namespace Valkey.Glide;
 
 public abstract partial class BaseClient
 {
+    #region Public Methods
+
     /// <inheritdoc cref="ISortedSetBaseCommands.SortedSetAddAsync(ValkeyKey, ValkeyValue, double)"/>
     public Task<bool> SortedSetAddAsync(ValkeyKey key, ValkeyValue member, double score)
         => Command(Request.SortedSetAddAsync(key, member, score));
@@ -249,10 +251,15 @@ public async Task<SortedSetPopResult> SortedSetBlockingPopAsync(IEnumerable<Valk
             : await SortedSetPopMaxAsync(keys, count, timeout);
 
     /// <inheritdoc cref="IBaseClient.SortedSetScanAsync(ValkeyKey, ScanOptions?)"/>
-    public async IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, ScanOptions? options = null)
-    {
-        long cursor = 0;
+    public IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, ScanOptions? options = null)
+        => SortedSetScanAsync(key, 0, options);
+
+    #endregion
+    #region Protected Methods
 
+    /// <inheritdoc cref="IBaseClient.SortedSetScanAsync(ValkeyKey, ScanOptions?)"/>
+    protected async IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, long cursor, ScanOptions? options)
+    {
         do
         {
             (cursor, var elements) = await Command(Request.SortedSetScanAsync(key, cursor, options));
@@ -263,4 +270,6 @@ public async IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key,
 
         } while (cursor != 0);
     }
+
+    #endregion
 }
diff --git a/sources/Valkey.Glide/Client/GlideClient.GenericCommands.cs b/sources/Valkey.Glide/Client/GlideClient.GenericCommands.cs
index ae6a4fab..8de9de55 100644
--- a/sources/Valkey.Glide/Client/GlideClient.GenericCommands.cs
+++ b/sources/Valkey.Glide/Client/GlideClient.GenericCommands.cs
@@ -17,21 +17,20 @@ public async Task<bool> MigrateAsync(IEnumerable<ValkeyKey> keys, MigrateOptions
         => await Command(Request.ScanAsync(cursor, options));
 
     /// <inheritdoc cref="IGlideClient.ScanAsync(ScanOptions?)"/>
-    public async IAsyncEnumerable<ValkeyKey> ScanAsync(ScanOptions? options = null)
-    {
-        string currentCursor = "0";
+    public IAsyncEnumerable<ValkeyKey> ScanAsync(ScanOptions? options = null)
+        => ScanKeysAsync("0", options);
 
+    /// <inheritdoc cref="IGlideClient.ScanAsync(ScanOptions?)"/>
+    internal async IAsyncEnumerable<ValkeyKey> ScanKeysAsync(string cursor, ScanOptions? options)
+    {
         do
         {
-            (string nextCursor, ValkeyKey[] keys) = await Command(Request.ScanAsync(currentCursor, options));
-
-            foreach (ValkeyKey key in keys)
+            (cursor, var keys) = await Command(Request.ScanAsync(cursor, options));
+            foreach (var key in keys)
             {
                 yield return key;
             }
-
-            currentCursor = nextCursor;
-        } while (currentCursor != "0");
+        } while (cursor != "0");
     }
 
     /// <inheritdoc cref="ITransactionCommands.UnwatchAsync()"/>
diff --git a/sources/Valkey.Glide/Client/GlideClient.cs b/sources/Valkey.Glide/Client/GlideClient.cs
index 92700069..faf501ab 100644
--- a/sources/Valkey.Glide/Client/GlideClient.cs
+++ b/sources/Valkey.Glide/Client/GlideClient.cs
@@ -58,4 +58,6 @@ protected override async Task<Version> GetServerVersionAsync()
 
         return _serverVersion;
     }
+
+    
 }

From 3714bc293925fe2be72a8f113116007007b68781 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 09:37:33 -0700
Subject: [PATCH 12/31] fix: Fix StreamTrimAsync infinite recursion and add
 guard clauses

The int overload of StreamTrimAsync called itself due to parameter
resolution. Cast to long to target the correct overload, and add
ThrowIfNegative validation for maxLength.

- Add GuardClauses.ThrowIfNegative(long, string)
- Add GuardClauses.ThrowIfUnsupported(StreamTrimMode)
- Move ThrowIfUnsupportedTrimMode logic to GuardClauses

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/Database.StreamCommands.cs       | 21 +++++----------
 .../Valkey.Glide/Internals/GuardClauses.cs    | 27 +++++++++++++++++++
 2 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
index d3014462..da45588e 100644
--- a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
@@ -200,13 +200,16 @@ public Task<StreamAutoClaimJustIdResult> StreamAutoClaimIdsOnlyAsync(ValkeyKey k
 
     /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, int, bool, CommandFlags)"/>
     public Task<long> StreamTrimAsync(ValkeyKey key, int maxLength, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None)
-        => StreamTrimAsync(key, maxLength, useApproximateMaxLength);
+    {
+        GuardClauses.ThrowIfNegative(maxLength, nameof(maxLength));
+        return StreamTrimAsync(key, (long)maxLength, useApproximateMaxLength, flags: flags);
+    }
 
     /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, long, bool, long?, StreamTrimMode, CommandFlags)"/>
     public Task<long> StreamTrimAsync(ValkeyKey key, long maxLength, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
-        ThrowIfUnsupportedTrimMode(trimMode);
+        GuardClauses.ThrowIfUnsupported(trimMode);
 
         var options = new StreamTrimOptions.MaxLen
         {
@@ -222,7 +225,7 @@ public Task<long> StreamTrimAsync(ValkeyKey key, long maxLength, bool useApproxi
     public Task<long> StreamTrimByMinIdAsync(ValkeyKey key, ValkeyValue minId, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
-        ThrowIfUnsupportedTrimMode(trimMode);
+        GuardClauses.ThrowIfUnsupported(trimMode);
 
         var options = new StreamTrimOptions.MinId
         {
@@ -275,17 +278,5 @@ private static StreamAddOptions ToStreamAddOptions(
     };
 
     /// <summary>
-    /// Throws a <see cref="NotImplementedException"/> if the stream trim mode is not supported.
-    /// </summary>
-    /// <param name="trimMode">The stream trim mode to validate.</param>
-    /// <exception cref="NotImplementedException">Thrown if <paramref name="trimMode"/> is not <see cref="StreamTrimMode.KeepReferences"/>.</exception>
-    private static void ThrowIfUnsupportedTrimMode(StreamTrimMode trimMode)
-    {
-        if (trimMode != StreamTrimMode.KeepReferences)
-        {
-            throw new NotImplementedException($"Stream trim mode {trimMode} is not supported by Valkey GLIDE");
-        }
-    }
-
     #endregion
 }
diff --git a/sources/Valkey.Glide/Internals/GuardClauses.cs b/sources/Valkey.Glide/Internals/GuardClauses.cs
index 603e437a..0fb99752 100644
--- a/sources/Valkey.Glide/Internals/GuardClauses.cs
+++ b/sources/Valkey.Glide/Internals/GuardClauses.cs
@@ -45,4 +45,31 @@ public static void ThrowIfNegative(TimeSpan value)
             throw new ArgumentException("Time span cannot be negative.");
         }
     }
+
+    /// <summary>
+    /// Throws an <see cref="ArgumentOutOfRangeException"/> if the given value is negative.
+    /// </summary>
+    /// <param name="value">The value to validate.</param>
+    /// <param name="name">The parameter name for the exception.</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="value"/> is negative.</exception>
+    public static void ThrowIfNegative(long value, string name)
+    {
+        if (value < 0)
+        {
+            throw new ArgumentOutOfRangeException(name, value, "Value cannot be negative.");
+        }
+    }
+
+    /// <summary>
+    /// Throws a <see cref="NotImplementedException"/> if the stream trim mode is not supported.
+    /// </summary>
+    /// <param name="trimMode">The stream trim mode to validate.</param>
+    /// <exception cref="NotImplementedException">Thrown if <paramref name="trimMode"/> is not <see cref="StreamTrimMode.KeepReferences"/>.</exception>
+    public static void ThrowIfUnsupported(StreamTrimMode trimMode)
+    {
+        if (trimMode != StreamTrimMode.KeepReferences)
+        {
+            throw new NotImplementedException($"Stream trim mode {trimMode} is not supported by Valkey GLIDE");
+        }
+    }
 }

From b834491d7282f18796e39b9a8f9439d2353a8d30 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 09:51:26 -0700
Subject: [PATCH 13/31] Fix TODO and add regions for stream commands

Signed-off-by: currantw <taylor.curran@improving.com>
---
 sources/Valkey.Glide/Abstract/Database.StreamCommands.cs | 1 -
 sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs | 3 ++-
 sources/Valkey.Glide/Client/GlideClient.cs               | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
index da45588e..76c0306a 100644
--- a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
@@ -277,6 +277,5 @@ private static StreamAddOptions ToStreamAddOptions(
                 : null
     };
 
-    /// <summary>
     #endregion
 }
diff --git a/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs b/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs
index a0598794..767c3aed 100644
--- a/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.StreamCommands.cs
@@ -95,7 +95,8 @@ public Task<bool> StreamDeleteAsync(ValkeyKey key, ValkeyValue messageId)
 
     #endregion
 
-    // TODO #326
+    // TODO #326: Redesign and expose these methods
+
     // ──────────────────────────────────────────────────────────────────────
     // Methods below are temporarily commented out pending cleanup.
     // The underlying Request methods are kept intact.
diff --git a/sources/Valkey.Glide/Client/GlideClient.cs b/sources/Valkey.Glide/Client/GlideClient.cs
index faf501ab..5dfe5862 100644
--- a/sources/Valkey.Glide/Client/GlideClient.cs
+++ b/sources/Valkey.Glide/Client/GlideClient.cs
@@ -18,7 +18,7 @@ public partial class GlideClient :
     BaseClient,
     IGlideClient
 {
-    internal GlideClient() { }
+    #region Public Methods
 
     /// <summary>
     /// Creates a new <see cref="GlideClient" /> instance and establishes a connection to a standalone Valkey server.
@@ -59,5 +59,5 @@ protected override async Task<Version> GetServerVersionAsync()
         return _serverVersion;
     }
 
-    
+    #endregion
 }

From 1405c3b7baba57db7a7a90146ee85ecbfa366502 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 13:09:07 -0700
Subject: [PATCH 14/31] refactor: Relax TODO pattern to match without comment
 prefix

Remove the comment-prefix requirement from _TODO_PATTERN so TODOs
inside block comments (e.g. /* TODO */) are also caught. Handle
false positives from documentation files via check-todos-ignore.

Also removes the stale TODO from rust/src/ffi.rs (fields are now
implemented).

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 .github/pull_request_template.md                     |  2 +-
 DEVELOPER.md                                         |  6 +++---
 Taskfile.yml                                         |  2 +-
 dev/conf/check-todos-ignore                          |  5 +++--
 dev/scripts/check_todos.py                           | 12 ++++++------
 rust/src/ffi.rs                                      |  5 -----
 .../Client/GlideClusterClient.GenericCommands.cs     |  7 ++-----
 .../Valkey.Glide/Internals/Request.StreamCommands.cs |  3 +++
 sources/Valkey.Glide/Internals/Request.cs            |  3 +++
 9 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index f4e09449..3aa2b8ae 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -64,4 +64,4 @@ Not applicable items should be crossed out, not removed.
 - [ ] `CHANGELOG.md`, `README.md`, `DEVELOPER.md`, and other documentation files are updated.
 - [ ] Destination branch is correct - `main` or release
 - [ ] Create merge commit if merging release branch into `main`, squash otherwise.
-- [ ] All TODO comments referencing issue(s) closed by this PR have been resolved.
+- [ ] All TODOs referencing issue(s) closed by this PR have been resolved.
diff --git a/DEVELOPER.md b/DEVELOPER.md
index 2299f1b0..b5962bc3 100644
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@@ -365,7 +365,7 @@ task lint:markdown  # Run Markdown linter
 
 ## Checks
 
-Run checks to validate examples, links, and TODO comments.
+Run checks to validate examples, links, and TODOs.
 
 ```bash
 task check
@@ -374,9 +374,9 @@ task check:links
 task check:todos
 ```
 
-### Inline TODOs
+### TODOs
 
-All TODO comments must follow the format `TODO #<number>: <description>`, where:
+All TODOs must follow the format `TODO #<number>: <description>`, where:
 
 - `<number>` is an open GitHub issue in this repository.
 - `<description>` is a short explanation of what needs to change (at least 10 characters).
diff --git a/Taskfile.yml b/Taskfile.yml
index 6f13feee..e485f0b6 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -183,5 +183,5 @@ tasks:
         cmd: lychee --config lychee.toml .
 
     check:todos:
-        desc: "Check that TODO comments reference an open GitHub issue"
+        desc: "Check that TODOs reference an open GitHub issue"
         cmd: python3 dev/scripts/check_todos.py
diff --git a/dev/conf/check-todos-ignore b/dev/conf/check-todos-ignore
index 092e2b09..81809b7a 100644
--- a/dev/conf/check-todos-ignore
+++ b/dev/conf/check-todos-ignore
@@ -1,5 +1,6 @@
-# Files excluded from the TODO checker (dev/scripts/check_todos.py).
-# Patterns use fnmatch-style glob matching against repo-relative paths.
+# Files excluded from the TODO checker.
+# See dev/scripts/check_todos.py for details.
 
 dev/conf/check-todos-ignore
 dev/scripts/check_todos.py
+DEVELOPER.md
diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
index 7130d2f1..69cb0e31 100644
--- a/dev/scripts/check_todos.py
+++ b/dev/scripts/check_todos.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-"""Check that all TODO comments follow the required format.
+"""Check that all TODOs follow the required format.
 
 Validation rules:
   1. Every TODO must follow the format `TODO #<number>: <description>`.
@@ -23,16 +23,16 @@
 
 
 class _Todo(NamedTuple):
-    """A TODO comment found in the codebase."""
+    """A TODO found in the codebase."""
 
     file: str
     line: int
     text: str
 
 
-# Matches TODO comments and captures GitHub issue ID and description.
+# Matches TODO and captures GitHub issue ID and description.
 _TODO_PATTERN = re.compile(
-    r"(//|#|/\*|\*|<!--).*TODO\b(\s+#(?P<github_id>\d+)(:\s+(?P<description>.+))?)?",
+    r"TODO\b(\s+#(?P<github_id>\d+)(:\s+(?P<description>.+))?)?",
     re.IGNORECASE,
 )
 
@@ -61,7 +61,7 @@ def _is_ignored(filepath: str, patterns: list[str]) -> bool:
 
 
 def _find_todos() -> list[_Todo]:
-    """Find all TODO comments in tracked files using git grep."""
+    """Find all TODOs in tracked files using git grep."""
     result = subprocess.run(
         ["git", "grep", "-n", "-i", "-P", _TODO_PATTERN.pattern],
         cwd=PROJECT_ROOT,
@@ -142,7 +142,7 @@ def _validate_todos(todos: list[_Todo]) -> dict[_Todo, str]:
 
 
 def main():
-    print("Checking TODO comments...\n")
+    print("Checking TODOs...\n")
 
     todos = _find_todos()
     failures = _validate_todos(todos)
diff --git a/rust/src/ffi.rs b/rust/src/ffi.rs
index ca6fdaa1..dad88090 100644
--- a/rust/src/ffi.rs
+++ b/rust/src/ffi.rs
@@ -148,11 +148,6 @@ pub struct ConnectionConfig {
     pub node_discovery_mode: NodeDiscoveryMode,
     pub has_client_side_cache_config: bool,
     pub client_side_cache_config: ClientSideCacheConfig,
-    /*
-    TODO below
-    pub periodic_checks: Option<PeriodicCheck>,
-    pub inflight_requests_limit: Option<u32>
-    */
 }
 
 #[repr(C)]
diff --git a/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs b/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs
index ba0e3557..3f0e3f17 100644
--- a/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs
+++ b/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs
@@ -13,15 +13,12 @@ public partial class GlideClusterClient
     /// <inheritdoc cref="IGlideClusterClient.ScanAsync(ScanOptions?)"/>
     public async IAsyncEnumerable<ValkeyKey> ScanAsync(ScanOptions? options = null)
     {
-        List<GlideString> glideArgs = [];
-        glideArgs.AddRange(Request.ToScanArgs(options));
-        string[] args = [.. glideArgs.Select(a => a.ToString())];
+        string[] args = [.. Request.ToScanArgs(options).Select(a => a.ToString())];
         ClusterScanCursor cursor = ClusterScanCursor.InitialCursor();
 
         while (!cursor.IsFinished)
         {
-            var (nextCursorId, keys) = await ClusterScanCommand(cursor.CursorId, args);
-            cursor = new ClusterScanCursor(nextCursorId);
+            (cursor, var keys) = await ClusterScanCommand(cursor, args);
 
             foreach (ValkeyKey key in keys)
             {
diff --git a/sources/Valkey.Glide/Internals/Request.StreamCommands.cs b/sources/Valkey.Glide/Internals/Request.StreamCommands.cs
index 99dc124c..36a22ab8 100644
--- a/sources/Valkey.Glide/Internals/Request.StreamCommands.cs
+++ b/sources/Valkey.Glide/Internals/Request.StreamCommands.cs
@@ -220,6 +220,9 @@ public static Cmd<long, long> StreamTrimAsync(ValkeyKey key, long? maxLength, Va
         return new(RequestType.XTrim, [.. args], false, response => response);
     }
 
+    public static Cmd<long, long> StreamTrimAsync(ValkeyKey key, StreamTrimOptions options)
+        => Simple<long>(RequestType.XTrim, [key, .. options.ToArgs()]);
+
     #endregion
 
     #region Response Converters
diff --git a/sources/Valkey.Glide/Internals/Request.cs b/sources/Valkey.Glide/Internals/Request.cs
index 73359fe9..126d424c 100644
--- a/sources/Valkey.Glide/Internals/Request.cs
+++ b/sources/Valkey.Glide/Internals/Request.cs
@@ -93,6 +93,9 @@ private static Dictionary<ValkeyKey, long> ToValkeyKeyLongDict(Dictionary<GlideS
         return result;
     }
 
+    internal static GlideString[] ToScanArgs(ScanOptions? options)
+        => options?.ToArgs() ?? [];
+
     /// <summary>
     /// Appends SetExpiryOptions arguments (PX/PXAT/KEEPTTL) to the args list.
     /// </summary>

From 750c4e1fdbf0f3da5c9b34707b97c518d7e4f95f Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Thu, 23 Jul 2026 14:39:10 -0700
Subject: [PATCH 15/31] chore: Remove unused raw-args StreamTrimAsync overload

The SER StreamTrimAsync methods delegate through the GLIDE
StreamTrimOptions overload. The raw-args version has no callers.

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/Database.StreamCommands.cs       |  4 +--
 .../GlideClusterClient.GenericCommands.cs     |  5 ++-
 .../Valkey.Glide/Internals/GuardClauses.cs    |  2 +-
 .../Internals/Request.StreamCommands.cs       | 36 -------------------
 4 files changed, 5 insertions(+), 42 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
index 76c0306a..36f3e2b6 100644
--- a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
@@ -209,7 +209,7 @@ public Task<long> StreamTrimAsync(ValkeyKey key, int maxLength, bool useApproxim
     public Task<long> StreamTrimAsync(ValkeyKey key, long maxLength, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
-        GuardClauses.ThrowIfUnsupported(trimMode);
+        GuardClauses.ThrowIfNotSupported(trimMode);
 
         var options = new StreamTrimOptions.MaxLen
         {
@@ -225,7 +225,7 @@ public Task<long> StreamTrimAsync(ValkeyKey key, long maxLength, bool useApproxi
     public Task<long> StreamTrimByMinIdAsync(ValkeyKey key, ValkeyValue minId, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
-        GuardClauses.ThrowIfUnsupported(trimMode);
+        GuardClauses.ThrowIfNotSupported(trimMode);
 
         var options = new StreamTrimOptions.MinId
         {
diff --git a/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs b/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs
index 3f0e3f17..60723be8 100644
--- a/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs
+++ b/sources/Valkey.Glide/Client/GlideClusterClient.GenericCommands.cs
@@ -13,13 +13,12 @@ public partial class GlideClusterClient
     /// <inheritdoc cref="IGlideClusterClient.ScanAsync(ScanOptions?)"/>
     public async IAsyncEnumerable<ValkeyKey> ScanAsync(ScanOptions? options = null)
     {
-        string[] args = [.. Request.ToScanArgs(options).Select(a => a.ToString())];
-        ClusterScanCursor cursor = ClusterScanCursor.InitialCursor();
+        var cursor = ClusterScanCursor.InitialCursor();
+        var args = Request.ToScanArgs(options).Select(a => a.ToString()).ToArray();
 
         while (!cursor.IsFinished)
         {
             (cursor, var keys) = await ClusterScanCommand(cursor, args);
-
             foreach (ValkeyKey key in keys)
             {
                 yield return key;
diff --git a/sources/Valkey.Glide/Internals/GuardClauses.cs b/sources/Valkey.Glide/Internals/GuardClauses.cs
index 0fb99752..9768a2d3 100644
--- a/sources/Valkey.Glide/Internals/GuardClauses.cs
+++ b/sources/Valkey.Glide/Internals/GuardClauses.cs
@@ -65,7 +65,7 @@ public static void ThrowIfNegative(long value, string name)
     /// </summary>
     /// <param name="trimMode">The stream trim mode to validate.</param>
     /// <exception cref="NotImplementedException">Thrown if <paramref name="trimMode"/> is not <see cref="StreamTrimMode.KeepReferences"/>.</exception>
-    public static void ThrowIfUnsupported(StreamTrimMode trimMode)
+    public static void ThrowIfNotSupported(StreamTrimMode trimMode)
     {
         if (trimMode != StreamTrimMode.KeepReferences)
         {
diff --git a/sources/Valkey.Glide/Internals/Request.StreamCommands.cs b/sources/Valkey.Glide/Internals/Request.StreamCommands.cs
index 36a22ab8..e44706fd 100644
--- a/sources/Valkey.Glide/Internals/Request.StreamCommands.cs
+++ b/sources/Valkey.Glide/Internals/Request.StreamCommands.cs
@@ -184,42 +184,6 @@ public static Cmd<object, StreamEntry[]> StreamReadGroupAsync(StreamPosition pos
     public static Cmd<object, ValkeyStream[]> StreamReadGroupAsync(IEnumerable<StreamPosition> positions, ValkeyValue group, ValkeyValue consumer, StreamReadGroupOptions options)
         => new(RequestType.XReadGroup, BuildStreamReadGroupArgs([.. positions], group, consumer, options), false, ConvertMultiStreamReadResponse, allowConverterToHandleNull: true);
 
-    // TODO SER only
-    public static Cmd<long, long> StreamTrimAsync(ValkeyKey key, long? maxLength, ValkeyValue minId, bool useApproximateMaxLength, long? limit)
-    {
-        List<GlideString> args = [key];
-
-        if (maxLength.HasValue)
-        {
-            args.Add("MAXLEN");
-
-            if (useApproximateMaxLength)
-            {
-                args.Add("~");
-            }
-
-            args.Add(maxLength.Value.ToGlideString());
-        }
-        else if (!minId.IsNull)
-        {
-            args.Add("MINID");
-            if (useApproximateMaxLength)
-            {
-                args.Add("~");
-            }
-
-            args.Add(minId);
-        }
-
-        if (limit.HasValue && useApproximateMaxLength)
-        {
-            args.Add("LIMIT");
-            args.Add(limit.Value.ToGlideString());
-        }
-
-        return new(RequestType.XTrim, [.. args], false, response => response);
-    }
-
     public static Cmd<long, long> StreamTrimAsync(ValkeyKey key, StreamTrimOptions options)
         => Simple<long>(RequestType.XTrim, [key, .. options.ToArgs()]);
 

From 5e75e2d942e6e8b315c4fd4d32592262f6c89ae8 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Fri, 24 Jul 2026 07:10:45 -0700
Subject: [PATCH 16/31] Remove unused ToValkeyKeyArray

Signed-off-by: currantw <taylor.curran@improving.com>
---
 sources/Valkey.Glide/Internals/Request.cs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/sources/Valkey.Glide/Internals/Request.cs b/sources/Valkey.Glide/Internals/Request.cs
index 126d424c..4a1d7558 100644
--- a/sources/Valkey.Glide/Internals/Request.cs
+++ b/sources/Valkey.Glide/Internals/Request.cs
@@ -119,12 +119,6 @@ private static void AddExpiryArgs(List<GlideString> args, SetExpiryOptions optio
 
     #region Collection Converters
 
-    /// <summary>
-    /// Converts the given objects to a <see cref="ValkeyKey"/> array.
-    /// </summary>
-    private static ValkeyKey[] ToValkeyKeyArray(IEnumerable<object> items)
-        => [.. items.Cast<GlideString>().Select(gs => (ValkeyKey)gs.Bytes)];
-
     /// <summary>
     /// Converts the given objects to a <see cref="ValkeyKey"/> set.
     /// </summary>

From 061a7f8c1ee59d4ad6f55254b6b1a6209ea7fc86 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 09:54:41 -0700
Subject: [PATCH 17/31] Make `SetScanAsync` and `SortedSetScanAsync` private
 protected.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 sources/Valkey.Glide/Client/BaseClient.SetCommands.cs       | 5 ++++-
 sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs | 5 ++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
index 6adf5567..fa453fe4 100644
--- a/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.SetCommands.cs
@@ -98,7 +98,10 @@ public IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, ScanOptions? op
     #region Internal Methods
 
     /// <inheritdoc cref="IBaseClient.SetScanAsync(ValkeyKey, ScanOptions?)"/>
-    protected async IAsyncEnumerable<ValkeyValue> SetScanAsync(ValkeyKey key, long cursor, ScanOptions? options)
+    private protected async IAsyncEnumerable<ValkeyValue> SetScanAsync(
+        ValkeyKey key,
+        long cursor,
+        ScanOptions? options)
     {
         do
         {
diff --git a/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs b/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
index a39d22b6..272528b5 100644
--- a/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
+++ b/sources/Valkey.Glide/Client/BaseClient.SortedSetCommands.cs
@@ -258,7 +258,10 @@ public IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, ScanOp
     #region Protected Methods
 
     /// <inheritdoc cref="IBaseClient.SortedSetScanAsync(ValkeyKey, ScanOptions?)"/>
-    protected async IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, long cursor, ScanOptions? options)
+    private protected async IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(
+        ValkeyKey key,
+        long cursor,
+        ScanOptions? options)
     {
         do
         {

From 7ff432af0454d170e5873c0387765f482e0e3b58 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 11:12:41 -0700
Subject: [PATCH 18/31] Split TODO regexes

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/scripts/check_todos.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
index 69cb0e31..ac3a4b4f 100644
--- a/dev/scripts/check_todos.py
+++ b/dev/scripts/check_todos.py
@@ -30,8 +30,11 @@ class _Todo(NamedTuple):
     text: str
 
 
-# Matches TODO and captures GitHub issue ID and description.
-_TODO_PATTERN = re.compile(
+# Used by git grep to discover TODO occurrences in tracked files.
+_TODO_GREP_PATTERN = r"\bTODO\b"
+
+# Used to validate format and extract GitHub issue ID and description.
+_TODO_VALIDATION_PATTERN = re.compile(
     r"TODO\b(\s+#(?P<github_id>\d+)(:\s+(?P<description>.+))?)?",
     re.IGNORECASE,
 )
@@ -63,7 +66,7 @@ def _is_ignored(filepath: str, patterns: list[str]) -> bool:
 def _find_todos() -> list[_Todo]:
     """Find all TODOs in tracked files using git grep."""
     result = subprocess.run(
-        ["git", "grep", "-n", "-i", "-P", _TODO_PATTERN.pattern],
+        ["git", "grep", "-n", "-i", "-P", _TODO_GREP_PATTERN],
         cwd=PROJECT_ROOT,
         capture_output=True,
         text=True,
@@ -117,7 +120,7 @@ def _validate_todos(todos: list[_Todo]) -> dict[_Todo, str]:
     checked_issues: dict[int, str | None] = {}
 
     for todo in todos:
-        match = _TODO_PATTERN.search(todo.text)
+        match = _TODO_VALIDATION_PATTERN.search(todo.text)
         github_id = match.group("github_id")
 
         if not github_id:

From ec9355d228afd3572380ada30a9ad56bcd4038d3 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 11:38:41 -0700
Subject: [PATCH 19/31] Add space before TODO, simplify check_todos to enforce
 format

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/scripts/check_todos.py                    | 29 +++++++++----------
 .../ConnectionManagementCommandTests.cs       |  2 +-
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
index ac3a4b4f..8be81a63 100644
--- a/dev/scripts/check_todos.py
+++ b/dev/scripts/check_todos.py
@@ -3,7 +3,7 @@
 """Check that all TODOs follow the required format.
 
 Validation rules:
-  1. Every TODO must follow the format `TODO #<number>: <description>`.
+  1. Every TODO must follow the format `TODO #<github_id>: <description>`.
   2. The description should provide a summary of the proposed changes, and must be at least 10 characters long.
   3. The referenced number must correspond to an open Valkey GLIDE C# GitHub issue.
 
@@ -35,7 +35,7 @@ class _Todo(NamedTuple):
 
 # Used to validate format and extract GitHub issue ID and description.
 _TODO_VALIDATION_PATTERN = re.compile(
-    r"TODO\b(\s+#(?P<github_id>\d+)(:\s+(?P<description>.+))?)?",
+    r"TODO #(?P<github_id>\d+): (?P<description>.+)",
     re.IGNORECASE,
 )
 
@@ -120,27 +120,26 @@ def _validate_todos(todos: list[_Todo]) -> dict[_Todo, str]:
     checked_issues: dict[int, str | None] = {}
 
     for todo in todos:
-        match = _TODO_VALIDATION_PATTERN.search(todo.text)
-        github_id = match.group("github_id")
 
-        if not github_id:
-            failures[todo] = "missing GitHub issue reference"
+        # Validate format
+        match = _TODO_VALIDATION_PATTERN.search(todo.text)
+        if not match:
+            failures[todo] = "invalid format (expected: TODO #<github_id>: <description>)"
             continue
 
+        # Check issue state
+        github_id = int(match.group("github_id"))
+        if github_id not in checked_issues:
+            checked_issues[github_id] = _check_issue(github_id)
+        if checked_issues[github_id]:
+            failures[todo] = checked_issues[github_id]
+
+        # Check description length
         description = match.group("description")
-        if description is None:
-            failures[todo] = "missing description (expected format: TODO #<number>: <description>)"
-            continue
         if len(description.strip()) < _MIN_DESCRIPTION_LENGTH:
             failures[todo] = f"description too short (must be at least {_MIN_DESCRIPTION_LENGTH} characters)"
             continue
 
-        issue_num = int(github_id)
-        if issue_num not in checked_issues:
-            checked_issues[issue_num] = _check_issue(issue_num)
-        if checked_issues[issue_num]:
-            failures[todo] = checked_issues[issue_num]
-
     return failures
 
 
diff --git a/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
index 7158b574..72967d97 100644
--- a/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
@@ -13,7 +13,7 @@ public class ConnectionManagementCommandTests(TestConfiguration config)
 {
     #region Constants
 
-    //TODO #414: Remove when ClientInfoAsync implemented.
+    // TODO #414: Remove when ClientInfoAsync implemented.
     private static readonly GlideString[] InfoCommand = ["CLIENT", "INFO"];
 
     // Library version is set dynamically by the CD workflow,

From 43e18ec2643649afd096a79eae824338e7fc618d Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 11:51:44 -0700
Subject: [PATCH 20/31] Add GuardClauses.ThrowIfNotPositive and update scan
 methods to throw if negative page offset

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Valkey.Glide/Abstract/Database.SetCommands.cs  |  1 +
 .../Abstract/Database.SortedSetCommands.cs         |  1 +
 sources/Valkey.Glide/Abstract/ValkeyServer.cs      |  1 +
 sources/Valkey.Glide/Internals/GuardClauses.cs     | 14 ++++++++++++++
 4 files changed, 17 insertions(+)

diff --git a/sources/Valkey.Glide/Abstract/Database.SetCommands.cs b/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
index 663c235a..9dba9ad7 100644
--- a/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.SetCommands.cs
@@ -147,6 +147,7 @@ public IAsyncEnumerable<ValkeyValue> SetScanAsync(
         CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
+        GuardClauses.ThrowIfNotPositive(pageSize, nameof(pageSize));
 
         var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
         return SetScanAsync(key, cursor, options).SkipAsync(pageOffset);
diff --git a/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs b/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
index 72e18735..a27f1f2c 100644
--- a/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.SortedSetCommands.cs
@@ -300,6 +300,7 @@ public IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(
         CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
+        GuardClauses.ThrowIfNotPositive(pageSize, nameof(pageSize));
 
         var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
         return SortedSetScanAsync(key, cursor, options).SkipAsync(pageOffset);
diff --git a/sources/Valkey.Glide/Abstract/ValkeyServer.cs b/sources/Valkey.Glide/Abstract/ValkeyServer.cs
index 392571d7..71a139f8 100644
--- a/sources/Valkey.Glide/Abstract/ValkeyServer.cs
+++ b/sources/Valkey.Glide/Abstract/ValkeyServer.cs
@@ -290,6 +290,7 @@ public IAsyncEnumerable<ValkeyKey> KeysAsync(
         CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
+        GuardClauses.ThrowIfNotPositive(pageSize, nameof(pageSize));
 
         var options = new ScanOptions { MatchPattern = pattern, Count = pageSize };
         return ScanAsync(cursor.ToString(), options).SkipAsync(pageOffset);
diff --git a/sources/Valkey.Glide/Internals/GuardClauses.cs b/sources/Valkey.Glide/Internals/GuardClauses.cs
index 9768a2d3..7eb79b2b 100644
--- a/sources/Valkey.Glide/Internals/GuardClauses.cs
+++ b/sources/Valkey.Glide/Internals/GuardClauses.cs
@@ -60,6 +60,20 @@ public static void ThrowIfNegative(long value, string name)
         }
     }
 
+    /// <summary>
+    /// Throws an <see cref="ArgumentOutOfRangeException"/> if the given value is not positive.
+    /// </summary>
+    /// <param name="value">The value to validate.</param>
+    /// <param name="name">The parameter name for the exception.</param>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="value"/> is zero or negative.</exception>
+    public static void ThrowIfNotPositive(long value, string name)
+    {
+        if (value <= 0)
+        {
+            throw new ArgumentOutOfRangeException(name, value, "Value must be positive.");
+        }
+    }
+
     /// <summary>
     /// Throws a <see cref="NotImplementedException"/> if the stream trim mode is not supported.
     /// </summary>

From 2361673ab0dfd9de2d6efb51b793dcc8177a8a6c Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 12:04:54 -0700
Subject: [PATCH 21/31] Make _TODO_VALIDATION_PATTERN case sensitive

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/scripts/check_todos.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
index 8be81a63..46c3d43f 100644
--- a/dev/scripts/check_todos.py
+++ b/dev/scripts/check_todos.py
@@ -36,7 +36,6 @@ class _Todo(NamedTuple):
 # Used to validate format and extract GitHub issue ID and description.
 _TODO_VALIDATION_PATTERN = re.compile(
     r"TODO #(?P<github_id>\d+): (?P<description>.+)",
-    re.IGNORECASE,
 )
 
 # Minimum length for the description.

From b2e6bf13a444e5e3d1351dce68532784d1073082 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 12:27:04 -0700
Subject: [PATCH 22/31] Add TODOs for unused configurations.

Signed-off-by: currantw <taylor.curran@improving.com>
---
 rust/src/ffi.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rust/src/ffi.rs b/rust/src/ffi.rs
index c01066b2..1df9e85c 100644
--- a/rust/src/ffi.rs
+++ b/rust/src/ffi.rs
@@ -373,8 +373,8 @@ pub(crate) unsafe fn create_connection_request(
         client_key_path: None,
         cert_reload: None,
         tcp_nodelay: false,
-        periodic_checks: None,
-        inflight_requests_limit: None,
+        periodic_checks: None, // TODO #485: Expose periodic_checks in ClusterClientConfiguration.
+        inflight_requests_limit: None, // TODO #484: Expose inflight_requests_limit in ConnectionConfiguration.
         address_resolver: None,
         client_circuit_breaker: None,
     })

From 7ce7aa3e94d7c8c6a1c4315ab105dc695a2cfab5 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 12:39:03 -0700
Subject: [PATCH 23/31] Clarify no inline comments

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/conf/check-todos-ignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dev/conf/check-todos-ignore b/dev/conf/check-todos-ignore
index 81809b7a..42fd6bad 100644
--- a/dev/conf/check-todos-ignore
+++ b/dev/conf/check-todos-ignore
@@ -1,4 +1,6 @@
 # Files excluded from the TODO checker.
+# Patterns use fnmatch-style glob matching.
+# Only full-line comments supported.
 # See dev/scripts/check_todos.py for details.
 
 dev/conf/check-todos-ignore

From 4374ee56cf60bfc913bf265f2fc194980b0b4607 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 13:10:09 -0700
Subject: [PATCH 24/31] fix: Restore StreamTrimAsync(long?) signature to avoid
 breaking change

Keep the previous `long? maxLength = null` signature on the extended
StreamTrimAsync overload to maintain backward compatibility. Add
ArgumentNullException for null maxLength (previously would have hit a
server syntax error). Add TODO #486 to align with SER signature in 2.0.

Signed-off-by: Taylor Curran <taylor.curran@valkey.io>
Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/Database.StreamCommands.cs         | 17 +++++++++++++----
 .../Abstract/IDatabaseAsync.StreamCommands.cs   |  4 +++-
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
index 36f3e2b6..590470c8 100644
--- a/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/Database.StreamCommands.cs
@@ -201,19 +201,28 @@ public Task<StreamAutoClaimJustIdResult> StreamAutoClaimIdsOnlyAsync(ValkeyKey k
     /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, int, bool, CommandFlags)"/>
     public Task<long> StreamTrimAsync(ValkeyKey key, int maxLength, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None)
     {
+        GuardClauses.ThrowIfCommandFlags(flags);
         GuardClauses.ThrowIfNegative(maxLength, nameof(maxLength));
-        return StreamTrimAsync(key, (long)maxLength, useApproximateMaxLength, flags: flags);
+
+        return StreamTrimAsync(key, new StreamTrimOptions.MaxLen
+        {
+            MaxLength = maxLength,
+            Exact = !useApproximateMaxLength,
+        });
     }
 
-    /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, long, bool, long?, StreamTrimMode, CommandFlags)"/>
-    public Task<long> StreamTrimAsync(ValkeyKey key, long maxLength, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
+    /// <inheritdoc cref="IDatabaseAsync.StreamTrimAsync(ValkeyKey, long?, bool, long?, StreamTrimMode, CommandFlags)"/>
+    public Task<long> StreamTrimAsync(ValkeyKey key, long? maxLength = null, bool useApproximateMaxLength = false, long? limit = null, StreamTrimMode trimMode = StreamTrimMode.KeepReferences, CommandFlags flags = CommandFlags.None)
     {
         GuardClauses.ThrowIfCommandFlags(flags);
         GuardClauses.ThrowIfNotSupported(trimMode);
 
+        // TODO #486: Remove once maxLength is no longer optional.
+        ArgumentNullException.ThrowIfNull(maxLength, nameof(maxLength));
+
         var options = new StreamTrimOptions.MaxLen
         {
-            MaxLength = maxLength,
+            MaxLength = maxLength.Value,
             Exact = !useApproximateMaxLength,
             Limit = limit
         };
diff --git a/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs b/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
index dd09c67f..c357bba2 100644
--- a/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
@@ -344,6 +344,7 @@ public partial interface IDatabaseAsync
     /// <param name="flags">Command flags (currently not supported by GLIDE).</param>
     /// <returns>The number of entries removed.</returns>
     /// <exception cref="NotImplementedException">Thrown if <paramref name="flags"/> is not <see cref="CommandFlags.None"/>.</exception>
+    // TODO #486: Remove default parameter values to match StackExchange.Redis signature.
     Task<long> StreamTrimAsync(
         ValkeyKey key,
         int maxLength,
@@ -355,9 +356,10 @@ Task<long> StreamTrimAsync(
     /// <param name="limit">The maximum number of entries to evict per call.</param>
     /// <param name="trimMode">The trim mode to use.</param>
     /// <returns>The number of entries removed.</returns>
+    // TODO #486: Change `long? maxLength = null` to `long maxLength` to match StackExchange.Redis signature.
     Task<long> StreamTrimAsync(
         ValkeyKey key,
-        long maxLength,
+        long? maxLength = null,
         bool useApproximateMaxLength = false,
         long? limit = null,
         StreamTrimMode trimMode = StreamTrimMode.KeepReferences,

From ec76f2352de76b4577fb2d5a1b96741b12deb90d Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 13:17:08 -0700
Subject: [PATCH 25/31] Update docs

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/IDatabaseAsync.StreamCommands.cs     | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs b/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
index c357bba2..16737371 100644
--- a/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
+++ b/sources/Valkey.Glide/Abstract/IDatabaseAsync.StreamCommands.cs
@@ -344,7 +344,12 @@ public partial interface IDatabaseAsync
     /// <param name="flags">Command flags (currently not supported by GLIDE).</param>
     /// <returns>The number of entries removed.</returns>
     /// <exception cref="NotImplementedException">Thrown if <paramref name="flags"/> is not <see cref="CommandFlags.None"/>.</exception>
-    // TODO #486: Remove default parameter values to match StackExchange.Redis signature.
+    /// <remarks>
+    /// The default <paramref name="useApproximateMaxLength"/> and <paramref name="flags"/>
+    /// values on this overload will be removed to match StackExchange.Redis.
+    /// See <see href="https://github.com/valkey-io/valkey-glide-csharp/issues/486">#486</see>.
+    /// </remarks>
+    // TODO #486: Remove default parameter values to match StackExchange.Redis signature in 2.0.
     Task<long> StreamTrimAsync(
         ValkeyKey key,
         int maxLength,
@@ -352,11 +357,15 @@ Task<long> StreamTrimAsync(
         CommandFlags flags = CommandFlags.None);
 
     /// <inheritdoc cref="StreamTrimAsync(ValkeyKey, int, bool, CommandFlags)" path="/*[not(self::param[@name='maxLength']) and not(self::returns)]"/>
-    /// <param name="maxLength">The maximum number of entries to keep.</param>
+    /// <param name="maxLength">The maximum number of entries to keep. Must not be <c>null</c>.</param>
     /// <param name="limit">The maximum number of entries to evict per call.</param>
     /// <param name="trimMode">The trim mode to use.</param>
     /// <returns>The number of entries removed.</returns>
-    // TODO #486: Change `long? maxLength = null` to `long maxLength` to match StackExchange.Redis signature.
+    /// <remarks>
+    /// The <paramref name="maxLength"/> parameter will change from <c>long?</c> to <c>long</c>
+    /// match StackExchange.Redis. See <see href="https://github.com/valkey-io/valkey-glide-csharp/issues/486">#486</see>.
+    /// </remarks>
+    // TODO #486: Change `long? maxLength = null` to `long maxLength` to match StackExchange.Redis signature in 2.0.
     Task<long> StreamTrimAsync(
         ValkeyKey key,
         long? maxLength = null,

From 5545a9693fe9b635320daf86a4b584c920541ce5 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 15:45:25 -0700
Subject: [PATCH 26/31] Add TODO to "Check issue state"

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/scripts/check_todos.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/scripts/check_todos.py b/dev/scripts/check_todos.py
index 46c3d43f..b228a931 100644
--- a/dev/scripts/check_todos.py
+++ b/dev/scripts/check_todos.py
@@ -132,12 +132,12 @@ def _validate_todos(todos: list[_Todo]) -> dict[_Todo, str]:
             checked_issues[github_id] = _check_issue(github_id)
         if checked_issues[github_id]:
             failures[todo] = checked_issues[github_id]
+            continue
 
         # Check description length
         description = match.group("description")
         if len(description.strip()) < _MIN_DESCRIPTION_LENGTH:
             failures[todo] = f"description too short (must be at least {_MIN_DESCRIPTION_LENGTH} characters)"
-            continue
 
     return failures
 

From 437606afad8627809737b197555406cbe1ddae34 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Mon, 27 Jul 2026 21:09:44 -0700
Subject: [PATCH 27/31] Update `ConnectionManagementCommandTests` to use
 `ServerFixture`

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../ConnectionManagementCommandTests.cs       | 98 ++++++++++---------
 1 file changed, 50 insertions(+), 48 deletions(-)

diff --git a/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
index 72967d97..be53f6ac 100644
--- a/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
@@ -8,8 +8,10 @@
 
 namespace Valkey.Glide.IntegrationTests;
 
-[Collection("GlideTests")]
-public class ConnectionManagementCommandTests(TestConfiguration config)
+/// <summary>
+/// Tests for connection management commands.
+/// </summary>
+public class ConnectionManagementCommandTests(ServerFixture fixture) : IClassFixture<ServerFixture>
 {
     #region Constants
 
@@ -22,18 +24,15 @@ public class ConnectionManagementCommandTests(TestConfiguration config)
         Environment.GetEnvironmentVariable("GLIDE_VERSION") ?? "unknown";
 
     #endregion
-    #region Public Properties
-
-    public TestConfiguration Config { get; } = config;
-
-    #endregion
-    #region Tests
+    #region ClientInfoAsync
 
     // TODO #414: Update when ClientInfoAsync implemented.
-    [Theory(DisableDiscoveryEnumeration = true)]
-    [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
-    public async Task TestClientInfo_ReportsCorrectLibNameAndVersion(BaseClient client)
+    [Theory]
+    [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
+    public async Task TestClientInfo_ReportsCorrectLibNameAndVersion(bool clusterMode)
     {
+        await using var client = await fixture.GetServer(clusterMode).CreateClientAsync();
+
         var result = client is GlideClusterClient clusterClient
             ? (await clusterClient.CustomCommand(InfoCommand, Route.Random)).SingleValue
             : await ((GlideClient)client).CustomCommand(InfoCommand);
@@ -45,18 +44,19 @@ public async Task TestClientInfo_ReportsCorrectLibNameAndVersion(BaseClient clie
     }
 
     // TODO #414: Update when ClientInfoAsync implemented.
-    [Theory(DisableDiscoveryEnumeration = true)]
+    [Theory]
     [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
-    public async Task TestClientInfo_WithClientName_ReportsName(bool useCluster)
+    public async Task TestClientInfo_WithClientName_ReportsName(bool clusterMode)
     {
         const string clientName = "client";
-        using BaseClient client = useCluster
+
+        await using BaseClient client = clusterMode
             ? await GlideClusterClient.CreateClient(
-                TestConfiguration.DefaultClusterClientConfig()
+                fixture.ClusterServer.CreateConfigBuilder()
                     .WithClientName(clientName)
                     .Build())
             : await GlideClient.CreateClient(
-                TestConfiguration.DefaultClientConfig()
+                fixture.StandaloneServer.CreateConfigBuilder()
                     .WithClientName(clientName)
                     .Build());
 
@@ -70,18 +70,21 @@ public async Task TestClientInfo_WithClientName_ReportsName(bool useCluster)
     #endregion
     #region ClientTrackingInfoAsync
 
-    [Theory(DisableDiscoveryEnumeration = true)]
-    [MemberData(nameof(TestConfiguration.TestClients), MemberType = typeof(TestConfiguration))]
-    public async Task ClientTrackingInfo_Off(BaseClient client)
+    [Theory]
+    [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
+    public async Task ClientTrackingInfo_Off(bool clusterMode)
     {
+        await using var client = await fixture.GetServer(clusterMode).CreateClientAsync();
+
         var info = await client.ClientTrackingInfoAsync();
         AssertTrackingInfoOff(info);
     }
 
-    [Theory(DisableDiscoveryEnumeration = true)]
-    [MemberData(nameof(TestConfiguration.TestClusterClients), MemberType = typeof(TestConfiguration))]
-    public async Task ClientTrackingInfo_Off_WithRoute(GlideClusterClient client)
+    [Fact]
+    public async Task ClientTrackingInfo_Off_WithRoute()
     {
+        await using GlideClusterClient client = await fixture.ClusterServer.CreateClusterClientAsync();
+
         var response = await client.ClientTrackingInfoAsync(Route.AllNodes);
 
         Assert.NotEmpty(response.MultiValue);
@@ -99,11 +102,11 @@ public async Task ClientTrackingInfo_On(bool clusterMode)
 
         await using BaseClient client = clusterMode
             ? await GlideClusterClient.CreateClient(
-                TestConfiguration.DefaultClusterClientConfig()
+                fixture.ClusterServer.CreateConfigBuilder()
                     .WithClientSideCache(cache)
                     .Build())
             : await GlideClient.CreateClient(
-                TestConfiguration.DefaultClientConfig()
+                fixture.StandaloneServer.CreateConfigBuilder()
                     .WithClientSideCache(cache)
                     .Build());
 
@@ -116,7 +119,7 @@ public async Task ClientTrackingInfo_On_WithRoute()
         var cache = BuildClientSideCacheConfig().WithServerAssisted();
 
         await using var client = await GlideClusterClient.CreateClient(
-            TestConfiguration.DefaultClusterClientConfig()
+            fixture.ClusterServer.CreateConfigBuilder()
                 .WithClientSideCache(cache)
                 .Build());
 
@@ -129,10 +132,6 @@ public async Task ClientTrackingInfo_On_WithRoute()
         }
     }
 
-    /// <summary>
-    /// Asserts that the given <see cref="ClientTrackingInfo"/>
-    /// contains the expected values when tracking is turned off.
-    /// </summary>
     private static void AssertTrackingInfoOff(ClientTrackingInfo info)
     {
         Assert.Equivalent(new HashSet<string> { "off" }, info.Flags);
@@ -140,10 +139,6 @@ private static void AssertTrackingInfoOff(ClientTrackingInfo info)
         Assert.Empty(info.Prefixes);
     }
 
-    /// <summary>
-    /// Asserts that the given <see cref="ClientTrackingInfo"/>
-    /// contains the expected values when tracking is turned on.
-    /// </summary>
     private static void AssertTrackingInfoOn(ClientTrackingInfo info)
     {
         Assert.Equivalent(new HashSet<string> { "on", "bcast" }, info.Flags);
@@ -154,10 +149,12 @@ private static void AssertTrackingInfoOn(ClientTrackingInfo info)
     #endregion
     #region ClientPauseAsync / ClientUnpauseAsync
 
-    [Theory(DisableDiscoveryEnumeration = true)]
-    [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
-    public async Task TestClientPause_ReadsPausedUntilExpires(BaseClient client)
+    [Theory]
+    [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
+    public async Task TestClientPause_ReadsPausedUntilExpires(bool clusterMode)
     {
+        await using var client = await fixture.GetServer(clusterMode).CreateClientAsync();
+
         var key = Guid.NewGuid().ToString();
         await client.SetAsync(key, "value");
 
@@ -171,10 +168,12 @@ public async Task TestClientPause_ReadsPausedUntilExpires(BaseClient client)
         Assert.True(sw.Elapsed >= pauseFor);
     }
 
-    [Theory(DisableDiscoveryEnumeration = true)]
-    [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
-    public async Task TestClientPause_WritesPausedUntilExpires(BaseClient client)
+    [Theory]
+    [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
+    public async Task TestClientPause_WritesPausedUntilExpires(bool clusterMode)
     {
+        await using var client = await fixture.GetServer(clusterMode).CreateClientAsync();
+
         var key = Guid.NewGuid().ToString();
         await client.SetAsync(key, "before");
 
@@ -188,10 +187,12 @@ public async Task TestClientPause_WritesPausedUntilExpires(BaseClient client)
         Assert.True(sw.Elapsed >= pauseFor);
     }
 
-    [Theory(DisableDiscoveryEnumeration = true)]
-    [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
-    public async Task TestClientPauseWrite_ReadsNotPaused(BaseClient client)
+    [Theory]
+    [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
+    public async Task TestClientPauseWrite_ReadsNotPaused(bool clusterMode)
     {
+        await using var client = await fixture.GetServer(clusterMode).CreateClientAsync();
+
         var key = Guid.NewGuid().ToString();
         await client.SetAsync(key, "before");
 
@@ -207,10 +208,12 @@ public async Task TestClientPauseWrite_ReadsNotPaused(BaseClient client)
         await client.ClientUnpauseAsync();
     }
 
-    [Theory(DisableDiscoveryEnumeration = true)]
-    [MemberData(nameof(Config.TestClients), MemberType = typeof(TestConfiguration))]
-    public async Task TestClientPauseWrite_ThenUnpause(BaseClient client)
+    [Theory]
+    [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
+    public async Task TestClientPauseWrite_ThenUnpause(bool clusterMode)
     {
+        await using var client = await fixture.GetServer(clusterMode).CreateClientAsync();
+
         var key = Guid.NewGuid().ToString();
         await client.SetAsync(key, "before");
 
@@ -232,16 +235,15 @@ public async Task TestClientPauseWrite_ThenUnpause(BaseClient client)
     [MemberData(nameof(Data.ClusterMode), MemberType = typeof(Data))]
     public async Task TestReset_ResetsConnectionState(bool clusterMode)
     {
-        // Create a client with server-assisted client-side caching.
         var cache = BuildClientSideCacheConfig().WithServerAssisted();
 
         await using BaseClient client = clusterMode
             ? await GlideClusterClient.CreateClient(
-                TestConfiguration.DefaultClusterClientConfig()
+                fixture.ClusterServer.CreateConfigBuilder()
                     .WithClientSideCache(cache)
                     .Build())
             : await GlideClient.CreateClient(
-                TestConfiguration.DefaultClientConfig()
+                fixture.StandaloneServer.CreateConfigBuilder()
                     .WithClientSideCache(cache)
                     .Build());
 

From c26d8f807eec2050bb072a09ee31c48cb1eb2026 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Tue, 28 Jul 2026 09:21:11 -0700
Subject: [PATCH 28/31] Use DisableParallelization = true

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../ConnectionManagementCommandTests.cs                         | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
index be53f6ac..232b7e1a 100644
--- a/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/ConnectionManagementCommandTests.cs
@@ -11,6 +11,8 @@ namespace Valkey.Glide.IntegrationTests;
 /// <summary>
 /// Tests for connection management commands.
 /// </summary>
+[Collection(typeof(ConnectionManagementCommandTests))]
+[CollectionDefinition(DisableParallelization = true)]
 public class ConnectionManagementCommandTests(ServerFixture fixture) : IClassFixture<ServerFixture>
 {
     #region Constants

From 8e69d472469a7bef94a22b03896d86ea089e10de Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Tue, 28 Jul 2026 09:46:36 -0700
Subject: [PATCH 29/31] Fixed shared batch test failure

Signed-off-by: currantw <taylor.curran@improving.com>
---
 tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs b/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs
index 1fe7b391..99f8011a 100644
--- a/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/SharedBatchTests.cs
@@ -42,7 +42,7 @@ public async Task BatchRaiseOnError(BaseClient client, bool isAtomic)
         Assert.Multiple(
             () => Assert.Equal(4, res.Length),
             () => Assert.Equal(true, res[0]),
-            () => Assert.Equal(1L, (long)res[2]!),
+            () => Assert.Equal(true, res[2]),
             () => Assert.IsType<RequestException>(res[1]),
             () => Assert.IsType<RequestException>(res[3]),
             () => Assert.Contains("wrong kind of value", (res[1] as RequestException)!.Message),

From bcaebc6a67b27ce7fe2ae57c6508dda8579433d1 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Tue, 28 Jul 2026 12:57:22 -0700
Subject: [PATCH 30/31] Slight branch coverage decrease because of
 simplification (fewer branches!)

Signed-off-by: currantw <taylor.curran@improving.com>
---
 dev/conf/coverage-baseline.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/conf/coverage-baseline.json b/dev/conf/coverage-baseline.json
index cdb285ef..6ba5958d 100644
--- a/dev/conf/coverage-baseline.json
+++ b/dev/conf/coverage-baseline.json
@@ -2,5 +2,5 @@
   "server_type": "valkey",
   "server_version": "9.0",
   "line_coverage": 71.4,
-  "branch_coverage": 52.1
+  "branch_coverage": 51.9
 }

From 43a7aab90d9ce95d38403b407dd00036e0dea583 Mon Sep 17 00:00:00 2001
From: currantw <taylor.curran@improving.com>
Date: Wed, 29 Jul 2026 12:51:20 -0700
Subject: [PATCH 31/31] docs: Document intentional pageOffset divergence from
 StackExchange.Redis

GLIDE skips pageOffset elements from the entire result stream
(deterministic), unlike SE.Redis which only skips within the first
SCAN batch (non-deterministic since batch sizes are server-controlled).

- Update XML docs on SetScanAsync, SortedSetScanAsync, and KeysAsync
- Add integration tests for pageOffset > pageSize edge case
- Remove duplicate KeysAsync_CommandFlags_Throws (already in CommandFlagsTests)

Signed-off-by: currantw <taylor.curran@improving.com>
---
 .../Abstract/IDatabaseAsync.SetCommands.cs    |  5 +-
 .../IDatabaseAsync.SortedSetCommands.cs       |  7 +-
 sources/Valkey.Glide/Abstract/IServer.cs      |  9 ++-
 .../StackExchange/SetCommandTests.cs          | 26 +++++--
 .../StackExchange/SortedSetCommandTests.cs    | 34 +++++----
 .../StackExchange/ValkeyServerTests.cs        | 74 +++++++++----------
 6 files changed, 94 insertions(+), 61 deletions(-)

diff --git a/sources/Valkey.Glide/Abstract/IDatabaseAsync.SetCommands.cs b/sources/Valkey.Glide/Abstract/IDatabaseAsync.SetCommands.cs
index 5a2b22b5..bff67451 100644
--- a/sources/Valkey.Glide/Abstract/IDatabaseAsync.SetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/IDatabaseAsync.SetCommands.cs
@@ -186,11 +186,14 @@ public partial interface IDatabaseAsync
     /// <param name="pattern">The pattern to match.</param>
     /// <param name="pageSize">The number of elements to return per iteration (hint to the server).</param>
     /// <param name="cursor">The cursor position to start at.</param>
-    /// <param name="pageOffset">The number of elements to skip from the first page.</param>
+    /// <param name="pageOffset">The number of elements to skip from the beginning of the result stream.</param>
     /// <param name="flags">Command flags (currently not supported by GLIDE).</param>
     /// <returns>An <see cref="IAsyncEnumerable{T}"/> that yields all matching elements of the set.</returns>
     /// <exception cref="NotImplementedException">Thrown if <paramref name="flags"/> is not <see cref="CommandFlags.None"/>.</exception>
     /// <remarks>
+    /// Unlike StackExchange.Redis, which only skips elements within the first scan batch (making the
+    /// skip non-deterministic since batch sizes are server-controlled), GLIDE skips <paramref name="pageOffset"/>
+    /// elements from the overall result stream regardless of internal batching. This provides deterministic behavior.
     /// <example>
     /// <code>
     /// await db.SetAddAsync("myset", ["apple", "banana", "apricot"]);
diff --git a/sources/Valkey.Glide/Abstract/IDatabaseAsync.SortedSetCommands.cs b/sources/Valkey.Glide/Abstract/IDatabaseAsync.SortedSetCommands.cs
index 66fcb22e..b3e97c0b 100644
--- a/sources/Valkey.Glide/Abstract/IDatabaseAsync.SortedSetCommands.cs
+++ b/sources/Valkey.Glide/Abstract/IDatabaseAsync.SortedSetCommands.cs
@@ -285,10 +285,15 @@ public partial interface IDatabaseAsync
     /// <param name="pattern">The pattern to match.</param>
     /// <param name="pageSize">The number of elements to return per iteration (hint to the server).</param>
     /// <param name="cursor">The cursor position to start at.</param>
-    /// <param name="pageOffset">The number of elements to skip from the first page.</param>
+    /// <param name="pageOffset">The number of elements to skip from the beginning of the result stream.</param>
     /// <param name="flags">Command flags (currently not supported by GLIDE).</param>
     /// <returns>An <see cref="IAsyncEnumerable{T}"/> that yields all matching elements of the sorted set.</returns>
     /// <exception cref="NotImplementedException">Thrown if <paramref name="flags"/> is not <see cref="CommandFlags.None"/>.</exception>
+    /// <remarks>
+    /// Unlike StackExchange.Redis, which only skips elements within the first scan batch (making the
+    /// skip non-deterministic since batch sizes are server-controlled), GLIDE skips <paramref name="pageOffset"/>
+    /// elements from the overall result stream regardless of internal batching. This provides deterministic behavior.
+    /// </remarks>
     IAsyncEnumerable<SortedSetEntry> SortedSetScanAsync(ValkeyKey key, ValkeyValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None);
 
     /// <inheritdoc cref="ISortedSetBaseCommands.SortedSetScoreAsync(ValkeyKey, ValkeyValue)"/>
diff --git a/sources/Valkey.Glide/Abstract/IServer.cs b/sources/Valkey.Glide/Abstract/IServer.cs
index 15080694..fce9ceab 100644
--- a/sources/Valkey.Glide/Abstract/IServer.cs
+++ b/sources/Valkey.Glide/Abstract/IServer.cs
@@ -349,13 +349,20 @@ public partial interface IServer : IRedisAsync
     /// <param name="pattern">The pattern to match keys against. If not specified, all keys are returned.</param>
     /// <param name="pageSize">The number of keys to return per SCAN iteration.</param>
     /// <param name="cursor">The cursor to start scanning from.</param>
-    /// <param name="pageOffset">The number of keys to skip from the first page of results.</param>
+    /// <param name="pageOffset">The number of keys to skip from the beginning of the result stream.</param>
     /// <param name="flags">Command flags (currently not supported by GLIDE).</param>
     /// <exception cref="NotImplementedException">Thrown if <paramref name="flags"/> is not <see cref="CommandFlags.None"/>.</exception>
     /// <returns>An async enumerable of keys matching the pattern.</returns>
     /// <remarks>
+    /// <para>
     /// Unlike StackExchange.Redis, GLIDE does not support per-database selection.
     /// Use <see cref="IConnectionManagementBaseCommands.SelectAsync(long)"/> to change the current database.
+    /// </para>
+    /// <para>
+    /// Unlike StackExchange.Redis, which only skips elements within the first scan batch (making the
+    /// skip non-deterministic since batch sizes are server-controlled), GLIDE skips <paramref name="pageOffset"/>
+    /// elements from the overall result stream regardless of internal batching. This provides deterministic behavior.
+    /// </para>
     /// </remarks>
     IAsyncEnumerable<ValkeyKey> KeysAsync(
         ValkeyValue pattern = default,
diff --git a/tests/Valkey.Glide.IntegrationTests/StackExchange/SetCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/StackExchange/SetCommandTests.cs
index 352831d2..d886e288 100644
--- a/tests/Valkey.Glide.IntegrationTests/StackExchange/SetCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/StackExchange/SetCommandTests.cs
@@ -85,20 +85,34 @@ public async Task SetScanAsync_WithPageSize_ReturnsAllMembers(IDatabaseAsync db)
     [MemberData(nameof(TestConfiguration.TestDatabases), MemberType = typeof(TestConfiguration))]
     public async Task SetScanAsync_WithPageOffset_SkipsElements(IDatabaseAsync db)
     {
-        string key = $"ser-sscan-offset-{Guid.NewGuid()}";
+        var key = $"ser-sscan-offset-{Guid.NewGuid()}";
         _ = await db.SetAddAsync(key, ["a", "b", "c", "d", "e"]);
 
-        // With pageOffset, we skip elements from the first page
-        List<ValkeyValue> results = [];
-        await foreach (ValkeyValue value in db.SetScanAsync(key, pageSize: 1000, pageOffset: 2))
+        var results = new List<ValkeyValue>();
+        await foreach (var value in db.SetScanAsync(key, pageOffset: 3))
         {
             results.Add(value);
         }
 
-        // Should have 3 elements (5 - 2 skipped)
-        Assert.Equal(3, results.Count);
+        Assert.Equal(2, results.Count);
+    }
 
+    [Theory(DisableDiscoveryEnumeration = true)]
+    [MemberData(nameof(TestConfiguration.TestDatabases), MemberType = typeof(TestConfiguration))]
+    public async Task SetScanAsync_WithPageOffsetGreaterThanPageSize_SkipsElements(IDatabaseAsync db)
+    {
+        var key = $"ser-sscan-offset-gt-pagesize-{Guid.NewGuid()}";
+        _ = await db.SetAddAsync(key, ["a", "b", "c", "d", "e"]);
+
+        var results = new List<ValkeyValue>();
+        await foreach (var value in db.SetScanAsync(key, pageSize: 2, pageOffset: 3))
+        {
+            results.Add(value);
+        }
+
+        Assert.Equal(2, results.Count);
     }
+
     #endregion
     #region SetAddAsync
 
diff --git a/tests/Valkey.Glide.IntegrationTests/StackExchange/SortedSetCommandTests.cs b/tests/Valkey.Glide.IntegrationTests/StackExchange/SortedSetCommandTests.cs
index 2add0771..fe29aaf8 100644
--- a/tests/Valkey.Glide.IntegrationTests/StackExchange/SortedSetCommandTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/StackExchange/SortedSetCommandTests.cs
@@ -932,24 +932,32 @@ public async Task SortedSetScanAsync_WithPageSize_ReturnsAllMembers(IDatabaseAsy
     [MemberData(nameof(TestConfiguration.TestDatabases), MemberType = typeof(TestConfiguration))]
     public async Task SortedSetScanAsync_WithPageOffset_SkipsElements(IDatabaseAsync db)
     {
-        string key = $"ser-zscan-offset-{Guid.NewGuid()}";
-        _ = await db.SortedSetAddAsync(key, [
-            new SortedSetEntry("a", 1.0),
-            new SortedSetEntry("b", 2.0),
-            new SortedSetEntry("c", 3.0),
-            new SortedSetEntry("d", 4.0),
-            new SortedSetEntry("e", 5.0)
-        ]);
+        var key = $"ser-zscan-offset-{Guid.NewGuid()}";
+        _ = await db.SortedSetAddAsync(key, [new("a", 1.0), new("b", 2.0), new("c", 3.0), new("d", 4.0), new("e", 5.0)]);
 
-        // With pageOffset, we skip elements from the first page
-        List<SortedSetEntry> results = [];
-        await foreach (SortedSetEntry entry in db.SortedSetScanAsync(key, pageSize: 1000, pageOffset: 2))
+        var results = new List<SortedSetEntry>();
+        await foreach (var entry in db.SortedSetScanAsync(key, pageOffset: 3))
         {
             results.Add(entry);
         }
 
-        // Should have 3 elements (5 - 2 skipped)
-        Assert.Equal(3, results.Count);
+        Assert.Equal(2, results.Count);
+    }
+
+    [Theory(DisableDiscoveryEnumeration = true)]
+    [MemberData(nameof(TestConfiguration.TestDatabases), MemberType = typeof(TestConfiguration))]
+    public async Task SortedSetScanAsync_WithPageOffsetGreaterThanPageSize_SkipsElements(IDatabaseAsync db)
+    {
+        var key = $"ser-zscan-offset-gt-pagesize-{Guid.NewGuid()}";
+        _ = await db.SortedSetAddAsync(key, [new("a", 1.0), new("b", 2.0), new("c", 3.0), new("d", 4.0), new("e", 5.0)]);
+
+        var results = new List<SortedSetEntry>();
+        await foreach (var entry in db.SortedSetScanAsync(key, pageSize: 2, pageOffset: 3))
+        {
+            results.Add(entry);
+        }
+
+        Assert.Equal(2, results.Count);
     }
 
     [Theory(DisableDiscoveryEnumeration = true)]
diff --git a/tests/Valkey.Glide.IntegrationTests/StackExchange/ValkeyServerTests.cs b/tests/Valkey.Glide.IntegrationTests/StackExchange/ValkeyServerTests.cs
index 7a06d51c..fd5cfd9d 100644
--- a/tests/Valkey.Glide.IntegrationTests/StackExchange/ValkeyServerTests.cs
+++ b/tests/Valkey.Glide.IntegrationTests/StackExchange/ValkeyServerTests.cs
@@ -22,64 +22,60 @@ public async Task KeysAsync_ReturnsMatchingKeys()
         var server = fixture.Server;
         var db = fixture.Database;
 
-        string prefix = Guid.NewGuid().ToString();
-        string key1 = $"{prefix}:key1";
-        string key2 = $"{prefix}:key2";
-        string key3 = $"{prefix}:key3";
-        string otherKey = "other:key";
-
-        _ = await db.StringSetAsync(key1, "value1");
-        _ = await db.StringSetAsync(key2, "value2");
-        _ = await db.StringSetAsync(key3, "value3");
-        _ = await db.StringSetAsync(otherKey, "other");
-
-        List<ValkeyKey> keys = [];
-        await foreach (ValkeyKey key in server.KeysAsync(pattern: $"{prefix}:*"))
+        var prefix = $"ser-keys-{Guid.NewGuid()}";
+        foreach (var element in new[] { "a", "b", "c", "d", "e" })
         {
-            keys.Add(key);
+            _ = await db.StringSetAsync($"{prefix}:{element}", "value");
         }
 
-        Assert.Equal(3, keys.Count);
-        Assert.Contains(key1, keys.Select(k => k.ToString()));
-        Assert.Contains(key2, keys.Select(k => k.ToString()));
-        Assert.Contains(key3, keys.Select(k => k.ToString()));
-        Assert.DoesNotContain(otherKey, keys.Select(k => k.ToString()));
+        // Test scanning all keys
+        var results = new List<ValkeyKey>();
+        await foreach (var key in server.KeysAsync(pattern: $"{prefix}:*"))
+        {
+            results.Add(key);
+        }
+
+        Assert.Equal(5, results.Count);
+        results.Clear();
 
         // Test scanning with pageSize
-        keys.Clear();
-        await foreach (ValkeyKey key in server.KeysAsync(pattern: $"{prefix}:*", pageSize: 1))
+        await foreach (var key in server.KeysAsync(pattern: $"{prefix}:*", pageSize: 1))
         {
-            keys.Add(key);
+            results.Add(key);
         }
-        Assert.Equal(3, keys.Count);
+
+        Assert.Equal(5, results.Count);
+        results.Clear();
 
         // Test scanning with pageOffset
-        keys.Clear();
-        await foreach (ValkeyKey key in server.KeysAsync(pattern: $"{prefix}:*", pageOffset: 1))
+        await foreach (var key in server.KeysAsync(pattern: $"{prefix}:*", pageOffset: 3))
         {
-            keys.Add(key);
+            results.Add(key);
         }
-        Assert.True(keys.Count >= 2);
+
+        Assert.Equal(2, results.Count);
+        results.Clear();
+
+        // Test scanning with pageOffset > pageSize
+        await foreach (var key in server.KeysAsync(pattern: $"{prefix}:*", pageSize: 2, pageOffset: 3))
+        {
+            results.Add(key);
+        }
+
+        Assert.Equal(2, results.Count);
+        results.Clear();
 
         // Test scanning non-existent pattern
-        keys.Clear();
-        await foreach (ValkeyKey key in server.KeysAsync(pattern: "nonexistent:*"))
+        await foreach (var key in server.KeysAsync(pattern: "nonexistent:*"))
         {
-            keys.Add(key);
+            results.Add(key);
         }
-        Assert.Empty(keys);
 
-        // Clear database.
+        Assert.Empty(results);
+
         await server.FlushDatabaseAsync();
     }
 
-    [Fact]
-    public async Task KeysAsync_CommandFlags_Throws()
-        => _ = await Assert.ThrowsAsync<NotImplementedException>(
-            () => fixture.Server.KeysAsync(flags: UnsupportedCommandFlag)
-                .GetAsyncEnumerator(TestContext.Current.CancellationToken)
-                .MoveNextAsync().AsTask());
-
     [Fact]
     public async Task DatabaseSizeAsync_ReturnsSize()
     {