devsquad 4.3.0__tar.gz → 4.3.1__tar.gz

{devsquad-4.3.0 → devsquad-4.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devsquad
-Version: 4.3.0
+Version: 4.3.1
 Summary: Production-Ready Multi-Role AI Task Orchestrator
 Author-email: DevSquad Team <devsquad@example.com>
 License: MIT
@@ -103,7 +103,7 @@ Dynamic: license-file
   <img alt="Python" src="https://img.shields.io/badge/Python-3.10+-blue?logo=python&logoColor=white" />
   <img alt="License" src="https://img.shields.io/badge/License-MIT-green" />
   <img alt="Tests" src="https://img.shields.io/badge/Tests-7681%20passing-brightgreen" />
-  <img alt="Version" src="https://img.shields.io/badge/V4.3.0-success" />
+  <img alt="Version" src="https://img.shields.io/badge/V4.3.1-success" />
   <img alt="CI" src="https://img.shields.io/badge/CI-GitHub_Actions-blue?logo=githubactions" />
   <img alt="Quality" src="https://img.shields.io/badge/Code%20Quality-4.3%2F5%20%E2%98%85%E2%98%85%E2%98%85%E2%98%85%E2%98%86-blue" />
   <img alt="Security" src="https://img.shields.io/badge/Security-5%2F5%20%E2%98%85%E2%98%85%E2%98%85%E2%98%85%E2%98%85-success" />

{devsquad-4.3.0 → devsquad-4.3.1}/README.md

@@ -10,7 +10,7 @@
   <img alt="Python" src="https://img.shields.io/badge/Python-3.10+-blue?logo=python&logoColor=white" />
   <img alt="License" src="https://img.shields.io/badge/License-MIT-green" />
   <img alt="Tests" src="https://img.shields.io/badge/Tests-7681%20passing-brightgreen" />
-  <img alt="Version" src="https://img.shields.io/badge/V4.3.0-success" />
+  <img alt="Version" src="https://img.shields.io/badge/V4.3.1-success" />
   <img alt="CI" src="https://img.shields.io/badge/CI-GitHub_Actions-blue?logo=githubactions" />
   <img alt="Quality" src="https://img.shields.io/badge/Code%20Quality-4.3%2F5%20%E2%98%85%E2%98%85%E2%98%85%E2%98%85%E2%98%86-blue" />
   <img alt="Security" src="https://img.shields.io/badge/Security-5%2F5%20%E2%98%85%E2%98%85%E2%98%85%E2%98%85%E2%98%85-success" />

{devsquad-4.3.0 → devsquad-4.3.1}/devsquad.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devsquad
-Version: 4.3.0
+Version: 4.3.1
 Summary: Production-Ready Multi-Role AI Task Orchestrator
 Author-email: DevSquad Team <devsquad@example.com>
 License: MIT
@@ -103,7 +103,7 @@ Dynamic: license-file
   <img alt="Python" src="https://img.shields.io/badge/Python-3.10+-blue?logo=python&logoColor=white" />
   <img alt="License" src="https://img.shields.io/badge/License-MIT-green" />
   <img alt="Tests" src="https://img.shields.io/badge/Tests-7681%20passing-brightgreen" />
-  <img alt="Version" src="https://img.shields.io/badge/V4.3.0-success" />
+  <img alt="Version" src="https://img.shields.io/badge/V4.3.1-success" />
   <img alt="CI" src="https://img.shields.io/badge/CI-GitHub_Actions-blue?logo=githubactions" />
   <img alt="Quality" src="https://img.shields.io/badge/Code%20Quality-4.3%2F5%20%E2%98%85%E2%98%85%E2%98%85%E2%98%85%E2%98%86-blue" />
   <img alt="Security" src="https://img.shields.io/badge/Security-5%2F5%20%E2%98%85%E2%98%85%E2%98%85%E2%98%85%E2%98%85-success" />

{devsquad-4.3.0 → devsquad-4.3.1}/devsquad.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ scripts/collaboration/async_coordinator.py
 scripts/collaboration/async_llm_backend.py
 scripts/collaboration/audit_logger.py
 scripts/collaboration/batch_scheduler.py
+scripts/collaboration/benchmark_regression_checker.py
 scripts/collaboration/cache_interface.py
 scripts/collaboration/ccr_store.py
 scripts/collaboration/checkpoint_manager.py

{devsquad-4.3.0 → devsquad-4.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devsquad"
-version = "4.3.0"
+version = "4.3.1"
 description = "Production-Ready Multi-Role AI Task Orchestrator"
 readme = "README.md"
 license = {text = "MIT"}

devsquad-4.3.1/scripts/collaboration/_version.py

@@ -0,0 +1 @@
+__version__ = "4.3.1"

devsquad-4.3.1/scripts/collaboration/benchmark_regression_checker.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""BenchmarkRegressionChecker -- V4.3.1 Phase 1 P1-1.
+
+P11 lifecycle gate checker that detects performance benchmark
+regressions by comparing a current snapshot against a baseline.
+
+Architecture reference: docs/analysis/2026-07-25_V4.3.1_plan.md sec 3.1
+Test plan: tests/unit/test_benchmark_regression_checker.py
+
+Skill integration (anti-ghost feature):
+- Integration point: ``unified_gate_engine.py`` P11 lifecycle gate
+- Trigger: dispatcher auto-invokes via
+  ``lifecycle_gate_check(phase="P11", ...)``
+- User visibility: Markdown report "Benchmark Regression" section
+- CI check: module call count > 0 (verified by
+  ``check_module_activation.py``)
+
+Regression model
+----------------
+For each metric present in both snapshots::
+
+    regression_percent = (current - baseline) / baseline * 100
+
+Positive values indicate slowdown (regression); negative values
+indicate speedup (improvement). A metric is flagged as regressed when
+its regression percentage strictly exceeds ``threshold_percent``. The
+report's ``regression_percent`` is the maximum across all comparable
+metrics, so a single slow metric raises the overall number even if
+others improved.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Literal
+
+from scripts.collaboration._version import __version__
+
+logger = logging.getLogger(__name__)
+
+RegressionLevel = Literal["none", "minor", "major", "critical"]
+
+
+@dataclass(slots=True)
+class BenchmarkMetric:
+    """A single benchmark measurement.
+
+    Attributes
+    ----------
+    name:
+        Metric identifier (e.g. ``"dispatch_p95_ms"``,
+        ``"memory_peak_mb"``).
+    value:
+        Measured value (float for latencies, int for counts).
+    unit:
+        Unit string (e.g. ``"ms"``, ``"MB"``, ``"ops/sec"``).
+    """
+
+    name: str
+    value: float
+    unit: str
+
+
+@dataclass(slots=True)
+class BenchmarkSnapshot:
+    """A versioned benchmark snapshot.
+
+    Attributes
+    ----------
+    version:
+        DevSquad version string (e.g. ``"4.3.0"``).
+    timestamp:
+        Unix timestamp of snapshot collection.
+    metrics:
+        List of :class:`BenchmarkMetric` instances.
+    """
+
+    version: str
+    timestamp: float
+    metrics: list[BenchmarkMetric] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class BenchmarkReport:
+    """Result of comparing current metrics against a baseline.
+
+    Attributes
+    ----------
+    regression_detected:
+        ``True`` if any metric regressed beyond its threshold.
+    regression_percent:
+        Maximum regression percentage across all comparable metrics
+        (``0.0`` when no metrics overlap). Positive value means
+        slowdown; negative means speedup.
+    regressed_metrics:
+        Names of metrics that exceeded the regression threshold.
+    baseline_version:
+        Version string of the baseline snapshot.
+    current_version:
+        Version string of the current snapshot.
+    threshold_percent:
+        Regression threshold in percent (default ``10.0``).
+    """
+
+    regression_detected: bool
+    regression_percent: float
+    regressed_metrics: list[str] = field(default_factory=list)
+    baseline_version: str = ""
+    current_version: str = ""
+    threshold_percent: float = 10.0
+
+    def to_markdown(self) -> str:
+        """Render the report as a Markdown section.
+
+        Returns
+        -------
+        str
+            Markdown text with a ``Benchmark Regression`` header and
+            fields for baseline/current version, threshold, max
+            regression percentage, regressed metric names, and a
+            status line.
+        """
+        status = "REGRESSION DETECTED" if self.regression_detected else "OK"
+        regressed_str = (
+            ", ".join(self.regressed_metrics) if self.regressed_metrics else "(none)"
+        )
+        lines = [
+            "## Benchmark Regression",
+            "",
+            f"- **Baseline version**: {self.baseline_version}",
+            f"- **Current version**: {self.current_version}",
+            f"- **Threshold**: {self.threshold_percent}%",
+            f"- **Max regression**: {self.regression_percent}%",
+            f"- **Regressed metrics**: {regressed_str}",
+            f"- **Status**: {status}",
+        ]
+        return "\n".join(lines)
+
+
+def _compute_regression_percent(baseline_value: float, current_value: float) -> float:
+    """Compute the regression percentage for a single metric.
+
+    Regression percent = ``(current - baseline) / baseline * 100``.
+    Positive means slowdown; negative means speedup. When the
+    baseline is ``0``, returns ``0.0`` to avoid division-by-zero
+    (a zero baseline carries no meaningful ratio).
+
+    Parameters
+    ----------
+    baseline_value:
+        The baseline metric value.
+    current_value:
+        The current metric value.
+
+    Returns
+    -------
+    float
+        The regression percentage.
+    """
+    if baseline_value == 0:
+        return 0.0
+    return (current_value - baseline_value) / baseline_value * 100.0
+
+
+class BenchmarkRegressionChecker:
+    """Detects performance benchmark regressions between two snapshots.
+
+    Compares a current :class:`BenchmarkSnapshot` against a baseline
+    and flags any metric whose value increased (slowed down) beyond a
+    configurable threshold.
+
+    Parameters
+    ----------
+    threshold_percent:
+        Regression threshold in percent. A metric is flagged when its
+        regression percentage strictly exceeds this value. Defaults to
+        ``10.0`` (a 10% slowdown is tolerated, but ``10.01%`` is
+        flagged).
+
+    Example
+    -------
+    >>> checker = BenchmarkRegressionChecker(threshold_percent=10.0)
+    >>> baseline = BenchmarkSnapshot("4.2.9", 0.0, [
+    ...     BenchmarkMetric("dispatch_p95_ms", 100.0, "ms"),
+    ... ])
+    >>> current = BenchmarkSnapshot("4.3.0", 0.0, [
+    ...     BenchmarkMetric("dispatch_p95_ms", 125.0, "ms"),
+    ... ])
+    >>> report = checker.compare(baseline, current)
+    >>> report.regression_detected
+    True
+    """
+
+    def __init__(self, threshold_percent: float = 10.0) -> None:
+        self.threshold_percent = threshold_percent
+
+    def compare(
+        self,
+        baseline: BenchmarkSnapshot,
+        current: BenchmarkSnapshot,
+    ) -> BenchmarkReport:
+        """Compare two snapshots and return a regression report.
+
+        Only metrics present in both snapshots are compared. The
+        report's ``regression_percent`` is the maximum regression
+        percentage across all comparable metrics (``0.0`` when no
+        metrics overlap). A metric is added to ``regressed_metrics``
+        when its regression percentage strictly exceeds
+        ``threshold_percent``.
+
+        Parameters
+        ----------
+        baseline:
+            The baseline snapshot to compare against.
+        current:
+            The current snapshot to evaluate.
+
+        Returns
+        -------
+        BenchmarkReport
+            The regression report with version fields populated from
+            the snapshots.
+        """
+        baseline_map = {m.name: m.value for m in baseline.metrics}
+        current_map = {m.name: m.value for m in current.metrics}
+
+        regressions: list[tuple[str, float]] = []
+        for name, current_value in current_map.items():
+            if name not in baseline_map:
+                continue
+            baseline_value = baseline_map[name]
+            regression = _compute_regression_percent(baseline_value, current_value)
+            regressions.append((name, regression))
+
+        if not regressions:
+            max_regression = 0.0
+            regressed_names: list[str] = []
+        else:
+            max_regression = max(r for _, r in regressions)
+            regressed_names = [
+                name for name, r in regressions if r > self.threshold_percent
+            ]
+
+        return BenchmarkReport(
+            regression_detected=len(regressed_names) > 0,
+            regression_percent=max_regression,
+            regressed_metrics=regressed_names,
+            baseline_version=baseline.version,
+            current_version=current.version,
+            threshold_percent=self.threshold_percent,
+        )
+
+    def run_live_benchmark(self) -> BenchmarkSnapshot:
+        """Run a live benchmark and return the snapshot.
+
+        This is a mock implementation that returns representative
+        metrics. In production, this would invoke the actual benchmark
+        suite (e.g. ``pytest --benchmark``). The mock metrics model a
+        typical dispatch pipeline: ``dispatch_p95_ms`` and
+        ``memory_peak_mb``.
+
+        Returns
+        -------
+        BenchmarkSnapshot
+            A snapshot tagged with the current package version, the
+            current wall-clock timestamp, and mock metrics
+            (``dispatch_p95_ms=120.0ms``, ``memory_peak_mb=200.0MB``).
+        """
+        metrics = [
+            BenchmarkMetric("dispatch_p95_ms", 120.0, "ms"),
+            BenchmarkMetric("memory_peak_mb", 200.0, "MB"),
+        ]
+        return BenchmarkSnapshot(
+            version=__version__,
+            timestamp=time.time(),
+            metrics=metrics,
+        )
+
+
+def _default_baseline(baseline_version: str) -> BenchmarkSnapshot:
+    """Build the default baseline snapshot for lifecycle_gate_check.
+
+    Parameters
+    ----------
+    baseline_version:
+        Version string to embed in the baseline snapshot.
+
+    Returns
+    -------
+    BenchmarkSnapshot
+        Baseline with ``dispatch_p95_ms=100.0ms`` and
+        ``memory_peak_mb=200.0MB``.
+    """
+    return BenchmarkSnapshot(
+        version=baseline_version,
+        timestamp=0.0,
+        metrics=[
+            BenchmarkMetric("dispatch_p95_ms", 100.0, "ms"),
+            BenchmarkMetric("memory_peak_mb", 200.0, "MB"),
+        ],
+    )
+
+
+def lifecycle_gate_check(
+    phase: str,
+    baseline_version: str,
+    current_version: str | None = None,
+    threshold_percent: float = 10.0,
+    baseline_snapshot: BenchmarkSnapshot | None = None,
+    current_snapshot: BenchmarkSnapshot | None = None,
+) -> BenchmarkReport:
+    """P11 lifecycle gate entry point.
+
+    Args:
+        phase: Lifecycle phase, must be ``"P11"``.
+        baseline_version: Version string of the baseline.
+        current_version: Current version (defaults to package
+            ``__version__``).
+        threshold_percent: Regression threshold in percent.
+        baseline_snapshot: Injected baseline (for testing). If
+            ``None``, uses the default baseline (100ms / 200MB).
+        current_snapshot: Injected current metrics (for testing). If
+            ``None``, runs the live benchmark.
+
+    Returns:
+        BenchmarkReport with ``regression_detected`` flag. The
+        ``baseline_version`` / ``current_version`` fields are set from
+        the function arguments (parameters take precedence over
+        snapshot-embedded versions).
+
+    Raises:
+        ValueError: If ``phase != "P11"``.
+
+    Example
+    -------
+    >>> report = lifecycle_gate_check(
+    ...     phase="P11",
+    ...     baseline_version="4.2.9",
+    ...     current_version="4.3.0",
+    ... )
+    >>> isinstance(report, BenchmarkReport)
+    True
+    """
+    if phase != "P11":
+        raise ValueError("BenchmarkRegressionChecker only supports P11 phase")
+
+    resolved_current_version = (
+        current_version if current_version is not None else __version__
+    )
+    baseline = (
+        baseline_snapshot
+        if baseline_snapshot is not None
+        else _default_baseline(baseline_version)
+    )
+    current = (
+        current_snapshot
+        if current_snapshot is not None
+        else BenchmarkRegressionChecker().run_live_benchmark()
+    )
+
+    checker = BenchmarkRegressionChecker(threshold_percent)
+    report = checker.compare(baseline, current)
+    # Function parameters take precedence over snapshot-embedded versions.
+    report.baseline_version = baseline_version
+    report.current_version = resolved_current_version
+    return report
+
+
+__all__ = [
+    "BenchmarkMetric",
+    "BenchmarkSnapshot",
+    "BenchmarkReport",
+    "RegressionLevel",
+    "lifecycle_gate_check",
+    "BenchmarkRegressionChecker",
+]

{devsquad-4.3.0 → devsquad-4.3.1}/scripts/collaboration/output_validator.py

@@ -29,6 +29,7 @@ deferred to Phase 3.
 
 from __future__ import annotations
 
+import base64
 import logging
 import re
 from dataclasses import dataclass, field
@@ -37,7 +38,14 @@ from typing import Literal
 logger = logging.getLogger(__name__)
 
 
-FindingCategory = Literal["code_injection", "sensitive_info", "path_leak", "prompt_injection"]
+FindingCategory = Literal[
+    "code_injection",
+    "sensitive_info",
+    "path_leak",
+    "prompt_injection",
+    "base64_encoded_leak",
+    "unicode_homoglyph",
+]
 FindingSeverity = Literal["low", "medium", "high"]
 
 
@@ -213,11 +221,44 @@ class OutputValidator:
         (r"(?i)\bshutdown\s+(?:now|immediately|-h\s+now)\b", "destructive_shutdown", "high"),
     ]
 
+    # V4.3.1: Base64-encoded sensitive content leakage detection.
+    # Strategy: detect JWT-like 3-segment base64 (eyJ prefix) and long
+    # base64 blobs (>=64 chars). For long blobs, attempt to decode and
+    # check if decoded content contains known sensitive patterns.
+    BASE64_ENCODED_LEAK_PATTERNS: list[tuple[str, str, FindingSeverity]] = [
+        # JWT-like 3-segment base64 (eyJ prefix)
+        (r"\beyJ[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\b",
+         "base64_jwt_token", "high"),
+        # Long base64 string (>=64 chars, may encode keys/credentials)
+        (r"\b[A-Za-z0-9+/]{64,}={0,2}\b", "base64_long_blob", "medium"),
+    ]
+
+    # V4.3.1: Unicode homoglyph attack detection.
+    # Strategy: detect common confusable characters (Cyrillic/Greek
+    # substitutes for Latin letters) using a static whitelist (no
+    # external dependency on a confusables database).
+    UNICODE_HOMOGLYPH_PATTERNS: list[tuple[str, str, FindingSeverity]] = [
+        # Cyrillic 'a' (U+0430 lowercase, U+0410 uppercase) for Latin 'a'
+        (r"[\u0430\u0410]", "homoglyph_cyrillic_a", "medium"),
+        # Cyrillic 'e' (U+0435 lowercase, U+0415 uppercase) for Latin 'e'
+        (r"[\u0435\u0415]", "homoglyph_cyrillic_e", "medium"),
+        # Cyrillic 'o' (U+043E lowercase, U+041E uppercase) for Latin 'o'
+        (r"[\u043e\u041e]", "homoglyph_cyrillic_o", "medium"),
+        # Cyrillic 'p' (U+0440 lowercase, U+0420 uppercase) for Latin 'p'
+        (r"[\u0440\u0420]", "homoglyph_cyrillic_p", "medium"),
+        # Cyrillic 'c' (U+0441 lowercase, U+0421 uppercase) for Latin 'c'
+        (r"[\u0441\u0421]", "homoglyph_cyrillic_c", "medium"),
+        # Greek 'o' (U+03BF lowercase, U+039F uppercase) for Latin 'o'
+        (r"[\u03bf\u039f]", "homoglyph_greek_o", "medium"),
+    ]
+
     # Compiled pattern cache (class-level for reuse).
     _COMPILED_CODE_INJECTION: list[tuple[re.Pattern[str], str, FindingSeverity]] = []
     _COMPILED_SENSITIVE_INFO: list[tuple[re.Pattern[str], str, FindingSeverity]] = []
     _COMPILED_PATH_LEAK: list[tuple[re.Pattern[str], str, FindingSeverity]] = []
     _COMPILED_PROMPT_INJECTION: list[tuple[re.Pattern[str], str, FindingSeverity]] = []
+    _COMPILED_BASE64: list[tuple[re.Pattern[str], str, FindingSeverity]] = []
+    _COMPILED_HOMOGLYPH: list[tuple[re.Pattern[str], str, FindingSeverity]] = []
 
     def __init__(self) -> None:
         # Compile once at instance construction (deferred from class-level
@@ -235,6 +276,12 @@ class OutputValidator:
             OutputValidator._COMPILED_PROMPT_INJECTION = [
                 (re.compile(p), name, sev) for p, name, sev in self.PROMPT_INJECTION_PATTERNS
             ]
+            OutputValidator._COMPILED_BASE64 = [
+                (re.compile(p), name, sev) for p, name, sev in self.BASE64_ENCODED_LEAK_PATTERNS
+            ]
+            OutputValidator._COMPILED_HOMOGLYPH = [
+                (re.compile(p), name, sev) for p, name, sev in self.UNICODE_HOMOGLYPH_PATTERNS
+            ]
 
     # ------------------------------------------------------------------
     # Public API
@@ -256,6 +303,8 @@ class OutputValidator:
         findings.extend(self._scan_sensitive_info(text))
         findings.extend(self._scan_path_leak(text))
         findings.extend(self._scan_prompt_injection(text))
+        findings.extend(self._scan_base64(text))
+        findings.extend(self._scan_unicode_homoglyph(text))
 
         # Sort by span start so redaction offsets are processed left-to-right.
         findings.sort(key=lambda f: f.span[0])
@@ -288,6 +337,49 @@ class OutputValidator:
     def _scan_prompt_injection(self, text: str) -> list[OutputFinding]:
         return self._scan(text, self._COMPILED_PROMPT_INJECTION, "prompt_injection")
 
+    def _scan_base64(self, text: str) -> list[OutputFinding]:
+        """Scan for base64-encoded sensitive content.
+
+        For long base64 blobs, attempt to decode and check if the decoded
+        content contains known sensitive patterns (sk-/password=/AKIA...).
+        If decoded content matches sensitive patterns, escalate severity
+        from medium to high.
+
+        Fail-secure: if base64 decode fails, keep medium severity.
+        """
+        findings = self._scan(text, self._COMPILED_BASE64, "base64_encoded_leak")
+        escalated: list[OutputFinding] = []
+        for f in findings:
+            if f.pattern_name == "base64_long_blob" and f.severity == "medium":
+                try:
+                    decoded_bytes = base64.b64decode(f.matched_text, validate=True)
+                    decoded = decoded_bytes.decode("utf-8", errors="ignore")
+                    if (
+                        re.search(r"sk-[A-Za-z0-9]{20,}", decoded)
+                        or re.search(r"(?i)password\s*[=:]", decoded)
+                        or re.search(r"AKIA[0-9A-Z]{16}", decoded)
+                    ):
+                        escalated.append(
+                            OutputFinding(
+                                category=f.category,
+                                severity="high",
+                                pattern_name=f.pattern_name + "_sensitive",
+                                matched_text=f.matched_text,
+                                redacted_text=f.redacted_text,
+                                span=f.span,
+                            )
+                        )
+                        continue
+                except Exception:
+                    # Fail-secure: keep medium severity if decode fails.
+                    pass
+            escalated.append(f)
+        return escalated
+
+    def _scan_unicode_homoglyph(self, text: str) -> list[OutputFinding]:
+        """Scan for Unicode homoglyph attacks."""
+        return self._scan(text, self._COMPILED_HOMOGLYPH, "unicode_homoglyph")
+
     @staticmethod
     def _scan(
         text: str,

{devsquad-4.3.0 → devsquad-4.3.1}/skills/__init__.py

@@ -1,5 +1,5 @@
 """
-DevSquad V4.3.0 — Layered Sub-Skill Architecture
+DevSquad V4.3.1 — Layered Sub-Skill Architecture
 
 This package provides fine-grained, independently usable skills that wrap
 DevSquad's core modules. Each sub-skill is a thin handler (~50 lines) that

devsquad-4.3.0/scripts/collaboration/_version.py

@@ -1 +0,0 @@
-__version__ = "4.3.0"