multacd 2.0.0b7__tar.gz → 2.0.0b8__tar.gz

{multacd-2.0.0b7 → multacd-2.0.0b8}/.github/workflows/release.yml

@@ -101,7 +101,7 @@ jobs:
 
             ```bash
             pkg install -y python git
-            pip install "multacd==2.0.0b7"
+            pip install "multacd==2.0.0b8"
             ```
 
             Windows (PowerShell):

{multacd-2.0.0b7 → multacd-2.0.0b8}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 Format: Keep a Changelog. Versi: Semantic Versioning.
 
+## [2.0.0b8] - 2026-09-13
+
+Beta v2 kedelapan (refactor arsitektur, tanpa ubah fitur): kontrak event
+`core/agent_events` (R2), SessionState + reducer keluar widget (R3),
+AgentController + fix approve [A] lintas turn (#32, R4), widget render
+dari state (R5), research sink task-scoped (R6), splash §10 lengkap (R7).
+
+Install: `pip install "multacd==2.0.0b8"` (tanpa --pre).
+
 ## [2.0.0b7] - 2026-09-12
 
 Beta v2 ketujuh (borongan): config key kosong dimaafkan (#27), limit jadi

{multacd-2.0.0b7 → multacd-2.0.0b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: multacd
-Version: 2.0.0b7
+Version: 2.0.0b8
 Summary: Agentic TUI for coding, research, and personal automation
 Project-URL: Homepage, https://github.com/prototypeall850-creator/multacd
 Project-URL: Issues, https://github.com/prototypeall850-creator/multacd/issues

multacd-2.0.0b8/core/agent_events.py

@@ -0,0 +1,86 @@
+"""Agent event contract — satu-satunya bahasa agent runtime → UI.
+
+Dipakai `core/agent_loop.py` (yield) dan consumer (`tui`, `tg`, tests).
+Modul ini murni dataclass: tanpa import Textual, tanpa I/O, tanpa LLM —
+tujuannya biar boundary tidak gampang bocor saat refactor (R2).
+
+Test cepat:
+    python -m core.agent_events
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AgentText:
+    delta: str
+
+
+@dataclass
+class AgentToolStart:
+    call_id: str
+    name: str
+    params: dict[str, Any]
+
+
+@dataclass
+class AgentToolDone:
+    call_id: str
+    name: str
+    success: bool
+    result: dict[str, Any] | None = None  # payload penuh (D4: expandable view)
+
+
+@dataclass
+class AgentDone:
+    text: str
+
+
+@dataclass
+class AgentUsage:
+    """Token resmi provider untuk satu panggilan LLM (0 = tak dilapor)."""
+
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    cost_usd: float = 0.0  # estimasi lokal (tabel harga provider)
+
+
+@dataclass
+class AgentContinue:
+    """LLM minta lanjut padahal batas iterasi tercapai.
+
+    Bukan error — TUI tampilkan ringkasan + tombol Lanjut/Berhenti.
+    CLI fallback: auto-lanjut kalau stdin bukan TTY? tidak — default berhenti.
+    Lihat run_agent(continue_on_limit) + main_screen._run_turn.
+    """
+
+    tool_count: int
+    limit: int
+    summary: str  # ringkasan tool terakhir biar user bisa nilai
+
+
+@dataclass
+class AgentError:
+    message: str
+
+
+AgentEvent = AgentText | AgentToolStart | AgentToolDone | AgentDone | AgentUsage | AgentContinue | AgentError
+
+
+if __name__ == "__main__":
+    evs: list[AgentEvent] = [
+        AgentText("halo"),
+        AgentToolStart("c1", "list_dir", {"path": "."}),
+        AgentToolDone("c1", "list_dir", True, {"success": True}),
+        AgentDone("selesai"),
+        AgentUsage(10, 5, 0.001),
+        AgentContinue(3, 3, "list_dir"),
+        AgentError("gagal"),
+    ]
+    assert len(evs) == 7
+    assert isinstance(evs[0], AgentText) and evs[0].delta == "halo"
+    assert isinstance(evs[5], AgentContinue) and evs[5].limit == 3
+    print("✅ agent_events self-test OK (7 event contract)")

{multacd-2.0.0b7 → multacd-2.0.0b8}/core/agent_loop.py

@@ -22,9 +22,18 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import AsyncIterator, Awaitable, Callable
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
+from core.agent_events import (
+    AgentContinue,
+    AgentDone,
+    AgentError,
+    AgentEvent,
+    AgentText,
+    AgentToolDone,
+    AgentToolStart,
+    AgentUsage,
+)
 from core.config import Config
 from core.llm_client import LLMClient, LLMError, StreamDone, StreamText, setup_client
 from core.permissions import PermissionChecker
@@ -54,57 +63,19 @@ AskCallback = Callable[[str], Awaitable[str]]
 OutputCallback = Callable[[str, str], None]
 
 
-@dataclass
-class AgentText:
-    delta: str
-
-
-@dataclass
-class AgentToolStart:
-    call_id: str
-    name: str
-    params: dict[str, Any]
-
-
-@dataclass
-class AgentToolDone:
-    call_id: str
-    name: str
-    success: bool
-    result: dict[str, Any] | None = None  # payload penuh (D4: expandable view)
-
-
-@dataclass
-class AgentDone:
-    text: str
-
-
-@dataclass
-class AgentUsage:
-    """Token resmi provider untuk satu panggilan LLM (0 = tak dilapor)."""
-
-    prompt_tokens: int = 0
-    completion_tokens: int = 0
-    cost_usd: float = 0.0  # estimasi lokal (tabel harga provider)
-
-
-@dataclass
-class AgentContinue:
-    """LLM minta lanjut padahal batas iterasi tercapai.
-
-    Bukan error — TUI tampilkan ringkasan + tombol Lanjut/Berhenti.
-    CLI fallback: auto-lanjut kalau stdin bukan TTY? tidak — default berhenti.
-    Lihat run_agent(continue_on_limit) + main_screen._run_turn.
-    """
-
-    tool_count: int
-    limit: int
-    summary: str  # ringkasan tool terakhir biar user bisa nilai
-
-
-@dataclass
-class AgentError:
-    message: str
+# Re-export biar import lama (`from core.agent_loop import AgentText, ...`)
+# tetap jalan selama migrasi (R2: tanpa ubah behavior).
+__all__ = [
+    "AgentContinue",
+    "AgentDone",
+    "AgentError",
+    "AgentEvent",
+    "AgentText",
+    "AgentToolDone",
+    "AgentToolStart",
+    "AgentUsage",
+    "run_agent",
+]
 
 
 def _stuck_error(tool_name: str) -> AgentError:
@@ -116,9 +87,6 @@ def _stuck_error(tool_name: str) -> AgentError:
     )
 
 
-AgentEvent = AgentText | AgentToolStart | AgentToolDone | AgentDone | AgentUsage | AgentContinue | AgentError
-
-
 async def _stdin_confirm(tool_name: str, params: dict[str, Any]) -> str:
     target = params.get("path") or params.get("command") or params.get("url") or ""
     extra = ""
@@ -167,6 +135,7 @@ async def run_agent(
     composer: PromptComposer | None = None,
     output_cb: OutputCallback | None = None,
     continue_on_limit: bool = False,
+    checker: PermissionChecker | None = None,
 ) -> AsyncIterator[AgentEvent]:
     """Jalankan satu turn agent. Yield AgentEvent secara real-time.
 
@@ -176,6 +145,11 @@ async def run_agent(
     retry lanjutan) langsung lanjut tanpa tanya. Infinite loop nyata
     (LLM ngulang tool sama tanpa progres) tetap berhenti via deteksi
     stagnan di bawah.
+
+    `checker` opsional biar pemilik sesi (AgentController) bisa pakai
+    satu PermissionChecker lintas turn — approve [A] jadi beneran
+    per-sesi, bukan hilang tiap turn (issue #32). Default None =
+    checker baru per turn (perilaku lama, dipakai CLI/test).
     """
     def _system_prompt() -> str:
         return composer.compose() if composer is not None else SYSTEM_PROMPT
@@ -191,7 +165,7 @@ async def run_agent(
         return
 
     llm = llm_client or setup_client(config)
-    checker = PermissionChecker(config)
+    checker = checker or PermissionChecker(config)
     confirm_cb = confirm or _stdin_confirm
     ask_cb = ask_user or _stdin_ask
     defs = get_tool_definitions()

multacd-2.0.0b8/core/research/bus.py

@@ -0,0 +1,66 @@
+"""Bus event research — jembatan orchestrator → TUI (R6: task-scoped).
+
+Alur: tool research (quick/deep) jalan sync di worker, orchestrator-nya
+async (kadang di thread terpisah via _run_coro). Callback on_event harus
+sampai ke widget Textual yang hidup di app loop.
+
+Dulu global mutable (`_sink`) — satu turn nimpa turn lain kalau dua sesi
+jalan bareng (TUI + daemon/tg, test paralel). Sekarang ContextVar: tiap
+task asyncio bawa sink sendiri-sendiri. Rantai propagasi dijaga dua titik:
+
+- `asyncio.to_thread(execute_tool)` (agent_loop) = copy context otomatis.
+- `_run_coro` (tools/research) = copy explisit (pool thread tidak warisi
+  context sendiri) — lihat quick_research._run_coro.
+
+API (set/get) tidak berubah — caller (controller, tool wrapper) sama.
+"""
+
+from __future__ import annotations
+
+import contextvars
+from collections.abc import Callable
+from typing import Any
+
+_sink: contextvars.ContextVar[
+    Callable[[dict[str, Any]], None] | None
+] = contextvars.ContextVar("research_sink", default=None)
+
+
+def set_research_sink(fn: Callable[[dict[str, Any]], None] | None) -> None:
+    """Pasang/cabut sink buat task ini saja (None = cabut)."""
+    _sink.set(fn)
+
+
+def get_research_sink() -> Callable[[dict[str, Any]], None] | None:
+    """Dibaca tool wrapper research saat panggil orchestrator."""
+    return _sink.get()
+
+
+if __name__ == "__main__":
+    import asyncio as _asyncio
+
+    assert get_research_sink() is None
+    evs: list = []
+    set_research_sink(evs.append)
+    assert get_research_sink() is not None
+    get_research_sink()({"type": "x"})
+    assert evs == [{"type": "x"}]
+    set_research_sink(None)
+    assert get_research_sink() is None
+
+    # Task-scoped: dua task tak saling timpa.
+    async def _main() -> None:
+        async def _isi(nama: str, wadah: list) -> None:
+            set_research_sink(wadah.append)
+            await _asyncio.sleep(0.01)  # kasih jeda biar interleave
+            get_research_sink()({"type": nama})  # type: ignore[operator]
+
+        a: list = []
+        b: list = []
+        await _asyncio.gather(_isi("a", a), _isi("b", b))
+        assert a == [{"type": "a"}], a
+        assert b == [{"type": "b"}], b
+        assert get_research_sink() is None  # task utama tak tercemar
+
+    _asyncio.run(_main())
+    print("✅ research bus self-test OK (task-scoped)")

multacd-2.0.0b8/core/session_state.py

@@ -0,0 +1,127 @@
+"""Session state — satu sumber kebenaran status agent per sesi (R3).
+
+Dulu status turn/token/cost/tool tersebar di `MainScreen`
+(`_turn_running`, `_tools_run`, `_sess_*`). Sekarang satu object:
+
+    state = SessionState()
+    state = reduce_event(state, event)  # tiap AgentEvent
+    ui.render(state)                    # widget baca state, bukan sebaliknya
+
+Tanpa import Textual — headless testable. Mode/model tetap milik
+config/mode_manager (tidak diduplikat di sini).
+
+Test cepat:
+    python -m core.session_state
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+from core.agent_events import (
+    AgentContinue,
+    AgentDone,
+    AgentError,
+    AgentEvent,
+    AgentText,
+    AgentToolDone,
+    AgentToolStart,
+    AgentUsage,
+)
+
+
+class AgentStatus(str, Enum):
+    IDLE = "idle"
+    THINKING = "thinking"
+    EXECUTING_TOOL = "executing"
+    WAITING_PERMISSION = "waiting_permission"
+    WAITING_USER = "waiting_user"
+
+
+@dataclass
+class SessionState:
+    """Status agent + metrik sesi. Satu instance per sesi TUI."""
+
+    status: AgentStatus = AgentStatus.IDLE
+    current_tool: str | None = None
+    current_call_id: str | None = None
+    tool_count: int = 0
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    cost_usd: float = 0.0
+    # Izin [A] per sesi (#32): resolver hidup di sini nantinya (R4).
+    # Dicatat dulu biar kontraknya jelas — belum dipakai runtime.
+    session_approved: set[str] = field(default_factory=set)
+
+    @property
+    def busy(self) -> bool:
+        """True selama turn jalan (dipakai submit-guard + quit-guard)."""
+        return self.status is not AgentStatus.IDLE
+
+    def begin_turn(self) -> None:
+        self.status = AgentStatus.THINKING
+        self.current_tool = None
+        self.current_call_id = None
+
+    def end_turn(self) -> None:
+        self.status = AgentStatus.IDLE
+        self.current_tool = None
+        self.current_call_id = None
+
+
+def reduce_event(state: SessionState, event: AgentEvent) -> SessionState:
+    """Lipat satu AgentEvent ke state. Return state yang sama (boleh chaining)."""
+    if isinstance(event, AgentToolStart):
+        state.status = AgentStatus.EXECUTING_TOOL
+        state.current_tool = event.name
+        state.current_call_id = event.call_id
+    elif isinstance(event, AgentToolDone):
+        state.status = AgentStatus.THINKING
+        state.current_tool = None
+        state.current_call_id = None
+        state.tool_count += 1
+    elif isinstance(event, AgentUsage):
+        state.prompt_tokens += event.prompt_tokens
+        state.completion_tokens += event.completion_tokens
+        state.cost_usd += event.cost_usd
+    elif isinstance(event, AgentContinue):
+        state.status = AgentStatus.WAITING_USER
+        state.current_tool = None
+        state.current_call_id = None
+    elif isinstance(event, (AgentDone, AgentError)):
+        state.status = AgentStatus.IDLE
+        state.current_tool = None
+        state.current_call_id = None
+    elif isinstance(event, AgentText):
+        if state.status in (AgentStatus.IDLE, AgentStatus.WAITING_USER):
+            state.status = AgentStatus.THINKING
+    return state
+
+
+if __name__ == "__main__":
+    s = SessionState()
+    assert not s.busy and s.status is AgentStatus.IDLE
+    s.begin_turn()
+    assert s.busy
+    reduce_event(s, AgentText("hai"))
+    assert s.status is AgentStatus.THINKING
+    reduce_event(s, AgentToolStart("c1", "bash", {"command": "ls"}))
+    assert s.status is AgentStatus.EXECUTING_TOOL
+    assert s.current_tool == "bash" and s.current_call_id == "c1"
+    reduce_event(s, AgentUsage(10, 5, 0.001))
+    assert (s.prompt_tokens, s.completion_tokens) == (10, 5)
+    reduce_event(s, AgentToolDone("c1", "bash", True, {"success": True}))
+    assert s.tool_count == 1 and s.current_tool is None
+    assert s.status is AgentStatus.THINKING
+    reduce_event(s, AgentContinue(3, 3, "bash"))
+    assert s.status is AgentStatus.WAITING_USER and s.busy
+    s.begin_turn()  # lanjut → thinking lagi
+    reduce_event(s, AgentDone("ok"))
+    assert s.status is AgentStatus.IDLE and not s.busy
+    s.begin_turn()
+    reduce_event(s, AgentError("boom"))
+    assert s.status is AgentStatus.IDLE
+    s.end_turn()
+    assert not s.busy
+    print("✅ session_state self-test OK (reducer + lifecycle)")

{multacd-2.0.0b7 → multacd-2.0.0b8}/core/version.py

@@ -8,7 +8,7 @@ Saat bump versi (Step 10 → 1.0.0): ubah pyproject + FALLBACK di sini.
 
 from __future__ import annotations
 
-FALLBACK = "2.0.0b7"  # beta v2; samakan dengan pyproject.toml
+FALLBACK = "2.0.0b8"  # beta v2; samakan dengan pyproject.toml
 
 
 def get_version() -> str:

{multacd-2.0.0b7 → multacd-2.0.0b8}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "multacd"
-version = "2.0.0b7"
+version = "2.0.0b8"
 description = "Agentic TUI for coding, research, and personal automation"
 readme = "README.md"
 requires-python = ">=3.10"

{multacd-2.0.0b7 → multacd-2.0.0b8}/scripts/install.sh

@@ -78,7 +78,7 @@ termux_pip_guide() {
     echo "     (ringan: tanpa kompilasi Rust — dependensi wheel murni)"
     echo ""
     echo "  2. Install multacd:"
-    echo "     pip install \"multacd==2.0.0b7\""
+    echo "     pip install \"multacd==2.0.0b8\""
     echo ""
     echo "  3. Jalankan: multacd"
     echo ""

{multacd-2.0.0b7 → multacd-2.0.0b8}/tests/test_selftests.py

@@ -26,6 +26,9 @@ _ISOLATED_HOME = tempfile.mkdtemp(prefix="multacd-pytest-home-")
 # Modul dengan self-test `python -m <module>` (exit 0 = lolos).
 SELF_TEST_MODULES = [
     "core.agent_loop",
+    "core.agent_events",
+    "core.session_state",
+    "tui.controllers.agent_controller",
     "core.llm_client",
     "core.permissions",
     "core.mode_manager",
@@ -51,6 +54,7 @@ SELF_TEST_MODULES = [
     "tui.themes",
     "tui.markup_safe",
     "tui.widgets.thinking_bar",
+    "tui.widgets.status_bar",
     "tui.widgets.permission_popup",
     "tui.widgets.tool_activity",
     "tui.widgets.slash_palette",

multacd-2.0.0b8/tests/unit/test_agent_controller.py

@@ -0,0 +1,118 @@
+"""Unit: AgentController — loop turn headless tanpa Textual (R4)."""
+
+from __future__ import annotations
+
+import asyncio
+
+from core.agent_events import AgentContinue, AgentDone
+from core.llm_client import StreamDone, ToolCallRequest
+from core.session_state import AgentStatus, SessionState
+from memory.context import ConversationContext
+from tui.controllers.agent_controller import AgentController, TurnHooks
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+async def _no_continue(ev: AgentContinue) -> bool:
+    raise AssertionError("tak boleh Continue di sini")
+
+
+async def _no_ask(question: str) -> str:
+    raise AssertionError("tak boleh ask")
+
+
+def _no_live(call_id: str, line: str) -> None:
+    pass
+
+
+def _hooks(emit, confirm, cont=_no_continue):
+    return TurnHooks(emit=emit, continue_prompt=cont, confirm=confirm,
+                     ask_user=_no_ask, live=_no_live)
+
+
+def test_plain_turn_emits_and_idles(sample_config, fake_llm_factory):
+    ctx = ConversationContext()
+    ctl = AgentController(SessionState(), sample_config, ctx)
+    ctl.llm_client = fake_llm_factory([StreamDone("halo dunia", [])])
+    seen: list[str] = []
+
+    async def _emit(ev):
+        seen.append(type(ev).__name__)
+
+    async def _deny(name, params):
+        raise AssertionError("tak boleh confirm")
+
+    _run(ctl.run_turn("hi", _hooks(_emit, _deny)))
+    assert seen[0] == "AgentText" and seen[-1] == "AgentDone", seen
+    assert ctl.session.status is AgentStatus.IDLE
+
+
+def test_session_approve_persists_across_turns(sample_config,
+                                               fake_llm_factory):
+    """Regression #32: [A] di turn 1 → turn 2 auto tanpa confirm."""
+    ctx = ConversationContext()
+    ctl = AgentController(SessionState(), sample_config, ctx)
+    seen: list[str] = []
+
+    async def _emit(ev):
+        seen.append(type(ev).__name__)
+
+    ctl.llm_client = fake_llm_factory([
+        StreamDone("", [ToolCallRequest(id="c1", name="bash",
+                                        arguments={"command": "echo a"})]),
+        StreamDone("satu", []),
+    ])
+    calls: list[str] = []
+
+    async def _all(name, params):
+        calls.append(name)
+        return "all"
+
+    _run(ctl.run_turn("run", _hooks(_emit, _all), active_tools=["bash"]))
+    assert calls == ["bash"]
+    assert isinstance(seen[-1], str) and "AgentToolDone" in seen
+
+    ctl.llm_client = fake_llm_factory([
+        StreamDone("", [ToolCallRequest(id="c2", name="bash",
+                                        arguments={"command": "echo b"})]),
+        StreamDone("dua", []),
+    ])
+
+    async def _boom(name, params):
+        raise AssertionError("turn 2 harus auto (approve sesi persist)")
+
+    _run(ctl.run_turn("lagi", _hooks(_emit, _boom), active_tools=["bash"]))
+    assert ctx.get_messages()[-2]["content"] == "b"  # hasil echo b
+
+
+def test_continue_prompt_continues_without_reset(sample_config,
+                                                 fake_llm_factory):
+    sample_config.max_tool_iterations = 1
+    ctx = ConversationContext()
+    ctl = AgentController(SessionState(), sample_config, ctx)
+    ctl.llm_client = fake_llm_factory([
+        StreamDone("", [ToolCallRequest(id="c1", name="list_dir",
+                                        arguments={"path": "."})]),
+        StreamDone("", [ToolCallRequest(id="c2", name="list_dir",
+                                        arguments={"path": "."})]),
+        StreamDone("selesai", []),
+    ])
+    dones = 0
+
+    async def _emit(ev):
+        nonlocal dones
+        if isinstance(ev, AgentDone):
+            dones += 1
+
+    async def _yes(name, params):
+        return "yes"
+
+    async def _lanjut(ev: AgentContinue) -> bool:
+        assert ev.limit == 1
+        return True
+
+    _run(ctl.run_turn("loop", _hooks(_emit, _yes, _lanjut)))
+    assert dones == 1  # AgentContinue di-swalallow controller, user terima Done
+    assert ctl.session.status is AgentStatus.IDLE

multacd-2.0.0b8/tests/unit/test_research_bus.py

@@ -0,0 +1,69 @@
+"""Unit: research bus task-scoped — dua sesi tak saling timpa (R6)."""
+
+from __future__ import annotations
+
+import asyncio
+
+from core.research.bus import get_research_sink, set_research_sink
+from tools.research.quick_research import _run_coro
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def test_tasks_do_not_clobber_each_other():
+    async def _main():
+        async def _isi(nama: str, wadah: list) -> None:
+            set_research_sink(wadah.append)
+            await asyncio.sleep(0.01)  # interleave
+            get_research_sink()({"type": nama})
+
+        a: list = []
+        b: list = []
+        await asyncio.gather(_isi("a", a), _isi("b", b))
+        assert a == [{"type": "a"}]
+        assert b == [{"type": "b"}]
+
+    _run(_main())
+    assert get_research_sink() is None  # konteks luar tak tercemar
+
+
+def test_reset_only_affects_own_task():
+    async def _main():
+        set_research_sink(lambda ev: None)
+        assert get_research_sink() is not None
+        set_research_sink(None)
+        assert get_research_sink() is None
+
+    _run(_main())
+    assert get_research_sink() is None
+
+
+def test_sink_survives_run_coro_pool_boundary():
+    """Rantai TUI: task → to_thread → _run_coro(pool) → sink tetap sama."""
+
+    async def _coro_read():
+        from core.research.bus import get_research_sink as _get
+        return _get()
+
+    async def _main():
+        marker = object()
+        set_research_sink(marker)  # type: ignore[arg-type]
+        # _run_coro dari dalam loop = jalur agent_loop (pool thread).
+        assert _run_coro(_coro_read()) is marker
+        # to_thread juga mewarisi context.
+        seen = await asyncio.to_thread(get_research_sink)
+        assert seen is marker
+        set_research_sink(None)
+
+    _run(_main())
+
+
+def test_no_sink_outside_turn():
+    async def _coro_read():
+        from core.research.bus import get_research_sink as _get
+        return _get()
+
+    # Konteks sync tanpa set → asyncio.run biasa → None.
+    assert _run_coro(_coro_read()) is None