sourcecode 1.26.0__tar.gz → 1.27.0__tar.gz

{sourcecode-1.26.0 → sourcecode-1.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.26.0
+Version: 1.27.0
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -221,7 +221,7 @@ Description-Content-Type: text/markdown
 
 **Compressed AI-ready context for Java/Spring enterprise codebases.**
 
-![Version](https://img.shields.io/badge/version-1.26.0-blue)
+![Version](https://img.shields.io/badge/version-1.27.0-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -255,7 +255,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.26.0
+# sourcecode 1.27.0
 ```
 
 ---

{sourcecode-1.26.0 → sourcecode-1.27.0}/README.md

@@ -2,7 +2,7 @@
 
 **Compressed AI-ready context for Java/Spring enterprise codebases.**
 
-![Version](https://img.shields.io/badge/version-1.26.0-blue)
+![Version](https://img.shields.io/badge/version-1.27.0-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -36,7 +36,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.26.0
+# sourcecode 1.27.0
 ```
 
 ---

{sourcecode-1.26.0 → sourcecode-1.27.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.26.0"
+version = "1.27.0"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.26.0 → sourcecode-1.27.0}/src/sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.26.0"
+__version__ = "1.27.0"

{sourcecode-1.26.0 → sourcecode-1.27.0}/src/sourcecode/cli.py

@@ -1777,6 +1777,7 @@ def prepare_context_cmd(
             # Hard error — emit structured error JSON and exit, skip normal delta fields
             _err_out: dict[str, Any] = {
                 "task": output.task,
+                "ci_decision": output.ci_decision or "git_ref_error",
                 "error": output.error_code,
                 "since": output.since,
                 "message": output.error_message,
@@ -1792,6 +1793,8 @@ def prepare_context_cmd(
                 _sys.stdout.buffer.write(b"\n")
                 _sys.stdout.buffer.flush()
             raise typer.Exit(code=1)
+        if output.ci_decision:
+            out["ci_decision"] = output.ci_decision
         if output.since:
             out["since"] = output.since
         if output.impact_summary:

{sourcecode-1.26.0 → sourcecode-1.27.0}/src/sourcecode/prepare_context.py

@@ -337,6 +337,12 @@ class TaskOutput:
     error_code: Optional[str] = None
     error_message: Optional[str] = None
     error_hints: list[str] = field(default_factory=list)
+    # CI decision state machine — machine-decidable signal
+    ci_decision: Optional[str] = None  # "no_changes" | "analysis_success" | "git_ref_error"
+    # git baseline resolution metadata
+    resolved_since_ref: Optional[str] = None   # actual ref/hash used for the diff
+    resolution_path: Optional[str] = None      # "exact_local_ref"|"remote_tracking_ref"|"symbolic_ref"|"head_minus_1_fallback"|"uncommitted_changes"|"unresolvable"
+    diff_validation_status: Optional[str] = None  # "valid_non_empty"|"valid_empty"|"invalid_ref"
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -648,6 +654,7 @@ class TaskContextBuilder:
                     error_message=f"Git reference '{since}' does not exist in this repository.",
                     error_hints=_hints,
                     gaps=[f"Cannot compute delta: git ref '{since}' not found."] + _hints,
+                    ci_decision="git_ref_error",
                 )
             elif _delta_raw:
                 _delta_files = set(_delta_raw)
@@ -937,6 +944,11 @@ class TaskContextBuilder:
             change_type=_delta_change_type,
             dependency_graph_summary=_delta_dep_graph_summary,
             impact_score_per_file=_delta_impact_score_per_file,
+            ci_decision=(
+                "no_changes" if task_name == "delta" and not changed_files
+                else "analysis_success" if task_name == "delta"
+                else None
+            ),
         )
 
     def render_prompt(self, output: TaskOutput) -> str:
@@ -2118,6 +2130,124 @@ class TaskContextBuilder:
             impact_score_per_file,
         )
 
+    def _resolve_git_baseline(self, since: Optional[str]) -> dict[str, Any]:
+        """Resolve git baseline for delta diff using a 4-stage fallback chain.
+
+        Resolution order when `since` is provided:
+          1. exact local ref (git rev-parse --verify <since>)
+          2. remote-tracking ref  (origin/<since>)
+          3. symbolic ref         (git symbolic-ref refs/remotes/origin/HEAD)
+          4. HEAD~1 fallback
+
+        When `since` is None:
+          1. uncommitted changes  (git diff --name-only --relative)
+          2. HEAD~1 fallback
+
+        Returns dict with keys:
+            files: list[str]           — changed paths (empty = confirmed no changes)
+            resolved_ref: str          — ref actually used for the diff
+            resolution_path: str       — which strategy resolved it
+            diff_validation_status: str — "valid_non_empty"|"valid_empty"|"invalid_ref"
+            error: bool                — True only when ALL strategies failed
+        """
+        import subprocess
+
+        def _run(*args: str, timeout: int = 5) -> tuple[bool, str]:
+            try:
+                r = subprocess.run(
+                    ["git", *args], cwd=str(self.root),
+                    capture_output=True, text=True,
+                    encoding="utf-8", errors="replace", timeout=timeout,
+                )
+                return r.returncode == 0, (r.stdout or "").strip()
+            except (subprocess.TimeoutExpired, FileNotFoundError):
+                return False, ""
+
+        def _verify(ref: str) -> bool:
+            ok, _ = _run("rev-parse", "--verify", ref)
+            return ok
+
+        def _diff(ref: str) -> Optional[list[str]]:
+            ok, out = _run("diff", "--name-only", "--relative", ref, "HEAD", timeout=10)
+            if not ok:
+                return None
+            return [line.strip() for line in out.splitlines() if line.strip()]
+
+        def _make(files: list[str], ref: str, path: str) -> dict[str, Any]:
+            return {
+                "files": files,
+                "resolved_ref": ref,
+                "resolution_path": path,
+                "diff_validation_status": "valid_non_empty" if files else "valid_empty",
+                "error": False,
+            }
+
+        if since:
+            # Stage 1: exact local ref
+            if _verify(since):
+                files = _diff(since)
+                if files is not None:
+                    return _make(files, since, "exact_local_ref")
+
+            # Stage 2: remote-tracking ref (origin/<since>)
+            remote_ref = f"origin/{since}"
+            if _verify(remote_ref):
+                files = _diff(remote_ref)
+                if files is not None:
+                    return _make(files, remote_ref, "remote_tracking_ref")
+
+            # Stage 3: symbolic ref (origin/HEAD → e.g. origin/main)
+            ok, symref = _run("symbolic-ref", "refs/remotes/origin/HEAD")
+            if ok and symref:
+                short = symref.removeprefix("refs/remotes/")
+                if _verify(short):
+                    files = _diff(short)
+                    if files is not None:
+                        return _make(files, short, "symbolic_ref")
+
+            # Stage 4: HEAD~1 fallback — original ref was invalid
+            if _verify("HEAD~1"):
+                files = _diff("HEAD~1")
+                if files is not None:
+                    return {
+                        "files": files,
+                        "resolved_ref": "HEAD~1",
+                        "resolution_path": "head_minus_1_fallback",
+                        "diff_validation_status": "invalid_ref",  # original ref unresolved
+                        "error": False,
+                    }
+
+            # All stages failed
+            return {
+                "files": [],
+                "resolved_ref": since,
+                "resolution_path": "unresolvable",
+                "diff_validation_status": "invalid_ref",
+                "error": True,
+            }
+
+        else:
+            # No since: uncommitted changes first
+            ok, out = _run("diff", "--name-only", "--relative", timeout=10)
+            if ok:
+                files = [line.strip() for line in out.splitlines() if line.strip()]
+                if files:
+                    return _make(files, "HEAD", "uncommitted_changes")
+
+            # HEAD~1 fallback
+            if _verify("HEAD~1"):
+                files = _diff("HEAD~1")
+                if files is not None:
+                    return _make(files or [], "HEAD~1", "head_minus_1_fallback")
+
+            return {
+                "files": [],
+                "resolved_ref": "HEAD",
+                "resolution_path": "unresolvable",
+                "diff_validation_status": "invalid_ref",
+                "error": True,
+            }
+
     def _get_git_changed_files(self, since: Optional[str] = None) -> Optional[list[str]]:
         """Get files changed since a git ref (default: HEAD~1) relative to self.root.
 

{sourcecode-1.26.0 → sourcecode-1.27.0}/src/sourcecode/serializer.py

@@ -1450,17 +1450,26 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
     """Opinionated output for AI agents — structured, noise-free, gap-aware.
 
     Output order:
-        1. project          → identity: type, summary, primary stack, frameworks
-        2. entry_points     → where execution starts (with reason/evidence)
-        3. architecture     → how it's structured (flow description)
-        4. key_dependencies → runtime dependencies that matter (when analyzed)
-        5. signals          → compact operational context (env, notes, tests)
-        6. confidence_summary → detection quality and hard/soft signals
-        7. analysis_gaps    → what's uncertain or missing
-
-    Never includes: file_tree, file_paths, schema internals, empty sections,
-    null fields, raw dependency lists, metrics, docs, or low-signal metadata.
+        1. project             → identity: type, summary, primary stack, frameworks
+        2. entry_points        → where execution starts (path+kind+confidence)
+        3. architecture        → pattern, layers (capped at 5)
+        4. file_relevance      → top-20 scored files — primary agent value-add
+        5. runtime_packages    → monorepo package roles (when available)
+        6. key_dependencies    → production deps: name+version+role+risk_flags (cap 20)
+        7. suspicious_dependencies → declared but never imported (cap 5)
+        8. signals             → env summary, top-5 code notes, tests, Spring/JVM context
+        9. git_context         → top-5 hotspots, branch, uncommitted count
+        10. confidence_summary → overall quality + anomalies (no internal signals)
+        11. confidence_reasons → actionable reasons for low-confidence sections
+        12. analysis_gaps      → what's uncertain or missing
+
+    Never includes: file_tree, file_paths, raw dep lists, dep_groups detail,
+    hard/soft/ignored signals, env var key list, metrics, docs, agent_mode meta.
     """
+    _AGENT_KEY_DEPS_CAP = 20
+    _AGENT_LAYERS_CAP = 5
+    _AGENT_CODE_NOTES_CAP = 5
+
     # ── 1. Identity ──────────────────────────────────────────────────────────
     primary = next((s for s in sm.stacks if s.primary), sm.stacks[0] if sm.stacks else None)
 
@@ -1509,14 +1518,23 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
         result["entry_points"] = _bs
     else:
         ep_groups = _entry_point_groups(sm.entry_points)
-        result["entry_points"] = ep_groups["production"][:_EP_PRODUCTION_CAP]
-        if ep_groups["development"]:
-            result["development_entry_points"] = ep_groups["development"][:_EP_DEV_CAP]
+        result["entry_points"] = [
+            {
+                "path": ep["path"],
+                **({"kind": ep["kind"]} if ep.get("kind") else {}),
+                **({"confidence": ep["confidence"]} if ep.get("confidence") else {}),
+            }
+            for ep in ep_groups["production"][:_EP_PRODUCTION_CAP]
+        ]
 
-    # ── 3. Architecture ───────────────────────────────────────────────────────
-    result["architecture"] = _architecture_context(sm)
+    # ── 3. Architecture — pattern + layers (capped) ───────────────────────────
+    _arch_ctx = _architecture_context(sm)
+    if "layers" in _arch_ctx and len(_arch_ctx["layers"]) > _AGENT_LAYERS_CAP:
+        _arch_ctx = dict(_arch_ctx)
+        _arch_ctx["layers"] = _arch_ctx["layers"][:_AGENT_LAYERS_CAP]
+    result["architecture"] = _arch_ctx
 
-    # ── 3a. File relevance: evidence-backed, high-signal only ────────────────
+    # ── 4. File relevance: top-scored files — primary agent value-add ────────
     _FR_AGENT_CAP = 20
     _total_paths = len(sm.file_paths)
     relevant_files = _file_relevance(sm, limit=_FR_AGENT_CAP if not full else _total_paths)
@@ -1528,7 +1546,7 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
                 "Use --full to see all."
             )
 
-    # ── 3b. Monorepo package roles (when available), capped ──────────────────
+    # ── 5. Monorepo package roles (when available), capped ───────────────────
     if sm.monorepo_packages:
         _noise_roles = {"benchmark_layer", "tooling_layer", "docs_layer", "test_layer"}
         operational_pkgs = [
@@ -1539,32 +1557,36 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
         if operational_pkgs:
             result["runtime_packages"] = operational_pkgs[:_MONOREPO_PKGS_CAP]
 
-    # ── 4. Dependencies: separated by operational role, capped ───────────────
-    # noise_dependencies intentionally excluded — not actionable.
-    dep_groups = _dependency_groups(sm)
-    if dep_groups["production_dependencies"]:
-        result["production_dependencies"] = dep_groups["production_dependencies"][:_PROD_DEPS_CAP]
-    for dep_key in ("dev_tools", "test_utilities", "build_tooling", "suspicious_dependencies"):
-        if dep_groups[dep_key]:
-            result[dep_key] = dep_groups[dep_key][:_SECONDARY_DEPS_CAP]
-
-    # Backward-compatible compact list, now production-only, with risk_flags.
+    # ── 6. Key dependencies: name+version+role+risk_flags only, cap 20 ───────
+    # dep_groups verbose detail (production_dependencies, dev_tools, etc.) excluded —
+    # fully overlaps key_dependencies with added noise from full asdict fields.
     production_key_deps = [
         d for d in sm.key_dependencies
         if (d.role or "unknown") in _PRODUCTION_DEP_ROLES and d.scope not in {"dev"}
     ]
     if sm.dependency_summary and sm.dependency_summary.requested and production_key_deps:
-        _dep_skip = {"parent", "manifest_path", "workspace", "source", "ecosystem"}
         _kd_list = []
-        for d in production_key_deps[:_KEY_DEPS_CAP]:
-            item = {k: v for k, v in asdict(d).items() if v is not None and k not in _dep_skip}
+        for d in production_key_deps[:_AGENT_KEY_DEPS_CAP]:
+            entry: dict[str, Any] = {"name": d.name}
+            if d.declared_version:
+                entry["version"] = d.declared_version
+            if d.role and d.role != "runtime":
+                entry["role"] = d.role
             flags = _dep_risk_flags(d.name, d.declared_version)
             if flags:
-                item["risk_flags"] = flags
-            _kd_list.append(item)
+                entry["risk_flags"] = flags
+            _kd_list.append(entry)
         result["key_dependencies"] = _kd_list
 
-    # ── 5. Signals — compact operational context ─────────────────────────────
+    # ── 7. Suspicious dependencies: declared but no static import observed ────
+    dep_groups = _dependency_groups(sm)
+    if dep_groups["suspicious_dependencies"]:
+        result["suspicious_dependencies"] = [
+            {"name": d.get("name", ""), "reason": d.get("reason", "")}
+            for d in dep_groups["suspicious_dependencies"][:_SECONDARY_DEPS_CAP]
+        ]
+
+    # ── 8. Signals — compact operational context ─────────────────────────────
     signals: dict[str, Any] = {}
 
     if sm.env_summary and sm.env_summary.requested and sm.env_summary.total > 0:
@@ -1580,15 +1602,6 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
         elif (sm.env_summary.spring_profiles or sm.env_summary.profiles_scanned):
             _raw_profiles = sm.env_summary.spring_profiles or sm.env_summary.profiles_scanned
             signals["env_vars"]["spring_profiles"] = sorted(set(_raw_profiles))
-        if sm.env_map:
-            _sorted_env = sorted(
-                sm.env_map,
-                key=lambda e: (not getattr(e, "required", False), getattr(e, "key", "")),
-            )
-            signals["env_vars"]["keys"] = [
-                {k: v for k, v in asdict(e).items() if v is not None and v != "" and v != []}
-                for e in _sorted_env[:10]
-            ]
 
     if sm.code_notes_summary and sm.code_notes_summary.requested and sm.code_notes_summary.total > 0:
         by_kind = {k: v for k, v in sm.code_notes_summary.by_kind.items() if v > 0}
@@ -1602,8 +1615,14 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
                 key=lambda n: (_SEVERITY_ORDER.get(getattr(n, "kind", "").upper(), 9), getattr(n, "path", "")),
             )
             _code_notes_signal["top"] = [
-                {k: v for k, v in asdict(n).items() if v is not None}
-                for n in _sorted_notes[:10]
+                {
+                    "kind": getattr(n, "kind", ""),
+                    "path": getattr(n, "path", ""),
+                    "line": getattr(n, "line", None),
+                    **({"text": _truncate_note(getattr(n, "text", ""), 120)} if getattr(n, "text", "") else {}),
+                }
+                for n in _sorted_notes[:_AGENT_CODE_NOTES_CAP]
+                if getattr(n, "kind", "").upper() in _SEVERITY_ORDER
             ]
         if _code_notes_signal:
             signals["code_notes"] = _code_notes_signal
@@ -1651,12 +1670,13 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
     if signals:
         result["signals"] = signals
 
-    # Git context — lightweight (top-5 hotspots, branch, uncommitted count)
+    # ── 9. Git context — lightweight (top-5 hotspots, branch, uncommitted count)
     _gc = _compact_git_context(sm)
     if _gc:
         result["git_context"] = _gc
 
-    # ── 6. Confidence summary ─────────────────────────────────────────────────
+    # ── 10. Confidence summary — overall quality + anomalies only ─────────────
+    # hard_signals/soft_signals/ignored_signals are detection internals — excluded.
     if sm.confidence_summary is not None:
         cs = sm.confidence_summary
         conf: dict[str, Any] = {
@@ -1665,23 +1685,11 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
             "entry_points": cs.entry_point_confidence,
             "sections": _section_confidence(sm),
         }
-        if cs.hard_signals:
-            _MAX_HARD_SIGNALS = 20
-            _hs = cs.hard_signals
-            _hs_total = len(_hs)
-            conf["hard_signals"] = _hs[:_MAX_HARD_SIGNALS]
-            if _hs_total > _MAX_HARD_SIGNALS:
-                conf["hard_signals_truncated"] = True
-                conf["hard_signals_total"] = _hs_total
-        if cs.soft_signals:
-            conf["soft_signals"] = cs.soft_signals
-        if cs.ignored_signals:
-            conf["ignored_signals"] = cs.ignored_signals
         if cs.anomalies:
             conf["anomalies"] = cs.anomalies
         result["confidence_summary"] = conf
 
-    # ── 6a. Confidence reasons: explain any low-confidence section ────────────
+    # ── 11. Confidence reasons: actionable explanation of low-confidence sections
     _conf_reasons = _confidence_reasons(sm)
     if _conf_reasons:
         result["confidence_reasons"] = _conf_reasons
@@ -1691,7 +1699,7 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
         # No reasons found → low was overly conservative; upgrade to high
         result["confidence_summary"].setdefault("sections", {})["architecture"] = "high"
 
-    # ── 7. Analysis gaps ──────────────────────────────────────────────────────
+    # ── 12. Analysis gaps ─────────────────────────────────────────────────────
     analysis_gaps: list[dict[str, Any]] = []
 
     if sm.analysis_gaps:
@@ -1727,23 +1735,6 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
     if analysis_gaps:
         result["analysis_gaps"] = analysis_gaps
 
-    # ── 8. Agent mode metadata — explicit transparency about auto-enabled/suppressed flags ──
-    _auto_enabled: list[str] = ["--dependencies", "--env-map", "--code-notes"]
-    _suppressed: list[str] = []
-    if sm.metrics_summary is not None and sm.metrics_summary.requested:
-        _suppressed.append("--full-metrics")
-    if sm.module_graph is not None and sm.module_graph.summary.requested:
-        _suppressed.append("--graph-modules")
-    if sm.doc_summary is not None and sm.doc_summary.requested:
-        _suppressed.append("--docs")
-    agent_mode_meta: dict[str, Any] = {
-        "auto_enabled": _auto_enabled,
-    }
-    if _suppressed:
-        agent_mode_meta["suppressed_flags"] = _suppressed
-        agent_mode_meta["suppressed_note"] = "computed but excluded from agent_view"
-    result["agent_mode"] = agent_mode_meta
-
     return result
 
 

{sourcecode-1.26.0 → sourcecode-1.27.0}/tests/test_block5_quality.py

@@ -117,59 +117,57 @@ def test_symbol_definers_not_truncated() -> None:
 
 
 # ---------------------------------------------------------------------------
-# 4. agent_view suppressed flags metadata
+# 4. agent_view noise exclusions
 # ---------------------------------------------------------------------------
 
-def test_agent_view_suppressed_flags_detected() -> None:
-    """When metrics_summary.requested=True, agent_view includes it in suppressed_flags."""
-    sm = _make_sm(
-        metrics_summary=MetricsSummary(requested=True, file_count=5),
-    )
-    result = agent_view(sm)
-
-    assert "agent_mode" in result
-    am = result["agent_mode"]
-    assert "--full-metrics" in am.get("suppressed_flags", [])
-    assert am.get("suppressed_note") == "computed but excluded from agent_view"
-
-
-def test_agent_view_suppressed_graph_modules() -> None:
-    """When module_graph.summary.requested=True, --graph-modules appears in suppressed_flags."""
-    mg = ModuleGraph(summary=ModuleGraphSummary(requested=True))
-    sm = _make_sm(module_graph=mg)
+def test_agent_view_no_agent_mode_block() -> None:
+    """agent_mode metadata block removed — static content with no signal value."""
+    sm = _make_sm(metrics_summary=MetricsSummary(requested=True, file_count=5))
     result = agent_view(sm)
-
-    am = result["agent_mode"]
-    assert "--graph-modules" in am.get("suppressed_flags", [])
-
-
-def test_agent_view_suppressed_docs() -> None:
-    """When doc_summary.requested=True, --docs appears in suppressed_flags."""
-    sm = _make_sm(doc_summary=DocSummary(requested=True))
+    assert "agent_mode" not in result
+
+
+def test_agent_view_no_hard_signals() -> None:
+    """confidence_summary excludes hard/soft/ignored signals — detection internals."""
+    from sourcecode.schema import ConfidenceSummary
+    cs = ConfidenceSummary(
+        overall="high",
+        stack_confidence="high",
+        entry_point_confidence="high",
+        hard_signals=["pom.xml found", "spring-boot-starter-web in deps"],
+        soft_signals=["src/main/java present"],
+        ignored_signals=["README.md"],
+    )
+    sm = _make_sm(confidence_summary=cs)
     result = agent_view(sm)
 
-    am = result["agent_mode"]
-    assert "--docs" in am.get("suppressed_flags", [])
+    conf = result.get("confidence_summary", {})
+    assert "hard_signals" not in conf
+    assert "soft_signals" not in conf
+    assert "ignored_signals" not in conf
 
 
-def test_agent_view_no_suppressed_flags() -> None:
-    """agent_view with no suppressed flags doesn't include suppressed_flags key."""
-    sm = _make_sm()
+def test_agent_view_no_env_keys_list() -> None:
+    """signals.env_vars excludes the keys[] list — already present in compact env_map."""
+    from sourcecode.schema import EnvSummary, EnvVarRecord
+    env_map = [EnvVarRecord(key="DB_URL", required=True, category="database")]
+    env_summary = EnvSummary(requested=True, total=1, required_count=1)
+    sm = _make_sm(env_summary=env_summary, env_map=env_map)
     result = agent_view(sm)
 
-    assert "agent_mode" in result
-    am = result["agent_mode"]
-    assert "suppressed_flags" not in am
-    assert "--dependencies" in am.get("auto_enabled", [])
+    env_vars = result.get("signals", {}).get("env_vars", {})
+    assert "keys" not in env_vars
 
 
-def test_agent_view_auto_enabled_always_present() -> None:
-    """auto_enabled list always contains the three flags agent mode enables."""
+def test_agent_view_no_dep_groups() -> None:
+    """Verbose dep group fields excluded — overlaps key_dependencies with noise."""
     sm = _make_sm()
     result = agent_view(sm)
 
-    am = result["agent_mode"]
-    assert set(am["auto_enabled"]) == {"--dependencies", "--env-map", "--code-notes"}
+    assert "production_dependencies" not in result
+    assert "dev_tools" not in result
+    assert "test_utilities" not in result
+    assert "build_tooling" not in result
 
 
 # ---------------------------------------------------------------------------
@@ -187,8 +185,8 @@ def test_agent_view_empty_ep_lists_omitted() -> None:
     assert "entry_points" in result
 
 
-def test_agent_view_dev_ep_present_when_nonempty() -> None:
-    """When a dev entry point exists, development_entry_points appears in agent_view."""
+def test_agent_view_dev_ep_excluded() -> None:
+    """development_entry_points excluded from agent_view — noise for production-focused agents."""
     dev_ep = EntryPoint(
         path="webpack.config.js",
         stack="nodejs",
@@ -199,7 +197,7 @@ def test_agent_view_dev_ep_present_when_nonempty() -> None:
     sm = _make_sm(entry_points=[dev_ep])
     result = agent_view(sm)
 
-    assert "development_entry_points" in result
+    assert "development_entry_points" not in result
 
 
 def test_standard_view_empty_ep_lists_omitted() -> None:

{sourcecode-1.26.0 → sourcecode-1.27.0}/tests/test_pipeline_integrity.py

@@ -141,20 +141,21 @@ class TestBenchmarkContamination:
         data = _parse_agent(result.output)
         assert data.get("entry_points") == []
 
-    def test_agent_splits_development_and_auxiliary_eps(self, nocobase_like: Path) -> None:
+    def test_agent_excludes_development_and_auxiliary_eps(self, nocobase_like: Path) -> None:
+        """agent_view only surfaces production EPs — dev/aux excluded as noise."""
         result = runner.invoke(app, ["--agent", str(nocobase_like)])
         assert result.exit_code == 0, result.output
         data = _parse_agent(result.output)
 
-        dev_eps = data.get("development_entry_points", [])
-        aux_eps = data.get("auxiliary_entry_points", [])
+        assert "development_entry_points" not in data
+        assert "auxiliary_entry_points" not in data
 
-        assert any(ep.get("path") == "docs/rspress.mjs" for ep in dev_eps), dev_eps
-        assert all(ep.get("classification") == "development" for ep in dev_eps), dev_eps
-        assert all(ep.get("runtime_relevance") == "low" for ep in dev_eps), dev_eps
-        assert any(ep.get("path") == "benchmarks/run.js" for ep in aux_eps), aux_eps
-        assert any(ep.get("path") == "examples/demo.js" for ep in aux_eps), aux_eps
-        assert all(ep.get("classification") == "auxiliary" for ep in aux_eps), aux_eps
+        entry_points = data.get("entry_points", [])
+        dev_paths = {"docs/rspress.mjs"}
+        aux_paths = {"benchmarks/run.js", "examples/demo.js"}
+        ep_paths = {ep.get("path", "") for ep in entry_points} if isinstance(entry_points, list) else set()
+        assert not (ep_paths & dev_paths), f"Dev EP leaked into entry_points: {ep_paths & dev_paths}"
+        assert not (ep_paths & aux_paths), f"Aux EP leaked into entry_points: {ep_paths & aux_paths}"
 
     def test_production_server_survives_benchmark_coexistence(
         self, production_nodejs: Path