cecli-dev 0.100.12rc5__tar.gz → 0.100.14__tar.gz

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/.github/workflows/ubuntu-tests.yml

@@ -55,6 +55,8 @@ jobs:
           -r requirements/requirements-help.in \
           -r requirements/requirements-playwright.in \
           ".[help,playwright]"
+      env:
+        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: "1"
 
     - name: Configure Git for tests
       run: |
@@ -67,3 +69,4 @@ jobs:
         pytest
       env:
         CECLI_TUI: "false"
+        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: "1"

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/.github/workflows/windows-tests.yml

@@ -43,6 +43,8 @@ jobs:
         python -m pip install --upgrade pip
         pip install uv
         uv pip install --system pytest pytest-asyncio pytest-mock -r requirements/requirements.in -r requirements/requirements-help.in -r requirements/requirements-playwright.in '.[help,playwright]'
+      env:
+        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: "1"
 
     - name: Configure Git for tests
       run: |
@@ -55,3 +57,4 @@ jobs:
         pytest
       env:
         CECLI_TUI: "false"
+        PYO3_USE_ABI3_FORWARD_COMPATIBILITY: "1"

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.12rc5
+Version: 0.100.14
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -59,6 +59,7 @@ Requires-Dist: rapidfuzz>=3.0
 Requires-Dist: ngram>=4.0.3
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: scipy>=1.15.3
+Requires-Dist: orjson>=3.11.6
 Requires-Dist: importlib-metadata>=7.2.1
 Requires-Dist: tomli>=2.3.0; python_version <= "3.10"
 Requires-Dist: tree-sitter==0.23.2; python_version < "3.10"

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/benchmark/README.md

@@ -26,6 +26,13 @@ without any human review or supervision! The LLM could generate dangerous python
 that harms your system, like this: `import os; os.system("sudo rm -rf /")`.
 Running inside a docker container helps limit the damage that could be done.
 
+The current harness (`benchmark.py`) organizes the exercises as "Cats": each
+exercise carries `cat.yaml` metadata, enabling per-test selection and
+deterministic subsets (e.g. `--hash-re '^0'`) for spot-checking models. The
+canonical exercises source is
+[ErichBSchulz/cecli-cats](https://github.com/ErichBSchulz/cecli-cats), a
+Cats-formatted conversion of the polyglot benchmark.
+
 ## Usage
 
 There are 3 main tasks involved in benchmarking:
@@ -41,8 +48,8 @@ There are 3 main tasks involved in benchmarking:
 These steps only need to be done once.
 
 ```
-ORG=Aider-AI
-REPO=aider
+ORG=cecli-dev
+REPO=cecli
 # Clone the main repo
 git clone https://github.com/$ORG/$REPO.git
 
@@ -50,8 +57,9 @@ git clone https://github.com/$ORG/$REPO.git
 cd $REPO
 mkdir tmp.benchmarks
 
-# Clone the repo with the exercises
-git clone https://github.com/$ORG/polyglot-benchmark tmp.benchmarks/polyglot-benchmark
+# Clone the canonical exercises source for the Cats harness
+git clone https://github.com/ErichBSchulz/cecli-cats tmp.benchmarks/cecli-cats
+
 
 # Build the docker container
 ./benchmark/docker_build.sh
@@ -69,10 +77,10 @@ Launch the docker container and run the benchmark inside it:
 ./benchmark/docker.sh
 
 # Run the benchmark:
-./benchmark/benchmark.py a-helpful-name-for-this-run --model gpt-3.5-turbo --edit-format whole --threads 10 --exercises-dir polyglot-benchmark
+./benchmark/benchmark.py a-helpful-name-for-this-run --model gpt-3.5-turbo --edit-format whole --threads 10 --exercises-dir cecli-cats
 
 # Or with OpenRouter models (requires OPENROUTER_API_KEY environment variable):
-./benchmark/benchmark.py openrouter-run --model openrouter/deepseek/deepseek-r1:free --edit-format whole --threads 10 --exercises-dir polyglot-benchmark
+./benchmark/benchmark.py openrouter-run --model openrouter/deepseek/deepseek-r1:free --edit-format whole --threads 10 --exercises-dir cecli-cats
 ```
 
 The above will create a folder
@@ -156,6 +164,7 @@ Note the roadmap priorities:
 
 ## Limitations
 
+- `benchmark_classic.py` is deprecated (it predates the async Coder API).
 - These scripts are not intended for use by typical `cecli` end users.
 - Some of the old (?deprecated) tools are written as `bash` scripts, so it will be hard to use
   them on Windows.

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.100.11.dev"
+__version__ = "0.100.14.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.12rc5'
-__version_tuple__ = version_tuple = (0, 100, 12, 'rc5')
+__version__ = version = '0.100.14'
+__version_tuple__ = version_tuple = (0, 100, 14)
 
-__commit_id__ = commit_id = 'g7a6568913'
+__commit_id__ = commit_id = 'gd2fa11692'

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/args.py

@@ -598,6 +598,12 @@ def get_parser(default_config_files, git_root):
         default=True,
         help="Enable/disable streaming responses (default: True)",
     )
+    group.add_argument(
+        "--spinner",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable the spinner while waiting for LLM responses (default: True)",
+    )
     group.add_argument(
         "--user-input-color",
         default="#00cc00",

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/coders/agent_coder.py

@@ -305,6 +305,25 @@ class AgentCoder(Coder):
                 call_result = await litellm.experimental_mcp_client.call_openai_tool(
                     session=session, openai_tool=tool_call_dict
                 )
+            except Exception as e:
+                if server.is_session_expired_error(e):
+                    try:
+                        session = await server.reconnect()
+                        call_result = await litellm.experimental_mcp_client.call_openai_tool(
+                            session=session, openai_tool=tool_call_dict
+                        )
+                    except Exception as retry_exc:
+                        self.io.tool_warning(
+                            f"Executing {tool_name} on {server.name} failed after reconnect:\n"
+                            f"Error: {retry_exc}"
+                        )
+                        return f"Error executing tool call {tool_name}: {retry_exc}"
+                else:
+                    self.io.tool_warning(
+                        f"Executing {tool_name} on {server.name} failed:\nError: {e}"
+                    )
+                    return f"Error executing tool call {tool_name}: {e}"
+            try:
                 content_parts = []
                 if call_result.content:
                     for item in call_result.content:
@@ -829,7 +848,7 @@ class AgentCoder(Coder):
             if lint_errors:
                 lint_errors = lint_errors.replace(
                     "# Fix any linting errors below, if possible.",
-                    "# Fix any linting errors below, if possible and then continue with your task.",
+                    "# Fix the linting errors below, and then continue with your task.",
                     1,
                 )
                 ConversationService.get_manager(self).add_message(

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/coders/base_coder.py

@@ -221,6 +221,7 @@ class Coder(metaclass=UsageMeta):
     message_tokens_sent = 0
     message_tokens_received = 0
     message_cached_tokens = 0
+    message_cost_deferred = None
     add_cache_headers = False
     cache_warming_thread = None
     num_cache_warming_pings = 0
@@ -1497,6 +1498,10 @@ class Coder(metaclass=UsageMeta):
                         self.show_announcements()
                     self.suppress_announcements_for_next_prompt = True
 
+                    if self.message_cost_deferred and not self.io.spinner_active:
+                        self.io.tool_output(self.message_cost_deferred)
+                        self.message_cost_deferred = None
+
                     await self.io.recreate_input()
                     await self.io.input_task
                     user_message = self.io.input_task.result()
@@ -1645,6 +1650,10 @@ class Coder(metaclass=UsageMeta):
                         self.show_announcements()
                     self.suppress_announcements_for_next_prompt = True
 
+                    if self.message_cost_deferred and not self.io.spinner_active:
+                        self.io.tool_output(self.message_cost_deferred)
+                        self.message_cost_deferred = None
+
                     # Stop spinner before showing announcements or getting input
                     self.io.stop_spinner()
                     self.copy_context()
@@ -1733,7 +1742,27 @@ class Coder(metaclass=UsageMeta):
                 # Compacting is wasteful since /clear will clear everything
                 # and /exit will exit the application
                 stripped = user_message.strip()
-                if stripped not in ("/clear", "/reset", "/exit", "/quit"):
+                is_command = self.commands.is_command(stripped)
+                is_allowed_command = False
+
+                if is_command:
+                    res = self.commands.matching_commands(user_message)
+                    if res is not None:
+                        matching_commands, first_word, rest_inp = res
+                        if len(matching_commands) == 1:
+                            command = matching_commands[0]
+                            splits = (rest_inp or "").split()
+                            split_map = {
+                                "/agent": 1,
+                                "/architect": 1,
+                                "/ask": 1,
+                                "/code": 1,
+                                "/model": 2,
+                            }
+                            if command in split_map and len(splits) >= split_map.get(command, 0):
+                                is_allowed_command = True
+
+                if not is_command or is_allowed_command:
                     self.compact_context_completed = False
                     await self.compact_context_if_needed()
                     self.compact_context_completed = True
@@ -1977,27 +2006,34 @@ class Coder(metaclass=UsageMeta):
         done_messages = manager.get_messages_dict(MessageTag.DONE)
         cur_messages = manager.get_messages_dict(MessageTag.CUR)
         diff_messages = manager.get_messages_dict(MessageTag.DIFFS)
+        file_context_messages = manager.get_messages_dict(MessageTag.FILE_CONTEXTS)
         all_messages = manager.get_messages_dict()
 
         # Exclude first cur_message since that's the user's initial input
         done_tokens = self.summarizer.count_tokens(done_messages)
         cur_tokens = self.summarizer.count_tokens(cur_messages[1:] if len(cur_messages) > 1 else [])
         diff_tokens = self.summarizer.count_tokens(diff_messages)
+        file_context_tokens = self.summarizer.count_tokens(file_context_messages)
         all_tokens = self.summarizer.count_tokens(all_messages)
 
-        combined_tokens = done_tokens + cur_tokens + diff_tokens
+        message_tokens = done_tokens + cur_tokens
+        file_tokens = diff_tokens + file_context_tokens
+        combined_tokens = done_tokens + cur_tokens + diff_tokens + file_context_tokens
 
         self.context_compaction_current_ratio = all_tokens / self.context_compaction_max_tokens
 
         if force or (
             all_tokens >= self.context_compaction_max_tokens * 0.9
             and ConversationService.get_chunks(self).last_clear_count > 20
+            and file_tokens / max(message_tokens, 1) > 2
         ):
             manager.clear_tag(MessageTag.LINT, ratio=0.33)
             manager.clear_tag(MessageTag.DIFFS, ratio=0.33)
             manager.clear_tag(MessageTag.FILE_CONTEXTS, ratio=0.33)
             ConversationService.get_files(self).clear_file_cache()
             ConversationService.get_chunks(self).flush_removals()
+            ConversationService.get_chunks(self).reset_clear_count()
+            ObservationService.get_instance(self).reset_index()
 
         if not force and combined_tokens < self.context_compaction_max_tokens:
             return
@@ -2031,9 +2067,9 @@ class Coder(metaclass=UsageMeta):
                 manager.clear_tag(tag)
 
                 if tag == MessageTag.DONE:
-                    manager.add_message({"role": "user", "content": text}, tag=tag)
-                    manager.add_message(
-                        {
+                    manager.queue_message(message_dict={"role": "user", "content": text}, tag=tag)
+                    manager.queue_message(
+                        message_dict={
                             "role": "assistant",
                             "content": (
                                 "Ok, I will use this summary and the observations as context for"
@@ -2044,12 +2080,13 @@ class Coder(metaclass=UsageMeta):
                     )
                 else:
                     if self.last_user_message:
-                        manager.add_message(
-                            {"role": "user", "content": self.last_user_message}, tag=tag
+                        manager.queue_message(
+                            message_dict={"role": "user", "content": self.last_user_message},
+                            tag=tag,
                         )
 
-                    manager.add_message(
-                        {
+                    manager.queue_message(
+                        message_dict={
                             "role": "assistant",
                             "content": "Ok. I am awaiting your summary of our goals to proceed.",
                         },
@@ -2057,8 +2094,8 @@ class Coder(metaclass=UsageMeta):
                         force=True,
                     )
 
-                    manager.add_message(
-                        {
+                    manager.queue_message(
+                        message_dict={
                             "role": "user",
                             "content": (
                                 "Here is a summary of our current goals and historical"
@@ -2068,8 +2105,8 @@ class Coder(metaclass=UsageMeta):
                         tag=tag,
                     )
 
-                    manager.add_message(
-                        {
+                    manager.queue_message(
+                        message_dict={
                             "role": "assistant",
                             "content": (
                                 "Ok, I will use this summary and proceed with our task. I will"
@@ -2102,6 +2139,9 @@ class Coder(metaclass=UsageMeta):
             manager.clear_tag(MessageTag.FILE_CONTEXTS)
             ConversationService.get_files(self).clear_file_cache()
             ConversationService.get_chunks(self).flush_removals()
+            ConversationService.get_chunks(self).reset_clear_count()
+            ObservationService.get_instance(self).reset_index()
+            self.format_chat_chunks()
 
         except Exception as e:
             self.io.tool_warning(f"Context compaction failed: {e}")
@@ -2481,7 +2521,11 @@ class Coder(metaclass=UsageMeta):
             if not self.tui:
                 spinner_text += f" • ${self.format_cost(self.total_cost)} session"
 
-            self.io.start_spinner(spinner_text, coder_uuid=getattr(self, "uuid", None))
+            if self.io.spinner_active:
+                self.io.start_spinner(spinner_text, coder_uuid=getattr(self, "uuid", None))
+            else:
+                self.message_cost_deferred = spinner_text
+
             if self.stream:
                 self.mdstream = True
             else:
@@ -2604,6 +2648,10 @@ class Coder(metaclass=UsageMeta):
 
             # Ensure any waiting spinner is stopped
             self.io.start_spinner("Processing Answer...", coder_uuid=getattr(self, "uuid", None))
+
+            if not self.io.spinner_active:
+                self.partial_response_content = self.get_multi_response_content_in_progress(True)
+
             self.remove_reasoning_content()
             self.multi_response_content = ""
 
@@ -2949,12 +2997,22 @@ class Coder(metaclass=UsageMeta):
                             continue
 
                         async def do_tool_call():
+                            nonlocal session
                             from litellm import experimental_mcp_client
 
-                            return await experimental_mcp_client.call_openai_tool(
-                                session=session,
-                                openai_tool=new_tool_call,
-                            )
+                            try:
+                                return await experimental_mcp_client.call_openai_tool(
+                                    session=session,
+                                    openai_tool=new_tool_call,
+                                )
+                            except Exception as e:
+                                if server.is_session_expired_error(e):
+                                    session = await server.reconnect()
+                                    return await experimental_mcp_client.call_openai_tool(
+                                        session=session,
+                                        openai_tool=new_tool_call,
+                                    )
+                                raise
 
                         call_result, interrupted = await coroutines.interruptible(
                             do_tool_call(), self.interrupt_event

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/commands/__init__.py

@@ -8,6 +8,7 @@ BaseCommand pattern for modular, testable command execution.
 from .add import AddCommand
 from .agent import AgentCommand
 from .agent_model import AgentModelCommand
+from .agent_tree import AgentTreeCommand
 from .architect import ArchitectCommand
 from .ask import AskCommand
 from .clear import ClearCommand
@@ -94,6 +95,7 @@ from .workspace import WorkspaceCommand
 CommandRegistry.register(AddCommand)
 CommandRegistry.register(AgentCommand)
 CommandRegistry.register(AgentModelCommand)
+CommandRegistry.register(AgentTreeCommand)
 CommandRegistry.register(ArchitectCommand)
 CommandRegistry.register(AskCommand)
 CommandRegistry.register(ClearCommand)
@@ -169,6 +171,7 @@ __all__ = [
     "AddCommand",
     "AgentCommand",
     "AgentModelCommand",
+    "AgentTreeCommand",
     "ArchitectCommand",
     "AskCommand",
     "BaseCommand",

cecli_dev-0.100.14/cecli/commands/agent_tree.py

@@ -0,0 +1,95 @@
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.helpers.agents.service import AgentService, SubAgentInfo, SubAgentStatus
+
+
+class TreeNode:
+    """A node in the agent hierarchy tree."""
+
+    def __init__(self, agent_info: SubAgentInfo):
+        self.agent_info = agent_info
+        self.children: List[TreeNode] = []
+
+    def add_child(self, child_node: "TreeNode"):
+        self.children.append(child_node)
+
+
+class AgentTreeCommand(BaseCommand):
+    """Command to display the hierarchy of active agents."""
+
+    NORM_NAME = "agent-tree"
+    DESCRIPTION = "Display the hierarchy of active agents."
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the /agent-tree command."""
+        agent_service = AgentService.get_instance(coder)
+        if not agent_service:
+            io.tool_output("Agent service not available.")
+            return
+
+        # Collect all agents: primary coder + sub-agents from sub_agents dict
+        all_infos: List[SubAgentInfo] = []
+
+        # Primary agent as a synthetic SubAgentInfo
+        primary_coder = agent_service.coder
+        primary_info = SubAgentInfo(
+            name="primary",
+            coder=primary_coder,
+            parent_uuid=str(primary_coder.parent_uuid or ""),
+            status=SubAgentStatus.RUNNING,
+        )
+        all_infos.append(primary_info)
+
+        # Sub-agents from the service's sub_agents dict
+        for info in agent_service.sub_agents.values():
+            if info and info.coder:
+                all_infos.append(info)
+
+        if len(all_infos) <= 1:
+            io.tool_output("No active sub-agents found.")
+            return
+
+        root_nodes = cls._build_tree(all_infos)
+        tree_output = cls._render_tree(root_nodes)
+        io.tool_output(tree_output)
+
+    @classmethod
+    def _build_tree(cls, all_agents: List[SubAgentInfo]) -> List[TreeNode]:
+        """Build the agent tree from a flat list of agents."""
+        nodes = {str(agent.coder.uuid): TreeNode(agent) for agent in all_agents}
+        root_nodes = []
+
+        for agent in all_agents:
+            parent_uuid = str(agent.coder.parent_uuid)
+            if parent_uuid and parent_uuid in nodes:
+                parent_node = nodes[parent_uuid]
+                child_node = nodes[str(agent.coder.uuid)]
+                parent_node.add_child(child_node)
+            else:
+                root_nodes.append(nodes[str(agent.coder.uuid)])
+
+        return root_nodes
+
+    @classmethod
+    def _render_tree(cls, nodes: List[TreeNode]) -> str:
+        """Render the agent tree to a string."""
+        output = []
+
+        def render_node(node: TreeNode, prefix: str = "", is_last: bool = True):
+            connector = "└── " if is_last else "├── "
+            output.append(
+                f"{prefix}{connector}{node.agent_info.name}"
+                f" ({node.agent_info.status.value})"
+                f" - {str(node.agent_info.coder.uuid)}"
+            )
+
+            child_prefix = prefix + ("    " if is_last else "│   ")
+            for i, child in enumerate(node.children):
+                render_node(child, child_prefix, i == len(node.children) - 1)
+
+        for i, node in enumerate(nodes):
+            render_node(node, is_last=i == len(nodes) - 1)
+
+        return "\n".join(output)

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/helpers/conversation/integration.py

@@ -245,62 +245,7 @@ class ConversationChunks:
         if not coder:
             return
 
-        # Check diff message ratio and clear if too many diffs
-        diff_messages = ConversationService.get_manager(coder).get_messages_dict(MessageTag.DIFFS)
-        read_only_messages = ConversationService.get_manager(coder).get_messages_dict(
-            MessageTag.READONLY_FILES
-        )
-        chat_messages = ConversationService.get_manager(coder).get_messages_dict(
-            MessageTag.CHAT_FILES
-        )
-        edit_messages = ConversationService.get_manager(coder).get_messages_dict(
-            MessageTag.EDIT_FILES
-        )
-
-        # Calculate token counts for token-based ratio check
-        diff_tokens = coder.main_model.token_count(diff_messages) if diff_messages else 0
-
-        # Calculate tokens for readonly, chat, and edit tag messages
-        other_tokens = 0
-        if read_only_messages:
-            other_tokens += coder.main_model.token_count(read_only_messages)
-        if chat_messages:
-            other_tokens += coder.main_model.token_count(chat_messages)
-        if edit_messages:
-            other_tokens += coder.main_model.token_count(edit_messages)
-
-        # Calculate message counts for message-based ratio check
-        diff_count = len(diff_messages)
-        other_count = len(read_only_messages) + len(chat_messages) + len(edit_messages)
-
-        # Clear diff messages and file caches if EITHER:
-        # 1. Diff tokens > 33% of other message tokens (token-based check)
-        # 2. Diff message count ratio > 5:1 (message count-based check for periodic refresh)
-        should_clear = False
-
-        # Token-based check
-        if diff_tokens > 0 and other_tokens > 0 and diff_tokens / other_tokens > 0.5:
-            should_clear = True
-
-        # Message count-based check (for periodic refresh)
-        if diff_count > 0 and other_count > 0 and diff_count / other_count > 20:
-            should_clear = True
-
         self.last_clear_count += 1
-
-        if (
-            should_clear
-            and coder.context_compaction_current_ratio > 0.8
-            and self.last_clear_count >= 20
-            and diff_tokens + other_tokens > coder.context_compaction_max_tokens * 0.5
-        ):
-            self.last_clear_count = 0
-
-            # Clear all diff messages
-            ConversationService.get_manager(coder).clear_tag(MessageTag.DIFFS, 0.33)
-            # Clear ConversationFiles caches to force regeneration
-            ConversationService.get_files(coder).clear_file_cache(clear_contexts=False)
-
         # Get all tracked files (both regular and image files)
         tracked_files = ConversationService.get_files(coder).get_all_tracked_files()
 
@@ -483,7 +428,7 @@ class ConversationChunks:
         repo_messages = ConversationService.get_manager(coder).get_messages_dict(MessageTag.REPO)
         if len(repo_messages) >= 20:
             # Clear all REPO tagged messages
-            ConversationService.get_manager(coder).clear_tag(MessageTag.REPO)
+            ConversationService.get_manager(coder).clear_tag(MessageTag.REPO, ratio=0.33)
             # Clear the combined repomap dict to force fresh regeneration
             if (
                 hasattr(coder, "repo_map")
@@ -1017,6 +962,9 @@ class ConversationChunks:
     def flush_removals(self):
         self._deferred_removals.clear()
 
+    def reset_clear_count(self):
+        self.last_clear_count = 0
+
     def _cancel_post_message_injections(self, modulus=10):
         coder = self.get_coder()
         if not coder:

{cecli_dev-0.100.12rc5 → cecli_dev-0.100.14}/cecli/helpers/hashline.py

@@ -320,6 +320,16 @@ def resolve_content_to_hashline_ids(
         value_stripped = value.strip()
         return [i for i, line in enumerate(lines) if value_stripped in line]
 
+    def _find_multiline_match(lines, value):
+        """Find the start index where the full multiline value matches consecutive lines."""
+        value_lines = value.strip().splitlines()
+        if len(value_lines) <= 1:
+            return None
+        for i in range(len(lines) - len(value_lines) + 1):
+            if all(value_lines[j].strip() in lines[i + j] for j in range(len(value_lines))):
+                return i
+        return None
+
     def _resolve_to_hash_id(lines, idx, hp):
         """Generate a hash ID for the line at the given index."""
         hash_id = hp.generate_public_id(lines[idx], idx)
@@ -333,10 +343,18 @@ def resolve_content_to_hashline_ids(
     resolved_start_idx = None
 
     if start_value is not None and not _looks_like_content_id(start_value):
-        containing_indices = _find_substring_matches(lines, start_value)
-        if len(containing_indices) == 1:
-            resolved_start_idx = containing_indices[0]
+        # For multiline values, try full multiline match first
+        first_line = start_value.splitlines()[0] if start_value.splitlines() else start_value
+        multiline_start_idx = _find_multiline_match(lines, start_value)
+        if multiline_start_idx is not None:
+            resolved_start_idx = multiline_start_idx
             resolved_start = _resolve_to_hash_id(lines, resolved_start_idx, hp)
+        else:
+            # Fall back to first line substring matching
+            containing_indices = _find_substring_matches(lines, first_line)
+            if len(containing_indices) == 1:
+                resolved_start_idx = containing_indices[0]
+                resolved_start = _resolve_to_hash_id(lines, resolved_start_idx, hp)
     elif start_value is not None and _looks_like_content_id(start_value):
         # Already a content ID - try to resolve it to find the line position
         # for proximity matching with end_value
@@ -352,18 +370,26 @@ def resolve_content_to_hashline_ids(
     resolved_end = end_value
 
     if end_value is not None and not _looks_like_content_id(end_value):
-        containing_indices = _find_substring_matches(lines, end_value)
-        if len(containing_indices) == 1:
-            # Unique match - resolve directly
-            idx = containing_indices[0]
+        # For multiline values, try full multiline match first
+        first_line = end_value.splitlines()[0] if end_value.splitlines() else end_value
+        multiline_end_idx = _find_multiline_match(lines, end_value)
+        if multiline_end_idx is not None:
+            idx = multiline_end_idx
             resolved_end = _resolve_to_hash_id(lines, idx, hp)
-        elif len(containing_indices) > 1 and resolved_start_idx is not None:
-            # Multiple matches - pick closest to start position
-            closest_idx = min(
-                containing_indices,
-                key=lambda idx: abs(idx - resolved_start_idx),
-            )
-            resolved_end = _resolve_to_hash_id(lines, closest_idx, hp)
+        else:
+            # Fall back to first line substring matching
+            containing_indices = _find_substring_matches(lines, first_line)
+            if len(containing_indices) == 1:
+                # Unique match - resolve directly
+                idx = containing_indices[0]
+                resolved_end = _resolve_to_hash_id(lines, idx, hp)
+            elif len(containing_indices) > 1 and resolved_start_idx is not None:
+                # Multiple matches - pick closest to start position
+                closest_idx = min(
+                    containing_indices,
+                    key=lambda idx: abs(idx - resolved_start_idx),
+                )
+                resolved_end = _resolve_to_hash_id(lines, closest_idx, hp)
 
     return resolved_start, resolved_end