klaude-code 1.9.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

klaude_code/session/session.py

@@ -9,16 +9,13 @@ from typing import Any, cast
 
 from pydantic import BaseModel, Field, PrivateAttr, ValidationError
 
-from klaude_code.protocol import events, llm_param, model, tools
-from klaude_code.session.store import JsonlSessionStore, ProjectPaths, build_meta_snapshot
+from klaude_code.const import ProjectPaths, project_key_from_cwd
+from klaude_code.protocol import events, llm_param, message, model, tools
+from klaude_code.session.store import JsonlSessionStore, build_meta_snapshot
 
 _DEFAULT_STORES: dict[str, JsonlSessionStore] = {}
 
 
-def _project_key_from_cwd() -> str:
-    return str(Path.cwd()).strip("/").replace("/", "-")
-
-
 def _read_json_dict(path: Path) -> dict[str, Any] | None:
     try:
         raw = json.loads(path.read_text(encoding="utf-8"))
@@ -30,7 +27,7 @@ def _read_json_dict(path: Path) -> dict[str, Any] | None:
 
 
 def get_default_store() -> JsonlSessionStore:
-    project_key = _project_key_from_cwd()
+    project_key = project_key_from_cwd()
     store = _DEFAULT_STORES.get(project_key)
     if store is None:
         store = JsonlSessionStore(project_key=project_key)
@@ -48,7 +45,7 @@ async def close_default_store() -> None:
 class Session(BaseModel):
     id: str = Field(default_factory=lambda: uuid.uuid4().hex)
     work_dir: Path
-    conversation_history: list[model.ConversationItem] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
+    conversation_history: list[message.HistoryEvent] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
     sub_agent_state: model.SubAgentState | None = None
     file_tracker: dict[str, model.FileStatus] = Field(default_factory=dict)
     todos: list[model.TodoItem] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
@@ -67,12 +64,12 @@ class Session(BaseModel):
 
     @property
     def messages_count(self) -> int:
-        """Count of user, assistant messages, and tool calls in conversation history."""
+        """Count of user, assistant messages, and tool results in conversation history."""
         if self._messages_count_cache is None:
             self._messages_count_cache = sum(
                 1
                 for it in self.conversation_history
-                if isinstance(it, (model.UserMessageItem, model.AssistantMessageItem, model.ToolCallItem))
+                if isinstance(it, (message.UserMessage, message.AssistantMessage, message.ToolResultMessage))
             )
         return self._messages_count_cache
 
@@ -89,13 +86,15 @@ class Session(BaseModel):
 
         if self._user_messages_cache is None:
             self._user_messages_cache = [
-                it.content for it in self.conversation_history if isinstance(it, model.UserMessageItem) and it.content
+                message.join_text_parts(it.parts)
+                for it in self.conversation_history
+                if isinstance(it, message.UserMessage) and message.join_text_parts(it.parts)
             ]
         return self._user_messages_cache
 
     @staticmethod
     def _project_key() -> str:
-        return _project_key_from_cwd()
+        return project_key_from_cwd()
 
     @classmethod
     def paths(cls) -> ProjectPaths:
@@ -186,21 +185,25 @@ class Session(BaseModel):
         session.conversation_history = store.load_history(id)
         return session
 
-    def append_history(self, items: Sequence[model.ConversationItem]) -> None:
+    def append_history(self, items: Sequence[message.HistoryEvent]) -> None:
         if not items:
             return
 
         self.conversation_history.extend(items)
         self._invalidate_messages_count_cache()
 
-        new_user_messages = [it.content for it in items if isinstance(it, model.UserMessageItem) and it.content]
+        new_user_messages = [
+            message.join_text_parts(it.parts)
+            for it in items
+            if isinstance(it, message.UserMessage) and message.join_text_parts(it.parts)
+        ]
         if new_user_messages:
             if self._user_messages_cache is None:
                 # Build from full history once to ensure correctness when resuming older sessions.
                 self._user_messages_cache = [
-                    it.content
+                    message.join_text_parts(it.parts)
                     for it in self.conversation_history
-                    if isinstance(it, model.UserMessageItem) and it.content
+                    if isinstance(it, message.UserMessage) and message.join_text_parts(it.parts)
                 ]
             else:
                 self._user_messages_cache.extend(new_user_messages)
@@ -279,69 +282,91 @@ class Session(BaseModel):
                 latest_id = sid
         return latest_id
 
-    def need_turn_start(self, prev_item: model.ConversationItem | None, item: model.ConversationItem) -> bool:
-        if not isinstance(
-            item,
-            model.ReasoningTextItem | model.AssistantMessageItem | model.ToolCallItem,
-        ):
+    def need_turn_start(self, prev_item: message.HistoryEvent | None, item: message.HistoryEvent) -> bool:
+        if not isinstance(item, message.AssistantMessage):
             return False
         if prev_item is None:
             return True
-        return isinstance(prev_item, model.UserMessageItem | model.ToolResultItem | model.DeveloperMessageItem)
+        return isinstance(prev_item, (message.UserMessage, message.ToolResultMessage, message.DeveloperMessage))
 
     def get_history_item(self) -> Iterable[events.HistoryItemEvent]:
         seen_sub_agent_sessions: set[str] = set()
-        prev_item: model.ConversationItem | None = None
+        prev_item: message.HistoryEvent | None = None
         last_assistant_content: str = ""
         report_back_result: str | None = None
+        history = self.conversation_history
+        history_len = len(history)
         yield events.TaskStartEvent(session_id=self.id, sub_agent_state=self.sub_agent_state)
-        for it in self.conversation_history:
+        for idx, it in enumerate(history):
             if self.need_turn_start(prev_item, it):
                 yield events.TurnStartEvent(session_id=self.id)
             match it:
-                case model.AssistantMessageItem() as am:
-                    content = am.content or ""
-                    last_assistant_content = content
+                case message.AssistantMessage() as am:
+                    content = message.join_text_parts(am.parts)
+                    images = [part for part in am.parts if isinstance(part, message.ImageFilePart)]
+                    last_assistant_content = message.format_saved_images(images, content)
+                    thinking_text = "".join(
+                        part.text for part in am.parts if isinstance(part, message.ThinkingTextPart)
+                    )
+                    for image in images:
+                        yield events.AssistantImageDeltaEvent(
+                            file_path=image.file_path,
+                            response_id=am.response_id,
+                            session_id=self.id,
+                        )
                     yield events.AssistantMessageEvent(
+                        thinking_text=thinking_text,
                         content=content,
                         response_id=am.response_id,
                         session_id=self.id,
                     )
-                case model.ToolCallItem() as tc:
-                    if tc.name == tools.REPORT_BACK:
-                        report_back_result = tc.arguments
-                    yield events.ToolCallEvent(
-                        tool_call_id=tc.call_id,
-                        tool_name=tc.name,
-                        arguments=tc.arguments,
-                        response_id=tc.response_id,
-                        session_id=self.id,
-                    )
-                case model.ToolResultItem() as tr:
+                    for part in am.parts:
+                        if not isinstance(part, message.ToolCallPart):
+                            continue
+                        if part.tool_name == tools.REPORT_BACK:
+                            report_back_result = part.arguments_json
+                        yield events.ToolCallEvent(
+                            tool_call_id=part.call_id,
+                            tool_name=part.tool_name,
+                            arguments=part.arguments_json,
+                            response_id=am.response_id,
+                            session_id=self.id,
+                        )
+                    if am.stop_reason == "aborted":
+                        yield events.InterruptEvent(session_id=self.id)
+                case message.ToolResultMessage() as tr:
+                    status = "success" if tr.status == "success" else "error"
+                    # Check if this is the last tool result in the current turn
+                    next_item = history[idx + 1] if idx + 1 < history_len else None
+                    is_last_in_turn = not isinstance(next_item, message.ToolResultMessage)
                     yield events.ToolResultEvent(
                         tool_call_id=tr.call_id,
                         tool_name=str(tr.tool_name),
-                        result=tr.output or "",
+                        result=tr.output_text,
                         ui_extra=tr.ui_extra,
                         session_id=self.id,
-                        status=tr.status,
+                        status=status,
                         task_metadata=tr.task_metadata,
+                        is_last_in_turn=is_last_in_turn,
                     )
                     yield from self._iter_sub_agent_history(tr, seen_sub_agent_sessions)
-                case model.UserMessageItem() as um:
-                    yield events.UserMessageEvent(content=um.content or "", session_id=self.id, images=um.images)
-                case model.ReasoningTextItem() as ri:
-                    yield events.ThinkingEvent(content=ri.content, session_id=self.id)
+                    if tr.status == "aborted":
+                        yield events.InterruptEvent(session_id=self.id)
+                case message.UserMessage() as um:
+                    images = [part for part in um.parts if isinstance(part, message.ImageURLPart)]
+                    yield events.UserMessageEvent(
+                        content=message.join_text_parts(um.parts),
+                        session_id=self.id,
+                        images=images or None,
+                    )
                 case model.TaskMetadataItem() as mt:
                     yield events.TaskMetadataEvent(session_id=self.id, metadata=mt)
-                case model.InterruptItem():
-                    yield events.InterruptEvent(session_id=self.id)
-                case model.DeveloperMessageItem() as dm:
+                case message.DeveloperMessage() as dm:
                     yield events.DeveloperMessageEvent(session_id=self.id, item=dm)
-                case model.StreamErrorItem() as se:
+                case message.StreamErrorItem() as se:
                     yield events.ErrorEvent(error_message=se.error, can_retry=False, session_id=self.id)
-                case _:
-                    continue
+                case message.SystemMessage():
+                    pass
             prev_item = it
 
         has_structured_output = report_back_result is not None
@@ -351,7 +376,7 @@ class Session(BaseModel):
         )
 
     def _iter_sub_agent_history(
-        self, tool_result: model.ToolResultItem, seen_sub_agent_sessions: set[str]
+        self, tool_result: message.ToolResultMessage, seen_sub_agent_sessions: set[str]
     ) -> Iterable[events.HistoryItemEvent]:
         ui_extra = tool_result.ui_extra
         if not isinstance(ui_extra, model.SessionIdUIExtra):
@@ -393,14 +418,18 @@ class Session(BaseModel):
                     if not isinstance(obj_raw, dict):
                         continue
                     obj = cast(dict[str, Any], obj_raw)
-                    if obj.get("type") != "UserMessageItem":
+                    if obj.get("type") != "UserMessage":
                         continue
                     data_raw = obj.get("data")
                     if not isinstance(data_raw, dict):
                         continue
                     data = cast(dict[str, Any], data_raw)
-                    content = data.get("content")
-                    if isinstance(content, str):
+                    try:
+                        user_msg = message.UserMessage.model_validate(data)
+                    except ValidationError:
+                        continue
+                    content = message.join_text_parts(user_msg.parts)
+                    if content:
                         messages.append(content)
             except (OSError, json.JSONDecodeError):
                 pass
@@ -457,6 +486,49 @@ class Session(BaseModel):
         items.sort(key=lambda d: d.updated_at, reverse=True)
         return items
 
+    @classmethod
+    def resolve_sub_agent_session_id(cls, resume: str) -> str:
+        """Resolve a sub-agent session id from an id prefix.
+
+        Args:
+            resume: Full session id or a unique prefix.
+
+        Returns:
+            The resolved full session id.
+
+        Raises:
+            ValueError: If resume is empty, not found, or ambiguous.
+        """
+
+        prefix = (resume or "").strip().lower()
+        if not prefix:
+            raise ValueError("resume cannot be empty")
+
+        store = get_default_store()
+        matches: set[str] = set()
+
+        for meta_path in store.iter_meta_files():
+            data = _read_json_dict(meta_path)
+            if data is None:
+                continue
+            # Only allow resuming sub-agent sessions.
+            if data.get("sub_agent_state") is None:
+                continue
+            sid = str(data.get("id", meta_path.parent.name)).strip()
+            if sid.lower().startswith(prefix):
+                matches.add(sid)
+
+        if not matches:
+            raise ValueError(f"resume id not found for this project: '{resume}'")
+
+        resolved = sorted(matches)
+        if len(resolved) > 1:
+            sample = ", ".join(resolved[:8])
+            suffix = "" if len(resolved) <= 8 else f" (+{len(resolved) - 8} more)"
+            raise ValueError(f"resume id is ambiguous: '{resume}' matches {sample}{suffix}")
+
+        return resolved[0]
+
     @classmethod
     def clean_small_sessions(cls, min_messages: int = 5) -> int:
         sessions = cls.list_sessions()

klaude_code/session/store.py

@@ -8,36 +8,11 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, cast
 
-from klaude_code.protocol import llm_param, model
+from klaude_code.const import ProjectPaths
+from klaude_code.protocol import llm_param, message, model
 from klaude_code.session.codec import decode_jsonl_line, encode_jsonl_line
 
 
-@dataclass(frozen=True)
-class ProjectPaths:
-    project_key: str
-
-    @property
-    def base_dir(self) -> Path:
-        return Path.home() / ".klaude" / "projects" / self.project_key
-
-    @property
-    def sessions_dir(self) -> Path:
-        return self.base_dir / "sessions"
-
-    @property
-    def exports_dir(self) -> Path:
-        return self.base_dir / "exports"
-
-    def session_dir(self, session_id: str) -> Path:
-        return self.sessions_dir / session_id
-
-    def events_file(self, session_id: str) -> Path:
-        return self.session_dir(session_id) / "events.jsonl"
-
-    def meta_file(self, session_id: str) -> Path:
-        return self.session_dir(session_id) / "meta.json"
-
-
 class _WriterClosedError(RuntimeError):
     pass
 
@@ -135,7 +110,7 @@ class JsonlSessionStore:
             return None
         return cast(dict[str, Any], raw) if isinstance(raw, dict) else None
 
-    def load_history(self, session_id: str) -> list[model.ConversationItem]:
+    def load_history(self, session_id: str) -> list[message.HistoryEvent]:
         events_path = self._paths.events_file(session_id)
         if not events_path.exists():
             return []
@@ -143,7 +118,7 @@ class JsonlSessionStore:
             lines = events_path.read_text(encoding="utf-8").splitlines()
         except OSError:
             return []
-        items: list[model.ConversationItem] = []
+        items: list[message.HistoryEvent] = []
         for line in lines:
             item = decode_jsonl_line(line)
             if item is None:
@@ -151,9 +126,7 @@ class JsonlSessionStore:
             items.append(item)
         return items
 
-    def append_and_flush(
-        self, *, session_id: str, items: Sequence[model.ConversationItem], meta: dict[str, Any]
-    ) -> None:
+    def append_and_flush(self, *, session_id: str, items: Sequence[message.HistoryEvent], meta: dict[str, Any]) -> None:
         if not items:
             return
         loop = asyncio.get_running_loop()

klaude_code/session/templates/export_session.html

@@ -1853,7 +1853,7 @@
                       ) {
                         let desc = args.description.trim();
                         if (desc.length > 30) {
-                          desc = desc.substring(0, 30) + "...";
+                          desc = desc.substring(0, 30) + "…";
                         }
                         label = label + " - " + desc;
                       }

klaude_code/session/templates/mermaid_viewer.html

@@ -485,7 +485,7 @@
           <textarea
             id="source-code"
             spellcheck="false"
-            placeholder="Enter mermaid diagram code..."
+            placeholder="Enter mermaid diagram code…"
           >
 __KLAUDE_CODE__</textarea
           >

klaude_code/trace/log.py

@@ -13,7 +13,12 @@ from rich.console import Console
 from rich.logging import RichHandler
 from rich.text import Text
 
-from klaude_code import const
+from klaude_code.const import (
+    DEFAULT_DEBUG_LOG_DIR,
+    DEFAULT_DEBUG_LOG_FILE,
+    LOG_BACKUP_COUNT,
+    LOG_MAX_BYTES,
+)
 
 # Module-level logger
 logger = logging.getLogger("klaude_code")
@@ -123,13 +128,13 @@ def set_debug_logging(
         file_path = None
 
     if use_file and file_path is not None:
-        _prune_old_logs(const.DEFAULT_DEBUG_LOG_DIR, LOG_RETENTION_DAYS, LOG_MAX_TOTAL_BYTES)
+        _prune_old_logs(DEFAULT_DEBUG_LOG_DIR, LOG_RETENTION_DAYS, LOG_MAX_TOTAL_BYTES)
 
     if use_file and file_path is not None:
         _file_handler = GzipRotatingFileHandler(
             file_path,
-            maxBytes=const.LOG_MAX_BYTES,
-            backupCount=const.LOG_BACKUP_COUNT,
+            maxBytes=LOG_MAX_BYTES,
+            backupCount=LOG_BACKUP_COUNT,
             encoding="utf-8",
         )
         _file_handler.setLevel(logging.DEBUG)
@@ -238,7 +243,7 @@ def _build_default_log_file_path() -> Path:
     """Build a per-session log path under the default log directory."""
 
     now = datetime.now()
-    session_dir = const.DEFAULT_DEBUG_LOG_DIR / now.strftime("%Y-%m-%d")
+    session_dir = DEFAULT_DEBUG_LOG_DIR / now.strftime("%Y-%m-%d")
     session_dir.mkdir(parents=True, exist_ok=True)
     filename = f"{now.strftime('%H%M%S')}-{os.getpid()}.log"
     return session_dir / filename
@@ -247,7 +252,7 @@ def _build_default_log_file_path() -> Path:
 def _refresh_latest_symlink(target: Path) -> None:
     """Point the debug.log symlink at the latest session file."""
 
-    latest = const.DEFAULT_DEBUG_LOG_FILE
+    latest = DEFAULT_DEBUG_LOG_FILE
     try:
         latest.unlink(missing_ok=True)
         latest.symlink_to(target)

klaude_code/ui/core/input.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator
 
-from klaude_code.protocol.model import UserInputPayload
+from klaude_code.protocol.message import UserInputPayload
 
 
 class InputProviderABC(ABC):

klaude_code/ui/core/stage_manager.py

@@ -40,16 +40,9 @@ class StageManager:
             return
         await self.transition_to(Stage.THINKING)
 
-    async def finish_assistant(self) -> None:
-        if self._stage != Stage.ASSISTANT:
-            await self._finish_assistant()
-            return
-        await self._finish_assistant()
-        self._stage = Stage.WAITING
-
     async def _leave_current_stage(self) -> None:
         if self._stage == Stage.THINKING:
             await self._finish_thinking()
         elif self._stage == Stage.ASSISTANT:
-            await self.finish_assistant()
+            await self._finish_assistant()
         self._stage = Stage.WAITING

klaude_code/ui/modes/debug/display.py

@@ -1,7 +1,7 @@
 import os
 from typing import override
 
-from klaude_code import const
+from klaude_code.const import DEFAULT_DEBUG_LOG_FILE
 from klaude_code.protocol import events
 from klaude_code.trace import DebugType, log_debug
 from klaude_code.ui.core.display import DisplayABC
@@ -11,7 +11,7 @@ class DebugEventDisplay(DisplayABC):
     def __init__(
         self,
         wrapped_display: DisplayABC | None = None,
-        log_file: str | os.PathLike[str] = const.DEFAULT_DEBUG_LOG_FILE,
+        log_file: str | os.PathLike[str] = DEFAULT_DEBUG_LOG_FILE,
     ):
         self.wrapped_display = wrapped_display
         self.log_file = log_file

klaude_code/ui/modes/repl/clipboard.py

@@ -19,7 +19,7 @@ from pathlib import Path
 
 from PIL import Image, ImageGrab
 
-from klaude_code.protocol.model import ImageURLPart
+from klaude_code.protocol.message import ImageURLPart
 
 # Directory for storing clipboard images
 CLIPBOARD_IMAGES_DIR = Path.home() / ".klaude" / "clipboard" / "images"
@@ -122,7 +122,7 @@ def _encode_image_file(file_path: str) -> ImageURLPart | None:
             encoded = b64encode(f.read()).decode("ascii")
         # Clipboard images are always saved as PNG
         data_url = f"data:image/png;base64,{encoded}"
-        return ImageURLPart(image_url=ImageURLPart.ImageURL(url=data_url, id=None))
+        return ImageURLPart(url=data_url, id=None)
     except OSError:
         return None
 

klaude_code/ui/modes/repl/completers.py

@@ -27,6 +27,7 @@ from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.document import Document
 from prompt_toolkit.formatted_text import FormattedText
 
+from klaude_code.const import COMPLETER_CACHE_TTL_SEC, COMPLETER_CMD_TIMEOUT_SEC, COMPLETER_DEBOUNCE_SEC
 from klaude_code.protocol.commands import CommandInfo
 from klaude_code.trace.log import DebugType, log_debug
 
@@ -65,7 +66,7 @@ class _SlashCommandCompleter(Completer):
     """Complete slash commands at the beginning of the first line.
 
     Behavior:
-    - Only triggers when cursor is on first line and text matches /...
+    - Only triggers when cursor is on first line and text matches /…
     - Shows available slash commands with descriptions
     - Inserts trailing space after completion
     """
@@ -132,7 +133,7 @@ class _SkillCompleter(Completer):
     """Complete skill names at the beginning of the first line.
 
     Behavior:
-    - Only triggers when cursor is on first line and text matches $ or ¥...
+    - Only triggers when cursor is on first line and text matches $ or ¥…
     - Shows available skills with descriptions
     - Inserts trailing space after completion
     """
@@ -240,7 +241,7 @@ class _AtFilesCompleter(Completer):
     """Complete @path segments using fd or ripgrep.
 
     Behavior:
-    - Only triggers when the cursor is after an "@..." token (until whitespace).
+    - Only triggers when the cursor is after an "@…" token (until whitespace).
     - Completes paths relative to the current working directory.
     - Uses `fd` when available (files and directories), falls back to `rg --files` (files only).
     - Debounces external commands and caches results to avoid excessive spawning.
@@ -251,8 +252,8 @@ class _AtFilesCompleter(Completer):
 
     def __init__(
         self,
-        debounce_sec: float = 0.25,
-        cache_ttl_sec: float = 60.0,
+        debounce_sec: float = COMPLETER_DEBOUNCE_SEC,
+        cache_ttl_sec: float = COMPLETER_CACHE_TTL_SEC,
         max_results: int = 20,
     ):
         self._debounce_sec = debounce_sec
@@ -283,7 +284,7 @@ class _AtFilesCompleter(Completer):
 
         # Command timeout is intentionally higher than a keypress cadence.
         # We rely on caching/narrowing to avoid calling fd repeatedly.
-        self._cmd_timeout_sec: float = 3.0
+        self._cmd_timeout_sec: float = COMPLETER_CMD_TIMEOUT_SEC
 
     # ---- prompt_toolkit API ----
     def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:  # type: ignore[override]
@@ -293,7 +294,7 @@ class _AtFilesCompleter(Completer):
             return []  # type: ignore[reportUnknownVariableType]
 
         frag = m.group("frag")  # raw text after '@' and before cursor (may be quoted)
-        # Normalize fragment for search: support optional quoting syntax @"...".
+        # Normalize fragment for search: support optional quoting syntax @"…".
         is_quoted = frag.startswith('"')
         search_frag = frag
         if is_quoted:
@@ -459,7 +460,7 @@ class _AtFilesCompleter(Completer):
         # 4. Basename hit first, then path hit position, then length
         # Since both fd and rg now search from current directory, all paths are relative to cwd
         kn = keyword_norm
-        out: list[tuple[str, tuple[int, int, int, int, int, int, int]]] = []
+        out: list[tuple[str, tuple[int, int, int, int, int, int, int, int]]] = []
         for p in paths_from_root:
             pl = p.lower()
             if kn not in pl:
@@ -481,11 +482,18 @@ class _AtFilesCompleter(Completer):
             # Deprioritize paths containing "test"
             has_test = "test" in pl
 
+            # Calculate basename match quality: how close is base to the keyword?
+            # Strip extension for files to compare stem (e.g., "renderer.py" -> "renderer")
+            base_stem = base.rsplit(".", 1)[0] if "." in base and not base.startswith(".") else base
+            # Exact stem match gets 0, otherwise difference in length
+            base_match_quality = abs(len(base_stem) - len(kn)) if base_pos != -1 else 10_000
+
             score = (
                 1 if is_hidden else 0,
                 1 if has_test else 0,
-                depth,
-                0 if base_pos != -1 else 1,
+                0 if base_pos != -1 else 1,  # basename match first
+                base_match_quality,  # more precise basename match wins
+                depth,  # then shallower paths
                 base_pos if base_pos != -1 else 10_000,
                 path_pos,
                 len(p),