bazaar-compute-node 0.2.0rc4__tar.gz → 0.2.0rc5__tar.gz

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.2.0rc4
+Version: 0.2.0rc5
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.2.0rc4"
+version = "0.2.0rc5"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.2.0rc4"
+version = "0.2.0rc5"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/claude/process.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 from collections import deque
 from collections.abc import Mapping
 from dataclasses import dataclass
@@ -22,6 +23,8 @@ from .protocol import (
 MAX_JSONL_BYTES = 1024 * 1024
 _EXIT_PIPE_DRAIN_SECONDS = 1
 _CLOSED = object()
+_REAP_REPORT_SECONDS = 30.0
+_LOGGER = logging.getLogger("bazaar_compute_node.runtime.claude.process")
 
 
 class ProcessState(StrEnum):
@@ -120,6 +123,8 @@ class ProcessSupervisor:
         self._write_lock = asyncio.Lock()
         self._lifecycle_lock = asyncio.Lock()
         self._exit_event = asyncio.Event()
+        self._abandoned: set[asyncio.Task[None]] = set()
+        self._started = False
 
     @property
     def state(self) -> ProcessState:
@@ -147,8 +152,9 @@ class ProcessSupervisor:
 
     async def start(self, *, timeout: float) -> None:
         async with self._lifecycle_lock:
-            if self.is_running:
-                return
+            if self._started:
+                raise RuntimeError("a stopped supervisor cannot start again")
+            self._started = True
             self._state = ProcessState.RUNNING
             try:
                 async with asyncio.timeout(timeout):
@@ -227,6 +233,7 @@ class ProcessSupervisor:
             now = asyncio.get_running_loop().time()
             graceful_deadline = now + timeout * 0.6
             terminate_deadline = now + timeout * 0.9
+            kill_deadline = now + timeout
             if process.stdin is not None:
                 process.stdin.close()
             try:
@@ -237,12 +244,74 @@ class ProcessSupervisor:
                     await self._wait_until(process, terminate_deadline)
                 except TimeoutError:
                     process.kill()
-                    await process.wait()
+                    try:
+                        await self._wait_until(process, kill_deadline)
+                    except TimeoutError:
+                        # a process that survived a kill will not be waited out,
+                        # so let go of it here instead of holding the lifecycle
+                        # lock
+                        self._abandon(process)
+                        self._state = ProcessState.STOPPED
+                        self._exit_event.set()
+                        return
             self._returncode = process.returncode
             await self._join_tasks(cancel=True)
             self._state = ProcessState.STOPPED
             self._exit_event.set()
 
+    def _abandon(self, process: asyncio.subprocess.Process) -> None:
+        """Give up on a process without losing track of it.
+
+        Closing this side of the pipes is what unblocks everything: the readers
+        stop waiting for an EOF that a grandchild holding the write end will
+        never deliver, and the exit waiters can complete once the pipes count as
+        disconnected. Whoever still holds that write end is free to keep it.
+        """
+
+        transport = getattr(process, "_transport", None)
+        if transport is not None:
+            for fd in (1, 2):
+                pipe = transport.get_pipe_transport(fd)
+                if pipe is not None:
+                    pipe.close()
+        # the watcher normally closes the queue, and it is about to be
+        # cancelled, so release whoever is already waiting in receive()
+        self._incoming.put_nowait(_CLOSED)
+        tasks = tuple(
+            task
+            for task in (self._stdout_task, self._stderr_task, self._watch_task)
+            if task is not None and task is not asyncio.current_task()
+        )
+        for task in tasks:
+            task.cancel()
+        self._stdout_task = None
+        self._stderr_task = None
+        self._watch_task = None
+        self._process = None
+        reaper = asyncio.create_task(
+            self._reap(process, tasks),
+            name=f"bcn-claude-reap-{process.pid}",
+        )
+        self._abandoned.add(reaper)
+        reaper.add_done_callback(self._abandoned.discard)
+
+    async def _reap(
+        self,
+        process: asyncio.subprocess.Process,
+        tasks: tuple[asyncio.Task[None], ...],
+    ) -> None:
+        """Outlive the caller waiting for a process nobody else is waiting for."""
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        try:
+            async with asyncio.timeout(_REAP_REPORT_SECONDS):
+                returncode = await process.wait()
+        except TimeoutError:
+            _LOGGER.warning("process %s outlived its kill; still waiting", process.pid)
+            returncode = await process.wait()
+        self._returncode = returncode
+
     async def _read_stdout(self, process: asyncio.subprocess.Process) -> None:
         stdout = process.stdout
         if stdout is None:

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/claude/runtime.py

@@ -25,7 +25,6 @@ from ...core.paths import resolve_workspace_dir
 from ...core.runtime import (
     IRuntime,
     IRuntimeTurnStream,
-    RuntimeBackgroundIdle,
     RuntimeCommandContext,
     RuntimeLifecycleEvent,
     RuntimeSandboxMode,
@@ -60,7 +59,6 @@ class _Connection:
     queued_human_cycle_started: asyncio.Event = field(default_factory=asyncio.Event)
     active_stream: TurnEventStream | None = None
     active_background_task_ids: set[str] = field(default_factory=set)
-    background_active: bool = False
 
 
 class Runtime(IRuntime, IAsyncLifecycle):
@@ -507,8 +505,7 @@ class Runtime(IRuntime, IAsyncLifecycle):
                 self._retirement_tasks.add(task)
                 task.add_done_callback(self._retirement_tasks.discard)
                 return
-            if _observe_background(connection, message):
-                self._lifecycle_events.put_nowait(RuntimeBackgroundIdle(session.id))
+            _observe_background(connection, message)
 
         client.set_message_observer(observe)
         return connection
@@ -595,32 +592,24 @@ def _sandbox_settings(
     return settings
 
 
-def _observe_background(connection: _Connection, message: dict[str, object]) -> bool:
-    was_active = connection.background_active
-    if message.get("type") == "system":
-        subtype = message.get("subtype")
-        task_id = message.get("task_id")
-        if isinstance(task_id, str) and task_id:
-            if subtype == "task_started" and message.get("task_type") in {
-                "local_agent",
-                "local_workflow",
-            }:
-                connection.active_background_task_ids.add(task_id)
-            elif subtype == "task_notification":
-                connection.active_background_task_ids.discard(task_id)
-            elif subtype == "task_updated":
-                patch = message.get("patch")
-                if isinstance(patch, dict) and patch.get("status") in {
-                    "completed",
-                    "failed",
-                    "stopped",
-                    "killed",
-                }:
-                    connection.active_background_task_ids.discard(task_id)
-    connection.background_active = bool(
-        connection.active_background_task_ids or connection.client.provider_wake_active
-    )
-    return was_active and not connection.background_active
+def _observe_background(connection: _Connection, message: dict[str, object]) -> None:
+    # Claude Code republishes the whole set on every change, so the latest
+    # snapshot is the answer and nothing has to be accumulated from edges
+    if (
+        message.get("type") != "system"
+        or message.get("subtype") != "background_tasks_changed"
+    ):
+        return
+    tasks = message.get("tasks")
+    if not isinstance(tasks, list):
+        return
+    connection.active_background_task_ids = {
+        task_id
+        for task in tasks
+        if isinstance(task, dict)
+        and isinstance(task_id := task.get("task_id"), str)
+        and task_id
+    }
 
 
 def _provider_result(error: BaseException) -> ProviderCallResult[Any]:

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/codex/process.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import os
 import signal
 from collections import deque
@@ -60,6 +61,8 @@ class JsonlProcessSpec:
 
 
 _QUEUE_CLOSED = object()
+_REAP_REPORT_SECONDS = 30.0
+_LOGGER = logging.getLogger("bazaar_compute_node.runtime.codex.process")
 
 
 class JsonlProcessSupervisor:
@@ -93,6 +96,8 @@ class JsonlProcessSupervisor:
         self._pending: dict[JsonlRequestId, asyncio.Future[JsonlMessage]] = {}
         self._next_request_id = 0
         self._closed_message_sent = False
+        self._abandoned: set[asyncio.Task[None]] = set()
+        self._started = False
 
     @property
     def state(self) -> JsonlProcessState:
@@ -123,10 +128,9 @@ class JsonlProcessSupervisor:
     async def start(self, *, timeout: float) -> None:
         _validate_timeout(timeout)
         async with self._lifecycle_lock:
-            if self.is_running:
-                return
-            await self._join_tasks()
-            self._reset_runtime_state()
+            if self._started:
+                raise RuntimeError("a stopped supervisor cannot start again")
+            self._started = True
             self._state = JsonlProcessState.STARTING
             try:
                 async with asyncio.timeout(timeout):
@@ -171,19 +175,42 @@ class JsonlProcessSupervisor:
                 self._send_closed_message()
                 return
             self._state = JsonlProcessState.STOPPING
-            deadline = asyncio.get_running_loop().time() + timeout
+            now = asyncio.get_running_loop().time()
+            graceful_deadline = now + timeout * 0.6
+            terminate_deadline = now + timeout * 0.8
+            kill_deadline = now + timeout * 0.9
+            deadline = now + timeout
             if process.stdin is not None:
                 process.stdin.close()
             try:
-                await self._wait_for_process(process, deadline)
+                await self._wait_for_process(process, graceful_deadline)
             except TimeoutError:
                 _terminate_process(process)
                 try:
-                    await self._wait_for_process(process, deadline)
+                    await self._wait_for_process(process, terminate_deadline)
                 except TimeoutError:
                     _kill_process(process)
-                    await process.wait()
-            await self._join_tasks()
+                    try:
+                        await self._wait_for_process(process, kill_deadline)
+                    except TimeoutError:
+                        # a process that survived SIGKILL will not be waited out,
+                        # so let go of it here instead of holding the lifecycle
+                        # lock
+                        self._abandon(process)
+                        self._state = JsonlProcessState.STOPPED
+                        self._send_closed_message()
+                        return
+            # an exited process is no guarantee of EOF: a background command it
+            # left behind can hold the pipes open, and then the readers never
+            # finish on their own either
+            remaining = deadline - asyncio.get_running_loop().time()
+            try:
+                if remaining <= 0:
+                    raise TimeoutError
+                async with asyncio.timeout(remaining):
+                    await self._join_tasks()
+            except TimeoutError:
+                self._abandon(process)
             self._state = JsonlProcessState.STOPPED
             self._send_closed_message()
 
@@ -493,6 +520,70 @@ class JsonlProcessSupervisor:
         async with asyncio.timeout(remaining):
             await asyncio.shield(process.wait())
 
+    def _abandon(self, process: asyncio.subprocess.Process) -> None:
+        """Give up on a process without losing track of it.
+
+        Closing this side of the pipes is what unblocks everything: the readers
+        stop waiting for an EOF that a grandchild holding the write end will
+        never deliver, and the exit waiters can complete once the pipes count as
+        disconnected. Whoever still holds that write end is free to keep it.
+        """
+
+        transport = getattr(process, "_transport", None)
+        if transport is not None:
+            for fd in (1, 2):
+                pipe = transport.get_pipe_transport(fd)
+                if pipe is not None:
+                    pipe.close()
+        # the watcher normally publishes the exit, and it is about to be
+        # cancelled, so release whoever is already waiting on it
+        self._exit_event.set()
+        pending = tuple(self._pending.values())
+        self._pending.clear()
+        # the process may already have exited here, and then its status is the
+        # honest answer; the reaper publishes the rest once it arrives
+        exited = JsonlProcessExited(
+            returncode=process.returncode,
+            stderr_tail=self.stderr_tail,
+        )
+        for future in pending:
+            if not future.done():
+                future.set_exception(exited)
+        tasks = tuple(
+            task
+            for task in (self._stdout_task, self._stderr_task, self._watch_task)
+            if task is not None and task is not asyncio.current_task()
+        )
+        for task in tasks:
+            task.cancel()
+        self._stdout_task = None
+        self._stderr_task = None
+        self._watch_task = None
+        self._process = None
+        reaper = asyncio.create_task(
+            self._reap(process, tasks),
+            name=f"bcn-codex-reap-{process.pid}",
+        )
+        self._abandoned.add(reaper)
+        reaper.add_done_callback(self._abandoned.discard)
+
+    async def _reap(
+        self,
+        process: asyncio.subprocess.Process,
+        tasks: tuple[asyncio.Task[None], ...],
+    ) -> None:
+        """Outlive the caller waiting for a process nobody else is waiting for."""
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        try:
+            async with asyncio.timeout(_REAP_REPORT_SECONDS):
+                returncode = await process.wait()
+        except TimeoutError:
+            _LOGGER.warning("process %s outlived its kill; still waiting", process.pid)
+            returncode = await process.wait()
+        self._returncode = returncode
+
     async def _join_tasks(self) -> None:
         tasks = tuple(
             task
@@ -505,20 +596,6 @@ class JsonlProcessSupervisor:
         self._stderr_task = None
         self._watch_task = None
 
-    def _reset_runtime_state(self) -> None:
-        while True:
-            try:
-                self._incoming.get_nowait()
-            except asyncio.QueueEmpty:
-                break
-        self._stderr_tail.clear()
-        self._returncode = None
-        self._fatal_error = None
-        self._next_request_id = 0
-        self._closed_message_sent = False
-        self._exit_event.clear()
-        self._pending.clear()
-
     def _send_closed_message(self) -> None:
         if self._closed_message_sent:
             return

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/codex/runtime.py

@@ -5,8 +5,8 @@ import json
 import logging
 import os
 import shutil
-from collections.abc import Callable, Mapping
-from dataclasses import dataclass, field, replace
+from collections.abc import Callable
+from dataclasses import dataclass, replace
 from functools import partial
 from pathlib import Path
 from typing import Any
@@ -24,7 +24,6 @@ from ...core.paths import resolve_workspace_dir
 from ...core.runtime import (
     IRuntime,
     IRuntimeTurnStream,
-    RuntimeBackgroundIdle,
     RuntimeCommandContext,
     RuntimeExpire,
     RuntimeLifecycleEvent,
@@ -62,7 +61,6 @@ _INITIALIZE_ATTEMPTS = 2
 _RECONCILE_ATTEMPTS = 2
 _WORKSPACE_AGENTS_WATCH_ID = "bcn-agents-workspace"
 _CODEX_HOME_AGENTS_WATCH_ID = "bcn-agents-codex-home"
-_BACKGROUND_REFRESH_TIMEOUT_SECONDS = 10.0
 
 
 @dataclass(slots=True)
@@ -72,8 +70,6 @@ class _Connection:
     workspace: Path
     provider_thread_id: str
     active_turn_id: str | None = None
-    background_state_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
-    background_job_present: bool = False
 
 
 class Runtime(IRuntime, IAsyncLifecycle):
@@ -113,7 +109,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         self._effort = effort
         self._connections: dict[str, _Connection] = {}
         self._lifecycle_events: asyncio.Queue[RuntimeLifecycleEvent] = asyncio.Queue()
-        self._background_refresh_tasks: set[asyncio.Task[None]] = set()
         self._logger = logging.getLogger("bazaar_compute_node.runtime.codex")
         self._started = False
         self._stopping = False
@@ -122,11 +117,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         del timeout
         if self._stopping:
             raise RuntimeError("Codex App Server runtime is stopping")
-        if os.name == "nt":
-            self._logger.warning(
-                "Codex idle timeout is not supported on Windows; "
-                "see openai/codex#15461."
-            )
         self._started = True
 
     async def stop(self, *, timeout: float) -> None:
@@ -135,11 +125,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         self._stopping = True
         connections = tuple(self._connections.items())
         self._connections.clear()
-        refresh_tasks = tuple(self._background_refresh_tasks)
-        for task in refresh_tasks:
-            task.cancel()
-        if refresh_tasks:
-            await asyncio.gather(*refresh_tasks, return_exceptions=True)
         for _, connection in connections:
             try:
                 await connection.supervisor.stop(timeout=timeout)
@@ -519,25 +504,20 @@ class Runtime(IRuntime, IAsyncLifecycle):
         *,
         timeout: float,
     ) -> bool:
-        if os.name == "nt":
-            # Detached OS processes are not exposed by the Windows Codex provider.
-            return True
         connection = self._connections.get(session.id)
         provider_thread_id = session.provider_thread_id
         if connection is None or not provider_thread_id:
             return False
         try:
-            async with connection.background_state_lock:
-                response = await connection.client.list_background_terminals(
-                    provider_thread_id,
-                    timeout=timeout,
-                )
-                present = parse_background_terminals_response(response)
-                if self._connections.get(session.id) is connection:
-                    _record_background_state(connection, present)
+            response = await connection.client.list_background_terminals(
+                provider_thread_id,
+                timeout=timeout,
+            )
         except AppServerProtocolError, JsonlTransportError:
-            return False
-        return present
+            # a question the provider could not answer is not a no: report work
+            # so the caller keeps the session instead of recycling a busy one
+            return True
+        return parse_background_terminals_response(response)
 
     async def stop_session(
         self,
@@ -563,7 +543,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         *,
         targets: dict[str, Path],
         runtime_session_id: str,
-        origin_holder: list[_Connection],
     ) -> bool:
         """Decide what a provider notification means for the session that owns it."""
 
@@ -572,27 +551,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
             parse_skills_changed_notification(message)
             self._lifecycle_events.put_nowait(RuntimeExpire(runtime_session_id))
             return True
-        if method == "item/completed" and os.name != "nt":
-            params = message.get("params")
-            item = params.get("item") if isinstance(params, Mapping) else None
-            if (
-                isinstance(params, Mapping)
-                and isinstance(params.get("threadId"), str)
-                and isinstance(item, Mapping)
-                and item.get("type") == "commandExecution"
-            ):
-                if not origin_holder:
-                    return False
-                origin = origin_holder[0]
-                task = asyncio.create_task(
-                    self._refresh_background_state(
-                        runtime_session_id,
-                        origin,
-                    ),
-                    name=f"bcn-codex-background-{runtime_session_id}",
-                )
-                self._background_refresh_tasks.add(task)
-                task.add_done_callback(self._background_refresh_tasks.discard)
         if method != "fs/changed":
             return False
         changed = parse_fs_changed_notification(message)
@@ -648,7 +606,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
         environment = dict(self._context.environment_for_session(session))
         for attempt in range(_INITIALIZE_ATTEMPTS):
             watch_targets: dict[str, Path] = {}
-            connection_holder: list[_Connection] = []
 
             supervisor = JsonlProcessSupervisor(
                 JsonlProcessSpec(
@@ -661,7 +618,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
                     self._route_notification,
                     targets=watch_targets,
                     runtime_session_id=session.id,
-                    origin_holder=connection_holder,
                 ),
             )
             client = Client(supervisor)
@@ -682,33 +638,9 @@ class Runtime(IRuntime, IAsyncLifecycle):
                 workspace=workspace,
                 provider_thread_id=session.provider_thread_id or "",
             )
-            connection_holder.append(connection)
             return connection
         raise AssertionError("Codex initialization retry loop did not return")
 
-    async def _refresh_background_state(
-        self,
-        session_id: str,
-        connection: _Connection,
-    ) -> None:
-        if self._connections.get(session_id) is not connection:
-            return
-        async with connection.background_state_lock:
-            if self._connections.get(session_id) is not connection:
-                return
-            try:
-                response = await connection.client.list_background_terminals(
-                    connection.provider_thread_id,
-                    timeout=_BACKGROUND_REFRESH_TIMEOUT_SECONDS,
-                )
-                present = parse_background_terminals_response(response)
-            except AppServerProtocolError, JsonlTransportError:
-                return
-            if self._connections.get(session_id) is not connection:
-                return
-            if _record_background_state(connection, present):
-                self._lifecycle_events.put_nowait(RuntimeBackgroundIdle(session_id))
-
     async def _stop_connection(
         self,
         connection: _Connection,
@@ -730,12 +662,6 @@ class Runtime(IRuntime, IAsyncLifecycle):
             raise RuntimeError("Codex App Server runtime is not started")
 
 
-def _record_background_state(connection: _Connection, present: bool) -> bool:
-    was_present = connection.background_job_present
-    connection.background_job_present = present
-    return was_present and not present
-
-
 def _provider_result(error: BaseException) -> ProviderCallResult[Any]:
     if isinstance(
         error,

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/sqlite/codec.py

@@ -294,9 +294,13 @@ def validate_outbound_message_input(message: object) -> None:
 
 
 def validate_outbound_insert(message: Message[OutboundAttachment]) -> None:
-    if message.delivery_state is not OutboundDeliveryState.PENDING:
-        raise ValueError("a new outbound message must start in pending state")
-    if any(
+    """Check a message written once the provider has already answered.
+
+    An outbound is recorded after its attempt, so it arrives carrying whatever
+    became of it; only a message still waiting may claim to know nothing.
+    """
+
+    if message.delivery_state is OutboundDeliveryState.PENDING and any(
         value is not None
         for value in (
             message.provider_message_id,
@@ -442,7 +446,6 @@ def validate_channel_session_update(
         existing.channel != incoming.channel
         or existing.provider_thread_id != incoming.provider_thread_id
         or existing.target_kind is not incoming.target_kind
-        or existing.created_at_ms != incoming.created_at_ms
     ):
         raise ValueError("channel session identity cannot change")
     _validate_updated_at(existing.updated_at_ms, incoming.updated_at_ms)

{bazaar_compute_node-0.2.0rc4 → bazaar_compute_node-0.2.0rc5}/src/bazaar_compute_node/contrib/sqlite/migrations/registry.py

@@ -37,6 +37,7 @@ from .v23_persist_sender_identity import SENDER_IDENTITY_MIGRATION
 from .v24_persist_sender_display_name import SENDER_DISPLAY_NAME_MIGRATION
 from .v25_rename_sessions_to_threads import THREAD_RENAME_MIGRATION
 from .v26_remove_handoff_messages import HANDOFF_MESSAGE_REMOVAL_MIGRATION
+from .v27_name_dms_by_the_peer_id import NAME_DM_BY_PEER_ID_MIGRATION
 
 if TYPE_CHECKING:
     from ..executor import SqliteSession
@@ -85,6 +86,7 @@ MIGRATIONS = _migration_ledger(
     SENDER_DISPLAY_NAME_MIGRATION,
     THREAD_RENAME_MIGRATION,
     HANDOFF_MESSAGE_REMOVAL_MIGRATION,
+    NAME_DM_BY_PEER_ID_MIGRATION,
 )