@ngocsangairvds/vsaf 3.2.16 → 4.0.1

package/tools/vds-scripts/scripts/validate_link_integrity.py

@@ -1,274 +0,0 @@
-#!/usr/bin/env python3
-"""
-Link Integrity Validation Script (Internal Links Only)
-Validates that all internal links in documentation resolve correctly.
-"""
-
-import json
-import re
-import sys
-from pathlib import Path
-
-# Link patterns to match
-MARKDOWN_LINK_PATTERN = r"\[([^\]]*)\]\(([^)]+)\)"
-REFERENCE_LINK_PATTERN = r"\[([^\]]*)\]:\s*([^\s]+)"
-
-
-def extract_links_from_file(file_path: Path) -> list[tuple[str, str, int]]:
-    """Extract all links from a markdown file."""
-    links = []
-
-    try:
-        with open(file_path, encoding="utf-8") as f:
-            content = f.read()
-
-        lines = content.split("\n")
-
-        for line_num, line in enumerate(lines, 1):
-            # Find markdown links [text](url)
-            for match in re.finditer(MARKDOWN_LINK_PATTERN, line):
-                text, url = match.groups()
-                links.append((text, url, line_num))
-
-            # Find reference links [text]: url
-            for match in re.finditer(REFERENCE_LINK_PATTERN, line):
-                text, url = match.groups()
-                links.append((text, url, line_num))
-
-    except Exception as e:
-        print(f"Error reading {file_path}: {e}")
-
-    return links
-
-
-def categorize_link(url: str, _base_path: Path) -> str:
-    """Categorize a link as internal, external, or anchor."""
-
-    # Remove fragments (anchors)
-    clean_url = url.split("#", maxsplit=1)[0]
-
-    if not clean_url:
-        return "anchor"
-    elif clean_url.startswith(("http://", "https://")):
-        return "external"
-    elif clean_url.startswith("mailto:"):
-        return "email"
-    else:
-        return "internal"
-
-
-def validate_internal_link(url: str, source_file: Path, docs_root: Path) -> dict:
-    """Validate an internal link."""
-
-    # Remove anchor fragment
-    clean_url = url.split("#", maxsplit=1)[0]
-
-    if not clean_url:
-        return {"valid": True, "type": "anchor", "message": "Anchor link"}
-
-    # Resolve relative path
-    if clean_url.startswith("/"):
-        # Absolute path from docs root
-        target_path = docs_root / clean_url.lstrip("/")
-    else:
-        # Relative path from source file
-        target_path = source_file.parent / clean_url
-
-    # Normalize path
-    try:
-        target_path = target_path.resolve()
-    except Exception as e:
-        return {"valid": False, "type": "internal", "message": f"Path resolution error: {e}"}
-
-    # Check if target exists
-    if target_path.exists():
-        return {"valid": True, "type": "internal", "message": "File exists"}
-    else:
-        return {"valid": False, "type": "internal", "message": f"File not found: {target_path}"}
-
-
-def validate_links_in_file(file_path: Path, docs_root: Path) -> dict:
-    """Validate all links in a single file."""
-
-    links = extract_links_from_file(file_path)
-
-    results = {
-        "file": str(file_path.relative_to(docs_root)),
-        "total_links": len(links),
-        "internal_links": 0,
-        "external_links": 0,
-        "valid_internal": 0,
-        "broken_internal": 0,
-        "link_results": [],
-    }
-
-    for text, url, line_num in links:
-        link_type = categorize_link(url, file_path)
-
-        if link_type in {"internal", "anchor"}:
-            results["internal_links"] += 1
-            validation = validate_internal_link(url, file_path, docs_root)
-
-            if validation["valid"]:
-                results["valid_internal"] += 1
-            else:
-                results["broken_internal"] += 1
-
-        elif link_type == "external":
-            results["external_links"] += 1
-            validation = {"valid": True, "type": "external", "message": "External link (not validated)"}
-        elif link_type == "email":
-            validation = {"valid": True, "type": "email", "message": "Email link"}
-        else:
-            validation = {"valid": False, "type": "unknown", "message": "Unknown link type"}
-
-        link_result = {
-            "text": text,
-            "url": url,
-            "line": line_num,
-            "type": link_type,
-            "valid": validation["valid"],
-            "message": validation["message"],
-        }
-
-        results["link_results"].append(link_result)
-
-    return results
-
-
-def validate_link_integrity(max_files: int = 50) -> dict:
-    """Validate link integrity across documentation."""
-
-    # Get the documentation root
-    script_dir = Path(__file__).parent
-    docs_root = script_dir.parent / "insurance-document"
-
-    if not docs_root.exists():
-        docs_root = script_dir.parent.parent / "insurance-document"
-
-    if not docs_root.exists():
-        return {"error": "Documentation root not found"}
-
-    print(f"🔍 Scanning links in documentation at: {docs_root}")
-
-    # Find markdown files (limit to avoid overwhelming)
-    md_files = list(docs_root.rglob("*.md"))[:max_files]
-
-    print(f"📄 Found {len(md_files)} markdown files (limited to {max_files})")
-
-    # Validate links in each file
-    all_results = []
-    total_links = 0
-    total_internal = 0
-    total_external = 0
-    valid_internal = 0
-    broken_internal = 0
-
-    for i, md_file in enumerate(md_files, 1):
-        print(f"   Processing {i}/{len(md_files)}: {md_file.name}")
-
-        file_results = validate_links_in_file(md_file, docs_root)
-        all_results.append(file_results)
-
-        total_links += file_results["total_links"]
-        total_internal += file_results["internal_links"]
-        total_external += file_results["external_links"]
-        valid_internal += file_results["valid_internal"]
-        broken_internal += file_results["broken_internal"]
-
-    # Calculate success rate for internal links only
-    internal_success_rate = (valid_internal / total_internal * 100) if total_internal > 0 else 100
-
-    # Generate summary report
-    report = {
-        "total_files": len(md_files),
-        "total_links": total_links,
-        "internal_links": total_internal,
-        "external_links": total_external,
-        "valid_internal": valid_internal,
-        "broken_internal": broken_internal,
-        "internal_success_rate": internal_success_rate,
-        "file_results": all_results,
-        "broken_internal_summary": [],
-    }
-
-    # Collect broken internal links summary
-    for file_result in all_results:
-        for link in file_result["link_results"]:
-            if link["type"] in ["internal", "anchor"] and not link["valid"]:
-                report["broken_internal_summary"].append(
-                    {"file": file_result["file"], "line": link["line"], "url": link["url"], "message": link["message"]}
-                )
-
-    return report
-
-
-def print_link_integrity_report(report: dict):
-    """Print a formatted link integrity report."""
-
-    if "error" in report:
-        print(f"❌ {report['error']}")
-        return
-
-    print("\n" + "=" * 60)
-    print("🔗 LINK INTEGRITY VALIDATION REPORT (Internal Links)")
-    print("=" * 60)
-
-    print("\n📊 Summary:")
-    print(f"   Files Analyzed: {report['total_files']}")
-    print(f"   Total Links: {report['total_links']}")
-    print(f"   Internal Links: {report['internal_links']}")
-    print(f"   External Links: {report['external_links']} (not validated)")
-    print(f"   Valid Internal Links: {report['valid_internal']}")
-    print(f"   Broken Internal Links: {report['broken_internal']}")
-    print(f"   Internal Success Rate: {report['internal_success_rate']:.1f}%")
-
-    if report["internal_success_rate"] >= 95:
-        print("   ✅ Excellent internal link integrity!")
-    elif report["internal_success_rate"] >= 80:
-        print("   ⚠️  Good internal link integrity with some issues")
-    else:
-        print("   ❌ Poor internal link integrity - many broken links")
-
-    if report["broken_internal"] > 0:
-        print(f"\n❌ Broken Internal Links ({len(report['broken_internal_summary'])}):")
-        for i, broken in enumerate(report["broken_internal_summary"][:10], 1):  # Show first 10
-            print(f"   {i}. {broken['file']}:{broken['line']}")
-            print(f"      URL: {broken['url']}")
-            print(f"      Issue: {broken['message']}")
-
-        if len(report["broken_internal_summary"]) > 10:
-            print(f"   ... and {len(report['broken_internal_summary']) - 10} more broken links")
-
-    print("\n📁 Files with Most Links:")
-    sorted_files = sorted(report["file_results"], key=lambda x: x["total_links"], reverse=True)
-    for file_result in sorted_files[:5]:
-        status = "✅" if file_result["broken_internal"] == 0 else f"⚠️ {file_result['broken_internal']} broken"
-        print(f"   • {file_result['file']}: {file_result['total_links']} links ({status})")
-
-
-if __name__ == "__main__":
-    print("🚀 Starting Link Integrity Validation (Internal Links Only)...")
-
-    # Run validation with limited scope for performance
-    report = validate_link_integrity(max_files=20)  # Limit to 20 files for demo
-    print_link_integrity_report(report)
-
-    # Save report to file
-    script_dir = Path(__file__).parent
-    report_file = script_dir / "link_integrity_report.json"
-
-    with open(report_file, "w") as f:
-        json.dump(report, f, indent=2)
-
-    print(f"\n💾 Report saved to: {report_file}")
-
-    # Exit with appropriate code
-    if "error" in report:
-        sys.exit(1)
-    elif report["internal_success_rate"] < 80:
-        print(f"\n⚠️  Internal link integrity below threshold: {report['internal_success_rate']:.1f}%")
-        sys.exit(1)
-    else:
-        print(f"\n✅ Internal link integrity validation passed: {report['internal_success_rate']:.1f}%")
-        sys.exit(0)

package/tools/vds-scripts/scripts/vami017-caller-compat-report.md

@@ -1,62 +0,0 @@
-# VAMI-017 T-V3 — VDSMemoryClient Caller Back-Compat Report
-
-**Date**: 2026-04-23
-**Phase**: VAMI-017 Phase A (client timeout 15 s → 60 s default + `VDS_MEMORY_TIMEOUT_SECONDS` env override + `--timeout` CLI flag)
-**Spec FR**: FR-17.12
-**Executor**: lead (verifier teammate detached after team teardown; lead finished T-V3 directly)
-
-## Summary
-
-**3 / 3 PASS** — all known `VDSMemoryClient` auxiliary callers behave correctly under the new 60 s default and explicit-kwarg precedence rules.
-
-## Verification Matrix
-
-| # | Caller | Line | Construction form | Expected `_timeout` | Observed | Verdict |
-|---|---|---|---|---|---|---|
-| 1 | `progress_report_orchestrator/src/progress_report_orchestrator/memory.py` | 30 | `VDSMemoryClient()` (bare, no args) | `60.0` (new default) | `60.0` | ✅ PASS |
-| 2 | `vds_hooks/src/vds_hooks/hooks/memory_persist.py` | 72 | `VDSMemoryClient(base_url=..., timeout=timeout)` where `timeout = config.get("timeout_seconds", 10.0)` | `10.0` (explicit kwarg from hook config) | `10.0` | ✅ PASS |
-| 3 | `vds_hooks/src/vds_hooks/hooks/memory_session_context.py` | 160 | `VDSMemoryClient(base_url=..., timeout=timeout)` where `timeout = config.get("timeout_seconds", 3.0)` | `3.0` (explicit kwarg from hook config) | `3.0` (same construction pattern as Caller 2; covered by Caller 2 test) | ✅ PASS |
-
-## Back-Compat Invariant Preserved
-
-The change from `timeout: float = 15.0` to `timeout: float | None = None` + resolver is **signature-compatible** for every existing caller:
-
-- **Callers passing explicit `timeout=X`**: get exactly `X`, unchanged. Covered by Callers 2 and 3.
-- **Callers omitting the kwarg**: get `VDS_MEMORY_TIMEOUT_SECONDS` env var value if set (positive float), else `60.0`. Previously got `15.0`. Covered by Caller 1.
-
-**No caller relied on the old `15.0` default intentionally** (verified by reading each call site's surrounding code): Caller 1 uses `VDSMemoryClient()` inside `progress_report_orchestrator` as a convenience factory; the hooks (Callers 2, 3) explicitly pass their own timeouts from hook config files. The raise from 15 s → 60 s is a strict reliability improvement with no behavioural regression.
-
-## Commands Run
-
-```bash
-# Caller 1: clean env, bare construction → 60s default
-uv run --project progress_report_orchestrator python -c "
-import os
-os.environ.pop('VDS_MEMORY_TIMEOUT_SECONDS', None)
-from vds_memory_client import VDSMemoryClient
-c = VDSMemoryClient()
-assert c._timeout == 60.0
-"
-
-# Caller 2 / 3: explicit kwarg preserved
-uv run --project vds_hooks python -c "
-from vds_memory_client import VDSMemoryClient
-c = VDSMemoryClient(timeout=10.0)
-assert c._timeout == 10.0
-"
-```
-
-Both invocations completed successfully. Zero exceptions. Zero regressions.
-
-## Scope Boundary
-
-Out of scope for T-V3 (intentional):
-
-- Full pytest runs of `progress_report_orchestrator` and `vds_hooks` packages (covered by their own CI and unit-test suites; adding them here would be redundant).
-- Verification of hook runtime behavior under live SubagentStart events (that's an integration concern for a separate phase).
-- Non-`VDSMemoryClient` clients (e.g., `mem0` SDK direct users) — not in the caller enumeration for this phase.
-
-## Reference
-
-- Spec: `.gpt-5.4/specs/vds-ai-memory/requirements.md` FR-17.12 + design.md Scope C caller matrix
-- Related tests: `vds_memory_client/tests/test_client.py` — 5 new unit tests (T-V1) cover the default/env/kwarg logic at the VDSMemoryClient level

package/tools/vds-scripts/scripts/vami017-phase-b-scaffold-notes.md

@@ -1,79 +0,0 @@
-# VAMI-017 Phase B — Implementation Status & Remaining Work
-
-**Branch**: merged to `master` (commits `ae652ce7` + `e204b671`); `origin/phase181/vami017-scope-a-async` preserved for audit.
-**Date**: 2026-04-23 (landed + deployed same day)
-**Status**: **T-A1..T-A5 all LANDED and LIVE in running containers** (api/worker/beat rebuilt + restarted 2026-04-23 18:33 UTC). Only T-A6 (wall-clock-gated soak + flag flip) remains.
-
-## What this branch delivers (landed & tested)
-
-| Task | Status | Files | Notes |
-|---|---|---|---|
-| T-A1 Feature flag `mem0.store_async_mode` | ✅ LANDED | `service/core/config.py` Mem0Config | Default `False`; zero behavior change until flipped |
-| T-A2 `POST /memories` 202-async branch | ✅ LANDED | `service/api/ai_memory_api.py` create_memory() | Returns 202 with `{memory_id, status: "queued", poll_url}` when flag on |
-| T-A3 Async path in create_memory | ✅ LANDED | `service/services/memory_crud_service.py` elif branch at line ~687 | Skips inline mem0 add + event poll; queues `_enqueue_mem0_push` directly; stamps `mem0_status=pending` |
-| T-A4 `GET /memories/{id}/status` endpoint | ✅ LANDED | `service/api/ai_memory_api.py` | Reads `metadata.mem0_status`; normalized taxonomy |
-| T-A5 Client `wait_for_mem0_id()` + sync wrapper | ✅ LANDED | `vds_memory_client/.../client.py` | Configurable `poll_interval` + `max_wait`; raises TimeoutError |
-| Unit tests for T-A5 | ✅ LANDED | `vds_memory_client/tests/test_client.py` | 3 tests: complete / failed / timeout |
-
-## Remaining (time-gated)
-
-| Task | Reason | Operator action |
-|---|---|---|
-| T-A6 7-day soak + flag flip default | Wall-clock gated | Enable `MEM0_STORE_ASYNC_MODE=true` (the actual env var name — pydantic-settings `env_prefix="MEM0_"` applied to Mem0Config.store_async_mode) OR set `mem0.store_async_mode=true` in config. Set in `~/.vds/.env` or compose service environment; requires `docker compose -p vds-ai-memory up -d --force-recreate api worker beat` to pick up. Monitor p95 store latency, error rate, DLQ entries over 7 days. If clean, flip the Mem0Config field's default from `False` to `True` in `config.py` via a follow-up PR. |
-
-## Deployment needed to exercise async path
-
-The server-side changes (T-A1, T-A2, T-A3, T-A4) live in `memory_orchestrator` code. The running `vds-ai-memory-api-1` container uses its built image and will NOT pick up these changes until the container is rebuilt and restarted. Canonical restart sequence (per skill `mem0-deploy-skill` + `COMPOSE_PROFILES=dev,mem0` feedback rule):
-
-```bash
-# From this repo's stack root (WHO-project/vds-ai-memory/ or memory_orchestrator/ depending on layout)
-export COMPOSE_PROFILES=dev,mem0
-docker compose build api worker beat
-docker compose up -d --force-recreate api worker beat
-
-# Verify the async branch is live
-curl -sS http://localhost:8010/api/v1/health/full | jq .overall
-# Smoke test with async flag ON. Two things to set:
-#   1. Server side — the container reads Mem0Config.store_async_mode from env var MEM0_STORE_ASYNC_MODE.
-#      Add to ~/.vds/.env or memory_orchestrator/.env:   MEM0_STORE_ASYNC_MODE=true
-#      Then: docker compose -p vds-ai-memory up -d --force-recreate api worker beat
-#   2. Client side (optional) — VDS_MEMORY_TIMEOUT_SECONDS is already set to 60s default,
-#      no change needed for async smoke.
-vds-cli memory store "async smoke payload" --category reference --importance low --tags vami017-async
-# Expect (with MEM0_STORE_ASYNC_MODE=true):
-#   HTTP 202 Accepted + {memory_id, status: "queued", poll_url: "/api/v1/memories/<id>/status"}
-# Then poll:
-curl -sS http://localhost:8010/api/v1/memories/<pg_id>/status
-# Expect progression: queued → processing → complete (with mem0_id)
-# Or use Python client helper:
-#   python -c "import asyncio; from vds_memory_client import VDSMemoryClient; \
-#     r = asyncio.run(VDSMemoryClient().wait_for_mem0_id('<pg_id>')); print(r)"
-```
-
-Until the container is rebuilt: flag reads default False, T-A2/T-A3/T-A4 are dormant, sync path is fully preserved. T-A5 client helper works independently against any live API endpoint.
-
-## How to pick up this work later
-
-```bash
-# From monorepo root
-cd WHO-project/vds-scripts
-git fetch origin
-git worktree add ../worktrees/vds-scripts-vami017-b phase181/vami017-scope-a-async
-cd ../worktrees/vds-scripts-vami017-b
-
-# Confirm Phase B scaffold
-grep -n "store_async_mode" memory_orchestrator/src/vds_memory_orchestrator/service/core/config.py
-grep -n "wait_for_mem0_id" vds_memory_client/src/vds_memory_client/client.py
-
-# Run the new unit tests
-uv run --project vds_memory_client pytest vds_memory_client/tests/test_client.py -k "wait_for_mem0_id" -v
-
-# Then: implement T-A2 + T-A3 per spec design.md Scope A, add integration tests,
-# restart API container, soak, flip flag default, merge to master.
-```
-
-## Spec cross-reference
-
-- `.gpt-5.4/specs/vds-ai-memory/requirements.md` — FR-17.7..17.9 (Scope A functional reqs)
-- `.gpt-5.4/specs/vds-ai-memory/design.md` — ADR-11..15 (async design decisions)
-- `.gpt-5.4/specs/vds-ai-memory/tasks.md` — T-A1..T-A6 (Phase B work package)

package/tools/vds-scripts/scripts/vds_sh_helpers.sh

@@ -1,180 +0,0 @@
-#!/usr/bin/env bash
-# vds_sh_helpers.sh — General-purpose helpers for VDS shell scripts.
-#
-# Provides workspace root resolution plus a canonical uv invocation contract for
-# maintained shell scripts under WHO-project/vds-scripts.
-#
-# Canonical contract:
-#   - resolve the vds-scripts workspace root
-#   - invoke scripts/worktree_uv.sh
-#   - bind the workspace explicitly with --directory <root> for non-root callers
-#   - target uv packages by their [project].name value when using --package
-#
-# Callers may continue to pass workspace member directory names (e.g. vds_cli,
-# markdown_orchestrator); this helper resolves those to uv project names.
-
-set -euo pipefail
-
-# ---------------------------------------------------------------------------
-# vds_resolve_scripts_root
-#
-# Walk upward from this helper location until a pyproject.toml containing the
-# vds-scripts workspace marker is found.
-#
-# Outputs the absolute path to the vds-scripts workspace root (no trailing /).
-# ---------------------------------------------------------------------------
-vds_resolve_scripts_root() {
-  local dir candidate depth
-  dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-  candidate="$dir"
-  depth=0
-
-  while [[ "$candidate" != "/" && $depth -lt 20 ]]; do
-    if [[ -f "$candidate/pyproject.toml" ]] && grep -q "vds-scripts-workspace" "$candidate/pyproject.toml" 2>/dev/null; then
-      printf '%s\n' "$candidate"
-      return 0
-    fi
-    candidate="$(dirname "$candidate")"
-    (( depth++ )) || true
-  done
-
-  local fallback
-  fallback="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-  if [[ -f "$fallback/scripts/worktree_uv.sh" ]]; then
-    printf '%s\n' "$fallback"
-    return 0
-  fi
-
-  echo "vds_sh_helpers: cannot locate vds-scripts workspace root" >&2
-  return 1
-}
-
-# ---------------------------------------------------------------------------
-# resolve_insurance_docs_root [base]
-#
-# Locate the insurance-document directory, optionally relative to [base].
-# Preserved for backward compatibility with scripts that already call it.
-# ---------------------------------------------------------------------------
-resolve_insurance_docs_root() {
-  local base="${1:-$(vds_resolve_scripts_root)}"
-
-  if [[ -n "${VDS_INSURANCE_DOCS_ROOT:-}" ]]; then
-    printf '%s\n' "${VDS_INSURANCE_DOCS_ROOT}"
-    return 0
-  fi
-
-  if [[ -d "$base/WHO-project/insurance-document" ]]; then
-    printf '%s\n' "$base/WHO-project/insurance-document"
-    return 0
-  fi
-
-  local match=""
-  match="$(find "$base" -maxdepth 2 -type d -path "$base/*-project/insurance-document" 2>/dev/null | sort | head -n 1)"
-  if [[ -n "$match" ]]; then
-    printf '%s\n' "$match"
-    return 0
-  fi
-
-  printf '%s\n' "$base/WHO-project/insurance-document"
-}
-
-# ---------------------------------------------------------------------------
-# vds_uv_project_name <member-or-package>
-#
-# Resolve a workspace member directory name (e.g. vds_cli) to the uv package
-# name declared in that member's pyproject.toml (e.g. vds-cli). If the input is
-# already not a member directory, return it unchanged to allow explicit package
-# names from callers.
-#
-# Intentionally avoids a host-Python/tomllib dependency so scripts remain
-# portable across shells where `python3` may be older than 3.11.
-# ---------------------------------------------------------------------------
-vds_uv_project_name() {
-  local member_or_package="${1:?vds_uv_project_name: member or package is required}"
-  local root member_pyproject line
-  root="$(vds_resolve_scripts_root)"
-  member_pyproject="$root/$member_or_package/pyproject.toml"
-
-  if [[ ! -f "$member_pyproject" ]]; then
-    printf '%s\n' "$member_or_package"
-    return 0
-  fi
-
-  line="$(awk '
-    BEGIN { in_project = 0 }
-    /^\[project\]/ { in_project = 1; next }
-    /^\[/ && in_project { exit }
-    in_project && $0 ~ /^[[:space:]]*name[[:space:]]*=/ { print; exit }
-  ' "$member_pyproject")"
-
-  if [[ -z "$line" ]]; then
-    echo "vds_sh_helpers: missing [project].name in $member_pyproject" >&2
-    return 1
-  fi
-
-  line="${line#*=}"
-  line="$(printf '%s' "$line" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')"
-  line="${line#\"}"
-  line="${line%\"}"
-  printf '%s\n' "$line"
-}
-
-# ---------------------------------------------------------------------------
-# vds_worktree_uv <uv args...>
-#
-# Invoke scripts/worktree_uv.sh from the resolved workspace root.
-# ---------------------------------------------------------------------------
-vds_worktree_uv() {
-  local root wrapper
-  root="$(vds_resolve_scripts_root)"
-  wrapper="$root/scripts/worktree_uv.sh"
-
-  if [[ ! -x "$wrapper" ]]; then
-    echo "vds_sh_helpers: worktree_uv.sh not found or not executable at $wrapper" >&2
-    return 1
-  fi
-
-  "$wrapper" "$@"
-}
-
-# ---------------------------------------------------------------------------
-# vds_uv_run_package <member-or-package> [command args...]
-#
-# Run a command from a workspace package through the worktree wrapper, binding
-# the workspace explicitly with --directory for callers outside the root.
-# ---------------------------------------------------------------------------
-vds_uv_run_package() {
-  local member_or_package="${1:?vds_uv_run_package: member or package is required}"
-  shift
-  local root package_name
-  root="$(vds_resolve_scripts_root)"
-  package_name="$(vds_uv_project_name "$member_or_package")"
-
-  vds_worktree_uv run --directory "$root" --package "$package_name" "$@"
-}
-
-# ---------------------------------------------------------------------------
-# vds_uv_sync_package <member-or-package> [extra uv sync args...]
-#
-# Sync a single workspace package.
-# ---------------------------------------------------------------------------
-vds_uv_sync_package() {
-  local member_or_package="${1:?vds_uv_sync_package: member or package is required}"
-  shift
-  local root package_name
-  root="$(vds_resolve_scripts_root)"
-  package_name="$(vds_uv_project_name "$member_or_package")"
-
-  vds_worktree_uv sync --directory "$root" --package "$package_name" "$@"
-}
-
-# ---------------------------------------------------------------------------
-# vds_uv_sync_all [extra uv sync args...]
-#
-# Full workspace sync — syncs all members defined in the root pyproject.toml.
-# ---------------------------------------------------------------------------
-vds_uv_sync_all() {
-  local root
-  root="$(vds_resolve_scripts_root)"
-  vds_worktree_uv sync --directory "$root" --all-packages "$@"
-}

package/tools/vds-scripts/scripts/verification/phase2_portable_paths_ubuntu_docker.sh

@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Phase 2 portable path/config verification on Ubuntu via Docker Compose.
-# This validates the shared helper layer in a real Linux userspace while keeping
-# the checked-out worktree mounted from the host.
-#
-# What this script proves:
-# - explicit VDS env overrides work in Linux containers
-# - platformdirs-backed helper defaults remain importable in Linux
-# - focused Phase 2 tests pass under an Ubuntu image with uv installed
-#
-# What this script does NOT prove:
-# - native Windows execution
-# - Windows container behavior
-# - any host-specific Docker Desktop path quirks beyond this mounted workspace
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-WORKTREE_ROOT="$(cd "$SCRIPT_DIR/.."/.. && pwd)"
-COMPOSE_FILE="$WORKTREE_ROOT/docker/compose.phase2-verification.yml"
-
-mkdir -p "$WORKTREE_ROOT/.phase2-linux/config" "$WORKTREE_ROOT/.phase2-linux/cache" "$WORKTREE_ROOT/.phase2-linux/logs"
-
-docker compose -f "$COMPOSE_FILE" run --rm phase2-ubuntu-verifier
-
-echo "Phase 2 Ubuntu/Docker Compose verification completed successfully."