squackit 0.7.0__tar.gz → 0.8.0__tar.gz

{squackit-0.7.0 → squackit-0.8.0}/.gitignore

@@ -15,3 +15,7 @@ site/
 .kibitzer/
 scripts/example_grid_out/
 .lackpy/
+
+# pluckit AST cache (created in the working repo when the cache is enabled)
+.pluckit.duckdb
+.pluckit.duckdb.wal

squackit-0.8.0/CHANGELOG.md

@@ -0,0 +1,127 @@
+# Changelog
+
+## 0.8.0
+
+### Added — source text from `find`, and a cache instead of re-parsing
+`find` returns source text via a caller-chosen peek extent, and the AST cache
+is enabled so repeated calls query a materialized table rather than re-parsing
+the tree every time. Selection is delegated to sitting_duck's `ast_select`
+rather than reimplemented here.
+
+Cached tables now also carry `start_column` / `end_column`. These were not
+zeroed before — they were *absent*, since `read_ast` only adds them under
+`source := 'full'`. On minified input every node reports `start_line = 1`, so
+character offsets are the only way to isolate a node: peek says how much text a
+node carries, the columns say where it is.
+
+### Fixed — `investigate` preferred substrings over exact names
+`investigate(name)` resolved definitions with a LIKE substring
+(`name_pattern='%name%'`), so a deep-dive on `ensure_loaded` dragged in
+`_ensure_loaded` — including vendored copies under `.venv`. Because the Source
+and Calls sections key off `defs[0]`, the briefing could describe the **wrong
+function** entirely. Exact matches now win.
+
+### Changed — requires `ast-pluckit>=0.15,<0.16`
+This package calls `Plucker(..., cache=True, peek=...)`. That keyword arrived in
+pluckit 0.15.0; the 0.14.0 the previous constraint allowed does not have it, so
+a normal install resolved a pluckit whose every tool call raised `TypeError`.
+The suite had hidden this by running with `PYTHONPATH` pointed at a checkout;
+it is now verified against the published wheel.
+
+### Fixed — tests that need a fledgling checkout now skip
+Six tests read repo-shaped content (a `docs/` tree, `fledgling/pro/__main__.py`)
+that only a fledgling source checkout has. Under the installed-package layout
+they failed on assertions about *content* — reading as bugs in squackit's own
+defaults inference — instead of saying what was missing. They now skip, naming
+`FLEDGLING_REPO_PATH`.
+
+## 0.7.1
+
+### Added — server consumes default-limit knobs
+`config()`'s `max_results_default` / `complexity_max_results_default` session
+knobs are now honored by the server's tool truncation, so the in-memory limits
+set via `config()` actually take effect.
+
+### Changed — ast-pluckit 0.14 selector delegation
+Consume ast-pluckit 0.14.0, which delegates CSS-selector matching to
+sitting_duck's `ast_select` (fixes `:has(.call#name)` over-match, sitting_duck
+#72 / squackit #8); pinned `ast-pluckit>=0.14,<0.15` with a regression test.
+
+### Added — AST tools de-vendor the source glob (fledgling #47)
+`find` / `find_names` / `view` / `complexity` now exclude submodule, build,
+cache, and checked-in third-party trees from a whole-repo glob, so they focus on
+the project's own code instead of drowning in vendored deps. On a DuckDB
+extension with `duckdb/` + `rdkit/` git submodules, `find_names('**/*.cpp', '.function')`
+went from **35k+ names parsed in ~9 s to 164 in ~2 s** (~660× less work at the
+parse layer).
+
+- Reuses fledgling's single-source-of-truth ignore policy (`_is_vendored_path`
+  denylist + `_submodule_prefixes` git-awareness, new in fledgling 0.12) — the
+  filtered file set is handed to sitting_duck as an explicit `read_ast` list,
+  which parses identically to a glob (verified same results), so only *which*
+  files are parsed changes, not how selectors match.
+- The repo root for submodule exclusion is derived from the **source glob**
+  (walking up to the nearest `.gitmodules`/`.git`), not the server's cwd, so it
+  works when an agent queries a different project by absolute path.
+- Explicit targets are honored: a single-file source, a DuckDB table name, or a
+  glob aimed *into* a vendored/submodule tree (e.g. `rdkit/**/*.cpp`) is passed
+  through unfiltered rather than filtered to zero.
+
+### Changed
+- Require `fledgling-mcp>=0.12` for the `_is_vendored_path` / `_submodule_prefixes`
+  ignore-policy macros.
+
+## 0.6.0
+
+### Added — `investigate(path=)` for cross-project scoping
+`investigate(name, path=)` accepts an explicit `path` argument and scopes the
+symbol-lookup to that path's `scoped_code_pattern`. Without `path=`, defaults
+to the process `cwd`-scoped pattern (was: the global registry pattern, which
+substring-matched across every indexed project — e.g. `investigate("main")`
+returned hits from vendored JS in unrelated repos). Pre-existing
+`file_pattern=` overrides still work.
+
+### Added — per-root FTS search
+`search_*` tools now accept `root=<dir>` to index + search any repo on the
+fly. Indexes are LRU-cached per root for the session, so repeated queries
+in the same root stay cheap.
+
+### Fixed — agent-ergonomics findings
+- FTS now fails loud on index errors instead of silently returning empty.
+- `investigate` no longer mislabels callers in cross-file results.
+- Selector docs verified end-to-end against the running tool surface.
+- `lackpy` 0.12 dropped top-level re-exports; switched to submodule imports
+  to keep import-time light.
+
+### Docs
+- `:has(.call#NAME)` works now that pluckit delegates selector compilation
+  to sitting_duck (was a notable known-bug in 0.5.0).
+- Tool count corrected in README (~20 was wrong; actually ~35 / ~40 full).
+- Receiver-qualified call selectors (#4) marked DONE.
+- Response-type improvement proposals collected in `docs/proposals/`.
+
+## 0.5.0
+
+### Changed — migrate off pluckit/fledgling private internals
+squackit no longer reaches into private connection attributes; it now uses the
+public, SemVer'd contract from fledgling 0.10 and pluckit 0.13:
+
+- `con._con` → `con.con`; `con._tools` → `con.tools` (`server.py`, `cli.py`).
+- The lazy FTS rebuild (which poked `con._con` + a private `_fts_built` flag)
+  now delegates to fledgling's `Connection.ensure_fts()`. squackit keeps only
+  the `_FTS_MACROS` gating (which tools need FTS).
+- `plucker._registry.pluckins` → `plucker.pluckins`; `Chain._MUTATION_OPS`
+  → `Chain.MUTATION_OPS` (`tools.py`).
+
+### Dependencies — declare what we actually use, with compatible ranges
+- `ast-pluckit>=0.13.0,<0.14` (was `>=0.9.0`) — needs the public `pluckins`
+  accessor + `pluckins.search`/`viewer`.
+- `fledgling-mcp>=0.10.0,<0.11` — **newly declared.** squackit imports
+  `fledgling.tools.ToolInfo` and needs the `Connection.con/.tools/.ensure_fts`
+  contract; declaring it makes `Plucker.connection` always a `fledgling.Connection`
+  (ending the bare-duckdb surprise that caused the `'_con' missing` failures).
+
+### Net
+The brittle, undocumented, conditionally-present coupling is gone: a grep for
+private reach-ins (`con._con`, `con._tools`, `_registry`, `_MUTATION_OPS`,
+`_fts_built`) returns zero. The suite now composes by a versioned public API.

{squackit-0.7.0 → squackit-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: squackit
-Version: 0.7.0
+Version: 0.8.0
 Summary: Semi-QUalified Agent Companion Kit — the stateful intelligence + MCP server layer for fledgling-equipped agents.
 Project-URL: Homepage, https://github.com/teaguesterling/squackit
 Project-URL: Documentation, https://squackit.readthedocs.io
@@ -15,11 +15,11 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
-Requires-Dist: ast-pluckit<0.14,>=0.13.0
+Requires-Python: >=3.10
+Requires-Dist: ast-pluckit<0.16,>=0.15
 Requires-Dist: click>=8.0
 Requires-Dist: fastmcp>=3.0
-Requires-Dist: fledgling-mcp<0.11,>=0.10.0
+Requires-Dist: fledgling-mcp<0.13,>=0.12
 Provides-Extra: docs
 Requires-Dist: mkdocs-exclude>=1.0; extra == 'docs'
 Requires-Dist: mkdocs-material>=9.5; extra == 'docs'

{squackit-0.7.0 → squackit-0.8.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "squackit"
-version = "0.7.0"
+version = "0.8.0"
 description = "Semi-QUalified Agent Companion Kit — the stateful intelligence + MCP server layer for fledgling-equipped agents."
 readme = "README.md"
 license = "Apache-2.0"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 authors = [
     { name = "Teague Sterling" },
 ]
@@ -17,8 +17,8 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
 ]
 dependencies = [
-    "ast-pluckit>=0.13.0,<0.14",
-    "fledgling-mcp>=0.10.0,<0.11",
+    "ast-pluckit>=0.15,<0.16",
+    "fledgling-mcp>=0.12,<0.13",
     "click>=8.0",
     "fastmcp>=3.0",
 ]

{squackit-0.7.0 → squackit-0.8.0}/squackit/server.py

@@ -225,6 +225,16 @@ def _register_executor_tool(mcp, presentation: ToolPresentation):
                     max_limit = int(val)
                 except (TypeError, ValueError):
                     pass
+            else:
+                # Caller passed limit=None — fall back to runtime config.
+                # `complexity` is its own bucket; everything else uses the
+                # general default_max_results.
+                from squackit.runtime import get_runtime
+                rt = get_runtime()
+                if tool_name == "complexity":
+                    max_limit = rt.complexity_max_results_default
+                elif limit_param == "max_results":
+                    max_limit = rt.max_results_default
 
         # Pop verbose param the same way — opts out of compact_columns
         # projection so the caller can see the full AST bookkeeping schema.

{squackit-0.7.0 → squackit-0.8.0}/squackit/tools.py

@@ -8,16 +8,136 @@ fledgling macro tools. They take priority over fledgling equivalents
 
 from __future__ import annotations
 
+import os
+
 from fledgling.tools import ToolInfo
 from squackit.tool_config import ToolPresentation
 
 
-def _make_plucker(source: str):
-    """Create a Plucker with AstViewer and Search for tool execution."""
+#: How much source text ``read_ast`` puts in the ``peek`` column when squackit
+#: materializes its own table. ``'smart'`` matches what pluckit's cache uses by
+#: default, so a query returns the same peek whether or not de-vendoring kicked in.
+DEFAULT_PEEK = "smart"
+
+
+def _peek_arg(peek: str) -> str:
+    """Render a ``peek`` value as a ``read_ast`` named argument.
+
+    Accepts sitting_duck's vocabulary: ``'none'`` (suppress the text),
+    ``'smart'`` (short bounded preview), ``'full'`` (whole node), or an integer
+    size. ``+schema`` is appended so the column stays in the projection even for
+    ``'none'`` — squackit names ``peek`` in its compact columns, and a column
+    that disappears breaks the projection instead of merely emptying it.
+    """
+    value = str(peek).strip() or DEFAULT_PEEK
+    return f"peek := '{value}+schema'" if "+" not in value else f"peek := '{value}'"
+
+
+def _filtered_source(plucker, source: str, peek: str = DEFAULT_PEEK) -> str:
+    """De-vendor a source glob before it reaches pluckit's AST engine.
+
+    A bare ``**/*`` glob over a repo with git submodules or checked-in
+    third-party trees (googletest, vendored deps) makes the AST tools parse
+    thousands of files that aren't the project's own code — the ``find`` /
+    ``view`` / ``complexity`` flood. We reuse fledgling's single-source-of-truth
+    ignore policy (``_is_vendored_path`` denylist + ``_submodule_prefixes``
+    git-awareness) to expand the glob, drop the vendored files, and hand pluckit
+    an explicit ``read_ast`` table of just the survivors via its existing
+    table-name source path. sitting_duck parses a list of paths exactly as it
+    parses a glob (verified identical results), so this changes only *which*
+    files are parsed, not how selectors match.
+
+    Returns the original ``source`` unchanged — so pluckit handles it directly —
+    when filtering doesn't apply or would be wrong:
+      * not a glob (a single file path or a DuckDB table/view name) — an
+        explicit target, nothing to de-flood;
+      * the glob expands to <= 1 file;
+      * filtering removes *everything* — the caller deliberately aimed at a
+        vendored/submodule tree (e.g. ``rdkit/**/*.cpp``), so honor it;
+      * filtering removes *nothing* — passing the glob through is cheaper and
+        gives identical results.
+    Otherwise returns the name of a TEMP table holding the filtered AST.
+
+    Degrades gracefully: if the fledgling ignore-policy macros can't run for any
+    reason (not loaded, SQL error), we fall back to the raw ``source`` — the
+    caller gets the historical unfiltered (flooded) behavior rather than a dead
+    tool. This is a de-flooding optimization, not a correctness gate, so a raw
+    glob is a safe answer; never let it take down find/view/complexity.
+    """
+    if "*" not in source:
+        return source
+
+    try:
+        db = plucker._ctx.db
+        resolved = (
+            source if os.path.isabs(source)
+            else os.path.join(plucker._ctx.repo, source)
+        )
+        # Submodule exclusion reads <root>/.gitmodules, so root must be the repo
+        # that actually contains the globbed files — NOT the plucker's cwd, which
+        # may be a different project entirely. Derive it from the glob's literal
+        # prefix (the path before the first wildcard) and walk up to the nearest
+        # .gitmodules / .git. The denylist is absolute-pattern based, no root needed.
+        prefix = resolved.split("*", 1)[0]
+        root = prefix if prefix.endswith("/") else os.path.dirname(prefix)
+        while root and root != "/":
+            if os.path.exists(os.path.join(root, ".gitmodules")) or os.path.exists(
+                os.path.join(root, ".git")
+            ):
+                break
+            root = os.path.dirname(root)
+        rq = resolved.replace("'", "''")
+        rootq = root.rstrip("/").replace("'", "''")
+
+        total = db.sql(f"SELECT count(*) FROM glob('{rq}')").fetchone()[0]
+        if total <= 1:
+            return source
+
+        kept = [
+            r[0]
+            for r in db.sql(
+                f"SELECT file FROM glob('{rq}') "
+                f"WHERE NOT _is_vendored_path(file) "
+                f"AND NOT EXISTS (SELECT 1 FROM _submodule_prefixes('{rootq}') s "
+                f"WHERE file LIKE s.prefix || '%') "
+                f"ORDER BY file"
+            ).fetchall()
+        ]
+        if not kept or len(kept) == total:
+            return source
+
+        lit = "[" + ", ".join("'" + f.replace("'", "''") + "'" for f in kept) + "]"
+        db.execute(
+            "CREATE OR REPLACE TEMP TABLE _squackit_src AS "
+            f"SELECT * FROM read_ast({lit}, {_peek_arg(peek)})"
+        )
+        return "_squackit_src"
+    except Exception:
+        # Ignore-policy macros unavailable / SQL error — fall back to the raw
+        # glob. Unfiltered (flooded) results beat a broken tool.
+        return source
+
+
+def _make_plucker(source: str, peek: str = DEFAULT_PEEK):
+    """Create a Plucker with AstViewer and Search for tool execution.
+
+    The source glob is de-vendored first (see :func:`_filtered_source`) so the
+    AST tools focus on the project's own code instead of drowning in submodules,
+    build output, and checked-in third-party trees.
+    """
     from pluckit import Plucker
     from pluckit.pluckins.search import Search
     from pluckit.pluckins.viewer import AstViewer
-    return Plucker(code=source, plugins=[AstViewer, Search])
+    # cache=True is what makes peek reachable. pluckit resolves a source three
+    # ways: a table name goes straight to ``ast_select_from`` (peek comes from
+    # the materialized table), a cached source is materialized then read the
+    # same way, and everything else falls through to ``ast_select`` — which
+    # parses with ``peek := 'none'`` and can only ever return NULL. Enabling the
+    # cache moves the un-filtered path onto ``ast_select_from`` too, so both
+    # paths return source text. It also stops re-parsing on every call.
+    p = Plucker(plugins=[AstViewer, Search], cache=True, peek=peek)
+    p._code_source = _filtered_source(p, source, peek)
+    return p
 
 
 def view_executor(*, source: str, selector: str):
@@ -26,9 +146,9 @@ def view_executor(*, source: str, selector: str):
     return p.view(selector)
 
 
-def find_executor(*, source: str, selector: str):
+def find_executor(*, source: str, selector: str, peek: str = DEFAULT_PEEK):
     """Execute a find query, returning matched AST nodes as a relation."""
-    p = _make_plucker(source)
+    p = _make_plucker(source, peek)
     return p.find(selector).relation
 
 

{squackit-0.7.0 → squackit-0.8.0}/squackit/workflows.py

@@ -151,7 +151,13 @@ def investigate(con, defaults, name, file_pattern=None, path=None):
         # `config(set={"active_root": X})` instead of passing path= per call.
         file_pattern = defaults.scoped_code_pattern(resolve_scope_path(path))
 
-    # 1. Find definitions matching the name
+    # 1. Find definitions matching the name. Fetch substring candidates, then
+    #    prefer EXACT name matches: a deep-dive on `ensure_loaded` must not drag
+    #    in `_ensure_loaded` (or `main` -> `remain`). The substring pollutes the
+    #    Definition table AND — because Source/Calls key off defs[0] — can make
+    #    the whole briefing describe the wrong symbol. Fall back to the full
+    #    substring set only when nothing matches exactly, preserving the
+    #    forgiving lookup for partial names / typos.
     try:
         rel = con.find_definitions(
             file_pattern=file_pattern, name_pattern=f"%{name}%",
@@ -162,6 +168,12 @@ def investigate(con, defaults, name, file_pattern=None, path=None):
         defs = []
         def_cols = []
 
+    if defs and "name" in def_cols:
+        _n_idx = def_cols.index("name")
+        _exact = [d for d in defs if d[_n_idx] == name]
+        if _exact:
+            defs = _exact
+
     if not defs:
         return f"No definition found for '{name}'. Try a broader pattern or check spelling."
 

{squackit-0.7.0 → squackit-0.8.0}/tests/conftest.py

@@ -67,6 +67,38 @@ def __getattr__(name):
     raise AttributeError(f"module 'conftest' has no attribute {name!r}")
 
 
+def _fledgling_source_available() -> bool:
+    """True when the discovered root is a fledgling *source checkout*.
+
+    ``_discover_fledgling_repo`` accepts an installed-package layout (a wheel
+    that bundles ``sql/`` inside the package) because that is enough for the
+    macros. It is not enough for tests that read repo-shaped content — a
+    ``docs/`` tree, or module files like ``fledgling/pro/__main__.py`` — which
+    a wheel does not lay out the same way.
+
+    Without this check those tests fail on an assertion about the *content*
+    ("expected doc_pattern to start with docs/"), which points at squackit's
+    own defaults logic rather than at the missing checkout, and sends anyone
+    debugging it in the wrong direction.
+    """
+    try:
+        root = _get_project_root()
+    except RuntimeError:
+        return False
+    return os.path.isdir(os.path.join(root, "docs")) and os.path.isfile(
+        os.path.join(root, "fledgling", "pro", "__main__.py")
+    )
+
+
+requires_fledgling_source = pytest.mark.skipif(
+    not _fledgling_source_available(),
+    reason=(
+        "needs a fledgling source checkout (found an installed-package "
+        "layout). Set FLEDGLING_REPO_PATH to a fledgling clone."
+    ),
+)
+
+
 def load_sql(con, filename):
     """Load a SQL macro file into a DuckDB connection."""
     path = os.path.join(_get_project_root(), "sql", filename)

squackit-0.8.0/tests/fixtures/has_call_filter.py

@@ -0,0 +1,23 @@
+"""Fixture for the :has(.call#name) regression test.
+
+Four top-level functions; exactly two call `_target`. Used to pin that
+`:has(.call#_target)` applies the nested `#_target` filter rather than
+dropping it and matching every function (sitting_duck #72 / squackit #8).
+"""
+
+
+def _target():
+    return 1
+
+
+def calls_target_once():
+    return _target()
+
+
+def calls_target_twice():
+    a = _target()
+    return a + _target()
+
+
+def calls_other():
+    return len([])

squackit-0.8.0/tests/test_config_consumption.py

@@ -0,0 +1,95 @@
+"""Tests for tools consuming runtime config knobs (max_results_default)."""
+
+from __future__ import annotations
+
+import pytest
+
+from squackit import runtime as rt
+from squackit.runtime import SquackitRuntimeConfig, update_runtime
+
+
+@pytest.fixture(autouse=True)
+def _isolate_runtime():
+    rt._runtime = SquackitRuntimeConfig()
+    rt._seed = SquackitRuntimeConfig()
+    yield
+    rt._runtime = SquackitRuntimeConfig()
+    rt._seed = SquackitRuntimeConfig()
+
+
+class TestMaxResultsDefault:
+    """When a tool is called with max_results=None, the runtime config's
+    max_results_default should be used as the cap (not the presentation's
+    static max_rows)."""
+
+    @pytest.fixture
+    def mcp(self):
+        pytest.importorskip("fastmcp")
+        from conftest import PROJECT_ROOT
+        from squackit.server import create_server
+        return create_server(root=PROJECT_ROOT, init=False)
+
+    def _call(self, mcp, name, args):
+        import asyncio
+        from fastmcp import Client
+
+        async def _c():
+            async with Client(mcp) as client:
+                return await client.call_tool(name, args)
+
+        loop = asyncio.new_event_loop()
+        try:
+            return loop.run_until_complete(_c())
+        finally:
+            loop.close()
+
+    def test_explicit_max_results_still_wins(self, mcp):
+        update_runtime({"max_results_default": 5})
+        # call find_names with explicit max_results=3 — runtime knob ignored
+        result = self._call(mcp, "find_names", {
+            "source": "**/*.py", "selector": ".fn", "max_results": 3,
+        })
+        text = result.content[0].text if hasattr(result, "content") else str(result)
+        # Just verify the call succeeded — cap is a runtime concern, the
+        # important thing is the call completes and returns content.
+        assert len(text) > 0
+
+    def test_runtime_default_picked_up_when_omitted(self, mcp):
+        # Set a distinctive default so we can tell it took effect
+        update_runtime({"max_results_default": 7})
+        result = self._call(mcp, "find_names", {
+            "source": "**/*.py", "selector": ".fn",
+        })
+        text = result.content[0].text if hasattr(result, "content") else str(result)
+        assert len(text) > 0
+
+
+class TestComplexityMaxResults:
+    """complexity gets its own knob since it's usually called in smaller batches."""
+
+    @pytest.fixture
+    def mcp(self):
+        pytest.importorskip("fastmcp")
+        from conftest import PROJECT_ROOT
+        from squackit.server import create_server
+        return create_server(root=PROJECT_ROOT, init=False)
+
+    def test_complexity_uses_its_own_knob(self, mcp):
+        import asyncio
+        from fastmcp import Client
+
+        update_runtime({"complexity_max_results_default": 3})
+
+        async def _c():
+            async with Client(mcp) as client:
+                return await client.call_tool("complexity", {
+                    "source": "**/*.py", "selector": ".fn",
+                })
+
+        loop = asyncio.new_event_loop()
+        try:
+            result = loop.run_until_complete(_c())
+        finally:
+            loop.close()
+        text = result.content[0].text if hasattr(result, "content") else str(result)
+        assert len(text) > 0

{squackit-0.7.0 → squackit-0.8.0}/tests/test_defaults.py

@@ -6,7 +6,7 @@ from dataclasses import fields
 
 from squackit.db import create_connection
 from squackit.defaults import ProjectDefaults, TOOL_DEFAULTS, apply_defaults, load_config, infer_defaults
-from conftest import PROJECT_ROOT
+from conftest import PROJECT_ROOT, requires_fledgling_source
 
 
 class TestProjectDefaults:
@@ -194,6 +194,7 @@ class TestInferDefaults:
         defaults = infer_defaults(con, root=str(PROJECT_ROOT))
         assert "Python" in defaults.languages
 
+    @requires_fledgling_source
     def test_doc_pattern_finds_docs_dir(self, con):
         """This repo has a docs/ directory."""
         defaults = infer_defaults(con, root=str(PROJECT_ROOT))
@@ -242,6 +243,7 @@ class TestServerIntegration:
         assert hasattr(server, "_defaults")
         assert isinstance(server._defaults, ProjectDefaults)
 
+    @requires_fledgling_source
     def test_server_defaults_inferred(self, server):
         """Defaults reflect this project (Python, docs/)."""
         assert "py" in server._defaults.code_pattern