devsquad 4.5.8__tar.gz → 4.5.9__tar.gz

{devsquad-4.5.8 → devsquad-4.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devsquad
-Version: 4.5.8
+Version: 4.5.9
 Summary: Production-Ready Multi-Role AI Task Orchestrator
 Author-email: DevSquad Team <devsquad@example.com>
 License: MIT
@@ -96,14 +96,14 @@ Dynamic: license-file
 <p align="center">
   <strong>🎯 把「单个 AI 助手」升级成「7 人 AI 专业团队」</strong>
   <br>
-  <em>One task → Multi-role AI collaboration → One conclusion | V4.5.8 (FileRiskStore persistence + risks add/assess/mitigate/close + exposure filters) | V4.5.7 (Coeffect Async + Risk Register UX CLI) | V4.5.6 (Module Fiber + Coeffect: 6-state FSM + topological activation + modules CLI) | V4.5.3 (Artifacts + Effect — ArtifactStore + DispatchEffect + EffectRegistry + Audit CLI) | V4.5.2 (Experience polish: MOKA + Metrics + GitLab + Doctor + BackendConfig) | V4.5.0 (cross-session continuity + protocol-native skills)</em>
+  <em>One task → Multi-role AI collaboration → One conclusion | V4.5.9 (Unified Gather Execution Core + Native Async Worker: 执行层统一 gather 化 + Worker 原生异步) | V4.5.8 (FileRiskStore persistence + risks add/assess/mitigate/close + exposure filters) | V4.5.7 (Coeffect Async + Risk Register UX CLI) | V4.5.6 (Module Fiber + Coeffect: 6-state FSM + topological activation + modules CLI) | V4.5.3 (Artifacts + Effect — ArtifactStore + DispatchEffect + EffectRegistry + Audit CLI) | V4.5.2 (Experience polish: MOKA + Metrics + GitLab + Doctor + BackendConfig) | V4.5.0 (cross-session continuity + protocol-native skills)</em>
 </p>
 
 <p align="center">
   <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-8996%2B%20passing-brightgreen" />
-  <img alt="Version" src="https://img.shields.io/badge/V4.5.8-success" />
+  <img alt="Version" src="https://img.shields.io/badge/V4.5.9-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.5.8 → devsquad-4.5.9}/README.md

@@ -3,14 +3,14 @@
 <p align="center">
   <strong>🎯 把「单个 AI 助手」升级成「7 人 AI 专业团队」</strong>
   <br>
-  <em>One task → Multi-role AI collaboration → One conclusion | V4.5.8 (FileRiskStore persistence + risks add/assess/mitigate/close + exposure filters) | V4.5.7 (Coeffect Async + Risk Register UX CLI) | V4.5.6 (Module Fiber + Coeffect: 6-state FSM + topological activation + modules CLI) | V4.5.3 (Artifacts + Effect — ArtifactStore + DispatchEffect + EffectRegistry + Audit CLI) | V4.5.2 (Experience polish: MOKA + Metrics + GitLab + Doctor + BackendConfig) | V4.5.0 (cross-session continuity + protocol-native skills)</em>
+  <em>One task → Multi-role AI collaboration → One conclusion | V4.5.9 (Unified Gather Execution Core + Native Async Worker: 执行层统一 gather 化 + Worker 原生异步) | V4.5.8 (FileRiskStore persistence + risks add/assess/mitigate/close + exposure filters) | V4.5.7 (Coeffect Async + Risk Register UX CLI) | V4.5.6 (Module Fiber + Coeffect: 6-state FSM + topological activation + modules CLI) | V4.5.3 (Artifacts + Effect — ArtifactStore + DispatchEffect + EffectRegistry + Audit CLI) | V4.5.2 (Experience polish: MOKA + Metrics + GitLab + Doctor + BackendConfig) | V4.5.0 (cross-session continuity + protocol-native skills)</em>
 </p>
 
 <p align="center">
   <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-8996%2B%20passing-brightgreen" />
-  <img alt="Version" src="https://img.shields.io/badge/V4.5.8-success" />
+  <img alt="Version" src="https://img.shields.io/badge/V4.5.9-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.5.8 → devsquad-4.5.9}/devsquad.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devsquad
-Version: 4.5.8
+Version: 4.5.9
 Summary: Production-Ready Multi-Role AI Task Orchestrator
 Author-email: DevSquad Team <devsquad@example.com>
 License: MIT
@@ -96,14 +96,14 @@ Dynamic: license-file
 <p align="center">
   <strong>🎯 把「单个 AI 助手」升级成「7 人 AI 专业团队」</strong>
   <br>
-  <em>One task → Multi-role AI collaboration → One conclusion | V4.5.8 (FileRiskStore persistence + risks add/assess/mitigate/close + exposure filters) | V4.5.7 (Coeffect Async + Risk Register UX CLI) | V4.5.6 (Module Fiber + Coeffect: 6-state FSM + topological activation + modules CLI) | V4.5.3 (Artifacts + Effect — ArtifactStore + DispatchEffect + EffectRegistry + Audit CLI) | V4.5.2 (Experience polish: MOKA + Metrics + GitLab + Doctor + BackendConfig) | V4.5.0 (cross-session continuity + protocol-native skills)</em>
+  <em>One task → Multi-role AI collaboration → One conclusion | V4.5.9 (Unified Gather Execution Core + Native Async Worker: 执行层统一 gather 化 + Worker 原生异步) | V4.5.8 (FileRiskStore persistence + risks add/assess/mitigate/close + exposure filters) | V4.5.7 (Coeffect Async + Risk Register UX CLI) | V4.5.6 (Module Fiber + Coeffect: 6-state FSM + topological activation + modules CLI) | V4.5.3 (Artifacts + Effect — ArtifactStore + DispatchEffect + EffectRegistry + Audit CLI) | V4.5.2 (Experience polish: MOKA + Metrics + GitLab + Doctor + BackendConfig) | V4.5.0 (cross-session continuity + protocol-native skills)</em>
 </p>
 
 <p align="center">
   <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-8996%2B%20passing-brightgreen" />
-  <img alt="Version" src="https://img.shields.io/badge/V4.5.8-success" />
+  <img alt="Version" src="https://img.shields.io/badge/V4.5.9-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.5.8 → devsquad-4.5.9}/devsquad.egg-info/SOURCES.txt

@@ -144,6 +144,7 @@ scripts/collaboration/file_bundler.py
 scripts/collaboration/file_risk_store.py
 scripts/collaboration/five_axis_consensus.py
 scripts/collaboration/gap_analyzer.py
+scripts/collaboration/gather_core.py
 scripts/collaboration/gitlab_connector.py
 scripts/collaboration/host_llm_bridge.py
 scripts/collaboration/host_llm_bridge_v2.py

{devsquad-4.5.8 → devsquad-4.5.9}/pyproject.toml

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

{devsquad-4.5.8 → devsquad-4.5.9}/scripts/api/routes/dispatch.py

@@ -13,6 +13,8 @@ Endpoints:
 
 from __future__ import annotations
 
+import asyncio
+import functools
 import logging
 import os
 import sys
@@ -216,11 +218,19 @@ async def dispatch_task(
                 logger.warning("Failed to create LLM backend '%s': %s, using default", request.backend, backend_err)
                 pass
 
-        result = dispatcher.dispatch(
-            task_description=request.task,
-            roles=request.roles,
-            mode=request.mode,
-            dry_run=request.dry_run,
+        # V4.5.9: dispatch() is synchronous and its Coordinator raises
+        # RuntimeError inside a running event loop (fail-fast sync bridge,
+        # see PRD V4.5.9 R3). Move the blocking call off the event loop.
+        loop = asyncio.get_running_loop()
+        result = await loop.run_in_executor(
+            None,
+            functools.partial(
+                dispatcher.dispatch,
+                task_description=request.task,
+                roles=request.roles,
+                mode=request.mode,
+                dry_run=request.dry_run,
+            ),
         )
 
         response_data = _convert_dispatch_result(result)

{devsquad-4.5.8 → devsquad-4.5.9}/scripts/check_module_activation.py

@@ -25,6 +25,9 @@ V4.5.8: Extended to include:
     - FileRiskStore (file-backed risk persistence)
     - CliRisks mutators (add/mitigate/close/list --min-exposure)
 
+V4.5.9: Extended to include:
+    - GatherCore (shared asyncio.gather execution core, _call_counter_gather)
+
 Usage:
     python3 scripts/check_module_activation.py
     CI: python3 scripts/check_module_activation.py || exit 1
@@ -177,12 +180,20 @@ def main() -> int:
         get_call_counter_er as _get_file_risk_store_counter_er,
     )
 
+    # V4.5.9 modules — touch counters in main scope
+    from scripts.collaboration.gather_core import (
+        get_call_counter_gather as _get_gather_counter,
+    )
+
     # V4.5.7 P12.5 activation (2 new modules)
     _activate_v457_modules()
 
     # V4.5.8 activation (FileRiskStore + CliRisks mutators)
     _activate_v458_modules()
 
+    # V4.5.9 activation (GatherCore — shared asyncio.gather execution core)
+    _activate_v459_modules()
+
     counters = {
         "TaskScaleGate": tsg(),
         "PerfBaseline": pb(),
@@ -212,9 +223,11 @@ def main() -> int:
         # V4.5.8 modules
         "FileRiskStore_V458.1": _get_file_risk_store_counter_er(),
         "CliRisksMutators_V458.2": _get_cli_risks_counter_er(),
+        # V4.5.9 modules
+        "GatherCore_V459.1": _get_gather_counter(),
     }
 
-    print("V4.5.8 Anti-Ghost Verification")
+    print("V4.5.9 Anti-Ghost Verification")
     print("=" * 60)
     failed = []
     for name, count in counters.items():
@@ -230,10 +243,34 @@ def main() -> int:
             print(f"  - {name}")
         return 1
 
-    print("All V4.5.8 modules activated. Anti-ghost gate PASSED.")
+    print("All V4.5.9 modules activated. Anti-ghost gate PASSED.")
     return 0
 
 
+def _activate_v459_modules() -> None:
+    """Exercise the V4.5.9 gather core to bump its anti-ghost counter.
+
+    Runs one minimal execute_batch_gather() batch — the same entry point a
+    parallel dispatch hits — so ``_call_counter_gather`` reflects real usage.
+    """
+    import asyncio
+
+    from scripts.collaboration.gather_core import execute_batch_gather
+    from scripts.collaboration.models import TaskDefinition, WorkerResult
+
+    async def _run_one(task: TaskDefinition) -> WorkerResult:
+        return WorkerResult(worker_id="anti-ghost", task_id=task.task_id, success=True)
+
+    async def _drive() -> list[WorkerResult]:
+        return await execute_batch_gather(
+            [TaskDefinition(description="anti-ghost check", role_id="architect")],
+            _run_one,
+            1,
+        )
+
+    asyncio.run(_drive())
+
+
 def _activate_v458_modules() -> None:
     """Exercise V4.5.8 modules to bump their anti-ghost counters.
 

devsquad-4.5.9/scripts/collaboration/_version.py

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

{devsquad-4.5.8 → devsquad-4.5.9}/scripts/collaboration/async_coordinator.py

@@ -37,6 +37,7 @@ from .context_compressor import (
     Message,
     MessageType,
 )
+from .gather_core import execute_batch_gather
 from .models import (
     BatchMode,
     ConsensusRecord,
@@ -75,6 +76,11 @@ class AsyncWorkerWrapper:
         """
         Execute worker task asynchronously with optional timeout.
 
+        V4.5.9 (AC-W4): when the wrapped Worker exposes ``aexecute`` (async
+        backends run natively inside it, sync backends bridge internally),
+        await it directly — no thread bridge at this layer. Otherwise fall
+        back to the legacy run_in_executor bridge.
+
         Args:
             task: Task definition to execute.
 
@@ -84,19 +90,15 @@ class AsyncWorkerWrapper:
         Raises:
             asyncio.TimeoutError: If task exceeds timeout.
         """
-        loop = asyncio.get_event_loop()
+        if hasattr(self.worker, "aexecute"):
+            coro = self.worker.aexecute(task)
+        else:
+            loop = asyncio.get_event_loop()
+            coro = loop.run_in_executor(None, self.worker.execute, task)
 
         if self.timeout:
-
-            async def _execute_with_timeout() -> WorkerResult:
-                return await asyncio.wait_for(
-                    loop.run_in_executor(None, self.worker.execute, task),
-                    timeout=self.timeout,
-                )
-
-            return await _execute_with_timeout()
-        else:
-            return await loop.run_in_executor(None, self.worker.execute, task)
+            return await asyncio.wait_for(coro, timeout=self.timeout)
+        return await coro
 
 
 class AsyncCoordinator:
@@ -425,20 +427,20 @@ class AsyncCoordinator:
 
     async def _execute_parallel_async(self, batch: TaskBatch) -> list[WorkerResult]:
         """
-        Execute tasks in parallel using asyncio.gather.
-
-        Key advantage over ThreadPoolExecutor:
-        - No thread creation/destruction overhead
-        - Single event loop context switching
-        - Better memory efficiency
-        - Natural integration with async backends
+        Execute tasks in parallel via the shared gather core (V4.5.9).
+
+        The gather mechanism (Semaphore cap, return_exceptions=True so one
+        Worker failure never discards sibling results, BaseException defense,
+        submission-order results) lives in ``gather_core.execute_batch_gather``
+        — the single source of truth shared with the sync Coordinator. The
+        per-task shell (worker routing, briefing, timeout/retry, per-task
+        Exception isolation) stays in ``_execute_with_semaphore`` below.
         """
         semaphore = await self._get_semaphore()
-        results: list[WorkerResult] = []
         max_workers = min(batch.max_concurrency or len(batch.tasks), len(batch.tasks))
 
         if max_workers <= 0:
-            return results
+            return []
 
         async def _execute_with_semaphore(
             task: TaskDefinition,
@@ -487,30 +489,12 @@ class AsyncCoordinator:
                         error=str(e),
                     )
 
-        tasks = [_execute_with_semaphore(task) for task in batch.tasks]
-        # P0-2 (V4.1.2): return_exceptions=True so one Worker failure does not
-        # discard the results of all other parallel Workers. The per-task
-        # _execute_with_semaphore already wraps exceptions into WorkerResult,
-        # but return_exceptions=True is the defensive belt-and-suspenders.
-        raw_results = await asyncio.gather(*tasks, return_exceptions=True)
-        results = []
-        for r in raw_results:
-            if isinstance(r, BaseException):
-                # Defensive: should rarely hit because _execute_with_semaphore
-                # catches Exception, but KeyboardInterrupt/SystemExit could propagate.
-                logger.error(
-                    "Worker raised unexpected exception in async gather: %s", r, exc_info=r
-                )
-                results.append(
-                    WorkerResult(
-                        worker_id="<unknown>",
-                        task_id="<unknown>",
-                        success=False,
-                        error=f"Unexpected exception: {r!r}",
-                    )
-                )
-            else:
-                results.append(r)
+        results = await execute_batch_gather(batch.tasks, _execute_with_semaphore, max_workers)
+
+        # V4.5.9 (DESIGN §6): user-visible evidence of the gather executor.
+        for r in results:
+            if isinstance(r.output, dict):
+                r.output["executor"] = "gather"
 
         return results
 

{devsquad-4.5.8 → devsquad-4.5.9}/scripts/collaboration/coordinator.py

@@ -14,15 +14,16 @@ Core component for multi-Worker collaboration:
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import re
 import time
 import uuid
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import TYPE_CHECKING, Any
 
 from .consensus import ConsensusEngine
 from .context_compressor import CompressedContext, CompressionLevel, ContextCompressor, Message, MessageType
+from .gather_core import execute_batch_gather
 from .models import (
     BatchMode,
     ConsensusRecord,
@@ -90,7 +91,6 @@ class Coordinator:
         "consensus",
         "workers",
         "_worker_index",
-        "_executor",
         "_execution_history",
         "coordinator_id",
         "enable_compression",
@@ -159,10 +159,10 @@ class Coordinator:
         self.consensus = ConsensusEngine()
         self.workers: dict[str, Worker] = {}
         self._worker_index: dict[str, Worker] = {}
-        # P2-4 (V4.1.2): max_workers aligned with max_roles=10 (.devsquad.yaml)
-        # so the pool can accommodate up to 10 parallel Workers when needed.
-        # Previously hardcoded to 7, which undersized the pool when max_roles=10.
-        self._executor = ThreadPoolExecutor(max_workers=10)
+        # V4.5.9: ThreadPoolExecutor removed — parallel batches execute through
+        # the shared asyncio.gather core (gather_core.execute_batch_gather)
+        # via the sync bridge in _execute_parallel. The thread bridge now only
+        # exists at the sync-Worker boundary (AC-C6).
         self._execution_history: list[dict[str, Any]] = []
         self.coordinator_id = f"coord-{uuid.uuid4().hex[:8]}"
         self.enable_compression = enable_compression
@@ -716,30 +716,73 @@ class Coordinator:
         return results, errors
 
     def _execute_parallel(self, batch: TaskBatch) -> list[WorkerResult]:
-        results: list[WorkerResult] = []
+        """Execute a PARALLEL batch through the shared gather core (V4.5.9, AC-C1).
+
+        Sync bridge (AC-C4): safe to call without a running event loop (enters
+        via ``asyncio.run``); raises an informative RuntimeError when a loop is
+        already running — use AsyncCoordinator / async_dispatch instead
+        (L-V457-002 pattern).
+
+        Semantics preserved from the legacy thread-pool implementation:
+        - tasks without a matching Worker are dropped (no result);
+        - a Worker failure yields ``WorkerResult(worker_id="unknown", ...)``
+          without losing the sibling results (AC-C3);
+        - concurrency is capped by ``asyncio.Semaphore(max_concurrency)`` (AC-C5);
+        - results keep submission order (new contract, PRD V4.5.9 R1).
+        """
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+        else:
+            raise RuntimeError(
+                "Coordinator._execute_parallel cannot run inside a running event loop; "
+                "use AsyncCoordinator / async_dispatch in async context."
+            )
         max_workers = min(batch.max_concurrency or len(batch.tasks), len(batch.tasks))
-        if max_workers <= 0:
-            return results
-        futures = {}
-        for task in batch.tasks:
+        if max_workers <= 0 or not batch.tasks:
+            return []
+        results = asyncio.run(self._aexecute_parallel(batch, max_workers))
+        # V4.5.9 (DESIGN §6): user-visible evidence of the gather executor.
+        for r in results:
+            if isinstance(r.output, dict):
+                r.output["executor"] = "gather"
+        return results
+
+    async def _aexecute_parallel(self, batch: TaskBatch, max_workers: int) -> list[WorkerResult]:
+        """Async half of the sync bridge — runs inside ``asyncio.run()``."""
+        loop = asyncio.get_running_loop()
+
+        async def run_one(task: TaskDefinition) -> WorkerResult:
             worker = self._get_worker_for_task(task)
-            if worker:
-                future = self._executor.submit(worker.execute, task)
-                futures[future] = task.task_id
-        for future in as_completed(futures):
+            if worker is None:  # unreachable: batch is pre-filtered below
+                return WorkerResult(
+                    worker_id="unknown",
+                    task_id=task.task_id,
+                    success=False,
+                    error="No worker found for task",
+                )
             try:
-                results.append(future.result())
+                if hasattr(worker, "aexecute"):
+                    # 真异步入口：async 后端原生 await；sync 后端在 aexecute
+                    # 内部经 run_in_executor 桥接（AC-C6/W2/W3）。
+                    return await worker.aexecute(task)
+                return await loop.run_in_executor(None, worker.execute, task)
             except Exception as e:
-                # Broad catch: wraps arbitrary worker execution in thread pool
-                results.append(
-                    WorkerResult(
-                        worker_id="unknown",
-                        task_id=futures[future],
-                        success=False,
-                        error=str(e),
-                    )
+                # Broad catch: wraps arbitrary worker execution; per-task
+                # isolation aligned with the legacy thread-pool
+                # future.result() -> worker_id="unknown" path (AC-C3).
+                return WorkerResult(
+                    worker_id="unknown",
+                    task_id=task.task_id,
+                    success=False,
+                    error=str(e),
                 )
-        return results
+
+        # Legacy thread-pool semantics: tasks without a matching Worker were
+        # never submitted (dropped silently) — preserve that behavior (AC-C2).
+        tasks = [t for t in batch.tasks if self._get_worker_for_task(t) is not None]
+        return await execute_batch_gather(tasks, run_one, max_workers)
 
     def _inject_briefing_to_worker(self, worker: Any) -> None:
         """Inject compressed briefing from preceding Agents into the next Worker."""
@@ -1025,7 +1068,3 @@ class Coordinator:
             duration: Any = self._execution_history[-1]["result"]["duration"]
             return float(duration)
         return 0.0
-
-    def __del__(self) -> None:
-        if hasattr(self, "_executor"):
-            self._executor.shutdown(wait=False)

{devsquad-4.5.8 → devsquad-4.5.9}/scripts/collaboration/dispatch_steps.py

@@ -687,6 +687,8 @@ class PostDispatchPipeline(
                     if r.output
                     else None,
                     "error": r.error,
+                    # V4.5.9 (DESIGN §6): user-visible gather-executor evidence.
+                    "executor": (r.output.get("executor", "gather") if isinstance(r.output, dict) else "gather"),
                 }
             )
         step7_time = time.time()

devsquad-4.5.9/scripts/collaboration/gather_core.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Shared asyncio.gather execution core (V4.5.9).
+
+Single source of truth for parallel batch execution. Both the sync
+Coordinator (via the asyncio.run bridge in ``_execute_parallel``) and the
+AsyncCoordinator (native) delegate here. Do NOT reimplement gather
+semantics elsewhere.
+
+Semantics (the single implementation):
+1. ``asyncio.Semaphore(max_concurrency)`` caps in-flight tasks (AC-C5).
+2. ``asyncio.gather(..., return_exceptions=True)`` — a single Worker failure
+   never discards the results of the other parallel Workers (hard constraint).
+3. BaseException defense — KeyboardInterrupt/SystemExit (or any exception that
+   escapes ``run_one``) is converted into a failure ``WorkerResult`` instead of
+   unwinding the whole batch.
+4. Results keep submission order (``tasks`` order) — a deliberate behavior
+   change from the legacy completion-order thread pool (PRD V4.5.9 R1, logged).
+
+``run_one`` is the per-task callback injected by the calling Coordinator: it
+owns worker routing, briefing, timeout and retry, and is expected to catch
+per-task ``Exception`` itself (translating them into ``WorkerResult``). This
+core only owns the gather mechanism — keeping it small is a design constraint.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable
+
+from .models import TaskDefinition, WorkerResult
+
+logger = logging.getLogger(__name__)
+
+# V4.5.9 anti-ghost counter: bumped once per execute_batch_gather() entry.
+# Verified by scripts/check_module_activation.py (GatherCore_V459.1).
+_call_counter_gather = 0
+
+
+def _inc_call_counter_gather() -> None:
+    """Bump the module-level anti-ghost counter."""
+    global _call_counter_gather
+    _call_counter_gather += 1
+
+
+def get_call_counter_gather() -> int:
+    """Return the current anti-ghost counter value."""
+    return _call_counter_gather
+
+
+async def execute_batch_gather(
+    tasks: list[TaskDefinition],
+    run_one: Callable[[TaskDefinition], Awaitable[WorkerResult]],
+    max_concurrency: int,
+) -> list[WorkerResult]:
+    """Execute ``tasks`` concurrently through ``run_one`` under a semaphore.
+
+    Args:
+        tasks: Task definitions in submission order.
+        run_one: Per-task coroutine factory injected by the calling
+            Coordinator (routes to ``Worker.aexecute`` or a sync bridge).
+        max_concurrency: Semaphore cap on in-flight tasks. Non-positive
+            values are treated as unbounded (clamped to ``len(tasks)``).
+
+    Returns:
+        WorkerResult list in submission order; never shorter than ``tasks``.
+    """
+    _inc_call_counter_gather()
+    if not tasks:
+        return []
+
+    limit = max_concurrency if max_concurrency and max_concurrency > 0 else len(tasks)
+    semaphore = asyncio.Semaphore(limit)
+
+    async def _run_one_limited(task: TaskDefinition) -> WorkerResult:
+        async with semaphore:
+            try:
+                return await run_one(task)
+            except asyncio.CancelledError:
+                raise
+            except BaseException as e:
+                # BaseException defense (AC-C1 hard constraint). Since Python
+                # 3.8 (bpo-32528) gather(return_exceptions=True) does NOT
+                # capture KeyboardInterrupt/SystemExit raised inside a child —
+                # they would unwind the whole batch. Convert any escaped
+                # exception into a failure WorkerResult so one Worker can
+                # never discard the sibling results.
+                logger.error("Worker raised unexpected exception in gather: %s", e, exc_info=e)
+                return WorkerResult(
+                    worker_id="<unknown>",
+                    task_id="<unknown>",
+                    success=False,
+                    error=f"Unexpected exception: {e!r}",
+                )
+
+    raw_results = await asyncio.gather(
+        *(_run_one_limited(t) for t in tasks),
+        return_exceptions=True,
+    )
+
+    results: list[WorkerResult] = []
+    for r in raw_results:
+        if isinstance(r, BaseException):
+            # Belt-and-suspenders: should be unreachable because
+            # _run_one_limited converts escaped exceptions, but a defensive
+            # conversion keeps the result list pure WorkerResult.
+            logger.error("Worker raised unexpected exception in gather: %s", r, exc_info=r)
+            results.append(
+                WorkerResult(
+                    worker_id="<unknown>",
+                    task_id="<unknown>",
+                    success=False,
+                    error=f"Unexpected exception: {r!r}",
+                )
+            )
+        else:
+            results.append(r)
+    return results