cecli-dev 1.6.2rc6__tar.gz → 1.7.0__tar.gz

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.6.2rc6
+Version: 1.7.0
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.6.2rc6'
-__version_tuple__ = version_tuple = (1, 6, 2, 'rc6')
+__version__ = version = '1.7.0'
+__version_tuple__ = version_tuple = (1, 7, 0)
 
-__commit_id__ = commit_id = 'g98f3e7e7c'
+__commit_id__ = commit_id = 'g7157616ab'

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/args.py

@@ -61,6 +61,7 @@ DEEP_MERGE_JSON_FIELDS: frozenset[str] = frozenset(
         "security_config",
         "retries",
         "custom",
+        "system_one",
         "tui_config",
     }
 )
@@ -360,7 +361,7 @@ def get_parser(default_config_files, git_root):
         metavar="RETRIES_JSON",
         help=(
             'Specify LLM retry configuration as a JSON/YAML string (e.g., \'{"retry_on_empty": '
-            "true}')"
+            'true, "retry-on-unauthorized": false}\')'
         ),
         default=None,
     )
@@ -427,6 +428,16 @@ def get_parser(default_config_files, git_root):
         help="Specify hooks configuration as a JSON string",
         default=None,
     )
+    group.add_argument(
+        "--system-one",
+        metavar="SYSTEM_ONE_JSON",
+        help=(
+            "Specify the System One decision endpoint as a JSON/YAML string (e.g.,"
+            ' \'{"api_base": "http://127.0.0.1:8000", "api_key_env": ["SYSTEM_ONE_API_KEY"],'
+            ' "model_name": "von-latest"}\')'
+        ),
+        default=None,
+    )
     group.add_argument(
         "--agent-model",
         metavar="AGENT_MODEL",

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/args_formatter.py

@@ -138,6 +138,7 @@ class YamlHelpFormatter(argparse.HelpFormatter):
             parts.append("#  retry-timeout: 60")
             parts.append("#  retry-backoff-factor: 2.0")
             parts.append("#  retry-on-unavailable: true")
+            parts.append("#  retry-on-unauthorized: false")
             parts.append("#  retry-on-empty: false")
             parts.append("")
             return "\n".join(parts)

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/coders/base_coder.py

@@ -66,7 +66,7 @@ from cecli.report import update_error_prefix
 from cecli.run_cmd import run_cmd_async
 from cecli.tools.utils.output import print_tool_response
 from cecli.tools.utils.registry import ToolRegistry
-from cecli.utils import copy_tool_call, format_tokens, is_image_file
+from cecli.utils import copy_tool_call, format_tokens, is_image_file, safe_relpath
 
 from ..dump import dump  # noqa: F401
 from ..prompts.utils.registry import PromptObject, PromptRegistry
@@ -2857,9 +2857,7 @@ class Coder(metaclass=UsageMeta):
 
                     retry_config = models.parse_retry_config(self.get_active_model().retries)
 
-                    should_retry = ex_info.retry
-                    if ex_info.name == "ServiceUnavailableError":
-                        should_retry = should_retry or retry_config["retry_on_unavailable"]
+                    should_retry, _ = models.parse_model_error(retry_config, err)
 
                     if should_retry:
                         retry_delay *= retry_config["retry_backoff_factor"]
@@ -4877,7 +4875,7 @@ class Coder(metaclass=UsageMeta):
             return
 
         if not Path(full_path).exists():
-            rel_path = os.path.relpath(full_path)
+            rel_path = safe_relpath(full_path)
             if not await self.io.confirm_ask(f"Create new file? ({rel_path})", subject=path):
                 self.io.tool_output(f"Skipping edits to {path}")
                 return

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/commands/add.py

@@ -10,7 +10,7 @@ from cecli.commands.utils.helpers import (
     parse_quoted_filenames,
     quote_filename,
 )
-from cecli.utils import is_image_file, run_fzf
+from cecli.utils import is_image_file, run_fzf, safe_relpath
 
 
 class AddCommand(BaseCommand):
@@ -67,7 +67,7 @@ class AddCommand(BaseCommand):
                 io.tool_output(f"You can add to git with: /git add {fname}")
                 continue
 
-            confirm_fname = os.path.relpath(fname)
+            confirm_fname = safe_relpath(fname)
             if len(confirm_fname) > 64:
                 confirm_fname = f".../{os.path.basename(confirm_fname)}"
 

cecli_dev-1.7.0/cecli/commands/paste.py

@@ -0,0 +1,206 @@
+import base64
+import os
+import shutil
+import subprocess
+import tempfile
+from io import BytesIO
+from pathlib import Path
+from typing import List
+
+import pyperclip
+from PIL import Image, ImageGrab
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class PasteCommand(BaseCommand):
+    NORM_NAME = "paste"
+    DESCRIPTION = (
+        "Paste image/text from the clipboard into the chat. Optionally provide a name for the"
+        " image."
+    )
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        try:
+            image = cls._grab_clipboard_image(io)
+
+            if not isinstance(image, Image.Image):
+                # Fall back to text when there is no image
+                text = cls._read_clipboard_text(io)
+                if text:
+                    if coder.tui and coder.tui():
+                        coder.tui().set_input_value(text)
+                    else:
+                        coder.io.set_placeholder(text)
+
+                    return format_command_result(io, "paste", "Pasted text from clipboard")
+
+                # On WSL the clipboard is owned by Windows and images are not always
+                # bridged to X11/Wayland, so probe the Windows clipboard directly.
+                if cls._is_wsl():
+                    image = cls._grab_clipboard_image_windows(io)
+
+            if isinstance(image, Image.Image):
+                if args.strip():
+                    filename = args.strip()
+                    ext = os.path.splitext(filename)[1].lower()
+                    if ext in (".jpg", ".jpeg", ".png"):
+                        basename = filename
+                    else:
+                        basename = f"{filename}.png"
+                else:
+                    basename = "clipboard_image.png"
+
+                temp_dir = tempfile.mkdtemp()
+                temp_file_path = os.path.join(temp_dir, basename)
+                image_format = "PNG" if basename.lower().endswith(".png") else "JPEG"
+                if image_format == "JPEG" and image.mode not in ("RGB", "L", "CMYK"):
+                    image = image.convert("RGB")
+
+                image.save(temp_file_path, image_format)
+
+                abs_file_path = Path(temp_file_path).resolve()
+
+                # Check if a file with the same name already exists in the chat
+                existing_file = next(
+                    (f for f in coder.abs_fnames if Path(f).name == abs_file_path.name), None
+                )
+                if existing_file:
+                    coder.abs_fnames.remove(existing_file)
+                    io.tool_output(f"Replaced existing image in the chat: {existing_file}")
+
+                coder.abs_fnames.add(str(abs_file_path))
+                io.tool_output(f"Added clipboard image to the chat: {abs_file_path}")
+                coder.check_added_files()
+
+                return format_command_result(io, "paste", f"Added clipboard image: {abs_file_path}")
+
+            io.tool_error("No image or text content found in clipboard.")
+            return format_command_result(
+                io, "paste", "No content found in clipboard", Exception("No content")
+            )
+
+        except Exception as e:
+            io.tool_error(f"Error processing clipboard content: {e}")
+            return format_command_result(io, "paste", f"Error: {str(e)}", e)
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for paste command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the paste command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /paste                    # Paste image or text from clipboard\n"
+        help_text += "  /paste image.png          # Paste image with specific filename\n"
+        help_text += (
+            "\nNote: This command pastes content from your system clipboard into the chat.\n"
+        )
+        help_text += (
+            "If an image is in the clipboard, it will be saved as a file and added to the chat.\n"
+        )
+        help_text += "If text is in the clipboard, it will be displayed in the chat.\n"
+        return help_text
+
+    @classmethod
+    def _grab_clipboard_image(cls, io):
+        """Return an image from the clipboard, or None if it cannot be read."""
+        try:
+            return ImageGrab.grabclipboard()
+        except Exception as e:
+            # WAYLAND_DISPLAY can be set with no live compositor (e.g. WSLg or a
+            # stale SSH env), which makes the Wayland probe fail even though the
+            # bridged X11 clipboard works. Retry once over X11.
+            if os.environ.get("WAYLAND_DISPLAY"):
+                cls._log_clipboard_error(io, f"Wayland image probe failed: {e}")
+                return cls._grab_clipboard_image_x11(io)
+
+            # The image probe can fail even when the text clipboard works, so keep
+            # it quiet unless the user asked for detail.
+            cls._log_clipboard_error(io, f"Clipboard image read failed: {e}")
+            return None
+
+    @classmethod
+    def _grab_clipboard_image_x11(cls, io):
+        """Retry the image probe with the Wayland display disabled."""
+        wayland_display = os.environ.pop("WAYLAND_DISPLAY", None)
+        try:
+            return ImageGrab.grabclipboard()
+        except Exception as e:
+            cls._log_clipboard_error(io, f"Clipboard image read failed over X11: {e}")
+            return None
+        finally:
+            if wayland_display is not None:
+                os.environ["WAYLAND_DISPLAY"] = wayland_display
+
+    @classmethod
+    def _grab_clipboard_image_windows(cls, io):
+        """Read an image from the Windows clipboard via PowerShell (WSL only)."""
+        powershell = shutil.which("powershell.exe")
+        if not powershell:
+            return None
+
+        script = (
+            "Add-Type -AssemblyName System.Windows.Forms,System.Drawing\n"
+            "$img = [System.Windows.Forms.Clipboard]::GetImage()\n"
+            "if ($img -eq $null) { exit 1 }\n"
+            "$ms = New-Object System.IO.MemoryStream\n"
+            "$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)\n"
+            "[Convert]::ToBase64String($ms.ToArray())\n"
+        )
+        try:
+            result = subprocess.run(
+                [powershell, "-NoProfile", "-STA", "-Command", script],
+                capture_output=True,
+                timeout=30,
+            )
+        except Exception as e:
+            cls._log_clipboard_error(io, f"Windows clipboard image read failed: {e}")
+            return None
+
+        if result.returncode != 0 or not result.stdout.strip():
+            detail = result.stderr.decode("utf-8", "replace").strip()
+            cls._log_clipboard_error(io, f"Windows clipboard image read failed: {detail}")
+            return None
+
+        try:
+            image = Image.open(BytesIO(base64.b64decode(result.stdout)))
+            image.load()
+            return image
+        except Exception as e:
+            cls._log_clipboard_error(io, f"Windows clipboard image decode failed: {e}")
+            return None
+
+    @classmethod
+    def _is_wsl(cls):
+        """Detect whether the process is running inside WSL."""
+        if os.environ.get("WSL_DISTRO_NAME") or os.environ.get("WSL_INTEROP"):
+            return True
+
+        try:
+            with open("/proc/version", "r", encoding="utf-8", errors="ignore") as f:
+                return "microsoft" in f.read().lower()
+        except OSError:
+            return False
+
+    @classmethod
+    def _read_clipboard_text(cls, io):
+        """Return clipboard text, or an empty string if it is empty/unavailable."""
+        try:
+            return pyperclip.paste() or ""
+        except Exception as e:
+            # pyperclip's WSL backend raises on an empty Windows clipboard
+            # (GetBytes(null)), which is not an error worth surfacing.
+            cls._log_clipboard_error(io, f"Clipboard text read failed: {e}")
+            return ""
+
+    @classmethod
+    def _log_clipboard_error(cls, io, message):
+        """Surface clipboard probe errors only in verbose mode."""
+        if getattr(io, "verbose", False):
+            io.tool_error(message)

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/helpers/config_utils.py

@@ -226,11 +226,22 @@ def read_and_merge_all_configs(
     return merged
 
 
+def _safe_deepcopy(val, memo=None):
+    try:
+        return copy.deepcopy(val, memo)
+    except (TypeError, copy.Error):
+        if isinstance(val, dict):
+            return {k: _safe_deepcopy(v, memo) for k, v in val.items()}
+        elif isinstance(val, list):
+            return [_safe_deepcopy(item, memo) for item in val]
+        return val
+
+
 def deep_merge(dict1: dict, dict2: dict, deep_merge_arrays: bool = True) -> dict:
     """
     Recursively merges dict2 into dict1.
     """
-    merged = copy.deepcopy(dict1)
+    merged = _safe_deepcopy(dict1)
 
     for key, value in dict2.items():
         if deep_merge_arrays and value is None:
@@ -248,7 +259,7 @@ def deep_merge(dict1: dict, dict2: dict, deep_merge_arrays: bool = True) -> dict
             merged[key] = _deduplicate_list(merged[key], value)
 
         else:
-            merged[key] = copy.deepcopy(value)
+            merged[key] = _safe_deepcopy(value)
 
     return merged
 

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/helpers/llms/domains/chat.py

@@ -139,7 +139,7 @@ async def chat_complete(
     else:
         post_kwargs["json"] = payload
 
-    async with make_client(timeout=DEFAULT_TIMEOUT, verify=VERIFY_SSL) as client:
+    async with make_client(timeout=_request_timeout(kwargs), verify=VERIFY_SSL) as client:
         resp = await client.post(url, headers=hdrs, params=params, **post_kwargs)
         resp.raise_for_status()
         data = resp.json()
@@ -191,7 +191,7 @@ async def chat_stream(
     else:
         stream_kwargs["json"] = payload
 
-    async with make_client(timeout=DEFAULT_TIMEOUT, verify=VERIFY_SSL) as client:
+    async with make_client(timeout=_request_timeout(kwargs), verify=VERIFY_SSL) as client:
         async with client.stream("POST", url, headers=hdrs, params=params, **stream_kwargs) as resp:
             resp.raise_for_status()
             last_finish_reason = None
@@ -443,6 +443,19 @@ def _openai_env_override() -> Optional[Tuple[str, Optional[str]]]:
     return (raw.strip().rstrip("/"), os.environ.get("OPENAI_API_KEY") or None)
 
 
+def _request_timeout(kwargs: Dict[str, Any]) -> float:
+    """Client timeout in seconds: the configured/request timeout, else the default.
+
+    The higher-level request kwargs carry ``timeout`` (issue #703); honoring it
+    here keeps long non-streaming responses from being cut off at
+    :data:`DEFAULT_TIMEOUT`.
+    """
+    try:
+        return float(kwargs.get("timeout") or DEFAULT_TIMEOUT)
+    except (TypeError, ValueError):
+        return DEFAULT_TIMEOUT
+
+
 __all__ = [
     "chat_payload",
     "chat_complete",

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/helpers/llms/litellm_compat.py

@@ -402,6 +402,16 @@ class _FacadeException(Exception):
         for k, v in kwargs.items():
             setattr(self, k, v)
 
+    def __str__(self) -> str:
+        s = super().__str__()
+        if s:
+            return s
+        cause = getattr(self, "__cause__", None)
+        if cause is not None:
+            cause_str = str(cause) or repr(cause)
+            return f"{self.__class__.__name__}: {cause_str}"
+        return self.__class__.__name__
+
 
 class APIConnectionError(_FacadeException):
     pass
@@ -509,7 +519,7 @@ def _translate_http_error(err: httpx.HTTPStatusError) -> _FacadeException:
     except Exception:
         text = ""
     body = text.lower()
-    message = text or str(err)
+    message = text or str(err) or repr(err)
 
     if status == 400 and any(
         token in body for token in ("context", "context_length", "maximum context")
@@ -874,11 +884,11 @@ class _LiteLLMFacade:
                 **passthrough,
             )
         except httpx.TimeoutException as err:
-            raise Timeout(str(err)) from err
+            raise Timeout(str(err) or repr(err)) from err
         except httpx.HTTPStatusError as err:
             raise _translate_http_error(err) from err
         except httpx.HTTPError as err:
-            raise APIConnectionError(str(err)) from err
+            raise APIConnectionError(str(err) or repr(err)) from err
 
         return _response_shim(resp, model)
 
@@ -892,11 +902,11 @@ class _LiteLLMFacade:
             async for chunk in gen:
                 yield _chunk_shim(chunk, model)
         except httpx.TimeoutException as err:
-            raise Timeout(str(err)) from err
+            raise Timeout(str(err) or repr(err)) from err
         except httpx.HTTPStatusError as err:
             raise _translate_http_error(err) from err
         except httpx.HTTPError as err:
-            raise APIConnectionError(str(err)) from err
+            raise APIConnectionError(str(err) or repr(err)) from err
 
     def stream_chunk_builder(
         self, chunks: List[Any], messages: Optional[Any] = None, **kwargs: Any

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/helpers/sessions/manager.py

@@ -248,19 +248,30 @@ class SessionManager:
                 self.io.tool_warning(f"Could not restore sub-agent from {sub_file}: {e}")
 
     async def _reload_sub_agent(self, service, sub_file: Path) -> None:
-        """Spawn and restore a single sub-agent from its saved payload."""
+        """Spawn and restore a single sub-agent from its saved payload.
+
+        Only sub-agents that were still relevant when the session was saved are
+        rebuilt: independent agents are always restored, while a dependent agent
+        is restored only if it had not finished or errored. The transient
+        ``memorizer`` helper is never restored.
+        """
         sub_data = self._read_session_payload(sub_file, quiet=True)
         if not isinstance(sub_data, dict):
             return
 
+        if not subagents.should_restore_sub_agent(sub_data):
+            return
+
         name = subagents.resolve_reload_agent_name(
             sub_data.get("agent_name") or "worker", sub_data.get("agent_root")
         )
         if not name:
             return
 
+        independent = bool(sub_data.get("independent", True))
+
         new_coder, _info = await service.spawn(
-            name, parent=self.coder, auto_reap=False, independent=True
+            name, parent=self.coder, auto_reap=False, independent=independent
         )
 
         sub_manager = SessionManager(new_coder, self.io)

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/helpers/sessions/payload.py

@@ -14,8 +14,19 @@ def build_payload(coder, io, session_name: str, agent_name: Optional[str] = None
 
     ``agent_name`` is the sub-agent type when saving a sub-agent and ``None``
     for the primary agent. Workspace agents (``ws:*``) also record their root so
-    a later load can rebuild them at the right path.
+    a later load can rebuild them at the right path. Sub-agent payloads also
+    record their independence and lifecycle status so a reload can decide
+    whether they should be rebuilt.
     """
+    # Sub-agent lifecycle flags come from the AgentService; the primary agent
+    # has none and stores ``None`` for both.
+    if agent_name:
+        from .subagents import sub_agent_state
+
+        independent, status = sub_agent_state(coder)
+    else:
+        independent, status = None, None
+
     editable_files = [coder.get_rel_fname(abs_fname) for abs_fname in coder.abs_fnames]
     read_only_files = [coder.get_rel_fname(abs_fname) for abs_fname in coder.abs_read_only_fnames]
     read_only_stubs_files = [
@@ -25,11 +36,13 @@ def build_payload(coder, io, session_name: str, agent_name: Optional[str] = None
     # Flush any queued messages so the saved chat history is complete
     ConversationService.get_manager(coder).flush_queue()
 
-    return {
+    payload = {
         "version": 1,
         "session_name": session_name,
         "agent_name": agent_name,
         "agent_root": str(coder.root) if agent_name and agent_name.startswith("ws:") else None,
+        "independent": independent,
+        "status": status,
         "model": coder.main_model.name,
         "weak_model": coder.main_model.weak_model.name,
         "editor_model": coder.main_model.editor_model.name,
@@ -66,6 +79,8 @@ def build_payload(coder, io, session_name: str, agent_name: Optional[str] = None
         },
     }
 
+    return payload
+
 
 async def apply_payload(
     coder, io, session_data: Dict, session_file, sub_agent: bool = False

{cecli_dev-1.6.2rc6 → cecli_dev-1.7.0}/cecli/helpers/sessions/subagents.py

@@ -12,6 +12,10 @@ from .storage import write_payload
 
 logger = logging.getLogger(__name__)
 
+# The memorizer is a transient helper that is re-spawned on demand; a saved
+# session must never try to resurrect it.
+MEMORIZER_AGENT_NAME = "memorizer"
+
 
 def detect_agent_name(coder) -> Optional[str]:
     """Return a coder's sub-agent type, or ``None`` for the primary agent."""
@@ -64,6 +68,33 @@ def live_sub_agents(coder) -> List[Tuple[str, object]]:
     return agents
 
 
+def sub_agent_state(coder) -> Tuple[bool, Optional[str]]:
+    """Return ``(independent, status)`` for a tracked sub-agent coder.
+
+    Falls back to ``(False, None)`` when the coder is not (or no longer) tracked
+    by the :class:`AgentService`, so payload building stays safe for callers with
+    no live service.
+    """
+    from cecli.helpers.agents.service import AgentService
+
+    coder_uuid = getattr(coder, "uuid", None)
+    if not isinstance(coder_uuid, str) or not coder_uuid:
+        return False, None
+
+    try:
+        service = AgentService.get_instance(coder)
+    except Exception:
+        return False, None
+
+    info = service.sub_agents.get(coder_uuid)
+    if info is None:
+        return False, None
+
+    status = getattr(getattr(info, "status", None), "value", None)
+
+    return bool(getattr(info, "independent", False)), status
+
+
 def save_sub_agents(coder, io, session_name: str, subs_dir: Path) -> int:
     """Write each descendant sub-agent payload into ``subs_dir/{child}/agent.json``.
 
@@ -83,6 +114,27 @@ def save_sub_agents(coder, io, session_name: str, subs_dir: Path) -> int:
     return written
 
 
+def should_restore_sub_agent(sub_data: Dict) -> bool:
+    """Return whether a saved sub-agent payload should be rebuilt on load.
+
+    Independent agents are always restored regardless of how they finished. A
+    dependent agent is restored only while it is still unfinished and unerrored.
+    The transient ``memorizer`` helper is never restored.
+    """
+    from cecli.helpers.agents.service import SubAgentStatus
+
+    agent_name = sub_data.get("agent_name")
+    if not agent_name or agent_name == MEMORIZER_AGENT_NAME:
+        return False
+
+    if sub_data.get("independent", True):
+        return True
+
+    status = sub_data.get("status")
+
+    return status not in (SubAgentStatus.FINISHED.value, SubAgentStatus.ERROR.value)
+
+
 def resolve_reload_agent_name(name: str, root: Optional[str]) -> Optional[str]:
     """Resolve a stored agent type to a registered name, falling back to ``worker``."""
     from cecli.helpers.agents.service import AgentService

cecli_dev-1.7.0/cecli/helpers/system_one/__init__.py

@@ -0,0 +1,86 @@
+"""System One decision endpoints, speaking the ``/v1/systemone`` wire format.
+
+Three layers live here, from the wire up:
+
+- :mod:`cecli.helpers.system_one.types` - the question/answer vocabulary
+  (``noul`` / ``choice`` / ``score``) and the parsing of response bodies.
+- :mod:`cecli.helpers.system_one.api` - one call per decision (:func:`decide`,
+  :func:`judge`, :func:`rate`) plus :func:`system_one` / :func:`ask` for
+  several questions over one state.
+- :mod:`cecli.helpers.system_one.integrations` - the shorthand forms other cecli
+  subsystems (hooks today) use, so their call sites stay one-liners.
+
+Endpoint settings come from ``--system-one`` (or the ``system-one`` config-file
+key), installed with :func:`configure`, or from ``SYSTEM_ONE_*`` defaults.
+"""
+
+from cecli.helpers.system_one.api import (
+    DECIDE_QUESTION_ID,
+    JUDGE_QUESTION_ID,
+    RATE_QUESTION_ID,
+    ask,
+    decide,
+    judge,
+    rate,
+    system_one,
+)
+from cecli.helpers.system_one.client import SystemOneClient, SystemOneError
+from cecli.helpers.system_one.config import (
+    DEFAULT_API_BASE,
+    ENDPOINT_PATH,
+    SystemOneConfig,
+    configure,
+    get_config,
+    is_configured,
+    reset,
+)
+from cecli.helpers.system_one.types import (
+    CHOICE,
+    NOUL,
+    QUESTION_TYPES,
+    SCORE,
+    ChoiceAnswer,
+    NoulAnswer,
+    ScoreAnswer,
+    SystemOneResponse,
+    build_payload,
+    choice,
+    noul,
+    parse_answer,
+    parse_response,
+    score,
+)
+
+__all__ = [
+    "CHOICE",
+    "DEFAULT_API_BASE",
+    "DECIDE_QUESTION_ID",
+    "JUDGE_QUESTION_ID",
+    "RATE_QUESTION_ID",
+    "ENDPOINT_PATH",
+    "NOUL",
+    "QUESTION_TYPES",
+    "SCORE",
+    "ChoiceAnswer",
+    "NoulAnswer",
+    "ScoreAnswer",
+    "SystemOneClient",
+    "SystemOneConfig",
+    "SystemOneError",
+    "SystemOneResponse",
+    "ask",
+    "build_payload",
+    "choice",
+    "configure",
+    "decide",
+    "get_config",
+    "is_configured",
+    "judge",
+    "noul",
+    "parse_answer",
+    "parse_response",
+    "rate",
+    "reset",
+    "score",
+    "system_one",
+]