bmad-module-skill-forge 2.2.0 → 4.0.0

package/src/shared/scripts/skf-disqualify-candidates.py

@@ -1,117 +1,216 @@
 # /// script
-# requires-python = ">=3.10"
+# requires-python = ">=3.11"
 # dependencies = []
 # ///
-"""SKF Disqualify Candidates — deterministic filter for skillable-unit boundaries.
-
-`identify-units.md` step 2 §D asks the LLM to evaluate each detected boundary
-against a fixed disqualification list (too-few-files, too-low-loc,
-generated-code, auto-generated-tag, etc.). The boundary checks are fully
-deterministic — file counts, line counts, path-substring matches against a
-known generated-code roster, header sentinel scans — and prior runs have
-shown LLMs miscount files, miss generated-code paths inside nested
-`node_modules/`, and forget to scan for `@generated`. This script collapses
-that work into one call.
-
-Canonical disqualification rules (kept in sync with
+"""SKF Disqualify Candidates: size, generated-code and signal evidence per boundary.
+
+`identify-units.md` section 2 hands this helper every detected boundary, and
+the helper lists each boundary's files itself. What it checks has one right
+answer per file list (file and
+line counts, generated or vendored directory segments, generated-code header
+sentinels, which signal files exist, what the boundary's own manifest names),
+and prior runs showed models miscount files, miss generated paths inside
+nested `node_modules/` and forget to scan for `@generated`, so one call does
+it all. What the evidence means for a boundary with only some generated files
+is the model's call.
+
+Which files count:
+
+  - A lockfile (`Cargo.lock`, `package-lock.json`, `yarn.lock`, `go.sum` and
+    the rest of LOCKFILE_NAMES and LOCKFILE_SUFFIXES) and a non-source file
+    (documentation, data and configuration, media, archives and binaries:
+    NON_SOURCE_EXTENSIONS, NON_SOURCE_NAMES, every dotfile; build and tool
+    configuration: every manifest skf-scan-manifests.py scans, setup.py,
+    build.gradle and Package.swift included, the Gradle and Maven wrappers,
+    Bazel files and `<tool>.config.<ext>` files such as vite.config.ts) is
+    never a source file. It is never scanned for a header sentinel and
+    never counted. Every other file is a source file, so a language these
+    tables do not know still counts.
+  - A source file is generated when its path below the boundary path holds
+    a vendored or cache folder at any depth (node_modules/, vendor/,
+    __pycache__/, .next/, .gradle/), or a build output folder (dist/,
+    build/, target/) that is the first folder below the boundary or sits in
+    a folder holding a manifest of the file list (a member package's own
+    dist/); or else when one of its first 10 lines holds a generated-code
+    sentinel (`@generated`, `// GENERATED CODE`, `# AUTOGENERATED`,
+    `<!-- generated -->`, matched case-insensitively). So a package that
+    itself lives in a folder named build/ is not generated, and neither is
+    a source folder of that name further down (src/build/, the Java package
+    folder com/acme/build/).
+
+Rules, first match wins (kept in sync with
 `src/skf-analyze-source/references/unit-detection-heuristics.md`):
 
-  - too-few-files     : files_count < {MIN_FILES} (default 3)
-  - too-low-loc       : loc_total < {MIN_LOC} (default 100)
-  - generated-code    : any file path contains a known generated/vendor
-                         directory segment (node_modules/, vendor/, dist/,
-                         build/, __pycache__/, .next/, target/, .gradle/)
-  - auto-generated-tag: any file's first 10 lines contain a known
-                         "auto-generated" sentinel string (`@generated`,
-                         `// GENERATED CODE`, `# AUTOGENERATED`,
-                         `<!-- generated -->`); case-insensitive matching
-                         on the full sentinel phrases.
-
-Rules NOT enforced by this script (still LLM-judged in step 2 §D):
-  - pure-configuration
-  - test-only
-  - already-skilled (requires existing_skills cross-reference)
-
-LoC counting: per file, count lines with NON-empty content. A "blank line"
-is one whose stripped form is empty (whitespace-only lines count as blank).
-This matches the spec phrasing "lines with content (strip empty lines)".
-
-The check order matters because heuristics are reported as a single
-`reason`; the first match wins. Order is:
-  1. generated-code      (path-based, cheapest, often the dominant signal)
-  2. auto-generated-tag  (header scan)
-  3. too-few-files       (file count after the above)
-  4. too-low-loc         (loc after the above)
+  1. generated-code / auto-generated-tag: every source file of the boundary
+     is generated (and it has at least one). generated-code when a
+     directory segment marked any of them, auto-generated-tag when only
+     header sentinels did.
+  2. too-few-files: files_count < --min-files (default 3)
+  3. too-low-loc:   loc_total < --min-loc (default 100)
+
+`files_count` and `loc_total` count the source files that are not
+generated; a line counts when its stripped form is not empty. A boundary
+with some generated files is kept when it passes rules 2 and 3, and its
+`generated_files` and `generated_ratio` are evidence the model weighs.
+`passes_with_generated` says whether rules 2 and 3 pass with the generated
+files counted too, so a boundary whose flagged files the model judges to be
+its own code can be restored without counting them by hand.
+
+Rules NOT enforced by this script (judged in identify-units section 2):
+pure-configuration, test-only, already-skilled.
+
+Manifest. Every record carries `manifest`, the boundary's own manifest: of
+the manifests at the boundary root (the file names skf-scan-manifests.py
+scans, its MANIFEST_ECOSYSTEMS), the first in path order that names a
+package, else the first; null when there is none. It is
+`{"path", "ecosystem", "name", "private"}`, `name` and `private` as that
+script's identity readers report them, which skf-skill-inventory.py
+derive-name takes to name the unit.
+
+Signals. Every record carries `signals`, the detection signals of
+unit-detection-heuristics.md that the file list shows, each the first file
+that shows it (shallowest, then in path order) or null:
+
+  own_manifest        the `manifest` path
+  entry_point         an entry file (ENTRY_POINT_NAMES: index.ts, main.go,
+                      lib.rs, __init__.py, ...) at most two folders below
+                      the boundary root
+  service_definition  a Dockerfile, Containerfile, compose file or
+                      serverless.yml, at any depth (skf-scan-manifests.py's
+                      is_service_definition, whose `services[]` lists them)
+  readme              a README at the boundary root
+  test_suite          a file in a test folder (test/, tests/, __tests__/,
+                      spec/, specs/), a test file (*.test.*, *.spec.*,
+                      *_test.*, test_*.py, *_spec.rb) or a test runner
+                      configuration
+  ci_reference        a CI configuration under --source-root (CI_FILE_GLOBS)
+                      that names the boundary path; null for a boundary at
+                      the root
+
+and `large_directory`: true when the file list holds 50 or more files.
+
+Boundary paths. Each `path` is normalized once, so `./packages/auth`,
+`packages/auth/` and `packages/./auth` all read as `packages/auth` (and
+`""` or `./` as `.`, the root); the record carries the normalized path. An
+absolute path, or one that leaves the source root (`..`), is an error.
+
+Listing. A boundary without `files` gets the files under
+<source-root>/<path>: those git lists when the source root is in a git
+work tree (tracked, and untracked but not ignored, so .gitignore holds and
+an installed node_modules/ or a build's target/ stays out), else every file
+of a walk that skips node_modules/ and __pycache__/. The walk also runs
+when git lists no file there (a folder the outer work tree ignores, such
+as an extracted tarball under an ignored vendor/). Hidden entries and
+symbolic links are left out either way. Paths are relative to the source
+root, forward-slash, sorted, each once. A boundary path that is no folder
+under the source root is an error. With --tree-dir, each boundary's file
+list (its listing, or the `files` it was given) is written there, one path
+per line, as `boundary-<n>.txt` (n its 1-based place in the input), and
+its record carries `tree_file`: the listing skf-detect-language.py
+--tree-file reads for that unit, so no file list passes through the
+caller. A file name that is not UTF-8 is written with `?` for each byte
+that is not, so the listing stays one UTF-8 file.
 
 Subcommand:
   filter --boundaries <json-file-or--for-stdin> [--source-root <path>]
-                     [--min-files N] [--min-loc N]
+                     [--tree-dir <folder>] [--min-files N] [--min-loc N]
 
       Read a boundaries JSON of the shape:
         [
           {"name": "<unit-name>",
            "path": "<rel-from-source-root>",
-           "files": ["<rel-path>", ...]},
+           "files": ["<rel-path>", ...]},   // optional: listed when absent
           ...
         ]
       and emit:
         {
-          "kept":    [{"name": "...", "path": "...",
-                       "files_count": N, "loc_total": L}, ...],
-          "dropped": [{"name": "...",
-                       "reason": "<too-few-files|too-low-loc|generated-code|"
-                                 "auto-generated-tag>",
-                       "context": {"files_count": N, "loc_total": L,
-                                   "first_match": "..."}}, ...],
-          "stats":   {"kept": N, "dropped": N,
-                       "by_reason": {"<reason>": N, ...}}
+          "kept":    [<record>, ...],
+          "dropped": [<record> + {"reason": "<too-few-files|too-low-loc|"
+                                             "generated-code|"
+                                             "auto-generated-tag>",
+                                  "context": {...}}, ...],
+          "stats":   {"kept": N, "dropped": N, "mixed": N,
+                      "by_reason": {"<reason>": N, ...}}
         }
+      where every <record> is
+        {"name": "...", "path": "...",
+         "files_count": N, "loc_total": L, "non_source_count": K,
+         "generated_files": [{"path": "...",
+                              "reason": "generated-code|auto-generated-tag",
+                              "match": "<segment or sentinel>"}, ...],
+         "generated_ratio": R, "passes_with_generated": B,
+         "manifest": {"path", "ecosystem", "name", "private"} | null,
+         "signals": {"own_manifest": "<path>|null", ..., "large_directory": B},
+         "tree_file": "<path>"}            // with --tree-dir only
+      `generated_files` is sorted by path. `generated_ratio` is the share of
+      the source files that are generated (0.0 with no source file), to
+      three decimals. `context` holds the rule's own evidence: `threshold`
+      for too-few-files and too-low-loc, `first_match` and
+      `matched_segment` or `matched_sentinel` for the generated rules.
+      `stats.mixed` counts the kept boundaries with generated files: the
+      mixed cases the model judges.
 
   --source-root defaults to the current working directory. File paths in
-  the `files[]` array are resolved against `<source-root>/<boundary-path>`
-  first (to match `path` from the earlier scan-project step), and falling
-  back to `<source-root>/<file-rel>` if that doesn't exist. Missing files
-  are treated as 0-line zero-byte files; the boundary is still subject to
-  count/loc thresholds.
+  the `files[]` array are resolved against `<source-root>/<file-rel>` first
+  and, when that does not exist, against
+  `<source-root>/<boundary-path>/<file-rel>`. A file listed twice counts
+  once. Missing files read as empty files; the boundary is still subject
+  to the count and LoC thresholds.
 
 CLI examples:
   uv run skf-disqualify-candidates.py filter --boundaries boundaries.json
   cat boundaries.json | uv run skf-disqualify-candidates.py filter \\
-      --boundaries - --source-root /path/to/project
+      --boundaries - --source-root /path/to/project --tree-dir /tmp/trees
 
 Exit codes:
-  0  — operation succeeded (including: empty input → empty kept/dropped)
-  1  — user error (bad JSON, missing required keys, malformed entry)
+  0  operation succeeded (including: empty input, which gives empty kept
+     and dropped lists)
+  1  user error (bad JSON, missing required keys, malformed entry, a
+     boundary path that is absolute or leaves the source root, a boundary
+     path to list that is no folder, a --tree-dir that cannot be
+     written), or no skf-scan-manifests.py beside this script that loads
+     (it needs Python 3.11 for tomllib, hence this script's floor)
 """
 
 from __future__ import annotations
 
 import argparse
+import importlib.util
 import json
+import os
+import posixpath
+import re
 import sys
 from pathlib import Path
 
 
 # --------------------------------------------------------------------------
-# Constants — disqualification rules (single source of truth)
+# Constants: disqualification rules (single source of truth)
 # --------------------------------------------------------------------------
 
 
 MIN_FILES = 3
 MIN_LOC = 100
 
-# Path segments that mark generated / vendored / build-output trees.
-# Trailing slash is significant — we match the segment as a directory.
-GENERATED_PATH_SEGMENTS = (
+# Path segments that mark vendored code and tool caches, generated at any
+# depth below the boundary. Trailing slash is significant: we match the
+# segment as a directory.
+VENDORED_PATH_SEGMENTS = (
     "node_modules/",
     "vendor/",
-    "dist/",
-    "build/",
     "__pycache__/",
     ".next/",
-    "target/",
     ".gradle/",
 )
+# Build output folders: generated only as the first folder below the
+# boundary or inside a folder that holds a manifest, since a source folder
+# can carry the same name (src/build/, the Java package com/acme/build/).
+OUTPUT_PATH_SEGMENTS = (
+    "dist/",
+    "build/",
+    "target/",
+)
+GENERATED_PATH_SEGMENTS = VENDORED_PATH_SEGMENTS + OUTPUT_PATH_SEGMENTS
 
 # Header-sentinel scan: case-insensitive substring match on each of the
 # first AUTO_GEN_HEADER_LINES of a file. The strings are spec-canonical;
@@ -125,8 +224,127 @@ AUTO_GEN_SENTINELS = (
 
 AUTO_GEN_HEADER_LINES = 10
 
+# Lockfiles: never source, never scanned (a committed Cargo.lock opens with
+# "@generated"). Compared on the lowercased file name.
+LOCKFILE_NAMES = frozenset({
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "pnpm-lock.yaml",
+    "go.sum",
+    "go.work.sum",
+    "package.resolved",
+    "packages.lock.json",
+})
+# Cargo.lock, yarn.lock, poetry.lock, Pipfile.lock, uv.lock, composer.lock,
+# Gemfile.lock, mix.lock, pubspec.lock, flake.lock, bun.lockb, gradle.lockfile
+LOCKFILE_SUFFIXES = (".lock", ".lockb", ".lockfile")
+
+# Non-source files: documentation, data and configuration, media, archives
+# and binaries. Compared on the lowercased extension.
+NON_SOURCE_EXTENSIONS = frozenset({
+    # documentation and text
+    ".md", ".mdx", ".markdown", ".rst", ".txt", ".adoc", ".rtf",
+    # data and configuration
+    ".json", ".jsonc", ".json5", ".yaml", ".yml", ".toml", ".ini", ".cfg",
+    ".conf", ".properties", ".env", ".csv", ".tsv", ".xml", ".plist",
+    # media and fonts
+    ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp", ".bmp",
+    ".tif", ".tiff", ".avif", ".mp3", ".mp4", ".wav", ".ogg", ".webm",
+    ".mov", ".woff", ".woff2", ".ttf", ".otf", ".eot",
+    # documents, archives and binaries
+    ".pdf", ".zip", ".tar", ".gz", ".tgz", ".bz2", ".xz", ".7z", ".jar",
+    ".war", ".class", ".so", ".dll", ".dylib", ".a", ".o", ".obj", ".lib",
+    ".exe", ".bin", ".pyc", ".pyo", ".wasm", ".node",
+    # by-products
+    ".map", ".snap", ".log",
+})
+# Non-source files named without a source extension, lowercased. Every
+# manifest skf-scan-manifests.py scans is non-source too.
+NON_SOURCE_NAMES = frozenset({
+    "license", "licence", "copying", "notice", "authors", "contributors",
+    "changelog", "changes", "history", "readme", "codeowners", "owners",
+    "makefile", "gnumakefile", "dockerfile", "containerfile", "procfile",
+    "gemfile", "pipfile", "podfile", "brewfile", "vagrantfile",
+    "jenkinsfile", "go.mod", "go.work",
+    # build tools: Gradle and Maven wrappers and settings, Bazel files
+    "settings.gradle", "settings.gradle.kts", "gradlew", "gradlew.bat",
+    "mvnw", "mvnw.cmd", "build", "build.bazel", "workspace",
+    "workspace.bazel", "module.bazel",
+})
+# LICENSE-MIT, LICENSE-APACHE, Dockerfile.dev
+NON_SOURCE_PREFIXES = ("license-", "licence-", "dockerfile.")
+# Tool configuration named <tool>.config.<ext>: vite.config.ts,
+# jest.config.js, babel.config.cjs, webpack.config.mjs
+NON_SOURCE_INFIXES = (".config.",)
+
+# The manifest scanner beside this script: own_manifest counts the file
+# names it scans and `manifest` reads them with its identity readers, so
+# the two never disagree on what a manifest is or what it names.
+SCAN_MANIFESTS = Path(__file__).resolve().parent / "skf-scan-manifests.py"
+_SCAN_MODULE = None
+_MANIFEST_FILENAMES: frozenset[str] = frozenset()
+_MANIFEST_FILENAMES_LC: frozenset[str] = frozenset()
+
+# The git runner beside this script (no hooks, no git location variables,
+# never a git shim in the current folder), which lists a boundary's files.
+SOURCE_TREE = Path(__file__).resolve().parent / "skf-source-tree.py"
+_SOURCE_TREE_MODULE = None
+
+# Folders a walk outside a git work tree skips: installed dependencies and
+# caches, never a boundary's own code, and often thousands of files.
+WALK_SKIPPED_FOLDERS = frozenset({"node_modules", "__pycache__"})
+
+# Entry files, lowercased; one counts at most ENTRY_POINT_MAX_DEPTH folders
+# below the boundary root (src/index.ts, src/pkg/__init__.py, cmd/x/main.go).
+ENTRY_POINT_NAMES = frozenset({
+    "index.js", "index.jsx", "index.mjs", "index.cjs", "index.ts",
+    "index.tsx", "index.mts", "index.cts", "index.php",
+    "main.js", "main.mjs", "main.cjs", "main.ts", "main.go", "main.rs",
+    "main.py", "main.swift", "main.java", "main.kt", "main.c", "main.cpp",
+    "main.dart",
+    "app.js", "app.ts", "app.py",
+    "lib.rs", "mod.ts", "__init__.py", "__main__.py",
+})
+ENTRY_POINT_MAX_DEPTH = 2
+
+TEST_FOLDERS = frozenset({"test", "tests", "__tests__", "spec", "specs"})
+TEST_CONFIG_NAMES = frozenset({
+    "conftest.py", "pytest.ini", "phpunit.xml", "phpunit.xml.dist", ".rspec",
+})
+TEST_CONFIG_PREFIXES = (
+    "jest.config.", "vitest.config.", "karma.conf.", "playwright.config.",
+    "cypress.config.",
+)
+TEST_FILE_RE = re.compile(
+    r"(\.(test|spec)\.[^./]+$)|(_test\.[^./]+$)|(^test_.+\.py$)|(_spec\.rb$)"
+)
 
-# Reason codes — exported as module-level constants so callers (and tests)
+# CI configurations read for ci_reference, relative to --source-root.
+CI_FILE_GLOBS = (
+    ".github/workflows/*.yml",
+    ".github/workflows/*.yaml",
+    ".gitlab-ci.yml",
+    ".circleci/config.yml",
+    ".travis.yml",
+    "azure-pipelines.yml",
+    "bitbucket-pipelines.yml",
+    ".buildkite/pipeline.yml",
+    "Jenkinsfile",
+)
+
+LARGE_DIRECTORY_FILES = 50
+
+SIGNAL_KEYS = (
+    "own_manifest",
+    "entry_point",
+    "service_definition",
+    "readme",
+    "test_suite",
+    "ci_reference",
+)
+
+
+# Reason codes: exported as module-level constants so callers (and tests)
 # can reference them without string typos.
 REASON_TOO_FEW_FILES = "too-few-files"
 REASON_TOO_LOW_LOC = "too-low-loc"
@@ -146,11 +364,30 @@ ALL_REASONS = (
 # --------------------------------------------------------------------------
 
 
+def normalize_boundary_path(name: str, path: str) -> str:
+    """`path` as one forward-slash path relative to the source root: `.`
+    for the root, no `./`, `//` or trailing slash. Raises ValueError for an
+    absolute path or one that leaves the source root."""
+    norm = posixpath.normpath(path.replace("\\", "/") or ".")
+    if (
+        norm.startswith("/")
+        or norm == ".."
+        or norm.startswith("../")
+        or re.match(r"^[A-Za-z]:", norm)
+    ):
+        raise ValueError(
+            f"boundary {name!r}: path {path!r} is not a folder below the source root"
+        )
+    return norm
+
+
 def validate_boundaries(boundaries: object) -> list[dict]:
-    """Validate the boundaries input is a list of {name, path, files} records.
+    """Validate the boundaries input is a list of {name, path, files?} records.
 
-    Returns the list with each entry's `files` normalized to forward-slash
-    strings. Raises ValueError on any structural defect.
+    Returns the list with each entry's `path` normalized
+    (normalize_boundary_path) and its `files` normalized to forward-slash
+    strings, or None when the entry gives none (the helper lists it).
+    Raises ValueError on any structural defect.
     """
     if not isinstance(boundaries, list):
         raise ValueError(
@@ -172,10 +409,15 @@ def validate_boundaries(boundaries: object) -> list[dict]:
             raise ValueError(
                 f"boundary entry {name!r} missing required `path` field"
             )
+        path = normalize_boundary_path(name, path)
         files = entry.get("files")
+        if files is None:
+            # Listed by the helper (list_boundary_files).
+            normalized.append({"name": name, "path": path, "files": None})
+            continue
         if not isinstance(files, list):
             raise ValueError(
-                f"boundary entry {name!r} missing required `files` array"
+                f"boundary entry {name!r} has a `files` value that is not an array"
             )
         norm_files: list[str] = []
         for f_idx, f in enumerate(files):
@@ -186,35 +428,204 @@ def validate_boundaries(boundaries: object) -> list[dict]:
             norm_files.append(f.replace("\\", "/"))
         normalized.append({
             "name": name,
-            "path": path.replace("\\", "/"),
+            "path": path,
             "files": norm_files,
         })
     return normalized
 
 
+# --------------------------------------------------------------------------
+# Listing a boundary's files
+# --------------------------------------------------------------------------
+
+
+def _source_tree_module():
+    """skf-source-tree.py, loaded once from beside this script, or None
+    when it cannot be loaded (the listing then walks the folder)."""
+    global _SOURCE_TREE_MODULE
+    if _SOURCE_TREE_MODULE is None:
+        spec = importlib.util.spec_from_file_location("skf_source_tree", SOURCE_TREE)
+        if spec is None or spec.loader is None or not SOURCE_TREE.is_file():
+            return None
+        module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(module)
+        except (OSError, ImportError, SyntaxError):
+            return None
+        _SOURCE_TREE_MODULE = module
+    return _SOURCE_TREE_MODULE
+
+
+def _hidden(rel: str) -> bool:
+    return any(part.startswith(".") for part in rel.split("/"))
+
+
+def _git_files(source_root: Path) -> list[str] | None:
+    """The files git lists under `source_root` (tracked, and untracked but
+    not ignored), relative to it, as git prints them (an unmerged path once
+    per stage); None when git is missing or the folder is in no work tree."""
+    module = _source_tree_module()
+    if module is None:
+        return None
+    res = module._git(source_root, "ls-files", "-z", "--cached", "--others", "--exclude-standard")
+    if res is None or res[0] != 0:
+        return None
+    files = []
+    for raw in res[1].split(b"\0"):
+        rel = os.fsdecode(raw).replace("\\", "/") if raw else ""
+        if rel and (source_root / rel).is_file() and not (source_root / rel).is_symlink():
+            files.append(rel)
+    return files
+
+
+def _walked_files(source_root: Path) -> list[str]:
+    files = []
+    for dirpath, dirnames, filenames in os.walk(source_root):
+        rel_dir = os.path.relpath(dirpath, source_root).replace(os.sep, "/")
+        rel_dir = "" if rel_dir == "." else rel_dir
+        dirnames[:] = sorted(
+            d for d in dirnames
+            if not d.startswith(".") and d not in WALK_SKIPPED_FOLDERS
+            and not os.path.islink(os.path.join(dirpath, d))
+        )
+        for name in filenames:
+            if not os.path.islink(os.path.join(dirpath, name)):
+                files.append(f"{rel_dir}/{name}" if rel_dir else name)
+    return files
+
+
+def list_source_files(source_root: Path) -> list[str]:
+    """Every file under `source_root` a boundary may hold, each once; see
+    the module docstring's Listing."""
+    listed = [rel for rel in _git_files(source_root) or [] if not _hidden(rel)]
+    if not listed:
+        # No git, no work tree, or a folder the outer work tree ignores
+        # (git lists nothing there): walk it.
+        listed = [rel for rel in _walked_files(source_root) if not _hidden(rel)]
+    # An unmerged path is listed once per stage during a conflicted merge.
+    return sorted(set(listed))
+
+
+def list_boundary_files(source_files: list[str], boundary_path: str) -> list[str]:
+    """The files of `source_files` below the boundary folder (all of them
+    for a boundary at the root)."""
+    root = boundary_path.strip("/")
+    if root in ("", "."):
+        return list(source_files)
+    prefix = root + "/"
+    return [f for f in source_files if f.startswith(prefix)]
+
+
+# --------------------------------------------------------------------------
+# File kinds: lockfiles and non-source files
+# --------------------------------------------------------------------------
+
+
+def scan_manifests_module():
+    """skf-scan-manifests.py, loaded once from beside this script.
+    Raises ImportError when it cannot be loaded.
+    """
+    global _SCAN_MODULE, _MANIFEST_FILENAMES, _MANIFEST_FILENAMES_LC
+    if _SCAN_MODULE is None:
+        spec = importlib.util.spec_from_file_location(
+            "skf_scan_manifests", SCAN_MANIFESTS
+        )
+        if spec is None or spec.loader is None or not SCAN_MANIFESTS.is_file():
+            raise ImportError(f"cannot load {SCAN_MANIFESTS}")
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        if not hasattr(module, "IDENTITY_READERS"):
+            raise ImportError(f"{SCAN_MANIFESTS} has no IDENTITY_READERS")
+        _MANIFEST_FILENAMES = frozenset(module.MANIFEST_ECOSYSTEMS)
+        _MANIFEST_FILENAMES_LC = frozenset(n.lower() for n in _MANIFEST_FILENAMES)
+        _SCAN_MODULE = module
+    return _SCAN_MODULE
+
+
+def manifest_filenames() -> frozenset[str]:
+    """The manifest file names skf-scan-manifests.py scans (the keys of its
+    MANIFEST_ECOSYSTEMS). Raises ImportError when it cannot be loaded.
+    """
+    scan_manifests_module()
+    return _MANIFEST_FILENAMES
+
+
+def _basename(file_path: str) -> str:
+    return file_path.replace("\\", "/").rsplit("/", 1)[-1]
+
+
+def is_lockfile(file_path: str) -> bool:
+    """True for a dependency lockfile (by file name)."""
+    name = _basename(file_path).lower()
+    return name in LOCKFILE_NAMES or name.endswith(LOCKFILE_SUFFIXES)
+
+
+def is_non_source(file_path: str) -> bool:
+    """True for documentation, data, configuration, media and binary files,
+    and for build and tool configuration (every manifest included).
+
+    Lockfiles are non-source too. A file with an extension the tables do
+    not list is a source file.
+    """
+    name = _basename(file_path).lower()
+    if not name or name.startswith("."):
+        return True
+    scan_manifests_module()
+    if (
+        is_lockfile(name)
+        or name in NON_SOURCE_NAMES
+        or name in _MANIFEST_FILENAMES_LC
+        or name.startswith(NON_SOURCE_PREFIXES)
+        or name.endswith(".dockerfile")
+        or any(infix in name for infix in NON_SOURCE_INFIXES)
+    ):
+        return True
+    ext = posixpath.splitext(name)[1]
+    return ext in NON_SOURCE_EXTENSIONS
+
+
 # --------------------------------------------------------------------------
 # Path-based detection (generated-code)
 # --------------------------------------------------------------------------
 
 
-def find_generated_segment(file_path: str) -> str | None:
-    """Return the first generated-path segment that appears in `file_path`,
-    or None if none match.
+def find_generated_segment(
+    file_path: str, manifest_dirs: frozenset[str] | set[str] = frozenset()
+) -> str | None:
+    """The generated-folder segment that marks `file_path`, a path below the
+    boundary, or None.
 
-    The match is on the raw string with forward slashes. We compare against
-    `<segment>` at any position (start or interior); a `node_modules/` at
-    the root counts the same as one nested deeper.
+    A vendored or cache folder counts at any depth (`node_modules/foo.js`
+    and `pkg/node_modules/foo.js` both hit). A build output folder counts
+    as the first folder, or inside a folder of `manifest_dirs`: the folders
+    below the boundary that hold a manifest ("" for the boundary root). The
+    leftmost folder that counts is returned.
     """
-    norm = file_path.replace("\\", "/")
-    # accept matches at the very start (no leading slash needed) too —
-    # so `node_modules/foo.js` and `pkg/node_modules/foo.js` both hit.
-    bracketed = "/" + norm  # so segments can match at the head consistently
-    for seg in GENERATED_PATH_SEGMENTS:
-        if "/" + seg in bracketed:
+    parts = [p for p in file_path.replace("\\", "/").split("/")[:-1] if p != "."]
+    for depth, part in enumerate(parts):
+        seg = part + "/"
+        if seg in VENDORED_PATH_SEGMENTS:
+            return seg
+        if seg in OUTPUT_PATH_SEGMENTS and (
+            depth == 0 or "/".join(parts[:depth]) in manifest_dirs
+        ):
             return seg
     return None
 
 
+def below_boundary(file_path: str, boundary_path: str) -> str:
+    """The part of `file_path` below the boundary folder.
+
+    A path that does not start with the boundary path (a boundary-relative
+    entry, or a boundary at the root) is returned whole.
+    """
+    root = boundary_path.strip("/")
+    if root in ("", "."):
+        return file_path
+    prefix = root + "/"
+    return file_path[len(prefix):] if file_path.startswith(prefix) else file_path
+
+
 # --------------------------------------------------------------------------
 # Header-sentinel scan (auto-generated-tag)
 # --------------------------------------------------------------------------
@@ -228,8 +639,8 @@ def has_auto_generated_marker(file_abs: Path) -> str | None:
     the AUTO_GEN_SENTINELS (case-insensitive substring match).
 
     Returns the matched sentinel (lowercased) on first hit, or None.
-    Unreadable / non-UTF-8 files return None — header-sentinel detection
-    is opportunistic; binary blobs will simply not match.
+    Unreadable / non-UTF-8 files return None: header-sentinel detection
+    is opportunistic, and binary blobs will simply not match.
     """
     try:
         with file_abs.open("r", encoding="utf-8", errors="replace") as fh:
@@ -265,6 +676,133 @@ def count_nonblank_lines(file_abs: Path) -> int:
         return 0
 
 
+# --------------------------------------------------------------------------
+# Signals
+# --------------------------------------------------------------------------
+
+
+def load_ci_files(source_root: Path) -> list[tuple[str, str]]:
+    """Read the CI configurations under `source_root`: (rel path, text) pairs,
+    sorted by path. Unreadable files are left out.
+    """
+    found: dict[str, str] = {}
+    for pattern in CI_FILE_GLOBS:
+        for path in source_root.glob(pattern):
+            if not path.is_file():
+                continue
+            try:
+                text = path.read_bytes().decode("utf-8", errors="replace")
+            except OSError:
+                continue
+            found[path.relative_to(source_root).as_posix()] = text
+    return sorted(found.items())
+
+
+def _names_path(text: str, boundary_path: str) -> bool:
+    """True when `text` names `boundary_path` as a whole path: not as part
+    of a longer name (`packages/auth` is not named by `packages/auth-ui`).
+    """
+    pattern = r"(?<![\w-])" + re.escape(boundary_path) + r"(?![\w.-])"
+    return re.search(pattern, text) is not None
+
+
+def _is_test_file(rel: str) -> bool:
+    parts = rel.split("/")
+    if any(part.lower() in TEST_FOLDERS for part in parts[:-1]):
+        return True
+    name = parts[-1].lower()
+    if name in TEST_CONFIG_NAMES or name.startswith(TEST_CONFIG_PREFIXES):
+        return True
+    return TEST_FILE_RE.search(name) is not None
+
+
+def collect_signals(
+    files: list[str],
+    boundary_path: str,
+    ci_files: list[tuple[str, str]],
+) -> dict:
+    """The presence flags of one boundary; see the module docstring."""
+    signals: dict = {key: None for key in SIGNAL_KEYS}
+    manifests = manifest_filenames()
+    entry_depth: int | None = None
+    for f in sorted(files):
+        rel = below_boundary(f, boundary_path)
+        depth = rel.count("/")
+        name = _basename(rel)
+        lname = name.lower()
+        if depth == 0 and signals["own_manifest"] is None and name in manifests:
+            signals["own_manifest"] = f
+        if depth == 0 and signals["readme"] is None and lname.startswith("readme"):
+            signals["readme"] = f
+        if (
+            lname in ENTRY_POINT_NAMES
+            and depth <= ENTRY_POINT_MAX_DEPTH
+            and (entry_depth is None or depth < entry_depth)
+        ):
+            signals["entry_point"] = f
+            entry_depth = depth
+        if (
+            signals["service_definition"] is None
+            and scan_manifests_module().is_service_definition(name)
+        ):
+            signals["service_definition"] = f
+        if signals["test_suite"] is None and _is_test_file(rel):
+            signals["test_suite"] = f
+    root = boundary_path.strip("/")
+    if root not in ("", "."):
+        for ci_path, text in ci_files:
+            if _names_path(text, root):
+                signals["ci_reference"] = ci_path
+                break
+    signals["large_directory"] = len(files) >= LARGE_DIRECTORY_FILES
+    return signals
+
+
+# --------------------------------------------------------------------------
+# Own manifest
+# --------------------------------------------------------------------------
+
+
+def describe_manifest(file_abs: Path, file_rel: str) -> dict:
+    """`{path, ecosystem, name, private}` of one manifest, `name` and
+    `private` as skf-scan-manifests.py's identity reader for its file name
+    reports them (null when the file is unreadable or names no package).
+    """
+    module = scan_manifests_module()
+    file_name = _basename(file_rel)
+    record = {
+        "path": file_rel,
+        "ecosystem": module.MANIFEST_ECOSYSTEMS[file_name],
+        "name": None,
+        "private": None,
+    }
+    reader = module.IDENTITY_READERS.get(file_name)
+    if reader is None:
+        return record
+    try:
+        text = file_abs.read_bytes().decode("utf-8", errors="replace")
+        record["name"], record["private"] = reader(text)
+    except Exception:  # noqa: BLE001 (a manifest that does not parse names nothing)
+        pass
+    return record
+
+
+def own_manifest(
+    files: list[str], boundary_path: str, source_root: Path
+) -> dict | None:
+    """The boundary's own manifest: of the manifests at its root, the first
+    in path order that names a package, else the first; None without one.
+    """
+    names = manifest_filenames()
+    described = [
+        describe_manifest(_resolve_file(source_root, boundary_path, f), f)
+        for f in sorted(files)
+        if "/" not in below_boundary(f, boundary_path) and _basename(f) in names
+    ]
+    named = [m for m in described if m["name"]]
+    return (named or described or [None])[0]
+
+
 # --------------------------------------------------------------------------
 # Per-boundary evaluation
 # --------------------------------------------------------------------------
@@ -286,114 +824,141 @@ def _resolve_file(source_root: Path, boundary_path: str, file_rel: str) -> Path:
     candidate_b = source_root / boundary_path / file_rel
     if candidate_b.is_file():
         return candidate_b
-    # neither exists — return the source-root form for missing-file accounting
+    # neither exists: return the source-root form for missing-file accounting
     return candidate_a
 
 
+def classify_file(
+    file_rel: str,
+    boundary_path: str,
+    source_root: Path,
+    manifest_dirs: frozenset[str] | set[str] = frozenset(),
+) -> dict | None:
+    """The generated-file entry for one source file, or None when the file
+    is not generated. Call it for source files only (see is_non_source);
+    `manifest_dirs` is find_generated_segment's.
+    """
+    rel = below_boundary(file_rel, boundary_path)
+    seg = find_generated_segment(rel, manifest_dirs)
+    if seg:
+        return {"path": file_rel, "reason": REASON_GENERATED_CODE, "match": seg}
+    sentinel = has_auto_generated_marker(
+        _resolve_file(source_root, boundary_path, file_rel)
+    )
+    if sentinel:
+        return {
+            "path": file_rel, "reason": REASON_AUTO_GENERATED_TAG, "match": sentinel,
+        }
+    return None
+
+
 def evaluate_boundary(
     boundary: dict,
     *,
     source_root: Path,
     min_files: int = MIN_FILES,
     min_loc: int = MIN_LOC,
+    ci_files: list[tuple[str, str]] | None = None,
 ) -> dict:
     """Evaluate a single boundary against all disqualification rules.
 
-    Returns a record:
-      - kept:    {"name", "path", "files_count", "loc_total"}
-      - dropped: {"name", "reason", "context": {...}}
+    Returns {"kind": "kept" | "dropped", "record": {...}}; the record shape
+    is the module docstring's <record>, and a dropped one adds `reason` and
+    `context`.
 
     Check order:
-      1. generated-code     (path segment match)
-      2. auto-generated-tag (header sentinel scan)
-      3. too-few-files      (count < min_files)
-      4. too-low-loc        (sum < min_loc)
+      1. generated-code / auto-generated-tag (every source file generated)
+      2. too-few-files      (files_count < min_files)
+      3. too-low-loc        (loc_total < min_loc)
     """
     name = boundary["name"]
     path = boundary["path"]
-    files = boundary["files"]
-    files_count = len(files)
-
-    # 1. generated-code — path-substring match (cheapest signal)
-    for f in files:
-        seg = find_generated_segment(f)
-        if seg:
-            return {
-                "kind": "dropped",
-                "record": {
-                    "name": name,
-                    "reason": REASON_GENERATED_CODE,
-                    "context": {
-                        "files_count": files_count,
-                        "first_match": f,
-                        "matched_segment": seg,
-                    },
-                },
-            }
-
-    # 2. auto-generated-tag — header sentinel scan
-    for f in files:
-        abs_path = _resolve_file(source_root, path, f)
-        sentinel = has_auto_generated_marker(abs_path)
-        if sentinel:
-            return {
-                "kind": "dropped",
-                "record": {
-                    "name": name,
-                    "reason": REASON_AUTO_GENERATED_TAG,
-                    "context": {
-                        "files_count": files_count,
-                        "first_match": f,
-                        "matched_sentinel": sentinel,
-                    },
-                },
-            }
-
-    # Compute loc_total for the remaining checks (and for kept records).
+    files = list(dict.fromkeys(boundary["files"]))  # a file listed twice counts once
+    if ci_files is None:
+        ci_files = load_ci_files(source_root)
+
+    manifests = manifest_filenames()
+    manifest_dirs = {
+        posixpath.dirname(below_boundary(f, path))
+        for f in files
+        if _basename(f) in manifests
+    }
+    sources = [f for f in files if not is_non_source(f)]
+    generated: list[dict] = []
+    plain: list[str] = []
+    for f in sources:
+        entry = classify_file(f, path, source_root, manifest_dirs)
+        if entry:
+            generated.append(entry)
+        else:
+            plain.append(f)
+    generated.sort(key=lambda g: g["path"])
+
     loc_total = 0
-    for f in files:
-        abs_path = _resolve_file(source_root, path, f)
-        loc_total += count_nonblank_lines(abs_path)
+    for f in plain:
+        loc_total += count_nonblank_lines(_resolve_file(source_root, path, f))
+
+    # Would rules 2 and 3 pass with the generated files counted too? Their
+    # lines are read only when that decides it.
+    passes = len(plain) >= min_files and loc_total >= min_loc
+    if not passes and len(sources) >= min_files:
+        loc = loc_total
+        for g in generated:
+            if loc >= min_loc:
+                break
+            loc += count_nonblank_lines(_resolve_file(source_root, path, g["path"]))
+        passes = loc >= min_loc
+
+    manifest = own_manifest(files, path, source_root)
+    signals = collect_signals(files, path, ci_files)
+    signals["own_manifest"] = manifest["path"] if manifest else None
+    record = {
+        "name": name,
+        "path": path,
+        "files_count": len(plain),
+        "loc_total": loc_total,
+        "non_source_count": len(files) - len(sources),
+        "generated_files": generated,
+        "generated_ratio": (
+            round(len(generated) / len(sources), 3) if sources else 0.0
+        ),
+        "passes_with_generated": passes,
+        "manifest": manifest,
+        "signals": signals,
+    }
+
+    # 1. every source file generated
+    if sources and not plain:
+        by_path = [g for g in generated if g["reason"] == REASON_GENERATED_CODE]
+        if by_path:
+            reason, first = REASON_GENERATED_CODE, by_path[0]
+            key = "matched_segment"
+        else:
+            reason, first = REASON_AUTO_GENERATED_TAG, generated[0]
+            key = "matched_sentinel"
+        context = {"first_match": first["path"], key: first["match"]}
+        return {
+            "kind": "dropped",
+            "record": {**record, "reason": reason, "context": context},
+        }
 
-    # 3. too-few-files
-    if files_count < min_files:
+    # 2. too-few-files
+    if len(plain) < min_files:
         return {
             "kind": "dropped",
-            "record": {
-                "name": name,
-                "reason": REASON_TOO_FEW_FILES,
-                "context": {
-                    "files_count": files_count,
-                    "loc_total": loc_total,
-                    "threshold": min_files,
-                },
-            },
+            "record": {**record, "reason": REASON_TOO_FEW_FILES,
+                       "context": {"threshold": min_files}},
         }
 
-    # 4. too-low-loc
+    # 3. too-low-loc
     if loc_total < min_loc:
         return {
             "kind": "dropped",
-            "record": {
-                "name": name,
-                "reason": REASON_TOO_LOW_LOC,
-                "context": {
-                    "files_count": files_count,
-                    "loc_total": loc_total,
-                    "threshold": min_loc,
-                },
-            },
+            "record": {**record, "reason": REASON_TOO_LOW_LOC,
+                       "context": {"threshold": min_loc}},
         }
 
-    return {
-        "kind": "kept",
-        "record": {
-            "name": name,
-            "path": path,
-            "files_count": files_count,
-            "loc_total": loc_total,
-        },
-    }
+    return {"kind": "kept", "record": record}
 
 
 # --------------------------------------------------------------------------
@@ -401,32 +966,77 @@ def evaluate_boundary(
 # --------------------------------------------------------------------------
 
 
+def fill_files(boundaries: list[dict], source_root: Path) -> list[dict]:
+    """The boundaries, each one without `files` given the files listed under
+    its path. Raises ValueError for such a boundary whose path is no folder
+    under `source_root`."""
+    source_files: list[str] | None = None
+    filled = []
+    for b in boundaries:
+        if b["files"] is None:
+            root = b["path"].strip("/")
+            if not (source_root / root).is_dir():
+                raise ValueError(
+                    f"boundary {b['name']!r}: {root or '.'} is not a folder under the source root"
+                )
+            if source_files is None:
+                source_files = list_source_files(source_root)
+            b = {**b, "files": list_boundary_files(source_files, b["path"])}
+        filled.append(b)
+    return filled
+
+
+def write_tree_file(tree_dir: Path, index: int, files: list[str]) -> Path:
+    """Write one boundary's file list, one path per line, as
+    `boundary-<index>.txt`; returns its path. A name that is not UTF-8
+    (decoded with surrogateescape) gets `?` for each byte that is not, so
+    the file stays UTF-8 for skf-detect-language.py."""
+    path = tree_dir / f"boundary-{index}.txt"
+    text = "".join(f"{f}\n" for f in sorted(set(files)))
+    path.write_bytes(text.encode("utf-8", errors="replace"))
+    return path
+
+
 def filter_boundaries(
     boundaries: list[dict],
     *,
     source_root: Path,
     min_files: int = MIN_FILES,
     min_loc: int = MIN_LOC,
+    tree_dir: Path | None = None,
 ) -> dict:
-    """Run evaluate_boundary on each entry; aggregate kept/dropped/stats."""
+    """Run evaluate_boundary on each entry; aggregate kept/dropped/stats.
+
+    A boundary without `files` is listed first (fill_files). With
+    `tree_dir`, each boundary's file list is written there and its record
+    names it in `tree_file`. Raises ValueError for a boundary path to list
+    that is no folder, and OSError for a tree file that cannot be written.
+    """
     kept: list[dict] = []
     dropped: list[dict] = []
     by_reason: dict[str, int] = {r: 0 for r in ALL_REASONS}
+    boundaries = fill_files(boundaries, source_root)
+    ci_files = load_ci_files(source_root) if boundaries else []
+    if tree_dir is not None and boundaries:
+        tree_dir.mkdir(parents=True, exist_ok=True)
 
-    for b in boundaries:
+    for index, b in enumerate(boundaries, 1):
         result = evaluate_boundary(
             b,
             source_root=source_root,
             min_files=min_files,
             min_loc=min_loc,
+            ci_files=ci_files,
         )
+        if tree_dir is not None:
+            result["record"]["tree_file"] = write_tree_file(tree_dir, index, b["files"]).as_posix()
         if result["kind"] == "kept":
             kept.append(result["record"])
         else:
             dropped.append(result["record"])
             by_reason[result["record"]["reason"]] += 1
 
-    # prune zero-count reasons from by_reason — keeps the report tight
+    # prune zero-count reasons from by_reason: keeps the report tight
     by_reason_compact = {r: n for r, n in by_reason.items() if n > 0}
 
     return {
@@ -435,6 +1045,7 @@ def filter_boundaries(
         "stats": {
             "kept": len(kept),
             "dropped": len(dropped),
+            "mixed": sum(1 for r in kept if r["generated_files"]),
             "by_reason": by_reason_compact,
         },
     }
@@ -498,12 +1109,27 @@ def _cmd_filter(args: argparse.Namespace) -> int:
         )
         return 1
 
-    result = filter_boundaries(
-        boundaries,
-        source_root=source_root,
-        min_files=args.min_files,
-        min_loc=args.min_loc,
-    )
+    try:
+        manifest_filenames()
+    except (ImportError, OSError, SyntaxError, AttributeError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    tree_dir = Path(args.tree_dir).resolve() if args.tree_dir else None
+    try:
+        result = filter_boundaries(
+            boundaries,
+            source_root=source_root,
+            min_files=args.min_files,
+            min_loc=args.min_loc,
+            tree_dir=tree_dir,
+        )
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    except OSError as exc:
+        print(f"error: cannot write a tree file under {tree_dir}: {exc}", file=sys.stderr)
+        return 1
     json.dump(result, sys.stdout, indent=2)
     sys.stdout.write("\n")
     return 0
@@ -514,8 +1140,10 @@ def _build_parser() -> argparse.ArgumentParser:
         prog="skf-disqualify-candidates",
         description=(
             "Filter detected boundaries against the unit-detection "
-            "disqualification list (too-few-files, too-low-loc, "
-            "generated-code, auto-generated-tag)."
+            "disqualification list (generated-code and auto-generated-tag "
+            "when every source file is generated, too-few-files, "
+            "too-low-loc), with each boundary's generated files and "
+            "detection signals as evidence."
         ),
     )
     sub = parser.add_subparsers(dest="cmd", required=True)
@@ -530,26 +1158,37 @@ def _build_parser() -> argparse.ArgumentParser:
         help=(
             "path to boundaries JSON, or '-' to read from stdin. "
             "Shape: [{\"name\": \"<unit>\", \"path\": \"<rel>\", "
-            "\"files\": [\"<rel>\", ...]}, ...]"
+            "\"files\": [\"<rel>\", ...]}, ...]; without files the "
+            "helper lists the files under the path"
         ),
     )
     p_filter.add_argument(
         "--source-root",
         default=None,
         help=(
-            "project root for resolving file paths in `files[]` "
+            "project root for listing a boundary's files, resolving file "
+            "paths in `files[]` and the CI configurations ci_reference reads "
             "(default: current working directory). Each file is resolved as "
             "<source-root>/<file-rel> first, falling back to "
             "<source-root>/<boundary-path>/<file-rel>."
         ),
     )
+    p_filter.add_argument(
+        "--tree-dir",
+        default=None,
+        help=(
+            "folder to write each boundary's file list to, one path per line "
+            "(boundary-<n>.txt, n its place in the input); each record names "
+            "its file in tree_file"
+        ),
+    )
     p_filter.add_argument(
         "--min-files",
         type=int,
         default=MIN_FILES,
         help=(
-            f"minimum files for too-few-files (default {MIN_FILES}; "
-            "matches unit-detection-heuristics.md)"
+            f"minimum source files (not generated) for too-few-files "
+            f"(default {MIN_FILES}; matches unit-detection-heuristics.md)"
         ),
     )
     p_filter.add_argument(
@@ -557,8 +1196,8 @@ def _build_parser() -> argparse.ArgumentParser:
         type=int,
         default=MIN_LOC,
         help=(
-            f"minimum non-blank LoC for too-low-loc (default {MIN_LOC}; "
-            "matches unit-detection-heuristics.md)"
+            f"minimum non-blank LoC of those files for too-low-loc "
+            f"(default {MIN_LOC}; matches unit-detection-heuristics.md)"
         ),
     )
     p_filter.set_defaults(func=_cmd_filter)