@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/project-topology.json

@@ -1,99 +0,0 @@
-{
-  "project_storage_key": "88718879",
-  "project_name": "3.2.1.3 Hệ thống quản lý chính sách tập trung - Policy management",
-  "repos": [
-    {
-      "repo_key": "policy-cdcn-policy-data-processing-service",
-      "repo_path": "/Users/vds-ai/.vds/cache/repos/policy-project/cdcn-policy-data-processing-service",
-      "repo_type": "backend",
-      "repo_role": "service",
-      "modules": [],
-      "entrypoints": [],
-      "language": "java",
-      "scan_summary": {
-        "modules": 0,
-        "entrypoints": 0
-      }
-    },
-    {
-      "repo_key": "policy-cdcn-policy-management-service",
-      "repo_path": "/Users/vds-ai/.vds/cache/repos/policy-project/cdcn-policy-management-service",
-      "repo_type": "backend",
-      "repo_role": "service",
-      "modules": [],
-      "entrypoints": [],
-      "language": "java",
-      "scan_summary": {
-        "modules": 0,
-        "entrypoints": 0
-      }
-    },
-    {
-      "repo_key": "policy-cdcn-policy-management-vsa",
-      "repo_path": "/Users/vds-ai/.vds/cache/repos/policy-project/cdcn-policy-management-vsa",
-      "repo_type": "backend",
-      "repo_role": "service",
-      "modules": [],
-      "entrypoints": [],
-      "language": "java",
-      "scan_summary": {
-        "modules": 0,
-        "entrypoints": 0
-      }
-    },
-    {
-      "repo_key": "policy-cdcn-policy-management-web",
-      "repo_path": "/Users/vds-ai/.vds/cache/repos/policy-project/cdcn-policy-management-web",
-      "repo_type": "fullstack",
-      "repo_role": "frontend",
-      "modules": [],
-      "entrypoints": [],
-      "language": "typescript",
-      "scan_summary": {
-        "modules": 0,
-        "entrypoints": 0
-      }
-    },
-    {
-      "repo_key": "policy-cdcn-policy-payment-fee-service",
-      "repo_path": "/Users/vds-ai/.vds/cache/repos/policy-project/cdcn-policy-payment-fee-service",
-      "repo_type": "backend",
-      "repo_role": "service",
-      "modules": [],
-      "entrypoints": [],
-      "language": "java",
-      "scan_summary": {
-        "modules": 0,
-        "entrypoints": 0
-      }
-    },
-    {
-      "repo_key": "policy-redis-win-local",
-      "repo_path": "/Users/vds-ai/.vds/cache/repos/policy-project/redis-win-local",
-      "repo_type": "unknown",
-      "repo_role": "unknown",
-      "modules": [],
-      "entrypoints": [],
-      "scan_summary": {
-        "modules": 0,
-        "entrypoints": 0
-      }
-    },
-    {
-      "repo_key": "policy-redis-windows-v2",
-      "repo_path": "/Users/vds-ai/.vds/cache/repos/policy-project/redis-windows-v2",
-      "repo_type": "unknown",
-      "repo_role": "unknown",
-      "modules": [],
-      "entrypoints": [],
-      "scan_summary": {
-        "modules": 0,
-        "entrypoints": 0
-      }
-    }
-  ],
-  "resolved_at": "2026-03-23T17:21:12.861260Z",
-  "thread_id": "pnttt-full-20260324-001--project-88718879-zai-openai",
-  "registry_source": "centralized_state",
-  "topology_source": "registry_state_confluence"
-}

package/tools/vds-scripts/public_interface_boundary_orchestrator/pyproject.toml

@@ -1,18 +0,0 @@
-[project]
-name = "public-interface-boundary-orchestrator"
-version = "0.1.0"
-description = "Evidence extraction CLI for explicit public interface boundary findings"
-requires-python = ">=3.11"
-dependencies = [
-  "typer>=0.12.0",
-]
-
-[project.scripts]
-vds-public-interface = "vds_public_interface_boundary_orchestrator.cli:app"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/vds_public_interface_boundary_orchestrator"]

package/tools/vds-scripts/public_interface_boundary_orchestrator/src/vds_public_interface_boundary_orchestrator/cli.py

@@ -1,232 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-from pathlib import Path
-from typing import Any
-
-import typer
-
-app = typer.Typer(help="Public interface boundary evidence extraction helpers")
-
-_TEXT_EXTENSIONS = {".py", ".java", ".kt", ".ts", ".tsx", ".js", ".jsx"}
-_EXCLUDE_PARTS = {"node_modules", "dist", "build", "target", ".git", ".venv", "__pycache__"}
-_IMPORT_PATTERNS: tuple[tuple[str, re.Pattern[str]], ...] = (
-    ("internal_import", re.compile(r"^\s*(from|import)\s+.*\binternal\b")),
-    ("impl_import", re.compile(r"^\s*(from|import)\s+.*\bimpl\b")),
-    ("adapter_import", re.compile(r"^\s*(from|import)\s+.*\badapter[s]?\b")),
-    ("infrastructure_import", re.compile(r"^\s*(from|import)\s+.*\binfrastructure\b")),
-    ("impl_symbol_import", re.compile(r"^\s*(from|import)\s+.*\b[A-Za-z0-9_]*(Impl|Implementation)\b")),
-)
-
-
-def _emit(payload: dict[str, Any], *, as_json: bool) -> None:
-    if as_json:
-        typer.echo(json.dumps(payload, indent=2, ensure_ascii=False))
-    else:
-        typer.echo(str(payload))
-
-
-def _write_output(payload: dict[str, Any], output_path: Path | None) -> None:
-    if output_path is None:
-        return
-    target = output_path.expanduser().resolve()
-    target.parent.mkdir(parents=True, exist_ok=True)
-    target.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
-
-
-def _should_scan(path: Path) -> bool:
-    if not path.is_file():
-        return False
-    if path.suffix.lower() not in _TEXT_EXTENSIONS:
-        return False
-    if set(path.parts) & _EXCLUDE_PARTS:
-        return False
-    normalized = path.as_posix()
-    if "/test/" in normalized or "/tests/" in normalized:
-        return False
-    return not (normalized.endswith("Test.java") or normalized.endswith("Tests.java"))
-
-
-def _scan_repo(repo_path: Path) -> dict[str, Any]:
-    repo = repo_path.expanduser().resolve()
-    if not repo.exists() or not repo.is_dir():
-        raise typer.BadParameter(f"Repository path does not exist or is not a directory: {repo_path}")
-    files_scanned = 0
-    candidates: list[dict[str, Any]] = []
-    type_counts: dict[str, int] = {}
-    for path in repo.rglob("*"):
-        if not _should_scan(path):
-            continue
-        try:
-            text = path.read_text(encoding="utf-8")
-        except Exception:
-            continue
-        files_scanned += 1
-        matches: list[dict[str, Any]] = []
-        for line_no, line in enumerate(text.splitlines(), start=1):
-            stripped = line.strip()
-            if not stripped.startswith(("import ", "from ")):
-                continue
-            for candidate_type, pattern in _IMPORT_PATTERNS:
-                if pattern.search(stripped):
-                    type_counts[candidate_type] = type_counts.get(candidate_type, 0) + 1
-                    matches.append(
-                        {
-                            "line_number": line_no,
-                            "candidate_type": candidate_type,
-                            "import_text": stripped,
-                            "confidence_hint": "low",
-                            "needs_manual_confirmation": True,
-                        }
-                    )
-                    break
-        if matches:
-            candidates.append(
-                {
-                    "repo_path": str(repo),
-                    "file_path": str(path),
-                    "module_boundary_hint": None,
-                    "public_contract_hint": None,
-                    "matches": matches,
-                }
-            )
-    result_type = "justified_no_violation" if not candidates else "evidence_gap"
-    reasoning = (
-        "No direct import statements matching internal/impl/adapter/infrastructure/*Impl heuristics were found in scanned source files excluding tests."
-        if not candidates
-        else "Candidate imports were found, but heuristic scanning alone does not prove a boundary violation. Syntax-aware confirmation and boundary interpretation are still required."
-    )
-    return {
-        "command": "scan-repo",
-        "scope": "repo",
-        "shared_companion_only": True,
-        "repo_path": str(repo),
-        "files_scanned": files_scanned,
-        "candidate_file_count": len(candidates),
-        "candidate_type_counts": type_counts,
-        "result_type": result_type,
-        "reasoning": reasoning,
-        "candidates": candidates,
-    }
-
-
-def _discover_repos_from_project_dir(project_dir: Path) -> list[Path]:
-    root = project_dir.expanduser().resolve()
-    if not root.exists() or not root.is_dir():
-        raise typer.BadParameter(f"Project directory does not exist: {project_dir}")
-    if (root / ".git").exists():
-        return [root]
-    repos: list[Path] = []
-    for child in sorted(root.iterdir()):
-        if child.is_dir() and (child / ".git").exists():
-            repos.append(child)
-    if not repos:
-        raise typer.BadParameter(f"No git repositories discovered under project directory: {project_dir}")
-    return repos
-
-
-@app.command("scan-repo")
-def scan_repo(
-    repo_path: Path = typer.Argument(..., help="Repository or project root path"),
-    json_output: bool = typer.Option(True, "--json/--no-json"),
-    output: Path | None = typer.Option(
-        None,
-        "--output",
-        help="Optional path to persist the JSON payload for reuse as companion context.",
-    ),
-) -> None:
-    """Scan a single repository for module-boundary violations."""
-    payload = _scan_repo(repo_path)
-    _write_output(payload, output)
-    _emit(payload, as_json=json_output)
-
-
-@app.command("scan-project")
-def scan_project(
-    source: Path = typer.Argument(..., help="Repository or project root path"),
-    json_output: bool = typer.Option(True, "--json/--no-json"),
-    output: Path | None = typer.Option(
-        None,
-        "--output",
-        help="Optional path to persist the project-scan payload for reuse across repo evaluations.",
-    ),
-) -> None:
-    """Scan all repositories in a project for module-boundary violations."""
-    path = source.expanduser().resolve()
-    if not path.exists():
-        raise typer.BadParameter(f"Source does not exist: {source}")
-    source_kind = "repos_file" if path.is_file() else "project_dir"
-    if path.is_file():
-        repo_entries = json.loads(path.read_text(encoding="utf-8"))
-        if not isinstance(repo_entries, list):
-            raise typer.BadParameter("Repos file JSON must be a list of repository paths.")
-        repos = [Path(str(item)) for item in repo_entries]
-    else:
-        repos = _discover_repos_from_project_dir(path)
-    repo_results: list[dict[str, Any]] = []
-    total_files_scanned = 0
-    total_candidate_files = 0
-    aggregate_type_counts: dict[str, int] = {}
-    for repo in repos:
-        repo_payload = _scan_repo(repo)
-        repo_results.append(repo_payload)
-        total_files_scanned += int(repo_payload.get("files_scanned") or 0)
-        total_candidate_files += int(repo_payload.get("candidate_file_count") or 0)
-        for key, value in (repo_payload.get("candidate_type_counts") or {}).items():
-            aggregate_type_counts[str(key)] = aggregate_type_counts.get(str(key), 0) + int(value or 0)
-    payload = {
-        "command": "scan-project",
-        "scope": "project",
-        "shared_companion_only": True,
-        "source_kind": source_kind,
-        "source_path": str(path),
-        "repo_count": len(repo_results),
-        "files_scanned": total_files_scanned,
-        "candidate_file_count": total_candidate_files,
-        "candidate_type_counts": aggregate_type_counts,
-        "result_type": "justified_no_violation" if total_candidate_files == 0 else "evidence_gap",
-        "repos": repo_results,
-    }
-    _write_output(payload, output)
-    _emit(payload, as_json=json_output)
-
-
-@app.command("summarize")
-def summarize(
-    input: Path = typer.Argument(..., help="Repository or project root path"),
-    json_output: bool = typer.Option(True, "--json/--no-json"),
-    output: Path | None = typer.Option(
-        None,
-        "--output",
-        help="Optional path to persist the summary JSON payload.",
-    ),
-) -> None:
-    """Summarize public-interface scan results across repositories."""
-    path = input.expanduser().resolve()
-    if not path.exists() or not path.is_file():
-        raise typer.BadParameter(f"Input file does not exist: {input}")
-    payload = json.loads(path.read_text(encoding="utf-8"))
-    if isinstance(payload, dict) and payload.get("command") == "scan-project":
-        repos = payload.get("repos") or []
-        summary = {
-            "command": "summarize",
-            "scope": "project",
-            "repo_count": len(repos),
-            "candidate_file_count": payload.get("candidate_file_count", 0),
-            "candidate_type_counts": payload.get("candidate_type_counts", {}),
-            "result_type": payload.get("result_type"),
-        }
-    elif isinstance(payload, dict):
-        summary = {
-            "command": "summarize",
-            "scope": "repo",
-            "repo_path": payload.get("repo_path"),
-            "candidate_file_count": payload.get("candidate_file_count", 0),
-            "candidate_type_counts": payload.get("candidate_type_counts", {}),
-            "result_type": payload.get("result_type"),
-        }
-    else:
-        raise typer.BadParameter("Input JSON must be an object produced by scan-repo or scan-project.")
-    _write_output(summary, output)
-    _emit(summary, as_json=json_output)

package/tools/vds-scripts/public_interface_boundary_orchestrator/tests/test_cli.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-from typer.testing import CliRunner
-from vds_public_interface_boundary_orchestrator.cli import _scan_repo, app
-
-runner = CliRunner()
-
-
-def test_scan_repo_reports_no_violation_for_clean_repo(tmp_path: Path) -> None:
-    src = tmp_path / "src"
-    src.mkdir(parents=True)
-    (src / "service.py").write_text("from contracts import OrderRepository\n")
-    payload = _scan_repo(tmp_path)
-    assert payload["files_scanned"] == 1
-    assert payload["candidate_file_count"] == 0
-    assert payload["result_type"] == "justified_no_violation"
-
-
-def test_scan_repo_reports_candidate_for_internal_import(tmp_path: Path) -> None:
-    src = tmp_path / "src"
-    src.mkdir(parents=True)
-    (src / "service.py").write_text("from billing.internal.repo import OrderRepositoryImpl\n")
-    payload = _scan_repo(tmp_path)
-    assert payload["files_scanned"] == 1
-    assert payload["candidate_file_count"] == 1
-    assert payload["result_type"] == "evidence_gap"
-    assert payload["candidate_type_counts"]["internal_import"] == 1
-
-
-def test_scan_project_aggregates_repo_results(tmp_path: Path) -> None:
-    repo_a = tmp_path / "repo-a"
-    repo_b = tmp_path / "repo-b"
-    (repo_a / ".git").mkdir(parents=True)
-    (repo_b / ".git").mkdir(parents=True)
-    (repo_a / "src").mkdir(parents=True)
-    (repo_b / "src").mkdir(parents=True)
-    (repo_a / "src" / "a.py").write_text("from contracts import Port\n")
-    (repo_b / "src" / "b.py").write_text("from infra.adapter import PaymentAdapter\n")
-    result = runner.invoke(app, ["scan-project", str(tmp_path), "--json"])
-    assert result.exit_code == 0, result.output
-    payload = json.loads(result.output)
-    assert payload["scope"] == "project"
-    assert payload["shared_companion_only"] is True
-    assert payload["repo_count"] == 2
-    assert payload["candidate_file_count"] == 1
-    assert payload["result_type"] == "evidence_gap"
-
-
-def test_scan_project_writes_output_for_shared_reuse(tmp_path: Path) -> None:
-    repo = tmp_path / "repo-a"
-    (repo / ".git").mkdir(parents=True)
-    (repo / "src").mkdir(parents=True)
-    (repo / "src" / "a.py").write_text("from contracts import Port\n")
-    output = tmp_path / "artifacts" / "boundary-project-scan.json"
-    result = runner.invoke(app, ["scan-project", str(tmp_path), "--json", "--output", str(output)])
-    assert result.exit_code == 0, result.output
-    persisted = json.loads(output.read_text())
-    assert persisted["command"] == "scan-project"
-    assert persisted["scope"] == "project"
-    assert persisted["shared_companion_only"] is True
-    assert persisted["repo_count"] == 1
-
-
-def test_summarize_handles_repo_payload(tmp_path: Path) -> None:
-    payload_path = tmp_path / "repo.json"
-    payload_path.write_text(
-        json.dumps(
-            {
-                "command": "scan-repo",
-                "repo_path": "/tmp/repo",
-                "candidate_file_count": 2,
-                "candidate_type_counts": {"internal_import": 2},
-                "result_type": "evidence_gap",
-            }
-        )
-    )
-    result = runner.invoke(app, ["summarize", str(payload_path), "--json"])
-    assert result.exit_code == 0, result.output
-    payload = json.loads(result.output)
-    assert payload["scope"] == "repo"
-    assert payload["candidate_file_count"] == 2
-    assert payload["result_type"] == "evidence_gap"
-
-
-def test_summarize_writes_output(tmp_path: Path) -> None:
-    payload_path = tmp_path / "repo.json"
-    output = tmp_path / "summary.json"
-    payload_path.write_text(
-        json.dumps(
-            {
-                "command": "scan-project",
-                "repo_count": 2,
-                "candidate_file_count": 3,
-                "candidate_type_counts": {"impl_import": 3},
-                "result_type": "evidence_gap",
-                "repos": [],
-            }
-        )
-    )
-    result = runner.invoke(app, ["summarize", str(payload_path), "--json", "--output", str(output)])
-    assert result.exit_code == 0, result.output
-    persisted = json.loads(output.read_text())
-    assert persisted["command"] == "summarize"
-    assert persisted["scope"] == "project"
-    assert persisted["candidate_file_count"] == 3

package/tools/vds-scripts/research_orchestrator/README.md

@@ -1,68 +0,0 @@
-# vds-research-orchestrator
-
-Evidence-first research CLI: web + code search, evidence scoring, and decision-packet generation via MCP Router.
-
-## Commands
-
-- `./scripts/worktree_uv.sh run --project vds_cli vds-cli research search` — Search internet/code providers through MCP tools
-- `./scripts/worktree_uv.sh run --project vds_cli vds-cli research health` — Check local tooling and MCP Router connectivity
-- `./scripts/worktree_uv.sh run --project vds_cli vds-cli research score` — Score evidence reliability
-- `./scripts/worktree_uv.sh run --project vds_cli vds-cli research report` — Generate decision packets
-
-## Worktree-safe invocation
-
-Run from `WHO-project/vds-scripts/research_orchestrator` and prefer local project execution:
-
-```bash
-export MCPR_URL="${MCPR_URL:-http://localhost:3282}"
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research health --json
-```
-
-This avoids accidental use of a stale globally-installed `vds-research`.
-
-## Help commands (verified)
-
-```bash
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research --help
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research search --help
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research health --help
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research score --help
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research report --help
-uv run --project ../vds_cli vds-cli research search --help
-```
-
-## Search tool matrix (agent-effective)
-
-| `--tool` | MCP tool | Required flags | Example |
-|---|---|---|---|
-| `tavily` | `tavily_search` | none | `... search "MCP" --tool tavily --json` |
-| `tavily-max` | `tavily_search` | none | `... search "MCP" --tool tavily-max --json` |
-| `exa` | `web_search_exa` | none | `... search "MCP" --tool exa --json` |
-| `brave` | `brave_web_search` | none | `... search "MCP" --tool brave --json` |
-| `github` | `searchGitHub` | `--language` (repeatable recommended) | `... search "useState(" --tool github --language TypeScript --json` |
-| `docs` | `search_docs` | `--library` | `... search "react hooks" --tool docs --library react --json` |
-| `context7` | `query-docs` | `--library-id` | `... search "cleanup" --tool context7 --library-id /facebook/react --json` |
-| `deep` | `read_wiki_structure` | `--repo` | `... search "microsoft/vscode" --tool deep --repo microsoft/vscode --json` |
-| `tavily-extract` | `tavily_extract` | `--url` | `... search "https://modelcontextprotocol.io" --tool tavily-extract --url https://modelcontextprotocol.io --json` |
-| `brightdata` / `brightdata-search` | `search_engine` | optional `--engine` | `... search "MCP Protocol" --tool brightdata --engine google --json` |
-| `brightdata-scrape` | `scrape_as_markdown` | `--url` | `... search "https://modelcontextprotocol.io" --tool brightdata-scrape --url https://modelcontextprotocol.io --json` |
-
-## Effective workflow
-
-```bash
-# 1) Health
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research health --json
-
-# 2) Local+web evidence
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research search "Model Context Protocol" --tool tavily --json
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research search "Model Context Protocol" --tool brightdata --engine google --json
-
-# 3) Score
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research score --primary-sources 2 --independent-sources 2 --local-validation --json > /tmp/score.json
-
-# 4) Report
-uv run --project . ./scripts/worktree_uv.sh run --project vds_cli vds-cli research report --title "..." --question "..." --recommendation "..." \
-  --decision investigate --confidence medium \
-  --local-evidence /tmp/local.json --internet-evidence /tmp/internet.json \
-  --score-json /tmp/score.json --json-output /tmp/packet.json --output /tmp/packet.md
-```

package/tools/vds-scripts/research_orchestrator/pyproject.toml

@@ -1,95 +0,0 @@
-[project]
-name = "vds-research-orchestrator"
-version = "0.2.0"
-description = "Evidence-first research CLI: web + code search, scoring, and decision-packet generation via MCP Router"
-readme = "README.md"
-requires-python = ">=3.14"
-license = { text = "MIT" }
-authors = [{ name = "VDS Team" }]
-keywords = ["cli", "research", "mcp", "evidence", "typer", "vds"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Environment :: Console",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3.14",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Typing :: Typed",
-]
-dependencies = [
-    "typer>=0.24.1",
-    "pydantic>=2.12.5",
-    "pydantic-settings>=2.12.0",
-    "httpx>=0.28.1",
-    "structlog>=25.5.0",
-    "rich>=14.3.3",
-    "vds-cli-common>=0.1.0",
-]
-
-[project.scripts]
-vds-research = "vds_research_orchestrator.cli:app"
-
-[tool.uv.sources]
-vds-cli-common = { workspace = true }
-
-[dependency-groups]
-dev = [
-    "pytest>=7.0.0",
-    "pytest-cov>=4.0.0",
-    "pytest-timeout>=2.3.0",
-    "ruff>=0.1.0",
-    "hatchling>=1.27.0",
-]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/vds_research_orchestrator"]
-
-[tool.uv]
-editable-backend = "path"
-
-[tool.ruff]
-target-version = "py314"
-line-length = 120
-src = ["src", "tests"]
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "W", "UP", "B", "C4", "ARG", "SIM", "TCH", "PTH", "ERA", "PL", "RUF"]
-ignore = [
-    "E501",        # line too long
-    "PLR0913",     # Too many arguments
-    "PLR2004",     # Magic value comparison
-    "ARG002",      # unused method argument
-    "F841",        # unused variable
-    "B008",        # function call in typer.Option default (intentional CLI pattern)
-    "PLC0415",     # import inside function (intentional: avoid json shadowing Typer params)
-    "RUF001",      # ambiguous unicode (EN DASH in docstrings is intentional)
-    "TC001",       # typing-only import (evidence models re-export, used at runtime)
-    "PLR0912",     # too many branches (scoring function with intentional case logic)
-]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-pythonpath = ["src"]
-addopts = "-v --tb=short"
-timeout = 60
-markers = [
-    "integration: Integration tests (may hit MCP Router)",
-    "unit: Unit tests (mocked surfaces)",
-]
-
-[tool.coverage.run]
-source = ["src/vds_research_orchestrator"]
-branch = true
-
-[tool.coverage.report]
-exclude_lines = [
-    "pragma: no cover",
-    "if TYPE_CHECKING:",
-    "if __name__ == .__main__.:",
-    "raise NotImplementedError",
-]
-fail_under = 80

package/tools/vds-scripts/research_orchestrator/src/vds_research_orchestrator/__init__.py

@@ -1,3 +0,0 @@
-"""VDS Research Orchestrator — evidence-first research CLI via MCP Router."""
-
-__version__ = "0.2.0"

package/tools/vds-scripts/research_orchestrator/src/vds_research_orchestrator/_env.py

@@ -1,11 +0,0 @@
-"""Shared environment loader for research orchestrator.
-
-Loads ~/.vds/.env into os.environ before pydantic-settings reads it.
-"""
-
-from __future__ import annotations
-
-from vds_cli_common.env import load_shared_env
-
-# Populate os.environ from ~/.vds/.env so ResearchSettings picks up MCPR_TOKEN
-load_shared_env()