KohakuTerrarium 2.0.0.dev4__tar.gz → 2.0.0.dev5__tar.gz

{kohakuterrarium-2.0.0.dev4/src/KohakuTerrarium.egg-info → kohakuterrarium-2.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KohakuTerrarium
-Version: 2.0.0.dev4
+Version: 2.0.0.dev5
 Summary: A universal agent framework for building self-driven AI agents and multi-agent teams
 Author-email: "Shih-Ying Yeh (KohakuBlueLeaf)" <apolloyeh0123@gmail.com>
 License: KohakuTerrarium-1.0

{kohakuterrarium-2.0.0.dev4 → kohakuterrarium-2.0.0.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "KohakuTerrarium"
-version = "2.0.0.dev4"
+version = "2.0.0.dev5"
 description = "A universal agent framework for building self-driven AI agents and multi-agent teams"
 authors = [
     { name = "Shih-Ying Yeh (KohakuBlueLeaf)", email = "apolloyeh0123@gmail.com" },
@@ -157,7 +157,7 @@ select = ["F401", "F841"]
 [tool.briefcase]
 project_name = "KohakuTerrarium"
 bundle = "com.kohaku.terrarium"
-version = "2.0.0.dev4"
+version = "2.0.0.dev5"
 url = "https://github.com/Kohaku-Lab/KohakuTerrarium"
 license.file = "LICENSE"
 author = "Shih-Ying Yeh (KohakuBlueLeaf)"

{kohakuterrarium-2.0.0.dev4 → kohakuterrarium-2.0.0.dev5/src/KohakuTerrarium.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KohakuTerrarium
-Version: 2.0.0.dev4
+Version: 2.0.0.dev5
 Summary: A universal agent framework for building self-driven AI agents and multi-agent teams
 Author-email: "Shih-Ying Yeh (KohakuBlueLeaf)" <apolloyeh0123@gmail.com>
 License: KohakuTerrarium-1.0

{kohakuterrarium-2.0.0.dev4 → kohakuterrarium-2.0.0.dev5}/src/KohakuTerrarium.egg-info/SOURCES.txt

@@ -289,6 +289,7 @@ src/kohakuterrarium/builtins/user_commands/tool_options.py
 src/kohakuterrarium/builtins/user_commands/triggers.py
 src/kohakuterrarium/builtins/user_commands/workspace.py
 src/kohakuterrarium/cli/__init__.py
+src/kohakuterrarium/cli/__main__.py
 src/kohakuterrarium/cli/_aio_entrypoint.py
 src/kohakuterrarium/cli/_aliases.py
 src/kohakuterrarium/cli/_config_layers.py

kohakuterrarium-2.0.0.dev5/src/kohakuterrarium/__briefcase__.py

@@ -0,0 +1,76 @@
+"""Briefcase desktop bundle entry point.
+
+The Briefcase artifact ships a launcher (this file's
+:func:`launcher.bootloader.prepare`) on top of a bundled Python +
+pre-installed ``app_packages``. On every launch we:
+
+1. Drive ``launcher.prepare()`` — first_install / maybe_update, splash
+   UI, atomic pointer swap. Returns the active version tree path.
+2. **Switch sys.path to the version tree** and clear the briefcase-
+   bundled ``kohakuterrarium.*`` from ``sys.modules``, then import
+   ``kohakuterrarium.cli`` — that import now resolves to the
+   version-tree copy.
+
+Why in-process ``sys.path`` swap instead of ``os.execv``:
+
+- Briefcase Windows shells ship ``python313._pth`` with
+  ``import site`` commented out → ``PYTHONPATH`` is ignored, so
+  ``os.execv`` with a tweaked env can't redirect the framework
+  import to the version tree.
+- ``sys.executable`` on briefcase is the stub binary itself
+  (``KohakuTerrarium.exe``), not a plain Python. Spawning it with
+  ``-m ...`` would re-enter the launcher, infinite-loop.
+
+Self-update therefore works as follows: the launcher writes the
+``active`` pointer at update-time; on the user's next relaunch the
+briefcase stub re-runs this module, ``prepare()`` reads the new
+pointer, and the in-process import resolves the framework code from
+the new version tree. The briefcase shell installer itself doesn't
+need to be re-downloaded.
+"""
+
+import sys
+
+from kohakuterrarium.launcher.bootloader import prepare
+
+
+def _swap_to_version_tree(site_packages: str) -> None:
+    """Prepend the version's ``site-packages/`` to ``sys.path`` and
+    evict the briefcase-bundled ``kohakuterrarium.*`` modules so the
+    framework re-imports from the version tree.
+
+    Keeps ``kohakuterrarium.launcher.*`` intact — that's still the
+    code we want for ``self-update`` etc. after the framework is up.
+    The framework's API layer imports ``launcher`` lazily anyway.
+    """
+    if site_packages not in sys.path:
+        sys.path.insert(0, site_packages)
+    # Evict everything except the launcher subpackage so the
+    # version-tree's framework code gets fresh imports.
+    for mod in list(sys.modules):
+        if mod == "kohakuterrarium" or (
+            mod.startswith("kohakuterrarium.")
+            and not mod.startswith("kohakuterrarium.launcher")
+        ):
+            del sys.modules[mod]
+
+
+def main() -> int:
+    result = prepare()
+    if result.done:
+        return result.exit_code
+    if result.site_packages is None:
+        return result.exit_code or 7
+
+    _swap_to_version_tree(str(result.site_packages))
+
+    # The launcher's already-imported ``kohakuterrarium`` package was
+    # just evicted — re-import the *framework's* version (now first in
+    # sys.path) and dispatch into its CLI entry.
+    from kohakuterrarium.cli import main as cli_main
+
+    return cli_main()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

kohakuterrarium-2.0.0.dev5/src/kohakuterrarium/cli/__main__.py

@@ -0,0 +1,13 @@
+"""``python -m kohakuterrarium.cli`` entry point.
+
+Used by the launcher's ``os.execv`` post-first-install — bypasses
+``kohakuterrarium.__main__`` (which contains the briefcase-bundle
+detector that would otherwise re-enter the launcher and loop).
+"""
+
+import sys
+
+from kohakuterrarium.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

kohakuterrarium-2.0.0.dev5/src/kohakuterrarium/launcher/bootloader.py

@@ -0,0 +1,290 @@
+"""Launcher entry point.
+
+Two entry shapes share most of the logic:
+
+- :func:`main` — used by ``python -m kohakuterrarium.launcher`` and the
+  ``kt-launcher`` console script. Drives :func:`prepare` and then
+  ``os.execv``'s the bundled Python with ``-m kohakuterrarium.cli`` so
+  the framework runs in a fresh process. Works on any environment
+  whose Python honours ``PYTHONPATH`` and exposes ``-m``.
+- :func:`prepare` — pure orchestration: parses settings, runs
+  first_install / maybe_update, returns the path to the active
+  version tree. No exec, no sys.path mutation.
+
+The briefcase desktop bundle's entry (``kohakuterrarium.__briefcase__``)
+calls :func:`prepare` directly and does in-process ``sys.path``
+manipulation rather than ``os.execv``. Briefcase ships a
+``python313._pth`` with ``import site`` disabled, which makes
+``PYTHONPATH`` ineffective; and ``sys.executable`` is the briefcase
+stub binary, not a plain Python — both make exec-into-versions
+impossible without redesigning the stub.
+"""
+
+import argparse
+import os
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from kohakuterrarium.launcher import migration as _migration
+from kohakuterrarium.launcher import settings as _settings
+from kohakuterrarium.launcher.log import get_logger
+from kohakuterrarium.launcher.paths import (
+    bundled_release_dir,
+    runtime_dir,
+    settings_path,
+    site_packages_dir,
+    version_dir,
+)
+from kohakuterrarium.launcher.splash_window import open_splash
+from kohakuterrarium.launcher.tree_ops import read_active_pointer
+from kohakuterrarium.launcher.update_runner import (
+    UpdateResult,
+    first_install,
+    maybe_update,
+    reset as runner_reset,
+)
+
+
+@dataclass
+class PrepareResult:
+    """Outcome of :func:`prepare`.
+
+    ``done=True`` means the launcher already finished its job (a
+    one-shot mode like ``--reset-settings`` or ``--splash-demo``) and
+    the caller should exit with ``exit_code``. ``site_packages``
+    populated means "you can hand off to the framework now"; the
+    caller decides whether to ``os.execv`` or do in-process
+    ``sys.path`` manipulation.
+    """
+
+    exit_code: int = 0
+    done: bool = False
+    error: str | None = None
+    version: str | None = None
+    version_root: Path | None = None
+    site_packages: Path | None = None
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="kt-launcher",
+        description="KohakuTerrarium launcher — manages versioned releases.",
+        add_help=False,  # let the framework's own argparse handle --help post-exec
+    )
+    parser.add_argument(
+        "--reset-settings",
+        action="store_true",
+        help="Overwrite app-settings.json with defaults and exit.",
+    )
+    parser.add_argument(
+        "--reset-runtime",
+        action="store_true",
+        help="Wipe runtime/versions/ and re-run first_install.",
+    )
+    parser.add_argument(
+        "--no-exec",
+        action="store_true",
+        help="Resolve launcher state and exit (don't exec into the version tree).",
+    )
+    parser.add_argument(
+        "--splash-demo",
+        action="store_true",
+        help="Open the splash window with a scripted progress sequence.",
+    )
+    known, _ = parser.parse_known_args(argv)
+    return known
+
+
+def prepare(argv: list[str] | None = None) -> "PrepareResult":
+    """Run the launcher's setup phase and return where the active
+    version lives. Does NOT exec, NOT modify ``sys.path``.
+
+    Used by both :func:`main` (which then exec's into a fresh process)
+    and :mod:`kohakuterrarium.__briefcase__` (which does in-process
+    ``sys.path`` manipulation).
+
+    The returned :class:`PrepareResult` carries a ``site_packages``
+    path on success, or an ``exit_code`` + ``error`` describing the
+    failure. The splash UI lifecycle is owned here so both entry
+    shapes get the same first-launch UX.
+    """
+    args = _parse_args(argv)
+    log = get_logger()
+
+    runtime_dir().mkdir(parents=True, exist_ok=True)
+
+    if args.reset_settings:
+        _settings.reset()
+        log.info("launcher: reset settings (wrote defaults to %s)", settings_path())
+        return PrepareResult(exit_code=0, done=True)
+
+    if args.reset_runtime:
+        log.info("launcher: --reset-runtime running first_install fresh")
+        result = runner_reset()
+        if not result.ok:
+            log.error("launcher: reset failed: %s", result.error)
+            return PrepareResult(exit_code=6, error=result.error, done=True)
+        log.info("launcher: reset succeeded at version %s", result.version)
+        return PrepareResult(exit_code=0, done=True)
+
+    if args.splash_demo:
+        return PrepareResult(exit_code=_run_splash_demo(log), done=True)
+
+    # One-shot 06 cleanup. Idempotent; no-op when nothing is there.
+    _migration.wipe_legacy_venv()
+
+    cfg = _settings.load()
+
+    if args.no_exec:
+        ptr = read_active_pointer()
+        log.info(
+            "launcher: --no-exec — runtime_dir=%s active=%s bundled_release=%s "
+            "feed.kind=%s channel=%s pinned=%s update_mode=%s",
+            runtime_dir(),
+            ptr.version if ptr else None,
+            bundled_release_dir(),
+            cfg.feed.kind,
+            cfg.channel,
+            cfg.pinned_version,
+            cfg.update.mode,
+        )
+        return PrepareResult(exit_code=0, done=True)
+
+    pointer = read_active_pointer()
+    if pointer is None:
+        # First launch — show splash so the user sees something during
+        # the (potentially long) extract / smoke / download. Without
+        # this, the briefcase shell appears frozen for tens of seconds.
+        srv = open_splash()
+        try:
+            srv.publish("Setting up", percent=5, message="")
+
+            def _progress(phase: str, percent: float, msg: str) -> None:
+                try:
+                    srv.publish(phase, percent=percent, message=msg)
+                except Exception:
+                    pass
+
+            log.info("launcher: no active pointer — first_install")
+            install_result = first_install(_progress)
+            if not install_result.ok:
+                srv.publish(
+                    "Failed",
+                    percent=100,
+                    message=install_result.error or "",
+                    status="failed",
+                )
+                log.error("launcher: first_install failed: %s", install_result.error)
+                time.sleep(2.0)
+                return PrepareResult(exit_code=5, error=install_result.error)
+            log.info("launcher: first_install succeeded at %s", install_result.version)
+            srv.publish(
+                "Ready",
+                percent=100,
+                message=str(install_result.version),
+                status="ok",
+            )
+            time.sleep(0.4)
+        finally:
+            try:
+                srv.stop()
+            except Exception:
+                pass
+        pointer = read_active_pointer()
+        if pointer is None:
+            log.error("launcher: first_install reported ok but pointer absent")
+            return PrepareResult(exit_code=7, error="post-install pointer absent")
+    else:
+        update_result = maybe_update()
+        if not update_result.ok:
+            log.warning(
+                "launcher: maybe_update reported failure (%s); "
+                "starting the existing version anyway",
+                update_result.error,
+            )
+        elif update_result.restart_required and update_result.version is not None:
+            log.info(
+                "launcher: maybe_update installed %s (auto mode)",
+                update_result.version,
+            )
+            pointer = read_active_pointer()
+            if pointer is None:
+                log.error("launcher: post-update pointer absent")
+                return PrepareResult(exit_code=7, error="post-update pointer absent")
+
+    target = version_dir(pointer.version)
+    site = site_packages_dir(target)
+    if not site.is_dir():
+        log.error("launcher: site-packages missing at %s", site)
+        return PrepareResult(exit_code=3, error=f"site-packages missing at {site}")
+
+    return PrepareResult(
+        exit_code=0,
+        version_root=target,
+        site_packages=site,
+        version=pointer.version,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry called by ``python -m kohakuterrarium.launcher`` /
+    ``kt-launcher``. Drives :func:`prepare` and ``os.execv``'s into
+    ``-m kohakuterrarium.cli`` against the active version tree.
+
+    Briefcase shells DO NOT use this — see :mod:`kohakuterrarium.__briefcase__`.
+    """
+    result = prepare(argv)
+    if result.done or result.site_packages is None:
+        return result.exit_code
+
+    log = get_logger()
+    forward = sys.argv[1:] if argv is None else list(argv)
+    os.environ["PYTHONPATH"] = _build_pythonpath(result.version_root)
+    os.environ["PYTHONNOUSERSITE"] = "1"
+    os.environ["KT_LAUNCHER_EXEC"] = "1"
+    py = str(sys.executable)
+    log.info("launcher: exec %s -m kohakuterrarium.cli %s", py, forward)
+    os.execv(py, [py, "-m", "kohakuterrarium.cli", *forward])
+    return 0  # unreachable; execv replaces the process
+
+
+def _build_pythonpath(version_root) -> str:
+    """Prepend the version's ``site-packages/`` to any existing PYTHONPATH."""
+    site = str(site_packages_dir(version_root))
+    existing = os.environ.get("PYTHONPATH", "")
+    if not existing:
+        return site
+    return os.pathsep.join([site, existing])
+
+
+def _run_splash_demo(log) -> int:
+    """Demo the splash UI without doing any real install."""
+    log.info("launcher: --splash-demo running scripted sequence")
+    srv = open_splash()
+    try:
+        srv.publish("Starting…", percent=5, message="")
+        time.sleep(0.8)
+        srv.publish("Resolving feed", percent=20, message="stable.json")
+        time.sleep(0.8)
+        srv.publish(
+            "Downloading",
+            percent=55,
+            message="kohakuterrarium-1.5.1-linux-x64-py3.13.tar.zst",
+        )
+        time.sleep(0.8)
+        srv.publish("Smoke testing", percent=85, message="kt --version")
+        time.sleep(0.4)
+        srv.publish("Ready", percent=100, message="", status="ok")
+        time.sleep(1.0)
+    finally:
+        srv.stop()
+    return 0
+
+
+__all__ = ["PrepareResult", "UpdateResult", "main", "prepare"]
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{kohakuterrarium-2.0.0.dev4 → kohakuterrarium-2.0.0.dev5}/src/kohakuterrarium/launcher/paths.py

@@ -128,24 +128,35 @@ def bundled_release_dir() -> Path | None:
     return None
 
 
-# ── Per-version entrypoint paths ────────────────────────────────────
+# ── Per-version layout ──────────────────────────────────────────────
 
 
-def kt_script(version_root: Path) -> Path:
-    """Path to the ``kt`` console-script shim inside a version tree."""
-    if sys.platform == "win32":
-        return version_root / "scripts" / "kt.exe"
-    return version_root / "scripts" / "kt"
+def site_packages_dir(version_root: Path) -> Path:
+    """The flat ``site-packages/`` tree inside a version directory.
+
+    This is the only directory the launcher cares about at exec time —
+    it points ``PYTHONPATH`` at this path and the bundled briefcase
+    Python imports the framework from there. No shim scripts, no
+    per-platform entrypoint trampolines.
+    """
+    return version_root / "site-packages"
+
+
+def manifest_path(version_root: Path) -> Path:
+    """The ``manifest.json`` describing the version (version / abi / sha)."""
+    return version_root / "manifest.json"
 
 
 def python_for(version_root: Path) -> Path:
-    """Path to the python interpreter to run the version with.
+    """The Python interpreter the launcher uses for this version.
 
-    The launcher exec'd via the briefcase-shell-provided python — that
-    interpreter is what runs ``versions/<v>/scripts/kt`` after
-    ``os.execv``. We surface it here so smoke-testing can spawn the
-    SAME interpreter rather than the shell's, keeping ABI consistent.
+    Always ``sys.executable`` — the briefcase-shell-provided Python is
+    the one bundled with this exact site-packages tree (ABI-matched at
+    build time by CI). ``version_root`` is unused but kept in the
+    signature for API symmetry / future-proofing if we ever decide to
+    ship per-version pythons.
     """
+    _ = version_root
     return Path(sys.executable)
 
 
@@ -162,6 +173,7 @@ __all__ = [
     "bundled_release_dir",
     "_candidate_bundled_release_dirs",
     "_has_release_tarball",
-    "kt_script",
+    "site_packages_dir",
+    "manifest_path",
     "python_for",
 ]

{kohakuterrarium-2.0.0.dev4 → kohakuterrarium-2.0.0.dev5}/src/kohakuterrarium/launcher/tree_ops.py

@@ -19,31 +19,30 @@ Atomic ops:
 GC: :func:`gc_old_versions` keeps the active + previous + N most-recent
 on disk; the rest get ``shutil.rmtree``'d.
 
-Smoke test: :func:`smoke_test_tree` spawns ``<dir>/scripts/kt --version``
-under the briefcase-shell python and checks for exit 0. The launcher
-runs this BEFORE the pointer swap so a broken extract never becomes
-the live install.
+Smoke test: :func:`smoke_test_tree` spawns the briefcase-shell python
+with PYTHONPATH pointing at ``<dir>/site-packages`` and asserts that
+``import kohakuterrarium`` succeeds. The launcher runs this BEFORE the
+pointer swap so a broken extract never becomes the live install. No
+shim files involved — there's nothing inside the version tree that
+needs to be invoked as an executable.
 """
 
 import datetime as _dt
 import json
-import os
+import re
 import shutil
-import subprocess
 from dataclasses import dataclass
 from pathlib import Path
 
 from kohakuterrarium.launcher.log import get_logger
 from kohakuterrarium.launcher.paths import (
     active_pointer_path,
-    kt_script,
     python_for,
+    site_packages_dir,
     version_dir,
     versions_dir,
 )
 
-SMOKE_TIMEOUT_SECONDS = 30.0
-
 
 class TreeOpError(RuntimeError):
     """Anything tree-lifecycle related that should surface to UI."""
@@ -201,46 +200,51 @@ def _iso_from_mtime(p: Path) -> str:
 # ── Smoke + swap + rollback ─────────────────────────────────────────
 
 
-def smoke_test_tree(version_root: Path) -> str:
-    """Spawn ``<root>/scripts/kt --version`` and verify exit 0.
+_VERSION_RE = re.compile(
+    r"""^__version__\s*=\s*['"]([^'"]+)['"]""",
+    re.MULTILINE,
+)
+
 
-    Returns the trimmed version string the script printed. Raises
-    :class:`TreeOpError` on missing shim, non-zero exit, timeout.
+def smoke_test_tree(version_root: Path) -> str:
+    """Validate the freshly-extracted version tree by file inspection.
+
+    Returns the framework's ``__version__`` from
+    ``site-packages/kohakuterrarium/__init__.py``. Raises
+    :class:`TreeOpError` when site-packages or kohakuterrarium is
+    missing.
+
+    **Why file inspection instead of an import subprocess.** Briefcase
+    Windows shells ship a ``python313._pth`` with ``import site``
+    disabled, which means ``PYTHONPATH`` doesn't take effect — there's
+    no way to point a subprocess at the version tree's site-packages
+    from outside the process. And ``sys.executable`` on briefcase is
+    the stub exe (``KohakuTerrarium.exe``), which dispatches into the
+    framework's CLI parser rather than acting as a plain Python.
+    Both make subprocess-based smoke impossible on the briefcase
+    target. CI ensures ABI matching at build time; the runtime check
+    that genuinely matters here is "did the extract land structurally"
+    — present-on-disk verification covers that.
+
+    The version string the function returns is informational; the
+    launcher persists it into the active pointer's ``build_id`` slot
+    only when the manifest didn't carry one. Failing to parse it is
+    not a fatal error.
     """
-    kt = kt_script(version_root)
-    if not kt.is_file():
-        raise TreeOpError(f"kt shim missing at {kt}")
+    site = site_packages_dir(version_root)
+    if not site.is_dir():
+        raise TreeOpError(f"site-packages missing at {site}")
+    init = site / "kohakuterrarium" / "__init__.py"
+    if not init.is_file():
+        raise TreeOpError(f"kohakuterrarium package not found at {init}")
     try:
-        out = subprocess.run(
-            [str(kt), "--version"],
-            check=True,
-            capture_output=True,
-            text=True,
-            timeout=SMOKE_TIMEOUT_SECONDS,
-            env=_smoke_env(version_root),
-        )
-    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
-        raise TreeOpError(f"smoke `kt --version` failed: {e}") from e
-    return (out.stdout or "").strip() or "<no-version>"
-
-
-def _smoke_env(version_root: Path) -> dict:
-    """Build the env for the smoke subprocess.
-
-    Points PYTHONPATH at the version's site-packages so the briefcase
-    python finds the framework. Disables user site to keep the smoke
-    deterministic across user machines.
-    """
-    env = os.environ.copy()
-    site = version_root / "site-packages"
-    existing = env.get("PYTHONPATH", "")
-    parts = [str(site)]
-    if existing:
-        parts.append(existing)
-    env["PYTHONPATH"] = os.pathsep.join(parts)
-    env["PYTHONNOUSERSITE"] = "1"
-    env["KT_LAUNCHER_SMOKE"] = "1"
-    return env
+        text = init.read_text(encoding="utf-8")
+    except OSError as e:
+        raise TreeOpError(f"could not read {init}: {e}") from e
+    match = _VERSION_RE.search(text)
+    if match:
+        return match.group(1)
+    return "<no-version>"
 
 
 def gc_old_versions(*, keep: int, always_keep: set[str]) -> list[str]:
@@ -303,7 +307,6 @@ def python_for_active() -> Path:
 
 
 __all__ = [
-    "SMOKE_TIMEOUT_SECONDS",
     "TreeOpError",
     "ActivePointer",
     "read_active_pointer",

kohakuterrarium-2.0.0.dev4/src/kohakuterrarium/__briefcase__.py

@@ -1,17 +0,0 @@
-"""Briefcase desktop bundle entry point.
-
-The Briefcase artifact is a thin wrapper around a managed venv that
-owns the framework install — see ``src/kohakuterrarium/launcher/`` and
-``plans/1.5.0-roadmap/06-app-update/`` for the design.  This module
-delegates to the launcher's ``main`` and intentionally imports nothing
-from the framework itself; the launcher is responsible for creating /
-refreshing the venv and ``exec``-ing the framework's ``kt`` entry once
-the venv is ready.
-"""
-
-import sys
-
-from kohakuterrarium.launcher.bootloader import main
-
-if __name__ == "__main__":
-    sys.exit(main())