scootcli 0.4.0__tar.gz → 0.6.0__tar.gz

{scootcli-0.4.0/src/scootcli.egg-info → scootcli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.4.0
+Version: 0.6.0
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -135,7 +135,7 @@ Write your own rules in `~/.config/scoot/router.json` (or the file named by `SCO
   ],
   "default": "ollama/llama3.2",
   "classifier": {
-    "model": "ollama/llama3.2",
+    "model": "openai/gpt-5-mini",
     "tiers": {"simple": "ollama/llama3.2", "coding": "openai/gpt-5.3-codex", "hard": "anthropic/claude-opus-5"}
   }
 }
@@ -145,7 +145,7 @@ Conditions: `complex`, `has_images`, `needs_tools`, `est_tokens_over`, `prompt_m
 The optional `classifier` asks a small model one question per turn ("simple, coding, or hard?") and maps the answer to a tier; it adds a short call, and any failure falls through to the rules.
 Expect it to be rough with a 3B local model: on a hand-labelled set of seven prompts, `llama3.2` and `qwen2.5` each got four right, mostly confusing "coding" with "hard".
 The rules are deterministic, so put the decisions you care about there, and if you want a better judge, name a cheap hosted model as the classifier (`openai/gpt-5-mini`), which costs a few hundred tokens per turn.
-`/route` shows the rules in force and why the current model was picked; `/status` shows tokens per model.
+`/route` shows the rules in force and why the current model was picked; `/status` shows tokens, cached tokens, and cost per model, from the list prices in `pricing.py` (stamped with the date they were last checked; unknown models show `?`).
 `SCOOT_EFFORT` (`low` | `medium` | `high` | `xhigh`, default `medium`) sets the reasoning effort for models that take it, on both OpenAI and Anthropic.
 On Claude Opus 5 the server-side refusal fallback is requested by default, so a declined request is retried on another Claude model inside the same call; `SCOOT_ANTHROPIC_FALLBACKS=0` turns that off.
 
@@ -206,6 +206,8 @@ scoot --no-panel --no-dock           # plain prompt, no status bar (also what yo
 /model     list or switch model     /approve   set mode (always|auto-read|auto-edits|yolo)
 /yolo      auto-approve all         /worktree  isolate work in a git worktree
 /auth      provider keys            /logo      show or toggle the mascot
+/scope     where file tools may go   /hooks     configured hooks and results
+/route     how auto picks a model
 /sessions  list saved sessions      /resume    resume a saved session ([id])
 /forget    delete session(s)        /panel     toggle the bottom status bar
 /verbosity feed detail (full|compact|quiet)
@@ -213,6 +215,7 @@ scoot --no-panel --no-dock           # plain prompt, no status bar (also what yo
 ```
 
 Press **ESC** while a turn is running to interrupt it; the conversation is kept.
+Press **Ctrl-N** while a turn is running to add a note: scoot asks for one line at the next model call and the model sees it before continuing ("use pytest, not unittest").
 Type `/` and press **Tab** to complete slash commands.
 
 **Terminals.** scoot works in macOS Terminal, iTerm2, and inside tmux; the status bar uses a scroll region, the input dock uses raw mode, and clipboard copy uses the system tool or an OSC-52 escape.
@@ -223,7 +226,11 @@ Without a TTY, scoot falls back to a plain prompt with no bar and no dock.
 ### Tools and approvals
 
 The agent has eight tools: `read_file`, `list_dir`, `search`, `write_file`, `edit_file`, `run_shell`, `open_editor` (hands a file to IntelliJ IDEA's `idea -e` or to VS Code, `SCOOT_EDITOR` picks), and `update_plan` (a progress checklist for multi-step work).
-Every tool is sandboxed to the workspace root.
+Paths are resolved against the workspace root, and `~` works.
+
+The workspace is where the agent works, not a wall.
+When a tool needs a file outside it, in `~/.config`, another repo, `/etc`, scoot asks once: allow this path `[a]`, allow that directory for the session `[d]`, allow anywhere for the session `[A]`, skip `[s]`, or quit `[q]`.
+`--scope anywhere`, `SCOOT_SCOPE=anywhere`, or `/scope anywhere` skip the question; `/scope` shows what has been granted.
 
 When a call needs approval you can approve once `[a]`, trust that tool for the session `[t]`, approve everything this session `[A]`, edit the arguments `[e]`, skip `[s]`, or quit `[q]`.
 `/approve <mode>` sets how much runs without asking: `always` prompts for everything, `auto-read` auto-approves reads, `auto-edits` also auto-approves file edits, `yolo` runs everything.
@@ -275,6 +282,9 @@ git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e
 ```
 
 The install script needs only `curl` and Python 3.9+. `SCOOT_VERSION=v0.2.0` pins a release and `SCOOT_INSTALL_DIR` changes the target; read it before you run it, it is sixty lines.
+**Upgrading.** `pipx upgrade scootcli`, or `pip install --upgrade scootcli`, or rerun the curl line, which always fetches the latest release; `scoot --version` shows what you have, and `scoot --check-update` asks PyPI whether a newer one exists. With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
+`bash install.sh --uninstall` removes the command installed by the script (pipx users: `pipx uninstall scootcli`); config and sessions stay.
+
 Both pipx and the script install into `~/.local/bin`. On a fresh Linux account that directory is added to PATH at login only if it already exists, so after the very first install either open a new login shell or run `pipx ensurepath`; the installer prints the exact line for your shell.
 
 Requirements: Python 3.9 or newer on macOS or Linux.

{scootcli-0.4.0 → scootcli-0.6.0}/README.md

@@ -110,7 +110,7 @@ Write your own rules in `~/.config/scoot/router.json` (or the file named by `SCO
   ],
   "default": "ollama/llama3.2",
   "classifier": {
-    "model": "ollama/llama3.2",
+    "model": "openai/gpt-5-mini",
     "tiers": {"simple": "ollama/llama3.2", "coding": "openai/gpt-5.3-codex", "hard": "anthropic/claude-opus-5"}
   }
 }
@@ -120,7 +120,7 @@ Conditions: `complex`, `has_images`, `needs_tools`, `est_tokens_over`, `prompt_m
 The optional `classifier` asks a small model one question per turn ("simple, coding, or hard?") and maps the answer to a tier; it adds a short call, and any failure falls through to the rules.
 Expect it to be rough with a 3B local model: on a hand-labelled set of seven prompts, `llama3.2` and `qwen2.5` each got four right, mostly confusing "coding" with "hard".
 The rules are deterministic, so put the decisions you care about there, and if you want a better judge, name a cheap hosted model as the classifier (`openai/gpt-5-mini`), which costs a few hundred tokens per turn.
-`/route` shows the rules in force and why the current model was picked; `/status` shows tokens per model.
+`/route` shows the rules in force and why the current model was picked; `/status` shows tokens, cached tokens, and cost per model, from the list prices in `pricing.py` (stamped with the date they were last checked; unknown models show `?`).
 `SCOOT_EFFORT` (`low` | `medium` | `high` | `xhigh`, default `medium`) sets the reasoning effort for models that take it, on both OpenAI and Anthropic.
 On Claude Opus 5 the server-side refusal fallback is requested by default, so a declined request is retried on another Claude model inside the same call; `SCOOT_ANTHROPIC_FALLBACKS=0` turns that off.
 
@@ -181,6 +181,8 @@ scoot --no-panel --no-dock           # plain prompt, no status bar (also what yo
 /model     list or switch model     /approve   set mode (always|auto-read|auto-edits|yolo)
 /yolo      auto-approve all         /worktree  isolate work in a git worktree
 /auth      provider keys            /logo      show or toggle the mascot
+/scope     where file tools may go   /hooks     configured hooks and results
+/route     how auto picks a model
 /sessions  list saved sessions      /resume    resume a saved session ([id])
 /forget    delete session(s)        /panel     toggle the bottom status bar
 /verbosity feed detail (full|compact|quiet)
@@ -188,6 +190,7 @@ scoot --no-panel --no-dock           # plain prompt, no status bar (also what yo
 ```
 
 Press **ESC** while a turn is running to interrupt it; the conversation is kept.
+Press **Ctrl-N** while a turn is running to add a note: scoot asks for one line at the next model call and the model sees it before continuing ("use pytest, not unittest").
 Type `/` and press **Tab** to complete slash commands.
 
 **Terminals.** scoot works in macOS Terminal, iTerm2, and inside tmux; the status bar uses a scroll region, the input dock uses raw mode, and clipboard copy uses the system tool or an OSC-52 escape.
@@ -198,7 +201,11 @@ Without a TTY, scoot falls back to a plain prompt with no bar and no dock.
 ### Tools and approvals
 
 The agent has eight tools: `read_file`, `list_dir`, `search`, `write_file`, `edit_file`, `run_shell`, `open_editor` (hands a file to IntelliJ IDEA's `idea -e` or to VS Code, `SCOOT_EDITOR` picks), and `update_plan` (a progress checklist for multi-step work).
-Every tool is sandboxed to the workspace root.
+Paths are resolved against the workspace root, and `~` works.
+
+The workspace is where the agent works, not a wall.
+When a tool needs a file outside it, in `~/.config`, another repo, `/etc`, scoot asks once: allow this path `[a]`, allow that directory for the session `[d]`, allow anywhere for the session `[A]`, skip `[s]`, or quit `[q]`.
+`--scope anywhere`, `SCOOT_SCOPE=anywhere`, or `/scope anywhere` skip the question; `/scope` shows what has been granted.
 
 When a call needs approval you can approve once `[a]`, trust that tool for the session `[t]`, approve everything this session `[A]`, edit the arguments `[e]`, skip `[s]`, or quit `[q]`.
 `/approve <mode>` sets how much runs without asking: `always` prompts for everything, `auto-read` auto-approves reads, `auto-edits` also auto-approves file edits, `yolo` runs everything.
@@ -250,6 +257,9 @@ git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e
 ```
 
 The install script needs only `curl` and Python 3.9+. `SCOOT_VERSION=v0.2.0` pins a release and `SCOOT_INSTALL_DIR` changes the target; read it before you run it, it is sixty lines.
+**Upgrading.** `pipx upgrade scootcli`, or `pip install --upgrade scootcli`, or rerun the curl line, which always fetches the latest release; `scoot --version` shows what you have, and `scoot --check-update` asks PyPI whether a newer one exists. With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
+`bash install.sh --uninstall` removes the command installed by the script (pipx users: `pipx uninstall scootcli`); config and sessions stay.
+
 Both pipx and the script install into `~/.local/bin`. On a fresh Linux account that directory is added to PATH at login only if it already exists, so after the very first install either open a new login shell or run `pipx ensurepath`; the installer prints the exact line for your shell.
 
 Requirements: Python 3.9 or newer on macOS or Linux.

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/__init__.py

@@ -1,4 +1,4 @@
 """scoot: a tiny coding agent that goes where you point it."""
 
-__version__ = "0.4.0"
+__version__ = "0.6.0"
 

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/agent.py

@@ -70,6 +70,12 @@ class HeadlessUI:
         self.events.append(("approve", tool.name, args))
         return Approval(self.decision, args)
 
+    scope_decision = "dir"  # what this headless UI answers to a scope question (tests override)
+
+    def approve_scope(self, tool, path, ctx) -> str:
+        self.events.append(("scope", tool.name, str(path)))
+        return self.scope_decision
+
     def auto_approved(self, tool, args) -> None:
         self.events.append(("auto", tool.name, args))
 
@@ -162,6 +168,9 @@ class Agent:
 
         Returns ``(result, streamed)`` where ``streamed`` is True if content was already printed.
         """
+        taker = getattr(ui, "take_note", None)
+        if callable(taker):
+            taker(session)  # a Ctrl-N pressed during the previous activity
         messages = self._messages(session, cfg)
         hints = {"task_text": self._last_user_text(session), "needs_tools": True, "step": steps}
         if self._streaming and hasattr(ui, "stream") and hasattr(self.provider, "chat_stream"):
@@ -345,7 +354,16 @@ class Agent:
     # ── tool execution ───────────────────────────────────────────────────────────
     def _run_tools(self, session, tool_calls, ui, cancel_event, cfg=None) -> Optional[str]:
         cfg = cfg or getattr(session, "config", None) or self.config
-        ctx = ToolContext(root=cfg.root, config=cfg, cancel_event=cancel_event)
+        scope = getattr(session, "scope", None)
+        if scope is None:
+            from .tools.base import Scope
+
+            scope = Scope(cfg.root, everything=(getattr(cfg, "scope", "workspace") == "anywhere"))
+            try:
+                session.scope = scope
+            except Exception:
+                pass
+        ctx = ToolContext(root=cfg.root, config=cfg, cancel_event=cancel_event, scope=scope)
         mode = getattr(session, "approval_mode", "always")
         # Session trust-list: tools the user chose to auto-approve for the rest of the session.
         trusted = getattr(session, "trusted_tools", None)
@@ -368,6 +386,17 @@ class Agent:
                 self._append_tool(session, tc_id, f"error: unknown tool '{name}'")
                 continue
 
+            # Paths outside the workspace: ask the user once (this path, its directory, or anywhere).
+            outside = self._outside_paths(tool, args, ctx)
+            if outside:
+                verdict = self._ask_scope(session, tool, outside, ctx, ui)
+                if verdict == "abort":
+                    self._append_tool(session, tc_id, "user aborted the operation")
+                    return "abort"
+                if verdict == "deny":
+                    self._append_tool(session, tc_id, f"user declined access outside the workspace: {outside[0]}")
+                    ui.tool_result(name, ToolResult(ok=False, summary="outside the workspace: declined"))
+                    continue
             # A PreToolUse hook may deny (skip the tool), allow (skip the prompt), or ask (force it).
             hook_action, hook_reason = self._pre_tool_hook(session, tool, args, cancel_event)
             if hook_action == "deny":
@@ -419,6 +448,46 @@ class Agent:
             self._append_tool(session, tc_id, payload or "(no output)")
         return None
 
+    @staticmethod
+    def _outside_paths(tool, args, ctx) -> "list":
+        from .tools.base import resolve_path
+
+        scope = ctx.scope
+        found = []
+        for raw in tool.paths(args):
+            try:
+                p = resolve_path(ctx.root, raw)
+            except Exception:
+                continue
+            if scope is None or not scope.allows(p):
+                found.append(p)
+        return found
+
+    def _ask_scope(self, session, tool, paths, ctx, ui) -> str:
+        """Ask for the first outside path; grant per the answer. Returns once|dir|all|deny|abort."""
+        scope = ctx.scope
+        if getattr(session, "config", None) is not None and getattr(session.config, "scope", "") == "anywhere":
+            scope.grant_all()
+            return "all"
+        asker = getattr(ui, "approve_scope", None)
+        if asker is None:
+            return "deny"
+        from .hooks import notify
+
+        notify(session, "scope", f"{tool.name} wants {paths[0]} outside the workspace")
+        verdict = asker(tool, paths[0], ctx)
+        if verdict == "once":
+            for p in paths:
+                scope.grant(p)
+        elif verdict == "dir":
+            for p in paths:
+                scope.grant_dir(p)
+            ui.assistant(f"allowing {scope.granted[-1]} for the rest of this session.")
+        elif verdict == "all":
+            scope.grant_all()
+            ui.assistant("allowing access anywhere on this machine for the rest of this session.")
+        return verdict
+
     @staticmethod
     def _handle_result(session, name: str, result: ToolResult, ui) -> None:
         """Surface a tool result: render a plan update specially, else the generic result line."""

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/approvals.py

@@ -126,6 +126,40 @@ def _edit_args(args: dict) -> dict:
     return args
 
 
+SCOPE_CHOICES = ("once", "dir", "all", "deny", "abort")
+
+
+def request_scope(tool: Tool, path, ctx: ToolContext) -> str:
+    """Ask once about a path outside the workspace. Returns one of ``SCOPE_CHOICES``."""
+    from pathlib import Path as _P
+
+    p = _P(str(path))
+    where = p if p.is_dir() else p.parent
+    print(color(f"  ⌂ {tool.name} wants {p}", "yellow") + color("  (outside the workspace)", "gray"))
+    while True:
+        print(
+            "  "
+            + color("allow this path", "green") + " [a]  "
+            + color(f"allow {where} this session", "green") + " [d]  "
+            + color("allow anywhere this session", "green") + " [A]  "
+            + color("skip", "yellow") + " [s]  "
+            + color("quit", "red") + " [q] › ",
+            end="", flush=True,
+        )
+        key = read_key()
+        print(key)
+        if key in ("a", "y", "\r", "\n", ""):
+            return "once"
+        if key == "d":
+            return "dir"
+        if key == "A":
+            return "all"
+        if key == "s":
+            return "deny"
+        if key == "q":
+            return "abort"
+
+
 def request_approval(tool: Tool, args: dict, ctx: ToolContext) -> Approval:
     """Show the pending tool call and read the user's decision (with optional arg editing)."""
     while True:

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/cli.py

@@ -33,6 +33,8 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     # Global flags (CLI-flag layer of config precedence).
     parser.add_argument("--version", action="version", version=f"scoot {__version__}")
+    parser.add_argument("--check-update", action="store_true",
+                        help="Ask PyPI whether a newer scoot exists, print both versions, and exit.")
     parser.add_argument("--model", help="Model as provider/model (e.g. openai/gpt-5.3-codex), 'default', or 'auto'.")
     parser.add_argument("--provider", help="Default provider (openai, ollama, ...) for bare model names.")
     parser.add_argument("--effort", choices=["low", "medium", "high", "xhigh"],
@@ -59,6 +61,8 @@ def _build_parser() -> argparse.ArgumentParser:
                         help="Don't inject the repo map (git + file tree) into the agent prompt.")
     parser.add_argument("--no-labels", action="store_true",
                         help="Hide the role labels/gutters (❯ you / ⏺ scoot) in the REPL transcript.")
+    parser.add_argument("--scope", choices=["workspace", "anywhere"],
+                        help="Where file tools may go: workspace (default; the first access outside it asks once) or anywhere.")
     parser.add_argument("--headless", action="store_true",
                         help="Line-delimited JSON on stdin/stdout instead of the REPL (see docs/headless-protocol.md).")
     parser.add_argument("--no-logo", action="store_true",
@@ -92,6 +96,7 @@ def _config_from_args(args: argparse.Namespace) -> Config:
         proxy=args.proxy,
         root=args.root,
         approval="yolo" if (args.yolo or args.yes) else args.approval,
+        scope="anywhere" if args.yes else args.scope,
         verbose=True if args.verbose else None,
         stream=False if args.no_stream else None,
         panel=False if args.no_panel else None,
@@ -196,10 +201,13 @@ def _run_once(config: Config, pool: ProviderPool, prompt: str, as_json: bool, re
         if outcome.content.strip() and not outcome.streamed:
             print(outcome.content.strip())
         if config.verbose:
+            from .pricing import fmt
+
             u = session.last_usage
             eprint(color(f"[{session.active_model}] steps={outcome.steps} "
                          f"prompt={u.get('prompt_tokens', '?')} "
-                         f"completion={u.get('completion_tokens', '?')}", "gray"))
+                         f"completion={u.get('completion_tokens', '?')} "
+                         f"cost={fmt(session.session_cost())}", "gray"))
         return 0
     eprint(color(f"⚠ {redact(outcome.error or outcome.status)}", "red"))
     return 1
@@ -267,6 +275,18 @@ def _resolve_prompt(args: argparse.Namespace) -> Optional[str]:
 
 def main(argv: Optional[List[str]] = None) -> int:
     args = _build_parser().parse_args(argv)
+    if args.check_update:
+        from .updates import check, is_newer, upgrade_hint
+
+        current, latest = check()
+        if latest is None:
+            print(f"scoot {current} (could not reach PyPI to check for updates)")
+            return 1
+        if is_newer(latest, current):
+            print(f"scoot {current}; newer release available: {latest}\n  {upgrade_hint()}")
+        else:
+            print(f"scoot {current} is the latest release.")
+        return 0
     try:
         config = _config_from_args(args)
         pool = ProviderPool(config)

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/commands/__init__.py

@@ -53,6 +53,7 @@ def load_builtins() -> None:
     from . import logo as _logo  # noqa: F401
     from . import route as _route  # noqa: F401
     from . import hooks as _hooks  # noqa: F401
+    from . import scope as _scope  # noqa: F401
 
     _loaded = True
 

scootcli-0.6.0/src/scootcli/commands/scope.py

@@ -0,0 +1,33 @@
+"""/scope — where file tools may go: the workspace, plus what you allowed, or anywhere."""
+
+from __future__ import annotations
+
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    scope = getattr(session, "scope", None)
+    if scope is None:
+        eprint(color("scope is not available in this context.", "yellow"))
+        return
+    want = (args or "").strip().lower()
+    if want in ("anywhere", "all", "everywhere"):
+        scope.grant_all()
+        print(color("file tools may now go anywhere on this machine for this session.", "gray"))
+    elif want == "workspace":
+        scope.everything = False
+        scope.granted.clear()
+        print(color("back to the workspace only; the next access outside it will ask.", "gray"))
+    elif want:
+        scope.grant_dir(want)
+        print(color(f"allowed {scope.granted[-1]} for this session.", "gray"))
+    print(color("scope: ", "bold") + scope.describe())
+    for g in scope.granted:
+        print(f"  {color('+', 'green')} {g}")
+    print(color("  usage: /scope anywhere · /scope workspace · /scope <dir>   (also --scope, SCOOT_SCOPE)", "gray"))
+
+
+register(SlashCommand("scope", "where file tools may go (workspace | anywhere | <dir>)", _run,
+                      usage="[anywhere|workspace|<dir>]"))

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/commands/status.py

@@ -23,8 +23,11 @@ def _run(session, args: str):
         ("model", session.active_model + ("  (auto)" if session.model.lower() == "auto" else "")),
         ("effort", getattr(cfg, "effort", "medium")),
         ("env files", ", ".join(getattr(cfg, "env_files", ()) or ()) or "none"),
+        ("update", (f"{session.update_available} available: pipx upgrade scootcli"
+                    if getattr(session, "update_available", "") else "none known (scoot --check-update, or SCOOT_UPDATE_CHECK=1)")),
         ("root", str(cfg.root)),
         ("approval", session.approval_mode),
+        ("scope", getattr(session, "scope", None).describe() if getattr(session, "scope", None) else "workspace"),
         ("streaming", "on" if getattr(cfg, "stream", True) else "off"),
         ("panel", "on" if getattr(session, "status_bar", None) and session.status_bar.enabled
                   else "off"),
@@ -43,10 +46,16 @@ def _run(session, args: str):
     for label, value in rows:
         print(f"  {color(label + ':', 'gray'):<28} {value}")
     by_model = getattr(session, "usage_by_model", None) or {}
-    if len(by_model) > 1 or (by_model and session.model.lower() == "auto"):
-        print(f"  {color('tokens by model:', 'gray')}")
+    if by_model:
+        from ..pricing import UPDATED, cost, fmt
+
+        print(f"  {color('tokens and cost by model:', 'gray')}")
         for name, u in sorted(by_model.items(), key=lambda kv: -(kv[1]['prompt'] + kv[1]['completion'])):
-            print(f"    {color(name, 'cyan'):<40} prompt={u['prompt']} completion={u['completion']} calls={u['calls']}")
+            c = cost(name, u["prompt"], u["completion"], u.get("cached", 0))
+            cached = f" cached={u['cached']}" if u.get("cached") else ""
+            print(f"    {color(name, 'cyan'):<40} prompt={u['prompt']}{cached} completion={u['completion']} calls={u['calls']}  {fmt(c)}")
+        total = session.session_cost() if hasattr(session, "session_cost") else None
+        print(f"  {color('cost (session):', 'gray'):<28} {fmt(total)}  {color(f'list prices as of {UPDATED}; unknown models show ?', 'gray')}")
     if session.model.lower() == "auto" and getattr(session, "route_reason", ""):
         print(f"  {color('routed by:', 'gray'):<28} {session.route_reason}")
     trusted = getattr(session, "trusted_tools", None)

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/config.py

@@ -179,6 +179,7 @@ class Config:
     vision_model: str = "auto"  # provider/model for image descriptions, or "auto" → pick a capable one
     image_max_bytes: int = 4 * 1024 * 1024  # per-image cap (no downscale without a 3rd-party lib)
     editor: str = "idea"  # external editor for the open_editor tool: idea | vscode
+    scope: str = "workspace"  # where file tools may go: workspace (ask once outside it) | anywhere
     env_files: Tuple[str, ...] = ()  # the .env files that were read, in load order (shown by /status)
     logo: bool = True  # mascot in the launch banner + status-bar face (--no-logo / SCOOT_LOGO / /logo)
     emoji: bool = True  # 🛴 transcript label; off → ⏺ for terminals without an emoji font (--no-emoji)
@@ -216,6 +217,7 @@ class Config:
             vision_model=get("SCOOT_VISION_MODEL", "auto"),
             image_max_bytes=int(get("SCOOT_IMAGE_MAX_BYTES", str(4 * 1024 * 1024))),
             editor=get("SCOOT_EDITOR", "idea").strip().lower(),
+            scope=get("SCOOT_SCOPE", "workspace").strip().lower(),
             logo=_resolve_logo_setting(get("SCOOT_LOGO")),
             emoji=_as_bool(get("SCOOT_EMOJI", "true")),
         )

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/headless.py

@@ -136,6 +136,32 @@ class HeadlessUI:
                              auto_approved=False, decision=str(msg.get("decision")).lower())
             return Approval(decision, new_args)
 
+    def approve_scope(self, tool, path, ctx) -> str:
+        req = self._call_id()
+        self.writer.emit("scope_request", id=req, name=tool.name, path=str(path),
+                         options=["allow_once", "allow_dir", "allow_all", "deny", "abort"], timeout_s=self.timeout)
+        mapping = {"allow_once": "once", "allow_dir": "dir", "allow_all": "all", "deny": "deny", "abort": "abort"}
+        deadline = time.time() + self.timeout
+        while True:
+            remaining = deadline - time.time()
+            if remaining <= 0:
+                self.writer.emit("notice", message=f"scope request {req} timed out after {self.timeout:g}s; denied")
+                return "deny"
+            if self.cancel_event is not None and self.cancel_event.is_set():
+                return "abort"
+            try:
+                msg = self.answers.get(timeout=min(0.2, remaining))
+            except queue.Empty:
+                continue
+            if msg.get("id") not in (None, "", req):
+                self.writer.emit("error", message=f"answer for unknown request {msg.get('id')}", kind="protocol")
+                continue
+            verdict = mapping.get(str(msg.get("decision", "")).lower())
+            if verdict is None:
+                self.writer.emit("error", message=f"unknown scope decision {msg.get('decision')!r}; expected one of {list(mapping)}", kind="protocol")
+                continue
+            return verdict
+
     def plan(self, plan) -> None:
         self.writer.emit("plan", steps=plan)
 

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/keys.py

@@ -24,6 +24,7 @@ except ImportError:  # pragma: no cover - non-POSIX
     _HAVE_TERMIOS = False
 
 ESC = "\x1b"
+NOTE_KEY = b"\x0e"  # Ctrl-N: ask for a note at the next model call
 
 
 def read_key() -> str:
@@ -54,8 +55,9 @@ class InterruptibleSection:
     is simply unavailable — the work still runs normally.
     """
 
-    def __init__(self, cancel_event: threading.Event):
+    def __init__(self, cancel_event: threading.Event, note_event: "threading.Event | None" = None):
         self.cancel_event = cancel_event
+        self.note_event = note_event
         self.enabled = _HAVE_TERMIOS and sys.stdin.isatty()
         self._fd = sys.stdin.fileno() if self.enabled else -1
         self._old_attrs = None
@@ -88,6 +90,9 @@ class InterruptibleSection:
                 ch = os.read(self._fd, 1)
             except (OSError, ValueError):
                 break
+            if ch == NOTE_KEY and self.note_event is not None:
+                self.note_event.set()
+                continue
             if ch == b"\x1b":
                 # Distinguish a bare ESC (a real interrupt) from an escape sequence — arrow keys,
                 # mouse reports, or bracketed-paste markers (\x1b[201~) left in the buffer after a

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/panel.py

@@ -108,6 +108,9 @@ def build_status_text(session, user: Optional[str] = None) -> str:
     err = getattr(session, "last_error", None)
     if err:
         segments.append(f"⚠ {err}")
+    newer = getattr(session, "update_available", "")
+    if newer:
+        segments.append(f"⬆ {newer}")
     # The mascot's face leads the bar; its eyes follow the turn (idle / thinking / stopped).
     if getattr(getattr(session, "config", None), "logo", True):
         from .logo import face

scootcli-0.6.0/src/scootcli/pricing.py

@@ -0,0 +1,80 @@
+"""Published list prices per million tokens, for the cost column in ``/status``.
+
+This table goes stale; ``UPDATED`` says when it was last checked against the vendors' pricing pages.
+Unknown models get no cost, never a guess. Local models cost nothing. Prices are USD.
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+from .providers.base import split_model_id
+
+UPDATED = "2026-09-06"
+
+# (model id prefix, input, cached input, output). Longest matching prefix wins.
+# Anthropic: cache reads are 10% of input; cache writes (25% premium) are counted as plain input here.
+PRICES = [
+    # OpenAI (developers.openai.com/api/docs/pricing)
+    ("gpt-5.6-astra", 10.00, 1.00, 50.00), ("gpt-5.6-sol", 4.00, 0.40, 20.00),
+    ("gpt-5.6-terra", 2.00, 0.20, 12.00), ("gpt-5.6-luna", 0.20, 0.02, 1.20),
+    ("gpt-5.5-pro", 30.00, 30.00, 180.00), ("gpt-5.5", 5.00, 0.50, 30.00),
+    ("gpt-5.4-pro", 30.00, 30.00, 180.00), ("gpt-5.4-mini", 0.75, 0.075, 4.50),
+    ("gpt-5.4-nano", 0.20, 0.02, 1.25), ("gpt-5.4", 2.50, 0.25, 15.00),
+    ("gpt-5.3-codex", 1.75, 0.175, 14.00), ("gpt-5.2-pro", 21.00, 21.00, 168.00),
+    ("gpt-5.2", 1.75, 0.175, 14.00), ("gpt-5.1", 1.25, 0.125, 10.00),
+    ("gpt-5-pro", 15.00, 15.00, 120.00), ("gpt-5-mini", 0.25, 0.025, 2.00),
+    ("gpt-5-nano", 0.05, 0.005, 0.40), ("gpt-5", 1.25, 0.125, 10.00),
+    ("gpt-4.1-mini", 0.40, 0.10, 1.60), ("gpt-4.1", 2.00, 0.50, 8.00),
+    ("gpt-4o-mini", 0.15, 0.075, 0.60), ("gpt-4o", 2.50, 1.25, 10.00),
+    # Anthropic (first-party API rates)
+    ("claude-fable-5", 10.00, 1.00, 50.00), ("claude-mythos-5", 10.00, 1.00, 50.00),
+    ("claude-opus-5", 5.00, 0.50, 25.00), ("claude-opus-4-8", 5.00, 0.50, 25.00),
+    ("claude-opus-4-7", 5.00, 0.50, 25.00), ("claude-opus-4-6", 5.00, 0.50, 25.00),
+    ("claude-sonnet-5", 2.00, 0.20, 10.00), ("claude-sonnet-4-6", 3.00, 0.30, 15.00),
+    ("claude-haiku-4-5", 1.00, 0.10, 5.00),
+]
+_FREE_PROVIDERS = ("ollama",)
+
+
+def price_for(model: str) -> Optional[Tuple[float, float, float]]:
+    """``(input, cached_input, output)`` per million tokens, or ``None`` when unknown."""
+    provider, name = split_model_id(model)
+    if provider in _FREE_PROVIDERS:
+        return (0.0, 0.0, 0.0)
+    name = (name or model or "").lower()
+    best = None
+    for prefix, inp, cached, out in PRICES:
+        if name.startswith(prefix) and (best is None or len(prefix) > len(best[0])):
+            best = (prefix, inp, cached, out)
+    return (best[1], best[2], best[3]) if best else None
+
+
+def cost(model: str, prompt: int, completion: int, cached: int = 0) -> Optional[float]:
+    """USD for one or more calls; ``cached`` is the part of ``prompt`` served from cache."""
+    p = price_for(model)
+    if p is None:
+        return None
+    inp, cached_price, out = p
+    cached = max(0, min(int(cached or 0), int(prompt or 0)))
+    fresh = int(prompt or 0) - cached
+    return (fresh * inp + cached * cached_price + int(completion or 0) * out) / 1_000_000
+
+
+def cached_tokens(usage: dict) -> int:
+    """Cached-input tokens from a normalized usage dict, whichever vendor shape it came in."""
+    if not isinstance(usage, dict):
+        return 0
+    n = usage.get("cache_read_input_tokens")
+    if n is None:
+        details = usage.get("input_tokens_details") or usage.get("prompt_tokens_details") or {}
+        n = details.get("cached_tokens") if isinstance(details, dict) else 0
+    return int(n or 0)
+
+
+def fmt(usd: Optional[float]) -> str:
+    if usd is None:
+        return "?"
+    if usd == 0:
+        return "$0"
+    return f"${usd:.4f}" if usd < 0.01 else f"${usd:.2f}"

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/prompts.py

@@ -23,7 +23,7 @@ You run inside the user's workspace and act through tools. Be concise, correct,
 ENVIRONMENT
 - Working directory (root): {{workspace_root}}
 - OS: {{os}}   Model: {{model}}
-- All file paths you use must stay inside the root. Never touch paths outside it.
+- The root is your workspace, not a wall: when the task needs files elsewhere on this machine (~/.config, another repo, /etc), use them with absolute paths (~ is fine). The first access outside the workspace asks the user once; never tell the user you are not allowed to leave the workspace, and never hand them a script to run in your place because of it.
 
 WORKSPACE (auto-generated map of the current repo — use it to orient before listing/reading files)
 {{workspace}}

{scootcli-0.4.0 → scootcli-0.6.0}/src/scootcli/providers/router.py

@@ -220,6 +220,9 @@ def describe(router: Router) -> List[str]:
     if cfg.classifier:
         lines.append(f"classifier: {cfg.classifier['model']} → " + ", ".join(
             f"{k}={v}" for k, v in cfg.classifier["tiers"].items()))
+        if str(cfg.classifier["model"]).startswith("ollama/"):
+            lines.append("  note: small local models are rough judges here (about half right in our test); "
+                         "a hosted mini model such as openai/gpt-5-mini classifies better for a few hundred tokens")
     for i, rule in enumerate(cfg.rules, 1):
         lines.append(f"  {i}. when {json.dumps(rule.get('when') or {})} → {rule['use']}")
     if cfg.default: