scootcli 0.8.1__tar.gz → 0.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.8.1
+Version: 0.9.0
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -239,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
 
@@ -314,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.1 → scootcli-0.9.0}/README.md

@@ -214,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
 
@@ -289,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.1 → 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.1"
+__version__ = "0.9.0"
 

{scootcli-0.8.1 → 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.1 → 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
 

{scootcli-0.8.1 → 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.1 → 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.1 → 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)

{scootcli-0.8.1 → scootcli-0.9.0}/src/scootcli/providers/anthropic.py

@@ -36,6 +36,7 @@ from .base import (
     ChatRequest,
     ChatResult,
     decode_json,
+    STREAM_ENDED,
     finish_stream,
     iter_sse_json,
     normalize_usage,
@@ -184,7 +185,7 @@ def translate_tool(tool: dict) -> dict:
 
 # ── response parsing ────────────────────────────────────────────────────────────
 _STOP = {"end_turn": "stop", "tool_use": "tool_calls", "max_tokens": "length", "stop_sequence": "stop",
-         "pause_turn": "stop", "refusal": "refusal"}
+         "pause_turn": "stop", "refusal": "refusal", STREAM_ENDED: "incomplete"}
 
 
 def total_input_usage(usage: Optional[dict]) -> dict:
@@ -213,7 +214,9 @@ def build_result(blocks: List[dict], model: str, usage: Optional[dict], stop_rea
                    "function": {"name": b.get("name", ""), "arguments": json.dumps(b.get("input") or {})}}
                   for b in blocks if b.get("type") == "tool_use"]
     content = streamed_text or "".join(texts)
-    finish = "tool_calls" if tool_calls else _STOP.get(stop_reason, "stop")
+    finish = _STOP.get(stop_reason, "stop")
+    if finish not in ("length", "incomplete") and tool_calls:
+        finish = "tool_calls"
     message: dict = {"role": "assistant", "content": content}
     if tool_calls:
         message["tool_calls"] = tool_calls
@@ -351,4 +354,5 @@ class AnthropicProvider(BaseProvider):
             raise_for_status(400, json.dumps({"error": state.error}), self.name)
             raise ApiError(str(state.error))
         return build_result(state.ordered_blocks(), self.qualified(state.model or req.model), state.usage,
-                            state.stop_reason, state.stop_details, streamed_text="".join(state.text))
+                            state.stop_reason or STREAM_ENDED, state.stop_details,
+                            streamed_text="".join(state.text))

{scootcli-0.8.1 → scootcli-0.9.0}/src/scootcli/providers/base.py

@@ -380,20 +380,34 @@ def iter_sse_json(lines: Iterator[str], status_holder: dict, leftovers: List[str
             status_holder["saw_data"] = True
             data = stripped[len("data:"):].strip()
             if data == "[DONE]":
+                status_holder["done"] = True
                 continue
             try:
                 yield json.loads(data)
             except json.JSONDecodeError:
+                # Counted, not skipped: a dropped event means lost text or a broken tool call.
+                status_holder["malformed"] = status_holder.get("malformed", 0) + 1
                 continue
         else:
             leftovers.append(line)
 
 
 def finish_stream(status_holder: dict, leftovers: List[str], provider: str) -> None:
-    """After a stream ends: raise the typed error for a non-200 status or a plain error body."""
+    """After a stream ends: raise the typed error for a non-200 status or a plain error body, for
+    a 200 that carried no events at all, and for events that could not be parsed."""
     status = status_holder.get("status", 200)
     if status != 200 or (not status_holder.get("saw_data") and leftovers):
         body = "".join(leftovers).strip()
         raise_for_status(status if status != 200 else 400, body, provider)
         if body:
             raise ApiError(body[:200], status=status)
+    if not status_holder.get("saw_data"):
+        raise ApiError(f"{provider} returned an empty stream (no events before the connection closed)",
+                       status=status, hint="a proxy or the endpoint closed the connection early; try again")
+    malformed = status_holder.get("malformed", 0)
+    if malformed:
+        raise ApiError(f"{provider} sent {malformed} unreadable stream event(s); the reply is not complete",
+                       status=status, hint="try again; if it repeats, check the proxy or the endpoint")
+
+
+STREAM_ENDED = "stream_ended"  # an adapter's stop marker when the stream closed before its terminal event

{scootcli-0.8.1 → scootcli-0.9.0}/src/scootcli/providers/openai_chat.py

@@ -137,6 +137,8 @@ class OpenAIChatProvider(BaseProvider):
             if text:
                 on_delta(text)
         finish_stream(holder, leftovers, self.name)
+        if not acc.finish_reason and not holder.get("done"):
+            acc.finish_reason = "incomplete"  # neither a finish_reason nor [DONE]: the stream broke off
         result = acc.result(req.model)
         result.model = self.qualified(result.model)
         return result

{scootcli-0.8.1 → scootcli-0.9.0}/src/scootcli/providers/openai_responses.py

@@ -26,6 +26,7 @@ from .base import (
     ChatRequest,
     ChatResult,
     decode_json,
+    STREAM_ENDED,
     finish_stream,
     iter_sse_json,
     normalize_usage,
@@ -149,10 +150,12 @@ def build_result(items: List[dict], model: str, usage: Optional[dict], status: s
     texts = [_text_of(it) for it in items if it.get("type") == "message"]
     tool_calls = [_tool_call_of(it) for it in items if it.get("type") == "function_call"]
     content = streamed_text or "".join(texts)
-    if tool_calls:
+    if status == "incomplete":
+        finish = "length"  # even with tool calls: their arguments may be cut short
+    elif status == STREAM_ENDED:
+        finish = "incomplete"
+    elif tool_calls:
         finish = "tool_calls"
-    elif status == "incomplete":
-        finish = "length"
     else:
         finish = "stop"
     message: dict = {"role": "assistant", "content": content}
@@ -245,4 +248,4 @@ class OpenAIResponsesProvider(BaseProvider):
             raise_for_status(400, json.dumps({"error": state.error}), self.name)
             raise ApiError(str(state.error))
         return build_result(state.items, self.qualified(state.model or req.model), state.usage,
-                            state.status, streamed_text="".join(state.text))
+                            state.status or STREAM_ENDED, streamed_text="".join(state.text))

{scootcli-0.8.1 → scootcli-0.9.0}/src/scootcli/repl.py

@@ -120,23 +120,41 @@ class ReplSession:
             messages=self.messages,
         )
 
+    def switch_root(self, root) -> None:
+        """Move the session to another workspace (entering or leaving a worktree).
+
+        The config root, the file scope, and the hooks move together, so a worktree nested under the
+        original checkout does not keep the original in scope. Paths granted for the old root are
+        dropped rather than carried into the new one.
+        """
+        from .tools.base import Scope
+
+        self.config = self.config.override(root=str(root))
+        self.scope = Scope(self.config.root, everything=(getattr(self.config, "scope", "workspace") == "anywhere"))
+        if getattr(self, "hooks", None) is not None:
+            from .hooks import Hooks
+
+            self.hooks = Hooks(self.config.root)
+
     def apply_record(self, record) -> None:
-        """Load a saved conversation + settings into this live session.
+        """Load a saved conversation into this live session.
 
         The saved model is adopted only when this run set nothing explicit (the preference is still
         the ``default`` alias) and the saved model's provider is configured; an explicit ``--model`` /
         ``SCOOT_MODEL`` / saved preference for this run always wins over what the session recorded.
+        The approval mode is never restored: it is this run's permission policy, and resuming a
+        session that once ran in ``yolo`` must not quietly turn ``--approval always`` into ``yolo``.
         """
+        from .sessions import complete_tool_results
+
         self.id = record.id
         self.created = record.created or self.created
         if self._may_adopt_saved_model(record.model, record.active_model):
             self.model = record.model or self.model
             self.active_model = record.active_model or self.active_model
-        if record.approval_mode in MODES:
-            self.approval_mode = record.approval_mode
         self.total_prompt = record.total_prompt
         self.total_completion = record.total_completion
-        self.messages = list(record.messages)
+        self.messages = complete_tool_results(list(record.messages))
         self.resumed = True
 
     def refresh_readiness(self) -> bool:
@@ -967,6 +985,14 @@ class Repl:
                     f"[{session.resolved_model()}] steps={outcome.steps} "
                     f"prompt={u.get('prompt_tokens', '?')} "
                     f"completion={u.get('completion_tokens', '?')}", "gray"))
+        elif outcome.status == "incomplete":
+            partial = outcome.content.strip()
+            session.last_output = partial
+            if partial and not outcome.streamed:
+                if self.labels and sys.stdout.isatty():
+                    print(_assistant_label(self.ui.emoji))
+                print(partial)
+            print(color(f"⚠ reply cut off: {outcome.error}. ask it to continue, or split the task.", "yellow"))
         elif outcome.status == "interrupted":
             print(color("⏹ interrupted", "yellow"))
         elif outcome.status == "aborted":

{scootcli-0.8.1 → scootcli-0.9.0}/src/scootcli/sessions.py

@@ -35,6 +35,35 @@ def new_session_id() -> str:
     return time.strftime("%Y%m%d-%H%M%S") + "-" + os.urandom(2).hex()
 
 
+def complete_tool_results(messages: List[dict]) -> List[dict]:
+    """Return ``messages`` with a result present for every assistant tool call.
+
+    A turn interrupted mid-batch used to leave calls without results; providers reject such a
+    history on the next request. Missing results are filled with a note, in place, right after the
+    results that do exist, so the conversation replays.
+    """
+    out: List[dict] = []
+    i = 0
+    while i < len(messages):
+        m = messages[i]
+        out.append(m)
+        i += 1
+        calls = m.get("tool_calls") if isinstance(m, dict) and m.get("role") == "assistant" else None
+        if not calls:
+            continue
+        answered = set()
+        while i < len(messages) and isinstance(messages[i], dict) and messages[i].get("role") == "tool":
+            answered.add(messages[i].get("tool_call_id"))
+            out.append(messages[i])
+            i += 1
+        for tc in calls:
+            tc_id = tc.get("id", "") if isinstance(tc, dict) else ""
+            if tc_id not in answered:
+                out.append({"role": "tool", "tool_call_id": tc_id,
+                            "content": "no result recorded: the turn was interrupted before this call finished"})
+    return out
+
+
 def _redact_messages(messages: List[dict]) -> List[dict]:
     """Copy messages, masking token-like substrings in string content fields."""
     cleaned: List[dict] = []