diff --git a/DEVELOPER_GUIDE.md b/DEVELOPER_GUIDE.md
index 87722ec8b..347c12c2a 100644
--- a/DEVELOPER_GUIDE.md
+++ b/DEVELOPER_GUIDE.md
@@ -2182,6 +2182,7 @@ Extractor strategy by language surface:
 | HTML | Uses a dedicated character-level state machine instead of the regex pattern loop. It walks tag openers, quoted/unquoted attribute values including multi-line values, and masks `<script>` / `<style>` / `<textarea>` / `<title>` bodies plus `<!-- ... -->` comments so attribute-lookalike strings inside those regions do not leak phantom symbols. |
 | JSON / JSON Lines | JSON emits `object`, `array`, `property`, and bounded primitive-array `value` symbols with indexed paths. Array indexes attach directly to the parent path (`command_cases[0]`, not `command_cases.command_cases[0]`), and object/array parent kinds preserve the hierarchy used by outline depth. Root arrays start at paths such as `[0]`. `.jsonl` and `.ndjson` parse each non-empty physical line independently, prefix symbols with a stable zero-based record path such as `[0].result.path`, and emit repository-local path references from each valid record without flattening malformed neighbors. |
 | TOML / repository metadata | TOML tables and keys, EditorConfig sections and keys, Git/Docker ignore rules, Git attribute rules/attributes, and `.rules` blocks/keys are emitted as bounded structural symbols. References are limited to repository-local paths or globs; remote URLs, absolute filesystem paths, and parent traversal are suppressed. |
+| CODEOWNERS | Path-aware detection recognizes only the case-sensitive paths `.github/CODEOWNERS`, repository-root `CODEOWNERS`, and `docs/CODEOWNERS`, relative to the enclosing Git worktree root or to the scan root for non-Git input. A dedicated bounded line parser handles full-line and inline comments and emits ordered ownership `rule` symbols and child owner `property` symbols, including ownerless rules, with limits of 4,096 characters per line, 128 owners per rule, and 256 characters per owner. Invalid input, including unsupported escaped leading `#` patterns and malformed mentions, produces category-deduplicated, persistable extraction-diagnostic annotations. No reference extractor is registered because owner authorization and pattern-to-path resolution are outside the syntax-only contract. |
 | Windows application manifests | Manifest element paths, assembly identities, execution levels, and supported-OS values remain structural symbols. Dependent assembly identities emit `dependency` references, while local `file`, `codeBase`, and probing paths emit `project_reference` edges. |
 | XML / NuGet.config | Generic XML emits bounded element and attribute paths. NuGet.config additionally promotes package sources, source mappings, signature validation mode, trusted signer names, certificate fingerprints, and `allowUntrustedRoot` values to semantic `property` symbols with `nuget.*` subkinds. |
 
@@ -6298,6 +6299,7 @@ LIMIT 20;
 | HTML | 汎用の正規表現 loop を使わず、専用の文字単位 state machine で tag opener、引用符付き/なし attribute value（複数行値を含む）、`<script>` / `<style>` / `<textarea>` / `<title>` body、`<!-- ... -->` comment を扱い、attribute 名に似た body 内文字列から phantom symbol が漏れないようにします。 |
 | JSON / JSON Lines | JSON は `object`、`array`、`property` と、上限付きの primitive-array `value` symbol を index 付き path で出力します。配列 index は親 path に直接連結し（`command_cases.command_cases[0]` ではなく `command_cases[0]`）、object / array の親 kind を保持して outline の depth に階層を反映します。root array は `[0]` のような path から始まります。`.jsonl` と `.ndjson` は空でない物理行を個別に parse し、`[0].result.path` のような安定した 0 始まり record path を付けます。各有効 record から repository-local path reference を出し、不正な隣接 record の内容は平坦化しません。 |
 | TOML / repository metadata | TOML の table / key、EditorConfig の section / key、Git / Docker ignore rule、Git attribute の rule / attribute、`.rules` の block / key を上限付き structural symbol として出力します。reference は repository-local な path / glob に限定し、remote URL、絶対 filesystem path、親 directory traversal は抑止します。 |
+| CODEOWNERS | path-aware detection は enclosing Git worktree root（非 Git input では scan root）からの相対位置が case-sensitive な `.github/CODEOWNERS`、repository root の `CODEOWNERS`、`docs/CODEOWNERS` である場合だけ認識します。専用の上限付き line parser が full-line / inline comment を処理し、順序付き ownership `rule` symbol と child owner `property` symbol を出力して ownerless rule も保持します。上限は1行4,096文字、1 rule 128 owner、1 owner 256文字です。GitHub が対応しない先頭 `#` の escaped pattern や malformed mention を含む不正 input は、category ごとに重複を除いた永続化可能な extraction-diagnostic annotation にします。owner authorization と pattern から path への解決は syntax-only contract の範囲外なので、reference extractor は登録しません。 |
 | Windows application manifest | manifest element path、assembly identity、execution level、supported OS value を structural symbol として維持します。依存 assembly identity は `dependency` reference、local な `file` / `codeBase` / probing path は `project_reference` edge を出力します。 |
 | XML / NuGet.config | 汎用 XML は上限付きの element / attribute path を出力します。NuGet.config ではさらに package source、source mapping、署名検証モード、trusted signer 名、証明書 fingerprint、`allowUntrustedRoot` の値を `nuget.*` subkind 付きの semantic `property` symbol にします。 |
 
diff --git a/TESTING_GUIDE.md b/TESTING_GUIDE.md
index efb135f9f..6bd740905 100644
--- a/TESTING_GUIDE.md
+++ b/TESTING_GUIDE.md
@@ -19,6 +19,7 @@ Use the full suite by default. Use targeted filters only while iterating locally
 
 ## Test Stack
 
+- Issue #5198 CODEOWNERS coverage belongs in `FileIndexerTests.cs`, `SymbolExtractorRepositoryMetadataTests.cs`, `QueryCommandRunnerFilesTests.cs`, `IndexCommandRunnerUpdateTests.cs`, `QueryCommandRunnerTests.cs`, and `McpServerToolsCallTests.cs`. Preserve the three case-sensitive Git-worktree-relative locations and the arbitrary-nested/case-variant/POSIX-literal-backslash negative cases, including scans rooted below the enclosing worktree; parser cases for full-line and inline comments, blank lines, whitespace, CRLF, rejection of unsupported escaped leading `#`, ownerless rules, user/team/email owners, malformed mentions, duplicate and overlapping patterns, invalid input, and persistable bounded diagnostics; ordered rule and owner child symbols; symbol-only capability guidance; full/scoped/delete indexing; branch-switch reconciliation; and removal from unknown-extension status diagnostics.
 - Issue #5194 shell-completion inventory coverage belongs in `CliFlagSchemaTests.cs` and `ConsoleUiTests.cs`. Keep exact contextual inventories for lsp, every workspace verb, config show, diff, import, archive export, and ctags export synchronized with authoritative help and safe parser probes. Preserve positive and negative nested cases, value-taking versus boolean metadata, context-specific short aliases, mutually exclusive diff modes, exact schema-to-renderer sets for Bash/zsh/fish/PowerShell, and the available-shell generated-script execution contract.
 - Issue #5187 exact graph-selector coverage belongs in `QueryCommandRunnerIssue5187Tests.cs` and `McpServerIssue5187Tests.cs`. Keep one fixture with unrelated same-name methods, distinct callees, and multiple callers. Round-trip selectors emitted by `inspect` through CLI and MCP references/callers/callees/impact; preserve explicit bare-name ambiguity metadata, exact selected zero behavior after filters, stable invalid/stale/cross-database diagnostics, selector-bound cursor mismatch, structured-field discovery, command help, and all four shell completions.
 - Issue #5157 C# primary-constructor property coverage belongs in `SymbolExtractorCSharpTests.cs` and `QueryCommandRunnerSymbolTests.cs`. Keep ordinary class/struct and nested/private attributed multiline parameters absent from property symbols while preserving positional `record`, `record class`, and `record struct` properties, including nullable and generic components. Exercise `symbols`, `definition`, `outline`, public-visibility filtering, and full/incremental indexing parity. When this extractor gate changes, keep `CSharpContractVersion` and the stale-index refresh assertions in `IndexCommandRunnerFullScanTests.cs` synchronized.
@@ -1161,6 +1162,7 @@ dotnet test --filter "FullyQualifiedName~GitHelperTests"
 
 ## テストスタック
 
+- Issue #5198 の CODEOWNERS coverage は `FileIndexerTests.cs`、`SymbolExtractorRepositoryMetadataTests.cs`、`QueryCommandRunnerFilesTests.cs`、`IndexCommandRunnerUpdateTests.cs`、`QueryCommandRunnerTests.cs`、`McpServerToolsCallTests.cs` が担当します。case-sensitive な3つの Git worktree-relative location と、enclosing worktree より下を scan root にした場合を含む任意の nested file・大小文字違い file・POSIX の literal backslash file の negative case、full-line / inline comment・blank line・whitespace・CRLF・未対応である先頭 `#` の escape の拒否・ownerless rule・user/team/email owner・malformed mention・duplicate / overlapping pattern・不正 input・永続化可能な上限付き diagnostic の parser case、順序付き rule と owner child symbol、symbol-only capability guidance、full / scoped / delete indexing、branch-switch reconciliation、unknown-extension status diagnostic からの除外を維持してください。
 - Issue #5194 の shell completion inventory coverage は `CliFlagSchemaTests.cs` と `ConsoleUiTests.cs` が担当します。lsp、workspace の全 verb、config show、diff、import、archive export、ctags export の正確な context 別 inventory を、authoritative help と安全な parser probe に同期してください。nested context の positive / negative case、value-taking と boolean の metadata、context 固有の short alias、diff の排他的 mode、Bash / zsh / fish / PowerShell における schema-to-renderer の完全一致、および利用可能な shell で生成 script を実行する契約を維持します。
 - Issue #5187 の exact graph-selector coverage は `QueryCommandRunnerIssue5187Tests.cs` と `McpServerIssue5187Tests.cs` が担当します。無関係な同名 method、異なる callee、複数 caller を持つ 1 つの fixture を維持してください。`inspect` が出力した selector を CLI / MCP の references、callers、callees、impact へ round-trip し、bare-name ambiguity metadata の明示、filter 適用後も正確な selected zero behavior、安定した invalid / stale / cross-database diagnostic、selector に束縛された cursor mismatch、structured-field discovery、command help、4 種類すべての shell completion を保ちます。
 - Issue #5157 の C# primary-constructor property coverage は `SymbolExtractorCSharpTests.cs` と `QueryCommandRunnerSymbolTests.cs` が担当します。通常の class / struct および attribute 付き multiline parameter を持つ nested / private type では property symbol を生成せず、nullable / generic component を含む位置 `record`、`record class`、`record struct` の property は維持してください。`symbols`、`definition`、`outline`、public visibility filter、full / incremental indexing の parity を検証します。この extractor gate を変更するときは、`CSharpContractVersion` と `IndexCommandRunnerFullScanTests.cs` の stale-index refresh assertion も同期してください。
diff --git a/USER_GUIDE.md b/USER_GUIDE.md
index e4265239c..7d8ef66fd 100644
--- a/USER_GUIDE.md
+++ b/USER_GUIDE.md
@@ -2927,6 +2927,7 @@ For one `--extension` lookup, CLI JSON and the MCP `languages` tool return the s
 | Gradle | `.gradle` | yes |
 | Dependency manifest | `package.json`, `pyproject.toml`, `requirements.txt`, `Gemfile`, `Podfile`, `Cargo.toml`, `composer.json`, `go.mod`, `packages.config` | -- |
 | Dependency lockfile | `package-lock.json`, `npm-shrinkwrap.json`, `yarn.lock`, `pnpm-lock.yaml`, `Gemfile.lock`, `Cargo.lock`, `go.sum`, `uv.lock` | -- |
+| CODEOWNERS | `.github/CODEOWNERS`, `CODEOWNERS`, `docs/CODEOWNERS` | yes |
 | Makefile | `Makefile`, `GNUmakefile`, `Makefile.<suffix>`, `GNUmakefile.<suffix>`, `.mk` | yes |
 | Dockerfile | `Dockerfile`, `Containerfile`, `Dockerfile.<suffix>`, `Containerfile.<suffix>` | yes |
 | Assembly | `.s`, `.S`, `.asm`, `.nasm` | yes |
@@ -2992,6 +2993,7 @@ For one `--extension` lookup, CLI JSON and the MCP `languages` tool return the s
 - Node module layouts: `.cjs` / `.mjs` are JavaScript; `.cts` / `.mts`, including `.d.cts` / `.d.mts`, are TypeScript.
 - Dependency manifests and lockfiles: use `--lang dependency_manifest` or `--lang dependency_lock` for dependency/security audits. `Directory.Packages.props`, `packages.config`, `requirements.txt`, `pyproject.toml`, `packages.lock.json`, and npm `package-lock.json` / `npm-shrinkwrap.json` expose package symbols and `dependency` references with version, scope, and direct/transitive metadata where the format provides it.
 - Solution and application manifests: `.sln` files expose project entries as symbols and project path references; `.manifest` files expose assembly identity, requested execution level, supported OS, and long-path settings as symbols.
+- CODEOWNERS: cdidx indexes every recognized candidate at the case-sensitive paths `.github/CODEOWNERS`, repository-root `CODEOWNERS`, and `docs/CODEOWNERS`; locations are relative to the enclosing Git worktree root, with the scan root used for non-Git input. Arbitrary nested or case-variant files are not classified as CODEOWNERS. GitHub selects the first existing file in that location order, and the last matching rule in the effective file controls ownership. Each ordered pattern is a `rule` symbol, each syntactically valid user, team, or email owner is a child `property` symbol, and ownerless rules remain visible. Full-line and inline comments, blank lines, horizontal whitespace, and CRLF input are handled; unsupported escaped leading `#` patterns and other malformed or oversized input produce bounded extraction-diagnostic annotations. Use `search --lang codeowners` for raw text, `files --lang codeowners` for candidates, and `symbols --lang codeowners` or `outline` for structure. cdidx does not resolve owner authorization, team membership, or pattern-to-path ownership, and CODEOWNERS does not advertise reference or graph support.
 - Shebang scripts: recognized first-line shebangs index extensionless and unknown-extension files for shell (`sh`, `bash`, `zsh`, `fish`, `dash`, `ksh`, `ash`), Python, Ruby, Perl, Tcl (`tclsh`, `wish`), Node.js, PHP, Lua, and PowerShell. Explicit language-map overrides remain authoritative; for ambiguous `.t` files, a recognized shebang overrides the Perl default, while strong known extensions continue to win conflicts.
 - Ambiguous `.m` / `.pl`: recognized shebangs win first, then bounded content checks use only strong Objective-C/MATLAB or Perl/Prolog markers, followed by conservative project markers. Scoped updates that add, change, or remove one of those markers automatically rescan the workspace so unchanged ambiguous files do not retain stale classifications. Weak or conflicting evidence remains searchable under `ambiguous_m` or `ambiguous_pl` instead of being assigned unconditionally. Unresolved `.m` content exposes the conservative union of MATLAB and Objective-C symbols/references after both comment syntaxes are position-preservingly masked. Prolog and `ambiguous_pl` expose conservative symbols, references, and graph queries after classification; `ambiguous_pl` uses a safe union of Perl and Prolog constructs without overriding the content-based language decision.
 
@@ -3039,6 +3041,7 @@ returns a typed stale-cursor error that requires restarting without `cursor`.
 | Verilog / SystemVerilog / VHDL | modules, packages, interfaces, classes, functions/tasks/processes, types, signals/parameters | module/entity/interface instantiations, package/import/use relationships, architecture/entity links, bounded known signal/type references | HDL graph extraction is syntax-based and does not elaborate generates, macros, parameterized hierarchy, or signal data flow; use `search` for those cases. |
 | Shell / PowerShell / Batch / Makefile / CMake / Justfile / MSBuild / Gradle | functions, labels, targets, recipes, tasks, imports where applicable | command-style calls, target dependencies, and control-flow targets | Runtime command construction is not resolved. |
 | Solution / application manifest | solution projects and manifest identity/settings | solution project references; application manifests are symbol-only | `.sln` project paths are graph edges for repository structure; use `symbols --lang app_manifest` for Windows manifest metadata. |
+| CODEOWNERS | ordered pattern rules and owner child properties | none | All three supported candidate locations are searchable. GitHub location and last-match precedence are documented above; cdidx does not perform authorization or path-to-owner resolution. |
 | SQL / Terraform / Dockerfile | statements/resources/stages/labels | table/resource/stage references, Dockerfile stage dependencies, Terraform dotted refs | SQL hotspot grouping defaults to statements; Dockerfile `COPY --from=<stage>` follows named stages. |
 | Markdown / HTML / CSS / Sass / Stylus / XML / XAML / GraphQL / Protobuf | headings, explicit anchors, selectors, UI elements, generic XML element/attribute paths, schema types/messages where supported | links/assets/components, path-scoped local and cross-document fragments, CSS/Sass/Stylus imports, variables, mixins/functions, XAML resources/bindings/handlers, schema references where supported | Markdown fragment references resolve only against headings or explicit anchors in the linked document. Generic non-XAML XML emits bounded structural symbols; use `search` for prose and generated markup. |
 | Dependency manifests / lockfiles | none | none | Use `--lang dependency_manifest` or `--lang dependency_lock` for dependency/security audits. |
@@ -6545,6 +6548,7 @@ CLI JSON と MCP の `languages` response は同じ catalog snapshot を共有
 | Gradle | `.gradle` | yes |
 | Dependency manifest | `package.json`, `pyproject.toml`, `requirements.txt`, `Gemfile`, `Podfile`, `Cargo.toml`, `composer.json`, `go.mod`, `packages.config` | -- |
 | Dependency lockfile | `package-lock.json`, `npm-shrinkwrap.json`, `yarn.lock`, `pnpm-lock.yaml`, `Gemfile.lock`, `Cargo.lock`, `go.sum`, `uv.lock` | -- |
+| CODEOWNERS | `.github/CODEOWNERS`、`CODEOWNERS`、`docs/CODEOWNERS` | yes |
 | Makefile | `Makefile`, `GNUmakefile`, `Makefile.<suffix>`, `GNUmakefile.<suffix>`, `.mk` | yes |
 | Dockerfile | `Dockerfile`, `Containerfile`, `Dockerfile.<suffix>`, `Containerfile.<suffix>` | yes |
 | Assembly | `.s`, `.S`, `.asm`, `.nasm` | yes |
@@ -6610,6 +6614,7 @@ CLI JSON と MCP の `languages` response は同じ catalog snapshot を共有
 - Node モジュール構成: `.cjs` / `.mjs` は JavaScript、`.cts` / `.mts`（`.d.cts` / `.d.mts` を含む）は TypeScript として扱います。
 - Dependency manifest / lockfile: dependency / security audit では `--lang dependency_manifest` または `--lang dependency_lock` を使います。`Directory.Packages.props`、`packages.config`、`requirements.txt`、`pyproject.toml`、`packages.lock.json`、npm の `package-lock.json` / `npm-shrinkwrap.json` は、format が提供する範囲で version、scope、direct/transitive metadata を持つ package symbol と `dependency` reference を公開します。
 - ソリューションとアプリケーションマニフェスト: `.sln` は project entry をシンボルとして公開し、project path を参照として記録します。`.manifest` は assembly identity、requested execution level、supported OS、long-path 設定をシンボルとして公開します。
+- CODEOWNERS: cdidx は case-sensitive な `.github/CODEOWNERS`、repository root の `CODEOWNERS`、`docs/CODEOWNERS` にある認識済み candidate をすべて索引します。location は enclosing Git worktree root からの相対位置で判定し、非 Git input では scan root を使います。任意の nested file や大小文字が異なる file は CODEOWNERS として分類しません。GitHub はこの順序で最初に存在する file を選び、有効な file 内では最後に一致した rule が ownership を決定します。順序付き pattern ごとに `rule` symbol、構文上有効な user・team・email owner ごとに child `property` symbol を出力し、owner のない rule も可視化します。full-line / inline comment、blank line、horizontal whitespace、CRLF を処理し、GitHub が対応しない先頭 `#` の escaped pattern と、その他の不正または過大な input は上限付き extraction-diagnostic annotation にします。raw text は `search --lang codeowners`、candidate は `files --lang codeowners`、構造は `symbols --lang codeowners` または `outline` で確認できます。cdidx は owner の authorization、team membership、pattern から path への ownership 解決を行わず、CODEOWNERS は reference / graph 対応を広告しません。
 - shebang script: 先頭行の shebang を認識できる拡張子なし/未知拡張子ファイルは、shell (`sh`, `bash`, `zsh`, `fish`, `dash`, `ksh`, `ash`)、Python、Ruby、Perl、Tcl (`tclsh`, `wish`)、Node.js、PHP、Lua、PowerShell として index 対象です。明示的な language-map override は常に優先し、曖昧な `.t` では認識済み shebang が Perl の既定値を上書きします。一方、曖昧でない既知拡張子は競合する shebang より優先されます。
 - 曖昧な `.m` / `.pl`: 認識済み shebang を最優先し、その後は bounded content check で Objective-C/MATLAB または Perl/Prolog の強い marker だけを使い、最後に保守的な project marker を確認します。これらの marker を追加・変更・削除する scoped update は workspace を自動的に再 scan し、未変更の曖昧ファイルに古い分類を残しません。弱い証拠や競合する証拠は無条件に言語を割り当てず、`ambiguous_m` / `ambiguous_pl` として全文検索可能なまま残します。未確定の `.m` は両方のコメント構文を位置を保ってマスクした後、MATLAB と Objective-C の symbol/reference を保守的に統合します。Prolog と `ambiguous_pl` は分類後に保守的な symbol、reference、graph query を公開し、`ambiguous_pl` は content-based の言語判定を上書きせず Perl / Prolog 構文の安全な和集合を使います。
 
@@ -6650,6 +6655,7 @@ item budget と byte budget のどちらが継続理由かも示します。filt
 | Verilog / SystemVerilog / VHDL | module、package、interface、class、function/task/process、type、signal/parameter | module/entity/interface のインスタンス化、package/import/use 関係、architecture/entity link、上限付きの既知 signal/type reference | HDL graph extraction は構文ベースで、generate、macro、parameterized hierarchy、signal data flow の elaboration は行いません。これらには `search` を使ってください。 |
 | Shell / PowerShell / Batch / Makefile / CMake / Justfile / MSBuild / Gradle | function、label、target、recipe、task、対応言語の import | command-style call、target dependency、control-flow target | runtime で組み立てられる command は解決しません。 |
 | ソリューション / アプリケーションマニフェスト | solution project、manifest identity / setting | `.sln` の project reference。manifest は symbol-only | `.sln` の project path はリポジトリ構造の graph edge です。Windows manifest metadata は `symbols --lang app_manifest` で確認できます。 |
+| CODEOWNERS | 順序付き pattern rule と owner の child property | なし | 対応する3箇所の candidate をすべて検索できます。GitHub の location precedence と last-match precedence は上記の説明に従い、cdidx は authorization や path から owner への解決を行いません。 |
 | SQL / Terraform / Dockerfile | statement/resource/stage/label | table/resource/stage reference、Dockerfile stage dependency、Terraform dotted refs | SQL hotspot grouping は既定で statement、Dockerfile `COPY --from=<stage>` は named stage を追跡します。 |
 | Markdown / HTML / CSS / Sass / Stylus / XML / XAML / GraphQL / Protobuf | heading、明示的な anchor、selector、UI element、汎用 XML の要素・属性パス、対応 schema type/message | link/asset/component、path に限定した同一文書・文書間の fragment、CSS/Sass/Stylus の import・variable・mixin/function、XAML resource / binding / handler、対応 schema reference | Markdown の fragment reference は、リンク先文書内の heading または明示的な anchor にのみ解決します。汎用の非 XAML XML は上限付きの構造シンボルを出力します。prose や generated markup には `search` を使ってください。 |
 | Dependency manifest / lockfile | なし | なし | dependency / security audit には `--lang dependency_manifest` または `--lang dependency_lock` を使います。 |
diff --git a/changelog.d/unreleased/5198.added.md b/changelog.d/unreleased/5198.added.md
new file mode 100644
index 000000000..ec080cc3e
--- /dev/null
+++ b/changelog.d/unreleased/5198.added.md
@@ -0,0 +1,26 @@
+---
+category: added
+issues:
+  - 5198
+affected:
+  - src/CodeIndex/Indexer/Scanning/FileIndexer.FileNameLanguages.cs
+  - src/CodeIndex/Indexer/Scanning/FileIndexer.LanguageDetection.cs
+  - src/CodeIndex/Indexer/Symbols/SymbolExtractor.CodeOwners.cs
+  - src/CodeIndex/Indexer/Symbols/SymbolExtractor.Contracts.cs
+  - src/CodeIndex/Indexer/Symbols/SymbolExtractor.ExtractionPhases.cs
+  - tests/CodeIndex.Tests/FileIndexerTests.cs
+  - tests/CodeIndex.Tests/IndexCommandRunnerUpdateTests.cs
+  - tests/CodeIndex.Tests/QueryCommandRunnerFilesTests.cs
+  - tests/CodeIndex.Tests/SymbolExtractorRepositoryMetadataTests.cs
+  - USER_GUIDE.md
+  - DEVELOPER_GUIDE.md
+  - TESTING_GUIDE.md
+---
+
+## English
+
+- **CODEOWNERS files are now first-class searchable repository metadata (#5198)** — cdidx recognizes the three case-sensitive GitHub-supported locations relative to the enclosing Git worktree root (or the scan root for non-Git input), handles full-line and inline comments, indexes ordered ownership rules and syntactically valid user/team/email owners for `symbols` and `outline`, keeps raw `search` and candidate `files` queries available, and persists bounded diagnostic annotations for unsupported, malformed, or oversized rules without claiming owner authorization or graph semantics.
+
+## 日本語
+
+- **CODEOWNERS file を first-class の検索可能な repository metadata として扱うようになりました (#5198)** — cdidx は enclosing Git worktree root（非 Git input では scan root）から見て GitHub が対応する case-sensitive な3つの location を認識し、full-line / inline comment を処理して、順序付き ownership rule と構文上有効な user/team/email owner を `symbols` / `outline` 用に索引します。raw `search` と candidate の `files` query も利用でき、未対応・不正・過大な rule には上限付き diagnostic annotation を永続化しつつ、owner authorization や graph semantics は保証しません。
diff --git a/src/CodeIndex/Indexer/Scanning/FileIndexer.FileNameLanguages.cs b/src/CodeIndex/Indexer/Scanning/FileIndexer.FileNameLanguages.cs
index 088fcd3b0..b91d96d59 100644
--- a/src/CodeIndex/Indexer/Scanning/FileIndexer.FileNameLanguages.cs
+++ b/src/CodeIndex/Indexer/Scanning/FileIndexer.FileNameLanguages.cs
@@ -63,6 +63,19 @@ public partial class FileIndexer
     private static readonly IReadOnlyDictionary<string, string> FileNameMapIgnoreCase =
         new Dictionary<string, string>(FileNameMap, StringComparer.OrdinalIgnoreCase);
 
+    // Repository-relative special paths whose meaning depends on their location. CODEOWNERS
+    // is intentionally not part of FileNameMap: GitHub recognizes only these three locations,
+    // and indexing an arbitrary nested CODEOWNERS file would overstate the ownership contract.
+    // location に意味が依存する repository-relative special path。CODEOWNERS は意図的に
+    // FileNameMap へ入れない。GitHub が認識する3箇所以外の nested file を ownership
+    // contract として index しないためである。
+    private static readonly (string Path, string Language)[] RepositoryRelativePathMap =
+    [
+        (".github/CODEOWNERS", "codeowners"),
+        ("CODEOWNERS", "codeowners"),
+        ("docs/CODEOWNERS", "codeowners"),
+    ];
+
     // Filename prefixes (with trailing dot) mapped to language for suffixed variants like
     // Dockerfile.dev / Makefile.common / GNUmakefile.am. The suffix must be non-empty.
     // Dockerfile.dev / Makefile.common / GNUmakefile.am のようにサフィックス付きで使われる
diff --git a/src/CodeIndex/Indexer/Scanning/FileIndexer.LanguageDetection.cs b/src/CodeIndex/Indexer/Scanning/FileIndexer.LanguageDetection.cs
index d3a002171..b98d9f960 100644
--- a/src/CodeIndex/Indexer/Scanning/FileIndexer.LanguageDetection.cs
+++ b/src/CodeIndex/Indexer/Scanning/FileIndexer.LanguageDetection.cs
@@ -287,6 +287,7 @@ internal static IReadOnlyList<LanguagePattern> GetLanguagePatterns(
         var capacity = LangMap.Count
             + DisplayOnlyLanguageExtensions.Length
             + FileNameMap.Count
+            + RepositoryRelativePathMap.Length
             + FileNamePrefixMap.Length
             + pluginExtensions.Count
             + languageMapOverrides.Count;
@@ -320,6 +321,8 @@ void TryAddPattern(string pattern, string language, LanguagePatternKind kind, st
             TryAddPattern(pattern, lang, LanguagePatternKind.Extension, "built_in");
         foreach (var (name, lang) in FileNameMap)
             TryAddPattern(name, lang, LanguagePatternKind.ExactFilename, "built_in");
+        foreach (var (path, lang) in RepositoryRelativePathMap)
+            TryAddPattern(path, lang, LanguagePatternKind.ExactFilename, "built_in");
         // Surface suffixed variants like Dockerfile.dev / Makefile.am as `<Prefix><suffix>` entries
         // so `cdidx languages` and the MCP listing reflect what TryDetectLanguage actually handles.
         // Dockerfile.dev / Makefile.am のようなサフィックス付き変種も `<Prefix><suffix>` 形で
@@ -393,7 +396,8 @@ internal LanguageDetectionResult TryDetectLanguageForIndexing(
                 ? null
                 : ObservePatternConfigurationDirectoryExists,
             patternConfigInputObserver: ObservePatternConfigurationInput,
-            deferUnknownScriptHeader: deferUnknownScriptHeader);
+            deferUnknownScriptHeader: deferUnknownScriptHeader,
+            repositoryRoot: _ignoreRuleRoot);
 
     private IReadOnlyDictionary<string, string> LoadLanguageMapOverridesForIndexing(string? startDirectory)
     {
@@ -493,6 +497,15 @@ internal static bool CanReuseDetectedLanguageWithoutContent(string filePath, str
             return !string.Equals(extension, ".h", StringComparison.OrdinalIgnoreCase);
 
         var fileName = Path.GetFileName(filePath);
+        if (string.Equals(language, "codeowners", StringComparison.Ordinal)
+            && string.Equals(fileName, "CODEOWNERS", StringComparison.OrdinalIgnoreCase))
+        {
+            // The scan result already proved that this exact path is one of the supported
+            // repository-relative locations, so content loading may reuse that decision.
+            // scan result が supported repository-relative path であることを証明済みなので、
+            // content loading はその判定を再利用できる。
+            return true;
+        }
         if (TryGetExactFileNameLanguage(fileName, ignoreCase: true, out var nameLanguage))
             return string.Equals(language, nameLanguage, StringComparison.Ordinal);
 
@@ -519,7 +532,8 @@ internal static LanguageDetectionResult TryDetectLanguage(
         Func<string, Stream>? openPatternConfig = null,
         Func<string, bool, bool>? patternConfigDirectoryExists = null,
         Action<string, ReadOnlyMemory<byte>?, long?>? patternConfigInputObserver = null,
-        bool deferUnknownScriptHeader = false)
+        bool deferUnknownScriptHeader = false,
+        string? repositoryRoot = null)
     {
         var fileName = Path.GetFileName(filePath);
         var ext = Path.GetExtension(fileName);
@@ -539,6 +553,20 @@ internal static LanguageDetectionResult TryDetectLanguage(
                 : new LanguageDetectionResult(FileProbeStatus.Supported, overrideLang);
         }
 
+        // Location-scoped special files are checked before filename-only rules. Indexing passes
+        // the enclosing Git worktree root (with the scan root as the non-Git fallback), so a scan
+        // rooted at a subdirectory cannot promote an arbitrary nested CODEOWNERS file.
+        // location scoped special file は filename-only rule より先に判定する。indexing path は
+        // enclosing Git worktree root（非 Git では scan root）を渡すため、subdirectory scan が
+        // 任意の nested CODEOWNERS に GitHub semantics を付与することはない。
+        if (TryGetRepositoryRelativePathLanguage(
+                filePath,
+                repositoryRoot ?? projectRoot,
+                out var repositoryPathLanguage))
+        {
+            return new LanguageDetectionResult(FileProbeStatus.Supported, repositoryPathLanguage);
+        }
+
         // Exact filename matching beats built-in extension lookup so manifest-style filenames
         // like `pyproject.toml` map to a dependency category instead of the generic file type.
         // `pyproject.toml` のような manifest 系 filename が汎用 extension ではなく dependency
@@ -681,6 +709,55 @@ private static bool TryGetExactFileNameLanguage(string fileName, bool ignoreCase
         return false;
     }
 
+    private static bool TryGetRepositoryRelativePathLanguage(
+        string filePath,
+        string? projectRoot,
+        out string language)
+    {
+        language = string.Empty;
+        string relativePath;
+        if (string.IsNullOrWhiteSpace(projectRoot))
+        {
+            // The public compatibility helper has no repository-root context. Preserve useful
+            // exact-filename detection there, while the indexing path below remains location-aware.
+            // public compatibility helper には repository root context がないため filename を
+            // 認識する。indexing path は下記の projectRoot 分岐で location-aware のままにする。
+            if (string.Equals(Path.GetFileName(filePath), "CODEOWNERS", StringComparison.Ordinal))
+            {
+                language = "codeowners";
+                return true;
+            }
+            return false;
+        }
+
+        try
+        {
+            relativePath = Path.GetRelativePath(projectRoot, filePath);
+            if (Path.DirectorySeparatorChar == '\\')
+                relativePath = relativePath.Replace('\\', '/');
+        }
+        catch (Exception ex) when (ex is ArgumentException or NotSupportedException)
+        {
+            return false;
+        }
+
+        if (relativePath == ".." || relativePath.StartsWith("../", StringComparison.Ordinal))
+            return false;
+
+        foreach (var (path, pathLanguage) in RepositoryRelativePathMap)
+        {
+            // GitHub's reserved CODEOWNERS paths are case-sensitive even when the local
+            // filesystem is not. Do not classify a path that GitHub would ignore.
+            // GitHub の予約 CODEOWNERS path は local filesystem が case-insensitive でも
+            // case-sensitive のため、GitHub が無視する path を分類しない。
+            if (!string.Equals(relativePath, path, StringComparison.Ordinal))
+                continue;
+            language = pathLanguage;
+            return true;
+        }
+        return false;
+    }
+
     private static bool TryGetFileNamePrefixLanguage(string fileName, bool ignoreCase, out string language)
     {
         language = string.Empty;
diff --git a/src/CodeIndex/Indexer/Symbols/SymbolExtractor.CodeOwners.cs b/src/CodeIndex/Indexer/Symbols/SymbolExtractor.CodeOwners.cs
new file mode 100644
index 000000000..3556190bf
--- /dev/null
+++ b/src/CodeIndex/Indexer/Symbols/SymbolExtractor.CodeOwners.cs
@@ -0,0 +1,330 @@
+using CodeIndex.Models;
+
+namespace CodeIndex.Indexer;
+
+public static partial class SymbolExtractor
+{
+    internal const int CodeOwnersMaxRuleLineLength = 4096;
+    internal const int CodeOwnersMaxOwnersPerRule = 128;
+    internal const int CodeOwnersMaxOwnerLength = 256;
+
+    private readonly record struct CodeOwnersOwnerToken(string Value, int Column);
+
+    private static List<SymbolRecord> ExtractCodeOwnersSymbols(long fileId, string[] lines)
+    {
+        var symbols = CreateSymbolListForLines(lines.Length);
+        var reportedDiagnostics = new HashSet<string>(StringComparer.Ordinal);
+
+        for (var lineIndex = 0; lineIndex < lines.Length; lineIndex++)
+        {
+            var line = lines[lineIndex];
+            var lineNumber = lineIndex + 1;
+            if (line.Length > CodeOwnersMaxRuleLineLength)
+            {
+                AddCodeOwnersDiagnostic(
+                    symbols,
+                    reportedDiagnostics,
+                    fileId,
+                    "codeowners_rule_line_too_long",
+                    lineNumber,
+                    lines,
+                    "CODEOWNERS rule exceeded the bounded line length and was skipped.");
+                continue;
+            }
+
+            if (!TryParseCodeOwnersRule(
+                    line,
+                    out var pattern,
+                    out var patternColumn,
+                    out var owners,
+                    out var ownerBudgetExceeded,
+                    out var diagnosticCategory,
+                    out var diagnosticMessage))
+            {
+                if (diagnosticCategory != null)
+                {
+                    AddCodeOwnersDiagnostic(
+                        symbols,
+                        reportedDiagnostics,
+                        fileId,
+                        diagnosticCategory,
+                        lineNumber,
+                        lines,
+                        diagnosticMessage!);
+                }
+                continue;
+            }
+
+            if (!TryAddCodeOwnersSymbol(
+                    symbols,
+                    reportedDiagnostics,
+                    fileId,
+                    new SymbolRecord
+                    {
+                        FileId = fileId,
+                        Kind = "rule",
+                        SubKind = "ownership_rule",
+                        Name = pattern,
+                        Line = lineNumber,
+                        StartLine = lineNumber,
+                        StartColumn = patternColumn,
+                        EndLine = lineNumber,
+                        Signature = LimitStructuredDataLineSignature(line),
+                    },
+                    lineNumber,
+                    lines))
+            {
+                break;
+            }
+
+            foreach (var owner in owners)
+            {
+                if (!TryAddCodeOwnersSymbol(
+                        symbols,
+                        reportedDiagnostics,
+                        fileId,
+                        new SymbolRecord
+                        {
+                            FileId = fileId,
+                            Kind = "property",
+                            SubKind = "owner",
+                            Name = owner.Value,
+                            Line = lineNumber,
+                            StartLine = lineNumber,
+                            StartColumn = owner.Column,
+                            EndLine = lineNumber,
+                            Signature = owner.Value,
+                            ContainerKind = "rule",
+                            ContainerName = pattern,
+                            ContainerQualifiedName = pattern,
+                        },
+                        lineNumber,
+                        lines))
+                {
+                    return symbols;
+                }
+            }
+
+            if (ownerBudgetExceeded)
+            {
+                AddCodeOwnersDiagnostic(
+                    symbols,
+                    reportedDiagnostics,
+                    fileId,
+                    "codeowners_owner_budget_exceeded",
+                    lineNumber,
+                    lines,
+                    "CODEOWNERS rule exceeded the per-rule owner budget; owner symbols were truncated.");
+            }
+        }
+
+        return symbols;
+    }
+
+    private static bool TryParseCodeOwnersRule(
+        string line,
+        out string pattern,
+        out int patternColumn,
+        out List<CodeOwnersOwnerToken> owners,
+        out bool ownerBudgetExceeded,
+        out string? diagnosticCategory,
+        out string? diagnosticMessage)
+    {
+        pattern = string.Empty;
+        patternColumn = 0;
+        owners = [];
+        ownerBudgetExceeded = false;
+        diagnosticCategory = null;
+        diagnosticMessage = null;
+
+        var span = line.AsSpan();
+        var index = 0;
+        SkipCodeOwnersWhitespace(span, ref index);
+        if (index >= span.Length || span[index] == '#')
+            return false;
+
+        patternColumn = index;
+        var patternStart = index;
+        while (index < span.Length && !char.IsWhiteSpace(span[index]))
+            index++;
+        var rawPattern = span[patternStart..index];
+        if (rawPattern.Length > StructuredDataMaxPathLength)
+        {
+            diagnosticCategory = "codeowners_pattern_too_long";
+            diagnosticMessage = "CODEOWNERS pattern exceeded the structured path limit and was skipped.";
+            return false;
+        }
+
+        if (rawPattern.IsEmpty
+            || rawPattern.StartsWith(@"\#")
+            || rawPattern[0] == '!'
+            || rawPattern.IndexOf('[') >= 0
+            || rawPattern.IndexOf(']') >= 0
+            || ContainsCodeOwnersControlCharacter(rawPattern))
+        {
+            diagnosticCategory = "codeowners_unsupported_pattern";
+            diagnosticMessage = "CODEOWNERS rule used unsupported or malformed pattern syntax and was skipped.";
+            return false;
+        }
+        pattern = rawPattern.ToString();
+
+        while (index < span.Length)
+        {
+            SkipCodeOwnersWhitespace(span, ref index);
+            if (index >= span.Length)
+                break;
+            if (span[index] == '#')
+                break;
+
+            var ownerColumn = index;
+            while (index < span.Length && !char.IsWhiteSpace(span[index]))
+                index++;
+            var owner = span[ownerColumn..index];
+            if (owner.Length > CodeOwnersMaxOwnerLength || !IsCodeOwnersOwner(owner))
+            {
+                diagnosticCategory = "codeowners_invalid_owner";
+                diagnosticMessage = "CODEOWNERS rule contained an invalid or oversized owner and was skipped.";
+                owners.Clear();
+                pattern = string.Empty;
+                return false;
+            }
+
+            if (owners.Count >= CodeOwnersMaxOwnersPerRule)
+            {
+                ownerBudgetExceeded = true;
+                continue;
+            }
+            owners.Add(new CodeOwnersOwnerToken(owner.ToString(), ownerColumn));
+        }
+
+        return true;
+    }
+
+    private static void SkipCodeOwnersWhitespace(ReadOnlySpan<char> value, ref int index)
+    {
+        while (index < value.Length && char.IsWhiteSpace(value[index]))
+            index++;
+    }
+
+    private static bool IsCodeOwnersOwner(ReadOnlySpan<char> owner)
+    {
+        if (owner.Length < 2 || ContainsCodeOwnersControlCharacter(owner))
+            return false;
+        if (owner[0] == '@')
+            return IsCodeOwnersMention(owner[1..]);
+
+        var atIndex = owner.IndexOf('@');
+        return atIndex > 0
+            && atIndex == owner.LastIndexOf('@')
+            && atIndex < owner.Length - 1;
+    }
+
+    private static bool IsCodeOwnersMention(ReadOnlySpan<char> mention)
+    {
+        var slashIndex = mention.IndexOf('/');
+        if (slashIndex < 0)
+            return IsCodeOwnersMentionSegment(mention);
+
+        return slashIndex > 0
+            && slashIndex < mention.Length - 1
+            && mention[(slashIndex + 1)..].IndexOf('/') < 0
+            && IsCodeOwnersMentionSegment(mention[..slashIndex])
+            && IsCodeOwnersMentionSegment(mention[(slashIndex + 1)..]);
+    }
+
+    private static bool IsCodeOwnersMentionSegment(ReadOnlySpan<char> segment)
+    {
+        if (segment.IsEmpty
+            || !IsCodeOwnersMentionAlphaNumeric(segment[0])
+            || !IsCodeOwnersMentionAlphaNumeric(segment[^1]))
+        {
+            return false;
+        }
+
+        var previousWasHyphen = false;
+        foreach (var character in segment)
+        {
+            if (IsCodeOwnersMentionAlphaNumeric(character))
+            {
+                previousWasHyphen = false;
+                continue;
+            }
+            if (character != '-' || previousWasHyphen)
+                return false;
+            previousWasHyphen = true;
+        }
+        return true;
+    }
+
+    private static bool IsCodeOwnersMentionAlphaNumeric(char character)
+        => character is >= 'a' and <= 'z'
+            or >= 'A' and <= 'Z'
+            or >= '0' and <= '9';
+
+    private static bool ContainsCodeOwnersControlCharacter(ReadOnlySpan<char> value)
+    {
+        foreach (var character in value)
+        {
+            if (char.IsControl(character))
+                return true;
+        }
+        return false;
+    }
+
+    private static bool TryAddCodeOwnersSymbol(
+        List<SymbolRecord> symbols,
+        HashSet<string> reportedDiagnostics,
+        long fileId,
+        SymbolRecord symbol,
+        int line,
+        string[] lines)
+    {
+        if (symbols.Count < StructuredDataMaxSymbols)
+        {
+            symbols.Add(symbol);
+            return true;
+        }
+
+        AddCodeOwnersDiagnostic(
+            symbols,
+            reportedDiagnostics,
+            fileId,
+            "codeowners_symbol_budget_exceeded",
+            line,
+            lines,
+            "CODEOWNERS symbol extraction exceeded the per-file budget; remaining rules were truncated.");
+        return false;
+    }
+
+    private static void AddCodeOwnersDiagnostic(
+        List<SymbolRecord> symbols,
+        HashSet<string> reportedDiagnostics,
+        long fileId,
+        string category,
+        int line,
+        string[] lines,
+        string message)
+    {
+        if (!reportedDiagnostics.Add(category))
+            return;
+
+        var signatureIndex = Math.Clamp(line - 1, 0, Math.Max(0, lines.Length - 1));
+        var signature = lines.Length == 0 ? message : $"{message} {lines[signatureIndex].Trim()}";
+        var diagnostic = new SymbolRecord
+        {
+            FileId = fileId,
+            Kind = "annotation",
+            SubKind = "extraction_diagnostic",
+            Name = category,
+            Line = Math.Max(1, line),
+            StartLine = Math.Max(1, line),
+            EndLine = Math.Max(1, line),
+            Signature = LimitStructuredDataSignature(signature),
+        };
+
+        if (symbols.Count >= StructuredDataMaxSymbols)
+            symbols[^1] = diagnostic;
+        else
+            symbols.Add(diagnostic);
+    }
+}
diff --git a/src/CodeIndex/Indexer/Symbols/SymbolExtractor.Contracts.cs b/src/CodeIndex/Indexer/Symbols/SymbolExtractor.Contracts.cs
index 176116094..d0ca9f4cc 100644
--- a/src/CodeIndex/Indexer/Symbols/SymbolExtractor.Contracts.cs
+++ b/src/CodeIndex/Indexer/Symbols/SymbolExtractor.Contracts.cs
@@ -30,6 +30,7 @@ public static partial class SymbolExtractor
     public const int SystemsLanguageContractVersion = 2;
     public const int ScientificNativeGraphContractVersion = 4;
     public const int RepositoryMetadataContractVersion = 2;
+    public const int CodeOwnersContractVersion = 1;
     public const int ApplicationManifestContractVersion = 3;
     public const int MarkdownContractVersion = 4;
     public const int DependencyLockContractVersion = 3;
@@ -66,6 +67,7 @@ public static partial class SymbolExtractor
         "editorconfig",
         "dockerignore",
         "config",
+        "codeowners",
     ];
 
     public static int GetContractVersion(string? lang)
@@ -84,6 +86,7 @@ public static int GetContractVersion(string? lang)
             "prolog" or "ambiguous_pl" => PrologReferenceGraphContractVersion,
             "ada" or "ambiguous_m" or "cython" or "d" or "julia" or "matlab" or "nim" or "objc" => ScientificNativeGraphContractVersion,
             "config" or "dockerignore" or "editorconfig" or "gitattributes" or "gitignore" or "toml" => RepositoryMetadataContractVersion,
+            "codeowners" => CodeOwnersContractVersion,
             "app_manifest" => ApplicationManifestContractVersion,
             "markdown" => MarkdownContractVersion,
             "dependency_lock" => DependencyLockContractVersion,
diff --git a/src/CodeIndex/Indexer/Symbols/SymbolExtractor.ExtractionPhases.cs b/src/CodeIndex/Indexer/Symbols/SymbolExtractor.ExtractionPhases.cs
index 941b47d9a..4d600ac29 100644
--- a/src/CodeIndex/Indexer/Symbols/SymbolExtractor.ExtractionPhases.cs
+++ b/src/CodeIndex/Indexer/Symbols/SymbolExtractor.ExtractionPhases.cs
@@ -594,6 +594,9 @@ private static bool TryExtractSpecializedSymbols(
             case "config":
                 symbols = ExtractRepositoryMetadataSymbols(fileId, lang, SplitContentLines(content));
                 return true;
+            case "codeowners":
+                symbols = ExtractCodeOwnersSymbols(fileId, SplitContentLines(content));
+                return true;
             case "yaml":
                 symbols = ExtractYamlSymbols(fileId, SplitContentLines(content));
                 return true;
diff --git a/tests/CodeIndex.Tests/FileIndexerTests.cs b/tests/CodeIndex.Tests/FileIndexerTests.cs
index 22883c290..653d83885 100644
--- a/tests/CodeIndex.Tests/FileIndexerTests.cs
+++ b/tests/CodeIndex.Tests/FileIndexerTests.cs
@@ -757,6 +757,7 @@ public void ScanFilesDetailed_HardlinkedFiles_SkipsDuplicatePathWithWarning()
     [InlineData("script.zsh", "shell")]
     [InlineData("script.fish", "shell")]
     [InlineData("Dockerfile", "dockerfile")]
+    [InlineData("CODEOWNERS", "codeowners")]
     [InlineData(".dockerfile", "dockerfile")]
     [InlineData("api.Dockerfile", "dockerfile")]
     [InlineData("api.Containerfile", "dockerfile")]
@@ -3233,6 +3234,82 @@ public void ScanFiles_IndexesDependencyManifests()
         Assert.Equal(["Cargo.toml", "composer.json", "package.json", "pyproject.toml", "requirements.txt"], files);
     }
 
+    [Fact]
+    public void ScanFiles_CodeOwnersRecognizesOnlySupportedRepositoryLocations_Issue5198()
+    {
+        using var project = TestProjectHelper.CreateTempProjectScope("codeindex_codeowners_issue5198");
+        var projectRoot = project.Root;
+        Directory.CreateDirectory(Path.Combine(projectRoot, ".github"));
+        Directory.CreateDirectory(Path.Combine(projectRoot, "docs"));
+        Directory.CreateDirectory(Path.Combine(projectRoot, "nested"));
+        File.WriteAllText(Path.Combine(projectRoot, ".github", "CODEOWNERS"), "/src/ @primary\n");
+        File.WriteAllText(Path.Combine(projectRoot, "CODEOWNERS"), "* @root\n");
+        File.WriteAllText(Path.Combine(projectRoot, "docs", "CODEOWNERS"), "/docs/ @docs\n");
+        File.WriteAllText(Path.Combine(projectRoot, "nested", "CODEOWNERS"), "* @nested\n");
+
+        var scan = new FileIndexer(projectRoot, ignoreCase: false).ScanFilesDetailed();
+        var indexedCodeOwners = scan.FileLanguages
+            .Where(pair => pair.Value == "codeowners")
+            .Select(pair => Path.GetRelativePath(projectRoot, pair.Key).Replace('\\', '/'))
+            .OrderBy(path => path, StringComparer.Ordinal)
+            .ToList();
+
+        Assert.Equal([".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"], indexedCodeOwners);
+        Assert.DoesNotContain(
+            scan.Files,
+            path => string.Equals(
+                Path.GetRelativePath(projectRoot, path).Replace('\\', '/'),
+                "nested/CODEOWNERS",
+                StringComparison.Ordinal));
+        Assert.All(
+            scan.FileLanguages.Where(pair => pair.Value == "codeowners"),
+            pair => Assert.Equal(
+                "codeowners",
+                FileIndexer.GetReusableDetectedLanguage(pair.Key, scan.FileLanguages)));
+    }
+
+    [Fact]
+    public void ScanFiles_CodeOwnersReservedPathsRemainCaseSensitive_Issue5198Review()
+    {
+        using var project = TestProjectHelper.CreateTempProjectScope("codeindex_codeowners_case_issue5198");
+        var projectRoot = project.Root;
+        Directory.CreateDirectory(Path.Combine(projectRoot, ".github"));
+        Directory.CreateDirectory(Path.Combine(projectRoot, "Docs"));
+        File.WriteAllText(Path.Combine(projectRoot, ".github", "codeowners"), "* @lowercase\n");
+        File.WriteAllText(Path.Combine(projectRoot, "CodeOwners"), "* @mixed\n");
+        File.WriteAllText(Path.Combine(projectRoot, "Docs", "CODEOWNERS"), "* @wrong-directory-case\n");
+        if (!OperatingSystem.IsWindows())
+            File.WriteAllText(Path.Combine(projectRoot, @".github\CODEOWNERS"), "* @literal-backslash\n");
+
+        var scan = new FileIndexer(projectRoot, ignoreCase: true).ScanFilesDetailed();
+
+        Assert.DoesNotContain(scan.FileLanguages, pair => pair.Value == "codeowners");
+        Assert.Null(FileIndexer.DetectLanguage(Path.Combine(projectRoot, ".github", "codeowners")));
+    }
+
+    [Fact]
+    public void ScanFiles_CodeOwnersUsesEnclosingGitWorktreeRoot_Issue5198Review()
+    {
+        using var repository = TestProjectHelper.CreateTempProjectScope("codeindex_codeowners_git_root_issue5198");
+        var repositoryRoot = repository.Root;
+        var projectRoot = Path.Combine(repositoryRoot, "packages", "app");
+        Directory.CreateDirectory(projectRoot);
+        RunGit(repositoryRoot, "init");
+        File.WriteAllText(Path.Combine(projectRoot, "CODEOWNERS"), "* @nested\n");
+
+        var resolvedRepositoryRoot = GitHelper.TryGetRepositoryRoot(projectRoot);
+        Assert.Equal(
+            Path.TrimEndingDirectorySeparator(Path.GetFullPath(repositoryRoot)),
+            Path.TrimEndingDirectorySeparator(resolvedRepositoryRoot!));
+
+        var scan = new FileIndexer(
+            projectRoot,
+            ignoreCase: false,
+            ignoreRuleRoot: resolvedRepositoryRoot).ScanFilesDetailed();
+
+        Assert.DoesNotContain(scan.FileLanguages, pair => pair.Value == "codeowners");
+    }
+
     private static readonly (string Entry, string Language)[] ExactLanguageMapEntries =
     [
         ("Dockerfile", "dockerfile"),
@@ -3265,6 +3342,9 @@ private static readonly (string Entry, string Language)[] ExactLanguageMapEntrie
         (".runsettings", "xml"),
         (".rules", "config"),
         (".gitattributes", "gitattributes"),
+        (".github/CODEOWNERS", "codeowners"),
+        ("CODEOWNERS", "codeowners"),
+        ("docs/CODEOWNERS", "codeowners"),
         (".s", "assembly"),
         (".S", "assembly")
     ];
diff --git a/tests/CodeIndex.Tests/IndexCommandRunnerUpdateTests.cs b/tests/CodeIndex.Tests/IndexCommandRunnerUpdateTests.cs
index 1c5b5dd25..1526f316a 100644
--- a/tests/CodeIndex.Tests/IndexCommandRunnerUpdateTests.cs
+++ b/tests/CodeIndex.Tests/IndexCommandRunnerUpdateTests.cs
@@ -9856,6 +9856,55 @@ public void Run_UpdateMode_WithChangedBetween_RemovesDeletedPath_2987()
         }
     }
 
+    [Fact]
+    public void Run_UpdateMode_WithChangedBetween_ReconcilesCodeOwnersAcrossBranchSwitch_Issue5198()
+    {
+        var projectRoot = CreateTempProject();
+        try
+        {
+            RunGit(projectRoot, "init");
+            var githubDirectory = Path.Combine(projectRoot, ".github");
+            Directory.CreateDirectory(githubDirectory);
+            var primaryPath = Path.Combine(githubDirectory, "CODEOWNERS");
+            File.WriteAllText(primaryPath, "/src/** @main-owner\n");
+            RunGit(projectRoot, "add", ".");
+            RunGit(projectRoot, "commit", "-m", "initial codeowners");
+            RunGit(projectRoot, "branch", "before-codeowners-switch");
+
+            var initialExitCode = IndexCommandRunner.Run([projectRoot, "--json", "--quiet"], _jsonOptions);
+            Assert.Equal(CommandExitCodes.Success, initialExitCode);
+            var dbPath = Path.Combine(projectRoot, ".cdidx", "codeindex.db");
+            var initialChecksum = ReadIndexedChecksum(dbPath, ".github/CODEOWNERS");
+            Assert.NotNull(initialChecksum);
+
+            RunGit(projectRoot, "switch", "-c", "codeowners-feature");
+            File.WriteAllText(primaryPath, "/src/** @feature-owner\n");
+            File.WriteAllText(Path.Combine(projectRoot, "CODEOWNERS"), "* @root-owner\n");
+            RunGit(projectRoot, "add", ".");
+            RunGit(projectRoot, "commit", "-m", "change codeowners");
+            RunGit(projectRoot, "branch", "after-codeowners-switch");
+
+            var (featureExitCode, featureJson) = RunAndCaptureJson(
+                [projectRoot, "--changed-between", "before-codeowners-switch", "after-codeowners-switch", "--json"]);
+            Assert.Equal(CommandExitCodes.Success, featureExitCode);
+            Assert.Equal("success", featureJson.GetProperty("status").GetString());
+            Assert.NotEqual(initialChecksum, ReadIndexedChecksum(dbPath, ".github/CODEOWNERS"));
+            Assert.Contains("CODEOWNERS", ReadIndexedPaths(dbPath));
+
+            RunGit(projectRoot, "switch", "before-codeowners-switch");
+            var (returnExitCode, returnJson) = RunAndCaptureJson(
+                [projectRoot, "--changed-between", "after-codeowners-switch", "before-codeowners-switch", "--json"]);
+            Assert.Equal(CommandExitCodes.Success, returnExitCode);
+            Assert.Equal("success", returnJson.GetProperty("status").GetString());
+            Assert.Equal(initialChecksum, ReadIndexedChecksum(dbPath, ".github/CODEOWNERS"));
+            Assert.DoesNotContain("CODEOWNERS", ReadIndexedPaths(dbPath));
+        }
+        finally
+        {
+            DeleteDirectory(projectRoot);
+        }
+    }
+
     [Fact]
     public void Run_UpdateMode_WithChangedBetween_FallsBackToFullScanWhenIgnoreFilesChange()
     {
diff --git a/tests/CodeIndex.Tests/McpServerToolsCallTests.cs b/tests/CodeIndex.Tests/McpServerToolsCallTests.cs
index 6f4d24617..c7abde5f4 100644
--- a/tests/CodeIndex.Tests/McpServerToolsCallTests.cs
+++ b/tests/CodeIndex.Tests/McpServerToolsCallTests.cs
@@ -6697,6 +6697,16 @@ public void ToolsCall_Languages_ReturnsCapabilities()
             Assert.True(entry["graph_queries"]!.GetValue<bool>());
             Assert.Empty(entry["capability_gaps"]!.AsArray());
         }
+
+        var codeOwners = languages.Single(language => language!["lang"]!.GetValue<string>() == "codeowners")!;
+        Assert.True(codeOwners["symbol_extraction"]!.GetValue<bool>());
+        Assert.True(codeOwners["outline"]!.GetValue<bool>());
+        Assert.False(codeOwners["reference_extraction"]!.GetValue<bool>());
+        Assert.False(codeOwners["graph_queries"]!.GetValue<bool>());
+        Assert.Contains("missing-references", codeOwners["capability_gaps"]!.AsArray().Select(value => value!.GetValue<string>()));
+        Assert.Contains("missing-graph", codeOwners["capability_gaps"]!.AsArray().Select(value => value!.GetValue<string>()));
+        var codeOwnersPaths = codeOwners["exact_filenames"]!.AsArray().Select(value => value!.GetValue<string>()).ToList();
+        Assert.Equal([".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"], codeOwnersPaths);
     }
 
     [Fact]
diff --git a/tests/CodeIndex.Tests/QueryCommandRunnerFilesTests.cs b/tests/CodeIndex.Tests/QueryCommandRunnerFilesTests.cs
index a44e0309c..f40c2d31f 100644
--- a/tests/CodeIndex.Tests/QueryCommandRunnerFilesTests.cs
+++ b/tests/CodeIndex.Tests/QueryCommandRunnerFilesTests.cs
@@ -407,6 +407,130 @@ public void RunFilesAndSearch_IndexRepositoryConfigurationFiles_Issue3898()
         }
     }
 
+    [Fact]
+    public void RunCodeOwners_FullAndIncrementalIndexingSupportsDiscoverySearchSymbolsOutlineAndStatus_Issue5198()
+    {
+        var projectRoot = TestProjectHelper.CreateTempProject("cdidx_codeowners_issue5198");
+        try
+        {
+            var dbPath = TestProjectHelper.CreateProjectDb(projectRoot);
+            Directory.CreateDirectory(Path.Combine(projectRoot, ".github"));
+            Directory.CreateDirectory(Path.Combine(projectRoot, "docs"));
+            File.WriteAllText(
+                Path.Combine(projectRoot, ".github", "CODEOWNERS"),
+                "# highest-precedence candidate\r\n/src/** @org/team owner@example.com # inline comment\r\n/src/special/**\r\n/src/** @later\r\n\\#literal @escaped\r\n");
+            File.WriteAllText(Path.Combine(projectRoot, "CODEOWNERS"), "* @root\n");
+            File.WriteAllText(Path.Combine(projectRoot, "docs", "CODEOWNERS"), "/docs/** @docs\n");
+
+            var (indexExitCode, _, indexStderr) = CaptureConsole(() => IndexCommandRunner.Run(
+                [projectRoot, "--db", dbPath, "--json", "--quiet"],
+                _jsonOptions));
+            Assert.Equal(CommandExitCodes.Success, indexExitCode);
+            Assert.Equal(string.Empty, indexStderr);
+
+            var (filesExitCode, filesStdout, filesStderr) = CaptureConsole(() => QueryCommandRunner.RunFiles(
+                ["--db", dbPath, "--lang", "codeowners", "--json=array"],
+                _jsonOptions));
+            using var filesDocument = ParseJsonOutput(filesStdout);
+            Assert.Equal(CommandExitCodes.Success, filesExitCode);
+            Assert.Equal(string.Empty, filesStderr);
+            Assert.Equal(
+                [".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"],
+                filesDocument.RootElement.EnumerateArray()
+                    .Select(file => file.GetProperty("path").GetString())
+                    .OrderBy(path => path, StringComparer.Ordinal));
+
+            AssertSearchesPath(dbPath, "@org/team", ".github/CODEOWNERS");
+            AssertSearchesPath(dbPath, "owner@example.com", ".github/CODEOWNERS");
+
+            var (symbolsExitCode, symbolsStdout, symbolsStderr) = CaptureConsole(() => QueryCommandRunner.RunSymbols(
+                ["--db", dbPath, "--lang", "codeowners", "--path", ".github/CODEOWNERS", "--json=array"],
+                _jsonOptions));
+            using var symbolsDocument = ParseJsonOutput(symbolsStdout);
+            var symbols = symbolsDocument.RootElement.EnumerateArray().ToList();
+            Assert.Equal(CommandExitCodes.Success, symbolsExitCode);
+            Assert.Equal(string.Empty, symbolsStderr);
+            Assert.Equal(3, symbols.Count(symbol => symbol.GetProperty("kind").GetString() == "rule"));
+            Assert.Contains(
+                symbols,
+                symbol => symbol.GetProperty("kind").GetString() == "property"
+                    && symbol.GetProperty("name").GetString() == "@org/team"
+                    && symbol.GetProperty("container_name").GetString() == "/src/**");
+            Assert.Contains(
+                symbols,
+                symbol => symbol.GetProperty("kind").GetString() == "annotation"
+                    && symbol.GetProperty("name").GetString() == "codeowners_unsupported_pattern");
+
+            var (outlineExitCode, outlineStdout, outlineStderr) = CaptureConsole(() => QueryCommandRunner.RunOutline(
+                [".github/CODEOWNERS", "--db", dbPath, "--json"],
+                _jsonOptions));
+            Assert.Equal(CommandExitCodes.Success, outlineExitCode);
+            Assert.Equal(string.Empty, outlineStderr);
+            Assert.Contains("/src/**", outlineStdout, StringComparison.Ordinal);
+            Assert.Contains("@org/team", outlineStdout, StringComparison.Ordinal);
+
+            var (statusExitCode, statusStdout, statusStderr) = CaptureConsole(() => QueryCommandRunner.RunStatus(
+                ["--db", dbPath, "--json"],
+                _jsonOptions));
+            using var statusDocument = ParseJsonOutput(statusStdout);
+            Assert.Equal(CommandExitCodes.Success, statusExitCode);
+            Assert.Equal(string.Empty, statusStderr);
+            Assert.Equal(0, statusDocument.RootElement.GetProperty("unknown_extension_file_count").GetInt64());
+
+            File.WriteAllText(Path.Combine(projectRoot, "CODEOWNERS"), "* @updated-root\n");
+            var (updateExitCode, _, updateStderr) = CaptureConsole(() => IndexCommandRunner.Run(
+                [projectRoot, "--db", dbPath, "--files", "CODEOWNERS", "--json", "--quiet"],
+                _jsonOptions));
+            Assert.Equal(CommandExitCodes.Success, updateExitCode);
+            Assert.Equal(string.Empty, updateStderr);
+            AssertSearchesPath(dbPath, "@updated-root", "CODEOWNERS");
+
+            File.Delete(Path.Combine(projectRoot, "docs", "CODEOWNERS"));
+            var (deleteExitCode, _, deleteStderr) = CaptureConsole(() => IndexCommandRunner.Run(
+                [projectRoot, "--db", dbPath, "--files", "docs/CODEOWNERS", "--json", "--quiet"],
+                _jsonOptions));
+            Assert.Equal(CommandExitCodes.Success, deleteExitCode);
+            Assert.Equal(string.Empty, deleteStderr);
+
+            var (deletedFilesExitCode, deletedFilesStdout, deletedFilesStderr) = CaptureConsole(() => QueryCommandRunner.RunFiles(
+                ["--db", dbPath, "--path", "docs/CODEOWNERS", "--json=array"],
+                _jsonOptions));
+            using var deletedFilesDocument = ParseJsonOutput(deletedFilesStdout);
+            Assert.Equal(CommandExitCodes.Success, deletedFilesExitCode);
+            Assert.Equal(string.Empty, deletedFilesStderr);
+            Assert.Empty(deletedFilesDocument.RootElement.EnumerateArray());
+        }
+        finally
+        {
+            TestProjectHelper.DeleteDirectory(projectRoot);
+        }
+    }
+
+    [Fact]
+    public void RunCodeOwners_GitSubdirectoryScanDoesNotPromoteNestedCandidate_Issue5198Review()
+    {
+        using var repository = TestProjectHelper.CreateTempProjectScope("cdidx_codeowners_git_subdirectory_issue5198");
+        TestProjectHelper.InitializeGitRepo(repository.Root);
+        var projectRoot = Path.Combine(repository.Root, "packages", "app");
+        Directory.CreateDirectory(projectRoot);
+        File.WriteAllText(Path.Combine(projectRoot, "CODEOWNERS"), "* @nested\n");
+        var dbPath = TestProjectHelper.CreateProjectDb(projectRoot);
+
+        var (indexExitCode, _, indexStderr) = CaptureConsole(() => IndexCommandRunner.Run(
+            [projectRoot, "--db", dbPath, "--json", "--quiet"],
+            _jsonOptions));
+        Assert.Equal(CommandExitCodes.Success, indexExitCode);
+        Assert.Equal(string.Empty, indexStderr);
+
+        var (filesExitCode, filesStdout, filesStderr) = CaptureConsole(() => QueryCommandRunner.RunFiles(
+            ["--db", dbPath, "--lang", "codeowners", "--json=array"],
+            _jsonOptions));
+        using var filesDocument = ParseJsonOutput(filesStdout);
+        Assert.Equal(CommandExitCodes.Success, filesExitCode);
+        Assert.Equal(string.Empty, filesStderr);
+        Assert.Empty(filesDocument.RootElement.EnumerateArray());
+    }
+
     [Fact]
     public void IndexAndDryRun_ZshCompletionCompdefIsShellAndQueryable_Issue5165()
     {
diff --git a/tests/CodeIndex.Tests/QueryCommandRunnerTests.cs b/tests/CodeIndex.Tests/QueryCommandRunnerTests.cs
index 1e1ed8141..7b6aa22d1 100644
--- a/tests/CodeIndex.Tests/QueryCommandRunnerTests.cs
+++ b/tests/CodeIndex.Tests/QueryCommandRunnerTests.cs
@@ -5459,6 +5459,22 @@ public void RunLanguages_JsonCatalogReportsExtensionsAliasesAndExtractionCapabil
             Assert.Empty(languages[repositoryMetadata].GetProperty("capability_gaps").EnumerateArray());
         }
 
+        Assert.True(languages.ContainsKey("codeowners"), "expected 'codeowners' to be listed");
+        var codeOwners = languages["codeowners"];
+        Assert.True(codeOwners.GetProperty("symbol_extraction").GetBoolean());
+        Assert.True(codeOwners.GetProperty("outline").GetBoolean());
+        Assert.False(codeOwners.GetProperty("reference_extraction").GetBoolean());
+        Assert.False(codeOwners.GetProperty("graph_queries").GetBoolean());
+        Assert.Contains(
+            "missing-references",
+            codeOwners.GetProperty("capability_gaps").EnumerateArray().Select(value => value.GetString()));
+        Assert.Contains(
+            "missing-graph",
+            codeOwners.GetProperty("capability_gaps").EnumerateArray().Select(value => value.GetString()));
+        var codeOwnersPaths = codeOwners.GetProperty("exact_filenames").EnumerateArray()
+            .Select(value => value.GetString()).ToList();
+        Assert.Equal([".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"], codeOwnersPaths);
+
         // Cython owns .pyx / .pxd exclusively; python keeps .py / .pyi / .pyw and Bazel filenames.
         // Cython は .pyx / .pxd を専有し、python は .py / .pyi / .pyw と Bazel ファイル名を維持。
         var cythonExts = languages["cython"].GetProperty("extensions").EnumerateArray()
diff --git a/tests/CodeIndex.Tests/SymbolExtractorRepositoryMetadataTests.cs b/tests/CodeIndex.Tests/SymbolExtractorRepositoryMetadataTests.cs
index 904942ce7..3f01c5f3d 100644
--- a/tests/CodeIndex.Tests/SymbolExtractorRepositoryMetadataTests.cs
+++ b/tests/CodeIndex.Tests/SymbolExtractorRepositoryMetadataTests.cs
@@ -97,6 +97,76 @@ public void SupportedLanguages_RepositoryMetadataIncludesJsonLines_Issue4740()
         Assert.Equal(
             SymbolExtractor.ApplicationManifestContractVersion,
             SymbolExtractor.GetContractVersion("app_manifest"));
+        Assert.Contains("codeowners", supported);
+        Assert.Equal(
+            SymbolExtractor.CodeOwnersContractVersion,
+            SymbolExtractor.GetContractVersion("codeowners"));
+    }
+
+    [Fact]
+    public void Extract_CodeOwners_PreservesOrderedRulesOwnersAndBoundedDiagnostics_Issue5198()
+    {
+        var content = string.Join(
+            "\r\n",
+            "  # comment",
+            string.Empty,
+            "   ",
+            "\t/src/**\t@org/team @user\towner@example.com # inline comment",
+            "/src/special/**",
+            @"\#literal @escaped",
+            "/src/** @later",
+            "!unsupported @owner",
+            "[ab].txt @owner",
+            "bad-owner @",
+            "invalid-double-at @@",
+            "invalid-empty-team @org/",
+            "invalid-nested-team @org/team/extra") + "\r\n";
+
+        var symbols = SymbolExtractor.Extract(1, "codeowners", content);
+        var rules = symbols.Where(symbol => symbol.Kind == "rule").ToList();
+
+        Assert.Equal(["/src/**", "/src/special/**", "/src/**"], rules.Select(rule => rule.Name));
+        Assert.Equal([4, 5, 7], rules.Select(rule => rule.Line));
+        Assert.All(rules, rule => Assert.Equal("ownership_rule", rule.SubKind));
+        Assert.Contains(rules, rule => rule.Name == "/src/special/**" && rule.Signature == "/src/special/**");
+
+        var owners = symbols.Where(symbol => symbol.Kind == "property").ToList();
+        Assert.Equal(
+            ["@org/team", "@user", "owner@example.com", "@later"],
+            owners.Select(owner => owner.Name));
+        Assert.All(owners, owner => Assert.Equal("owner", owner.SubKind));
+        Assert.Contains(owners, owner => owner.Name == "@org/team" && owner.ContainerName == "/src/**");
+
+        var diagnostics = symbols
+            .Where(symbol => symbol.Kind == "annotation" && symbol.SubKind == "extraction_diagnostic")
+            .ToList();
+        Assert.Equal(2, diagnostics.Count);
+        Assert.Contains(diagnostics, diagnostic => diagnostic.Name == "codeowners_unsupported_pattern");
+        Assert.Contains(diagnostics, diagnostic => diagnostic.Name == "codeowners_invalid_owner");
+    }
+
+    [Fact]
+    public void Extract_CodeOwners_BoundsOwnerAndLinePayloads_Issue5198()
+    {
+        var owners = string.Join(' ', Enumerable.Range(0, SymbolExtractor.CodeOwnersMaxOwnersPerRule + 1).Select(index => $"@owner{index}"));
+        var oversizedLine = new string('x', SymbolExtractor.CodeOwnersMaxRuleLineLength + 1);
+        var symbols = SymbolExtractor.Extract(1, "codeowners", $"/bounded/** {owners}\n{oversizedLine}\n");
+
+        Assert.Single(symbols, symbol => symbol.Kind == "rule" && symbol.Name == "/bounded/**");
+        Assert.Equal(
+            SymbolExtractor.CodeOwnersMaxOwnersPerRule,
+            symbols.Count(symbol => symbol.Kind == "property" && symbol.ContainerName == "/bounded/**"));
+        Assert.Contains(
+            symbols,
+            symbol => symbol.Kind == "annotation"
+                && symbol.SubKind == "extraction_diagnostic"
+                && symbol.Name == "codeowners_owner_budget_exceeded");
+        Assert.Contains(
+            symbols,
+            symbol => symbol.Kind == "annotation"
+                && symbol.SubKind == "extraction_diagnostic"
+                && symbol.Name == "codeowners_rule_line_too_long");
+        Assert.True(symbols.Count(symbol => symbol.SubKind == "extraction_diagnostic") <= 2);
     }
 
     [Fact]