lcode-cli 0.33.1__py3-none-any.whl → 0.35.0__py3-none-any.whl

lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.33.1"
+__version__ = "0.35.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

lcode/agent.py

@@ -29,6 +29,7 @@ from lcode import (
     catalog,
     checks,
     codesearch,
+    escalate,
     extensions,
     limits,
     notify,
@@ -48,7 +49,7 @@ from lcode.config import format_tokens
 from lcode.jobs import Jobs
 from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
-from lcode.permissions import Permissions
+from lcode.permissions import LEADING_CD, Permissions
 from lcode.render import MarkdownStreamer
 from lcode.repeats import Repeats
 from lcode.sandbox import Sandbox, SandboxError, project_root
@@ -122,7 +123,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 # Verifying your work
 - A syntax check or an import only shows that code loads. Run what you changed the way it will be used (the script, the tests, the app) and fix what fails.
 - To fix a bug, first reproduce each problem the user reports with a test, a command or a short script, then run the same checks to show they're gone.
-- For what you can't see, like a GUI, a web page or a layout, check it without a screen where you can: `QT_QPA_PLATFORM=offscreen` for Qt, a headless browser, or a script that prints sizes and positions or renders to an image{look}. Measure instead of assuming.
+- For what you can't see, like a GUI, a web page or a layout, use the screenshot tool: it runs the program (or opens the page) without a screen and returns what it shows, with the sizes of windows, widgets or the page measured{look}. Measure instead of assuming.
 - Never claim something works, mark a todo done, or call it tested unless you ran it. If you couldn't check something, say so and tell the user exactly what to look for. If something fails, say so and show the relevant error.{checks}
 
 # Communication
@@ -131,7 +132,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 
 # Environment
 - Working directory: {cwd}
-- OS: {os}; shell: bash; Python command: `{python}`
+- OS: {os}; shell: bash; Python command: {python}
 - Date: {date}
 - Git: {git}
 
@@ -218,6 +219,30 @@ def call_arguments(call: dict) -> dict:
     return args if isinstance(args, dict) else {}
 
 
+VENV_DIRS = (".venv", "venv", "env")
+
+
+def project_python(cwd: Path) -> Path | None:
+    """The project's virtual environment's Python (.venv, venv or env, here or up to the repository's root)."""
+    for folder in [cwd, *cwd.parents][:4]:
+        for name in VENV_DIRS:
+            path = folder / name / "bin" / "python"
+            if path.exists() and (folder / name / "pyvenv.cfg").exists():
+                return path
+        if (folder / ".git").exists():
+            break  # not beyond the repository
+    return None
+
+
+def python_line(cwd: Path) -> str:
+    """How the system prompt names the Python command."""
+    venv = project_python(cwd)
+    if venv is None:
+        return f"`{'python' if shutil.which('python') else 'python3'}`"
+    shown = venv.relative_to(cwd) if cwd in venv.parents else venv
+    return f"`{shown}` (the project's virtual environment: plain python lacks its packages)"
+
+
 class Progress:
     """The status line under a running request.
 
@@ -283,6 +308,9 @@ class Settings:
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
     checks: str = "off"  # the project's checks after a change (lcode.checks): auto, off or a command
     review: str = "off"  # check a change against the request before the answer (lcode.review): auto or off
+    escalate_model: str | None = None  # a stronger model to ask when stuck (lcode.escalate): provider/model
+    escalate_url: str | None = None  # its server, when not the provider's usual one
+    escalate_price: str | None = None  # dollars per million tokens in/out, e.g. "3/15", for the cost estimate
 
 
 class Agent:
@@ -345,6 +373,8 @@ class Agent:
         self._check: tuple[Path, checks.Check | None] | None = None
         self.check_results: list[dict] = []  # the checks of the last request: command, exit code, who ran them
         self.review_results: list[str] | None = None  # what the last request's review found (None: no review)
+        self.escalations: list[dict] = []  # the stronger model asked in the last request (lcode.escalate)
+        self.escalate_approved: bool | None = None  # decided in advance (lcode -p --escalate, the benchmark)
         self.sent_chars = 0  # characters of the conversation the model had already read
         self.counted_chars: int | None = None  # characters that ctx_used covers (None: all of them)
         self.turn_status = ""  # how the last request ended: success, max_steps, loop
@@ -372,7 +402,7 @@ class Agent:
             model=self.settings.model,
             cwd=self.cwd,
             os=f"{platform.system()} {platform.release()} ({platform.machine()})",
-            python="python" if shutil.which("python") else "python3",
+            python=python_line(self.cwd),
             date=dt.date.today().isoformat(),
             git=git_info(self.cwd),
             tree=tree(self.cwd, depth=1, limit=120),
@@ -383,7 +413,7 @@ class Agent:
             skills=extensions.skills_prompt(self.extensions().skills, self.settings.context),
             code=self.code_prompt(),
             map=self.map_prompt(),
-            look=" you look at with view_image" if self.vision_model() else "",
+            look="; look at other images with view_image" if self.vision_model() else "",
             checks=self.checks_prompt(),
         )
 
@@ -928,9 +958,8 @@ class Agent:
             )
             return None
         if round_ >= checks.MAX_ROUNDS:
-            self.say(
-                f"Checks still fail ({check.command}, exit code {code}): the model will say what's left.", warning=True
-            )
+            then = "" if self.can_escalate() else ": the model will say what's left"
+            self.say(f"Checks still fail ({check.command}, exit code {code}){then}.", warning=True)
         else:
             self.say(
                 f"Checks fail ({check.command}, exit code {code}): the model gets the output to fix it.", warning=True
@@ -1000,6 +1029,9 @@ class Agent:
             return f"agent({args.get('type', '')}: {args.get('description') or str(args.get('task', ''))[:50]})"
         if name == "bash":
             return f"$ {str(args.get('command', ''))[:60]}"
+        if name == "screenshot":
+            what = args.get("url") or LEADING_CD.sub("", str(args.get("command") or ""))
+            return f"screenshot({what[:60]})"
         if name in ("web_search", "web_fetch", "view_image"):
             return f"{name}({args.get('query') or args.get('url') or args.get('path') or ''})"
         if self.mcp and self.mcp.owns(name):
@@ -1076,6 +1108,8 @@ class Agent:
         self.repeats.reset()
         self.check_results = []
         self.review_results = None
+        self.escalations = []
+        escalated = False  # the stronger model is asked at most once per request
         self.tools.before = {}
         reviewed = False
         changed = verified = False  # files changed in this request; the checks passed since
@@ -1139,6 +1173,15 @@ class Agent:
                     check_rounds += 1
                     feedback = self.run_check(check, check_rounds)
                     if feedback:
+                        if check_rounds >= checks.MAX_ROUNDS and not escalated and self.can_escalate():
+                            escalated = True
+                            why = f"the project's checks (`{check.command}`) failed {check_rounds} times in a row"
+                            advice = escalate.run(self, why, failure=feedback)
+                            if advice:
+                                self.messages.append({"role": "user", "content": advice})
+                                check_rounds -= 1  # the checks run once more after the advice
+                                changed = False
+                                continue
                         self.messages.append({"role": "user", "content": feedback})
                         changed = False  # run them again only if the model changes something more
                         continue
@@ -1232,6 +1275,14 @@ class Agent:
                             skipped["tool_call_id"] = rest["id"]
                         self.messages.append(skipped)
                     break
+            if looping and not escalated and self.can_escalate():
+                escalated = True
+                advice = escalate.run(self, f"it kept making the same call with the same result: {looping}")
+                if advice:
+                    self.messages.append({"role": "user", "content": advice})
+                    self.repeats.reset()
+                    looping = ""
+                    continue
             if looping:
                 self.turn_status = "loop"
                 self.console.print(
@@ -1249,6 +1300,11 @@ class Agent:
         self.turn_status = "success"
         self.print_stats()
 
+    def can_escalate(self) -> bool:
+        """Whether a stronger model may be asked here: one is set, and this isn't a subagent or plan mode."""
+        model = (self.settings.escalate_model or "").strip().lower()
+        return bool(model) and model != "off" and self.allowed_tools is None and not self.planning()
+
     def steer(self) -> None:
         """Between two steps: pause if the user pressed Esc, then hand the model the notes typed meanwhile."""
         steering = self.steering

lcode/api.py

@@ -78,6 +78,7 @@ class Result:
     usage: dict = field(default_factory=dict)  # requests, prompt_tokens, output_tokens
     checks: list[dict] = field(default_factory=list)  # {"command", "exit_code", "by": "lcode" | "model"}
     review: list[str] | None = None  # problems the review sent back ([] when it found none; None: no review)
+    escalations: list[dict] = field(default_factory=list)  # a stronger model asked: model, why, tokens, seconds
     seconds: float = 0.0
     error: str = ""
 
@@ -200,6 +201,9 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         repeat_limit=cfg["repeat_limit"],
         checks=cfg["checks"],
         review=cfg["review"],
+        escalate_model=cfg["escalate_model"],
+        escalate_url=cfg["escalate_url"],
+        escalate_price=cfg["escalate_price"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -309,6 +313,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         usage=usage,
         checks=list(agent.check_results),
         review=agent.review_results,
+        escalations=list(agent.escalations),
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )

lcode/backends.py

@@ -265,11 +265,16 @@ class OpenAICompatible:
             return self.chat({k: v for k, v in payload.items() if k not in ("format", "tools")}, timeout)
         if r.status_code != 200:
             raise self._failed(r.status_code, r.text)
-        choice = (r.json().get("choices") or [{}])[0].get("message") or {}
+        data = r.json()
+        choice = (data.get("choices") or [{}])[0].get("message") or {}
         message: dict = {"role": "assistant", "content": strip_thinking(choice.get("content") or "")}
         if choice.get("tool_calls"):
             message["tool_calls"] = [self._ollama_call(c) for c in choice["tool_calls"]]
-        return {"message": message}
+        reply: dict = {"message": message}
+        usage = data.get("usage") or {}
+        if usage.get("prompt_tokens") is not None:  # as Ollama counts them
+            reply["prompt_eval_count"], reply["eval_count"] = usage["prompt_tokens"], usage.get("completion_tokens")
+        return reply
 
     @staticmethod
     def _ollama_call(call: dict) -> dict:

lcode/bench.py

@@ -29,7 +29,7 @@ from rich.markup import escape
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__
+from lcode import __version__, escalate
 from lcode.agent import Agent, Settings
 from lcode.config import format_tokens
 from lcode.hardware import Hardware
@@ -790,6 +790,8 @@ class TaskResult:
     tool_errors: int = 0  # failed tool calls, including malformed ones
     error: str | None = None  # why the run stopped early: a timeout or an Ollama error
     errors_by_tool: dict[str, int] = field(default_factory=dict)  # which tools failed, "malformed" for unreadable calls
+    first_passed: bool | None = None  # with --retry: whether the first try passed (None: no retry was needed)
+    escalations: int = 0  # times the stronger model was asked (--escalate)
 
 
 @dataclass
@@ -887,8 +889,13 @@ def run_task(
     keep: bool,
     usage: dict,
     agent: Agent | None = None,
+    retry: bool = False,
 ) -> TaskResult:
-    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session)."""
+    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session).
+
+    With `retry`, a failed task gets one more try, as a user would ask: "That didn't fix it. Look again." With a
+    stronger model set (--escalate), its advice goes along, as with /escalate.
+    """
     folder = Path(tempfile.mkdtemp(prefix=f"lcode-bench-{task.id}-"))
     try:
         for rel, content in task.files.items():
@@ -906,25 +913,28 @@ def run_task(
             if model:
                 codesearch.Index(folder, model).update(ollama)  # on the CPU: lcode's model stays loaded
             agent._code_index = None
+        agent.escalate_approved = True if settings.escalate_model else None  # the --escalate flag is the OK
         before = dict(agent.usage)
         first = len(agent.messages)
-        error = None
         started = time.monotonic()
-        try:
-            with time_limit(timeout):
-                agent.run_turn(task.prompt)
-        except TaskTimeout:
-            error = f"timed out after {timeout:.0f}s"
-        except OllamaError as e:
-            error = str(e).splitlines()[0][:200]
+        escalations = 0
+        error = attempt(agent, task.prompt, timeout)
+        escalations += len(agent.escalations)
+        check = checked(task, folder, agent)
+        first_passed = None
+        if retry and not (check.passed and error is None):
+            first_passed = False
+            text = RETRY
+            if error is None and agent.can_escalate():
+                advice = escalate.run(agent, "the user says the fix didn't work")
+                escalations += 1 if advice else 0
+                text = f"{RETRY}\n\n{advice}" if advice else RETRY
+            error = attempt(agent, text, timeout)
+            escalations += len(agent.escalations)
+            check = checked(task, folder, agent)
         seconds = time.monotonic() - started
         for key, value in agent.usage.items():
             usage[key] = usage.get(key, 0) + value - before.get(key, 0)
-        answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
-        try:
-            check = task.check(folder, answer)
-        except Exception as e:  # a check must never crash the benchmark
-            check = Check(False, f"check failed: {type(e).__name__}: {e}")
     finally:  # also when Ctrl+C stops the task
         from lcode.codesearch import index_dir
 
@@ -942,9 +952,34 @@ def run_task(
         tool_errors=count_tool_errors(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         errors_by_tool=errors_by_tool(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         error=error,
+        first_passed=first_passed,
+        escalations=escalations,
     )
 
 
+RETRY = "That didn't fix it: it still doesn't work right. Look again."
+
+
+def attempt(agent: Agent, text: str, timeout: float) -> str | None:
+    """One request of a task; why it stopped early, if it did."""
+    try:
+        with time_limit(timeout):
+            agent.run_turn(text)
+    except TaskTimeout:
+        return f"timed out after {timeout:.0f}s"
+    except OllamaError as e:
+        return str(e).splitlines()[0][:200]
+    return None
+
+
+def checked(task: Task, folder: Path, agent: Agent) -> Check:
+    answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
+    try:
+        return task.check(folder, answer)
+    except Exception as e:  # a check must never crash the benchmark
+        return Check(False, f"check failed: {type(e).__name__}: {e}")
+
+
 def prompt_speed(ollama: Ollama, settings: Settings, options: dict) -> float | None:
     """Prompt tokens per second for prompts the model hasn't seen: the faster of two readings.
 
@@ -998,6 +1033,7 @@ def run_model(
     keep: bool = False,
     verbose: bool = False,
     session: bool = False,
+    retry: bool = False,
 ) -> ModelRun:
     run = ModelRun(name, settings.model, settings.context, settings.num_batch, settings.think, session=session)
     shared: Agent | None = None  # with --session, one conversation for all tasks
@@ -1038,10 +1074,10 @@ def run_model(
         try:
             if verbose:
                 console.rule(f"{task.id}: {task.title}")
-                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
             else:
                 with console.status(Elapsed(f"  {task.id:<13} {task.title}")):
-                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
         except KeyboardInterrupt:
             console.print("  [yellow]Stopped.[/]")
             run.interrupted = True

lcode/cli.py

@@ -582,11 +582,14 @@ def cmd_bench(args) -> None:
             compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
             checks=cfg["checks"] if args.checks is None else args.checks,
             review=cfg["review"] if args.review is None else args.review,
+            escalate_model=args.escalate_model,
+            escalate_url=cfg["escalate_url"],
+            escalate_price=cfg["escalate_price"],
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
         run = bench.run_model(
-            ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose, args.session
+            ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose, args.session, args.retry
         )
         runs.append(run)
         if run.interrupted:
@@ -662,6 +665,8 @@ def cmd_chat(args) -> None:
             sys.exit(1)
         fail(str(e))
     exit_code = 0
+    if args.escalate and args.prompt:
+        agent.escalate_approved = True  # the flag is the user's OK for this run
     try:
         if quiet:
             agent.perms.approve = lambda request: False  # nobody to ask: refuse what needs permission
@@ -727,6 +732,11 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--plan", action="store_true", help="start in plan mode: agree on a plan before any change")
     parser.add_argument("--auto-edit", action="store_true", help="apply file edits without asking")
     parser.add_argument("--yolo", action="store_true", help="never ask for permission (edits and commands)")
+    parser.add_argument(
+        "--escalate",
+        action="store_true",
+        help="with -p: let lcode ask escalate_model for help when stuck, without asking you (it costs money)",
+    )
     parser.add_argument("--no-think", action="store_true", help="disable model reasoning (faster, less accurate)")
     parser.add_argument("--no-web", action="store_true", help="don't let the model search or fetch web pages")
     parser.add_argument("--no-mcp", action="store_true", help="don't start MCP servers in this session")
@@ -779,6 +789,17 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument(
         "--review", choices=["auto", "off"], help="review each change before it counts (default: the setting)"
     )
+    p.add_argument(
+        "--retry",
+        action="store_true",
+        help='give a failed task one more try, as a user would: "That didn\'t fix it. Look again."',
+    )
+    p.add_argument(
+        "--escalate",
+        dest="escalate_model",
+        metavar="MODEL",
+        help="a stronger model to ask when stuck and on --retry, e.g. ollama/qwen3.8-27b (no questions asked)",
+    )
     p.add_argument(
         "--checks",
         metavar="auto|off|COMMAND",

lcode/config.py

@@ -61,6 +61,14 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
     "review": ("off", str, "before the answer, check a change against the request and send problems back: auto | off"),
     "checks": ("auto", str, "run the project's checks before calling work done: auto | off | a command"),
+    "escalate_model": (
+        None,
+        str,
+        "a stronger model to ask, with your OK, when the model is stuck: anthropic/…, openai/…, xai/… (key from "
+        "ANTHROPIC_API_KEY, OPENAI_API_KEY, XAI_API_KEY) or ollama/<model> (local or at escalate_url)",
+    ),
+    "escalate_url": (None, str, "the stronger model's server, if not its provider's (another Ollama, any OpenAI API)"),
+    "escalate_price": (None, str, "its price in dollars per million tokens in/out, e.g. 3/15, for the cost shown"),
     "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),
     "compact_at": (65536, int, "summarize at this many tokens even when the window is larger (0: only at 85%)"),
@@ -165,6 +173,22 @@ def coerce(key: str, value: object) -> object:
         if value not in MEMORY_MODES:
             raise ConfigError(f"memory must be one of {', '.join(MEMORY_MODES)}")
         return value
+    if key in ("escalate_model", "escalate_url", "escalate_price"):
+        from lcode import escalate
+
+        text = str(value).strip()
+        if key == "escalate_url":
+            return normalize_host(text)
+        if key == "escalate_model":
+            provider = text.partition("/")[0].lower()
+            if "/" in text and provider not in escalate.PROVIDERS:
+                raise ConfigError(f"escalate_model's provider must be one of {', '.join(escalate.PROVIDERS)}")
+            return text
+        try:
+            escalate.parse_price(text)
+        except escalate.EscalateError as e:
+            raise ConfigError(str(e)) from e
+        return text
     if key == "lsp" and str(value).lower() not in ("auto", "off"):
         raise ConfigError("lsp must be auto or off")
     if key == "lsp":

lcode/context.py

@@ -41,6 +41,8 @@ ERROR_LINE = re.compile(
 )
 MAX_ERROR_LINES = 40
 OUTPUT_DAYS = 7  # saved full outputs are deleted after this
+MAX_SAVED = 20_000_000  # characters of one saved output: a runaway command doesn't fill the disk
+MAX_SAVED_TOTAL = 200_000_000  # bytes of saved outputs in all, the oldest go first
 
 
 # ----------------------------------------------------------------------------- the user's requests
@@ -262,17 +264,38 @@ def save_output(text: str, label: str) -> Path | None:
     folder = outputs_dir()
     try:
         folder.mkdir(parents=True, exist_ok=True)
-        cutoff = time.time() - OUTPUT_DAYS * 86400
-        for old in folder.glob("*.txt"):
-            if old.stat().st_mtime < cutoff:
-                old.unlink(missing_ok=True)
+        clean_outputs(folder, room=min(len(text), MAX_SAVED))
         path = folder / f"{time.strftime('%Y%m%d-%H%M%S')}-{re.sub(r'[^a-z0-9]+', '-', label.lower())[:30]}.txt"
-        path.write_text(text)
+        path.write_text(text if len(text) <= MAX_SAVED else text[:MAX_SAVED] + CUT_SAVED)
         return path
     except OSError:
         return None
 
 
+CUT_SAVED = "\n[lcode stopped saving here: the output went on, but a saved output is kept to 20 MB]\n"
+
+
+def clean_outputs(folder: Path, room: int = 0) -> None:
+    """Delete saved outputs older than OUTPUT_DAYS, then the oldest until they take MAX_SAVED_TOTAL with `room`."""
+    cutoff = time.time() - OUTPUT_DAYS * 86400
+    files = []
+    for old in folder.glob("*.txt"):
+        try:
+            info = old.stat()
+        except OSError:
+            continue
+        if info.st_mtime < cutoff:
+            old.unlink(missing_ok=True)
+        else:
+            files.append((info.st_mtime, info.st_size, old))
+    total = sum(size for _, size, _ in files) + room
+    for _, size, old in sorted(files):
+        if total <= MAX_SAVED_TOTAL:
+            break
+        old.unlink(missing_ok=True)
+        total -= size
+
+
 def shorten(text: str, limit: int, label: str = "output") -> str:
     """Head, tail and the error-looking lines in between; the full text goes to a file."""
     if len(text) <= limit:
@@ -315,6 +338,7 @@ class OutputSpool:
         self.chars = 0
         self.file = None
         self.path: Path | None = None
+        self.saved = 0  # characters written to the file
 
     def add(self, line: str) -> None:
         self.chars += len(line)
@@ -323,10 +347,12 @@ class OutputSpool:
             if self.chars > self.limit * 2:
                 self._spool()
             return
-        try:
-            self.file.write(line)
-        except OSError:
-            pass
+        if self.saved <= MAX_SAVED:  # past it, only the end and the error lines are kept (in memory)
+            try:
+                self.file.write(line if self.saved + len(line) <= MAX_SAVED else CUT_SAVED)
+            except OSError:
+                pass
+            self.saved += len(line)
         if ERROR_LINE.search(line) and len(self.errors) < MAX_ERROR_LINES:
             self.errors.append(line.strip()[:300])
         self.tail.append(line)
@@ -337,6 +363,7 @@ class OutputSpool:
     def _spool(self) -> None:
         text = "".join(self.head)
         self.path = save_output(text, self.label)
+        self.saved = len(text)
         if self.path is not None:
             try:
                 self.file = self.path.open("a")
@@ -359,12 +386,10 @@ class OutputSpool:
             note += "\n[...]\n\n"
         else:
             note += "] ...\n\n"
-        where = (
-            f"\n[The full {self.label} ({self.chars} characters) is in {self.path}: read parts of it with read_file "
-            "if you need them.]"
-            if self.path
-            else ""
-        )
+        whole = f"The full {self.label} ({self.chars} characters)"
+        if self.saved > MAX_SAVED:
+            whole = f"The first {MAX_SAVED // 1_000_000} MB of the {self.label} ({self.chars} characters in all)"
+        where = f"\n[{whole} is in {self.path}: read parts of it with read_file if you need them.]" if self.path else ""
         return f"{head}{note}{tail}{where}"