scootcli 0.8.0__tar.gz → 0.9.0__tar.gz

{scootcli-0.8.0/src/scootcli.egg-info → scootcli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.8.0
+Version: 0.9.0
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -115,8 +115,9 @@ scoot --model openai/gpt-5.3-codex "..."
 scoot --model auto "..."             # pick a model per prompt from the live list (cheap for trivial, strong for edits)
 ```
 
-Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
-Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+Inside the REPL, `/model <provider/model>` switches and is remembered for the folder you are in, so each project can have its own model; `/model default` goes back to the provider's preferred model.
+Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it there; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+`/model X everywhere` makes `X` the model for every folder that has no choice of its own, `/model forget` drops the current folder's choice so it follows that, and `/status` says where the active model came from.
 
 ### Routing
 
@@ -171,7 +172,7 @@ The most useful settings (see [`.env.example`](./.env.example) for all of them):
 |---|---|---|
 | `OPENAI_API_KEY` | OpenAI key (or `scoot auth set openai`) | |
 | `SCOOT_PROVIDER` | default provider for bare model names | first with a key, else `ollama` |
-| `SCOOT_MODEL` | `default`, `auto`, or `provider/model` | `default` |
+| `SCOOT_MODEL` | `default`, `auto`, or `provider/model`; overrides the saved per-folder and global choices | `default` |
 | `SCOOT_EFFORT` | reasoning effort | `medium` |
 | `SCOOT_APPROVAL` | `always` · `auto-read` · `auto-edits` · `yolo` | `yolo` |
 | `SCOOT_MAX_STEPS` | tool-call steps per turn before asking to continue | `50` |
@@ -238,7 +239,8 @@ When a call needs approval you can approve once `[a]`, trust that tool for the s
 `/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.
 Catastrophic shell commands (a denylist: `rm -rf /`, `git push --force`, piping downloads into a shell, and so on) are re-confirmed in every mode.
 
-For risky autonomous runs, `/worktree start` moves the work into a throwaway git worktree; `/worktree merge` or `/worktree discard` when done.
+For risky autonomous runs, `/worktree start` moves the work into a throwaway git worktree; `/worktree merge`, `/worktree keep`, or `/worktree discard` when done.
+A commit or merge that fails keeps the worktree and your files; nothing is removed by force except by `discard`.
 
 ### Streaming, images, sessions
 
@@ -313,7 +315,8 @@ python -m pytest -q          # network-free suite
 ./scripts/build.sh           # dist/scoot.pyz + wheel + sdist
 ```
 
-Design notes live in [`DESIGN.md`](./DESIGN.md), the behaviour spec in [`SPEC.md`](./SPEC.md), what is next in [`ROADMAP.md`](./ROADMAP.md), and the release history in [`CHANGELOG.md`](./CHANGELOG.md).
+Design notes live in [`DESIGN.md`](./DESIGN.md), the behaviour spec in [`SPEC.md`](SPEC.md), what is next in [`ROADMAP.md`](./ROADMAP.md), and the release history in [`CHANGELOG.md`](./CHANGELOG.md).
+Want to build a CLI agent like this yourself? [`docs/blueprint.md`](./docs/blueprint.md) is the minimal spec: the components, the turn, the tools, the permission rules, and the acceptance checks, with no dependency on scoot's code.
 New capability is a drop-in file: a tool in `tools/`, a slash command in `commands/`, a provider row or adapter in `providers/`.
 
 ## Security

{scootcli-0.8.0 → scootcli-0.9.0}/README.md

@@ -90,8 +90,9 @@ scoot --model openai/gpt-5.3-codex "..."
 scoot --model auto "..."             # pick a model per prompt from the live list (cheap for trivial, strong for edits)
 ```
 
-Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
-Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+Inside the REPL, `/model <provider/model>` switches and is remembered for the folder you are in, so each project can have its own model; `/model default` goes back to the provider's preferred model.
+Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it there; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+`/model X everywhere` makes `X` the model for every folder that has no choice of its own, `/model forget` drops the current folder's choice so it follows that, and `/status` says where the active model came from.
 
 ### Routing
 
@@ -146,7 +147,7 @@ The most useful settings (see [`.env.example`](./.env.example) for all of them):
 |---|---|---|
 | `OPENAI_API_KEY` | OpenAI key (or `scoot auth set openai`) | |
 | `SCOOT_PROVIDER` | default provider for bare model names | first with a key, else `ollama` |
-| `SCOOT_MODEL` | `default`, `auto`, or `provider/model` | `default` |
+| `SCOOT_MODEL` | `default`, `auto`, or `provider/model`; overrides the saved per-folder and global choices | `default` |
 | `SCOOT_EFFORT` | reasoning effort | `medium` |
 | `SCOOT_APPROVAL` | `always` · `auto-read` · `auto-edits` · `yolo` | `yolo` |
 | `SCOOT_MAX_STEPS` | tool-call steps per turn before asking to continue | `50` |
@@ -213,7 +214,8 @@ When a call needs approval you can approve once `[a]`, trust that tool for the s
 `/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.
 Catastrophic shell commands (a denylist: `rm -rf /`, `git push --force`, piping downloads into a shell, and so on) are re-confirmed in every mode.
 
-For risky autonomous runs, `/worktree start` moves the work into a throwaway git worktree; `/worktree merge` or `/worktree discard` when done.
+For risky autonomous runs, `/worktree start` moves the work into a throwaway git worktree; `/worktree merge`, `/worktree keep`, or `/worktree discard` when done.
+A commit or merge that fails keeps the worktree and your files; nothing is removed by force except by `discard`.
 
 ### Streaming, images, sessions
 
@@ -288,7 +290,8 @@ python -m pytest -q          # network-free suite
 ./scripts/build.sh           # dist/scoot.pyz + wheel + sdist
 ```
 
-Design notes live in [`DESIGN.md`](./DESIGN.md), the behaviour spec in [`SPEC.md`](./SPEC.md), what is next in [`ROADMAP.md`](./ROADMAP.md), and the release history in [`CHANGELOG.md`](./CHANGELOG.md).
+Design notes live in [`DESIGN.md`](./DESIGN.md), the behaviour spec in [`SPEC.md`](SPEC.md), what is next in [`ROADMAP.md`](./ROADMAP.md), and the release history in [`CHANGELOG.md`](./CHANGELOG.md).
+Want to build a CLI agent like this yourself? [`docs/blueprint.md`](./docs/blueprint.md) is the minimal spec: the components, the turn, the tools, the permission rules, and the acceptance checks, with no dependency on scoot's code.
 New capability is a drop-in file: a tool in `tools/`, a slash command in `commands/`, a provider row or adapter in `providers/`.
 
 ## Security

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/__init__.py

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

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/agent.py

@@ -27,13 +27,20 @@ from .tools.base import ToolContext, ToolResult
 
 @dataclass
 class AgentOutcome:
-    status: str  # "done" | "interrupted" | "aborted" | "max_steps" | "error"
+    status: str  # "done" | "incomplete" | "interrupted" | "aborted" | "max_steps" | "error"
     content: str = ""
     error: str = ""
     steps: int = 0
     streamed: bool = False  # True if the final content was already printed live (streaming)
 
 
+# finish reasons that mean the reply is not the model's whole answer, and what to tell the user.
+_CUT_OFF = {
+    "length": "the model hit its output limit",
+    "incomplete": "the stream ended before the reply was complete",
+}
+
+
 def _strip_done(text: str) -> str:
     """Remove a trailing ``DONE`` sentinel line from the model's final message."""
     lines = (text or "").rstrip().splitlines()
@@ -104,6 +111,7 @@ class Agent:
         steps = 0
         compacted = False
         stop_blocks = 0
+        cut_off = 0  # tool batches the model could not finish (output limit); bounded retries
         while True:
             if cancel_event.is_set():
                 return AgentOutcome("interrupted", steps=steps)
@@ -145,14 +153,28 @@ class Agent:
             if result.tool_calls:
                 if (result.content or "").strip() and not streamed:
                     ui.assistant(result.content.strip())
+                if result.finish_reason in _CUT_OFF:
+                    # The reply stopped before the calls were complete: their arguments cannot be
+                    # trusted, so nothing runs. Tell the model once or twice, then give up.
+                    cut_off += 1
+                    self._close_batch(session, result.tool_calls,
+                                      "not executed: the reply was cut off before this tool call was "
+                                      "complete; call it again with less in one call")
+                    if cut_off >= 2:
+                        return AgentOutcome("incomplete", steps=steps, error=_CUT_OFF[result.finish_reason])
+                    ui.assistant(f"reply cut off ({_CUT_OFF[result.finish_reason]}); asking the model to retry.")
+                    continue
                 signal = self._run_tools(session, result.tool_calls, ui, cancel_event, cfg)
                 if signal in ("abort", "interrupted"):
                     status = "aborted" if signal == "abort" else "interrupted"
                     return AgentOutcome(status, steps=steps)
                 continue
 
-            # No tool calls -> the model is done, unless a Stop hook asks for more (bounded).
+            # No tool calls -> the model is done, unless it was cut off or a Stop hook asks for more (bounded).
             content = _strip_done(result.content)
+            if result.finish_reason in _CUT_OFF:
+                return AgentOutcome("incomplete", content=content, steps=steps, streamed=streamed,
+                                    error=_CUT_OFF[result.finish_reason])
             if stop_blocks < 3:
                 reason = self._stop_hook(session, content, steps)
                 if reason:
@@ -344,16 +366,48 @@ class Agent:
         )
 
     @staticmethod
-    def _parse_args(raw) -> dict:
+    def _tool_payload(result: ToolResult) -> str:
+        """What the model reads back. On failure the error line comes first, followed by whatever
+        the tool captured: a failing test's or compiler's output is exactly what the model needs
+        next, and ``ERROR: exit 1`` alone only invites a blind rerun."""
+        if result.ok:
+            return result.content or "(no output)"
+        head = f"ERROR: {result.error or 'failed'}"
+        body = (result.content or "").strip()
+        if body.startswith(result.error or "\0"):
+            body = body[len(result.error):].lstrip("\n")
+        return f"{head}\n{body}" if body else head
+
+    @staticmethod
+    def _parse_args(raw) -> Optional[dict]:
+        """The call's arguments as a dict; ``None`` when they are not a JSON object (a truncated or
+        malformed call must not run as if it had no arguments)."""
         if isinstance(raw, dict):
             return raw
         if not raw:
             return {}
         try:
             parsed = json.loads(raw)
-            return parsed if isinstance(parsed, dict) else {}
         except (json.JSONDecodeError, TypeError):
-            return {}
+            return None
+        return parsed if isinstance(parsed, dict) else None
+
+    @staticmethod
+    def _close_batch(session, tool_calls, note: str) -> None:
+        """Give every call in the batch that has no result yet a result saying why.
+
+        Called on abort, interrupt, and cut-off replies: a history with an unanswered tool call is
+        rejected by providers on the next request, so the turn must never leave one behind.
+        """
+        answered = set()
+        for m in reversed(session.messages):
+            if m.get("role") != "tool":
+                break
+            answered.add(m.get("tool_call_id"))
+        for tc in tool_calls:
+            tc_id = tc.get("id", "")
+            if tc_id not in answered:
+                session.messages.append({"role": "tool", "tool_call_id": tc_id, "content": note})
 
     # ── tool execution ───────────────────────────────────────────────────────────
     def _run_tools(self, session, tool_calls, ui, cancel_event, cfg=None) -> Optional[str]:
@@ -379,7 +433,7 @@ class Agent:
                 pass
         for tc in tool_calls:
             if cancel_event.is_set():
-                return "interrupted"
+                return self._interrupted(session, tool_calls)
             tc_id = tc.get("id", "")
             fn = tc.get("function", {}) or {}
             name = fn.get("name", "")
@@ -389,6 +443,11 @@ class Agent:
             if tool is None:
                 self._append_tool(session, tc_id, f"error: unknown tool '{name}'")
                 continue
+            if args is None:
+                self._append_tool(session, tc_id, "error: the arguments are not a JSON object (the call may "
+                                                  "have been cut off); call the tool again")
+                ui.tool_result(name, ToolResult(ok=False, summary="malformed arguments"))
+                continue
 
             # Paths outside the workspace: ask the user once (this path, its directory, or anywhere).
             outside = self._outside_paths(tool, args, ctx)
@@ -396,13 +455,16 @@ class Agent:
                 verdict = self._ask_scope(session, tool, outside, ctx, ui)
                 if verdict == "abort":
                     self._append_tool(session, tc_id, "user aborted the operation")
-                    return "abort"
+                    return self._aborted(session, tool_calls)
                 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 cancel_event.is_set():  # ESC while the hook ran
+                self._append_tool(session, tc_id, "not executed: the user interrupted the turn")
+                return self._interrupted(session, tool_calls)
             if hook_action == "deny":
                 self._append_tool(session, tc_id, f"user declined via hook: {hook_reason or 'no reason given'}")
                 ui.tool_result(name, ToolResult(ok=False, summary=f"denied by hook: {hook_reason}"[:80]))
@@ -423,7 +485,7 @@ class Agent:
                 approval = ui.approve(tool, args, ctx)
                 if approval.decision == Decision.ABORT:
                     self._append_tool(session, tc_id, "user aborted the operation")
-                    return "abort"
+                    return self._aborted(session, tool_calls)
                 if approval.decision == Decision.SKIP:
                     self._append_tool(
                         session, tc_id, "user declined this action; consider another approach"
@@ -442,16 +504,25 @@ class Agent:
                 with ui.activity(f"running {name}…", cancel_event):
                     result = tool.run(args, ctx)
             except Interrupted:
-                return "interrupted"
+                self._append_tool(session, tc_id, "interrupted by the user while running; it may have "
+                                                  "partially completed, check before repeating it")
+                return self._interrupted(session, tool_calls)
             except Exception as exc:  # a tool must never take down the loop
                 result = ToolResult.fail(f"tool crashed: {exc}")
 
             self._handle_result(session, name, result, ui)
             self._post_tool_hook(session, tool, args, result)
-            payload = result.content if result.ok else f"ERROR: {result.error}"
-            self._append_tool(session, tc_id, payload or "(no output)")
+            self._append_tool(session, tc_id, self._tool_payload(result))
         return None
 
+    def _aborted(self, session, tool_calls) -> str:
+        self._close_batch(session, tool_calls, "not executed: the user aborted the turn")
+        return "abort"
+
+    def _interrupted(self, session, tool_calls) -> str:
+        self._close_batch(session, tool_calls, "not executed: the user interrupted the turn")
+        return "interrupted"
+
     @staticmethod
     def _outside_paths(tool, args, ctx) -> "list":
         from .tools.base import resolve_path

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/cli.py

@@ -210,6 +210,8 @@ def _run_once(config: Config, pool: ProviderPool, prompt: str, as_json: bool, re
                          f"completion={u.get('completion_tokens', '?')} "
                          f"cost={fmt(session.session_cost())}", "gray"))
         return 0
+    if outcome.status == "incomplete" and outcome.content.strip() and not outcome.streamed:
+        print(outcome.content.strip())
     eprint(color(f"⚠ {redact(outcome.error or outcome.status)}", "red"))
     return 1
 
@@ -229,9 +231,9 @@ def _interactive(pool: ProviderPool, resume=None, remember_model: Optional[str]
     """Launch the persistent REPL (banner, live status, ESC-interrupt, slash-commands).
 
     ``remember_model`` is the model named on the command line (``--model``), if any. Launching the REPL
-    with it counts as choosing it, exactly like ``/model`` inside the REPL, so it is saved as the
-    preference and a plain ``scoot`` next time starts on the same model. One-shot prompts and headless
-    runs do not save it: a flag on a single command is not a choice for the next session.
+    with it counts as choosing it for this folder, exactly like ``/model`` inside the REPL, so a plain
+    ``scoot`` here next time starts on the same model. One-shot prompts and headless runs do not save
+    it: a flag on a single command is not a choice for the next session.
     """
     from .repl import Repl
 
@@ -239,7 +241,7 @@ def _interactive(pool: ProviderPool, resume=None, remember_model: Optional[str]
     if remember_model and remember_model.strip():
         from .preferences import set_model
 
-        set_model(remember_model.strip())
+        set_model(remember_model.strip(), root=config.root)
     # resume=auto (SCOOT_RESUME / --resume-last): reload the latest session for this directory
     # unless the user already picked one explicitly via --resume/--continue.
     if resume is None and getattr(config, "resume", "hint") == "auto":

scootcli-0.9.0/src/scootcli/commands/model.py

@@ -0,0 +1,115 @@
+"""/model: list available models or switch the active one.
+
+Models are ``provider/model`` ids (``openai/gpt-5.3-codex``, ``ollama/llama3.2``); a bare name means
+the default provider. A switch made here is **persisted** (``~/.config/scoot/preferences.json``) for
+this folder, so the next launch here reuses it; ``/model X everywhere`` saves it for every folder
+without a choice of its own, and ``/model forget`` drops this folder's choice so it follows that. An
+explicit ``--model`` flag or ``SCOOT_MODEL`` still overrides it for that run.
+"""
+
+from __future__ import annotations
+
+from .. import preferences
+from ..providers.base import qualify, split_model_id
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+_USAGE = "/model <provider/model> · /model default · /model auto (pick per task) · add 'everywhere' for all folders · /model forget"
+
+
+def _root(session):
+    return getattr(getattr(session, "config", None), "root", None)
+
+
+def _saved_line(session) -> str:
+    folder, everywhere = preferences.saved_models(_root(session))
+    return f"saved: this folder {folder or '(none)'} · everywhere {everywhere or '(none)'}"
+
+
+def _remember(session, name: str, everywhere: bool) -> str:
+    """Persist ``name`` for this folder (or every folder); return how to say so."""
+    root = _root(session)
+    if everywhere:
+        preferences.set_model_everywhere(name, root=root)
+        _note_origin(session, name, preferences.EVERYWHERE)
+        return "saved for every folder"
+    preferences.set_model(name, root=root)
+    _note_origin(session, name, preferences.FOLDER)
+    return "saved for this folder"
+
+
+def _note_origin(session, name: str, source: str) -> None:
+    """Keep ``config.model_source`` truthful after a switch, so ``/status`` names the right layer."""
+    cfg = getattr(session, "config", None)
+    if cfg is not None and hasattr(cfg, "override"):
+        session.config = cfg.override(model=name, model_source=source)
+
+
+def _run(session, args: str):
+    words = args.split()
+    everywhere = False
+    if words and words[-1].lower() == "everywhere":
+        everywhere = True
+        words = words[:-1]
+    arg = " ".join(words)
+    available = session.available_models()
+
+    if not arg:
+        print(color(f"models  (preference: {session.model} → active: {session.active_model})", "bold"))
+        print(color(f"  {_saved_line(session)}", "gray"))
+        current = ""
+        for mid in available:
+            head, _ = split_model_id(mid)
+            if head != current:
+                current = head
+                print(color(f"  {head}", "bold"))
+            mark = color(" ← active", "green") if mid == session.active_model else ""
+            print("    " + color(mid, "cyan") + mark)
+        errors = getattr(getattr(session, "provider", None), "list_errors", None) or {}
+        for name, err in sorted(errors.items()):
+            print(color(f"  {name}: unavailable ({err})", "yellow"))
+        print(color(f"  use: {_USAGE}", "gray"))
+        return
+
+    if arg == "forget":
+        preferences.clear_model(root=_root(session))
+        session.model = preferences.get_model(_root(session)) or "default"
+        session.active_model = session.resolved_model()
+        _note_origin(session, session.model, preferences.model_source(_root(session)) or "default")
+        print(color(f"this folder's model choice forgotten; now {session.model} → {session.active_model}. "
+                    f"{_saved_line(session)}", "gray"))
+        if hasattr(session, "refresh_readiness") and not session.refresh_readiness():
+            print(color(session.setup_message, "yellow"))
+        return
+
+    if arg in ("auto", "default"):
+        session.model = arg
+        session.active_model = session.resolved_model()
+        how = _remember(session, arg, everywhere)
+        what = "picked per task from the live list" if arg == "auto" else f"the provider's preferred model, now {session.active_model}"
+        print(color(f"model preference set to {arg} ({what}); {how}.", "gray"))
+        if hasattr(session, "refresh_readiness") and not session.refresh_readiness():
+            print(color(session.setup_message, "yellow"))
+        return
+
+    if arg not in available:
+        head, _ = split_model_id(arg)
+        if head is None:
+            try:
+                arg = qualify(session.provider.default_name, arg)
+            except Exception:
+                pass
+        if arg not in available:
+            print(color(f"warning: '{arg}' is not in the models list; setting it anyway.", "yellow"))
+    session.model = arg
+    session.active_model = arg
+    how = _remember(session, arg, everywhere)
+    print(color(f"model set to {arg}; {how}.", "gray"))
+    if hasattr(session, "refresh_readiness") and not session.refresh_readiness():
+        print(color(session.setup_message, "yellow"))
+
+
+register(SlashCommand("model", "list or switch model (default|auto|provider/model), per folder or everywhere",
+                      _run, usage="[provider/model|default|auto] [everywhere] | forget"))
+

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/commands/status.py

@@ -7,6 +7,16 @@ from . import register
 from .base import SlashCommand
 
 
+_ORIGINS = {"flag": "--model", "env": "SCOOT_MODEL", "folder": "saved for this folder",
+            "everywhere": "saved for every folder", "default": "the default"}
+
+
+def _model_origin(session) -> str:
+    """``"  (from --model)"`` and the like: which layer chose the model this run started with."""
+    src = getattr(getattr(session, "config", None), "model_source", "")
+    return f"  (from {_ORIGINS[src]})" if src in _ORIGINS else ""
+
+
 def _run(session, args: str):
     cfg = session.config
     try:
@@ -20,7 +30,8 @@ def _run(session, args: str):
         provider_row = getattr(cfg, "provider", "") or "?"
     rows = [
         ("provider", provider_row),
-        ("model", session.active_model + ("  (auto)" if session.model.lower() == "auto" else "")),
+        ("model", session.active_model + ("  (auto)" if session.model.lower() == "auto" else "")
+         + _model_origin(session)),
         ("effort", getattr(cfg, "effort", "medium")),
         ("env files", ", ".join(getattr(cfg, "env_files", ()) or ()) or "none"),
         ("update", (f"{session.update_available} available: pipx upgrade scootcli"

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/commands/worktree.py

@@ -25,7 +25,7 @@ def _start(session):
         eprint(color(f"could not create worktree: {exc}", "red"))
         return
     session.worktree = w
-    session.config = session.config.override(root=str(w.path))
+    session.switch_root(w.path)
     print(color(f"⚙ isolated in worktree {w.branch}", "cyan"))
     print(color(f"  root → {w.path}", "gray"))
     print(color("  work freely (try /yolo); then /worktree merge|keep|discard", "gray"))
@@ -36,10 +36,15 @@ def _finish(session, action):
     if w is None:
         print(color("not in a worktree.", "yellow"))
         return
-    msg = wt.finish(w, action)
-    session.config = session.config.override(root=str(w.original_root))
+    result = wt.finish(w, action)
+    print(color(result.message, "gray" if result.ok else "yellow"))
+    if result.retained:
+        # The work is still in the worktree; the session stays there so nothing is lost.
+        print(color(f"  still in worktree {w.branch} at {w.path}", "gray"))
+        print(color(f"  fix it and run /worktree {action} again, or /worktree discard to drop it", "gray"))
+        return
+    session.switch_root(w.original_root)
     session.worktree = None
-    print(color(f"{msg}", "gray"))
     print(color(f"  root → {w.original_root}", "gray"))
 
 

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/config.py

@@ -2,6 +2,9 @@
 
 Precedence (highest wins):
   CLI flag → environment variable → project ``.env`` → global ``~/.config/scoot/.env`` → default.
+The model has two more layers between the ``.env`` files and the default: the model saved for this
+workspace root, then the one saved for every folder (see ``preferences.py``); ``model_source`` says
+which layer answered.
 
 Two optional ``.env`` files are read: the global one in scoot's config home, and the nearest ``.env``
 found walking up from the current directory (so a repo-root file applies from any subdirectory).
@@ -129,16 +132,23 @@ def is_model_alias(model: Optional[str]) -> bool:
     return (model or "").strip().lower() in (DEFAULT_MODEL_ALIAS, AUTO_MODEL_ALIAS, "")
 
 
-def _resolve_model_setting(model_env: Optional[str]) -> str:
-    """Model precedence (below the CLI flag, applied later): SCOOT_MODEL → saved pref → default."""
+MODEL_SOURCES = ("flag", "env", "folder", "everywhere", "default")
+
+
+def _resolve_model_setting(model_env: Optional[str], root=None) -> Tuple[str, str]:
+    """``(model, source)`` below the CLI flag (applied later): SCOOT_MODEL → the model saved for
+    ``root`` → the model saved for every folder → default."""
     if model_env:
-        return model_env
+        return model_env, "env"
     try:
-        from .preferences import get_model
+        from .preferences import get_model, model_source
 
-        return get_model() or DEFAULT_MODEL_ALIAS
+        saved = get_model(root)
+        if saved:
+            return saved, model_source(root) or "everywhere"
     except Exception:
-        return DEFAULT_MODEL_ALIAS
+        pass
+    return DEFAULT_MODEL_ALIAS, "default"
 
 
 def _resolve_logo_setting(logo_env: Optional[str]) -> bool:
@@ -161,6 +171,7 @@ class Config:
     proxy: str = DEFAULT_PROXY
     provider: str = ""  # default provider name; empty → first provider with a key, else ollama
     model: str = DEFAULT_MODEL_ALIAS  # "default" | "auto" | a model id, ideally provider/model
+    model_source: str = "default"  # where ``model`` came from: flag | env | folder | everywhere | default
     effort: str = "medium"  # reasoning effort for models that take it: low | medium | high | xhigh
     timeout: int = 120
     max_steps: int = 50
@@ -194,17 +205,20 @@ class Config:
             load_dotenv(env_file)
 
         get = os.environ.get
+        root = Path(get("SCOOT_ROOT", str(cwd))).resolve()
+        model, model_source = _resolve_model_setting(get("SCOOT_MODEL"), root)
         return cls(
             proxy=get("HTTPS_PROXY") or get("https_proxy") or DEFAULT_PROXY,
             env_files=tuple(str(f) for f in files),
             provider=get("SCOOT_PROVIDER", "").strip().lower(),
-            model=_resolve_model_setting(get("SCOOT_MODEL")),
+            model=model,
+            model_source=model_source,
             effort=get("SCOOT_EFFORT", "medium").strip().lower(),
             timeout=int(get("SCOOT_TIMEOUT", "120")),
             max_steps=int(get("SCOOT_MAX_STEPS", "50")),
             compact_at=int(get("SCOOT_COMPACT_AT", "100000")),
             approval=get("SCOOT_APPROVAL", "yolo"),
-            root=Path(get("SCOOT_ROOT", str(cwd))).resolve(),
+            root=root,
             verbose=_as_bool(get("SCOOT_VERBOSE", "false")),
             stream=_as_bool(get("SCOOT_STREAM", "true")),
             panel=_as_bool(get("SCOOT_PANEL", "true")),
@@ -223,10 +237,18 @@ class Config:
         )
 
     def override(self, **kwargs) -> "Config":
-        """Return a copy with the given (non-None) fields overridden — the CLI-flag layer."""
+        """Return a copy with the given (non-None) fields overridden: the CLI-flag layer.
+
+        A ``model`` here is the flag. A new ``root`` (``--root``) without one re-resolves the saved
+        model for that folder, unless the flag or ``SCOOT_MODEL`` already decided it.
+        """
         clean = {k: v for k, v in kwargs.items() if v is not None}
         if "root" in clean:
             clean["root"] = Path(clean["root"]).resolve()
+        if "model" in clean:
+            clean.setdefault("model_source", "flag")
+        elif "root" in clean and self.model_source not in ("flag", "env") and clean["root"] != self.root:
+            clean["model"], clean["model_source"] = _resolve_model_setting(None, clean["root"])
         return replace(self, **clean)
 
     def resolve_model(self, task_hint: str = "") -> str:

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/headless.py

@@ -302,6 +302,8 @@ class Headless:
                 self.writer.emit("notice", message=f"reached the step limit ({self.session.config.max_steps}); send another prompt to continue")
             if outcome.status == "error":
                 self.writer.emit("error", message=outcome.error, kind="turn")
+            if outcome.status == "incomplete":
+                self.writer.emit("notice", message=f"reply cut off: {outcome.error}; the content is partial")
             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(),

{scootcli-0.8.0 → scootcli-0.9.0}/src/scootcli/hooks.py

@@ -24,7 +24,6 @@ from __future__ import annotations
 import json
 import os
 import re
-import subprocess
 import threading
 import time
 from dataclasses import dataclass, field
@@ -186,29 +185,36 @@ class Hooks:
         return Decision(context="\n".join(context))
 
     def _run_command(self, event: str, command: str, payload: dict, timeout: int, cancel_event) -> Decision:
+        from .errors import Interrupted
+        from .tools.base import ToolError, run_subprocess
+
         env = dict(os.environ)
         env["SCOOT_SESSION_ID"] = str(payload.get("session_id", ""))
         env["SCOOT_HOOK_EVENT"] = event
         started = time.time()
         try:
-            proc = subprocess.run(
-                command, shell=True, cwd=str(self.root), env=env, input=json.dumps(payload),
-                capture_output=True, text=True, timeout=timeout,
+            # The same runner as the tools: its own process group, bounded waits, ESC honoured.
+            returncode, stdout, stderr = run_subprocess(
+                ["/bin/sh", "-c", command], self.root, cancel_event, timeout=timeout, env=env,
+                input_text=json.dumps(payload),
             )
-        except subprocess.TimeoutExpired:
+        except ToolError:
             self._record(event, command, "timeout", f"after {timeout}s", started)
             return Decision()
+        except Interrupted:
+            self._record(event, command, "cancelled", "by the user", started)
+            return Decision()
         except OSError as exc:
             self._record(event, command, "error", str(exc), started)
             return Decision()
-        out = (proc.stdout or "")[:_MAX_CAPTURE].strip()
-        err = (proc.stderr or "")[:_MAX_CAPTURE].strip()
-        if proc.returncode == 2:
+        out = (stdout or "")[:_MAX_CAPTURE].strip()
+        err = (stderr or "")[:_MAX_CAPTURE].strip()
+        if returncode == 2:
             action = "deny" if event == "PreToolUse" else "block"
             self._record(event, command, action, err, started)
             return Decision(action=action, reason=err or "blocked by hook")
-        if proc.returncode != 0:
-            self._record(event, command, "error", f"exit {proc.returncode}: {err[:200]}", started)
+        if returncode != 0:
+            self._record(event, command, "error", f"exit {returncode}: {err[:200]}", started)
             return Decision()
         if not out:
             self._record(event, command, "ok", "", started)