code-standards 8.56.1__tar.gz → 8.58.0__tar.gz

{code_standards-8.56.1 → code_standards-8.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-standards
-Version: 8.56.1
+Version: 8.58.0
 Summary: One deterministic quality gate for Sarj Python, TypeScript, Swift, Kotlin, shell, SQL, IaC, and repository policy.
 Project-URL: Homepage, https://code-standards.sarj.ai/
 Project-URL: Documentation, https://code-standards.sarj.ai/cli/
@@ -31,7 +31,7 @@ Requires-Dist: referencing==0.37.0
 Requires-Dist: repo-standards==6.6.0
 Requires-Dist: ruff==0.17.0
 Requires-Dist: sarj-iac-lint==0.21.0
-Requires-Dist: sarj-python-lint==1.36.1
+Requires-Dist: sarj-python-lint==1.37.0
 Requires-Dist: sarj-rule-contracts==0.2.4
 Requires-Dist: sarj-sql-lint==0.20.0
 Requires-Dist: shellcheck-py==0.11.0.1; (sys_platform == 'darwin' and platform_machine == 'arm64') or (sys_platform == 'darwin' and platform_machine == 'x86_64') or (sys_platform == 'linux' and platform_machine == 'x86_64') or (sys_platform == 'win32' and platform_machine == 'AMD64')
@@ -50,6 +50,10 @@ uv tool install --python 3.15 code-standards
 
 Adopt the repository once with `code-standards setup`. It installs one canonical staged gate that includes semantic lint and repository policy, plus commit-message and pull-request history enforcement. Do not install Repo Standards separately.
 
+The pre-commit gate runs once on every commit and discovers paths directly from the Git index, including mixed file types and deletion-only commits. The shared dispatcher selects applicable rules and retains type analysis, repository policy, exclusions and suppression accountability. Errors and incomplete analysis block the commit; warning-stage findings stay visible even when the hook passes. Agents should address the diagnostics, run `code-standards fix --staged` for safe mechanical fixes, review and stage intended edits, then retry. Staged fixes never fall back to the whole repository and refuse files with unstaged changes.
+
+Setup installs the selected hook manager. In a fresh checkout, run `code-standards doctor --repair` before committing; doctor checks installation and the exact unconditional command. Conditional Lefthook jobs must be moved to an unconditional job without changing unrelated hooks. Git can bypass local hooks with `--no-verify`; the canonical CI gate independently enforces policy.
+
 ```bash
 code-standards setup
 code-standards check

{code_standards-8.56.1 → code_standards-8.58.0}/README.md

@@ -10,6 +10,10 @@ uv tool install --python 3.15 code-standards
 
 Adopt the repository once with `code-standards setup`. It installs one canonical staged gate that includes semantic lint and repository policy, plus commit-message and pull-request history enforcement. Do not install Repo Standards separately.
 
+The pre-commit gate runs once on every commit and discovers paths directly from the Git index, including mixed file types and deletion-only commits. The shared dispatcher selects applicable rules and retains type analysis, repository policy, exclusions and suppression accountability. Errors and incomplete analysis block the commit; warning-stage findings stay visible even when the hook passes. Agents should address the diagnostics, run `code-standards fix --staged` for safe mechanical fixes, review and stage intended edits, then retry. Staged fixes never fall back to the whole repository and refuse files with unstaged changes.
+
+Setup installs the selected hook manager. In a fresh checkout, run `code-standards doctor --repair` before committing; doctor checks installation and the exact unconditional command. Conditional Lefthook jobs must be moved to an unconditional job without changing unrelated hooks. Git can bypass local hooks with `--no-verify`; the canonical CI gate independently enforces policy.
+
 ```bash
 code-standards setup
 code-standards check

{code_standards-8.56.1 → code_standards-8.58.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "code-standards"
-version = "8.56.1"
+version = "8.58.0"
 description = "One deterministic quality gate for Sarj Python, TypeScript, Swift, Kotlin, shell, SQL, IaC, and repository policy."
 readme = "README.md"
 requires-python = ">=3.14"
@@ -32,7 +32,7 @@ dependencies = [
   "ruff==0.17.0",
   "shellcheck-py==0.11.0.1; (sys_platform == 'darwin' and platform_machine == 'arm64') or (sys_platform == 'darwin' and platform_machine == 'x86_64') or (sys_platform == 'linux' and platform_machine == 'x86_64') or (sys_platform == 'win32' and platform_machine == 'AMD64')",
   "sarj-iac-lint==0.21.0",
-  "sarj-python-lint==1.36.1",
+  "sarj-python-lint==1.37.0",
   "sarj-sql-lint==0.20.0",
   "typer==0.27.3",
 ]

{code_standards-8.56.1 → code_standards-8.58.0}/src/sarj_standards/api.py

@@ -54,7 +54,7 @@ from .libs.diagnostics import (
 )
 from .libs.filesystem import is_link_like
 from .libs.linting.analysis import analyze as analyze_paths, report_from_tools
-from .libs.linting.external import analyze_external
+from .libs.linting.external import UpstreamESLintRules, analyze_external
 from .libs.linting.library_policy import (
     ManifestPolicyError,
     accepts_path as library_policy_accepts_path,
@@ -78,6 +78,7 @@ if TYPE_CHECKING:
 
 _INVALID_EXIT = 2
 _INTERRUPTED_EXIT = 130
+_NO_UPSTREAM_ESLINT_RULES = UpstreamESLintRules()
 _INVALID_DOCTOR_FINDING_IDS = frozenset(
     {"doctor.manifest.destination", "doctor.config.unknown", "doctor.package-json.invalid"}
 )
@@ -250,6 +251,7 @@ class Standards:
         trust: TrustMode | str = TrustMode.SAFE,
         mode: AnalysisMode | str = AnalysisMode.POLICY,
         rules: Sequence[str | RuleSelector] | None = None,
+        upstream_rules: UpstreamESLintRules = _NO_UPSTREAM_ESLINT_RULES,
         staged: bool = False,
         react_doctor_triggered: bool = False,
         include_react_doctor: bool = True,
@@ -262,6 +264,7 @@ class Standards:
     ) -> AnalysisReport:
         if jobs not in {1, 2}:
             return _failed_analysis(self.root, "invalid-input", "analysis jobs must be 1 or 2")
+        external = external or bool(upstream_rules.ids)
         try:
             normalized_trust = TrustMode(trust)
             normalized_mode = AnalysisMode(mode)
@@ -291,10 +294,7 @@ class Standards:
             selected_groups = group_paths(active_selected, policy=selection_policy)
         except (OSError, TypeError, ValueError) as exc:
             return _failed_analysis(self.root, "invalid-input", str(exc))
-        requested_paths = adopted.verify_paths if paths is None and adopted is not None else paths
-        react_doctor_full_scan = not staged and (
-            requested_paths is None or any(Path(path) == Path() for path in requested_paths)
-        )
+        react_doctor_full_scan = _react_doctor_full_scan(adopted, paths, staged=staged)
 
         def native_analysis() -> tuple[ToolReport, ...]:
             native = analyze_paths(
@@ -311,7 +311,9 @@ class Standards:
             prepared = _prepared_reports(self.root, adopted, prepared_devops, prepared_targets)
             return (*native.tools, *prepared)
 
-        coverage = _selection_coverage(self.root, selected, active_selected, selected_groups, rule_selection)
+        coverage = _selection_coverage(
+            self.root, selected, active_selected, selected_groups, rule_selection, upstream_rules=upstream_rules
+        )
         coverage.extend(_prepared_coverage(adopted, prepared_devops))
         if not external:
             native = report_from_tools(self.root, native_analysis())
@@ -355,14 +357,18 @@ class Standards:
                 react_doctor_full_scan=react_doctor_full_scan,
                 pass_on_unpruned_eslint_suppressions=pass_on_unpruned_eslint_suppressions,
                 python_type_check=python_type_check,
+                upstream_rules=upstream_rules,
             )
 
         combined = report_from_tools(
             self.root, analyze_groups(self.root, native_analysis, external_analysis, jobs=jobs)
         )
         combined = _with_shell_format_severity(combined, paths=paths, staged=staged, changed_scope=changed_scope)
-        if normalized_mode in {AnalysisMode.POLICY, AnalysisMode.OBSERVE}:
-            combined = _with_warning_severity(combined, _warning_rule_keys())
+        combined = _with_warning_severity(
+            combined,
+            _warning_rule_keys() if normalized_mode in {AnalysisMode.POLICY, AnalysisMode.OBSERVE} else frozenset(),
+            upstream_rules=upstream_rules,
+        )
         return _with_coverage(
             _without_baselined_diagnostics(combined, baseline_counts, changed_scope=changed_scope), coverage
         )
@@ -717,6 +723,7 @@ def _selected_external_analysis(
     react_doctor_full_scan: bool,
     pass_on_unpruned_eslint_suppressions: bool,
     python_type_check: bool,
+    upstream_rules: UpstreamESLintRules,
 ) -> tuple[ToolReport, ...]:
     rule_ids = (
         frozenset(str(value) for value in rule_selection.ids_for(RuleEngine.ESLINT))
@@ -724,12 +731,13 @@ def _selected_external_analysis(
         else None
     )
     external_engines = frozenset({RuleEngine.ESLINT, RuleEngine.CHECKOV, RuleEngine.ZIZMOR})
+    upstream_capabilities = frozenset({"eslint"}) if upstream_rules.ids else frozenset[str]()
     selected_capabilities = (
-        frozenset(engine.value for engine in rule_selection.engines & external_engines)
+        frozenset(engine.value for engine in rule_selection.engines & external_engines) | upstream_capabilities
         if rule_selection is not None
         else None
     )
-    run_external = rule_selection is None or not rule_selection.engines.isdisjoint(external_engines)
+    run_external = selected_capabilities is None or bool(selected_capabilities)
     external_reports = (
         (
             analyze_external(
@@ -742,6 +750,7 @@ def _selected_external_analysis(
                 ),
                 grouped=selected_groups,
                 rule_ids=rule_ids,
+                upstream_rules=upstream_rules,
                 security_selection=rule_selection,
                 include_react_doctor=include_react_doctor and rule_selection is None,
                 force_react_doctor=react_doctor_triggered,
@@ -758,6 +767,7 @@ def _selected_external_analysis(
                 capabilities=selected_capabilities,
                 grouped=selected_groups,
                 rule_ids=rule_ids,
+                upstream_rules=upstream_rules,
                 security_selection=rule_selection,
                 include_react_doctor=include_react_doctor and rule_selection is None,
                 force_react_doctor=react_doctor_triggered,
@@ -771,7 +781,10 @@ def _selected_external_analysis(
         else ()
     )
     if rule_selection is not None:
-        external_reports = tuple(_filter_report_selectors(report, rule_selection) for report in external_reports)
+        external_reports = tuple(
+            _filter_report_selectors(report, rule_selection, upstream_rules=upstream_rules)
+            for report in external_reports
+        )
     return external_reports
 
 
@@ -805,12 +818,19 @@ def _with_repository_analysis(root: Path, native: AnalysisReport, *, staged: boo
     return native
 
 
+def _react_doctor_full_scan(adopted: Manifest | None, paths: Sequence[str] | None, *, staged: bool) -> bool:
+    requested_paths = adopted.verify_paths if paths is None and adopted is not None else paths
+    return not staged and (requested_paths is None or any(Path(path) == Path() for path in requested_paths))
+
+
 def _selection_coverage(
     root: Path,
     selected: list[str],
     active_selected: list[str],
     selected_groups: GroupedPaths,
     rule_selection: RuleSelection | None,
+    *,
+    upstream_rules: UpstreamESLintRules,
 ) -> list[CoverageNotice]:
     coverage: list[CoverageNotice] = []
     excluded = sum(Path(item).is_file() and item not in active_selected for item in selected)
@@ -824,6 +844,8 @@ def _selection_coverage(
             )
         )
     routed = _routed_for_selection(selected_groups, rule_selection)
+    if upstream_rules.ids:
+        routed.update(selected_groups.typescript)
     if rule_selection is None:
         routed.update(
             item for item in active_selected if Path(item).is_file() and library_policy_accepts_path(Path(item), root)
@@ -941,9 +963,13 @@ def _routed_for_selection(grouped: object, selected: RuleSelection | None) -> se
 def _filter_report_selectors(
     report: ToolReport,
     selected: RuleSelection,
+    *,
+    upstream_rules: UpstreamESLintRules = _NO_UPSTREAM_ESLINT_RULES,
 ) -> ToolReport:
     engine = RuleEngine(report.name) if report.name in {"eslint", "zizmor", "checkov"} else None
     allowed: frozenset[str] = frozenset() if engine is None else selected.native_ids_for(engine)
+    if engine is RuleEngine.ESLINT:
+        allowed |= upstream_rules.ids
     return ToolReport(
         report.name,
         report.completion,
@@ -966,15 +992,23 @@ def _warning_rule_keys() -> frozenset[RuleSelector]:
     return warning_selectors()
 
 
-def _with_warning_severity(report: AnalysisReport, selectors: frozenset[RuleSelector]) -> AnalysisReport:
-    if not selectors:
+def _with_warning_severity(
+    report: AnalysisReport,
+    selectors: frozenset[RuleSelector],
+    *,
+    upstream_rules: UpstreamESLintRules = _NO_UPSTREAM_ESLINT_RULES,
+) -> AnalysisReport:
+    if not selectors and not upstream_rules.warning_only:
         return report
     tools = tuple(
         ToolReport(
             tool.name,
             tool.completion,
             diagnostics=tuple(
-                replace(item, severity=Severity.WARNING) if _selector_for_diagnostic(item) in selectors else item
+                replace(item, severity=Severity.WARNING)
+                if _selector_for_diagnostic(item) in selectors
+                or (tool.name == "eslint" and upstream_rules.warning_only and item.rule_id in upstream_rules.ids)
+                else item
                 for item in tool.diagnostics
             ),
             issues=tool.issues,

{code_standards-8.56.1 → code_standards-8.58.0}/src/sarj_standards/cli/main.py

@@ -180,6 +180,8 @@ class _Args:
     ratchet_cmd: str = ""
     baseline_cmd: str = ""
     selected_rules: list[RuleSelector] = field(default_factory=list)
+    test_value: bool = False
+    observation_base: str | None = None
     corpus_manifest: Path | None = None
     private_overlay: Path | None = None
     selector: RuleSelector | None = None
@@ -1128,15 +1130,6 @@ def cmd_check(args: _Args) -> int:
         if health_status:
             return health_status
         args.files = [path for path in args.files if runner.accepts_hook_path(Path(path), root=root)]
-        if not args.files and not scope.react_doctor_triggered:
-            return _run_canonical_check(
-                root,
-                (),
-                trusted=args.trust_repository_code,
-                staged=True,
-                jobs=args.jobs,
-                python_type_check=args.python_type_check,
-            )
     if args.output_format != "text":
         return _check_machine_output(args, root, scope)
     return _check_text_output(args, root, scope)
@@ -1160,6 +1153,11 @@ def _check_selected_rules(args: _Args, root: Path, scope: _CheckScope) -> int:
 
 
 def _check_text_output(args: _Args, root: Path, scope: _CheckScope) -> int:
+    if args.staged and not args.files:
+        check_options: dict[str, bool] = {"trusted": args.trust_repository_code, "staged": True}
+        if scope.react_doctor_triggered:
+            check_options["react_doctor_triggered"] = True
+        return _run_canonical_check(root, (), jobs=args.jobs, python_type_check=args.python_type_check, **check_options)
     if scope.pull_request_scoped:
         adoption_report = _machine_adoption_gate(root)
         if adoption_report is not None:
@@ -1183,7 +1181,7 @@ def _check_text_output(args: _Args, root: Path, scope: _CheckScope) -> int:
             )
     if not args.files:
         return cmd_verify(args)
-    check_options: dict[str, bool] = {
+    check_options = {
         "trusted": args.trust_repository_code,
         "staged": args.staged,
     }
@@ -1286,11 +1284,11 @@ def _check_machine_output(args: _Args, root: Path, scope: _CheckScope) -> int:
     args.external = True
     args.trust = "trusted" if args.trust_repository_code else "safe"
     args.analysis_mode = "policy"
-    if scope.repository_wide:
+    if scope.repository_wide and not args.staged:
         adoption_report = _machine_adoption_gate(root)
         if adoption_report is not None:
             return _emit_analysis_report(args, root, adoption_report)
-    if scope.pull_request_scoped and not args.files:
+    if (scope.pull_request_scoped or args.staged) and not args.files:
         from sarj_standards.api import (  # ruff: ignore[import-outside-top-level]
             AnalysisMode,
             Standards,
@@ -1303,6 +1301,7 @@ def _check_machine_output(args: _Args, root: Path, scope: _CheckScope) -> int:
             jobs=args.jobs,
             trust=TrustMode.TRUSTED if args.trust_repository_code else TrustMode.SAFE,
             mode=AnalysisMode.POLICY,
+            staged=args.staged,
             react_doctor_triggered=scope.react_doctor_triggered,
             python_type_check=args.python_type_check,
         )
@@ -1400,6 +1399,11 @@ def _run_canonical_check(
     rendered = to_text(report)
     if rendered:
         print(rendered, end="" if rendered.endswith("\n") else "\n")
+    if staged and report.diagnostics:
+        print(
+            "Agent: address the findings above. Run `code-standards fix --staged` for safe mechanical fixes, "
+            "review the changes, stage the intended edits, and retry the commit."
+        )
     return report.exit_code
 
 
@@ -1613,32 +1617,75 @@ def _object_table(value: object) -> dict[str, object] | None:
 
 def cmd_observe(args: _Args) -> int:
     from sarj_standards.api import AnalysisMode, Standards, TrustMode  # ruff: ignore[import-outside-top-level]
-    from sarj_standards.libs.linting.policy import warning_selectors  # ruff: ignore[import-outside-top-level]
+    from sarj_standards.libs.linting.external import UpstreamESLintRules  # ruff: ignore[import-outside-top-level]
+    from sarj_standards.libs.linting.test_value import UPSTREAM_RULES  # ruff: ignore[import-outside-top-level]
 
     root = _resolve_dest(args.dest)
     if _validate_analysis_output(args, root):
         return 2
-    warning_rules = warning_selectors()
-    invalid = sorted(set(args.selected_rules) - warning_rules)
-    if invalid:
-        rendered = ", ".join(map(str, invalid))
-        print(
-            f"error: observe accepts warning-stage rules only: {rendered}\n"
-            f"next: code-standards maintain rules stage-warning {invalid[0]}",
-            file=sys.stderr,
+    try:
+        selected_rules = _observation_rules(args)
+        files = _observation_paths(args, root)
+    except (OSError, ValueError, subprocess.SubprocessError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return _emit_analysis_report(args, root, _machine_input_error(root, str(exc)))
+    if files == []:
+        from sarj_standards.libs.diagnostics import (  # ruff: ignore[import-outside-top-level]
+            AnalysisReport,
+            Completion,
+            Conclusion,
         )
-        return 2
+
+        return _emit_analysis_report(args, root, AnalysisReport(root, Completion.COMPLETE, Conclusion.PASSED, ()))
     report = Standards(root).analyze(
-        args.files or None,
+        files,
         jobs=args.jobs,
-        external=any(selector.engine.value == "eslint" for selector in args.selected_rules),
+        external=args.test_value or any(selector.engine.value == "eslint" for selector in selected_rules),
         trust=TrustMode.TRUSTED if args.trust_repository_code else TrustMode.SAFE,
         mode=AnalysisMode.OBSERVE,
-        rules=args.selected_rules,
+        rules=selected_rules,
+        upstream_rules=UpstreamESLintRules(UPSTREAM_RULES, warning_only=True)
+        if args.test_value
+        else UpstreamESLintRules(),
     )
     return _emit_analysis_report(args, root, report)
 
 
+def _observation_rules(args: _Args) -> list[RuleSelector]:
+    from sarj_standards.libs.linting.policy import warning_selectors  # ruff: ignore[import-outside-top-level]
+    from sarj_standards.libs.linting.test_value import SELECTORS  # ruff: ignore[import-outside-top-level]
+
+    warning_rules = warning_selectors()
+    selected_rules = sorted(set(args.selected_rules) | (SELECTORS if args.test_value else frozenset()), key=str)
+    if not selected_rules:
+        msg = "observe requires --rule or --test-value"
+        raise ValueError(msg)
+    invalid = sorted(set(selected_rules) - warning_rules)
+    if invalid:
+        rendered = ", ".join(map(str, invalid))
+        msg = (
+            f"observe accepts warning-stage rules only: {rendered}; "
+            f"next: code-standards maintain rules stage-warning {invalid[0]}"
+        )
+        raise ValueError(msg)
+    return selected_rules
+
+
+def _observation_paths(args: _Args, root: Path) -> list[str] | None:
+    from sarj_standards.libs.linting.test_value import select_test_paths  # ruff: ignore[import-outside-top-level]
+
+    files = args.files or None
+    if args.observation_base is not None:
+        if args.files:
+            msg = "observe --base cannot be combined with explicit paths"
+            raise ValueError(msg)
+        files = _changed_file_paths(root, args.observation_base)
+    if args.test_value:
+        candidates = _selected_paths(root, files) if files is not None else _selected_paths(root, ["."])
+        return select_test_paths(root, candidates)
+    return files
+
+
 def _rule_evaluation_summary(report: object, selectors: Sequence[RuleSelector]) -> str:
     from sarj_standards.libs.diagnostics import AnalysisReport  # ruff: ignore[import-outside-top-level]
     from sarj_standards.libs.rules import RuleEngine  # ruff: ignore[import-outside-top-level]
@@ -2000,7 +2047,7 @@ def _staged_file_names(root: Path) -> list[str]:
         msg = "git is required for --staged"
         raise OSError(msg)
     completed = subprocess.run(  # ruff: ignore[subprocess-without-shell-equals-true] -- fixed argv, no shell.
-        [git, "diff", "--cached", "--name-only", "--diff-filter=ACDMR", "-z"],
+        [git, "diff", "--cached", "--name-only", "-z"],
         cwd=root,
         check=True,
         capture_output=True,
@@ -2150,11 +2197,9 @@ def cmd_format(args: _Args) -> int:
         print("fix: run `code-standards doctor --repair`, then retry", file=sys.stderr)
         return 2 if any(finding.id in _INVALID_DOCTOR_IDS for finding in drifted) else 1
     if args.staged:
-        try:
-            args.files = _staged_files(root)
-        except (OSError, subprocess.SubprocessError) as exc:
-            print(f"error: cannot read staged files: {exc}", file=sys.stderr)
-            return 2
+        selection_status = _select_staged_fix(args, root)
+        if selection_status is not None:
+            return selection_status
     elif args.files:
         try:
             args.files = _selected_paths(root, args.files)
@@ -2171,6 +2216,27 @@ def cmd_format(args: _Args) -> int:
     return lifecycle.execute(commands)
 
 
+def _select_staged_fix(args: _Args, root: Path) -> int | None:
+    try:
+        staged_names = _staged_file_names(root)
+        drifted = _unstaged_versions(root, staged_names)
+        if drifted:
+            print(
+                "error: --staged found files with unstaged content; stage the intended versions before fixing: "
+                + ", ".join(drifted),
+                file=sys.stderr,
+            )
+            return 2
+        args.files = _safe_staged_paths(root, staged_names)
+    except (OSError, subprocess.SubprocessError) as exc:
+        print(f"error: cannot read staged files: {exc}", file=sys.stderr)
+        return 2
+    if not args.files:
+        print("No staged files to fix.")
+        return 0
+    return None
+
+
 def _staged_files(root: Path) -> list[str]:
     return _safe_staged_paths(root, _staged_file_names(root))
 
@@ -3043,7 +3109,7 @@ def build_app(handler: Callable[[_Args], int] = _dispatch) -> typer.Typer:
             bool,
             typer.Option(
                 "--staged",
-                help="run custom rules on hook-supplied paths, or discover staged files when none are supplied",
+                help="run the complete gate on staged files; optional paths narrow the staged selection",
             ),
         ] = False,
         selected_rules: Annotated[
@@ -3094,9 +3160,15 @@ def build_app(handler: Callable[[_Args], int] = _dispatch) -> typer.Typer:
         ctx: typer.Context,
         *,
         selected_rules: Annotated[
-            list[RuleSelector],
+            list[RuleSelector] | None,
             typer.Option("--rule", parser=_parse_rule_selector, help="canonical ENGINE:ID selector (repeatable)"),
-        ],
+        ] = None,
+        test_value: Annotated[
+            bool, typer.Option("--test-value", help="report the curated opt-in test-oracle advisories")
+        ] = False,
+        base: Annotated[
+            str | None, typer.Option("--base", help="observe existing paths changed from this Git base")
+        ] = None,
         output_format: Annotated[_DiagnosticFormat, typer.Option("--format")] = _DiagnosticFormat.TEXT,
         output: Annotated[Path | None, typer.Option("--output")] = None,
         trust_repository_code: Annotated[
@@ -3112,7 +3184,9 @@ def build_app(handler: Callable[[_Args], int] = _dispatch) -> typer.Typer:
             _Args(
                 dest=_command_root(ctx),
                 cmd="observe",
-                selected_rules=selected_rules,
+                selected_rules=selected_rules or [],
+                test_value=test_value,
+                observation_base=base,
                 output_format=output_format.value,
                 output=output if output is not None else None,
                 trust_repository_code=trust_repository_code,