smelt-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{smelt_cli-0.1.2 → smelt_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: smelt-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Static guardrails for Python codebases maintained by humans and coding agents.
 Author: Mathis Arends
 Author-email: Mathis Arends <mathisarends27@gmail.com>
@@ -24,18 +24,7 @@ with the exact location, what is allowed instead and how to fix it:
 
 ## Installation
 
-Requires Python 3.12 or newer. Until this project has a PyPI release under its own
-distribution name, install from this repository:
-
-```bash
-uv tool install git+https://github.com/mathisarends/smelt.git
-smelt --version
-```
-
-From a local checkout, use `uv tool install .`. The PyPI package named `smelt` belongs
-to a different project; `pip install smelt` and bare `uvx smelt` install that project.
-
-## Installation
+Requires Python 3.12 or newer.
 
 ```bash
 uv tool install smelt-cli
@@ -45,11 +34,14 @@ pip install smelt-cli
 
 The PyPI package is named `smelt-cli`; the CLI command and Python package are both
 named `smelt`. To run without installing, use `uvx --from smelt-cli smelt check`.
+From a local checkout, use `uv tool install .`. The PyPI package named `smelt` belongs
+to a different project; `pip install smelt` and bare `uvx smelt` install that project.
 
 ## Usage
 
 ```bash
 smelt init                           # draft smelt.yaml from the code (also uv workspaces)
+smelt init --config other.yaml       # write elsewhere; only that file is checked and overwritten
 smelt check                          # whole project
 smelt check --changed                # only what the working tree introduced since HEAD
 smelt check --changed --base origin/main --format json
@@ -68,6 +60,15 @@ config error, not a silently disabled rule.
 Explicit check paths must exist and contain analyzed source or test files; unknown
 `--select`/`--ignore` prefixes are usage errors. JSON includes the reporting scope, file
 count and active rule codes. `--config PATH` works before or after a subcommand.
+A stored JSON report explains itself: `scope.mode` is `full` or `changed`, and
+`comparison` names the requested `base`, the resolved `merge_base`, the
+`compared_revision` and `head`, so `passed` from `--changed` reads as "nothing new since
+that commit", not as a clean inventory. `coverage` lists the source and test roots,
+workspace members that are not analyzed, module counts per classification, the
+composition-root and wiring exemptions, third-party policies per layer, the import
+settings (`type_checking`, `transitive`, `cycles`), cross-feature allowances as fields,
+and a `policy_hash` that is equal for reports checked under the same resolved config.
+`smelt context --format json` carries the same import settings, allowances and hash.
 With `--format json`, an exit `2` prints a JSON document as well, so an agent needs no
 text parser: `{"schema_version": 1, "status": "error", "error": {...}}` with `kind`
 (`usage`, `config` or `analysis`), `message`, the rejected `input` (`option`, `value`)
@@ -129,8 +130,18 @@ tests:
   import restrictions and configured cycle checks still apply.
 
 `smelt init` infers most of this: features, layers, shared and settings modules, the
-composition root including an app factory, wiring patterns, central packages by name and
+composition root including an app factory (imported or named as a `"backend.app:app"`
+server target), wiring patterns, central packages by name and
 the mirror pattern the existing tests follow. Review it before adopting its findings.
+It follows the names a composition root imports through package facades into their
+definitions (`FEATURES = (chat.feature, ...)`); a module whose definition is built from
+providers, such as a `feature.py` assembling `TelegramProvider`, becomes wiring, and the
+config comment shows the chain. Merely importing framework types changes nothing. An
+unclassified package only the root uses is proposed as a commented-out candidate with its
+chain and confidence, never applied silently.
+In a uv workspace it lists every declared member with the packages it found or why it
+skipped it (`tool.uv.workspace.exclude`, no Python package); namespace packages without
+`__init__.py` count under `src/` and where `tool.uv.build-backend` declares them.
 Its starter policy explicitly allows third-party packages and checks direct imports.
 Review these decisions: to keep frameworks out of the core, set e.g.
 `domain.third_party: {default: deny, allow: [pydantic]}` under `architecture.layers`.
@@ -155,6 +166,14 @@ elsewhere is an error. The message names the fix where it can: the right directo
 right file name (`test_session_infrastructure_repository.py` should be named
 `test_repository.py`), a neighbouring module with a similar name, or a missing `{root}` in
 the pattern.
+Imports through package facades count as imports of the module that defines the
+name, so `from app.channels.application import ChannelCommands` points at
+`application/commands/`. A move needs that evidence (or a test named exactly after its
+subject, marked `"evidence": "name"`); a similar file name alone suggests nothing.
+Otherwise the JSON lists `expected.candidates`: the imported modules, nearest first, with
+the names imported from them, the facade they came through and their mirrored test path.
+A test importing two modules of its name (`application/bootstrap.py` and
+`infrastructure/bootstrap.py`) gets both as candidates and no move.
 
 `tests.mirror` sets the convention relative to the test root: the default
 `{path}/test_{module}.py` drops the root package, `{root}/{path}/test_{module}.py` keeps it,
@@ -180,7 +199,15 @@ A first check often reports dozens of findings that come down to a few decisions
 import finding carries an `edge` in JSON (`"billing.application -> voice.domain"`; for
 cycles, the cycle), and the text output ends with the edges behind several findings.
 Settle each edge once: fix the code, or record an intended dependency as policy, e.g. a
-`cross_feature.allow` entry. Accept what remains with a baseline:
+`cross_feature.allow` entry.
+JSON also lists `groups`, sorted by size: a `facade` group collects the indirect
+findings one module relays (its count is what narrowing that facade's exports would
+address), an `edge` group counts `direct` and `transitive` findings of one dependency, a
+`cycle` group carries the witness import path, and a `test_move` group the SMT401 files
+moving between the same directories. Groups cite findings by their `id`; every finding
+stays in `violations`, so a group is one decision, not one more defect.
+
+Accept what remains with a baseline:
 
 `smelt debt` records today's violations in `.smelt/debt.json` and sets `debt:` in
 `smelt.yaml`. `smelt check` then fails only on new violations, and SMT903 reports entries
@@ -227,7 +254,7 @@ regression test.
 ```yaml
 repos:
   - repo: https://github.com/mathisarends/smelt
-    rev: v0.1.2
+    rev: v0.1.3
     hooks:
       - id: smelt
 ```

{smelt_cli-0.1.2 → smelt_cli-0.1.3}/README.md

@@ -9,18 +9,7 @@ with the exact location, what is allowed instead and how to fix it:
 
 ## Installation
 
-Requires Python 3.12 or newer. Until this project has a PyPI release under its own
-distribution name, install from this repository:
-
-```bash
-uv tool install git+https://github.com/mathisarends/smelt.git
-smelt --version
-```
-
-From a local checkout, use `uv tool install .`. The PyPI package named `smelt` belongs
-to a different project; `pip install smelt` and bare `uvx smelt` install that project.
-
-## Installation
+Requires Python 3.12 or newer.
 
 ```bash
 uv tool install smelt-cli
@@ -30,11 +19,14 @@ pip install smelt-cli
 
 The PyPI package is named `smelt-cli`; the CLI command and Python package are both
 named `smelt`. To run without installing, use `uvx --from smelt-cli smelt check`.
+From a local checkout, use `uv tool install .`. The PyPI package named `smelt` belongs
+to a different project; `pip install smelt` and bare `uvx smelt` install that project.
 
 ## Usage
 
 ```bash
 smelt init                           # draft smelt.yaml from the code (also uv workspaces)
+smelt init --config other.yaml       # write elsewhere; only that file is checked and overwritten
 smelt check                          # whole project
 smelt check --changed                # only what the working tree introduced since HEAD
 smelt check --changed --base origin/main --format json
@@ -53,6 +45,15 @@ config error, not a silently disabled rule.
 Explicit check paths must exist and contain analyzed source or test files; unknown
 `--select`/`--ignore` prefixes are usage errors. JSON includes the reporting scope, file
 count and active rule codes. `--config PATH` works before or after a subcommand.
+A stored JSON report explains itself: `scope.mode` is `full` or `changed`, and
+`comparison` names the requested `base`, the resolved `merge_base`, the
+`compared_revision` and `head`, so `passed` from `--changed` reads as "nothing new since
+that commit", not as a clean inventory. `coverage` lists the source and test roots,
+workspace members that are not analyzed, module counts per classification, the
+composition-root and wiring exemptions, third-party policies per layer, the import
+settings (`type_checking`, `transitive`, `cycles`), cross-feature allowances as fields,
+and a `policy_hash` that is equal for reports checked under the same resolved config.
+`smelt context --format json` carries the same import settings, allowances and hash.
 With `--format json`, an exit `2` prints a JSON document as well, so an agent needs no
 text parser: `{"schema_version": 1, "status": "error", "error": {...}}` with `kind`
 (`usage`, `config` or `analysis`), `message`, the rejected `input` (`option`, `value`)
@@ -114,8 +115,18 @@ tests:
   import restrictions and configured cycle checks still apply.
 
 `smelt init` infers most of this: features, layers, shared and settings modules, the
-composition root including an app factory, wiring patterns, central packages by name and
+composition root including an app factory (imported or named as a `"backend.app:app"`
+server target), wiring patterns, central packages by name and
 the mirror pattern the existing tests follow. Review it before adopting its findings.
+It follows the names a composition root imports through package facades into their
+definitions (`FEATURES = (chat.feature, ...)`); a module whose definition is built from
+providers, such as a `feature.py` assembling `TelegramProvider`, becomes wiring, and the
+config comment shows the chain. Merely importing framework types changes nothing. An
+unclassified package only the root uses is proposed as a commented-out candidate with its
+chain and confidence, never applied silently.
+In a uv workspace it lists every declared member with the packages it found or why it
+skipped it (`tool.uv.workspace.exclude`, no Python package); namespace packages without
+`__init__.py` count under `src/` and where `tool.uv.build-backend` declares them.
 Its starter policy explicitly allows third-party packages and checks direct imports.
 Review these decisions: to keep frameworks out of the core, set e.g.
 `domain.third_party: {default: deny, allow: [pydantic]}` under `architecture.layers`.
@@ -140,6 +151,14 @@ elsewhere is an error. The message names the fix where it can: the right directo
 right file name (`test_session_infrastructure_repository.py` should be named
 `test_repository.py`), a neighbouring module with a similar name, or a missing `{root}` in
 the pattern.
+Imports through package facades count as imports of the module that defines the
+name, so `from app.channels.application import ChannelCommands` points at
+`application/commands/`. A move needs that evidence (or a test named exactly after its
+subject, marked `"evidence": "name"`); a similar file name alone suggests nothing.
+Otherwise the JSON lists `expected.candidates`: the imported modules, nearest first, with
+the names imported from them, the facade they came through and their mirrored test path.
+A test importing two modules of its name (`application/bootstrap.py` and
+`infrastructure/bootstrap.py`) gets both as candidates and no move.
 
 `tests.mirror` sets the convention relative to the test root: the default
 `{path}/test_{module}.py` drops the root package, `{root}/{path}/test_{module}.py` keeps it,
@@ -165,7 +184,15 @@ A first check often reports dozens of findings that come down to a few decisions
 import finding carries an `edge` in JSON (`"billing.application -> voice.domain"`; for
 cycles, the cycle), and the text output ends with the edges behind several findings.
 Settle each edge once: fix the code, or record an intended dependency as policy, e.g. a
-`cross_feature.allow` entry. Accept what remains with a baseline:
+`cross_feature.allow` entry.
+JSON also lists `groups`, sorted by size: a `facade` group collects the indirect
+findings one module relays (its count is what narrowing that facade's exports would
+address), an `edge` group counts `direct` and `transitive` findings of one dependency, a
+`cycle` group carries the witness import path, and a `test_move` group the SMT401 files
+moving between the same directories. Groups cite findings by their `id`; every finding
+stays in `violations`, so a group is one decision, not one more defect.
+
+Accept what remains with a baseline:
 
 `smelt debt` records today's violations in `.smelt/debt.json` and sets `debt:` in
 `smelt.yaml`. `smelt check` then fails only on new violations, and SMT903 reports entries
@@ -212,7 +239,7 @@ regression test.
 ```yaml
 repos:
   - repo: https://github.com/mathisarends/smelt
-    rev: v0.1.2
+    rev: v0.1.3
     hooks:
       - id: smelt
 ```

{smelt_cli-0.1.2 → smelt_cli-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "smelt-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Static guardrails for Python codebases maintained by humans and coding agents."
 readme = "README.md"
 requires-python = ">=3.12"

{smelt_cli-0.1.2 → smelt_cli-0.1.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "smelt-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Static guardrails for Python codebases maintained by humans and coding agents."
 readme = "README.md"
 authors = [{ name = "Mathis Arends", email = "mathisarends27@gmail.com" }]

smelt_cli-0.1.3/smelt/analysis/exports.py

@@ -0,0 +1,166 @@
+"""Where a name that a module exposes is defined, following package re-exports.
+
+``from app.billing import Invoice`` names ``app.billing``, but ``Invoice`` lives in
+``app.billing.models`` when the facade ``app/billing/__init__.py`` re-exports it.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from smelt.analysis.parsing import resolve_relative
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
+# Re-export chains are short; a longer one is more likely a cycle than a design.
+MAX_HOPS = 8
+
+
+@dataclass(frozen=True, slots=True)
+class Namespace:
+    """The names a module binds at top level."""
+
+    module: str
+    # local name -> the absolute name it was imported as
+    imported: dict[str, str] = field(default_factory=dict)
+    defined: frozenset[str] = frozenset()
+    # defined name -> dotted names its value refers to: ``("chat", "feature")``
+    references: dict[str, tuple[tuple[str, ...], ...]] = field(default_factory=dict)
+
+
+type Loader = Callable[[str], "Namespace | None"]
+
+
+def namespace_of(tree: ast.Module, module: str, *, is_package: bool) -> Namespace:
+    imported: dict[str, str] = {}
+    defined: set[str] = set()
+    references: dict[str, tuple[tuple[str, ...], ...]] = {}
+    for node in _top_level(tree.body):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                name = alias.asname or alias.name.split(".")[0]
+                imported[name] = alias.name if alias.asname else name
+                defined.discard(name)
+                references.pop(name, None)
+        elif isinstance(node, ast.ImportFrom):
+            base = resolve_relative(
+                module, is_package=is_package, level=node.level, target=node.module
+            )
+            for alias in node.names:
+                if alias.name != "*":
+                    qualified = f"{base}.{alias.name}" if base else alias.name
+                    name = alias.asname or alias.name
+                    imported[name] = qualified
+                    defined.discard(name)
+                    references.pop(name, None)
+        else:
+            for name in _defined_names(node):
+                defined.add(name)
+                imported.pop(name, None)
+                references[name] = tuple(_dotted_names(node))
+    return Namespace(module, imported, frozenset(defined), references)
+
+
+def resolve_export(
+    module: str, name: str, load: Loader
+) -> tuple[str, str | None] | None:
+    """The module defining ``module.name`` and its name there.
+
+    ``(submodule, None)`` when the name is a module itself; None for names outside
+    the loader's modules, star imports, and chains that cycle or run too long.
+    """
+    seen: set[tuple[str, str]] = set()
+    while len(seen) < MAX_HOPS and (module, name) not in seen:
+        seen.add((module, name))
+        namespace = load(module)
+        if namespace is None:
+            return None
+        if name in namespace.defined:
+            return module, name
+        target = namespace.imported.get(name) or f"{module}.{name}"
+        if load(target) is not None:
+            return target, None
+        if target == f"{module}.{name}":
+            return None
+        module, _, name = target.rpartition(".")
+        if not module:
+            return None
+    return None
+
+
+def resolve_dotted(qualified: str, load: Loader) -> tuple[str, str | None] | None:
+    """Like :func:`resolve_export` for a dotted name such as ``app.billing.Invoice``.
+
+    The longest module prefix short of the last segment is imported as a module;
+    the remaining segments are attributes, as in ``from app.billing import
+    Invoice``, so a facade binding wins over a submodule of the same name. Access
+    on anything but a module stops at that object, which is where it is defined.
+    """
+    parts = qualified.split(".")
+    end = next(
+        (
+            end
+            for end in range(len(parts) - 1, 0, -1)
+            if load(".".join(parts[:end])) is not None
+        ),
+        None,
+    )
+    if end is None:
+        return (qualified, None) if load(qualified) is not None else None
+    current: tuple[str, str | None] | None = (".".join(parts[:end]), None)
+    for attribute in parts[end:]:
+        if current is None or current[1] is not None:
+            break
+        current = resolve_export(current[0], attribute, load)
+    return current
+
+
+def _top_level(body: list[ast.stmt]) -> Iterator[ast.stmt]:
+    """Statements at module level, including those under ``if`` and ``try``."""
+    for node in body:
+        if isinstance(node, ast.If):
+            yield from _top_level(node.body)
+            yield from _top_level(node.orelse)
+        elif isinstance(node, ast.Try):
+            for block in (node.body, node.orelse, node.finalbody):
+                yield from _top_level(block)
+            for handler in node.handlers:
+                yield from _top_level(handler.body)
+        else:
+            yield node
+
+
+def _defined_names(node: ast.stmt) -> list[str]:
+    if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+        return [node.name]
+    targets: list[ast.expr] = []
+    if isinstance(node, ast.Assign):
+        targets = node.targets
+    elif isinstance(node, ast.AnnAssign | ast.AugAssign):
+        targets = [node.target]
+    elif isinstance(node, ast.TypeAlias):
+        targets = [node.name]
+    return [
+        name.id
+        for target in targets
+        for name in ast.walk(target)
+        if isinstance(name, ast.Name)
+    ]
+
+
+def _dotted_names(node: ast.stmt) -> Iterator[tuple[str, ...]]:
+    """``chat.feature`` -> ``("chat", "feature")`` for every name the value reads."""
+    for child in ast.walk(node):
+        if isinstance(child, ast.Attribute):
+            parts: list[str] = []
+            current: ast.expr = child
+            while isinstance(current, ast.Attribute):
+                parts.append(current.attr)
+                current = current.value
+            if isinstance(current, ast.Name):
+                yield (current.id, *reversed(parts))
+        elif isinstance(child, ast.Name) and isinstance(child.ctx, ast.Load):
+            yield (child.id,)

{smelt_cli-0.1.2 → smelt_cli-0.1.3}/smelt/analysis/syntax.py

@@ -4,6 +4,7 @@ import ast
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from smelt.analysis.exports import Namespace, namespace_of
 from smelt.analysis.parsing import AstCache, resolve_relative
 
 if TYPE_CHECKING:
@@ -25,6 +26,7 @@ class SyntaxIndex:
         self.files = files
         self._asts = asts
         self._by_path: dict[str, ModuleSyntax] = {}
+        self._namespaces: dict[str, Namespace | None] = {}
 
     def for_path(self, path: str) -> ModuleSyntax | None:
         cached = self._by_path.get(path)
@@ -43,6 +45,21 @@ class SyntaxIndex:
         self._by_path[path] = syntax
         return syntax
 
+    def namespace(self, module: str) -> Namespace | None:
+        """The top-level names of a source module; a loader for ``analysis.exports``."""
+        if module not in self._namespaces:
+            source = self.files.sources.get(module)
+            self._namespaces[module] = (
+                None
+                if source is None
+                else namespace_of(
+                    self._asts.parse(source.path),
+                    module,
+                    is_package=source.is_package,
+                )
+            )
+        return self._namespaces[module]
+
 
 def _collect_bindings(syntax: ModuleSyntax) -> None:
     for node in ast.walk(syntax.tree):

{smelt_cli-0.1.2 → smelt_cli-0.1.3}/smelt/cli/app.py

@@ -61,9 +61,13 @@ def build_parser() -> argparse.ArgumentParser:
 
 
 def _allow_local_config(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument(
-        "--config", metavar="PATH", default=argparse.SUPPRESS, help="path to smelt.yaml"
-    )
+    if "--config" not in parser._option_string_actions:
+        parser.add_argument(
+            "--config",
+            metavar="PATH",
+            default=argparse.SUPPRESS,
+            help="path to smelt.yaml",
+        )
     for action in parser._actions:
         if isinstance(action, argparse._SubParsersAction):
             for child in action.choices.values():
@@ -131,7 +135,15 @@ def _add_discovery(sub: Subparsers) -> None:
 
 def _add_maintenance(sub: Subparsers) -> None:
     init = sub.add_parser("init", help="write a starter smelt.yaml")
-    init.add_argument("--force", action="store_true", help="overwrite an existing file")
+    init.add_argument(
+        "--config",
+        metavar="PATH",
+        default=argparse.SUPPRESS,
+        help="write the config here (default: smelt.yaml); its directory is the project root",
+    )
+    init.add_argument(
+        "--force", action="store_true", help="overwrite the target if it exists"
+    )
     init.set_defaults(handler=commands.init)
 
     debt = sub.add_parser("debt", help="record current violations as known debt")

{smelt_cli-0.1.2 → smelt_cli-0.1.3}/smelt/cli/commands/adopt.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from smelt.analysis.parsing import AnalysisError
@@ -12,37 +13,65 @@ from smelt.engine.inference import infer_config, render_config
 
 if TYPE_CHECKING:
     import argparse
-    from pathlib import Path
 
     from smelt.engine.inference import InferredConfig
+    from smelt.engine.workspace import WorkspaceMember
 
 
 def init(args: argparse.Namespace, console: Console, cwd: Path) -> int:
-    existing = [cwd / name for name in CONFIG_FILENAMES if (cwd / name).exists()]
-    if existing and not args.force:
-        msg = f"{existing[0].name} already exists (use --force to overwrite)"
-        raise CliError(msg)
-    inferred = infer_config(cwd)
+    custom: str | None = args.config
+    target, shown = _init_target(custom, cwd)
+    if target.is_dir():
+        msg = f"{shown} is a directory; pass the path of the config file to write"
+        raise CliError(msg, option="--config", value=custom)
+    if target.exists() and not args.force:
+        msg = f"{shown} already exists (use --force to overwrite)"
+        raise CliError(msg, option="--config" if custom else None, value=custom)
+    root = target.parent
+    if not root.is_dir():
+        msg = (
+            f"directory {root} does not exist; it would be the project root of {shown}"
+        )
+        raise CliError(msg, option="--config", value=custom)
+    inferred = infer_config(root)
     if inferred is None:
         msg = (
             "no Python package found in this directory, src/, or declared uv workspace members; "
             "run `smelt init` from the project root or configure source_roots manually"
         )
         raise CliError(msg)
-    target = cwd / CONFIG_FILENAME
-    for path in existing:
-        if path != target:
-            path.unlink()
     target.write_text(render_config(inferred), encoding="utf-8", newline="\n")
-    console.print(f"Wrote {CONFIG_FILENAME}")
+    console.print(f"Wrote {shown}")
     for line in _summary(inferred):
         console.print(f"  {line}")
     console.print(_violation_summary(target))
+    if target.name not in CONFIG_FILENAMES:
+        console.print(
+            f"smelt only finds {' or '.join(CONFIG_FILENAMES)} on its own; "
+            f"pass --config {shown} to every command."
+        )
     return EXIT_OK
 
 
+def _init_target(custom: str | None, cwd: Path) -> tuple[Path, str]:
+    """The one file ``init`` writes: ``--config``, else the default config here.
+
+    Only that file is checked and overwritten; a reviewed config elsewhere stays.
+    Without ``--config`` an existing ``smelt.yml`` is the target, not a second file.
+    """
+    if custom is not None:
+        path = Path(custom)
+        return (path if path.is_absolute() else cwd / path), custom
+    existing = next((name for name in CONFIG_FILENAMES if (cwd / name).exists()), None)
+    name = existing or CONFIG_FILENAME
+    return cwd / name, name
+
+
 def _summary(inferred: InferredConfig) -> list[str]:
     lines = [f"root packages: {', '.join(inferred.root_packages)}"]
+    if inferred.members:
+        lines.append("workspace members:")
+        lines.extend(f"  {_member_status(member)}" for member in inferred.members)
     lines.append(
         "boundary coverage: direct imports only; third-party packages allowed (review layers.*.third_party and imports.transitive)"
     )
@@ -57,10 +86,7 @@ def _summary(inferred: InferredConfig) -> list[str]:
         lines.append("layers: none detected (see the commented example)")
     if inferred.shared:
         lines.append(f"shared: {', '.join(inferred.shared)}")
-    if inferred.composition_root:
-        lines.append(f"composition root: {', '.join(inferred.composition_root)}")
-    if inferred.wiring:
-        lines.append(f"wiring: {', '.join(inferred.wiring)}")
+    lines.extend(_assembly_summary(inferred))
     if inferred.modules:
         lines.append(
             "central modules: "
@@ -91,6 +117,38 @@ def _summary(inferred: InferredConfig) -> list[str]:
     return lines
 
 
+def _assembly_summary(inferred: InferredConfig) -> list[str]:
+    lines: list[str] = []
+    if inferred.composition_root:
+        lines.append(f"composition root: {', '.join(inferred.composition_root)}")
+    if inferred.wiring:
+        lines.append(f"wiring: {', '.join(inferred.wiring)}")
+    lines.extend(
+        f"  {module}: {why}"
+        for module, why in inferred.evidence.items()
+        if module in inferred.composition_root or module in inferred.wiring
+    )
+    if inferred.candidates:
+        lines.append(
+            "composition-root candidates (commented out in the config, review):"
+        )
+        lines.extend(
+            f"  {c.module} ({c.confidence} confidence, {c.reason}): {' → '.join(c.chain)}"
+            for c in inferred.candidates
+        )
+    return lines
+
+
+def _member_status(member: WorkspaceMember) -> str:
+    if member.skipped:
+        return f"{member.path}: skipped, {member.skipped}"
+    packages = ", ".join(
+        f"{name} (namespace package)" if name in member.namespace else name
+        for name in member.packages
+    )
+    return f"{member.path}: {packages} in {member.source_root}"
+
+
 def _violation_summary(path: Path) -> str:
     try:
         outcome = run_check(load_config(path), CheckOptions(use_debt=False))
@@ -103,7 +161,7 @@ def _violation_summary(path: Path) -> str:
         return "The inferred config yields no violations. Run `smelt check` any time."
     return (
         f"The inferred config yields {errors} error{'s' * (errors != 1)} and "
-        f"{warnings} warning{'s' * (warnings != 1)}. Review {CONFIG_FILENAME}, then run "
+        f"{warnings} warning{'s' * (warnings != 1)}. Review {path.name}, then run "
         "`smelt check`, or `smelt debt` to adopt incrementally."
     )