pcode 0.1.4__tar.gz → 0.1.5__tar.gz

{pcode-0.1.4 → pcode-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pcode
-Version: 0.1.4
+Version: 0.1.5
 Summary: Terminal-native AI coding agent with background jobs, parallel worktrees, forkable sessions, and multi-model support
 Project-URL: Homepage, https://github.com/cruxwell/pcode
 Project-URL: Documentation, https://cruxwell.github.io/pcode/

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/aside_ui.py

@@ -51,6 +51,7 @@ from pcode.popup_ui import (
 from pcode.prefix_keys import PrefixKeys
 from pcode.session_ui import literal
 from pcode.task_prompt import TaskPrompt
+from pcode.text_selection import copy_drags
 from pcode.tool_display import plain
 from pcode.ui import StatusLine, status_parts, status_spinner
 
@@ -164,15 +165,22 @@ class AsideBrowser:
         self._refreshing = False
         # Enter on the list reads the selected thread full width; Esc brings
         # the list back. A viewer opened on a lone thread starts reading, so
-        # one that arrives meanwhile does not pull the list in beside it.
-        self.reading = len(self.threads) <= 1
+        # one that arrives meanwhile does not pull the list in beside it. One
+        # opened to type in (`edit`) starts reading the newest thread too, with
+        # the cursor in its editor; Esc shows the list.
+        self.reading = len(self.threads) <= 1 or self.edit
         self._ids: list[str] = []
         self.notice = ""
         # The copy or link picker over the viewer, while one is open.
         self.picker: CopyPicker | LinkPicker | None = None
         self.list = TextArea(read_only=True, wrap_lines=False, scrollbar=True)
+        copy_drags(self.list, lambda text: setattr(self, "notice", text))
         self.list.window.cursorline = Always()
-        self.detail = RichPane(theme=rich_theme, color_system=color_system)
+        self.detail = RichPane(
+            theme=rich_theme,
+            color_system=color_system,
+            notify=lambda text: setattr(self, "notice", text),
+        )
         self.list.buffer.on_cursor_position_changed += lambda _: self.select()
         self.prefix_keys = shortcuts = PrefixKeys(key_prefix)
         shortcuts.set_help(self.help)
@@ -243,7 +251,7 @@ class AsideBrowser:
                         submit=lambda text: self.finish(Bridge(thread, "summary", text)),
                     )
 
-            @shortcuts.add("t", "Merge to /tree", filter=idle)
+            @shortcuts.add("t", "Merge into conversation", filter=idle)
             def merge(event):
                 if self.bridgeable():
                     self.finish(Bridge(self.selected, "merge"))
@@ -447,7 +455,9 @@ class AsideBrowser:
                     lambda focus: bridge("summary", focus),
                     argument="[focus]",
                 ),
-                PopupCommand("/merge", "Merge to /tree", lambda _: bridge("merge", "")),
+                PopupCommand(
+                    "/merge", "Merge into the conversation", lambda _: bridge("merge", "")
+                ),
             ]
         commands.append(PopupCommand("/stop", "Stop running answers", lambda _: self.stop()))
         return commands

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/claude_sdk/messages.py

@@ -106,15 +106,14 @@ def _render_block(block: dict) -> str:
 def _web_result_text(content: Any) -> str:
     """A web search's hits or a fetched page, as `web.result_block` shaped them."""
     if isinstance(content, list):
-        return "\n".join(
-            f"{item.get('title') or item.get('url')}: {item.get('url')}"
-            for item in content
-            if isinstance(item, dict)
-        )
+        hits = [item for item in content if isinstance(item, dict)]
+        lines = [f"{h.get('title') or h['url']}: {h['url']}" for h in hits if h.get("url")]
+        summary = next((hit["summary"] for hit in hits if hit.get("summary")), "")
+        return "\n\n".join(filter(None, ("\n".join(lines), summary)))
     if not isinstance(content, dict):
         return ""
     if "error_code" in content:
-        return f"(error: {content['error_code']})"
+        return f"(error: {content.get('message') or content['error_code']})"
     document = content.get("content")
     source = document.get("source") if isinstance(document, dict) else None
     return str(source.get("data", "")) if isinstance(source, dict) else ""

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/claude_sdk/web.py

@@ -8,10 +8,20 @@ The blocks are pcode's record only; the model reads the CLI's own transcript.
 They are tagged with the `claude` provider, so no other model is ever sent
 them, and they are used just for display and for a fresh replay
 (`messages.replay`).
+
+What the CLI returns has no slot in Anthropic's shapes, so it rides in extra
+fields, which Pydantic AI keeps: a search's summary on its first hit
+(`summary`), and a failure's full text beside its code (`message`). Pydantic
+AI also serializes these blocks against the SDK types, so `error_code` must
+stay one of Anthropic's codes or every result logs a serializer warning.
 """
 
 import json
+import logging
 import re
+from datetime import datetime, timezone
+
+logger = logging.getLogger(__name__)
 
 # CLI tool name -> Anthropic server tool name (also the native tool's `kind`).
 CLI_WEB_TOOLS = {"WebSearch": "web_search", "WebFetch": "web_fetch"}
@@ -19,6 +29,9 @@ CLI_WEB_TOOLS = {"WebSearch": "web_search", "WebFetch": "web_fetch"}
 # The CLI's search result opens with its query, then this JSON list of hits,
 # then a summary its own sub-request wrote.
 _LINKS = re.compile(r"^Links: (\[.*\])$", re.MULTILINE)
+_QUERY = re.compile(r"\AWeb search results for query: .*$", re.MULTILINE)
+# The CLI's closing instruction to its model, not part of the summary.
+_REMINDER = re.compile(r"\n*REMINDER: You MUST include the sources.*\Z", re.DOTALL)
 
 
 def cli_tool_names(native_tools) -> tuple[str, ...]:
@@ -40,24 +53,44 @@ def _text(content: object) -> str:
     return ""
 
 
+def _hit(title: str, url: str) -> dict:
+    return {
+        "type": "web_search_result",
+        "title": title,
+        "url": url,
+        # Pydantic AI's result model requires both; the CLI has neither.
+        "encrypted_content": "",
+        "page_age": None,
+    }
+
+
 def _hits(text: str) -> list[dict]:
+    """The hits in the CLI's search text, the first carrying its summary.
+
+    Text with no parseable `Links:` line means the CLI changed its format (an
+    empty search still prints `Links: []`), so that is logged rather than
+    shown as a quiet "0 results"; the text is kept on a URL-less hit.
+    """
     match = _LINKS.search(text)
     try:
-        links = json.loads(match.group(1)) if match else []
+        links = json.loads(match.group(1)) if match else None
     except ValueError:
-        links = []
-    return [
-        {
-            "type": "web_search_result",
-            "title": str(link.get("title") or ""),
-            "url": str(link["url"]),
-            # Pydantic AI's result model requires both; the CLI has neither.
-            "encrypted_content": "",
-            "page_age": None,
-        }
-        for link in links
+        links = None
+    if links is None:
+        logger.warning("Claude Code's WebSearch result has no parseable Links line: %.200r", text)
+        summary = _QUERY.sub("", text)
+    else:
+        summary = text[match.end() :] if match else ""
+    summary = _REMINDER.sub("", summary).strip()
+    hits = [
+        _hit(str(link.get("title") or ""), str(link["url"]))
+        for link in links or []
         if isinstance(link, dict) and link.get("url")
     ]
+    if summary:
+        hits = hits or [_hit("", "")]
+        hits[0]["summary"] = summary
+    return hits
 
 
 def result_block(name: str, tool_use_id: str, args: dict, content: object, is_error: bool) -> dict:
@@ -65,17 +98,19 @@ def result_block(name: str, tool_use_id: str, args: dict, content: object, is_er
     server = CLI_WEB_TOOLS[name]
     text = _text(content)
     if is_error:
-        # Anthropic's error block holds a code only; the CLI's message is more
-        # use to whoever reads the failure, so it travels in that field.
-        first = text.strip().splitlines()[0] if text.strip() else "unavailable"
-        body: object = {"type": f"{server}_tool_result_error", "error_code": first[:200]}
+        body: object = {
+            "type": f"{server}_tool_result_error",
+            "error_code": "unavailable",
+            "message": text.strip(),
+        }
     elif server == "web_search":
         body = _hits(text)
     else:
         body = {
             "type": "web_fetch_result",
             "url": str(args.get("url") or ""),
-            "retrieved_at": None,
+            # When the CLI handed the answer over, which is when it fetched.
+            "retrieved_at": datetime.now(timezone.utc).isoformat(),
             "content": {
                 "type": "document",
                 "source": {"type": "text", "media_type": "text/plain", "data": text},

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/config_ui.py

@@ -86,7 +86,7 @@ class ConfigBrowser:
             ),
             always_hide_cursor=True,
         )
-        self.detail = RichPane()
+        self.detail = RichPane(notify=lambda text: setattr(self, "message", text))
         self._detail_text = None
         keys = KeyBindings()
         self.detail.bind_scrolling(keys)

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/controller.py

@@ -516,6 +516,10 @@ class SessionController:
         # under a system row, a skill's prompt, an extension reload, a sign-in.
         self.job_requested: tuple[str, str, Callable[[], list[str]]] | None = None
         self.skill_requested: str | None = None
+        # An extension command's prompt waits for its own turn: steered into a
+        # running one, it would miss what the command set up (plan mode's
+        # reminder only joins a turn's opening request).
+        self.skill_queued = False
         self.skill_mcp_requested: tuple[str, tuple[str, ...]] | None = None
         self.reload_requested = False
         self.reload_pending = False  # Asked for mid-turn; `consume` runs it between turns.
@@ -1204,9 +1208,11 @@ class SessionController:
                 # for it on mcp_idle.
                 self.start_skill_mcp(skill, names)
             prompt, self.skill_requested = self.skill_requested, None
+            queued, self.skill_queued = self.skill_queued, False
             # Queued like a typed message so send mode, steering, and
             # cancellation keep their usual meaning.
-            self.prompts.put(prompt, load_preferences().get("send_mode", "steering"))
+            mode = "queue" if queued else load_preferences().get("send_mode", "steering")
+            self.prompts.put(prompt, mode)
             self.activity.busy = True
         if self.mcp_defaults_requested:
             self.start_mcp_defaults()
@@ -2254,10 +2260,35 @@ class SessionController:
                         f"Extension {extension.name}: {', '.join(taken)} already exists; skipped."
                     )
                     continue
-                self.registry.register(command)
+                self.registry.register(replace(command, handler=self.prompting(command)))
                 self.extension_command_names.append(command.name)
         self.view.commands_changed()
 
+    def prompting(self, command):
+        """Send the text an extension command returns as a prompt, like a skill.
+
+        A sync handler stays sync, so callers that never await still run it whole.
+        """
+
+        def request(result) -> None:
+            if isinstance(result, str) and result.strip():
+                if not self.model:
+                    raise ValueError(f"{command.name} requires a live model session.")
+                self.skill_requested = result
+                self.skill_queued = True
+
+        def run(argument: str):
+            result = command.handler(argument)
+            if not inspect.isawaitable(result):
+                return request(result)
+
+            async def finish() -> None:
+                request(await result)
+
+            return finish()
+
+        return run
+
     def extension_arguments(self) -> tuple[str, ...]:
         """Complete `on`/`off` against the extensions this workspace discovered."""
         found = self.extensions.extensions if self.extensions else ()

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/edit_transcript.py

@@ -5,10 +5,12 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from functools import cache
 
+from markdown_it import MarkdownIt
 from prompt_toolkit.formatted_text import ANSI, to_formatted_text
 from prompt_toolkit.lexers import Lexer
 from pygments.token import Generic, Token
 from rich.console import Console, ConsoleOptions, RenderResult
+from rich.markdown import Markdown
 from rich.segment import Segment
 from rich.style import Style
 from rich.syntax import Syntax
@@ -19,6 +21,7 @@ from pcode.delta import Delta, preview_patch
 from pcode.edits import edit_text, patch_text
 from pcode.runtime import EditCompleted
 from pcode.syntax import transparent_theme
+from pcode.terminal_text import safe_text
 from pcode.tool_display import command_text
 
 
@@ -40,29 +43,93 @@ class EditTranscript:
             )
         )
         if change.patch:
-            text = patch_text(change.patch, dedent=self.dedent)
-            lines = self.delta.render(text, options.max_width) if self.delta else None
-            patch = (
-                Text("\n").join(lines)
-                if lines is not None
-                else Syntax(text, "diff", theme=transparent_theme(self.code_theme), word_wrap=True)
-            )
+            if (source := created_markdown(change)) is not None:
+                # Link targets print beside their text: a file's URLs are part
+                # of what was written, not something to hide in a hyperlink.
+                patch = Markdown(safe_text(source), code_theme=self.code_theme, hyperlinks=False)
+                omitted = "… rest of file omitted"
+            else:
+                omitted = "… additional diff rows omitted"
+                text = patch_text(change.patch, dedent=self.dedent)
+                lines = self.delta.render(text, options.max_width) if self.delta else None
+                patch = (
+                    Text("\n").join(lines)
+                    if lines is not None
+                    else Syntax(
+                        text, "diff", theme=transparent_theme(self.code_theme), word_wrap=True
+                    )
+                )
             rows = console.render_lines(patch, options, pad=False)
             for row in rows[: self.max_rows]:
                 yield from row
                 yield Segment.line()
             if len(rows) > self.max_rows or change.truncated:
-                yield Text("… additional diff rows omitted", style="pcode.muted")
+                yield Text(omitted, style="pcode.muted")
         if change.omitted:
             yield Text(f"Diff unavailable: {edit_text(change.omitted)}", style="pcode.muted")
         yield block_rule()
 
 
+MARKDOWN_SUFFIXES = (".md", ".markdown")
+
+
+def created_markdown(change: EditCompleted) -> str | None:
+    """A new Markdown file's redacted source, to show rendered rather than as a diff.
+
+    Every line of a created file is an addition, so the `+` column says
+    nothing and the raw source buries the document. The patch is the only
+    copy of the content the transcript keeps; each `+` line after the hunk
+    header is a line of the file; a truncated patch's last one may be cut
+    short, so it is dropped. None keeps the diff, including for a document
+    whose rendering would hide some of what was written (see `_hides_text`).
+    """
+    if (
+        change.operation != "created"
+        or change.removed
+        or not change.patch
+        or not change.path.lower().endswith(MARKDOWN_SUFFIXES)
+    ):
+        return None
+    lines = patch_text(change.patch, dedent=False).split("\n")
+    start = next((i for i, line in enumerate(lines) if line.startswith("@@")), len(lines))
+    body = [line[1:] for line in lines[start + 1 :] if line.startswith("+")]
+    if change.truncated:
+        body = body[:-1]
+    source = "\n".join(body)
+    return None if _hides_text(source) else source
+
+
+_MARKDOWN = MarkdownIt("commonmark").enable(["strikethrough", "table"])
+
+
+def _hides_text(source: str) -> bool:
+    """Whether rendering drops written text: HTML, comments, or link definitions.
+
+    Rich skips HTML blocks and inline tags and never shows a reference
+    definition, so an instruction in an `<!-- -->` comment would vanish from
+    the record of the write. Such a file shows as its diff instead.
+    """
+    env: dict = {}
+    tokens = _MARKDOWN.parse(source, env)
+    if env.get("references"):
+        return True
+    return any(
+        token.type == "html_block"
+        or any(child.type == "html_inline" for child in token.children or ())
+        for token in tokens
+    )
+
+
 def prefetch_edits(objects, width: int) -> None:
     """Render every delta edit block in `objects` through one delta process each."""
     patches: dict[Delta, list[str]] = {}
     for obj in objects:
-        if isinstance(obj, EditTranscript) and obj.delta is not None and obj.change.patch:
+        if (
+            isinstance(obj, EditTranscript)
+            and obj.delta is not None
+            and obj.change.patch
+            and created_markdown(obj.change) is None
+        ):
             text = patch_text(obj.change.patch, dedent=obj.dedent)
             patches.setdefault(obj.delta, []).append(text)
     for delta, texts in patches.items():

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/edit_ui.py

@@ -44,6 +44,7 @@ from pcode.popup_ui import (
 )
 from pcode.prefix_keys import PrefixKeys
 from pcode.runtime import EditCompleted
+from pcode.text_selection import copy_drags
 
 NO_MATCH = "No matching files."
 PROMPTS = {"paths": "Search paths: ", "diffs": "Search diff lines: "}
@@ -398,9 +399,11 @@ class DiffBrowser:
         self.query = TextArea(height=1, prompt=lambda: PROMPTS[self.scope], multiline=False)
         self.note = TextArea(height=1, prompt=self.note_prompt, multiline=False)
         self.files = TextArea(read_only=True, wrap_lines=False, scrollbar=True)
+        copy_drags(self.files, lambda text: setattr(self, "notice", text))
         self.files.window.cursorline = Always()
         self.lexer = DiffLexer(code_theme)
         self.diff = TextArea(read_only=True, wrap_lines=False, scrollbar=True, lexer=self.lexer)
+        copy_drags(self.diff, lambda text: setattr(self, "notice", text))
         self.diff.window.cursorline = Always()
         self.query.buffer.on_text_changed += lambda _: self.refresh(first_match=True)
         self.files.buffer.on_cursor_position_changed += lambda _: self.follow_files()

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/ext.py

@@ -245,7 +245,7 @@ class ExtensionAPI:
         self,
         name: str,
         description: str,
-        handler: Callable[[str], None],
+        handler: Callable[[str], str | None],
         *,
         arguments: tuple[str, ...] = (),
         aliases: tuple[str, ...] = (),
@@ -255,6 +255,8 @@ class ExtensionAPI:
     ) -> None:
         """Add a slash command. `handler(argument)` runs on the terminal's event loop.
 
+        A handler that returns text sends it to the model as a prompt.
+
         Without `arguments`, any text is accepted; with them, only those values
         unless `free_arguments=True` keeps them as completions for free text.
         `argument_descriptions` labels each in the completion menu.

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/extension_guide.md

@@ -153,8 +153,8 @@ Pass `complete_paths=True` to Tab-complete the argument (after any leading
 
 Handlers run on the terminal's event loop, so keep them quick. Raise
 `ValueError("message")` to show a usage error. A name pcode already uses is
-reported and skipped. Commands cannot send a prompt to the model; to do that,
-write a skill (`SKILL.md`) instead.
+reported and skipped. A handler that returns a string sends it to the model as
+a prompt of its own turn, after any running one; return `None` to send nothing.
 
 ### Sub-agents
 

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/extensions/plan_mode.py

@@ -1,10 +1,13 @@
 """Plan mode: think a change through with the user before building it.
 
-`/plan [topic]` turns it on. While it is on, each user turn carries a reminder
-to investigate, keep a plan in `.pcode/plans/<slug>.md`, and hold off on
-implementing until the user approves. Approval is the model's call: when the
-user says "go ahead" (in whatever words), it calls `exit_plan_mode` and starts
-building in the same turn. `/plan off` is the manual way out.
+`/plan [request]` turns it on and sends the request, if any, as the first
+prompt (its opening words also name the plan file). While it is on, each user
+turn carries a reminder to investigate, keep a plan in
+`.pcode/plans/<slug>.md`, and hold off on implementing until the user approves.
+Approval is the model's call: when the user says "go ahead" (in whatever
+words), or answers the last open questions without raising new ones, it calls
+`exit_plan_mode` and starts building in the same turn.
+`/plan off` is the manual way out.
 
 The model is trusted rather than fenced in: nothing blocks edits, the reminder
 just says what the user wants. The active plan lives in a marker file beside
@@ -30,9 +33,13 @@ Plan mode is on. The user wants to agree on a plan before any implementation.
 - Do not start implementing. A small throwaway experiment to answer a question
   is fine; making the change itself is not.
 - End each turn with the open questions or a clear "ready to proceed?".
-- When the user approves (for example "go ahead", "do it", "lgtm", "ship it"),
-  call `exit_plan_mode`, then implement the plan in that same turn. Approval
-  with changes ("yes, but skip step 3") counts: fold the change in, then exit.
+- When the user approves, call `exit_plan_mode`, then implement the plan in
+  that same turn. Approval can be explicit ("go ahead", "lgtm", "ship it") or
+  implicit: if the user's reply answers every remaining open question and
+  raises no new concerns, that is the go-ahead; don't ask again for a
+  separate confirmation. Approval with changes ("yes, but skip step 3")
+  counts too: fold the change in, then exit. Stay in plan mode only while
+  something is genuinely unresolved or the user asks to keep planning.
 </plan-mode>"""
 
 
@@ -43,7 +50,15 @@ def is_worker(ctx) -> bool:
 
 def slugify(text: str) -> str:
     slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
-    return slug[:60].rstrip("-") or "plan"
+    if len(slug) > 60:  # Cut at a word boundary when there is one.
+        cut = slug[:61]
+        slug = cut.rsplit("-", 1)[0] if "-" in cut else slug[:60]
+    return slug or "plan"
+
+
+def topic_slug(request: str) -> str:
+    """Name the plan after the request's opening words."""
+    return slugify(" ".join(request.split("\n", 1)[0].split()[:8]))
 
 
 def setup(pcode) -> None:
@@ -74,7 +89,7 @@ def setup(pcode) -> None:
             ignore.write_text("*\n")
         marker.write_text(slug + "\n")
 
-    def plan_command(argument: str) -> None:
+    def plan_command(argument: str) -> str | None:
         argument = argument.strip()
         current = active()
         if argument == "off":
@@ -89,21 +104,25 @@ def setup(pcode) -> None:
                 f"Plan mode on: {relative(current)}" if current else "Plan mode is off."
             )
             return
-        slug = slugify(argument) if argument else (current or latest() or "plan")
+        slug = topic_slug(argument) if argument else (current or latest() or "plan")
         start(slug)
         exists = (pcode.workspace / relative(slug)).exists()
         verb = "Resuming" if exists else "Planning in"
+        ask = "Say" if argument else "Describe the change; say"
         pcode.ui.notify(
-            f"Plan mode on. {verb} {relative(slug)}. Describe the change; "
-            "say 'go ahead' when the plan looks right."
+            f"Plan mode on. {verb} {relative(slug)}. {ask} 'go ahead' "
+            "(or just answer its questions) when the plan looks right."
         )
+        # The text is the request itself, so it goes to the model now rather
+        # than making the user send it again.
+        return argument or None
 
     pcode.register_command(
         "/plan",
         "Plan before implementing; the model exits when you approve",
         plan_command,
         arguments=("off", "status"),
-        free_arguments=True,  # anything else names the plan's topic
+        free_arguments=True,  # anything else is the request to plan
         argument_descriptions={
             "off": "Leave plan mode (the plan file is kept)",
             "status": "Show whether plan mode is on and its file",
@@ -114,7 +133,8 @@ def setup(pcode) -> None:
     def exit_plan_mode() -> str:
         """Leave plan mode once the user has approved the plan, then implement it.
 
-        Call this only when plan mode is on and the user has said to go ahead.
+        Call this only when plan mode is on and the user has approved, either by
+        saying so or by answering every open question without raising new ones.
         """
         current = active()
         if current is None:

{pcode-0.1.4 → pcode-0.1.5}/src/pcode/extensions/web_research.py

@@ -9,8 +9,10 @@ plain HTTP fetch otherwise.
 
 The `web_search` preference picks the policy: `auto` (native when supported),
 `local` (never advertise native tools), or `off`. Under `auto`, `web_fetch`
-set to `local` keeps fetching on the local tool, whose page text is verbatim
-(the `claude:` CLI's fetch answers with a summary). Copy this file to
+picks the fetch: `auto` uses a native fetch only where it returns the page
+text, so `claude:` models read pages through `get_page` (the CLI's WebFetch
+answers with a small model's summary instead); `native` opts into that summary
+anyway, and `local` always fetches locally. Copy this file to
 `~/.config/pcode/extensions/web_research.py` to replace the defaults; an empty
 `setup` removes web tools entirely.
 """
@@ -18,7 +20,14 @@ set to `local` keeps fetching on the local tool, whose page text is verbatim
 import os
 
 SEARCH_RESULTS = 5
-PAGE_CHARS = 10_000
+# Long enough for most documentation pages. With the default `spill` tool
+# output mode, a page past the threshold is saved to disk and read back in
+# slices, so the cap bounds the fetch, not what lands in context.
+PAGE_CHARS = 100_000
+# Harness's ceiling for Exa page text (`EXA_MAX_PAGE_TEXT_CHARS`, which it takes
+# for Exa's limit; Exa's API reference documents 1,000,000), less the character
+# of headroom it needs to notice a longer page and mark it truncated.
+EXA_PAGE_CHARS = min(PAGE_CHARS, 9_999)
 
 INSTRUCTIONS = (
     "You can research the web: search for pages, then fetch the most promising "
@@ -43,7 +52,7 @@ def _exa_tools():
     exa = ExaSearchToolset(
         client=None,  # Harness builds the client from EXA_API_KEY; the model never sees it.
         num_results=SEARCH_RESULTS,
-        max_text_chars=PAGE_CHARS,
+        max_text_chars=EXA_PAGE_CHARS,
         include_deep_search=False,
     )
     return Tool(exa.web_search, name="web_search"), Tool(exa.get_page, name="get_page")
@@ -75,6 +84,22 @@ def _local_tools():
     return Tool(web_search, name="web_search"), fetch
 
 
+def _native_fetch(native: bool):
+    """The `native` argument for page fetching, per the `web_fetch` preference."""
+    fetch = _mode("web_fetch")
+    if not native or fetch == "local":
+        return False
+    if fetch == "native":
+        return True
+    from pydantic_ai.native_tools import WebFetchTool
+
+    def page_text_only(ctx):
+        # Omitting the native tool leaves `get_page` in the request instead.
+        return None if ctx.model.system == "claude" else WebFetchTool()
+
+    return page_text_only
+
+
 def setup(pcode) -> None:
     mode = _mode()
     if mode == "off":
@@ -88,6 +113,5 @@ def setup(pcode) -> None:
     native = mode == "auto"
     # Ids name the prompt sources in /status; they never reach the model.
     pcode.add_capability(WebSearch(id="web_research", native=native, local=search))
-    native_fetch = native and _mode("web_fetch") == "auto"
-    pcode.add_capability(WebFetch(id="web_fetch", native=native_fetch, local=fetch))
+    pcode.add_capability(WebFetch(id="web_fetch", native=_native_fetch(native), local=fetch))
     pcode.instructions(INSTRUCTIONS)