pcode 0.1.4__tar.gz → 0.1.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pcode
-Version: 0.1.4
+Version: 0.1.6
 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.6}/src/pcode/app.py

@@ -554,15 +554,15 @@ class PreviewApp:
         if self.runtime.session:
             self.replay()
             return
-        from pcode.diagnostics import redact
+        from pcode.diagnostics import strip_controls
 
         tree = self.runtime.tree
         with self.transcript.restore():
             for node_id in tree.path(tree.active):
                 node = tree.nodes[node_id]
-                self.transcript.user(redact(node.prompt))
+                self.transcript.user(strip_controls(node.prompt))
                 if node.response:
-                    self.transcript.events((Message(redact(node.response)),))
+                    self.transcript.events((Message(strip_controls(node.response)),))
         self.activity.plan = tree.nodes[tree.active].plan if tree.active else []
 
     def aside_changed(self, aside) -> None:
@@ -1884,7 +1884,7 @@ class PreviewApp:
 
         `end` stops at that journal offset: a host sends the rest as it happened.
         """
-        from pcode.diagnostics import redact
+        from pcode.diagnostics import strip_controls
 
         saved = saved or self.runtime.session
         self.activity.plan = saved.latest_plan()
@@ -1898,9 +1898,9 @@ class PreviewApp:
             for record in saved.transcript_records(end):
                 kind = record["kind"]
                 if kind in ("turn_started", "steering"):
-                    self.transcript.user(redact(record["prompt"]))
+                    self.transcript.user(strip_controls(record["prompt"]))
                 elif kind in ("Thinking", "thinking_partial"):
-                    self.transcript.thinking(redact(record["text"]).rstrip("\n") + "\n\n")
+                    self.transcript.thinking(strip_controls(record["text"]).rstrip("\n") + "\n\n")
                 elif kind == "CacheBust":
                     continue  # Kept in the journal; live runs show it in the footer.
                 elif kind == "EditCompleted":
@@ -1912,21 +1912,21 @@ class PreviewApp:
                     self.transcript.tool_result(
                         ToolSummary(
                             record["name"],
-                            redact(record["detail"]),
+                            strip_controls(record["detail"]),
                             record.get("failed", False),
                             record.get("call_id", ""),
                             record.get("elapsed_seconds"),
-                            redact(record.get("error", "")),
-                            redact(record.get("command", "")),
-                            result=redact(result) if isinstance(result, str) else None,
+                            strip_controls(record.get("error", "")),
+                            strip_controls(record.get("command", "")),
+                            result=strip_controls(result) if isinstance(result, str) else None,
                             outcome=record.get("outcome", ""),
                             parent_call_id=record.get("parent_call_id", ""),
-                            purpose=redact(record.get("purpose", "")),
+                            purpose=strip_controls(record.get("purpose", "")),
                             execution=record.get("execution", ""),
                         )
                     )
                 elif kind in ("Message", "partial"):
-                    self.transcript.events((Message(redact(record["markdown"])),))
+                    self.transcript.events((Message(strip_controls(record["markdown"])),))
                     if kind == "partial":
                         self.transcript.warning("[Partial output from an interrupted run]")
 

{pcode-0.1.4 → pcode-0.1.6}/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
@@ -578,8 +588,7 @@ class AsideBrowser:
     def links(self) -> list[Link]:
         """URLs in the selected thread's questions and answers, oldest first.
 
-        From the raw text, as `/links` reads the conversation: redaction would
-        cut a URL holding a token short, and the browser would get the stub.
+        From the raw text, as `/links` reads the conversation.
         """
         found: dict[str, Link] = {}
         for aside in self.current():

{pcode-0.1.4 → pcode-0.1.6}/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.6}/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.6}/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.6}/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.
@@ -901,7 +905,7 @@ class SessionController:
         registry = getattr(self.runtime, "jobs", None)
         if registry is None:
             return []
-        from pcode.shell import REDUCED_SHELL_OUTPUT, result_projection
+        from pcode.shell import REDUCED_SHELL_OUTPUT
 
         finished = registry.take_announcements("ui", job_id)
         for job in finished:
@@ -915,7 +919,7 @@ class SessionController:
                 failed=job.stopped or job.exit_code != 0,
                 elapsed_seconds=job.elapsed,
                 command=command_text(job.command),
-                result=command_text(result_projection(result)),
+                result=command_text(result),
                 purpose=command_text(job.purpose),
             )
             saved = getattr(self.runtime, "session", None)
@@ -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 ()
@@ -3420,7 +3451,7 @@ class SessionController:
 
     async def merge_thread(self, thread: str) -> None:
         """Add a side thread to the conversation tree where it was asked."""
-        from pcode.diagnostics import redact
+        from pcode.diagnostics import strip_controls
 
         follows = self.check_bridge(thread)
         asked = self.asides.thread(thread)
@@ -3437,8 +3468,8 @@ class SessionController:
         count = f"{len(steps)} side question{'s' if len(steps) > 1 else ''}"
         if moved:
             for question, answer, _ in steps:
-                self.view.user(redact(question))
-                self.view.show_events((Message(redact(answer)),))
+                self.view.user(strip_controls(question))
+                self.view.show_events((Message(strip_controls(answer)),))
             self.view.note(
                 f"Merged {count} into the conversation, which continues from the last answer."
             )
@@ -3450,7 +3481,7 @@ class SessionController:
 
     async def summarize_thread(self, follows: Aside, instructions: str) -> None:
         """Add a summary of `follows`'s thread to the conversation, and show it."""
-        from pcode.diagnostics import redact
+        from pcode.diagnostics import strip_controls
 
         asked = self.asides.thread(follows.thread)
         questions = [aside.question for aside, _ in exchanges(asked, follows.reply.messages)]
@@ -3458,8 +3489,8 @@ class SessionController:
         summary = await self.runtime.summarize_aside(follows.reply, request, instructions)
         follows.bridged = "summarized"
         self.view.aside_changed(follows)
-        self.view.user(redact(request))
-        self.view.show_events((Message(redact(summary)),))
+        self.view.user(strip_controls(request))
+        self.view.show_events((Message(strip_controls(summary)),))
 
     def aside_completions(self, argument: str):
         """Complete a `$MODEL` word in `/btw` arguments from the /model catalog.

{pcode-0.1.4 → pcode-0.1.6}/src/pcode/conversation_tree.py

@@ -113,11 +113,11 @@ class ConversationTree:
 
     def rows(self) -> list[tuple[tuple[str | None, bool], str]]:
         """Depth-first user/edit and assistant/continue rows, with stable IDs."""
-        from pcode.diagnostics import redact
+        from pcode.diagnostics import strip_controls
         from pcode.ui import plain
 
         def excerpt(text):
-            return plain(redact(" ".join(text.split())), 100)
+            return plain(strip_controls(" ".join(text.split())), 100)
 
         rows = [
             ((None, False), "Conversation start" + (" ← active" if self.active is None else ""))

{pcode-0.1.4 → pcode-0.1.6}/src/pcode/delegation.py

@@ -39,7 +39,6 @@ from pcode.planning import PlanSnapshot
 from pcode.preferences import SETTINGS, load_preferences
 from pcode.retries import RequestCheckpoint
 from pcode.runtime import ToolStarted, ToolSummary
-from pcode.shell import result_projection
 from pcode.tool_display import (
     COMMAND_TOOLS,
     assignment,
@@ -208,9 +207,6 @@ async def stream_child_activity(_ctx, events):
             detail, failed = result_detail(
                 name, args, event.part.content, outcome, stored_source(args, called)
             )
-            content = (
-                result_projection(event.part.content) if name == "shell" else event.part.content
-            )
             child = ToolSummary(
                 name,
                 detail,
@@ -219,8 +215,8 @@ async def stream_child_activity(_ctx, events):
                 elapsed_seconds=max(0, monotonic() - started),
                 command=invocation(name, args),
                 purpose=stated_purpose(args),
-                error=command_error(content) if failed and name in COMMAND_TOOLS else "",
-                result=capture(content),
+                error=command_error(event.part.content) if failed and name in COMMAND_TOOLS else "",
+                result=capture(event.part.content),
                 run_id=parent.run_id or "",
                 outcome=outcome,
                 parent_call_id=parent_id,

{pcode-0.1.4 → pcode-0.1.6}/src/pcode/diagnostics.py

@@ -44,7 +44,17 @@ _ASSIGNMENT = re.compile(
 )
 
 
+def strip_controls(text: str) -> str:
+    """Drop control characters other than newline and tab."""
+    return re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", text)
+
+
 def redact(text: str) -> str:
+    """Best-effort credential removal for error reports and text sent off the machine.
+
+    Not for the screen: the model has already seen what pcode displays, and
+    keyword matching rewrites ordinary code.
+    """
     for name, value in os.environ.items():
         if len(value) >= 8 and re.search(r"TOKEN|SECRET|PASSWORD|API_KEY|ACCESS_KEY", name):
             text = text.replace(value, "[redacted]")
@@ -52,7 +62,7 @@ def redact(text: str) -> str:
     text = re.sub(r"(?i)(https?://)[^/\s@]+@", r"\1[redacted]@", text)
     text = _TOKEN.sub("[redacted]", text)
     text = _ASSIGNMENT.sub(r"\1[redacted]", text)
-    return re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", text)
+    return strip_controls(text)
 
 
 # Enough for a deep cause chain through the agent graph, small enough that a

{pcode-0.1.4 → pcode-0.1.6}/src/pcode/edit_preview.py

@@ -15,7 +15,7 @@ from pydantic_ai.messages import (
 )
 from pydantic_core import from_json
 
-from pcode.edits import MAX_SOURCE, edit_text, sensitive_path
+from pcode.edits import MAX_SOURCE, edit_text
 from pcode.runtime import EditPreview
 
 
@@ -88,15 +88,11 @@ class StreamingEditPreview:
             return clear + self._code_preview(index, partial, complete)
         path = complete.get("path")
         # Never expose content until the complete path is known and checked.
-        permitted = isinstance(path, str) and not sensitive_path(path)
+        permitted = isinstance(path, str)
         if permitted:
             try:
                 resolved = (self.root / path).resolve()
-                permitted = (
-                    not Path(path).is_absolute()
-                    and resolved.is_relative_to(self.root)
-                    and not sensitive_path(str(resolved.relative_to(self.root)))
-                )
+                permitted = not Path(path).is_absolute() and resolved.is_relative_to(self.root)
             except OSError, ValueError, RuntimeError:
                 permitted = False
         if not permitted:

{pcode-0.1.4 → pcode-0.1.6}/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 sanitized 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.6}/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()
@@ -744,7 +747,7 @@ class DiffBrowser:
         terms = self.terms()
         if self.scope == "paths":
             return all(fuzzy_match(term, change.path.casefold()) for term in terms)
-        # Match the redacted text, so redaction cannot hide the row a query matched.
+        # Match the text as shown, so sanitizing cannot hide the row a query matched.
         text = "\n".join([change_heading(change), patch_text(change.patch, dedent=self.dedent)])
         return not terms or bool(matching_rows(text, terms))