wizolt 0.44.0__tar.gz

wizolt-0.44.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, hit9
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

wizolt-0.44.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+recursive-include wizolt/builtin_skills *.md
+prune demo*
+prune tests

wizolt-0.44.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: wizolt
+Version: 0.44.0
+Summary: A terminal coding agent written in Python
+Author-email: hit9 <hit9@icloud.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/hit9/wizolt
+Project-URL: Repository, https://github.com/hit9/wizolt
+Project-URL: Issues, https://github.com/hit9/wizolt/issues
+Project-URL: Documentation, https://wizolt.readthedocs.io
+Keywords: ai,coding-agent,cli,terminal
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development
+Classifier: Topic :: Terminals
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=1.0.0
+Requires-Dist: code-symbol-index>=0.5.1
+Requires-Dist: json-repair
+Requires-Dist: fastmcp-slim[client]<4,>=3
+Requires-Dist: httpx2>=2.12.0
+Requires-Dist: openai>=3.0.0
+Requires-Dist: pathspec>=1.0
+Requires-Dist: pillow>=11.0
+Requires-Dist: prompt-toolkit>=3.0.53
+Requires-Dist: rich>=13.0
+Requires-Dist: socksio>=1.0.0
+Requires-Dist: websockets>=15.0.1
+Provides-Extra: dev
+Requires-Dist: pyright>=1.1.411; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.8; extra == "dev"
+Requires-Dist: ruff==0.16.0; extra == "dev"
+Dynamic: license-file
+
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/docs/_static/wizolt-logo.png" alt="Wizolt logo: a blue hooded terminal mage holding a lightning staff" width="112"><br>
+  wizolt
+</h1>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt1.gif" alt="wizolt editing code and running tools" width="600">
+</p>
+
+<p align="center">
+  A terminal coding agent I use, maintain, and customize, shipped as a self-contained Python package.
+</p>
+
+## Safety
+
+**Use at your own risk.** wizolt can edit files and run shell commands in the environment where it starts. It does not provide sandbox isolation; use a container or VM when needed.
+
+## What it is
+
+wizolt does not introduce a new kind of coding agent. It combines familiar features — reading and editing files, running commands, follow-ups, sessions, diffs, MCP, and skills — into a tool I use personally.
+
+It works on real repositories, including its own: I use wizolt to build and maintain wizolt. Everything ships in one self-contained Python package, so I can change the behavior directly whenever I want the workflow to work differently.
+
+Wizolt is the former minacode, which began as the single-file nanocode. The implementation outgrew both earlier names; the project history remains continuous.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt2.gif" alt="wizolt resuming a saved session" width="600">
+</p>
+<p align="center"><sub>Resuming a saved session with its conversation and tool history.</sub></p>
+
+## Highlights
+
+- **Worker delegation:** hand a bounded task to a second in-process session on its own provider with `/worker`; the `Delegate` tool keeps worker context across delegations until reset.
+- **Forced reply language:** `/language` or `[runtime] language` pins the reply language for the session.
+- **Smarter retries:** exponential backoff with jitter and provider `Retry-After`, shown as a live `retrying` phase with a countdown.
+- **Prompt-cache aware:** stable request prefixes let supported providers reuse work and can reach 90–99% cache hit rates; `/status` shows the reported result.
+- **Code navigation:** jump to definitions, callers, and implementations with a searchable code index.
+- **Live follow-ups:** type while the agent works; `Enter` queues a message for the next model step, while `Ctrl-C` discards a draft or interrupts the task once the input is empty.
+- **Evidence-checked edits:** patch from a numbered source view or exact unique text; stale and ambiguous targets are refused.
+- **Resumable sessions:** conversation, tool calls, diffs, and working memory survive `-c` or `--resume`.
+- **Built-in diff viewer:** `/diff` shows the latest round and the net session result.
+- **MCP and skills:** connect Model Context Protocol servers and load Markdown instruction packs on demand.
+- **Provider-side web search:** opt in to a provider's own search tool (OpenAI, Qwen, Anthropic, Z.AI) and see each search and its sources in the transcript.
+- **Provider compatibility:** OpenAI-compatible APIs and Anthropic.
+
+## Install
+
+Requires macOS or Linux, Python 3.11+, and [uv](https://docs.astral.sh/uv/).
+
+```sh
+uv tool install wizolt
+wizolt --init-config
+```
+
+Add your provider to `~/.wizolt/config.toml`:
+
+```toml
+[provider]
+active = "default"
+
+[provider.default]
+url = "https://api.deepseek.com"
+key = "sk-..."
+model = "deepseek-v4-flash"
+```
+
+Then run:
+
+```sh
+wizolt
+```
+
+Upgrade with `uv tool upgrade wizolt`.
+
+## Links
+
+- [Documentation](https://wizolt.readthedocs.io/en/latest/) — full usage guide and reference.
+- [Blog post](https://hit9.dev/post/nanocode) — why and how it was built.
+- [code-symbol-index](https://github.com/hit9/code-symbol-index) — the code index library wizolt uses.

wizolt-0.44.0/README.md

@@ -0,0 +1,79 @@
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/docs/_static/wizolt-logo.png" alt="Wizolt logo: a blue hooded terminal mage holding a lightning staff" width="112"><br>
+  wizolt
+</h1>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt1.gif" alt="wizolt editing code and running tools" width="600">
+</p>
+
+<p align="center">
+  A terminal coding agent I use, maintain, and customize, shipped as a self-contained Python package.
+</p>
+
+## Safety
+
+**Use at your own risk.** wizolt can edit files and run shell commands in the environment where it starts. It does not provide sandbox isolation; use a container or VM when needed.
+
+## What it is
+
+wizolt does not introduce a new kind of coding agent. It combines familiar features — reading and editing files, running commands, follow-ups, sessions, diffs, MCP, and skills — into a tool I use personally.
+
+It works on real repositories, including its own: I use wizolt to build and maintain wizolt. Everything ships in one self-contained Python package, so I can change the behavior directly whenever I want the workflow to work differently.
+
+Wizolt is the former minacode, which began as the single-file nanocode. The implementation outgrew both earlier names; the project history remains continuous.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt2.gif" alt="wizolt resuming a saved session" width="600">
+</p>
+<p align="center"><sub>Resuming a saved session with its conversation and tool history.</sub></p>
+
+## Highlights
+
+- **Worker delegation:** hand a bounded task to a second in-process session on its own provider with `/worker`; the `Delegate` tool keeps worker context across delegations until reset.
+- **Forced reply language:** `/language` or `[runtime] language` pins the reply language for the session.
+- **Smarter retries:** exponential backoff with jitter and provider `Retry-After`, shown as a live `retrying` phase with a countdown.
+- **Prompt-cache aware:** stable request prefixes let supported providers reuse work and can reach 90–99% cache hit rates; `/status` shows the reported result.
+- **Code navigation:** jump to definitions, callers, and implementations with a searchable code index.
+- **Live follow-ups:** type while the agent works; `Enter` queues a message for the next model step, while `Ctrl-C` discards a draft or interrupts the task once the input is empty.
+- **Evidence-checked edits:** patch from a numbered source view or exact unique text; stale and ambiguous targets are refused.
+- **Resumable sessions:** conversation, tool calls, diffs, and working memory survive `-c` or `--resume`.
+- **Built-in diff viewer:** `/diff` shows the latest round and the net session result.
+- **MCP and skills:** connect Model Context Protocol servers and load Markdown instruction packs on demand.
+- **Provider-side web search:** opt in to a provider's own search tool (OpenAI, Qwen, Anthropic, Z.AI) and see each search and its sources in the transcript.
+- **Provider compatibility:** OpenAI-compatible APIs and Anthropic.
+
+## Install
+
+Requires macOS or Linux, Python 3.11+, and [uv](https://docs.astral.sh/uv/).
+
+```sh
+uv tool install wizolt
+wizolt --init-config
+```
+
+Add your provider to `~/.wizolt/config.toml`:
+
+```toml
+[provider]
+active = "default"
+
+[provider.default]
+url = "https://api.deepseek.com"
+key = "sk-..."
+model = "deepseek-v4-flash"
+```
+
+Then run:
+
+```sh
+wizolt
+```
+
+Upgrade with `uv tool upgrade wizolt`.
+
+## Links
+
+- [Documentation](https://wizolt.readthedocs.io/en/latest/) — full usage guide and reference.
+- [Blog post](https://hit9.dev/post/nanocode) — why and how it was built.
+- [code-symbol-index](https://github.com/hit9/code-symbol-index) — the code index library wizolt uses.

wizolt-0.44.0/pyproject.toml

@@ -0,0 +1,105 @@
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wizolt"
+version = "0.44.0"
+description = "A terminal coding agent written in Python"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+authors = [
+    { name = "hit9", email = "hit9@icloud.com" },
+]
+keywords = ["ai", "coding-agent", "cli", "terminal"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Software Development",
+    "Topic :: Terminals",
+]
+
+dependencies = [
+    # anthropic 1.x and openai 3.x both moved their HTTP client to httpx2, which stops installing
+    # certifi and verifies TLS against the OS trust store instead (SSL_CERT_FILE/SSL_CERT_DIR
+    # override it). The floors pin that migration rather than leaving it to the resolver: an older
+    # pair would land on plain httpx, a combination retryable_error's transport-error matching is
+    # tested against but the rest of the tree no longer is.
+    "anthropic>=1.0.0",
+    "code-symbol-index>=0.5.1",
+    "json-repair",
+    "fastmcp-slim[client]>=3,<4",
+    # Direct, not transitive: the update check imports httpx2 itself. The provider SDKs bring it
+    # in too, but a dependency wizolt imports is wizolt's to declare.
+    "httpx2>=2.12.0",
+    "openai>=3.0.0",
+    "pathspec>=1.0",
+    "pillow>=11.0",
+    # 3.0.53 fixed Application.invalidate() so it is safe to call from any thread; older versions
+    # crash with "no running event loop" when the agent thread asks for a redraw.
+    "prompt-toolkit>=3.0.53",
+    "rich>=13.0",
+    "socksio>=1.0.0",
+    "websockets>=15.0.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/hit9/wizolt"
+Repository = "https://github.com/hit9/wizolt"
+Issues = "https://github.com/hit9/wizolt/issues"
+Documentation = "https://wizolt.readthedocs.io"
+
+[project.scripts]
+wizolt = "wizolt.__main__:main"
+
+[project.optional-dependencies]
+dev = [
+    "pyright>=1.1.411",
+    "pytest>=8.0",
+    "pytest-asyncio>=1.0",
+    "pytest-xdist>=3.8",
+    "ruff==0.16.0",
+]
+
+[tool.setuptools]
+packages = ["wizolt", "wizolt.builtin_skills", "wizolt.cli", "wizolt.model", "wizolt.mcp", "wizolt.providers", "wizolt.session", "wizolt.source", "wizolt.tools", "wizolt.tui"]
+
+[tool.setuptools.package-data]
+wizolt = ["builtin_skills/*/SKILL.md", "providers/catalog.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = ["-n", "auto"]
+# A test that awaits the code under test reads better than the same test wrapped in an
+# asyncio.run() driver, so `async def` tests run without a per-test marker. Each gets its own
+# loop, which is also what the production entry points do.
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 160
+target-version = "py311"
+
+[tool.ruff.lint]
+extend-select = ["F403"]
+per-file-ignores = { "wizolt/__init__.py" = ["F401"] }
+
+[tool.pyright]
+include = ["wizolt"]
+# `uv build` leaves a full copy of the package under build/lib. An editor that analyzes any file in
+# the workspace type-checks that copy as a second definition of every class, so an assignment there
+# reports a mismatch between two same-named types (`ToolRunner* is not assignable to ToolRunner`).
+# `include` alone does not stop it, because the file is analyzed when opened.
+exclude = ["build", "dist", "**/__pycache__", "**/.venv"]
+pythonVersion = "3.11"
+typeCheckingMode = "basic"

wizolt-0.44.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wizolt-0.44.0/wizolt/__init__.py

@@ -0,0 +1,5 @@
+"""A terminal coding agent."""
+
+from wizolt.base import __version__
+
+__all__ = ["__version__"]

wizolt-0.44.0/wizolt/__main__.py

@@ -0,0 +1,228 @@
+"""wizolt entry point: command-line argument parsing and dispatch.
+
+Invoked through the ``wizolt`` console script or ``python -m wizolt``.
+
+Deliberately imports nothing from the wizolt package at module level: argparse, help, version, and
+config initialization should answer before the interactive CLI — prompt_toolkit, the tools, the
+TUI, the session machinery — is imported. The interactive-CLI names `main` needs are reached
+through the lazy `_cli` namespace below: reading `_cli.Session` imports it on first use and caches
+it on this module, so tests can keep substituting fakes here without importing wizolt at module
+load time.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import importlib
+import os
+import subprocess
+import sys
+import threading
+
+# Every interactive-CLI name `main` needs, as (module, attribute). Loaded on first use and cached
+# on this module, so tests can keep substituting fakes here without `import wizolt.__main__`
+# paying for the interactive CLI.
+_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
+    "__version__": ("wizolt.base", "__version__"),
+    "Agent": ("wizolt.engine", "Agent"),
+    "CatalogError": ("wizolt.providers.schema", "CatalogError"),
+    "CatalogRuntime": ("wizolt.providers.sync", "CatalogRuntime"),
+    "CommandLoop": ("wizolt.cli", "CommandLoop"),
+    "Config": ("wizolt.config", "Config"),
+    "ConfigError": ("wizolt.base", "ConfigError"),
+    "ConfigFile": ("wizolt.config", "ConfigFile"),
+    "RuntimeSettings": ("wizolt.config", "RuntimeSettings"),
+    "Session": ("wizolt.session", "Session"),
+    "Theme": ("wizolt.render", "Theme"),
+    "UpdateChecker": ("wizolt.cli.update", "UpdateChecker"),
+    "UpdateStatus": ("wizolt.base", "UpdateStatus"),
+    "WizoltError": ("wizolt.base", "WizoltError"),
+    "configure_logging": ("wizolt.base", "configure_logging"),
+}
+
+
+def _import_lazy(name: str):
+    """Import one interactive-CLI name and cache it on this module (PEP 562)."""
+    spec = _LAZY_IMPORTS[name]
+    value = getattr(importlib.import_module(spec[0]), spec[1])
+    globals()[name] = value
+    return value
+
+
+def __getattr__(name: str):
+    """Import a lazy interactive-CLI name on first attribute read (PEP 562)."""
+    if name not in _LAZY_IMPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    return _import_lazy(name)
+
+
+class _EntryCli:
+    """The entry point's handle on the interactive CLI. Reading an attribute (`_cli.Session`)
+    imports that name on first use and caches it on this module, so later reads are plain
+    attribute lookups; a name a test has already bound here (a fake) is returned as-is. This is
+    the seam that keeps `wizolt.__main__` importable without the interactive CLI while `main`
+    still resolves the real classes through module attributes the way it always has."""
+
+    def __getattr__(self, name: str):
+        bound = globals().get(name)
+        if bound is not None:
+            return bound
+        if name not in _LAZY_IMPORTS:
+            raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+        return _import_lazy(name)
+
+
+_cli = _EntryCli()
+
+
+def run_update() -> int:
+    """Check PyPI for a newer wizolt and upgrade it via the detected package manager."""
+    print(f"wizolt {_cli.__version__}")
+    try:
+        latest = _cli.UpdateChecker.fetch_latest_sync()
+    except Exception as error:  # noqa: BLE001 - update failures from any network/backend layer are reported uniformly.
+        print(f"Error: could not check the latest version: {error}", file=sys.stderr)
+        return 1
+    if not _cli.UpdateStatus(latest=latest).newer_than(_cli.__version__):
+        print(f"already up to date ({_cli.__version__})")
+        return 0
+    command = _cli.UpdateChecker.upgrade_command()
+    print(f"updating {_cli.__version__} -> {latest}: {' '.join(command)}")
+    try:
+        return subprocess.call(command)
+    except OSError as error:
+        print(f"Error: could not run the upgrade command: {error}", file=sys.stderr)
+        return 1
+
+
+def warm_provider_sdks() -> None:
+    """Import the provider SDKs off the main thread so the prompt accepts input immediately.
+
+    ModelClient imports them lazily because they cost ~0.8s, which was the whole of the delay
+    before a fresh prompt echoed keystrokes. Loading them here in the background keeps the prompt
+    instant without moving that cost onto the first request: the user's first message takes far
+    longer to type than the import takes to finish.
+
+    Racing this thread against the request path is safe, and deliberately so:
+
+    - CPython locks imports per module (`importlib._bootstrap._ModuleLock`), so a request-path
+      `from openai import OpenAI` that lands mid-warm-up blocks on that module's lock and then
+      reads the finished module from `sys.modules`. It cannot observe a half-initialized module,
+      and both threads therefore bind the same class object.
+    - Per-module locks can deadlock only on an import cycle entered from two threads at once.
+      `anthropic` and `openai` do not import each other, and their shared dependencies form a DAG,
+      so the lock-wait graph has no cycle. `_DeadlockError` detection is the backstop if that ever
+      stops being true.
+    - The thread is a daemon because warming must never delay exit. CPython freezes daemon threads
+      at finalization rather than letting them run against a torn-down import system, so quitting
+      mid-import is silent.
+
+    Verified by stress test: a barrier-synchronized four-way race and repeated immediate-exit runs
+    produce no deadlock, no exception, and no stderr noise.
+    """
+
+    def load() -> None:
+        # Warming is only an optimization, and an uncaught failure here would print a thread
+        # traceback over the live prompt. Any real problem resurfaces on the request path, which
+        # imports the same modules and reports the failure to the user.
+        with contextlib.suppress(Exception):
+            import anthropic  # noqa: F401 - imported for its side effect of populating sys.modules
+            import openai  # noqa: F401
+
+    threading.Thread(target=load, name="sdk-warmup", daemon=True).start()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="wizolt", epilog="Documentation: https://wizolt.readthedocs.io")
+    parser.add_argument("--config", default=None, help="Path to config TOML")
+    parser.add_argument("--init-config", action="store_true", help="Create a default config file")
+    parser.add_argument("--yolo", action="store_true", help="Skip confirmations for mutating tools")
+    parser.add_argument(
+        "--theme", choices=["auto", "light", "dark"], default="", help="Color theme (defaults to runtime.theme, then auto-detect via COLORFGBG)"
+    )
+    resume = parser.add_mutually_exclusive_group()
+    resume.add_argument(
+        "--resume",
+        default="",
+        nargs="?",
+        const="latest",
+        help='Resume a session by UID, uid prefix, or name, or "latest"/"last" for this project\'s most recent',
+    )
+    resume.add_argument("-c", "--last", "--latest", dest="continue_project", action="store_true", help="Resume the latest session in the current project")
+    parser.add_argument("-v", "--version", action="store_true", help="Show version")
+    parser.add_argument(
+        "command", nargs="?", choices=["update", "upgrade"], default=None, help="Maintenance command: update/upgrade wizolt to the latest version"
+    )
+    args = parser.parse_args(argv)
+    if sys.platform == "win32":
+        print("Error: wizolt does not support native Windows; use WSL instead.", file=sys.stderr)
+        return 1
+    # Cheap exits answer before the interactive CLI is loaded. The explicit update
+    # command loads its HTTP/update implementation here, but still never starts a session.
+    if args.version:
+        print(_cli.__version__)
+        return 0
+    if args.command in {"update", "upgrade"}:
+        return run_update()
+    if args.init_config:
+        path, created = _cli.ConfigFile.init(args.config)
+        print(("Created" if created else "Exists") + " config: " + path)
+        return 0
+
+    # This line needs only the lightweight version module. Put it on screen before importing the
+    # session and rendering stacks; the first CommandLoop consumes the handoff, while a session
+    # selected later through /resume prints its own banner normally.
+    banner_preprinted = sys.stdin.isatty() and sys.stdout.isatty()
+    preprinted_output = ""
+    if banner_preprinted:
+        preprinted_output = f"wizolt {_cli.__version__}. /help for commands.\n\n"
+        print(preprinted_output, end="", flush=True)
+
+    _cli.configure_logging()
+    try:
+        # Switching sessions ends one run and starts the next rather than re-pointing a live
+        # object graph at another Session: everything below is built around one, and this is the
+        # only moment nothing is running. Teardown stays in the `finally` that already does it.
+        resume = args.resume or ("latest" if args.continue_project else "")
+        while True:
+            if resume:
+                data = _cli.ConfigFile.load(args.config)
+                catalog = _cli.CatalogRuntime(_cli.Config.data_dir_from(data))
+                config = _cli.Config.from_dict(data, policy=catalog.policy)
+                session = _cli.Session.load_snapshot(
+                    resume,
+                    config=config,
+                    settings=_cli.RuntimeSettings.from_dict(data, yolo=args.yolo, theme=args.theme),
+                    cwd=os.getcwd(),
+                    catalog=catalog,
+                )
+            else:
+                session = _cli.Session.from_config_file(path=args.config, yolo=args.yolo, theme=args.theme)
+            _cli.Theme.set_mode(_cli.Theme.resolve(session.settings.theme))
+            warm_provider_sdks()
+            command_loop = _cli.CommandLoop(_cli.Agent(session))
+            try:
+                if banner_preprinted:
+                    command_loop.preprinted_output = preprinted_output
+                    code = command_loop.run(show_banner=False)
+                    banner_preprinted = False
+                else:
+                    code = command_loop.run()
+            finally:
+                # The runtime closes what the session opened, on the loop that opened it; all that
+                # is left here is the terminal-output gate, in case the runtime never got that far.
+                command_loop.close_background_output()
+            resume = command_loop.resume_request
+            if not resume:
+                return code
+    except _cli.ConfigError as error:
+        print("ConfigError: " + str(error), file=sys.stderr)
+        return 2
+    except (_cli.WizoltError, _cli.CatalogError) as error:
+        print("Error: " + str(error), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())