pcode 0.1.7__tar.gz → 0.1.8__tar.gz

{pcode-0.1.7 → pcode-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pcode
-Version: 0.1.7
+Version: 0.1.8
 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/
@@ -25,13 +25,13 @@ Requires-Dist: genai-prices<0.2,>=0.1.7
 Requires-Dist: httpx2<3,>=2.13.1
 Requires-Dist: prompt-toolkit==3.0.53
 Requires-Dist: psutil<8,>=6
-Requires-Dist: pydantic-ai-harness[codemode,coder,exa,playwright]<0.56,>=0.55.0
-Requires-Dist: pydantic-ai-slim[anthropic,bedrock,duckduckgo,google,groq,mcp,openai,web-fetch,xai]<3,>=2.55.0
+Requires-Dist: pydantic-ai-harness[codemode,coder,exa,playwright]<0.57,>=0.56.0
+Requires-Dist: pydantic-ai-slim[anthropic,bedrock,duckduckgo,google,groq,mcp,openai,web-fetch,xai]<3,>=2.56.0
 Requires-Dist: rich<16,>=15
 Requires-Dist: websockets<17,>=15.0.1
 Requires-Dist: yappi<2,>=1.7.6
 Provides-Extra: claude
-Requires-Dist: claude-agent-sdk<0.3,>=0.2.164; extra == 'claude'
+Requires-Dist: claude-agent-sdk<0.3,>=0.2.167; extra == 'claude'
 Description-Content-Type: text/markdown
 
 <img width="1392" height="1522" alt="pcode in a dark terminal" src="docs/assets/screenshots/tabs-dark.png" />
@@ -76,7 +76,7 @@ brew install cruxwell/pcode/pcode
 Or from [PyPI](https://pypi.org/project/pcode/) with [uv](https://docs.astral.sh/uv/):
 
 ```sh
-uv tool install --python 3.14 'pcode[claude]'
+uv tool install --python 3.15 'pcode[claude]'
 ```
 
 `brew install --HEAD` tracks `master` instead of the latest release.

{pcode-0.1.7 → pcode-0.1.8}/README.md

@@ -40,7 +40,7 @@ brew install cruxwell/pcode/pcode
 Or from [PyPI](https://pypi.org/project/pcode/) with [uv](https://docs.astral.sh/uv/):
 
 ```sh
-uv tool install --python 3.14 'pcode[claude]'
+uv tool install --python 3.15 'pcode[claude]'
 ```
 
 `brew install --HEAD` tracks `master` instead of the latest release.

{pcode-0.1.7 → pcode-0.1.8}/pyproject.toml

@@ -33,11 +33,11 @@ dependencies = [
     # itself is downloaded on first use, not at install.
     # Harness ships from the pydantic-ai repo with every Pydantic AI release and
     # pins pydantic-ai-slim to the same minor; bump both together.
-    "pydantic-ai-harness[exa,coder,codemode,playwright]>=0.55.0,<0.56",
+    "pydantic-ai-harness[exa,coder,codemode,playwright]>=0.56.0,<0.57",
     # duckduckgo and web-fetch back the bundled web_research extension when no
     # provider-native search or Exa key is available.
     # google covers both google and google-cloud providers; bedrock pulls boto3.
-    "pydantic-ai-slim[anthropic,bedrock,duckduckgo,google,groq,mcp,openai,web-fetch,xai]>=2.55.0,<3",
+    "pydantic-ai-slim[anthropic,bedrock,duckduckgo,google,groq,mcp,openai,web-fetch,xai]>=2.56.0,<3",
     "rich>=15,<16",
     # FastMCP 4.x OAuth callback server selects Uvicorn's websockets-sansio protocol.
     # Capped below 17 by google-genai (still <17 as of 2.29), not by pcode.
@@ -49,7 +49,7 @@ dependencies = [
 # (about 95 MB to download, 215 MB installed); the sdist would run whatever
 # `claude` is on PATH instead of the CLI version pcode was verified against.
 claude = [
-    "claude-agent-sdk>=0.2.164,<0.3",
+    "claude-agent-sdk>=0.2.167,<0.3",
 ]
 
 [project.urls]

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/agent.py

@@ -9,6 +9,7 @@ from contextvars import ContextVar
 from copy import copy
 from dataclasses import dataclass, fields, replace
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from pydantic_ai import Agent
 from pydantic_ai.capabilities import (
@@ -18,13 +19,11 @@ from pydantic_ai.capabilities import (
     LocalWorkspace,
 )
 from pydantic_ai.models import Model
-from pydantic_ai.models.openai_codex import OpenAICodexModel
 from pydantic_ai.profiles.openai import OpenAIModelProfile
-from pydantic_ai.providers.openai_codex import OpenAICodexProvider
 from pydantic_ai.toolsets import CombinedToolset
 from pydantic_ai.usage import UsageLimits
 from pydantic_ai_harness.coder import Coder
-from pydantic_ai_harness.compaction import ClearToolResults, WarnNearLimits
+from pydantic_ai_harness.compaction import ClearToolResults
 from pydantic_ai_harness.filesystem import FileSystem
 from pydantic_ai_harness.repo_context import RepoContext
 from pydantic_ai_harness.shell import LLM_API_KEY_ENV_PATTERNS, Shell
@@ -43,11 +42,9 @@ from pcode.filesystem import DisplayFileSystem
 from pcode.isolated_delegation import WorkspaceSubAgents
 from pcode.job_notices import JobNotices
 from pcode.jobs import isolated_registry
-from pcode.llm_proxy import ProxiedCodexProvider
 from pcode.mcp import configured_servers
 from pcode.mcp_notice import MCPServers
 from pcode.meridian import MeridianSessionIdentity
-from pcode.meridian_reminders import MeridianLimitWarnings
 from pcode.output_limits import ModelOutputLimits
 from pcode.planning import IdentifiedPlanning
 from pcode.preferences import SETTINGS, load_preferences, subagent_models
@@ -57,6 +54,9 @@ from pcode.strict_tools import create_strict_tools
 from pcode.tool_output_limits import create_tool_output_limits
 from pcode.workspace import WorkspaceGuard
 
+if TYPE_CHECKING:
+    from pydantic_ai.models.openai_codex import OpenAICodexModel
+
 # Harness gives a child its own usage counter only when its `SubAgent` carries
 # `usage_limits`; without one the child shares the parent's counter and silently
 # gets the library's 50-request default, which a busy session has already spent.
@@ -199,8 +199,6 @@ def _adapt(capability, workspace: Path, output_limits):
         # Replace Coder's 64k truncation, so it cannot cut data before spilling.
         case ToolOutputLimits():
             return output_limits
-        case WarnNearLimits():
-            return MeridianLimitWarnings(**_init_fields(capability))
         case Shell():
             return _job_shell(capability, workspace)
         case _:
@@ -446,7 +444,13 @@ def codex_model(model: str) -> OpenAICodexModel:
     Without a pcode store the provider reads the CLI file at construction time
     and keeps refreshed tokens in memory only.
     """
+    # Imported here, not at module level: `openai_codex` loads the whole OpenAI
+    # SDK (about 0.3 s), which a session on any other provider never uses.
+    from pydantic_ai.models.openai_codex import OpenAICodexModel
+    from pydantic_ai.providers.openai_codex import OpenAICodexProvider
+
     from pcode.codex_login import credential_source
+    from pcode.llm_proxy import ProxiedCodexProvider
 
     proxy = os.environ.get("PCODE_LLM_PROXY", "").strip()
     source = credential_source()

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/app.py

@@ -70,7 +70,7 @@ from pcode.shell_mode import shell_command
 from pcode.startup_input import StartupInput
 from pcode.stream_display import PrintedReply, present_events, present_stream_event
 from pcode.terminal_notify import TabProgress, TabTitle
-from pcode.theme import THEMES, replay_pending_input
+from pcode.theme import THEMES, replay_pending_input, terminal_background
 from pcode.tool_display import plain
 from pcode.ui import (
     WATCHED_PREFIX,
@@ -155,6 +155,7 @@ class PreviewApp:
             attach_tasks=load_preferences().get("attach_tasks", SETTINGS["attach_tasks"].default)
             == "on",
             task_style=load_preferences().get("task_style", SETTINGS["task_style"].default),
+            frame_style=load_preferences().get("frame_style", SETTINGS["frame_style"].default),
             tool_glyphs=load_preferences().get("tool_glyphs", SETTINGS["tool_glyphs"].default),
             tool_max_rows=tool_rows_preference(),
             tool_linger_seconds=preference_count("tool_linger_seconds"),
@@ -769,6 +770,7 @@ class PreviewApp:
         self.activity.tasks_min_rows = preference_count("tasks_min_rows")
         self.activity.tasks_min_columns = preference_count("tasks_min_columns")
         self.activity.task_style = preferences.get("task_style", SETTINGS["task_style"].default)
+        self.activity.frame_style = preferences.get("frame_style", SETTINGS["frame_style"].default)
         self.activity.tool_glyphs = preferences.get("tool_glyphs", SETTINGS["tool_glyphs"].default)
         self.activity.tool_max_rows = tool_rows_preference()
         self.activity.tool_linger_seconds = preference_count("tool_linger_seconds")
@@ -1070,7 +1072,8 @@ class PreviewApp:
 
     async def choose_copy(self, output: TerminalOutput, session) -> None:
         from pcode.clipboard import copy as copy_to_clipboard
-        from pcode.copy_ui import answers, copy_dialog, snippets
+        from pcode.copy_ui import answers, snippets
+        from pcode.tree_ui import copy_dialog
 
         self.copy_requested = False
         tree = getattr(self.runtime, "tree", None)
@@ -1083,7 +1086,10 @@ class PreviewApp:
         if len(history) > 1 or len(choices) > 1:
             async with self.popup(output, session) as modal_input:
                 dialog = copy_dialog(
-                    history,
+                    tree,
+                    rich_theme=self.transcript.rich_theme,
+                    code_theme=self.transcript.code_theme,
+                    color_system=self.transcript.console.color_system,
                     input=modal_input,
                     output=session.app.output,
                     style=session.app.style,
@@ -1248,14 +1254,22 @@ class PreviewApp:
         self.transcript.regenerate()
 
     def follow_appearance(self, detected: str) -> None:
-        """The terminal reported its background; repaint if `theme auto` now differs."""
-        if detected == self.transcript.detected_theme:
-            return
-        self.transcript.detected_theme = detected
-        if self.transcript.theme == "auto":
-            self.transcript.regenerate()
-            if self.prompt_session is not None:
-                self.prompt_session.app.invalidate()  # The editor's style follows too.
+        """The terminal reported its appearance; repaint what follows it.
+
+        Always invalidates the editor: shaded frames mix from the reported
+        background even when the theme stays (another dark profile), or under
+        a fixed `/theme`. A mode 2031 flip carries no color, so it asks for
+        one; the OSC 11 answer records a matching theme, so this asks once.
+        """
+        reported = terminal_background()
+        if self._appearance is not None and (reported is None or reported[1] != detected):
+            self._appearance.refresh()
+        if detected != self.transcript.detected_theme:
+            self.transcript.detected_theme = detected
+            if self.transcript.theme == "auto":
+                self.transcript.regenerate()
+        if self.prompt_session is not None:
+            self.prompt_session.app.invalidate()
 
     def syntax(self, argument: str) -> None:
         """Choose the Pygments style for code, the completion menu and the prompt.
@@ -2342,7 +2356,9 @@ class PreviewApp:
         self.output = output
         self.prompt_session = session
         session.app.style = DynamicStyle(
-            lambda: self.transcript.prompt_style(self.activity.task_style)
+            lambda: self.transcript.prompt_style(
+                self.activity.task_style, self.activity.frame_style
+            )
         )
         try:
             terminal = session.app.output.fileno()

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/claude_sdk/errors.py

@@ -5,7 +5,7 @@ from pydantic_ai.exceptions import ModelAPIError, ModelHTTPError
 MISSING_SDK = (
     "claude: models need pcode's optional `claude` extra, which is not installed. "
     "From a pcode checkout run `make install`, "
-    "or `uv tool install --python 3.14 --editable '.[claude]'`."
+    "or `uv tool install --python 3.15 --editable '.[claude]'`."
 )
 
 

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/compaction.py

@@ -14,9 +14,7 @@ from pydantic_ai.messages import (
     BinaryContent,
     FilePart,
     FileUrl,
-    ModelRequest,
     ModelResponse,
-    SystemPromptPart,
     ToolReturnPart,
     UploadedFile,
     UserPromptPart,
@@ -140,37 +138,6 @@ def context_estimate(messages, parameters=None) -> int:
     return estimate
 
 
-def newest_summary_only(messages) -> list:
-    """Drop every compaction summary but the newest, which supersedes the rest.
-
-    Harness keeps the first user request verbatim, and pydantic-ai merges the
-    summary request into it on the next run, so without this each compaction
-    re-keeps every earlier summary inside that "first user message". Harness
-    also anchors its update on the *last* summary part it finds, which in that
-    merged request is the oldest one. A new summary always opens the history,
-    so the first summary part in order is the newest. Reported upstream as
-    pydantic/pydantic-ai#9686; drop this once a Harness release fixes it.
-    """
-    seen = False
-    kept = []
-    for message in messages:
-        if not isinstance(message, ModelRequest):
-            kept.append(message)
-            continue
-        parts = []
-        for part in message.parts:
-            if isinstance(part, SystemPromptPart) and part.content.startswith(SUMMARY_PREFIX):
-                if seen:
-                    continue
-                seen = True
-            parts.append(part)
-        if len(parts) == len(message.parts):
-            kept.append(message)
-        elif parts:
-            kept.append(replace(message, parts=parts))
-    return kept
-
-
 def text_and_media(messages) -> tuple[int, int]:
     """The heuristic's token count of `messages` without media, and the media items held."""
     media = 0
@@ -230,9 +197,8 @@ async def summarize(messages, *, model, focus=None, usage=None, window=None, par
     # a compaction to ~244k whose next request was billed 67k.
     text, media = text_and_media(messages)
     density = max(1.0, (before - schemas - media * MEDIA_TOKENS) / text) if text else 1.0
-    source = newest_summary_only(messages)
-    cutoff = find_token_cutoff(source, keep)
-    oversized_tail = estimate_token_count(source[cutoff:]) > keep
+    cutoff = find_token_cutoff(messages, keep)
+    oversized_tail = estimate_token_count(messages[cutoff:]) > keep
 
     def summarizer(tool_return_max_chars: int) -> SummarizingCompaction:
         return SummarizingCompaction(
@@ -271,10 +237,11 @@ async def summarize(messages, *, model, focus=None, usage=None, window=None, par
             *(tightened(tool_chars, part_chars) for tool_chars, part_chars in TIGHTENED_ATTEMPTS),
         ]
     )
-    candidate = await compact_now(strategy, deepcopy(source), model=model, focus=focus, usage=usage)
-    if candidate == source:
+    candidate = await compact_now(
+        strategy, deepcopy(messages), model=model, focus=focus, usage=usage
+    )
+    if candidate == messages:
         return CompactionResult(messages, before, before, False)
-    candidate = newest_summary_only(candidate)
     if not is_provider_valid(candidate):
         raise CompactionError("Compaction produced invalid tool-call pairs; history unchanged.")
     # Harness returns text, not structured output: reject empty summaries explicitly.

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/config.py

@@ -2,7 +2,7 @@
 
 Editing defaults deliberately does not mutate a running conversation. In-session
 shortcuts change both the active setting and its saved default; the terminal also
-applies layout-only settings (`attach_tasks`, `tasks_max_height`, `task_style`,
+applies layout-only settings (`attach_tasks`, `tasks_max_height`, `task_style`, `frame_style`,
 `tool_glyphs`, `tool_max_lines`, `tool_linger_seconds` and `show_hints`) immediately.
 
 `config project ...` edits the workspace's `.pcode/preferences.json`, which is
@@ -38,6 +38,7 @@ IMMEDIATE_SETTINGS = frozenset(
         "tasks_min_rows",
         "tasks_min_columns",
         "task_style",
+        "frame_style",
         "tool_glyphs",
         "tool_max_lines",
         "tool_linger_seconds",

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/conversation_tree.py

@@ -6,6 +6,14 @@ from dataclasses import dataclass, field
 from pcode.links import Link, extract_links, remember_link
 
 
+def excerpt(text: str) -> str:
+    """One safe line of ``text`` for a list row."""
+    from pcode.diagnostics import strip_controls
+    from pcode.ui import plain
+
+    return plain(strip_controls(" ".join(text.split())), 100)
+
+
 @dataclass
 class TurnNode:
     id: str
@@ -113,12 +121,6 @@ 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 strip_controls
-        from pcode.ui import plain
-
-        def excerpt(text):
-            return plain(strip_controls(" ".join(text.split())), 100)
-
         rows = [
             ((None, False), "Conversation start" + (" ← active" if self.active is None else ""))
         ]

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/copy_ui.py

@@ -3,11 +3,12 @@
 The transcript draws a Markdown quote with a `▌` rail and hard-wraps it to the
 terminal, so selecting it with the mouse picks up both. The source still has
 the text as written: this pulls each top-level quote and fenced code block out
-of it for a small picker, shared by `/copy` and `/tree`.
+of it, for `/copy`'s rows (see `tree_ui.CopyBrowser`, which `SnippetMarkdown`
+highlights them for) and for the small pickers in `/tree` and `/btw`.
 """
 
 import re
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from markdown_it import MarkdownIt
 from prompt_toolkit.application import Application, get_app
@@ -18,11 +19,14 @@ from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous
 from prompt_toolkit.layout import DynamicContainer, HSplit, Layout
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.widgets import Label, TextArea
+from rich.console import Group
+from rich.markdown import BlockQuote, CodeBlock, Markdown
 
 from pcode.frame import Dialog
 from pcode.popup_ui import (
     bind_list_paging,
     focus_overlay,
+    marked,
     popup_container,
     popup_mouse,
     popup_style,
@@ -62,9 +66,11 @@ def answers(tree) -> list[Answer]:
 
 @dataclass(frozen=True)
 class Snippet:
-    kind: str  # "response", "quote", or "code"
+    kind: str  # "prompt", "response", "quote", or "code"
     text: str
     language: str = ""
+    # Source lines [start, end) of a quote or code block, for `SnippetMarkdown`.
+    lines: tuple[int, int] | None = field(default=None, compare=False)
 
     @property
     def label(self) -> str:
@@ -83,6 +89,43 @@ def _unquote(lines: list[str]) -> str:
     ).strip("\n")
 
 
+_HARD_BREAK = re.compile(r"(  |\\)$")
+
+
+def _unwrap(markdown: str) -> str:
+    """``markdown`` with each paragraph's soft line breaks joined by spaces.
+
+    Markdown draws a lone newline inside a paragraph as a space, so a quote
+    copied as written would break where nothing on screen does. Hard breaks,
+    blank lines, code, and nested quotes keep their lines.
+    """
+    lines = markdown.splitlines()
+    depth = 0
+    joined: dict[int, int] = {}  # paragraph's first line -> its end
+    for token in MarkdownIt("commonmark").parse(markdown):
+        if token.type == "blockquote_open":
+            depth += 1
+        elif token.type == "blockquote_close":
+            depth -= 1
+        elif token.type == "paragraph_open" and depth == 0 and token.map:
+            joined[token.map[0]] = token.map[1]
+    out: list[str] = []
+    index = 0
+    while index < len(lines):
+        end = joined.get(index, index + 1)
+        paragraph = lines[index:end]
+        line = paragraph[0]
+        for following in paragraph[1:]:
+            if _HARD_BREAK.search(line):
+                out.append(_HARD_BREAK.sub("", line).rstrip())
+                line = following
+            else:
+                line = f"{line.rstrip()} {following.lstrip()}"
+        out.append(line)
+        index = end
+    return "\n".join(out)
+
+
 def snippets(markdown: str) -> list[Snippet]:
     """The whole response, then each top-level quote and code block in order."""
     if not markdown.strip():
@@ -94,8 +137,13 @@ def snippets(markdown: str) -> list[Snippet]:
         if token.type == "blockquote_open":
             if depth == 0 and token.map:
                 start, end = token.map
-                if text := _unquote(lines[start:end]):
-                    found.append(Snippet("quote", text))
+                # Its first line can open inside a list item, e.g. "2. > text":
+                # with no enclosing quote, the first `>` is this quote's own.
+                quoted = lines[start:end]
+                if (marker := quoted[0].find(">")) > 0:
+                    quoted[0] = quoted[0][marker:]
+                if text := _unwrap(_unquote(quoted)):
+                    found.append(Snippet("quote", text, lines=(start, end)))
             depth += 1
         elif token.type == "blockquote_close":
             depth -= 1
@@ -103,10 +151,55 @@ def snippets(markdown: str) -> list[Snippet]:
             language = token.info.split()[0] if token.info.strip() else ""
             # No trailing newline: pasted into a shell, it would run the command.
             text = token.content.rstrip("\n")
-            found.append(Snippet("code", text, language))
+            found.append(Snippet("code", text, language, tuple(token.map) if token.map else None))
     return found
 
 
+class _Marked:
+    """A Markdown element tagged with its snippet's pane mark, when it has one."""
+
+    mark: str | None = None
+
+    @classmethod
+    def create(cls, markdown, token):
+        element = super().create(markdown, token)
+        element.mark = markdown.marks.get(tuple(token.map)) if token.map else None
+        return element
+
+    def __rich_console__(self, console, options):
+        rendered = super().__rich_console__(console, options)
+        if self.mark is None:
+            yield from rendered
+        else:
+            yield marked(Group(*rendered), self.mark)
+
+
+class _MarkedCodeBlock(_Marked, CodeBlock):
+    pass
+
+
+class _MarkedBlockQuote(_Marked, BlockQuote):
+    pass
+
+
+class SnippetMarkdown(Markdown):
+    """Markdown whose quotes and code blocks carry their snippets' `marked` keys.
+
+    ``marks`` maps a snippet's source lines to its key. Rich parses the same
+    source as `snippets`, so a block's line map identifies the snippet.
+    """
+
+    elements = {
+        **Markdown.elements,
+        "fence": _MarkedCodeBlock,
+        "blockquote_open": _MarkedBlockQuote,
+    }
+
+    def __init__(self, markup: str, marks: dict[tuple[int, int], str], **options) -> None:
+        super().__init__(markup, **options)
+        self.marks = marks
+
+
 def last_response(tree) -> str:
     """The newest assistant text on the active branch, skipping compactions."""
     for identity in reversed(tree.path(tree.active)):
@@ -337,35 +430,6 @@ class CopyPicker:
         app.invalidate()
 
 
-def copy_dialog(choices: list[Answer], *, input=None, output=None, style=None):
-    """One popup application whose result is the picked Snippet, or None."""
-    app: Application
-    shortcuts = PrefixKeys()
-    picker = CopyPicker(
-        choices,
-        on_pick=lambda snippet: app.exit(result=snippet),
-        on_cancel=lambda: app.exit(result=None),
-        shortcuts=shortcuts,
-    )
-    shortcuts.set_help(picker.help)
-    dialog = Dialog(
-        title=lambda: picker.title,
-        body=HSplit([picker.container, Label(shortcuts.summary)], padding=1),
-    )
-    app = Application(
-        layout=Layout(
-            popup_container(dialog, shortcuts), focused_element=picker.query or picker.list
-        ),
-        key_bindings=shortcuts.key_bindings(KeyBindings()),
-        full_screen=True,
-        mouse_support=popup_mouse(shortcuts),
-        input=input,
-        output=output,
-        style=popup_style(style),
-    )
-    return app
-
-
 def snippet_dialog(choices: list[Snippet], *, input=None, output=None, style=None):
     """A popup application whose result is the picked snippet, or None."""
     app: Application

{pcode-0.1.7 → pcode-0.1.8}/src/pcode/edits.py

@@ -1,7 +1,6 @@
 """Bounded, sanitized evidence of completed file mutations, not workspace diffs."""
 
 import difflib
-import os
 import re
 
 from pcode.runtime import EditCompleted
@@ -72,7 +71,10 @@ def _dedent(lines: list[str], body: list[int]) -> None:
     indents = [c[: len(c) - len(c.lstrip())] for c in contents if c.strip()]
     if not indents:
         return
-    shared = os.path.commonprefix(indents)
+    # The prefix the lexicographic extremes share is shared by every indent.
+    # (`os.path.commonprefix` did this, but Python 3.15 deprecates it.)
+    low, high = min(indents), max(indents)
+    shared = low[: next((i for i, (a, b) in enumerate(zip(low, high)) if a != b), len(low))]
     if not shared:
         return
     for i, content in zip(body, contents, strict=True):

pcode-0.1.8/src/pcode/meridian_reminders.py

@@ -0,0 +1,48 @@
+"""Durable, append-only reminders that keep a provider's cached prefix intact."""
+
+from pydantic_ai.messages import ModelRequest, UserPromptPart
+
+
+def last_reminder(messages, tag: str) -> str | None:
+    """Return the most recent reminder text for `tag`, or None when none was sent.
+
+    Detection is by content, not message metadata: Pydantic AI merges consecutive
+    `ModelRequest`s when history is resumed and keeps only its own reserved
+    metadata namespace, so a marker stored there survives a run but not a resume.
+    Only a `UserPromptPart` that *starts* with the tag counts, so a tool result or
+    quoted prompt that merely mentions it is not mistaken for a sent reminder.
+    """
+    for message in reversed(messages):
+        if not isinstance(message, ModelRequest):
+            continue
+        for part in reversed(message.parts):
+            content = getattr(part, "content", None)
+            if isinstance(part, UserPromptPart) and isinstance(content, str):
+                if content.startswith(tag):
+                    return content
+    return None
+
+
+def append_reminder(ctx, request_context, tag: str, text: str) -> None:
+    """Append `text` as durable history unless the last reminder already says it.
+
+    Appending, rather than moving a mutable tail, keeps previously sent messages
+    byte-identical so the provider's cached prefix stays reusable as the
+    conversation grows.
+    """
+    messages = request_context.messages
+    if not messages or not isinstance(messages[-1], ModelRequest):
+        return
+    previous = last_reminder(messages, tag)
+    if previous == text:
+        return
+    # Stamped here: the framework fills these in only after every before-hook
+    # has run, which is after the request checkpoint has copied the request.
+    reminder = ModelRequest(
+        parts=[UserPromptPart(content=text)],
+        run_id=ctx.run_id,
+        conversation_id=ctx.conversation_id,
+    )
+    # Both lists: the request is what gets sent, `ctx.messages` the run's history.
+    request_context.messages = [*messages, reminder]
+    ctx.messages.append(reminder)