scootcli 0.5.0__tar.gz → 0.7.0__tar.gz

{scootcli-0.5.0/src/scootcli.egg-info → scootcli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.5.0
+Version: 0.7.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.
 
@@ -215,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.
@@ -258,12 +259,13 @@ Put them in `~/.config/scoot/hooks.json` or `.scoot/hooks.json` in the project:
 }
 ```
 
-A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason.
+A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason. Claude Code's nested `hookSpecificOutput` answer is accepted as is, so a hook written for Claude Code works without edits.
 A `Stop` hook that answers `{"decision": "block", "reason": "run the tests first"}` sends the agent back to work with that instruction, at most three times per turn.
+Matchers understand Claude Code's tool names as well as scoot's, so `"matcher": "Bash|Write|Edit"` fires for `run_shell`, `write_file`, and `edit_file`, and the payload carries the alias as `tool_alias`: one `hooks.json` and one script can serve both tools.
 `/hooks` shows what is configured and what ran; `SCOOT_HOOKS=0` turns hooks off.
 
 **Headless mode** is for editors, automation, and remote-control tools: `scoot --headless` reads JSON lines on stdin (`prompt`, `approve`, `note`, `interrupt`, `command`, `shutdown`) and writes JSON lines on stdout (streamed text, tool calls, approval requests, results, plan updates, usage, errors, a heartbeat), with nothing else ever printed there.
-Same sessions, tools, approvals, routing, and hooks as the REPL.
+Same sessions, tools, approvals, routing, and hooks as the REPL; every `turn_end` carries the turn's tokens and cost, and `--json` one-shot output carries `cost` too.
 The message tables and a full transcript are in [`docs/headless-protocol.md`](./docs/headless-protocol.md); an unanswered approval is denied after `SCOOT_APPROVAL_TIMEOUT` seconds (default 120).
 
 ### The status bar
@@ -275,13 +277,26 @@ The bottom row shows the mascot's face (its eyes follow the turn: `o o` idle, `>
 ```bash
 pipx install scootcli && pipx ensurepath       # recommended: isolated; ensurepath puts ~/.local/bin on PATH for new shells
 curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # no pipx: puts the zipapp at ~/.local/bin/scoot
-pip install scootcli                           # anywhere
+pip install scootcli                           # inside a venv, container, or CI job (system Pythons on recent Linux and Homebrew block pip outside a venv)
 curl -LO https://github.com/sergenes/scootcli/releases/latest/download/scoot.pyz && python3 scoot.pyz  # single file, no install
 git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e .                       # from source
 ```
 
 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.
+## Upgrade options
+
+Use the same tool you installed with:
+
+```bash
+pipx upgrade scootcli                          # pipx install
+pip install --upgrade scootcli                 # pip install
+curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # the curl installer: rerun it, it always fetches the latest release
+scoot --version                                # what you have
+scoot --check-update                           # ask PyPI whether a newer release 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.
+To remove scoot: `pipx uninstall scootcli`, `pip uninstall scootcli`, or `bash install.sh --uninstall` for the curl installer; config in `~/.config/scoot` and sessions in `~/.local/state/scoot` stay either way.
 
 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.
 

{scootcli-0.5.0 → scootcli-0.7.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.
 
@@ -190,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.
@@ -233,12 +234,13 @@ Put them in `~/.config/scoot/hooks.json` or `.scoot/hooks.json` in the project:
 }
 ```
 
-A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason.
+A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason. Claude Code's nested `hookSpecificOutput` answer is accepted as is, so a hook written for Claude Code works without edits.
 A `Stop` hook that answers `{"decision": "block", "reason": "run the tests first"}` sends the agent back to work with that instruction, at most three times per turn.
+Matchers understand Claude Code's tool names as well as scoot's, so `"matcher": "Bash|Write|Edit"` fires for `run_shell`, `write_file`, and `edit_file`, and the payload carries the alias as `tool_alias`: one `hooks.json` and one script can serve both tools.
 `/hooks` shows what is configured and what ran; `SCOOT_HOOKS=0` turns hooks off.
 
 **Headless mode** is for editors, automation, and remote-control tools: `scoot --headless` reads JSON lines on stdin (`prompt`, `approve`, `note`, `interrupt`, `command`, `shutdown`) and writes JSON lines on stdout (streamed text, tool calls, approval requests, results, plan updates, usage, errors, a heartbeat), with nothing else ever printed there.
-Same sessions, tools, approvals, routing, and hooks as the REPL.
+Same sessions, tools, approvals, routing, and hooks as the REPL; every `turn_end` carries the turn's tokens and cost, and `--json` one-shot output carries `cost` too.
 The message tables and a full transcript are in [`docs/headless-protocol.md`](./docs/headless-protocol.md); an unanswered approval is denied after `SCOOT_APPROVAL_TIMEOUT` seconds (default 120).
 
 ### The status bar
@@ -250,13 +252,26 @@ The bottom row shows the mascot's face (its eyes follow the turn: `o o` idle, `>
 ```bash
 pipx install scootcli && pipx ensurepath       # recommended: isolated; ensurepath puts ~/.local/bin on PATH for new shells
 curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # no pipx: puts the zipapp at ~/.local/bin/scoot
-pip install scootcli                           # anywhere
+pip install scootcli                           # inside a venv, container, or CI job (system Pythons on recent Linux and Homebrew block pip outside a venv)
 curl -LO https://github.com/sergenes/scootcli/releases/latest/download/scoot.pyz && python3 scoot.pyz  # single file, no install
 git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e .                       # from source
 ```
 
 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.
+## Upgrade options
+
+Use the same tool you installed with:
+
+```bash
+pipx upgrade scootcli                          # pipx install
+pip install --upgrade scootcli                 # pip install
+curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # the curl installer: rerun it, it always fetches the latest release
+scoot --version                                # what you have
+scoot --check-update                           # ask PyPI whether a newer release 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.
+To remove scoot: `pipx uninstall scootcli`, `pip uninstall scootcli`, or `bash install.sh --uninstall` for the curl installer; config in `~/.config/scoot` and sessions in `~/.local/state/scoot` stay either way.
 
 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.
 

{scootcli-0.5.0 → scootcli-0.7.0}/src/scootcli/__init__.py

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

{scootcli-0.5.0 → scootcli-0.7.0}/src/scootcli/agent.py

@@ -168,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"):
@@ -216,8 +219,10 @@ class Agent:
             return "", ""
         from .hooks import tool_kind
 
+        from .hooks import tool_alias
+
         payload = hooks.payload(session, "PreToolUse", tool_name=tool.name, tool_input=args,
-                                tool_kind=tool_kind(tool))
+                                tool_kind=tool_kind(tool), tool_alias=tool_alias(tool.name))
         decision = hooks.run("PreToolUse", payload, cancel_event)
         return decision.action, decision.reason
 
@@ -229,9 +234,11 @@ class Agent:
 
         response = {"ok": result.ok, "summary": result.summary or "", "error": result.error or "",
                     "content": (result.content or "")[:4000]}
+        from .hooks import tool_alias
+
         hooks.run("PostToolUse", hooks.payload(session, "PostToolUse", tool_name=tool.name,
                                                tool_input=args, tool_kind=tool_kind(tool),
-                                               tool_response=response))
+                                               tool_alias=tool_alias(tool.name), tool_response=response))
 
     @staticmethod
     def _last_user_text(session) -> str:

{scootcli-0.5.0 → scootcli-0.7.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"],
@@ -192,6 +194,7 @@ def _run_once(config: Config, pool: ProviderPool, prompt: str, as_json: bool, re
             "content": outcome.content,
             "error": outcome.error,
             "usage": session.last_usage,
+            "cost": session.session_cost(),
         }, indent=2))
         return 0 if outcome.status == "done" else 1
 
@@ -199,10 +202,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
@@ -270,6 +276,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.5.0 → scootcli-0.7.0}/src/scootcli/commands/status.py

@@ -23,6 +23,8 @@ 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"),
@@ -44,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.5.0 → scootcli-0.7.0}/src/scootcli/headless.py

@@ -285,6 +285,7 @@ class Headless:
         self.cancel = threading.Event()
         self.ui.cancel_event = self.cancel
         self.session.last_error = ""
+        before = self._session_cost()
         try:
             with redirect_stdout(sys.stderr):  # any stray print from a tool or command stays off the protocol
                 try:
@@ -303,6 +304,7 @@ class Headless:
                 self.writer.emit("error", message=outcome.error, kind="turn")
             self.writer.emit("turn_end", turn=self._turn, status=outcome.status, steps=outcome.steps,
                              model=self.session.active_model, usage=self.session.last_usage,
+                             cost=self._turn_cost(before), cost_session=self._session_cost(),
                              content=outcome.content, error=outcome.error)
         except ScootError as exc:
             self.writer.emit("error", message=str(exc), hint=getattr(exc, "hint", ""), kind="turn")
@@ -313,6 +315,19 @@ class Headless:
             self.cancel = None
             self.ui.cancel_event = None
 
+    def _session_cost(self):
+        fn = getattr(self.session, "session_cost", None)
+        try:
+            return fn() if callable(fn) else None
+        except Exception:
+            return None
+
+    def _turn_cost(self, before):
+        after = self._session_cost()
+        if after is None or before is None:
+            return None
+        return round(after - before, 6)
+
     def _command(self, msg: dict) -> None:
         from . import commands
         import io

{scootcli-0.5.0 → scootcli-0.7.0}/src/scootcli/hooks.py

@@ -36,6 +36,12 @@ EVENTS = ("SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop
 DEFAULT_TIMEOUT = 60
 _MAX_CAPTURE = 16_000
 _TOOL_KINDS = {"read": "read", "write": "write", "shell": "shell"}
+# Claude Code's names for the same jobs, so a hooks.json written for it ("matcher": "Bash|Write|Edit")
+# fires for scoot's tools too, and a shared script can switch on ``tool_alias``.
+TOOL_ALIASES = {
+    "read_file": "Read", "list_dir": "LS", "search": "Grep", "write_file": "Write", "edit_file": "Edit",
+    "run_shell": "Bash", "open_editor": "Open", "update_plan": "TodoWrite",
+}
 
 
 @dataclass
@@ -96,6 +102,19 @@ def tool_kind(tool) -> str:
     return _TOOL_KINDS.get(getattr(tool, "risk", ""), "read")
 
 
+def tool_alias(name: str) -> str:
+    return TOOL_ALIASES.get(name, name)
+
+
+def matcher_hits(matcher: str, tool_name: str) -> bool:
+    """A matcher regex matches scoot's tool name or its Claude Code alias."""
+    try:
+        rx = re.compile(str(matcher))
+    except re.error:
+        return False
+    return bool(rx.search(tool_name) or rx.search(tool_alias(tool_name)))
+
+
 class Hooks:
     """The merged hook configuration for one workspace, plus a record of what ran."""
 
@@ -149,10 +168,7 @@ class Hooks:
         for entry in self.config.get(event, []):
             matcher = entry.get("matcher")
             if matcher and event in ("PreToolUse", "PostToolUse"):
-                try:
-                    if not re.search(str(matcher), tool_name):
-                        continue
-                except re.error:
+                if not matcher_hits(matcher, tool_name):
                     continue
             for hook in entry.get("hooks", []):
                 if not isinstance(hook, dict) or hook.get("type", "command") != "command":
@@ -212,7 +228,21 @@ class Hooks:
     @staticmethod
     def _interpret(event: str, data: dict) -> Decision:
         reason = str(data.get("reason") or "")
-        perm = str(data.get("permissionDecision") or "").lower()
+        # Claude Code nests a hook's decision under "hookSpecificOutput" (with the reason as
+        # "permissionDecisionReason" and extra context as "additionalContext"); scoot's own flat
+        # shape puts the same keys at the top level. Read both, nested first.
+        hso = data.get("hookSpecificOutput")
+        if isinstance(hso, dict):
+            if not reason:
+                reason = str(hso.get("permissionDecisionReason") or hso.get("reason") or "")
+            perm_src = hso.get("permissionDecision")
+            context_src = hso.get("additionalContext")
+        else:
+            perm_src = data.get("permissionDecision")
+            context_src = None
+        perm = str(perm_src or "").lower()
+        if perm == "approve":
+            perm = "allow"  # Claude Code's older synonym
         if event == "PreToolUse" and perm in ("allow", "deny", "ask"):
             return Decision(action=perm, reason=reason)
         raw = str(data.get("decision") or "").lower()
@@ -220,7 +250,7 @@ class Hooks:
             return Decision(action="deny" if event == "PreToolUse" else "block", reason=reason)
         if raw == "approve" and event == "PreToolUse":
             return Decision(action="allow", reason=reason)
-        context = data.get("additionalContext") or data.get("context") or ""
+        context = context_src or data.get("additionalContext") or data.get("context") or ""
         return Decision(context=str(context) if context else "")
 
     def _record(self, event: str, command: str, outcome: str, detail: str, started: float) -> None:

{scootcli-0.5.0 → scootcli-0.7.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.5.0 → scootcli-0.7.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.7.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.5.0 → scootcli-0.7.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:

{scootcli-0.5.0 → scootcli-0.7.0}/src/scootcli/repl.py

@@ -79,6 +79,7 @@ class ReplSession:
         self.mascot_state = "idle"  # drives the mascot's eyes in the status bar: idle | thinking | stopped
         self.usage_by_model: dict = {}  # qualified model -> {"prompt": n, "completion": n, "calls": n}
         self.provider_ready = True  # False until a provider can take a request (see refresh_readiness)
+        self.update_available = ""  # newer release on PyPI, when the opt-in check found one
         from .tools.base import Scope
 
         self.scope = Scope(config.root, everything=(getattr(config, "scope", "workspace") == "anywhere"))
@@ -212,12 +213,27 @@ class ReplSession:
         completion = int((usage or {}).get("completion_tokens", 0) or 0)
         self.total_prompt += prompt
         self.total_completion += completion
+        from .pricing import cached_tokens
+
         key = model or getattr(self, "active_model", "") or "?"
-        slot = self.usage_by_model.setdefault(key, {"prompt": 0, "completion": 0, "calls": 0})
+        slot = self.usage_by_model.setdefault(key, {"prompt": 0, "completion": 0, "cached": 0, "calls": 0})
         slot["prompt"] += prompt
         slot["completion"] += completion
+        slot["cached"] += cached_tokens(usage)
         slot["calls"] += 1
 
+    def session_cost(self):
+        """USD spent this session across models, or ``None`` if any model's price is unknown."""
+        from .pricing import cost
+
+        total = 0.0
+        for name, u in self.usage_by_model.items():
+            c = cost(name, u["prompt"], u["completion"], u.get("cached", 0))
+            if c is None:
+                return None
+            total += c
+        return total
+
     def full_messages(self) -> List[dict]:
         return [{"role": "system", "content": CHAT_SYSTEM_PROMPT}, *self.messages]
 
@@ -294,6 +310,7 @@ class ReplUI:
     def __init__(self, labels: bool = True, verbosity: str = "full", emoji: bool = True):
         self.labels = labels
         self.emoji = emoji  # 🛴 label, or ⏺ when the terminal has no emoji font
+        self.note_requested = threading.Event()  # Ctrl-N during a turn; taken at the next model call
         self.verbosity = verbosity if verbosity in self.LEVELS else "full"
         self._tty = sys.stdout.isatty()
         self._transient = False  # a transient line is currently on screen (no trailing newline)
@@ -375,7 +392,7 @@ class ReplUI:
         status = Status()
         status.start(message)
         try:
-            with InterruptibleSection(cancel_event):
+            with InterruptibleSection(cancel_event, self.note_requested):
                 yield
         finally:
             status.stop()  # clears the spinner row; the tool row above stays on screen
@@ -393,7 +410,7 @@ class ReplUI:
         status.start("thinking…")
         printer = _StreamPrinter(status, labels=self.labels, on_label=self.label_once)
         try:
-            with InterruptibleSection(cancel_event):
+            with InterruptibleSection(cancel_event, self.note_requested):
                 yield printer
         finally:
             if not printer.started:
@@ -421,6 +438,30 @@ class ReplUI:
 
         return request_scope(tool, path, ctx)
 
+    def take_note(self, session) -> None:
+        """If Ctrl-N was pressed during the last activity, read one line now (cooked mode) and queue it
+        for the next model call. Called by the agent between activities."""
+        if not self.note_requested.is_set():
+            return
+        self.note_requested.clear()
+        self._commit_line()
+        try:
+            text = input(color("  note › ", "cyan")).strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+        if not text:
+            return
+        notes = getattr(session, "pending_notes", None)
+        if notes is None:
+            notes = []
+            try:
+                session.pending_notes = notes
+            except Exception:
+                return
+        notes.append(text)
+        print(color("  noted; the model sees it at its next call.", "gray"))
+
     def auto_approved(self, tool, args) -> None:
         import json as _json
 
@@ -551,6 +592,7 @@ class Repl:
         from .hooks import session_event
 
         session_event(self.session, "SessionStart", source="resume" if self.session.resumed else "startup")
+        self._start_update_check()
         code = 1
         try:
             code = self._loop()
@@ -615,6 +657,20 @@ class Repl:
             else:
                 print(color("  (run with --verbose or set SCOOT_VERBOSE=1 for a traceback)", "gray"))
 
+    def _start_update_check(self) -> None:
+        """Opt-in (SCOOT_UPDATE_CHECK=1): one PyPI request in the background; the bar shows ⬆ x.y.z."""
+        from .updates import enabled, is_newer, latest_version
+
+        if not enabled():
+            return
+
+        def _run() -> None:
+            latest = latest_version()
+            if is_newer(latest):
+                self.session.update_available = latest
+
+        threading.Thread(target=_run, daemon=True).start()
+
     def _auth_user(self):
         """Status-bar identity: the provider serving the active model, or a plain 'not set up'."""
         if not getattr(self.session, "provider_ready", True):