mini-code-cli 0.1.1.1__py3-none-any.whl → 0.1.1.3__py3-none-any.whl

mini_code_cli/__init__.py

@@ -11,22 +11,41 @@ to ``"unknown"`` so importing the package can never fail over a version lookup.
 __all__ = ["__version__"]
 
 
+def _version_from_file(path):
+    """Return the ``[project] version`` in ``path``.
+
+    ``tomllib`` only exists from Python 3.11, and the scan below is not a
+    nicety for 3.10: without it this function used to skip the file entirely on
+    that interpreter and report the *installed* metadata instead, so a checkout
+    with a stale editable install showed the wrong version in the banner (found
+    on the 3.10 CI leg). Both paths read the same key, and the section tracking
+    matters: a ``version`` key in some other table must not win.
+    """
+    try:
+        import tomllib  # Python >= 3.11
+    except ImportError:  # pragma: no cover - exercised on the 3.10 CI leg
+        tomllib = None
+    if tomllib is not None:
+        with open(path, "rb") as f:
+            return str(tomllib.load(f)["project"]["version"])
+    section = None
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            stripped = line.strip()
+            if stripped.startswith("["):
+                section = stripped
+            elif section == "[project]" and stripped.startswith("version"):
+                return stripped.split("=", 1)[1].strip().strip('"')
+    raise KeyError(f"no version in the [project] table of {path}")
+
+
 def _read_version():
     """Best-effort package version: pyproject.toml, then installed metadata."""
     try:
         from pathlib import Path
 
         pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
-        try:
-            import tomllib  # Python >= 3.11
-        except ImportError:  # pragma: no cover - older interpreters
-            tomllib = None
-        if tomllib is not None:
-            try:
-                with open(pyproject, "rb") as f:
-                    return str(tomllib.load(f)["project"]["version"])
-            except Exception:
-                pass
+        return _version_from_file(pyproject)
     except Exception:
         pass
     try:

mini_code_cli/__main__.py

@@ -0,0 +1,12 @@
+"""Allow ``python -m mini_code_cli`` to start the agent.
+
+The console script ``mini-code`` (see ``[project.scripts]``) is the normal entry
+point; this module exists so the package also runs straight from a checkout or
+an installed wheel without the script on ``PATH`` -- which is what a reader
+tries first after ``pip install -e .``.
+"""
+
+from .agent_loop import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mini_code_cli/agent_loop.py

@@ -31,7 +31,7 @@ from . import prompts
 from . import shell_safety_utils
 from . import tools
 from . import utils
-from .utils import oneline
+from .utils import oneline, plural
 from . import ui
 from . import subagents
 from . import skills
@@ -118,7 +118,12 @@ def _safe_int(value, default=0):
 # ---------------------------------------------------------------------------
 
 def parse_args():
-    parser = argparse.ArgumentParser(description="Agent loop for interacting with a language model")
+    # ``prog`` is pinned so ``--help`` reads the same whether the agent was
+    # started through the ``mini-code`` script, ``python -m mini_code_cli`` or
+    # a test harness (without it, the usage line said ``__main__.py``).
+    parser = argparse.ArgumentParser(
+        prog="mini-code",
+        description="Agent loop for interacting with a language model")
     # MODEL / LLM related
     parser.add_argument("--url", type=str, default=f"{DEFAULT_MODEL_URL}", help=f"API host, default={DEFAULT_MODEL_URL}")
     parser.add_argument("--max-tokens", type=int, help="Maximum tokens for a single LLM response (the reply budget), default=None. Also used as the output headroom reserved when deriving the compaction limit from the model's context window.")
@@ -267,6 +272,37 @@ def _compaction_trigger(messages, token_limit, reserved_output_tokens, current_t
     return False, ""
 
 
+def _in_flight_tail(messages):
+    """Return the messages of the turn that is still in flight, or ``[]``.
+
+    Compaction rewrites the transcript, so whatever it drops is gone from the
+    conversation *and* from everything saved afterwards. The last turn is not
+    finished work, though: it is either the instruction being answered right now
+    (the transcript ends with a ``user`` message) or the tool exchange the model
+    is waiting on (it ends with a ``tool`` result). Either way it has to be
+    carried across verbatim, or the model answers the summary instead of the
+    user's request -- and the typed line never reaches the recorder, the new
+    segment or a later restore.
+
+    The suffix starts at the last ``user`` message, which always begins a
+    self-contained turn: every ``assistant`` tool call inside it is followed by
+    its ``tool`` results, so the slice is a valid transcript on its own.
+
+    ``[]`` when the transcript already ends with an ``assistant`` reply: that
+    turn is answered, and re-sending it would ask the model to answer it twice.
+    """
+    if not messages:
+        return []
+    last = messages[-1]
+    if not isinstance(last, dict) or last.get("role") == "assistant":
+        return []
+    for index in range(len(messages) - 1, -1, -1):
+        message = messages[index]
+        if isinstance(message, dict) and message.get("role") == "user":
+            return list(messages[index:])
+    return []
+
+
 def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats,
                   history_index=0, token_limit=None, reserved_output_tokens=0,
                   current_tokens=None, plan_hook=None, console=None):
@@ -279,7 +315,9 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
     against ``token_limit``. Nothing else triggers compaction: in particular the
     number of messages is not a criterion. Compaction is then done by asking the
     LLM to summarize the history and replacing the old turns with that summary,
-    keeping the original system prompt as the first message. The compaction call
+    keeping the original system prompt as the first message *and the turn that is
+    still in flight* (see :func:`_in_flight_tail`) verbatim after it -- a summary
+    of the user's current request is not the request. The compaction call
     itself is a single, tool-free request, so it cannot trigger further tool
     calls or recurse into compaction.
 
@@ -289,10 +327,12 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
     ``plan_hook`` is an optional callable the caller supplies only when running
     under plan mode (in practice ``AgentSession._handle_compaction``). After the
     summary is built the hook re-injects the running goal + plan so the compacted
-    messages carry them forward. It receives the compacted list and must update it
-    *in place*, because that list is what gets returned to the caller. Passing it in -- instead of referencing the
-    owning session -- keeps ``maybe_compact`` a small, module-level, network-free
-    helper that the test-suite can import and exercise directly.
+    messages carry them forward. It receives the compacted list *and* the
+    in-flight tail (see below) and must update the compacted list in place,
+    because that list is what gets returned to the caller. Passing it in --
+    instead of referencing the owning session -- keeps ``maybe_compact`` a
+    small, module-level, network-free helper that the test-suite can import and
+    exercise directly.
     """
     # ``console`` defaults to None so callers may omit it, but every branch below
     # reports through a console. Falling back to the shared one keeps the
@@ -311,8 +351,20 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
         # bare messages would crash them.
         return messages, False, history_index
 
+    # The turn this step is answering -- the instruction just typed, or the tool
+    # exchange the model is waiting on -- is carried across the rollover (see
+    # :func:`_in_flight_tail`). It is computed *before* the slow summary call so
+    # the console can tell the user right away that nothing they just sent is at
+    # stake; a compaction note that stays silent about that is exactly what makes
+    # the rollover look like it might have eaten the message.
+    tail = _in_flight_tail(messages)
+    kept_note = (f" The current turn ({plural(len(tail), 'message')}) is kept "
+                 f"verbatim." if tail else "")
+
     try:
-        console.note(f"Compacting conversation history ({reason}) -> summary...", "warn")
+        console.note(
+            f"Compacting the conversation: {plural(len(messages), 'message')} "
+            f"-> a summary ({reason}).{kept_note}", "warn")
         summary_prompt = prompts.compaction_prompt(messages)
 
         # The summariser sometimes answers with nothing at all. An empty summary
@@ -324,7 +376,7 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
         # the over-cap transcript was retried, and paid for, on every step.
         summary = ""
         for attempt in (1, 2):
-            console.start_thinking("compacting")
+            console.start_thinking("compacting history")
             try:
                 reply, _, compact_usage, _ = utils.unpack_llm_result(
                     utils.call_openai_server(
@@ -347,9 +399,14 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
                 console.note("The summariser returned an empty summary; retrying once.", "warn")
 
         if not summary:
+            # Say plainly what did *not* happen: nothing was dropped and the
+            # segment did not move -- only the shrink did, so the next request
+            # may still be too large.
             console.note(
                 f"Could not compact history: the summariser returned an empty "
-                f"summary twice. Keeping all {len(messages)} messages "
+                f"summary twice. Keeping all {plural(len(messages), 'message')} "
+                f"and history_{history_index}.json as they are -- nothing was "
+                f"lost, but the next request may still be too large "
                 f"({reason}).", "warn")
             return messages, False, history_index
 
@@ -362,22 +419,56 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
             "content": f"Here is a summary of our earlier conversation so far:\n{summary}",
         })
 
+        # The turn in flight has to survive the rollover. Compaction runs at the
+        # *start* of a step, so ``messages`` normally ends with the user message
+        # this step is meant to answer, or with the tool result the model is
+        # waiting on. Replacing the transcript with just (system, summary)
+        # therefore dropped the user's instruction on the floor: the model
+        # answered the summary -- "Understood. What would you like me to do?" --
+        # and the typed line never reached the new segment, the recorder or a
+        # later restore (it survived only inside the *closed* segment, which no
+        # recorder record points at any more). ``tail`` was computed before the
+        # summary call so the opening note could already promise this.
+
         # In plan mode, re-inject the running plan + current goal so a
         # compaction (which would otherwise drop them) keeps the model
         # working against the goal it is still trying to finish. The hook is
         # wired in only when the caller runs under plan mode; otherwise
-        # compaction degrades to a plain summary.
+        # compaction degrades to a plain summary. It is also handed the tail so
+        # it can restate the *real* instruction rather than the summary text.
         if plan_hook is not None:
-            plan_hook(compacted)
-
-        console.note(f"History compacted to {len(compacted)} messages.", "warn")
+            plan_hook(compacted, tail)
+
+        # ... and only then the live turn, so the user's actual instruction
+        # reads as the most recent thing the model has to act on.
+        compacted.extend(tail)
+
+        # What the user is shown has to answer the three questions a rollover
+        # raises: *what* was folded away (the summary itself), *how much* (the
+        # closing segment's message count, and what the new one starts with),
+        # and *where it went* (which segment file was closed and which was
+        # started).
+        console.note(f"Summary preview: {utils.oneline(summary, 120)}", "warn")
+        kept = (f"summary + {plural(len(tail), 'kept message')}" if tail
+                else "summary only")
+        # Phrased as "old segment -> new segment" rather than "N messages -> M
+        # messages": the replacement can be *longer* than what it replaced (a
+        # system prompt, the summary and the kept turn), and a bare pair of
+        # counts that sometimes grows reads like a bug.
+        console.note(
+            f"Compacted history_{history_index}.json "
+            f"({plural(len(messages), 'message')}) into a summary; "
+            f"history_{history_index + 1}.json now starts with "
+            f"{plural(len(compacted), 'message')} ({kept}).", "warn")
         # A new segment (history_index + 1) is started on compaction: the
         # compacted messages are its snapshot, and every later turn appends
         # to it. The caller records a single high-level 'summary' turn for
         # this index so the recorder stays flat across the rollover.
         return compacted, True, history_index + 1
     except Exception as e:
-        console.note(f"Failed to compact history: {e}", "error")
+        console.note(
+            f"Failed to compact history: {e}. Keeping all "
+            f"{plural(len(messages), 'message')} unchanged.", "error")
 
     return messages, False, history_index
 
@@ -427,6 +518,11 @@ class AgentSession:
 
         self.plan_mode = bool(getattr(self.args, "plan", False))
 
+        # The good-bye box is printed once, from shutdown(). Several exits
+        # funnel through there (quit, exit, EOF, a /quit command) and a repeated
+        # box would read like a second session had ended.
+        self._farewell_shown = False
+
         # Token accounting. ``token_stats`` covers the *current history
         # segment* and is reset when compaction rolls over to a new one;
         # ``total_usage`` is the whole-session accumulator and never decreases.
@@ -1263,8 +1359,12 @@ class AgentSession:
             return
         except KeyboardInterrupt:
             self.console.note("Interrupting: Mini Code Exiting...", "error")
+            self.shutdown(farewell=False)
+            return
         except Exception as e:
             self.console.note(f"Exception {e}. Exiting...", "error")
+            self.shutdown(farewell=False)
+            return
         self.shutdown()
 
     def _emit_tip(self):
@@ -1508,7 +1608,7 @@ class AgentSession:
         return True
 
 
-    def _handle_compaction(self, compacted):
+    def _handle_compaction(self, compacted, tail=()):
         """Re-inject goal + plan into the compacted messages (plan mode).
 
         Plan-mode counterpart to the plan handling inside :meth:`maybe_compact`,
@@ -1516,7 +1616,8 @@ class AgentSession:
         a network-free module-level helper. The loop wires in this method only
         when plan mode is on; it re-injects the goal + plan via
         :meth:`_apply_plan_to_compacted`, which also rewrites the tracking files
-        to match.
+        to match. ``tail`` is the turn that is still in flight, which
+        ``maybe_compact`` appends after the hook's messages.
 
         The hook must update ``compacted`` **in place**: ``maybe_compact``
         returns *that* list to the caller, which then assigns it to
@@ -1524,9 +1625,9 @@ class AgentSession:
         discarded a moment later, silently dropping the goal and plan -- which is
         exactly what happened before this was a slice assignment.
         """
-        compacted[:] = self._apply_plan_to_compacted(compacted)
+        compacted[:] = self._apply_plan_to_compacted(compacted, tail)
 
-    def _apply_plan_to_compacted(self, messages):
+    def _apply_plan_to_compacted(self, messages, tail=()):
         """Re-inject the current goal + plan after a history compaction.
 
         Compaction replaces the transcript with a summary, which would otherwise
@@ -1534,16 +1635,18 @@ class AgentSession:
         back off disk and append them as fresh user turns so the model keeps
         working against the goal it is still trying to finish. The goal is
         appended last so it reads as the most recent instruction the model
-        should act on.
+        should act on -- ``maybe_compact`` then appends the in-flight turn, which
+        is the same instruction verbatim.
         """
         plan_text = self.plan_manager.read_plan()
         goal_text = self.plan_manager.read_goal()
 
-        # Recover the user's latest instruction from the pre-compaction tail, in
-        # case the loop had not recorded a goal yet, so there is always a goal to
-        # restate after compaction.
+        # Recover the user's latest instruction from the *in-flight turn* -- not
+        # from ``messages``, which by now holds the summary -- so a session that
+        # compacts before its goal was recorded still restates the real
+        # instruction instead of the summary text.
         current_input = None
-        for m in reversed(messages):
+        for m in reversed(list(tail or ())):
             if m.get("role") == "user":
                 current_input = m.get("content")
                 break
@@ -1857,7 +1960,9 @@ class AgentSession:
         #    just the turns. In verbose mode everything is printed permanently.
         transient = not self.console.verbose
         func = self.tools_dict[name]["function"]
-        result = call_function_with_timeout(func, tool_params, name, timeout_seconds=self.args.tool_timeout)
+        result = call_function_with_timeout(func, tool_params, name,
+                                            timeout_seconds=self.args.tool_timeout,
+                                            console=self.console)
 
         self.console.tool_call_display(name, tool_params, result, transient=transient)
         self._append_tool_result(call_id, str(result))
@@ -1931,8 +2036,15 @@ class AgentSession:
             self.console.note(
                 f"Saved usage to: {usage_path} (session total: {total_path})", "info")
 
-    def shutdown(self):
-        """Persist and print a final summary (called on quit / exit)."""
+    def shutdown(self, farewell=True):
+        """Persist and print a final summary (called on quit / exit).
+
+        ``farewell=False`` is used by the interrupt / fatal paths in :meth:`run`,
+        which have already told the user (in red) that the session is being torn
+        down: a cheerful "thanks and here is your state" box on top of a crash is
+        the wrong note, and the state it would recap is the state that just
+        failed.
+        """
         self._persist()
         segments = history_segment_indices(self.session_dir)
         # List what is really on disk. The old message claimed
@@ -1948,7 +2060,62 @@ class AgentSession:
         self.console.note(
             f"Saved session to {self.cache_dir}/{self.unique_id}/ "
             f"({present} + summary_history.json).", "ok")
-        self.console.usage_summary(self.total_usage)
+        # The detailed per-field usage block is verbose-only (the console
+        # documents it that way); in the quiet default view the good-bye box
+        # below carries the same totals, so nothing is lost by leaving it out.
+        if self.console.verbose:
+            self.console.usage_summary(self.total_usage)
+        if farewell:
+            self._farewell(segments)
+
+    def _farewell(self, segments=None):
+        """Print the good-bye box: version, sign-off and what the session left.
+
+        Printed once (see ``_farewell_shown``) and only on a normal exit. It
+        restates the state in one glanceable place -- the same facts the user
+        would otherwise have to piece together from the save note, ``/history``
+        and the (verbose-only) usage readout, which in the quiet default view
+        means they saw none of it.
+        """
+        if self._farewell_shown:
+            return
+        self._farewell_shown = True
+        from . import __version__ as version
+
+        if segments is None:
+            segments = history_segment_indices(self.session_dir)
+        if not segments:
+            where = f"history_{self.history_index}.json"
+        elif len(segments) == 1:
+            where = f"history_{segments[0]}.json"
+        else:
+            where = f"history_{segments[0]}..{segments[-1]}.json"
+
+        turns = len(self.summary)
+        usage = self.total_usage or {}
+
+        def count(key):
+            # A display detail on the exit path must never raise: a server that
+            # reported ``null`` usage leaves a None here, and crashing while
+            # saying goodbye would be the worst possible time to fail.
+            try:
+                return int(usage.get(key) or 0)
+            except (TypeError, ValueError):
+                return 0
+
+        rows = [
+            ("session id", self.unique_id),
+            ("saved under", f"{self.cache_dir}/{self.unique_id}/"),
+            ("history", f"{where} (segment {self.history_index}), "
+                        f"{plural(len(self.messages), 'message')}"),
+            ("conversation", plural(turns, "recorded turn")),
+            ("tokens", f"{count('prompt_tokens'):,} in / "
+                       f"{count('completion_tokens'):,} out "
+                       f"({count('total_tokens'):,} total)"),
+            ("calls", f"{count('llm_calls'):,} LLM, "
+                      f"{count('tool_calls'):,} tool"),
+        ]
+        self.console.farewell(version, rows)
 
     # -- single LLM turn ---------------------------------------------------
 
@@ -2000,14 +2167,19 @@ class AgentSession:
                              self.history_index)
             except Exception as e:
                 self.console.note(
-                    f"Could not save the closed history segment: {e}", "warn")
+                    f"Could not save the closed history segment "
+                    f"history_{self.history_index}.json: {e}. The compacted "
+                    f"conversation is unaffected, but /reset back into that "
+                    f"segment may be incomplete.", "warn")
             self.history_index = new_index
             self.token_stats = empty_usage()
             # Snapshot the compacted messages into the new segment so its turns
             # are preserved, and record the summary as the first turn of it.
             save_history(self.messages, self.cache_dir, self.unique_id, self.history_index)
             self._record_turn(
-                f"summary: history compacted to {len(self.messages)} messages",
+                f"summary: history_{new_index - 1}.json "
+                f"({plural(len(closing_messages), 'message')}) compacted into a "
+                f"summary; history_{self.history_index}.json started",
                 self.messages)
 
         # Show a "… thinking" spinner while the LLM works (in-place, non-scrolling;

mini_code_cli/runner.py

@@ -18,13 +18,19 @@ class _TimedOut(Exception):
     pass
 
 
-def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_TOOL_TIMEOUT):
+def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_TOOL_TIMEOUT,
+                               console=None):
     """Call ``func(**tool_params)``, aborting after ``timeout_seconds``.
 
     On timeout -- or if the tool raises *any* other exception -- a friendly
     ``Error:`` string is returned so the failure reaches the model as a tool
     result (letting it recover or retry) instead of propagating and crashing the
     whole agent loop. A timeout is reported distinctly from a generic failure.
+
+    ``console`` is the session's console. It defaults to the shared one so a
+    bare call still works, but the agent loop passes its own: a sub-agent's
+    console redirects its output, and reporting to the module-level console
+    would print a background child's tool errors onto the user's terminal.
     """
     def _handler(signum, frame):
         raise _TimedOut()
@@ -35,30 +41,32 @@ def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_
         # signal only works in the main thread; if we cannot arm it, just run
         # the tool without the wall-clock guard rather than failing outright --
         # but still shield the loop from a tool that raises.
-        return _call_tool_safely(func, tool_params, name)
+        return _call_tool_safely(func, tool_params, name, console)
 
+    console = console if console is not None else ui.console
     signal.alarm(int(timeout_seconds) if timeout_seconds else 0)
     try:
         return func(**tool_params)
     except _TimedOut:
-        ui.console.note(f"Function {name} timed out after {timeout_seconds} seconds.", "error")
+        console.note(f"Function {name} timed out after {timeout_seconds} seconds.", "error")
         return f"Error: Function {name} timed out after {timeout_seconds} seconds."
     except Exception as e:  # noqa: BLE001 -- a failing tool must not crash the loop
-        ui.console.note(f"Tool {name} raised an error: {e}", "error")
+        console.note(f"Tool {name} raised an error: {e}", "error")
         return f"Error: tool {name} raised an error: {e}"
     finally:
         signal.alarm(0)
         signal.signal(signal.SIGALRM, previous)
 
 
-def _call_tool_safely(func, tool_params, name):
+def _call_tool_safely(func, tool_params, name, console=None):
     """Run a tool with no wall-clock guard (SIGALRM unavailable) but still
     shield the loop from a tool that raises.
 
     Used as the fallback when we could not arm SIGALRM (e.g. a non-main thread).
     """
+    console = console if console is not None else ui.console
     try:
         return func(**tool_params)
     except Exception as e:  # noqa: BLE001 -- never let a tool exception propagate
-        ui.console.note(f"Tool {name} raised an error: {e}", "error")
+        console.note(f"Tool {name} raised an error: {e}", "error")
         return f"Error: tool {name} raised an error: {e}"

mini_code_cli/skills.py

@@ -294,7 +294,10 @@ def run_skill(allowed_dir, skill_name, script_name, args=None):
     argv = shlex.split(args) if args else []
     cmd = [sys.executable, script_path] + argv
     try:
-        result = subprocess.run(cmd, capture_output=True, text=True,
+        # Run *inside* the skill's own directory: a script that writes or reads
+        # a relative path then stays in the skill folder instead of landing in
+        # whatever directory the agent process happens to have inherited.
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd=base,
                                 timeout=DEFAULT_TOOL_TIMEOUT, check=False)
     except Exception as e:
         return f"Error: {e}"

mini_code_cli/ui.py

@@ -29,7 +29,7 @@ import shutil
 import sys
 import threading
 
-from .utils import oneline
+from .utils import oneline, plural
 
 # --- ANSI SGR codes ---------------------------------------------------------
 _RESET = "\033[0m"
@@ -348,12 +348,6 @@ class Console:
                 styled_lines.append(text)
         self.print_box(styled_lines, title=title, fg=fg)
 
-    def truncate(self, text, limit):
-        text = str(text)
-        if len(text) > limit:
-            return text[:limit] + "... (truncated)"
-        return text
-
     @staticmethod
     def _oneline(text, limit=None):
         """Collapse ``text`` to one line (delegates to :func:`utils.oneline`)."""
@@ -570,7 +564,7 @@ class Console:
         """Render one attempted tool call: its name, parameters and result."""
         self.emit(self.style(f"{self.glyph('gear')} {name}", fg="magenta", bold=True))
         for key, value in (params or {}).items():
-            snippet = self.truncate(self._oneline(str(value), 100), 100)
+            snippet = self._oneline(str(value), 100)
             key_str = self.style(f"    {key}:", fg="gray", dim=True) if self.color_enabled \
                 else f"    {key}:"
             self.emit(f"{key_str} {snippet}")
@@ -586,7 +580,7 @@ class Console:
                 first = text.splitlines()[0] if text.strip() else "(no output)"
                 arrow = self.style(self.glyph("arrow"), fg=color) if self.color_enabled \
                     else self.glyph("arrow")
-                self.emit(f"    {arrow} {self.truncate(first, 300)}")
+                self.emit(f"    {arrow} {self._oneline(first, 300)}")
 
     def tool_call_display(self, name, params=None, result=None, transient=True):
         """Render one attempted tool call.
@@ -624,7 +618,7 @@ class Console:
                     f"total={usage.get('total_tokens', 0)}")
         if llm_calls is not None:
             calls = int(llm_calls)
-            text += f" | {calls} LLM call{'' if calls == 1 else 's'}"
+            text += f" | {plural(calls, 'LLM call')}"
         label = self.style("tokens", fg="cyan", dim=True) if self.color_enabled else "tokens"
         return f"{label}: {text}"
 
@@ -683,7 +677,7 @@ class Console:
         self.emit(self.style(header, bold=True, fg="cyan"))
         for turn, what, where in rows:
             turn_cell = self.style(turn.rjust(turn_w), fg="magenta", bold=True) if self.color_enabled else turn.rjust(turn_w)
-            what_cell = self.style(self.truncate(what, what_w), dim=True) if self.color_enabled else what.ljust(what_w)
+            what_cell = self.style(self._oneline(what, what_w), dim=True) if self.color_enabled else what.ljust(what_w)
             where_cell = self.style(where, fg="gray", dim=True) if self.color_enabled else where
             self.emit(f"{turn_cell}  {what_cell}  {where_cell}")
         self.emit(self.style("(commands: /history <n> to inspect, /reset <n> to rewind)", dim=True, fg="cyan"))
@@ -739,6 +733,32 @@ class Console:
         ]
         self.banner(f"MiniCodeCLI v{version}", lines, fg="cyan")
 
+    def farewell(self, version, rows, sign_off=None):
+        """Render the exit banner: a sign-off plus a summary of the session state.
+
+        Deliberately narrower than :meth:`welcome`. Everything the welcome banner
+        shows is about how the session *will* run -- server, model, permissions,
+        allowed dir -- and all of it is irrelevant once the session is over. What
+        the user can still act on is what the session *left behind*: which
+        folder it was saved in, which history segments exist, how much was said
+        and what it cost. So the box carries only the version, a good-bye line
+        and those ``rows``.
+
+        ``rows`` is a list of ``(label, value)`` pairs, laid out in a single
+        colon-aligned column like the welcome banner; the caller supplies the
+        pairs because it owns the state (the console stays free of session
+        policy).
+        """
+        label_w = max((len(str(label)) for label, _ in rows), default=0)
+        lines = [sign_off or "Goodbye, and thanks for using MiniCodeCLI!", ""]
+        lines += [f"{str(label).ljust(label_w)} : {value}" for label, value in rows]
+        # Yellow, not the welcome banner's cyan: this is the one box that
+        # *closes* the session, so it reads as a distinct, valedictory note
+        # rather than the startup banner reappearing. Colours only apply on a
+        # colour-capable TTY (see :meth:`box`), so piped/ASCII output is
+        # unchanged.
+        self.banner(f"MiniCodeCLI v{version} - goodbye", lines, fg="yellow")
+
     def announce_api_key(self, present):
         if present:
             self.note("API key found (MINI_CODE_API_KEY).", "ok")