mini-code-cli 0.1.1.1__tar.gz → 0.1.1.2__tar.gz

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.1.1.1
+Version: 0.1.1.2
 Summary: Mini Coding Agent. Allows you to easily experiment with a small coding agent.
 Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -970,6 +970,28 @@ reserve (`--max-tokens`). Unset (default) it is derived from the model's context
 output reserve and a safety margin. Lower it to compact sooner, raise it to compact later — there
 is no message-count cap to configure.
 
+Compaction replaces the older turns with a summary, but it always carries the **turn in flight**
+across the rollover: the message you just typed (or, mid-turn, the tool call the model is
+waiting on) is kept verbatim after the summary. So a compaction that fires just as you send an
+instruction cannot swallow it — the model still answers what you asked, and the turn stays in
+the session file, in `/history` and in a later restore.
+
+Because a rollover leaves no trace in the transcript (the old turns really are gone), the
+console says in plain terms what happened — all of it without `--verbose`:
+
+```
+[!] Compacting the conversation: 42 messages -> a summary (51000 tokens in, 8192 reserved for the reply > 52000 budget). The current turn (1 message) is kept verbatim.
+[!] Summary preview: The user asked for a token-based compaction trigger, then fixed ...
+[!] Compacted history_0.json (42 messages) into a summary; history_1.json now starts with 3 messages (summary + 1 kept message).
+```
+
+So you can see *what* was folded away (a preview of the summary itself), *how much* (the
+message count of the segment that was closed), *where it went* (`history_0.json` closed,
+`history_1.json` started) and that nothing you just typed was lost. If the summariser answers
+with an empty summary twice, or the call fails, compaction is abandoned and the note says so
+explicitly — "nothing was lost, but the next request may still be too large" — with the
+transcript and the segment left untouched.
+
 
 ## Serving a model locally
 

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/README.md

@@ -290,6 +290,28 @@ reserve (`--max-tokens`). Unset (default) it is derived from the model's context
 output reserve and a safety margin. Lower it to compact sooner, raise it to compact later — there
 is no message-count cap to configure.
 
+Compaction replaces the older turns with a summary, but it always carries the **turn in flight**
+across the rollover: the message you just typed (or, mid-turn, the tool call the model is
+waiting on) is kept verbatim after the summary. So a compaction that fires just as you send an
+instruction cannot swallow it — the model still answers what you asked, and the turn stays in
+the session file, in `/history` and in a later restore.
+
+Because a rollover leaves no trace in the transcript (the old turns really are gone), the
+console says in plain terms what happened — all of it without `--verbose`:
+
+```
+[!] Compacting the conversation: 42 messages -> a summary (51000 tokens in, 8192 reserved for the reply > 52000 budget). The current turn (1 message) is kept verbatim.
+[!] Summary preview: The user asked for a token-based compaction trigger, then fixed ...
+[!] Compacted history_0.json (42 messages) into a summary; history_1.json now starts with 3 messages (summary + 1 kept message).
+```
+
+So you can see *what* was folded away (a preview of the summary itself), *how much* (the
+message count of the segment that was closed), *where it went* (`history_0.json` closed,
+`history_1.json` started) and that nothing you just typed was lost. If the summariser answers
+with an empty summary twice, or the call fails, compaction is abandoned and the note says so
+explicitly — "nothing was lost, but the next request may still be too large" — with the
+transcript and the segment left untouched.
+
 
 ## Serving a model locally
 

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/mini_code_cli/agent_loop.py

@@ -267,6 +267,42 @@ 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 _plural(count, noun, suffix="s"):
+    """``"1 message"`` / ``"4 messages"`` -- for messages the user reads."""
+    return f"{count} {noun}" + ("" if count == 1 else suffix)
+
+
 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
@@ -1931,8 +2034,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 +2058,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 +2165,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-0.1.1.1 → mini_code_cli-0.1.1.2}/mini_code_cli/ui.py

@@ -739,6 +739,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")

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/mini_code_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.1.1.1
+Version: 0.1.1.2
 Summary: Mini Coding Agent. Allows you to easily experiment with a small coding agent.
 Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -970,6 +970,28 @@ reserve (`--max-tokens`). Unset (default) it is derived from the model's context
 output reserve and a safety margin. Lower it to compact sooner, raise it to compact later — there
 is no message-count cap to configure.
 
+Compaction replaces the older turns with a summary, but it always carries the **turn in flight**
+across the rollover: the message you just typed (or, mid-turn, the tool call the model is
+waiting on) is kept verbatim after the summary. So a compaction that fires just as you send an
+instruction cannot swallow it — the model still answers what you asked, and the turn stays in
+the session file, in `/history` and in a later restore.
+
+Because a rollover leaves no trace in the transcript (the old turns really are gone), the
+console says in plain terms what happened — all of it without `--verbose`:
+
+```
+[!] Compacting the conversation: 42 messages -> a summary (51000 tokens in, 8192 reserved for the reply > 52000 budget). The current turn (1 message) is kept verbatim.
+[!] Summary preview: The user asked for a token-based compaction trigger, then fixed ...
+[!] Compacted history_0.json (42 messages) into a summary; history_1.json now starts with 3 messages (summary + 1 kept message).
+```
+
+So you can see *what* was folded away (a preview of the summary itself), *how much* (the
+message count of the segment that was closed), *where it went* (`history_0.json` closed,
+`history_1.json` started) and that nothing you just typed was lost. If the summariser answers
+with an empty summary twice, or the call fails, compaction is abandoned and the note says so
+explicitly — "nothing was lost, but the next request may still be too large" — with the
+transcript and the segment left untouched.
+
 
 ## Serving a model locally
 

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mini-code-cli"
 # version = { file = "mini_code_cli/__init__.py", attr = "__version__" }
-version = "0.1.1.1"
+version = "0.1.1.2"
 description = "Mini Coding Agent. Allows you to easily experiment with a small coding agent."
 readme = "README.md"
 requires-python = ">=3.10"

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/tests/test_e2e_agent_loop.py

@@ -522,7 +522,7 @@ class CompactionTest(unittest.TestCase):
         messages = self._messages(4)
         out, did_compact, _ = self._compact(
             messages, token_limit=10, current_tokens=50,
-            plan_hook=lambda msgs: msgs.append({"role": "user", "content": "GOAL + PLAN"}))
+            plan_hook=lambda msgs, tail: msgs.append({"role": "user", "content": "GOAL + PLAN"}))
 
         self.assertTrue(did_compact)
         self.assertEqual(out[-1]["content"], "GOAL + PLAN")
@@ -714,6 +714,50 @@ class TokenBudgetCompactionTest(unittest.TestCase):
         # Atomic writes: nothing half-written is left lying around.
         self.assertEqual([n for n in os.listdir(session_dir) if ".tmp." in n], [])
 
+    def test_the_typed_turn_survives_the_rollover(self):
+        """The line typed just before a compaction is still the turn answered.
+
+        The bug: the rollover replaced the transcript with (system, summary), so
+        the user message this step existed to answer was summarised away. The
+        model answered the summary ("Understood. What would you like me to
+        do?"), and the typed line was missing from the live transcript, from the
+        new segment, from the recorder's target and therefore from a restore --
+        from the user's side, they typed an instruction and nothing happened.
+        """
+        session = self._session(max_context_tokens=1)
+        typed = "please fix the parser bug in main.py"
+        session.messages.append({"role": "user", "content": typed})
+
+        self._run_step(session, [
+            ("A summary of the work so far.", [], USAGE),   # the compaction call
+            ("Understood. Fixing the parser.", [], USAGE),  # the step's own call
+        ])
+        session.shutdown()
+
+        # 1) the model was asked to answer the typed line, not the summary.
+        self.assertEqual(session.messages[-2], {"role": "user", "content": typed})
+        self.assertIn("A summary of the work so far.", session.messages[-3]["content"])
+
+        # 2) the recorder's last record reaches it, so /history and /reset can.
+        last = session.summary[-1]
+        self.assertEqual(last["history_file"], session.history_index)
+        self.assertIn(typed, [m.get("content") for m in session._segment_upto(last)])
+
+        # 3) it is in the segment the recorder points at, so a restore has it.
+        session_dir = os.path.join(self.cache_dir, session.unique_id)
+        with open(os.path.join(session_dir, f"history_{last['history_file']}.json"),
+                  "r", encoding="utf-8") as f:
+            segment = json.load(f)
+        self.assertIn(typed, [m.get("content") for m in segment])
+
+        args = make_args(self.workdir, self.cache_dir)
+        args.restore_session = session_dir
+        restored = AgentSession(args, console=silent_console())
+        restored.start_session()
+        self.assertEqual([m.get("content") for m in restored.messages],
+                         [m.get("content") for m in session.messages])
+        self.assertIn(typed, [m.get("content") for m in restored.messages])
+
     def test_the_stale_prompt_report_is_dropped_after_a_rollover(self):
         session = self._session(max_context_tokens=1)
         session.last_prompt_tokens = 12_345

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/tests/test_interactive.py

@@ -941,6 +941,35 @@ class CompactionEdgeCaseTest(unittest.TestCase):
                                    console=self.console())
         return result, stub
 
+    def test_success_reports_what_was_compacted_where_and_what_was_kept(self):
+        """The default (non-verbose) console has to answer the user's questions.
+
+        A rollover leaves no trace in the transcript, so the notes are the only
+        thing the user has: they must say *what* was folded away (a summary
+        preview), *how much* (before -> after), *where it went* (which segment
+        file was closed and which was started) and that the instruction being
+        answered was not lost. All of it is ``warn``, i.e. visible without
+        ``--verbose``.
+        """
+        messages = [{"role": "system", "content": "S"},
+                    {"role": "user", "content": "q"},
+                    {"role": "assistant", "content": "a"},
+                    {"role": "user", "content": "the new instruction"}]
+        (out, did_compact, index), _ = self._compact(
+            messages, ["The user asked a question and got an answer."])
+        text = self.output()
+
+        self.assertTrue(did_compact)
+        self.assertEqual(len(out), 3)            # system + summary + turn in flight
+        # the summary content itself, not just a message count
+        self.assertIn("Summary preview: The user asked a question", text)
+        # how much was folded away, and which segment file it went into
+        self.assertIn("Compacted history_0.json (4 messages) into a summary", text)
+        self.assertIn("history_1.json now starts with 3 messages", text)
+        self.assertIn("summary + 1 kept message", text)
+        # and that the instruction this step is answering survived the rollover
+        self.assertIn("The current turn (1 message) is kept verbatim", text)
+
     def test_compaction_prompt_tolerates_missing_content(self):
         """A tool-call-only turn (content None or absent) must not raise KeyError."""
         messages = [
@@ -972,6 +1001,9 @@ class CompactionEdgeCaseTest(unittest.TestCase):
         self.assertEqual(len(stub.calls), 2)           # exactly one retry
         self.assertEqual(self.stats["llm_calls"], 2)   # both attempts were billed
         self.assertIn("Could not compact history", self.output())
+        # ... and it must say that nothing was lost, not just that it failed.
+        self.assertIn("nothing was lost", self.output())
+        self.assertIn("Keeping all 3 messages and history_0.json", self.output())
 
     def test_empty_summary_then_a_real_one_still_compacts(self):
         """A single empty reply is recovered from by the retry."""
@@ -1002,6 +1034,7 @@ class CompactionEdgeCaseTest(unittest.TestCase):
         self.assertEqual(index, 0)
         self.assertIs(out, messages)
         self.assertIn("Failed to compact history", self.output())
+        self.assertIn("Keeping all 3 messages unchanged", self.output())
 
 
 if __name__ == "__main__":

{mini_code_cli-0.1.1.1 → mini_code_cli-0.1.1.2}/tests/test_tokens.py

@@ -289,9 +289,11 @@ class CompactionTriggerTest(unittest.TestCase):
         self.assertTrue(did_compact)
         self.assertEqual(index, 1)
         # No system prompt to preserve, so the old turns collapse to one summary
-        # turn -- from two ~1k-token messages to one short one.
-        self.assertEqual(len(out), 1)
+        # turn -- plus the second (unanswered) user message, which is the turn in
+        # flight and must reach the model, not just the summariser.
+        self.assertEqual(len(out), 2)
         self.assertIn("A short summary.", out[0]["content"])
+        self.assertEqual(out[1], messages[-1])
         self.assertEqual(self.stats["llm_calls"], 1)
 
     def test_a_large_transcript_under_the_budget_does_not_compact(self):
@@ -365,6 +367,52 @@ class CompactionTriggerTest(unittest.TestCase):
         self.assertEqual(index, 0)
         self.assertEqual(self.stats["llm_calls"], 0)      # no summariser call
 
+    # -- the turn in flight survives the rollover --------------------------
+
+    def test_a_fresh_user_message_is_not_summarised_away(self):
+        """The line just typed must reach the model, not only the summariser.
+
+        Compaction used to return (system, summary) only, so the message the
+        next request was supposed to answer was gone: the model answered the
+        summary instead and the typed line never appeared again.
+        """
+        messages = [{"role": "system", "content": "SYSTEM"},
+                    {"role": "user", "content": "earlier question"},
+                    {"role": "assistant", "content": "earlier answer"},
+                    {"role": "user", "content": "the new instruction"}]
+        out, did_compact, _ = self._compact(
+            messages, token_limit=1_000, current_tokens=4_000)
+
+        self.assertTrue(did_compact)
+        self.assertEqual([m["role"] for m in out], ["system", "user", "user"])
+        self.assertIn("A short summary.", out[1]["content"])
+        self.assertEqual(out[2], {"role": "user", "content": "the new instruction"})
+
+    def test_a_tool_exchange_in_flight_is_carried_over(self):
+        """Compacting mid tool loop keeps the call *and* the result it awaits."""
+        messages = [{"role": "system", "content": "SYSTEM"},
+                    {"role": "user", "content": "read the file"},
+                    {"role": "assistant", "content": "", "tool_calls": [{"id": "c1"}]},
+                    {"role": "tool", "tool_call_id": "c1", "content": "file contents"}]
+        out, did_compact, _ = self._compact(
+            messages, token_limit=1_000, current_tokens=4_000)
+
+        self.assertTrue(did_compact)
+        self.assertEqual([m["role"] for m in out],
+                         ["system", "user", "user", "assistant", "tool"])
+        self.assertEqual(out[-1]["content"], "file contents")
+
+    def test_an_answered_turn_adds_nothing(self):
+        """A transcript ending in an assistant reply has no turn in flight."""
+        messages = [{"role": "system", "content": "SYSTEM"},
+                    {"role": "user", "content": "question"},
+                    {"role": "assistant", "content": "answer"}]
+        out, did_compact, _ = self._compact(
+            messages, token_limit=1_000, current_tokens=4_000)
+
+        self.assertTrue(did_compact)
+        self.assertEqual([m["role"] for m in out], ["system", "user"])
+
     # -- unchanged behaviour ----------------------------------------------
 
     def test_an_explicit_limit_is_honoured(self):
@@ -389,11 +437,14 @@ class CompactionTriggerTest(unittest.TestCase):
     def test_the_plan_hook_still_reinjects_the_goal_and_plan(self):
         out, did_compact, _ = self._compact(
             long_messages(2, 8_000), token_limit=1_000, current_tokens=4_000,
-            plan_hook=lambda msgs: msgs.append(
+            plan_hook=lambda msgs, tail: msgs.append(
                 {"role": "user", "content": "GOAL + PLAN"}))
 
         self.assertTrue(did_compact)
-        self.assertEqual(out[-1]["content"], "GOAL + PLAN")
+        # The goal/plan context sits between the summary and the live turn, so
+        # the user's actual instruction stays the last thing the model reads.
+        self.assertEqual(out[1]["content"], "GOAL + PLAN")
+        self.assertEqual(out[2]["role"], "user")          # the in-flight turn
 
     def test_an_empty_summary_keeps_the_transcript_and_the_segment(self):
         messages = long_messages(2, 8_000)