zettcode 0.1.7__tar.gz → 0.1.8__tar.gz

{zettcode-0.1.7 → zettcode-0.1.8}/.gitignore

@@ -20,3 +20,8 @@ node_modules/
 docs/.vitepress/dist/
 docs/.vitepress/cache/
 docs/.vitepress/.temp/
+
+# The palette gallery is generated by `make palettes`: every widget painted in
+# every palette, written by docs/scripts/palette_gallery.py. Regenerate it
+# rather than committing a 2 MB copy that goes stale the moment a colour moves.
+docs/internal/palettes.html

{zettcode-0.1.7 → zettcode-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode
-Version: 0.1.7
+Version: 0.1.8
 Summary: A focused terminal coding agent powered by zett-agent
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Project-URL: Issues, https://github.com/Chang-LeHung/zettcode/issues
@@ -32,7 +32,7 @@ Requires-Dist: truststore<1,>=0.10
 Requires-Dist: uvicorn<1,>=0.35
 Requires-Dist: wcwidth<1,>=0.2
 Requires-Dist: websockets<17,>=15
-Requires-Dist: zett-agent<0.2,>=0.1.15
+Requires-Dist: zett-agent<0.2,>=0.1.17
 Description-Content-Type: text/markdown
 
 <p align="center">

{zettcode-0.1.7 → zettcode-0.1.8}/pyproject.toml

@@ -53,7 +53,7 @@ dependencies = [
   # than it did. An exact pin would make zettcode fight every other tool that
   # shares the dependency — including an upgrade of zett-agent itself, which pip
   # would downgrade to satisfy it.
-  "zett-agent>=0.1.15,<0.2",
+  "zett-agent>=0.1.17,<0.2",
 ]
 
 [project.scripts]

{zettcode-0.1.7 → zettcode-0.1.8}/src/zettcode/__init__.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 #: The one place the version is written. ``pyproject.toml`` reads it from here
 #: and the release workflow checks the tag against it, so a bump is one edit.
-__version__ = "0.1.7"
+__version__ = "0.1.8"
 
 #: Where each public name lives; read by :func:`__getattr__` on first use.
 _EXPORTS = {

{zettcode-0.1.7 → zettcode-0.1.8}/src/zettcode/app/agent/agent/__init__.py

@@ -22,7 +22,8 @@ is the composition and the lifecycle — building the runtime, and closing it.
 
 from __future__ import annotations
 
-from ....config import ZettCodeConfig
+from zettcode.config import ZettCodeConfig
+
 from ..runtime import ZettCodeRuntime
 from .commands import CommandsMixin
 from .context import ContextMixin

zettcode-0.1.8/src/zettcode/app/agent/agent/commands.py

@@ -0,0 +1,214 @@
+"""What the agent offers the shell to run and to show: its own commands, and what plugins added.
+
+The commands report through transcript Markdown; commands that present a widget belong to
+the shell, which owns the widgets. The plugin contributions are listed here because the
+agent is where the shell asks for everything the runtime loaded.
+"""
+
+from __future__ import annotations
+
+from zettcode.app.commands import Command, CommandContext, CommandHost, CommandResult
+from zettcode.app.pets import PetCatalog, bundled_pets
+from zettcode.plugins import UiRow
+from zettcode.plugins.services import HOST_LINK, HostLink
+from zettcode.providers import BUILTIN_PROVIDERS, Provider, merge_providers
+from zettcode.statusline import NAMES, unknown
+from zettcode.tui import ThemeCatalog
+
+from ..conversation.presenters import Presenters
+from ..dialogue.mentions import MentionProvider
+from .exports import ExportsMixin
+
+#: The words ``/self-compact`` takes after it, or after ``global``.
+_SELF_COMPACT_WORDS = frozenset({"on", "off", "default"})
+
+
+class CommandsMixin(ExportsMixin):
+    """The ``/new``, ``/compact``, and ``/export`` commands, and the plugins' commands, mentions, and rows."""
+
+    @property
+    def commands(self) -> tuple[Command, ...]:
+        """Return the conversation commands the agent owns.
+
+        They report through transcript Markdown; commands that present a widget
+        (such as the model picker) belong to the shell, which owns the widgets.
+        """
+        return (
+            Command("/new", "start a fresh session", "agent", self._command_new),
+            Command("/compact", "summarize the context now", "agent", self._command_compact),
+            Command("/export", "write this session to an HTML file: /export [path]", "agent", self._command_export),
+        )
+
+    def attach_host(self, host: CommandHost) -> None:
+        """Tell the plugins where the shell is, so the words their commands offer can follow the session."""
+        link = self.runtime.plugins.find(HOST_LINK, HostLink)
+        if link is not None:
+            link.attach(host)
+
+    @property
+    def plugin_commands(self) -> tuple[Command, ...]:
+        """Return the commands the installed plugins registered, not counting the built-in ones.
+
+        The shell keeps them after everything built in, so a plugin cannot take over a built-in name;
+        plugin-versus-plugin duplicates are rejected when the plugins load.
+        """
+        return self.runtime.plugins.installed_commands
+
+    @property
+    def builtin_plugin_commands(self) -> tuple[Command, ...]:
+        """Return the commands the program's own plugins registered: ``/resume``, ``/model``, ``/usage`` and the rest."""
+        return self.runtime.plugins.builtin_commands
+
+    @property
+    def plugin_mentions(self) -> tuple[MentionProvider, ...]:
+        """Return the ``@`` resource providers the installed plugins registered."""
+        return self.runtime.plugins.mentions
+
+    @property
+    def providers(self) -> tuple[Provider, ...]:
+        """Return the hosts ``/config`` can offer: the built-in ones, then the plugins' own."""
+        return merge_providers(BUILTIN_PROVIDERS, self.runtime.plugins.providers)
+
+    @property
+    def themes(self) -> ThemeCatalog:
+        """Return every palette that can be asked for by name: the plugins', then the reader's own files.
+
+        Built fresh each time it is asked: it lists names and builds nothing, and the reader's directory may have
+        gained a file since the last look.
+        """
+        return ThemeCatalog(self.runtime.plugins.themes, self.runtime.config.themes_dir)
+
+    @property
+    def pets(self) -> PetCatalog:
+        """Return every pet that can be asked for by name: the built-in plugin's, then any other plugin's.
+
+        A plugin bundle that offers none (one built by hand, without the built-in plugin) gets the program's own.
+        """
+        sources = self.runtime.plugins.pets
+        return PetCatalog(sources or bundled_pets())
+
+    @property
+    def plugin_failures(self) -> tuple[str, ...]:
+        """Return one message per plugin that could not be loaded or activated."""
+        return self.runtime.plugins.failures
+
+    @property
+    def presenters(self) -> Presenters:
+        """Return how this run draws entries: the built-in presenters, and any a plugin outranks them with.
+
+        Built from the bundle rather than from a module-level default for the same reason the palettes are: the
+        program's own rows are registered through the plugin route, so a plugin that draws a kind or a family of
+        rows reaches the transcript without a second path only plugins could not take.
+        """
+        return Presenters(self.runtime.plugins.presenters)
+
+    @property
+    def plugin_rows(self) -> tuple[UiRow, ...]:
+        """Return the header and status rows plugins asked the shell to draw."""
+        return self.runtime.plugins.rows
+
+    async def _command_new(self, context: CommandContext) -> CommandResult:
+        """Start a fresh session."""
+        session_id = self.new_session()
+        return CommandResult(notification=f"started session {session_id[:8]}")
+
+    async def _command_export(self, context: CommandContext) -> CommandResult:
+        """Write the session and its context to one HTML file.
+
+        The path argument is optional; without it the file lands in the
+        workspace, named after the session, and the result says where.
+        """
+        path = await self.export_session(context.argument.strip() or None)
+        return CommandResult(message=f"Exported to `{path}`")
+
+    def self_compaction_summary(self) -> str:
+        """Say in one line whether self-compaction is on here, where that comes from, and what the default is."""
+        state = "on" if self.self_compaction else "off"
+        default = "on" if self.self_compaction_default else "off"
+        if self.self_compaction_choice is None:
+            return f"Self-compaction is {state}: this session follows the default ({default})"
+        return f"Self-compaction is {state}: this session chose it; the default is {default}"
+
+    def self_compact_report(self) -> str:
+        """Say what self-compaction is, whether it is on here, and where that comes from."""
+        choice = self.self_compaction_choice
+        default = "on" if self.self_compaction_default else "off"
+        state = "on" if self.self_compaction else "off"
+        source = (
+            f"this session chose it; the config default is **{default}**"
+            if choice is not None
+            else "following the config default (`[compaction] self`)"
+        )
+        return (
+            f"Self-compaction is **{state}** ({source}).\n\n"
+            "When on, the model gets a `compact_context` tool and can summarize its own earlier conversation "
+            "when it judges the detail is no longer needed. The current turn is always kept. "
+            "`/compact` and the automatic threshold work either way.\n\n"
+            "`/self-compact on|off` sets this session; `default` hands it back to the config; "
+            "`global on|off` changes the default for every session that has not chosen."
+        )
+
+    def change_self_compaction(self, argument: str) -> str:
+        """Read or change self-compaction from the words ``/self-compact`` takes, and say what now applies.
+
+        ``on``, ``off`` and ``default`` set this session's own choice; ``global on`` and ``global off``
+        write the default for every session into the config file. A failed write is never reported as saved.
+
+        Raises:
+            ValueError: The words are not ones the command takes, or the change could not be saved.
+        """
+        words = argument.lower().split()
+        scope = "session"
+        if words[:1] == ["global"]:
+            scope, words = "global", words[1:]
+        usage = ValueError("Usage: /self-compact [on|off|default] or /self-compact global on|off")
+        if len(words) > 1 or (scope == "global" and not words) or (words and words[0] not in _SELF_COMPACT_WORDS):
+            raise usage
+        if scope == "global":
+            if words[0] == "default":
+                raise usage
+            self.remember_self_compaction(words[0] == "on")
+        elif words:
+            self.use_self_compaction({"on": True, "off": False, "default": None}[words[0]])
+        return self.self_compact_report()
+
+    def statusline_summary(self) -> str:
+        """Say in one line which parts of the header and the status line are hidden."""
+        hidden = [name for name in NAMES if name in self.statusline_hidden]
+        if not hidden:
+            return "Status line: every part is shown"
+        return f"Status line: {len(hidden)} of {len(NAMES)} parts hidden ({', '.join(hidden)})"
+
+    def change_statusline(self, argument: str) -> str:
+        """Hide or show parts of the header and status line from the words ``/statusline`` takes.
+
+        ``hide <name>...`` and ``show <name>...`` change the named parts, and ``show all`` brings every one
+        back. The change is written to ``[statusline]`` in the config file, and nothing is changed when any
+        name is not a part.
+
+        Raises:
+            ValueError: The words are not ones the command takes, or the change could not be saved.
+        """
+        words = argument.lower().split()
+        usage = ValueError(
+            f"Usage: /statusline [hide|show] <part>... or /statusline show all; parts: {', '.join(NAMES)}"
+        )
+        if len(words) < 2 or words[0] not in {"hide", "show"}:
+            raise usage
+        visible = words[0] == "show"
+        names = list(NAMES) if visible and words[1:] == ["all"] else words[1:]
+        if stray := unknown(names):
+            raise ValueError(f"No such part: {', '.join(stray)}. Parts: {', '.join(NAMES)}")
+        self.remember_statusline({name: visible for name in names})
+        return self.statusline_summary()
+
+    async def _command_compact(self, context: CommandContext) -> CommandResult:
+        """Summarize the conversation now, whatever its size.
+
+        The row and the outcome notice arrive while this await runs: the pass
+        dispatches through the same event dispatcher a turn does, so the
+        transcript animates ``Compacting`` and ends with ``Context compaction
+        applied`` (or ``skipped`` when the summary would not be smaller).
+        """
+        await self.compact()
+        return CommandResult()

{zettcode-0.1.7 → zettcode-0.1.8}/src/zettcode/app/agent/agent/sessions.py

@@ -8,15 +8,17 @@ the rest of the shell does.
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
 from zett_agent.messages import AssistantMessage, UserMessage
+from zett_agent.model import ReasoningEffort
 
 from ..conversation.replay import Replayed, replay
 from ..conversation.transcript import Transcript
 from ..dialogue.title import summarize_title
-from ..storage import Session, SessionInfo
+from ..storage import Session, SessionInfo, SessionStats
 from .context import ContextMixin
 
 #: The name a session shows before the agent has given it a title.
@@ -170,6 +172,13 @@ class SessionsMixin(ContextMixin):
         """List persisted session metadata by recent activity."""
         return await self.runtime.persistence.list_sessions(limit=limit)
 
+    async def session_stats(self, sessions: Sequence[SessionInfo]) -> dict[str, SessionStats]:
+        """Return the entry count and token totals of listed sessions, keyed by session id.
+
+        A session missing from the answer has no totals to show.
+        """
+        return await self.runtime.persistence.session_stats([session.session_id for session in sessions])
+
     async def rename_session(self, title: str) -> str:
         """Store a display title for the active session and return it cleaned.
 
@@ -218,7 +227,9 @@ class SessionsMixin(ContextMixin):
         if not question or not answer:
             return None
         await self.runtime.start()
-        title = await summarize_title(self.runtime.provider, question=question, answer=answer)
+        # A level the model takes, so naming the session cannot be what fails on an endpoint that lacks `low`.
+        effort = self.runtime.active_model.accepted_effort(ReasoningEffort.LOW)
+        title = await summarize_title(self.runtime.provider, question=question, answer=answer, effort=effort)
         if title is None:
             return None
         await self.runtime.persistence.set_title(session_id, title)

zettcode-0.1.8/src/zettcode/app/agent/agent/settings.py

@@ -0,0 +1,327 @@
+"""What the reader can change about how the agent runs: model, reasoning effort, shell permission."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import replace
+from pathlib import Path
+
+from zettcode.config import ModelConfig, _read_models
+from zettcode.config_edit import (
+    ConfigEditError,
+    add_model,
+    file_entries,
+    remove_model,
+    replace_model,
+    set_pet,
+    set_self_compaction,
+    set_statusline,
+    set_theme,
+    write_text_atomically,
+)
+from zettcode.paths import config_path
+from zettcode.statusline import NAMES
+
+from ..permission import PERMISSION_LEVELS, Permission
+from .base import AgentBase
+
+
+class SettingsMixin(AgentBase):
+    """Read and change the model, the reasoning effort, and how much of the shell may run unasked."""
+
+    @property
+    def reduced_motion(self) -> bool:
+        """Return whether decorative animation is disabled."""
+        return self.runtime.config.reduced_motion
+
+    @property
+    def models(self) -> tuple[ModelConfig, ...]:
+        """Return the models available for selection."""
+        return self.runtime.config.models
+
+    @property
+    def active_model(self) -> ModelConfig:
+        """Return the model selected for the next turn."""
+        return self.runtime.active_model
+
+    def find_model(self, name: str) -> ModelConfig | None:
+        """Return the configured model a recorded name stands for, if exactly one does."""
+        return self.runtime.find_model(name)
+
+    def use_model(self, name: str | ModelConfig) -> ModelConfig:
+        """Select a configured model for subsequent turns."""
+        return self.runtime.use_model(name)
+
+    # -- the models in the config file --------------------------------------------------
+    @property
+    def config_file(self) -> Path:
+        """Return the file the models are read from and written to."""
+        return config_path()
+
+    def _read_config_file(self) -> str:
+        """Return the config file's text, or raise :class:`ConfigEditError` saying why not."""
+        path = self.config_file
+        try:
+            return path.read_text(encoding="utf-8")
+        except FileNotFoundError as error:
+            raise ConfigEditError(f"{path} does not exist") from error
+        except (OSError, UnicodeDecodeError) as error:
+            raise ConfigEditError(f"{path} cannot be read: {error}") from error
+
+    def file_models(self) -> tuple[tuple[ModelConfig, Mapping[str, object]], ...]:
+        """Return each model in the file with the keys the file writes for it.
+
+        The file is the source of truth for editing, not the models the session started with: a
+        reader may have changed it by hand since. The keys are what is *written* — a token left to
+        an environment variable is absent — which is what a rewrite has to start from.
+
+        Raises:
+            ConfigEditError: When the file cannot be read, is not valid, or lays its models out in
+                a way the editor cannot safely change.
+        """
+        text = self._read_config_file()
+        path = self.config_file
+        entries = file_entries(text, where=path)
+        try:
+            models = _read_models(entries, path)
+        except ValueError as error:
+            raise ConfigEditError(str(error)) from error
+        return tuple(zip(models, entries, strict=True))
+
+    def _commit_models(self, text: str) -> ModelConfig:
+        """Write the edited text, then make the running session use what it now says.
+
+        The file is written first and the session is changed second, so a write that fails leaves
+        the session as it was, and what the session holds is always something the file holds too.
+        """
+        path = self.config_file
+        try:
+            write_text_atomically(path, text)
+        except OSError as error:
+            raise ConfigEditError(f"{path} could not be written: {error}") from error
+        models = _read_models(file_entries(text, where=path), path)
+        return self.runtime.replace_models(models)
+
+    def add_configured_model(self, entry: Mapping[str, object]) -> ModelConfig:
+        """Add one ``[[models]]`` entry to the file and to this session; return the new model.
+
+        The model in use does not change: adding is not choosing. The new one appears in ``/model``.
+
+        Args:
+            entry: The keys of the new model as the file writes them.
+
+        Raises:
+            ConfigEditError: When the entry is not a model that can be called, or the file cannot
+                be edited. Nothing is written then.
+        """
+        text = add_model(self._read_config_file(), entry, where=self.config_file)
+        self._commit_models(text)
+        return self.runtime.config.models[-1]
+
+    def update_configured_model(self, index: int, entry: Mapping[str, object]) -> ModelConfig:
+        """Rewrite model number ``index`` (from zero) of the file as ``entry``; return the result."""
+        text = replace_model(self._read_config_file(), index, entry, where=self.config_file)
+        self._commit_models(text)
+        return self.runtime.config.models[index]
+
+    def change_compact_percent(self, percent: float) -> tuple[ModelConfig, str | None]:
+        """Compact the model in use at ``percent`` of its window from the next request, and write it to the config file.
+
+        The running session is changed whatever becomes of the file, since the reader asked for it now: a file
+        that cannot be edited (no file, a layout the editor refuses) leaves the change for this run only, and the
+        reason is returned beside the model so it can be said.
+
+        Args:
+            percent: Share of the window, more than 0 and at most 100.
+
+        Returns:
+            The model now in use, and why the file was not changed (``None`` when it was).
+
+        Raises:
+            ValueError: ``percent`` is not between 0 and 100.
+        """
+        if not 0 < percent <= 100:
+            raise ValueError("The compression share must be more than 0 and at most 100.")
+        active = self.active_model
+        value = int(percent) if float(percent).is_integer() else percent
+        try:
+            for index, (model, entry) in enumerate(self.file_models()):
+                if model == active:
+                    return self.update_configured_model(index, {**entry, "compact_percent": value}), None
+            reason = "the model in use is not in the config file"
+        except ConfigEditError as error:
+            reason = str(error)
+        edited = replace(active, compact_percent=float(percent))
+        models = tuple(edited if model is active else model for model in self.models)
+        return self.runtime.replace_models(models), reason
+
+    def remove_configured_model(self, index: int) -> ModelConfig:
+        """Remove model number ``index`` (from zero) from the file and this session.
+
+        Returns:
+            The model in use afterwards: the one before unless it was the one removed.
+
+        Raises:
+            ConfigEditError: When it is the only model, or the file cannot be edited.
+        """
+        text = remove_model(self._read_config_file(), index, where=self.config_file)
+        return self._commit_models(text)
+
+    def remember_theme(self, name: str) -> Path:
+        """Write ``[ui] theme = name`` into the config file, so the next start opens in that palette.
+
+        Only that line changes. A config file that does not exist is not created for it: a file with nothing but
+        ``[ui]`` in it would stand where a reader's environment-variable setup is, and say nothing about models.
+
+        Returns:
+            The file written.
+
+        Raises:
+            ConfigEditError: When there is no config file, it cannot be read or edited safely, or it cannot be
+                written. Nothing is written then.
+        """
+        text = set_theme(self._read_config_file(), name, where=self.config_file)
+        try:
+            write_text_atomically(self.config_file, text)
+        except OSError as error:
+            raise ConfigEditError(f"{self.config_file} could not be written: {error}") from error
+        return self.config_file
+
+    def remember_pet(self, name: str) -> Path:
+        """Write ``[ui] pet = name`` into the config file, so the next start opens with that pet.
+
+        Only that line changes, and a config file that does not exist is not created for it. The pet in force
+        for this run is the shell's to switch; what this keeps up to date is the setting the shell reads back.
+
+        Returns:
+            The file written.
+
+        Raises:
+            ConfigEditError: When there is no config file, it cannot be read or edited safely, or it cannot be
+                written. Nothing is written then.
+        """
+        text = set_pet(self._read_config_file(), name, where=self.config_file)
+        try:
+            write_text_atomically(self.config_file, text)
+        except OSError as error:
+            raise ConfigEditError(f"{self.config_file} could not be written: {error}") from error
+        self.runtime.config = replace(self.runtime.config, pet=name)
+        return self.config_file
+
+    @property
+    def statusline_hidden(self) -> frozenset[str]:
+        """Return the names of the header and status-line parts the reader switched off."""
+        return frozenset(self.runtime.config.statusline_hidden)
+
+    def remember_statusline(self, shown: Mapping[str, bool]) -> Path:
+        """Write which parts of the header and status line are shown into ``[statusline]``.
+
+        Only the parts that differ from what is in force are written. The file is written first and the
+        running configuration changed second, so a write that fails leaves both as they were; the rows
+        follow at the next paint. A config file that does not exist is not created for it, as for the theme.
+
+        Args:
+            shown: Part name to whether it is shown. A part left out keeps what it has.
+
+        Returns:
+            The file written.
+
+        Raises:
+            ConfigEditError: When there is no config file, it cannot be read or edited safely, or it cannot
+                be written.
+        """
+        hidden = set(self.statusline_hidden)
+        changes = {name: visible for name, visible in shown.items() if (name not in hidden) != visible}
+        if not changes:
+            return self.config_file
+        text = set_statusline(self._read_config_file(), changes, where=self.config_file)
+        try:
+            write_text_atomically(self.config_file, text)
+        except OSError as error:
+            raise ConfigEditError(f"{self.config_file} could not be written: {error}") from error
+        hidden = {name for name in hidden if name not in changes} | {name for name, v in changes.items() if not v}
+        ordered = tuple(name for name in NAMES if name in hidden)
+        self.runtime.config = replace(self.runtime.config, statusline_hidden=ordered)
+        return self.config_file
+
+    @property
+    def self_compaction(self) -> bool:
+        """Return whether the model may request compaction in this session right now."""
+        return self.runtime.self_compacting(self.session_id)
+
+    @property
+    def self_compaction_choice(self) -> bool | None:
+        """Return this session's own choice, or ``None`` when it follows the default."""
+        return self.runtime.self_compaction_choice(self.session_id)
+
+    @property
+    def self_compaction_default(self) -> bool:
+        """Return what a session that has made no choice does: ``[compaction] self`` in the config."""
+        return self.runtime.config.self_compaction
+
+    def use_self_compaction(self, choice: bool | None) -> None:
+        """Set this session's own choice, or give it back with ``None`` so it follows the default.
+
+        Raises:
+            SessionLocked: Another process has the session open; the choice is part of the session.
+            ConfigEditError: The choice could not be saved. Nothing is reported as saved then.
+        """
+        self.require_session()
+        try:
+            self.runtime.choose_self_compaction(self.session_id, choice)
+        except OSError as error:
+            raise ConfigEditError(f"Self-compaction setting was not saved: {error}") from error
+
+    def remember_self_compaction(self, enabled: bool) -> Path:
+        """Write ``[compaction] self = enabled`` into the config file: the default for every session.
+
+        The file is written first and the running configuration changed second, so a write that fails
+        leaves both as they were. A session with a choice of its own keeps it; one without follows this at
+        once. A config file that does not exist is not created for it, as for the theme.
+
+        Returns:
+            The file written.
+
+        Raises:
+            ConfigEditError: When there is no config file, it cannot be read or edited safely, or it cannot
+                be written.
+        """
+        text = set_self_compaction(self._read_config_file(), enabled, where=self.config_file)
+        try:
+            write_text_atomically(self.config_file, text)
+        except OSError as error:
+            raise ConfigEditError(f"{self.config_file} could not be written: {error}") from error
+        self.runtime.config = replace(self.runtime.config, self_compaction=enabled)
+        return self.config_file
+
+    @property
+    def effort(self) -> str:
+        """Return the reasoning effort the next request will ask for."""
+        return self.runtime.effort.value
+
+    @property
+    def efforts(self) -> tuple[str, ...]:
+        """Return the reasoning levels the active model takes, cheapest first."""
+        return tuple(level.value for level in self.runtime.active_model.efforts)
+
+    def use_effort(self, name: str) -> str:
+        """Select a reasoning level for later requests and return its value."""
+        return self.runtime.use_effort(name).value
+
+    def approve_all_shell_commands(self) -> None:
+        """Approve every shell command for the rest of this run, without asking."""
+        self.runtime.approve_all_shell_commands()
+
+    @property
+    def permission(self) -> Permission:
+        """Return how much of the shell may run without asking."""
+        return self.runtime.permission
+
+    @property
+    def permissions(self) -> tuple[str, ...]:
+        """Return the permission levels, strictest first."""
+        return tuple(level.value for level in PERMISSION_LEVELS)
+
+    def use_permission(self, name: str | Permission) -> Permission:
+        """Set how much of the shell may run without asking, for the rest of this run."""
+        return self.runtime.use_permission(name)