mini-code-cli 0.1.0.1__tar.gz → 0.1.0.3__tar.gz

{mini_code_cli-0.1.0.1 → mini_code_cli-0.1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.1.0.1
+Version: 0.1.0.3
 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
@@ -720,7 +720,8 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - allowed-dir: this specifies which dirs the agent can read and write from, that does not stop the shell comands! (though dangerous shell commands are still blocked by the classifier above).
 - ask-permission: asks user permission before every tool call. For shell commands, commands in the ALLOW tier skip the prompt, DENY is blocked, and ASK always prompts.
 - system-prompt: you can override the default prompt by using a string. (Note: Agent.md is always appended after the system prompt.)
-- load-last-session: instead of starting a fresh conversation, automatically continue your most recently active session (the one whose history was last modified) from the default cache dir. It resumes under a brand-new session id, so the original session is never overwritten. An explicit `--restore-session` (a specific path) takes precedence if both are given.
+- load-last-session: instead of starting a fresh conversation, automatically continue your most recently active session from the default cache dir. It resumes under a brand-new session id, so the original session is never overwritten. An explicit `--restore-session` (a specific path) takes precedence if both are given. The "most recent" session is resolved in two steps: at the end of every interactive session, its path is recorded in a tiny `.mini/last_session.json` pointer inside the `--allowed-dir`, and `--load-last-session` consults that pointer first; only if there is no pointer (e.g. a fresh allowed dir, or the `--skills` feature disabled) does it fall back to the timestamp heuristic (the session whose history was modified most recently). The `.mini` pointer is the same directory the `--skills` feature uses, but it is a single dedicated file, so the two never clash.
+- **Interactive session offer:** if a previous session exists in the cache dir but you did **not** explicitly ask to resume one (i.e. neither `--load-last-session` nor `--restore-session` was passed), the prompt asks what you'd like to do before the conversation starts: 1) **Resume** the previous session (splice its history in under a brand-new session id and continue it), 2) **Start a new** session (empty history), or 3) **Exit** (start nothing). Ctrl-C / EOF at the offer is treated as a graceful exit. This is distinct from `--load-last-session`, which silently resumes the most recent session without asking.
 - plan: `--plan` enables **plan mode**. The agent now keeps two tracking files in the session directory: `CURRENT_GOAL.md` (the user's latest instruction) and `CURRENT_PLAN.md` (its own step-by-step plan, which it must update as it works and mark finished once the goal is done). The system message gets an extra instruction telling the agent to do this. Plan mode also changes how history compaction works: after the history is compacted to a summary, the current `CURRENT_PLAN.md` and the user's last instruction (`CURRENT_GOAL.md`) are re-injected into the messages so the agent keeps working against the same goal. When the session ends, the active goal is marked finished in `CURRENT_PLAN.md`.
 
 ### Available tools

{mini_code_cli-0.1.0.1 → mini_code_cli-0.1.0.3}/README.md

@@ -46,7 +46,8 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - allowed-dir: this specifies which dirs the agent can read and write from, that does not stop the shell comands! (though dangerous shell commands are still blocked by the classifier above).
 - ask-permission: asks user permission before every tool call. For shell commands, commands in the ALLOW tier skip the prompt, DENY is blocked, and ASK always prompts.
 - system-prompt: you can override the default prompt by using a string. (Note: Agent.md is always appended after the system prompt.)
-- load-last-session: instead of starting a fresh conversation, automatically continue your most recently active session (the one whose history was last modified) from the default cache dir. It resumes under a brand-new session id, so the original session is never overwritten. An explicit `--restore-session` (a specific path) takes precedence if both are given.
+- load-last-session: instead of starting a fresh conversation, automatically continue your most recently active session from the default cache dir. It resumes under a brand-new session id, so the original session is never overwritten. An explicit `--restore-session` (a specific path) takes precedence if both are given. The "most recent" session is resolved in two steps: at the end of every interactive session, its path is recorded in a tiny `.mini/last_session.json` pointer inside the `--allowed-dir`, and `--load-last-session` consults that pointer first; only if there is no pointer (e.g. a fresh allowed dir, or the `--skills` feature disabled) does it fall back to the timestamp heuristic (the session whose history was modified most recently). The `.mini` pointer is the same directory the `--skills` feature uses, but it is a single dedicated file, so the two never clash.
+- **Interactive session offer:** if a previous session exists in the cache dir but you did **not** explicitly ask to resume one (i.e. neither `--load-last-session` nor `--restore-session` was passed), the prompt asks what you'd like to do before the conversation starts: 1) **Resume** the previous session (splice its history in under a brand-new session id and continue it), 2) **Start a new** session (empty history), or 3) **Exit** (start nothing). Ctrl-C / EOF at the offer is treated as a graceful exit. This is distinct from `--load-last-session`, which silently resumes the most recent session without asking.
 - plan: `--plan` enables **plan mode**. The agent now keeps two tracking files in the session directory: `CURRENT_GOAL.md` (the user's latest instruction) and `CURRENT_PLAN.md` (its own step-by-step plan, which it must update as it works and mark finished once the goal is done). The system message gets an extra instruction telling the agent to do this. Plan mode also changes how history compaction works: after the history is compacted to a summary, the current `CURRENT_PLAN.md` and the user's last instruction (`CURRENT_GOAL.md`) are re-injected into the messages so the agent keeps working against the same goal. When the session ends, the active goal is marked finished in `CURRENT_PLAN.md`.
 
 ### Available tools

{mini_code_cli-0.1.0.1 → mini_code_cli-0.1.0.3}/mini_code_cli/agent_loop.py

@@ -52,6 +52,7 @@ from .persistence import (
     load_summary_from_dir,
     load_usage_from_dir,
     find_last_session_dir,
+    save_last_session_pointer,
     accumulate_usage,
     generate_unique_id,
     _restore_dir,
@@ -137,6 +138,7 @@ def parse_args():
         args.enable_shell = True
         args.sudo = True
         args.auto_mode = True
+        args.skills = True
     
     if args.all_last:
         args.load_last_session = True
@@ -288,36 +290,10 @@ class AgentSession:
         self.model = model_name if model_name else args.model
         self.api_key = args.api_key if args.api_key else os.environ.get("MINI_CODE_API_KEY", "")
 
-        # Which tools the LLM may call. The shell tool is only available when
-        # --enable-shell was passed.
-        forbidden = None if args.enable_shell else tools.shell_tools
-        self.tools_dict = tools.util_get_tools_dict(forbidden_tools=forbidden)
-        self.llm_tools = tools.util_get_tools(forbidden_tools=forbidden)
-
-        # Sub-agents (opt-in via --enable-subagents). Each registered sub-agent
-        # becomes an extra tool the model can call; see subagents/. A child
-        # session built by a sub-agent never sets enable_subagents, so sub-agents
-        # cannot recursively spawn sub-agents.
-        self.enable_subagents = bool(getattr(args, "enable_subagents", False))
-        self.subagents_registry = subagents.get_registry() if self.enable_subagents else {}
-        for sa in self.subagents_registry.values():
-            self.llm_tools.append(sa.tool_schema())
-            # Marked so _run_one_tool_call knows to delegate rather than call a
-            # real function.
-            self.tools_dict[sa.name] = {"function": None, "description": sa.description, "subagent": True}
-
-        # Skills (opt-in via --skills). Each registered skill tool is exposed to
-        # the model as a normal tool, but they are all sandbox-safe: the .mini
-        # directory lives *inside* --allowed-dir and the tools never accept a
-        # path from the model -- skill / script names are validated as single
-        # path segments and resolved under the .mini root. So skills are exposed
-        # even in sessions without --enable-shell (run_skill only executes a
-        # named Python file, never a free-form shell command).
-        self.enable_skills = bool(getattr(args, "enable_skills", False))
-        if self.enable_skills:
-            self.skills_tools_dict = skills.get_skills_tools_dict(self.allowed_dir)
-            self.llm_tools.extend(skills.get_skills_tools(self.allowed_dir))
-            self.tools_dict.update(self.skills_tools_dict)
+        # Which tools the LLM may call (shell / sub-agents / skills), and which
+        # of them are registered. Split out of __init__ for readability -- see
+        # _register_tools().
+        self._register_tools(args)
 
         # Token accounting for the whole session.
         self.token_stats = {
@@ -365,25 +341,47 @@ class AgentSession:
         # cache dir and continues it -- exactly like --restore-session, but without
         # needing to know the folder name. An explicit --restore-session always wins
         # and is used verbatim; otherwise the newest session is resolved here.
+        # A "last session" candidate -- only when the user did NOT explicitly
+        # ask to resume one (no --load-last-session / --restore-session): the
+        # most recent previous session in the cache dir. Unlike a real restore,
+        # the conversation starts empty here and is only spliced in if the user
+        # confirms they want it (see _offer_resume_last_session).
         restore_session = getattr(self.args, "restore_session", None)
+        self.last_session_candidate = None
         self.loaded_last_session_dir = None
-        if getattr(self.args, "load_last_session", False) and not restore_session:
-            detected = find_last_session_dir(self.cache_dir)
-            if detected:
-                restore_session = detected
-                self.loaded_last_session_dir = detected
+        # Resolve the "most recent session" exactly once, and reuse the result
+        # for both concerns below (an explicit --restore-session always wins and
+        # is used verbatim):
+        #   * --load-last-session turns the detected session into a real restore
+        #     (continue it under this new id), OR
+        #   * when the user did NOT explicitly ask to resume (no
+        #     --load-last-session / --restore-session), it becomes a resume
+        #     *candidate* that run() offers interactively (see
+        #     _offer_resume_last_session). The conversation still starts empty
+        #     here and is spliced in only if the user confirms.
+        # Skipped entirely once a real restore is already in hand, so those paths
+        # never offer anything.
+        detected = self._detect_last_session()
+        if getattr(self.args, "load_last_session", False) and not restore_session and detected:
+            restore_session = detected
+            self.loaded_last_session_dir = detected
+        if not restore_session and detected:
+            self.last_session_candidate = detected
         restore_directory = _restore_dir(restore_session)
         restored = load_history_from_dir(restore_directory) if restore_directory else None
+        # A session built from an explicit restore / load-last-session reuses the
+        # restored history (under this brand-new id, so the original is never
+        # overwritten); an idle start keeps the freshly built initial messages.
         self.messages = restored if restored is not None else self._build_initial_messages()
-        if restored is not None:
-            self._restore_usage_if_available(restore_session)
-            self._load_summary_if_restored(restore_directory)
-        else:
-            # --load-last-session asked for a session but nothing usable was found:
-            # don't advertise a load. The recorder starts empty and the first
-            # assistant / tool-call turn seeds turn 1 -- mirroring the restore
-            # path, which also has no leading system turn, so /history turn
-            # numbers stay consistent whether or not we restored.
+        self._restore_from(restore_directory, restored)
+        # --load-last-session asked for a session but nothing usable was found:
+        # clear the flag so run() reports "no previous session to load" instead
+        # of pretending it resumed one. When the restore succeeded the flag set
+        # above (loaded_last_session_dir = detected) is kept so run() prints the
+        # "Loaded most recent session ... and continuing it" note. Best-effort:
+        # a missing/empty/corrupt history falls back to a fresh session rather
+        # than crashing.
+        if restored is None:
             self.loaded_last_session_dir = None
 
         # Snapshot the initial (or restored) messages as the first history segment
@@ -392,6 +390,56 @@ class AgentSession:
         save_history(self.messages, self.cache_dir, self.unique_id, self.history_index)
         save_summary(self.summary, self.cache_dir, self.unique_id)
 
+    def _detect_last_session(self):
+        """Resolve the most recent previous session dir, once.
+
+        Consults the .mini pointer recorded under --allowed-dir first (an
+        explicit record of the last session worked in), then falls back to the
+        timestamp heuristic over the cache dir. Returns the path, or None. The
+        constructor calls this a single time so the (relatively expensive)
+        pointer / directory scan does not run twice for the two independent
+        concerns -- --load-last-session vs. the interactive resume candidate.
+        """
+        return find_last_session_dir(
+            self.cache_dir,
+            allowed_dir=self.allowed_dir,
+            use_pointer=True,
+        )
+
+    def _register_tools(self, args):
+        """Wire up which tools the LLM may call, and register the opt-in ones.
+
+        Base tools depend on --enable-shell (the shell tool is withheld unless
+        shell is explicitly on). Then two opt-in features each add their own
+        sandbox-safe tools:
+
+          * Sub-agents (--enable-subagents): every registered sub-agent becomes
+            an extra tool. Its tools_dict entry has ``function=None`` so
+            _run_one_tool_call knows to *delegate* to a nested session rather
+            than call a real function. A child session never sets
+            enable_subagents, so sub-agents cannot recursively spawn sub-agents.
+          * Skills (--skills): the .mini directory (inside --allowed-dir) exposes
+            list/read/create/run_skill tools. They are sandbox-safe -- names are
+            validated as single path segments and resolved under .mini, so they
+            never accept an arbitrary path from the model and are usable even
+            without --enable-shell.
+        """
+        forbidden = None if args.enable_shell else tools.shell_tools
+        self.tools_dict = tools.util_get_tools_dict(forbidden_tools=forbidden)
+        self.llm_tools = tools.util_get_tools(forbidden_tools=forbidden)
+
+        self.enable_subagents = bool(getattr(args, "enable_subagents", False))
+        self.subagents_registry = subagents.get_registry() if self.enable_subagents else {}
+        for sa in self.subagents_registry.values():
+            self.llm_tools.append(sa.tool_schema())
+            self.tools_dict[sa.name] = {"function": None, "description": sa.description, "subagent": True}
+
+        self.enable_skills = bool(getattr(args, "enable_skills", False))
+        if self.enable_skills:
+            self.skills_tools_dict = skills.get_skills_tools_dict(self.allowed_dir)
+            self.llm_tools.extend(skills.get_skills_tools(self.allowed_dir))
+            self.tools_dict.update(self.skills_tools_dict)
+
     def _build_initial_messages(self):
         """Assemble the system prompt and optional Agent.md into the first turns."""
         if self.args.system_prompt:
@@ -457,6 +505,28 @@ class AgentSession:
                 self.summary.append({"turn": turn, "what": "assistant",
                                      "history_file": 0, "index": i})
 
+    def _restore_from(self, directory, messages=None):
+        """Seed usage, recorder and messages for a restore under this id.
+
+        Shared by the constructor (for an explicit ``--restore-session`` /
+        ``--load-last-session``) and the interactive resume prompt. The caller
+        resolves and loads ``directory`` itself, then hands the loaded
+        ``messages`` here so all seeding lives in one place.
+
+        ``usage.json`` is layered *on top* of the in-memory totals (so a restore
+        under a brand-new session id accumulates cleanly), the recorder is
+        flattened across the segment boundary so ``/history`` / ``/reset`` stay
+        consistent, and ``self.messages`` becomes the restored snapshot.
+        Best-effort: a missing directory / unreadable files leave the session
+        unchanged (a fresh, empty history).
+        """
+        restored = messages if messages is not None else (
+            load_history_from_dir(directory) if directory else None)
+        self._restore_usage_if_available(directory)
+        self._load_summary_if_restored(directory)
+        if restored:
+            self.messages = restored
+
     def _record_turn(self, what, messages, history_index=None):
         """Append one entry to the high-level recorder.
 
@@ -575,16 +645,95 @@ class AgentSession:
                 f"Sub-agents enabled ({len(self.subagents_registry)} available: "
                 f"{', '.join(self.subagents_registry)}).", "info")
 
+    def _offer_resume_last_session(self):
+        """Offer to continue the most recent previous session, if one exists.
+
+        Only reached when the user did *not* already ask to resume a session
+        (``--load-last-session`` / ``--restore-session``), which resolve their
+        own before this and leave ``last_session_candidate`` unset. When a
+        candidate exists the user chooses between three outcomes:
+
+          * **Resume** -- splice the previous session's history into this one
+            (still under the brand-new id) and continue it, under a new id.
+          * **New** -- leave the conversation empty and start a fresh session.
+          * **Exit** -- stop here before any pointer is written or loop enters.
+
+        The choice is recorded by setting/clearing ``self.last_session_candidate``:
+        ``resume`` keeps it pointing at the previous session's directory (the
+        caller in :meth:`run` performs the restore); ``new`` clears it (nothing
+        to restore). Returns True when the user chose to exit so the caller
+        returns before writing any pointer or entering the loop.
+        """
+        if not self.last_session_candidate:
+            return False
+        choice = self._resume_choice()
+        if choice == "resume":
+            return False  # keep the candidate: run() restores it below.
+        # "new" -> clear the candidate (nothing to restore); "exit" -> clear
+        # and tell the caller to stop before writing a pointer / entering the
+        # loop.
+        self.last_session_candidate = None
+        return choice == "exit"
+
+    def _resume_choice(self):
+        """Prompt for the resume choice and return its label.
+
+        Returns one of ``"resume"``, ``"new"`` or ``"exit"``. The prompt
+        degrades cleanly on a non-TTY / piped console: an EOF / Ctrl-C (``read_line``
+        returns None) is treated as ``"exit"`` so the loop never spins on unread input.
+        """
+        self.console.emit(
+            self.console.style(
+                "A previous session was found. What would you like to do?", dim=True,
+                fg="cyan"))
+        self.console.emit("  1) Resume the previous session (continue where you left off)")
+        self.console.emit("  2) Start a new session (empty history)")
+        self.console.emit("  3) Exit (start nothing)")
+        while True:
+            answer = self.console.read_line(
+                self.console.style("Resume previous session? Type 1, 2, or 3: ", fg="cyan"))
+            if answer is None:
+                # EOF / Ctrl-C at the offer -> graceful exit, no session written.
+                return "exit"
+            choice = answer.strip().lower()
+            if choice in ("1", "resume"):
+                return "resume"
+            if choice in ("2", "new"):
+                return "new"
+            if choice in ("3", "exit"):
+                return "exit"
+            self.console.note("Please choose 1, 2, or 3.", "warn")
+
     def run(self, initial_prompt=None):
         """Drive the agent loop until the user quits."""
         self.print_announcements()
         print_welcome(self.allowed_dir, self.server_url, self.args,
                       self.unique_id, self.cache_dir, self.model)
 
+        # A previous session exists but the user did not explicitly ask to
+        # resume it. Offer them a choice; on "exit" we return here before
+        # writing any pointer or entering the loop, and we splice the
+        # restored history into this session if they pick "resume".
+        if self._offer_resume_last_session():
+            return
+        if self.last_session_candidate is not None:
+            restored_dir = self.last_session_candidate
+            self.last_session_candidate = None
+            restored = load_history_from_dir(restored_dir)
+            self._restore_from(restored_dir, restored)
+            self.loaded_last_session_dir = restored_dir
+
         # Announce the session's unique id as an assistant-styled message so the
         # user can see / copy the id this conversation is being saved under.
         self._print_session_id()
 
+        # Record this session as the "latest" so a future --load-last-session can
+        # resume it without scanning the cache dir. This lives in the top-level
+        # loop's own directory (cache_dir/unique_id), and only the interactive
+        # run() writes it -- a sub-agent child drives via _drive_auto and would
+        # otherwise overwrite the pointer with its own buried path.
+        self._save_last_session_pointer()
+
         # Report the outcome of --load-last-session up front, so the user sees
         # whether we resumed an earlier conversation (under a brand-new id) or
         # started fresh because no previous session was found.
@@ -616,6 +765,7 @@ class AgentSession:
                 # 1) Get the user's turn: the one-shot preset, or a fresh line.
                 if pending is not None:
                     self.console.rule(title="Preset prompt", char="=", fg="cyan")
+                    self.console.short_divider()
                     self.console.turn("You", pending, accent="cyan")
                     user_input = pending
                     pending = None
@@ -643,7 +793,8 @@ class AgentSession:
                     self._persist()
                     if not should_continue:
                         break
-                    self.console.note("Continuing with LLM calls until no more tool calls.", "info")
+                    self.console.note(
+                        "Continuing with LLM calls until no more tool calls.", "info")
             except _Abort:
                 # Ctrl-C during a permission prompt already shut the session
                 # down; just unwind the loop quietly.
@@ -654,18 +805,24 @@ class AgentSession:
                 self._persist()
 
     def _print_session_id(self):
-        """Print the session's unique id as an assistant-styled message.
+        """Print the session's unique id as a minimal "Assistant" turn.
 
-        A short, styled announcement (in the assistant accent) so the user can
-        see and copy the id the conversation is saved under -- the same id shown
-        in the welcome banner, but rendered as a transcript turn so it is easy
-        to spot and grep.
+        Instead of a banner/header the id is rendered as an assistant-styled
+        (green) turn carrying *only* the id in brackets, so the user can see /
+        copy the id this conversation is being saved under without the noise of
+        the extra "saved under" line.
         """
-        self.console.divider()
-        self.console.turn(
-            "Session id",
-            f"{self.unique_id}  (saved under {self.cache_dir})",
-            accent="green")
+        self.console.turn("Assistant", f"[{self.unique_id}]", accent="green")
+
+    def _save_last_session_pointer(self):
+        """Record this session's directory in --allowed-dir/.mini.
+
+        Writes the .mini pointer that a later --load-last-session consults first
+        (see save_last_session_pointer). Best-effort: never raises, so a pointer
+        hiccup can never break the interactive session.
+        """
+        save_last_session_pointer(self.allowed_dir,
+                                  os.path.join(self.cache_dir, self.unique_id))
 
     # -- autonomous drive (used by sub-agents) ------------------------------
 
@@ -832,7 +989,12 @@ class AgentSession:
     # -- interactive input -------------------------------------------------
 
     def _read_user_line(self):
-        """Read one turn from the user. Returns the text to send, or None to quit."""
+        """Read one turn from the user. Returns the text to send, or None to quit.
+
+        An empty (blank) line is not a real instruction, so it is ignored and the
+        user is asked again rather than sending an empty turn to the model.
+        """
+        self.console.short_divider()
         user_input = self.console.read_line(style_line_prompt("You:"))
         if user_input is None:  # EOF / Ctrl-C at the prompt
             self.console.note("Thank you. Goodbye! Saving history...", "info")
@@ -847,6 +1009,12 @@ class AgentSession:
             # Nothing to send to the model; ask again.
             return self._read_user_line()
 
+        # A blank line carries no instruction: say so and re-prompt instead of
+        # appending an empty user turn and spending an LLM call on it.
+        if not user_input.strip():
+            self.console.note("No input. (Type /help for commands, /quit to exit.)", "warn")
+            return self._read_user_line()
+
         return user_input
 
     def _handle_command(self, user_input):

{mini_code_cli-0.1.0.1 → mini_code_cli-0.1.0.3}/mini_code_cli/persistence.py

@@ -24,6 +24,7 @@ raising.
 import json
 import os
 import re
+import time
 
 from . import ui
 from .config import DEFAULT_CACHE_LOCATION
@@ -76,8 +77,112 @@ def generate_unique_id():
     return f"{timestamp}-{uuid.uuid4().hex[:8]}"
 
 
-def find_last_session_dir(cache_dir):
-    """Return the path to the most recently *active* session dir under ``cache_dir``.
+# ---------------------------------------------------------------------------
+# latest-session pointer (.mini)
+# ---------------------------------------------------------------------------
+
+# The .mini directory (inside the user's --allowed-dir) holds a tiny pointer to
+# the most recent session. --load-last-session consults this pointer *first*
+# (an explicit opt-in the user's environment recorded) before falling back to
+# the timestamp heuristic in find_last_session_dir().
+#
+# NOTE: .mini is also the skills feature's directory. The pointer is a single
+# dedicated file inside it (LAST_SESSION_FILENAME), so the two never collide and
+# the skills code (which only reads <skill-name>/ + SKILLS.md) is unaffected.
+SKILLS_DIRNAME = ".mini"
+LAST_SESSION_FILENAME = "last_session.json"
+
+
+def _last_session_dir_store(allowed_dir):
+    """Return the .mini directory for ``allowed_dir`` (creating it if needed).
+
+    Best-effort: never raises. Returns None if the directory cannot be ensured,
+    in which case the pointer is simply not consulted/updated.
+    """
+    if not allowed_dir:
+        return None
+    store = os.path.join(os.path.abspath(allowed_dir), SKILLS_DIRNAME)
+    try:
+        os.makedirs(store, exist_ok=True)
+        return store
+    except OSError as e:
+        ui.console.note(f"Could not use {store} for the latest-session pointer: {e}", "warn")
+        return None
+
+
+def save_last_session_pointer(allowed_dir, session_dir):
+    """Record ``session_dir`` as the latest session in ``allowed_dir/.mini``.
+
+    Writes a tiny JSON file (the absolute path plus a timestamp) so a later
+    --load-last-session run can resume the most recent session without scanning
+    the cache dir. Best-effort: never raises, returns the written path or None.
+    """
+    if not session_dir:
+        return None
+    store = _last_session_dir_store(allowed_dir)
+    if store is None:
+        return None
+    payload = {
+        "session_dir": os.path.abspath(session_dir),
+        "recorded_at": time.time(),
+    }
+    path = os.path.join(store, LAST_SESSION_FILENAME)
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(payload, f, indent=2)
+        return path
+    except OSError as e:
+        ui.console.note(f"Could not record latest-session pointer: {e}", "warn")
+        return None
+
+
+def load_last_session_pointer(allowed_dir):
+    """Read the latest-session pointer recorded under ``allowed_dir/.mini``.
+
+    Returns the recorded session directory (a path into the cache folder), or
+    None if no pointer exists or it cannot be read. Best-effort: a missing or
+    malformed pointer simply yields None so the caller falls back to the
+    timestamp heuristic.
+    """
+    if not allowed_dir:
+        return None
+    store = os.path.join(os.path.abspath(allowed_dir), SKILLS_DIRNAME)
+    path = os.path.join(store, LAST_SESSION_FILENAME)
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            payload = json.load(f)
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    session_dir = payload.get("session_dir")
+    if not session_dir or not os.path.isdir(session_dir):
+        return None
+    return session_dir
+
+
+def find_last_session_dir(cache_dir=None, allowed_dir=None, use_pointer=True):
+    """Return the path to the most recently *active* session dir.
+
+    When ``use_pointer`` and an ``allowed_dir`` are given, the .mini pointer
+    recorded by a previous run (see save_last_session_pointer) is consulted
+    *first* -- it is an explicit record of the session the user last worked in.
+    Only if that yields nothing do we fall back to the timestamp heuristic over
+    ``cache_dir`` (find_last_session_dir_by_mtime). Session folders with no
+    files are ignored. Never raises: a missing/unreadable cache dir simply
+    yields None.
+    """
+    if use_pointer and allowed_dir:
+        pointed = load_last_session_pointer(allowed_dir)
+        if pointed:
+            return pointed
+    return find_last_session_dir_by_mtime(cache_dir)
+
+
+def find_last_session_dir_by_mtime(cache_dir):
+    """Timestamp heuristic for the most recently *active* session dir.
 
     "Most recent" is decided by the newest modification time of any file inside
     each session folder (a session rewrites its ``history_{n}.json`` every step),

{mini_code_cli-0.1.0.1 → mini_code_cli-0.1.0.3}/mini_code_cli/runner.py

@@ -21,10 +21,10 @@ class _TimedOut(Exception):
 def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_TOOL_TIMEOUT):
     """Call ``func(**tool_params)``, aborting after ``timeout_seconds``.
 
-    On timeout, returns a friendly ``Error:`` string (so the agent sees the
-    failure as a tool result rather than crashing). Any *other* exception the
-    tool raises is allowed to propagate -- the tool authors are responsible for
-    returning ``Error`` strings, and surfacing genuine bugs here is intentional.
+    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.
     """
     def _handler(signum, frame):
         raise _TimedOut()
@@ -33,8 +33,9 @@ def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_
         previous = signal.signal(signal.SIGALRM, _handler)
     except (ValueError, OSError):
         # 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.
-        return func(**tool_params)
+        # 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)
 
     signal.alarm(int(timeout_seconds) if timeout_seconds else 0)
     try:
@@ -42,6 +43,22 @@ def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_
     except _TimedOut:
         ui.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")
+        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):
+    """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).
+    """
+    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")
+        return f"Error: tool {name} raised an error: {e}"

{mini_code_cli-0.1.0.1 → mini_code_cli-0.1.0.3}/mini_code_cli/ui.py

@@ -371,6 +371,16 @@ class Console:
         """
         self.emit(self.style("-" * self.width, fg="gray", dim=True))
 
+    def short_divider(self, char="-", width=8, fg="gray"):
+        """Render a short horizontal delimiter line (not the full width).
+
+        Used to set off the user's own "You:" turn from the preceding assistant
+        reply with a light, unobtrusive rule rather than a full-width divider.
+        Defaults to a plain ASCII dash so it renders consistently regardless of
+        the console's unicode setting.
+        """
+        self.emit(self.style(char * width, fg=fg, dim=True))
+
     def clear_screen(self):
         """Clear the terminal and move the cursor to the top-left.