Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
fix(dead-code): serve every surface through one cross-repo read, and lower confidence only on a contract link (#4375)
Raghav Chamadiya6009a92dbb1d
diff --git a/docs/architecture/dead-code.md b/docs/architecture/dead-code.mdindex bf2277764..ee05cdf5b 100644--- a/docs/architecture/dead-code.md+++ b/docs/architecture/dead-code.md@@ -177,7 +177,9 @@ built from the `risk_factors.py` constants. The TypeScript mirror is`DEAD_CODE_CONFIDENCE` in `packages/types/src/dead-code.ts`, so CLI, web andMCP tier identically.-`adjust_cross_repo` runs after tiering in workspace mode: a file with-cross-repo co-change partners gets confidence `* 0.5` and a-`cross_repo_note`; otherwise an `unused_export` in a repo that other repos-depend on as a package gets `* 0.3`.+`serve_findings` is the one read the MCP tool, the REST routes and the CLI+share: it applies `cross_repo_cut` to each stored row, then the filters, and+tiering reads the result. A file another repo's contract link points at gets+confidence `* 0.3`. Cross-repo co-change partners, or an `unused_export` in a+repo other repos depend on as a package, keep the confidence. Each adds a+`cross_repo_note` and withdraws `safe_to_delete`.diff --git a/docs/layers/DEAD_CODE.md b/docs/layers/DEAD_CODE.mdindex 35b3e1635..1c3d57558 100644--- a/docs/layers/DEAD_CODE.md+++ b/docs/layers/DEAD_CODE.md@@ -77,11 +77,11 @@ finding's evidence saying why.| Medium | `0.4` to `0.7` | Likely unused, but something indirect may reach it. Review first. || Low | `< 0.4` | Plausibly used at runtime (dynamic loading, reflection, published API). Investigate first. |-The CLI, the dashboard and `get_dead_code` use the same tier floors. The-default `min_confidence` is `0.4` everywhere, which hides the low tier unless-you ask for it. In a workspace, only `get_dead_code` applies the-[cross-repo cut](#workspaces), after that floor, so it can place a finding in a-lower tier than the CLI and dashboard do, including below `0.4`.+The dead-code lists and summaries of the CLI, the dashboard and+`get_dead_code` use the same tier floors and the same+[cross-repo cut](#workspaces), so a finding lands in the same tier on each.+The default `min_confidence` is `0.4` everywhere, which hides the low tier+unless you ask for it.### `safe_to_delete`@@ -171,24 +171,25 @@ deleting anything.## WorkspacesIn a workspace, a file dead inside its own repo may be the surface another repo-depends on. `get_dead_code` checks each finding against the cross-repo data-before returning it:--- If the file changes together with files in other repos (git co-change),- confidence is halved and the finding gains a `cross_repo_note` naming those- repos.-- Otherwise, if the finding is an unused export and another repo depends on- this one as a package, confidence is cut to 30% of its value with a note to- verify consumers. The note names a dependent only when its package link- covers the file's package (or records no manifest) or its contract link (an- HTTP route, a generated client) points at the file. The cut applies either way, because package links- can miss a consumer.--The adjustment runs before tiering, so a lowered finding sits in the tier its-new confidence names and is never safe to delete. `repo="all"` merges every workspace-repo and tags each finding with its alias. The CLI has no cross-repo pass:-`--repo <alias>` analyzes one repo in isolation (the primary repo by default).-See [WORKSPACES.md](../scale/WORKSPACES.md) for how cross-repo data is built.+depends on. The CLI, the dashboard and `get_dead_code` check each finding+against the cross-repo data before the confidence floor and the tiers:++- If another repo's contract link (an HTTP route, a generated client) points+ at the file, confidence is cut to 30% of its value and the `cross_repo_note`+ names the consumer.+- Otherwise, if the file changes together with files in other repos (git+ co-change), or the finding is an unused export and another repo depends on+ this one as a package, the finding keeps its confidence and gains a note.+ The note names a package dependent only when its link covers the file's+ package (or records no manifest). These links say a consumer may exist, not+ that one does.++A finding with a note is never safe to delete, and a lowered one sits in the+tier its new confidence names, so one cut below `0.4` is hidden by the default+floor. The dashboard adds the note to the finding's evidence. `repo="all"` merges every+workspace repo and tags each finding with its alias. The CLI analyzes one repo+per run (the primary repo unless `--repo <alias>`), and `--no-workspace` skips+the cut. See [WORKSPACES.md](../scale/WORKSPACES.md) for how cross-repo data is built.## Accuracy and limitsdiff --git a/docs/reference/MCP_RESPONSE_FIELDS.md b/docs/reference/MCP_RESPONSE_FIELDS.mdindex 74d17920a..85f9b2ca5 100644--- a/docs/reference/MCP_RESPONSE_FIELDS.md+++ b/docs/reference/MCP_RESPONSE_FIELDS.md@@ -701,7 +701,7 @@ Per-file `covered_line_count`, `total_coverable_lines` (targeted adds `covered_l| `limit_note` | A `limit` over 25 was clamped |- No language is gated; dead code on Java, C#, C, C++, Kotlin and Swift is preview, labelled in `_meta.preview`.-- Workspace mode lowers confidence on findings another repo imports.+- In workspace mode a finding another repo may use is never `safe_to_delete`, and a contract link to its file also lowers its confidence.- The 0.7 and 0.4 floors are shared by the CLI, web UI and this tool. See [DEAD_CODE.md](../layers/DEAD_CODE.md).---diff --git a/packages/cli/src/repowise/cli/commands/dead_code_cmd.py b/packages/cli/src/repowise/cli/commands/dead_code_cmd.pyindex 5701d6396..defa41a22 100644--- a/packages/cli/src/repowise/cli/commands/dead_code_cmd.py+++ b/packages/cli/src/repowise/cli/commands/dead_code_cmd.py@@ -3,6 +3,7 @@from __future__ import annotationsimport json+from dataclasses import replacefrom pathlib import Pathfrom typing import Any@@ -22,7 +23,13 @@ from repowise.cli.helpers import (from repowise.cli.output import notice_consolefrom repowise.core.analysis.dead_code.models import DeadCodeFindingData, DeadCodeReportfrom repowise.core.analysis.dead_code.risk_factors import RISK_CAP_CONFIDENCE-from repowise.core.analysis.dead_code.serving import safe_only_note+from repowise.core.analysis.dead_code.serving import (+ CrossRepoLookup,+ ServedFinding,+ is_safe,+ safe_only_note,+ serve_findings,+)from repowise.core.analysis.finding_registry import preview_lines#: The floor ``init`` and ``update`` store findings at: they run the analyzer@@ -149,6 +156,56 @@ def _analyze_live(repo_path: Path, config: dict, notices: Any) -> DeadCodeReportreturn analyzer.analyze(config)+def _cross_repo_inputs(+ target: Any, repo_path: Path, no_workspace: bool+) -> tuple[CrossRepoLookup | None, str | None]:+ """The workspace data and alias the cross-repo cut reads for *repo_path*."""+ if no_workspace or target.ws_root is None:+ return None, None+ from repowise.core.workspace.config import WorkspaceConfig++ ws_config = target.ws_config or WorkspaceConfig.load(target.ws_root)+ resolved = repo_path.resolve()+ alias = next(+ (e.alias for e in ws_config.repos if (target.ws_root / e.path).resolve() == resolved),+ None,+ )+ if alias is None:+ return None, None+ from repowise.server.mcp_server._enrichment import CrossRepoEnricher++ return CrossRepoEnricher.for_workspace(target.ws_root), alias+++def _with_cut(served: ServedFinding) -> DeadCodeFindingData:+ if served.cross_repo_note is None:+ return served.row+ return replace(+ served.row,+ confidence=served.confidence,+ safe_to_delete=is_safe(served),+ evidence=[*served.row.evidence, served.cross_repo_note],+ )+++def _cut_cross_repo(+ report: DeadCodeReport, lookup: CrossRepoLookup | None, alias: str | None, floor: float+) -> tuple[DeadCodeReport, int]:+ """The cross-repo cut every surface applies, then the floor again, since it only lowers.++ Returns the report and how many findings the cut touched.+ """+ if lookup is None:+ return report, 0+ served = serve_findings(report.findings, lookup, alias)+ cut = [_with_cut(s) for s in served]+ shown = [f for f in cut if f.confidence >= floor]+ touched = sum(1 for s in served if s.cross_repo_note)+ return DeadCodeReport.from_findings(+ shown, hidden_below_threshold=report.hidden_below_threshold + len(cut) - len(shown)+ ), touched++@click.command("dead-code")@click.argument("path", required=False, type=click.Path(exists=True))@click.option(@@ -238,8 +295,9 @@ def dead_code_command(with no index, it parses the working tree and analyzes it live.In workspace mode, analyzes the primary repo by default; pass- --repo <alias> to target a different repo. Cross-repo dead-code- detection is not yet supported — run once per repo for now.+ --repo <alias> to target a different repo. A finding whose file another+ workspace repo may use is never cleanup-ready, with the same confidence as+ on every other surface. Run once per repo."""# The live path parses the whole tree, and its structlog lines go to# stdout: they would corrupt JSON/Markdown and bury the table.@@ -294,6 +352,14 @@ def dead_code_command(report = _analyze_live(repo_path, config, notices)else:_notice_stored(repo_path, notices)+ report, touched = _cut_cross_repo(+ report, *_cross_repo_inputs(target, repo_path, no_workspace), min_confidence+ )+ if touched:+ notices.print(+ f"[dim]{touched} finding(s) not cleanup-ready: another workspace repo may use "+ "their file.[/dim]"+ )findings = sorted(report.findings, key=_finding_order)if safe_only:diff --git a/packages/core/src/repowise/core/analysis/dead_code/serving.py b/packages/core/src/repowise/core/analysis/dead_code/serving.pyindex 91d978667..20948f611 100644--- a/packages/core/src/repowise/core/analysis/dead_code/serving.py+++ b/packages/core/src/repowise/core/analysis/dead_code/serving.py@@ -9,7 +9,7 @@ from __future__ import annotationsimport jsonimport posixpath-from collections.abc import Callable+from collections.abc import Callable, Mappingfrom dataclasses import dataclassfrom dataclasses import field as dataclass_fieldfrom typing import Any, Protocol@@ -179,18 +179,16 @@ def apply_filters(findings: list, filters: FindingFilters) -> list:return [f for f in findings if all(check(f) for check in checks)]-def summary_counts(- shown: list, withdrawn: Callable[[Any], bool] | None = None-) -> dict[str, Any]:+def summary_counts(shown: list) -> dict[str, Any]:"""Counts over every shown open finding; merge per-repo parts with:func:`merge_summary_counts` so no caller holds every repo's rows at once.- *withdrawn* (see :func:`cross_repo_withdraws`) keeps safe counts in step with the tiers.+ Pass :func:`serve_findings` rows so safe counts agree with the tiers."""by_kind: dict[str, int] = {}for f in shown:kind = field(f, "kind")by_kind[kind] = by_kind.get(kind, 0) + 1- safe = [f for f in shown if is_safe(f) and not (withdrawn and withdrawn(f))]+ safe = [f for f in shown if is_safe(f)]return {"total_findings": len(shown),"deletable_lines": sum(field(f, "lines") or 0 for f in safe),@@ -332,6 +330,9 @@ def serialize_finding(label = verification_label(result["kind"])if label:result["verification"] = label+ note = field(f, "cross_repo_note")+ if note:+ result["cross_repo_note"] = noteif git_meta_map:meaningful = last_meaningful_change(git_meta_map.get(result["file_path"]))if meaningful:@@ -339,7 +340,8 @@ def serialize_finding(return result-def _tier_of(confidence: float) -> str:+def tier_of(confidence: float) -> str:+ """The tier *confidence* falls in, by :data:`TIER_FLOORS`."""if confidence >= TIER_FLOORS["high"]:return "high"if confidence >= TIER_FLOORS["medium"]:@@ -361,7 +363,7 @@ def build_tiers("""banded: dict[str, list[dict]] = {"high": [], "medium": [], "low": []}for f in findings:- banded[_tier_of(f["confidence"])].append(f)+ banded[tier_of(f["confidence"])].append(f)tiers: dict[str, Any] = {}for name, items in banded.items():@@ -449,7 +451,7 @@ def _recommendation(tiers: dict) -> str:class CrossRepoLookup(Protocol):- """What :func:`adjust_cross_repo` needs from the workspace's cross-repo data."""+ """What :func:`serve_findings` needs from the workspace's cross-repo data."""def has_cross_repo_consumers(self, repo_alias: str, file_path: str) -> list[dict]: ...@@ -460,77 +462,127 @@ class CrossRepoLookup(Protocol):def get_contract_links_as_provider(self, repo_alias: str, file_path: str) -> list[dict]: ...-def cross_repo_withdraws(- lookup: CrossRepoLookup | None, alias: str | None, file_path: str, kind: Any-) -> bool:- """Whether :func:`adjust_cross_repo` would withdraw ``safe_to_delete``."""- if lookup is None or not alias:- return False- if lookup.has_cross_repo_consumers(alias, file_path):- return True- return kind == "unused_export" and bool(lookup.get_repos_depending_on(alias))+@dataclass(frozen=True)+class CrossRepoCut:+ """What another repo's use does to a finding: never safe, maybe lower, and why."""+ factor: float+ note: str-def adjust_cross_repo(- findings: list[dict], lookup: CrossRepoLookup | None, repo_alias: str | None = None-) -> None:- """Lower confidence on serialized findings that other repos consume, in place.- Runs before :func:`build_tiers`, so a lowered finding lands in the tier its- new confidence belongs to. A finding's own ``repo`` wins over *repo_alias*,- so one call covers both a single repo and the workspace-wide merge.+# A contract link names the file another repo calls; co-change and package+# links only say a consumer may exist, so they withdraw safety and leave the+# confidence alone. Measured on a three-repo workspace: 7 of 7 findings those+# weaker links had cut had no consumer in another repo.+_CONTRACT_FACTOR = 0.3+++def cross_repo_cut(+ lookup: CrossRepoLookup | None, alias: str | None, file_path: str, kind: Any+) -> CrossRepoCut | None:+ """What another workspace repo's use of *file_path* does to its finding, or None.++ A contract link (HTTP route, generated client) from another repo lowers+ confidence for every kind. Co-change partners in another repo, or a+ package dependent of an export's repo, only withdraw ``safe_to_delete``."""- if lookup is None:- return- for finding in findings:- alias = finding.get("repo", repo_alias)- if alias:- _adjust_one(finding, lookup, alias)---def _adjust_one(finding: dict, lookup: CrossRepoLookup, alias: str) -> None:- consumers = lookup.has_cross_repo_consumers(alias, finding.get("file_path", ""))- if consumers:- finding["confidence"] = round(finding["confidence"] * 0.5, 2)- finding["safe_to_delete"] = False- consumer_repos = sorted({c["repo"] for c in consumers})- finding["cross_repo_note"] = (- f"Confidence reduced: {len(consumers)} cross-repo consumer(s) "- f"in {', '.join(consumer_repos)}."+ if lookup is None or not alias:+ return None+ if contract_repos := _contract_consumers(lookup, alias, file_path):+ noun = "export" if kind == "unused_export" else "file"+ return CrossRepoCut(+ _CONTRACT_FACTOR,+ f"This {noun} may be consumed by: {', '.join(sorted(contract_repos))}. "+ "Verify before deletion.",)- return- # Package-level dependents may consume an export without a file edge.- if finding.get("kind") != "unused_export":- return- if lookup.get_repos_depending_on(alias):- finding["confidence"] = round(finding["confidence"] * 0.3, 2)- finding["safe_to_delete"] = False- finding["cross_repo_note"] = _package_dependent_note(- lookup, alias, finding.get("file_path", "")+ if partners := lookup.has_cross_repo_consumers(alias, file_path):+ repos = sorted({c["repo"] for c in partners})+ return CrossRepoCut(+ 1.0,+ f"Not cleanup-ready: changes together with {len(partners)} file(s) in "+ f"{', '.join(repos)}. Verify before deletion.",)+ if kind == "unused_export" and lookup.get_repos_depending_on(alias):+ return CrossRepoCut(1.0, _package_dependent_note(lookup, alias, file_path))+ return None-def _package_dependent_note(lookup: CrossRepoLookup, alias: str, file_path: str) -> str:- """Name only the dependents whose recorded link reaches *file_path*.+class ServedFinding:+ """A stored finding as every surface shows it: the cross-repo cut applied.- The cut itself stays repo-wide: package links miss consumers (an- unresolved PyPI pin, a CLI call), so they can name a consumer but never- prove there is none.+ Reads through to the row for every other field, so filters, serializers+ and response models take it wherever they take the row."""- reaching = {++ __slots__ = ("confidence", "cross_repo_note", "row", "safe_to_delete")++ def __init__(self, row: Any, cut: CrossRepoCut | None) -> None:+ self.row = row+ self.confidence = field(row, "confidence")+ self.safe_to_delete = field(row, "safe_to_delete")+ self.cross_repo_note = None+ if cut is not None:+ if cut.factor != 1.0:+ self.confidence = round(self.confidence * cut.factor, 2)+ self.safe_to_delete = False+ self.cross_repo_note = cut.note++ def __getattr__(self, name: str) -> Any:+ row = object.__getattribute__(self, "row")+ if isinstance(row, Mapping):+ try:+ return row[name]+ except KeyError:+ raise AttributeError(name) from None+ return getattr(row, name)+++def serve_findings(+ rows: list,+ lookup: CrossRepoLookup | None,+ alias: str | None,+ filters: FindingFilters | None = None,+) -> list[ServedFinding]:+ """The one read every surface serves findings through.++ The cross-repo cut runs first, so the confidence floor, ``safe_only`` and+ the tiers all see the confidence the finding is shown with (#4196).+ """+ served = [+ ServedFinding(r, cross_repo_cut(lookup, alias, field(r, "file_path"), field(r, "kind")))+ for r in rows+ ]+ return apply_filters(served, filters) if filters is not None else served+++def _contract_consumers(lookup: CrossRepoLookup, alias: str, file_path: str) -> set[str]:+ """The other repos a recorded contract link from *file_path* reaches."""+ return {link["consumer_repo"]for link in lookup.get_contract_links_as_provider(alias, file_path)if link.get("consumer_repo") not in (None, alias)}- reaching.update(+++def _package_dependent_note(lookup: CrossRepoLookup, alias: str, file_path: str) -> str:+ """Name only the dependents whose package link reaches *file_path*.++ Safety is withdrawn either way: package links miss consumers (an+ unresolved PyPI pin, a CLI call), so they can name a consumer but never+ prove there is none.+ """+ reaching = {link["source_repo"]for link in lookup.get_package_consumers(alias)if _inside_manifest(file_path, link.get("target_manifest"))- )+ }if reaching:- return f"This export may be consumed by: {', '.join(sorted(reaching))}. Verify before deletion."+ return (+ f"Not cleanup-ready: {', '.join(sorted(reaching))} may consume this export. "+ "Verify before deletion."+ )return (- "Confidence lowered: another workspace repo depends on this one, though no recorded "+ "Not cleanup-ready: another workspace repo depends on this one, though no recorded ""package or contract link reaches this file. Verify before deletion.")diff --git a/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.py b/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.pyindex 90f0f4593..f59463419 100644--- a/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.py+++ b/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.py@@ -11,10 +11,12 @@ from sqlalchemy.ext.asyncio import AsyncSessionfrom repowise.core.analysis.dead_code.deletion_gate import effective_safe_to_deletefrom repowise.core.analysis.dead_code.models import DeadCodeFindingData, DeadCodeKind-from repowise.core.analysis.dead_code.risk_factors import (- RISK_CAP_CONFIDENCE,- SAFE_CONFIDENCE_THRESHOLD,- path_risk_factors,+from repowise.core.analysis.dead_code.risk_factors import path_risk_factors+from repowise.core.analysis.dead_code.serving import (+ CrossRepoLookup,+ is_safe,+ serve_findings,+ tier_of,)from repowise.core.analysis.finding_registry import excluded_types@@ -306,11 +308,18 @@ async def update_dead_code_status(async def get_dead_code_summary(- session: AsyncSession, repository_id: str, *, include_unverified: bool = False+ session: AsyncSession,+ repository_id: str,+ *,+ include_unverified: bool = False,+ lookup: CrossRepoLookup | None = None,+ alias: str | None = None,) -> dict:"""Return aggregate dead code statistics over the findings a surface shows.``gated`` counts the open findings a language gate held back, by language.+ In a workspace, *lookup* and *alias* apply the cross-repo cut first, so the+ counts match the list (:func:`serve_findings`)."""scope = (DeadCodeFinding.repository_id == repository_id,@@ -328,7 +337,7 @@ async def get_dead_code_summary(),))- findings = list(result.scalars().all())+ findings = serve_findings(list(result.scalars().all()), lookup, alias)gated = await gated_counts(session,"dead_code",@@ -343,12 +352,7 @@ async def get_dead_code_summary(by_kind: dict[str, int] = {}for f in findings:- if f.confidence >= SAFE_CONFIDENCE_THRESHOLD:- summary["high"] += 1- elif f.confidence >= RISK_CAP_CONFIDENCE:- summary["medium"] += 1- else:- summary["low"] += 1+ summary[tier_of(f.confidence)] += 1total_lines += f.lines or 0by_kind[f.kind] = by_kind.get(f.kind, 0) + 1@@ -357,11 +361,7 @@ async def get_dead_code_summary(# risk-factor logic existed (or in a config/bootstrap/database/environment# file the allowlist missed) are not counted as deletion-ready.# Totals sum the known counts; an unknown (NULL) count adds nothing.- deletable = [- f- for f in findings- if effective_safe_to_delete(f.confidence, f.file_path, f.safe_to_delete, f.kind)- ]+ deletable = [f for f in findings if is_safe(f)]deletable_lines = sum(f.lines or 0 for f in deletable)return {diff --git a/packages/server/src/repowise/server/deps.py b/packages/server/src/repowise/server/deps.pyindex 96ea189ec..1039abd51 100644--- a/packages/server/src/repowise/server/deps.py+++ b/packages/server/src/repowise/server/deps.py@@ -13,6 +13,7 @@ import ipaddressimport loggingimport osfrom collections.abc import AsyncGenerator+from pathlib import Pathfrom fastapi import HTTPException, Request, Securityfrom fastapi.security import APIKeyHeader, SecurityScopes@@ -104,6 +105,19 @@ async def get_cross_repo_enricher(request: Request):return getattr(request.app.state, "cross_repo_enricher", None)+def workspace_alias_for(app_state, repo_id: str) -> str | None:+ """The workspace alias of the member stored as ``repo_id``; None outside a workspace."""+ ws_config = getattr(app_state, "workspace_config", None)+ ws_root = getattr(app_state, "workspace_root", None)+ path_to_id = getattr(app_state, "workspace_path_to_repo_id", None) or {}+ if ws_config is None or ws_root is None:+ return None+ for entry in ws_config.repos:+ if path_to_id.get(str((Path(ws_root) / entry.path).resolve())) == repo_id:+ return entry.alias+ return None++def client_is_local(request: Request) -> bool:"""True when the request's peer address is a loopback address.diff --git a/packages/server/src/repowise/server/mcp_server/_enrichment.py b/packages/server/src/repowise/server/mcp_server/_enrichment.pyindex bf225135b..fa395e7ae 100644--- a/packages/server/src/repowise/server/mcp_server/_enrichment.py+++ b/packages/server/src/repowise/server/mcp_server/_enrichment.py@@ -133,6 +133,24 @@ class CrossRepoEnricher:# update. Read-only.self._conformance: dict | None = None+ @classmethod+ def for_workspace(cls, ws_root: Path) -> CrossRepoEnricher:+ """The enricher over every artifact a workspace update wrote under *ws_root*."""+ from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME+ from repowise.core.workspace.config import WORKSPACE_DATA_DIR+ from repowise.core.workspace.conformance import CONFORMANCE_FILENAME+ from repowise.core.workspace.contracts import CONTRACTS_FILENAME+ from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAME++ data_dir = Path(ws_root) / WORKSPACE_DATA_DIR+ return cls(+ data_dir / "cross_repo_edges.json",+ contracts_path=data_dir / CONTRACTS_FILENAME,+ system_graph_path=data_dir / SYSTEM_GRAPH_FILENAME,+ breaking_changes_path=data_dir / BREAKING_CHANGES_FILENAME,+ conformance_path=data_dir / CONFORMANCE_FILENAME,+ )+@classmethoddef from_data(cls,diff --git a/packages/server/src/repowise/server/mcp_server/_server.py b/packages/server/src/repowise/server/mcp_server/_server.pyindex 47af2e4cd..0777ab783 100644--- a/packages/server/src/repowise/server/mcp_server/_server.py+++ b/packages/server/src/repowise/server/mcp_server/_server.py@@ -483,26 +483,10 @@ async def _lifespan(server: FastMCP):# Load cross-repo enricher (Phase 3 + 4)try:- from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME- from repowise.core.workspace.config import WORKSPACE_DATA_DIR- from repowise.core.workspace.conformance import CONFORMANCE_FILENAME- from repowise.core.workspace.contracts import CONTRACTS_FILENAME- from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAMEfrom repowise.server.mcp_server._enrichment import CrossRepoEnricher- cross_repo_path = ws_root / WORKSPACE_DATA_DIR / "cross_repo_edges.json"- contracts_path = ws_root / WORKSPACE_DATA_DIR / CONTRACTS_FILENAME- system_graph_path = ws_root / WORKSPACE_DATA_DIR / SYSTEM_GRAPH_FILENAME- breaking_changes_path = ws_root / WORKSPACE_DATA_DIR / BREAKING_CHANGES_FILENAME- conformance_path = ws_root / WORKSPACE_DATA_DIR / CONFORMANCE_FILENAME- enricher = CrossRepoEnricher(- cross_repo_path,- contracts_path=contracts_path,- system_graph_path=system_graph_path,- breaking_changes_path=breaking_changes_path,- conformance_path=conformance_path,- )- if enricher.has_data or enricher.has_system_graph:+ enricher = CrossRepoEnricher.for_workspace(ws_root)+ if enricher.has_data or enricher.has_contract_data or enricher.has_system_graph:_state._cross_repo_enricher = enricher_log.info("Cross-repo enricher loaded: %d co-change edges, %d package deps, %d contract links",diff --git a/packages/server/src/repowise/server/mcp_server/tool_dead_code.py b/packages/server/src/repowise/server/mcp_server/tool_dead_code.pyindex 883ca399b..244e75295 100644--- a/packages/server/src/repowise/server/mcp_server/tool_dead_code.py+++ b/packages/server/src/repowise/server/mcp_server/tool_dead_code.py@@ -14,22 +14,20 @@ from repowise.core.analysis.dead_code.serving import (TIER_FLOORS,CrossRepoLookup,FindingFilters,- adjust_cross_repo,apply_filters,build_summary,build_tiers,compute_impact,- cross_repo_withdraws,dead_code_finding_id,excluded_kinds,merge_summary_counts,rollup_by_directory,rollup_by_owner,serialize_finding,+ serve_findings,summary_counts,)from repowise.core.analysis.finding_registry import excluded_types, served_previews-from repowise.core.analysis.health.rows import fieldfrom repowise.core.persistence.crud import get_dead_code_findingsfrom repowise.core.persistence.database import get_sessionfrom repowise.core.persistence.models import GitMetadata@@ -52,29 +50,8 @@ from repowise.server.mcp_server._meta import build_meta as _build_metadef _cross_repo_lookup() -> CrossRepoLookup | None:- """The workspace's cross-repo data, when there is any to adjust by."""- enricher = _state._cross_repo_enricher- if enricher is None or not enricher.has_data or not _is_workspace_mode():- return None- return enricher---def _adjust_cross_repo(- findings: list[dict], filters: FindingFilters, repo_alias: str | None-) -> list[dict]:- """The cross-repo cut, then ``safe_only`` again, since the cut withdraws safety."""- adjust_cross_repo(findings, _cross_repo_lookup(), repo_alias)- if filters.safe_only:- return [f for f in findings if f["safe_to_delete"]]- return findings---def _withdrawn_by(repo_alias: str | None) -> Callable[[Any], bool] | None:- """The cross-repo cut as a predicate over stored rows, for the summary."""- lookup = _cross_repo_lookup()- if lookup is None or not repo_alias:- return None- return lambda f: cross_repo_withdraws(lookup, repo_alias, field(f, "file_path"), field(f, "kind"))+ """The workspace's cross-repo data; an empty artifact simply cuts nothing."""+ return _state._cross_repo_enricher if _is_workspace_mode() else Noneasync def _get_dead_code_all_repos(@@ -96,11 +73,12 @@ async def _get_dead_code_all_repos(repo_findings, withheld = filters.split_withheld(repo_findings)repo_findings, gated = filters.split_gated(repo_findings)git_meta_map = await _load_git_meta_map(session, repository.id, repo_findings)+ served = serve_findings(repo_findings, _cross_repo_lookup(), ctx.alias)serialized = [serialize_finding(f, git_meta_map, repository=ctx.alias)- for f in apply_filters(repo_findings, filters)+ for f in apply_filters(served, filters)]- return serialized, summary_counts(repo_findings, _withdrawn_by(ctx.alias)), withheld, gated+ return serialized, summary_counts(served), withheld, gatedfed = Federation()answered = await fed.run(_one_repo)@@ -113,7 +91,6 @@ async def _get_dead_code_all_repos(merged = into.setdefault(name, {**entry, "count": 0})merged["count"] += entry["count"]- merged_findings = _adjust_cross_repo(merged_findings, filters, None)summary = build_summary(merge_summary_counts([part[1] for _, part in answered]),len(merged_findings),@@ -198,7 +175,7 @@ async def get_dead_code(Run before a cleanup sprint, not a targeted fix. Findings tierhigh/medium/low with per-directory and per-owner rollups; workspace- mode lowers confidence on findings other repos import.+ mode withdraws safety on findings other repos may use.Args:repo: usually omitted.@@ -317,11 +294,12 @@ async def get_dead_code(git_meta_map = await _load_git_meta_map(session, repository.id, every_shown_kind)reference_repository = ctx.alias or repository.name+ lookup = _cross_repo_lookup()if finding_id:match = next((row- for row in every_shown_kind+ for row in serve_findings(every_shown_kind, lookup, ctx.alias)if finding_id in {row.id, dead_code_finding_id(row, reference_repository)}),None,@@ -345,7 +323,8 @@ async def get_dead_code(),}- filtered = apply_filters(all_findings, filters)+ served = serve_findings(all_findings, lookup, ctx.alias)+ filtered = apply_filters(served, filters)serialized = [serialize_finding(f, git_meta_map, repository=reference_repository) for f in filtered]@@ -356,9 +335,8 @@ async def get_dead_code("\n".join(json.dumps(f, separators=(",", ":")) for f in beyond),)- serialized = _adjust_cross_repo(serialized, filters, ctx.alias)tiers = build_tiers(serialized, limit, tier, on_overflow=_keep_overflow)- counts = summary_counts(all_findings, _withdrawn_by(ctx.alias))+ counts = summary_counts(served)summary = build_summary(counts, len(serialized), filters, withheld, gated)result: dict[str, Any] = {"summary": summary, "tiers": tiers}diff --git a/packages/server/src/repowise/server/routers/dead_code.py b/packages/server/src/repowise/server/routers/dead_code.pyindex bdf64b1ef..9218cd239 100644--- a/packages/server/src/repowise/server/routers/dead_code.py+++ b/packages/server/src/repowise/server/routers/dead_code.py@@ -5,12 +5,12 @@ from __future__ import annotationsfrom fastapi import APIRouter, Depends, HTTPException, Query, Requestfrom sqlalchemy.ext.asyncio import AsyncSession-from repowise.core.analysis.dead_code.deletion_gate import effective_safe_to_deletefrom repowise.core.analysis.dead_code.risk_factors import (RISK_CAP_CONFIDENCE,)+from repowise.core.analysis.dead_code.serving import FindingFilters, ServedFinding, serve_findingsfrom repowise.core.persistence import crud-from repowise.server.deps import get_db_session, verify_api_key+from repowise.server.deps import get_db_session, verify_api_key, workspace_alias_forfrom repowise.server.routers._unverified import UnverifiedQueryfrom repowise.server.schemas import (DeadCodeAnalyzeResponse,@@ -26,12 +26,30 @@ router = APIRouter()+def _cross_repo(request: Request, repo_id: str) -> dict:+ """The cross-repo cut's inputs for *repo_id*; empty outside a workspace."""+ state = request.app.state+ return {+ "lookup": getattr(state, "cross_repo_enricher", None),+ "alias": workspace_alias_for(state, repo_id),+ }+++def _response(f: ServedFinding) -> DeadCodeFindingResponse:+ response = DeadCodeFindingResponse.from_orm(f)+ if f.cross_repo_note:+ # Evidence is the list the finding's signals already render from.+ response.evidence.append(f.cross_repo_note)+ return response++@router.get("/api/repos/{repo_id}/dead-code",response_model=list[DeadCodeFindingResponse],)async def list_dead_code(repo_id: str,+ request: Request,kind: str | None = Query(None, description="Filter by finding kind"),min_confidence: float = Query(RISK_CAP_CONFIDENCE, ge=0.0, le=1.0),status: str = Query("open"),@@ -41,7 +59,8 @@ async def list_dead_code(session: AsyncSession = Depends(get_db_session),) -> list[DeadCodeFindingResponse]:"""List dead code findings for a repository."""- findings = await crud.get_dead_code_findings(+ # The cut only lowers confidence, so the SQL floor keeps a superset.+ rows = await crud.get_dead_code_findings(session,repo_id,kind=kind,@@ -49,13 +68,12 @@ async def list_dead_code(status=status,include_unverified=include_unverified,)- if safe_only:- findings = [- f- for f in findings- if effective_safe_to_delete(f.confidence, f.file_path, f.safe_to_delete, f.kind)- ]- return [DeadCodeFindingResponse.from_orm(f) for f in findings[:limit]]+ filters = FindingFilters(+ kind=None, safe_only=safe_only, min_confidence=min_confidence, directory=None, owner=None+ )+ findings = serve_findings(rows, **_cross_repo(request, repo_id), filters=filters)+ findings.sort(key=lambda f: -f.confidence)+ return [_response(f) for f in findings[:limit]]@router.post(@@ -112,12 +130,13 @@ async def analyze_dead_code()async def dead_code_summary(repo_id: str,+ request: Request,include_unverified: bool = UnverifiedQuery,session: AsyncSession = Depends(get_db_session),) -> DeadCodeSummaryResponse:"""Get aggregate dead code statistics for a repository."""summary = await crud.get_dead_code_summary(- session, repo_id, include_unverified=include_unverified+ session, repo_id, include_unverified=include_unverified, **_cross_repo(request, repo_id))analyzed_at = await dead_code_analyzed_at(session, repo_id)return DeadCodeSummaryResponse(**summary, analyzed_at=analyzed_at)@@ -127,6 +146,7 @@ async def dead_code_summary(async def resolve_finding(finding_id: str,body: DeadCodePatchRequest,+ request: Request,session: AsyncSession = Depends(get_db_session),) -> DeadCodeFindingResponse:"""Update the status of a dead code finding."""@@ -140,4 +160,5 @@ async def resolve_finding(finding = await crud.update_dead_code_status(session, finding_id, body.status, body.note)if finding is None:raise HTTPException(status_code=404, detail="Finding not found")- return DeadCodeFindingResponse.from_orm(finding)+ repo_id = finding.repository_id+ return _response(serve_findings([finding], **_cross_repo(request, repo_id))[0])diff --git a/packages/server/src/repowise/server/workspace_startup.py b/packages/server/src/repowise/server/workspace_startup.pyindex bec55af38..3863dda09 100644--- a/packages/server/src/repowise/server/workspace_startup.py+++ b/packages/server/src/repowise/server/workspace_startup.py@@ -195,22 +195,10 @@ async def _reset_member_stale_jobs(app_state) -> None:def _publish_cross_repo_enricher(app_state, ws_config, ws_root: Path) -> None:- from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME- from repowise.core.workspace.config import WORKSPACE_DATA_DIR- from repowise.core.workspace.conformance import CONFORMANCE_FILENAME- from repowise.core.workspace.contracts import CONTRACTS_FILENAME- from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAMEfrom repowise.server.chat_tools import set_tool_workspacefrom repowise.server.mcp_server._enrichment import CrossRepoEnricher- data_dir = ws_root / WORKSPACE_DATA_DIR- enricher = CrossRepoEnricher(- data_dir / "cross_repo_edges.json",- contracts_path=data_dir / CONTRACTS_FILENAME,- system_graph_path=data_dir / SYSTEM_GRAPH_FILENAME,- breaking_changes_path=data_dir / BREAKING_CHANGES_FILENAME,- conformance_path=data_dir / CONFORMANCE_FILENAME,- )+ enricher = CrossRepoEnricher.for_workspace(ws_root)if enricher.has_data or enricher.has_contract_data or enricher.has_system_graph:app_state.cross_repo_enricher = enricherset_tool_workspace(cross_repo_enricher=enricher)diff --git a/tests/unit/cli/test_dead_code_stored.py b/tests/unit/cli/test_dead_code_stored.pyindex 02cdbfb89..dec33c2fd 100644--- a/tests/unit/cli/test_dead_code_stored.py+++ b/tests/unit/cli/test_dead_code_stored.py@@ -206,3 +206,47 @@ def test_footer_names_the_tier_counts_as_findings(indexed_repo, monkeypatch):assert "Cleanup-candidate lines:" in result.outputassert "findings by confidence: high 1" in result.outputassert "confidence)" not in result.output+++class _HttpConsumed:+ def has_cross_repo_consumers(self, repo_alias, file_path):+ return []++ def get_repos_depending_on(self, repo_alias):+ return []++ def get_package_consumers(self, repo_alias):+ return []++ def get_contract_links_as_provider(self, repo_alias, file_path):+ return [{"consumer_repo": "web"}]+++def test_a_workspace_consumer_lowers_the_stored_finding(indexed_repo, monkeypatch):+ analyze_live = dead_code_cmd._analyze_live+ monkeypatch.setattr(dead_code_cmd, "_analyze_live", None)+ monkeypatch.setattr(+ dead_code_cmd, "_cross_repo_inputs", lambda *_a: (_HttpConsumed(), "api")+ )+ # 0.9 * 0.3 = 0.27, under the default floor the other surfaces apply too.+ assert _json(indexed_repo) == []+ assert "1 finding(s) hidden below threshold" in _md(indexed_repo)+ # The live path takes the same cut.+ monkeypatch.setattr(dead_code_cmd, "_analyze_live", analyze_live)+ live = _json(indexed_repo, "--min-confidence", "0.0")+ assert live and all(f["confidence"] <= 0.3 and not f["safe_to_delete"] for f in live)+++def test_cross_repo_inputs_resolve_the_alias_and_honour_no_workspace(tmp_path, monkeypatch):+ from types import SimpleNamespace++ from repowise.server.mcp_server._enrichment import CrossRepoEnricher++ monkeypatch.setattr(CrossRepoEnricher, "for_workspace", classmethod(lambda cls, root: root))+ member = tmp_path / "api"+ target = SimpleNamespace(+ ws_root=tmp_path, ws_config=SimpleNamespace(repos=[SimpleNamespace(alias="api", path="api")])+ )+ assert dead_code_cmd._cross_repo_inputs(target, member, False) == (tmp_path, "api")+ assert dead_code_cmd._cross_repo_inputs(target, member, True) == (None, None)+ assert dead_code_cmd._cross_repo_inputs(target, tmp_path / "other", False) == (None, None)diff --git a/tests/unit/dead_code/test_serving.py b/tests/unit/dead_code/test_serving.pyindex 43bd67d3c..7781178e5 100644--- a/tests/unit/dead_code/test_serving.py+++ b/tests/unit/dead_code/test_serving.py@@ -15,20 +15,21 @@ from repowise.core.analysis.dead_code.serving import (SUMMARY_SCOPE,TIER_FLOORS,FindingFilters,- adjust_cross_repo,apply_filters,build_summary,build_tiers,compute_impact,- cross_repo_withdraws,+ cross_repo_cut,dead_code_finding_id,excluded_kinds,+ is_safe,last_meaningful_change,merge_summary_counts,rollup_by_directory,rollup_by_owner,safe_only_note,serialize_finding,+ serve_findings,summary_counts,)@@ -243,34 +244,64 @@ class _Lookup:return [{"consumer_repo": "web"}] if file_path == "src/a/two.py" else []-def test_adjust_cross_repo_lowers_consumed_findings() -> None:- findings = [serialize_finding(r) for r in _ROWS]- adjust_cross_repo(findings, _Lookup(), "api")- by_path = {f["file_path"]: f for f in findings}- assert by_path["src/a/one.py"]["confidence"] == 0.45- assert "1 cross-repo consumer(s) in web" in by_path["src/a/one.py"]["cross_repo_note"]- assert by_path["src/b/five.py"]["confidence"] == 0.27- assert "mobile" in by_path["src/b/five.py"]["cross_repo_note"]+def _served(rows: list, lookup=None, alias: str | None = "api") -> list[dict]:+ return [serialize_finding(f) for f in serve_findings(rows, lookup or _Lookup(), alias)]+++def test_only_a_contract_link_lowers_confidence() -> None:+ by_path = {f["file_path"]: f for f in _served(_ROWS)}+ # Contract provider: cut to 30%, the consumer named.+ assert by_path["src/a/two.py"]["confidence"] == 0.28+ assert "consumed by: web." in by_path["src/a/two.py"]["cross_repo_note"]+ # Co-change partners and package dependents keep the confidence.+ assert by_path["src/a/one.py"]["confidence"] == 0.9+ assert "changes together with 1 file(s) in web" in by_path["src/a/one.py"]["cross_repo_note"]+ assert by_path["src/b/five.py"]["confidence"] == 0.9+ assert "mobile may consume this export." in by_path["src/b/five.py"]["cross_repo_note"]# A finding another repo may consume is never safe to delete.- assert not by_path["src/a/one.py"]["safe_to_delete"]- assert not by_path["src/b/five.py"]["safe_to_delete"]+ assert not any(f["safe_to_delete"] for f in by_path.values())def test_package_dependents_are_named_only_where_their_link_reaches() -> None:- findings = [serialize_finding(r) for r in _ROWS]- adjust_cross_repo(findings, _Lookup(), "api")- by_path = {f["file_path"]: f for f in findings}- # Inside the consumed package, and a contract provider: named.- assert "consumed by: mobile." in by_path["src/b/five.py"]["cross_repo_note"]- assert "consumed by: web." in by_path["src/a/two.py"]["cross_repo_note"]- # Outside every link: nobody is named, yet the cut stays and safety is withdrawn.- lone = [serialize_finding(_row("src/c/six.py", 0.9))]- adjust_cross_repo(lone, _Lookup(), "api")+ # Outside every link: nobody is named, yet safety is withdrawn.+ lone = _served([_row("src/c/six.py", 0.9)])assert "mobile" not in lone[0]["cross_repo_note"]- assert lone[0]["confidence"] == 0.27+ assert lone[0]["confidence"] == 0.9assert not lone[0]["safe_to_delete"]+class _ContractOnlyLookup(_Lookup):+ """A provider repo nothing depends on as a package, e.g. an HTTP backend."""++ def get_repos_depending_on(self, repo_alias: str) -> list[str]:+ return []++ def get_package_consumers(self, repo_alias: str) -> list[dict]:+ return []+++def test_a_contract_link_cuts_every_kind_without_package_dependents() -> None:+ rows = [+ _row("src/a/two.py", 0.9, kind="unreachable_file"),+ _row("src/a/two.py", 0.95),+ _row("src/c/six.py", 0.9, kind="unreachable_file"),+ ]+ file_row, export_row, untouched = _served(rows, _ContractOnlyLookup())+ assert file_row["confidence"] == 0.27+ assert file_row["cross_repo_note"].startswith("This file may be consumed by: web.")+ assert export_row["cross_repo_note"].startswith("This export may be consumed by: web.")+ assert not file_row["safe_to_delete"] and not export_row["safe_to_delete"]+ assert untouched["confidence"] == 0.9 and "cross_repo_note" not in untouched+++def test_a_same_repo_contract_link_is_not_a_cross_repo_consumer() -> None:+ class _SelfLinked(_ContractOnlyLookup):+ def get_contract_links_as_provider(self, repo_alias: str, file_path: str) -> list[dict]:+ return [{"consumer_repo": repo_alias}]++ assert cross_repo_cut(_SelfLinked(), "api", "src/a/two.py", "unreachable_file") is None++class _UnscopedLookup(_Lookup):def get_package_consumers(self, repo_alias: str) -> list[dict]:return [{"source_repo": "mobile", "target_manifest": ""}]@@ -278,27 +309,30 @@ class _UnscopedLookup(_Lookup):def test_a_package_link_with_no_manifest_names_its_dependent() -> None:# Unknown package scope is not evidence the file sits outside it.- lone = [serialize_finding(_row("src/c/six.py", 0.9))]- adjust_cross_repo(lone, _UnscopedLookup(), "api")- assert "consumed by: mobile." in lone[0]["cross_repo_note"]+ lone = _served([_row("src/c/six.py", 0.9)], _UnscopedLookup())+ assert "mobile may consume this export." in lone[0]["cross_repo_note"]-def test_adjusted_findings_are_tiered_by_their_lowered_confidence() -> None:- findings = [serialize_finding(r) for r in _ROWS]- adjust_cross_repo(findings, _Lookup(), "api")- tiers = build_tiers(findings, 25, None)+def test_cut_findings_are_tiered_by_their_lowered_confidence() -> None:+ tiers = build_tiers(_served(_ROWS), 25, None)for name, block in tiers.items():for f in block["findings"]:assert f["confidence"] >= TIER_FLOORS[name]- assert "src/a/one.py" not in {f["file_path"] for f in tiers["high"]["findings"]}+ assert "src/a/two.py" in {f["file_path"] for f in tiers["low"]["findings"]}++def test_the_floor_and_safe_only_read_the_cut_confidence() -> None:+ # 0.95 * 0.3 = 0.28: below the default floor once cut, so not listed.+ kept = serve_findings(_ROWS, _Lookup(), "api", _filters(min_confidence=RISK_CAP_CONFIDENCE))+ assert all(f.confidence >= RISK_CAP_CONFIDENCE for f in kept)+ assert "src/a/two.py" not in {f.file_path for f in kept}+ assert serve_findings(_ROWS, _Lookup(), "api", _filters(safe_only=True)) == []-def test_adjust_cross_repo_without_data_or_alias_is_a_no_op() -> None:- findings = [serialize_finding(r) for r in _ROWS]- before = json.dumps(findings, default=str)- adjust_cross_repo(findings, None, "api")- adjust_cross_repo(findings, _Lookup(), None)- assert json.dumps(findings, default=str) == before++def test_serve_findings_without_data_or_alias_changes_nothing() -> None:+ plain = [serialize_finding(r) for r in _ROWS]+ assert _served(_ROWS, lookup=None, alias=None) == plain+ assert [serialize_finding(f) for f in serve_findings(_ROWS, None, "api")] == plaindef test_recommendation_never_points_at_an_empty_tier() -> None:@@ -321,17 +355,16 @@ def test_merged_per_repo_counts_equal_counting_everything_at_once() -> None:def test_summary_safe_counts_drop_what_the_cross_repo_cut_withdraws() -> None:- lookup = _Lookup()-- def withdrawn(f) -> bool:- return cross_repo_withdraws(lookup, "api", f["file_path"], f["kind"])-plain = summary_counts(_ROWS)- cut = summary_counts(_ROWS, withdrawn)- adjusted = [serialize_finding(r) for r in _ROWS]- adjust_cross_repo(adjusted, lookup, "api")- assert cut["safe_to_delete_count"] == sum(f["safe_to_delete"] for f in adjusted)+ served = serve_findings(_ROWS, _Lookup(), "api")+ cut = summary_counts(served)+ assert cut["safe_to_delete_count"] == sum(f["safe_to_delete"] for f in _served(_ROWS))assert cut["safe_to_delete_count"] <= plain["safe_to_delete_count"]assert cut["total_findings"] == plain["total_findings"]- assert not cross_repo_withdraws(None, "api", "src/a/one.py", "unused_export")- assert not cross_repo_withdraws(lookup, None, "src/a/one.py", "unused_export")+++def test_the_cut_never_makes_a_finding_safe() -> None:+ rows = [*_ROWS, _row("src/a/one.py", 0.9, safe_to_delete=False)]+ for served in serve_findings(rows, _Lookup(), "api"):+ assert served.confidence <= served.row["confidence"]+ assert not is_safe(served) or is_safe(served.row)diff --git a/tests/unit/persistence/test_dead_code_crud.py b/tests/unit/persistence/test_dead_code_crud.pyindex d38a48c18..60623480d 100644--- a/tests/unit/persistence/test_dead_code_crud.py+++ b/tests/unit/persistence/test_dead_code_crud.py@@ -354,10 +354,12 @@ async def test_get_dead_code_git_fields_is_empty_for_an_unknown_repo(async_sessiasync def test_summary_uses_shared_confidence_thresholds(async_session, monkeypatch):+ from repowise.core.analysis.dead_code.serving import TIER_FLOORSfrom repowise.core.persistence.crud.analysis import dead_code as dead_code_crud- monkeypatch.setattr(dead_code_crud, "SAFE_CONFIDENCE_THRESHOLD", 0.8)- monkeypatch.setattr(dead_code_crud, "RISK_CAP_CONFIDENCE", 0.3)+ # The summary tiers through the serving module's one table.+ monkeypatch.setitem(TIER_FLOORS, "high", 0.8)+ monkeypatch.setitem(TIER_FLOORS, "medium", 0.3)repo = await insert_repo(async_session)diff --git a/tests/unit/server/mcp/test_dead_code.py b/tests/unit/server/mcp/test_dead_code.pyindex 25169e9be..45663c979 100644--- a/tests/unit/server/mcp/test_dead_code.py+++ b/tests/unit/server/mcp/test_dead_code.py@@ -154,3 +154,23 @@ async def test_cross_repo_cut_reaches_summary_and_rollups(setup_mcp, monkeypatchsafe = await get_dead_code(safe_only=True)assert safe["summary"]["filtered_findings"] == 0assert "safe_only_note" in safe["summary"]+++class _EveryFileCalled(_EveryFileConsumed):+ def get_contract_links_as_provider(self, repo_alias, file_path):+ return [{"consumer_repo": "web"}]+++async def test_the_default_floor_reads_the_cut_confidence(setup_mcp, monkeypatch):+ from repowise.server.mcp_server import get_dead_code, tool_dead_code++ monkeypatch.setattr(tool_dead_code, "_cross_repo_lookup", lambda: _EveryFileCalled())++ # 0.9 / 0.7 / 0.5 cut to 0.27 / 0.21 / 0.15: none clears 0.4.+ result = await get_dead_code()+ assert not any(t["findings"] for t in result["tiers"].values())+ assert result["summary"]["filtered_findings"] == 0+ assert result["summary"]["total_findings"] == 3+ low = await get_dead_code(min_confidence="low")+ assert [f["confidence"] for f in low["tiers"]["low"]["findings"]] == [0.27, 0.21, 0.15]diff --git a/tests/unit/server/test_dead_code.py b/tests/unit/server/test_dead_code.pyindex 7b6464996..335a04a09 100644--- a/tests/unit/server/test_dead_code.py+++ b/tests/unit/server/test_dead_code.py@@ -304,3 +304,78 @@ async def test_stored_safe_unreachable_file_is_review_only_on_every_surface(async with get_session(app.state.session_factory) as session:items, total, _ = await _dead_code_items(session, repo["id"])assert (items, total) == ([], 0)+++class _ConsumedLookup:+ """Co-change partners on one file, an HTTP consumer on the other."""++ def has_cross_repo_consumers(self, repo_alias, file_path):+ return [{"repo": "web"}] if file_path == "src/dead_module.py" else []++ def get_repos_depending_on(self, repo_alias):+ return []++ def get_package_consumers(self, repo_alias):+ return []++ def get_contract_links_as_provider(self, repo_alias, file_path):+ return [{"consumer_repo": "web"}] if file_path == "src/utils.py" else []+++async def test_workspace_cut_reaches_list_summary_and_patch(+ client: AsyncClient, app, tmp_path, monkeypatch+) -> None:+ from types import SimpleNamespace++ repo = await create_test_repo(client)+ finding_id = await _insert_dead_code(app.state.session_factory, repo["id"])+ monkeypatch.setattr(app.state, "cross_repo_enricher", _ConsumedLookup(), raising=False)+ monkeypatch.setattr(+ app.state,+ "workspace_config",+ SimpleNamespace(repos=[SimpleNamespace(alias="api", path=".")]),+ raising=False,+ )+ monkeypatch.setattr(app.state, "workspace_root", str(tmp_path), raising=False)+ monkeypatch.setattr(+ app.state,+ "workspace_path_to_repo_id",+ {str(tmp_path.resolve()): repo["id"]},+ raising=False,+ )++ # Co-change keeps 0.9 but withdraws safety; 0.5 * 0.3 = 0.15 falls under the floor.+ listed = (await client.get(f"/api/repos/{repo['id']}/dead-code")).json()+ assert [(f["file_path"], f["confidence"], f["safe_to_delete"]) for f in listed] == [+ ("src/dead_module.py", 0.9, False)+ ]+ assert any("changes together with" in e for e in listed[0]["evidence"])+ everything = (+ await client.get(f"/api/repos/{repo['id']}/dead-code", params={"min_confidence": 0})+ ).json()+ assert {f["file_path"]: f["confidence"] for f in everything}["src/utils.py"] == 0.15++ summary = (await client.get(f"/api/repos/{repo['id']}/dead-code/summary")).json()+ assert summary["confidence_summary"] == {"high": 1, "medium": 0, "low": 1}+ assert summary["safe_to_delete_count"] == 0++ patched = (+ await client.patch(f"/api/dead-code/{finding_id}", json={"status": "acknowledged"})+ ).json()+ assert patched["confidence"] == 0.9 and patched["safe_to_delete"] is False+++def test_workspace_alias_for_an_unmapped_repo_is_none(tmp_path) -> None:+ from types import SimpleNamespace++ from repowise.server.deps import workspace_alias_for++ state = SimpleNamespace(+ workspace_config=SimpleNamespace(repos=[SimpleNamespace(alias="api", path=".")]),+ workspace_root=str(tmp_path),+ workspace_path_to_repo_id={str(tmp_path.resolve()): "r1"},+ )+ assert workspace_alias_for(state, "r1") == "api"+ assert workspace_alias_for(state, "r2") is None+ assert workspace_alias_for(SimpleNamespace(), "r1") is None