trinity-agent 0.7.1__tar.gz → 0.7.2__tar.gz

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trinity-agent
-Version: 0.7.1
+Version: 0.7.2
 Summary: Three minds, one context — Multi-agent AI orchestrator for Claude Code, Codex, and Gemini CLI.
 Project-URL: Homepage, https://github.com/hongdangmoo49/Trinity
 Project-URL: Repository, https://github.com/hongdangmoo49/Trinity
@@ -150,7 +150,7 @@ Trinity가 백그라운드에서 다음 단계를 자동으로 수행합니다:
 Trinity는 **Rich 라이브러리 기반의 미려한 터미널 UI(TUI)**를 제공하여, 에이전트 간의 실시간 토론 과정을 시각적으로 보여줍니다.
 
 ```
-  🧠 Trinity v0.7.1  —  세 개의 두뇌, 하나의 컨텍스트
+  🧠 Trinity v0.7.2  —  세 개의 두뇌, 하나의 컨텍스트
 
   🏗️ claude ✅    ⚙️ codex ✅    🔍 gemini ✅
 
@@ -228,9 +228,13 @@ Trinity는 **Rich 라이브러리 기반의 미려한 터미널 UI(TUI)**를 제
 | `/agent <이름> on\|off` | 특정 에이전트를 즉시 활성화하거나 비활성화 |
 | `/history` | 이전 라운드의 토론 히스토리 요약 조회 |
 | `/save` | 현재 토론 세션의 전체 결과를 파일로 영구 저장 |
+| `/resume [N\|latest\|ID]` | 저장된 workflow 세션을 선택해 재개 |
 | `/help` | 사용 가능한 인라인 명령어 도움말 표시 |
 | `/quit` | Trinity 종료 및 백그라운드 리소스 정리 |
 
+TUI는 기본적으로 새 workflow 세션으로 시작한다. 이전 active workflow는
+`.trinity/workflow/history/`에 보존되며 `/resume`으로 명시적으로 재개한다.
+
 ---
 
 ## ⚙️ 설정
@@ -408,8 +412,8 @@ uv publish --token <PYPI_TOKEN>
 
 | 지표 | 수치 |
 | :--- | :--- |
-| **버전** | 0.7.1 |
-| **테스트** | 909개 테스트 통과 |
+| **버전** | 0.7.2 |
+| **테스트** | 915개 테스트 통과 |
 | **커버리지** | 약 87% |
 | **소스 파일** | 50여 개 |
 | **주요 의존성 라이브러리** | `click`, `rich`, `prompt_toolkit`, `tomli` |

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/README.en.md

@@ -124,7 +124,7 @@ That's it. Trinity will:
 Trinity features a **Rich-based terminal UI** with real-time deliberation visualization.
 
 ```
-  🧠 Trinity v0.7.1  —  Three minds, one context
+  🧠 Trinity v0.7.2  —  Three minds, one context
 
   🏗️ claude ✅    ⚙️ codex ✅    🔍 gemini ✅
 
@@ -202,9 +202,14 @@ Inside the interactive TUI (`trinity` with no args):
 | `/agent <name> on\|off` | Enable/disable an agent |
 | `/history` | Show deliberation history |
 | `/save` | Save session results to file |
+| `/resume [N\|latest\|ID]` | Select and resume a saved workflow session |
 | `/help` | Show help |
 | `/quit` | Exit Trinity |
 
+The TUI starts with a new workflow session by default. The previous active
+workflow is preserved in `.trinity/workflow/history/` and can be resumed
+explicitly with `/resume`.
+
 ---
 
 ## ⚙️ Configuration
@@ -382,8 +387,8 @@ uv publish --token <PYPI_TOKEN>
 
 | Metric | Value |
 | :--- | :--- |
-| **Version** | 0.7.1 |
-| **Tests** | 909 passed |
+| **Version** | 0.7.2 |
+| **Tests** | 915 passed |
 | **Coverage** | ~87% |
 | **Source files** | 50+ |
 | **Dependencies** | `click`, `rich`, `prompt_toolkit`, `tomli` |

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/README.md

@@ -122,7 +122,7 @@ Trinity가 백그라운드에서 다음 단계를 자동으로 수행합니다:
 Trinity는 **Rich 라이브러리 기반의 미려한 터미널 UI(TUI)**를 제공하여, 에이전트 간의 실시간 토론 과정을 시각적으로 보여줍니다.
 
 ```
-  🧠 Trinity v0.7.1  —  세 개의 두뇌, 하나의 컨텍스트
+  🧠 Trinity v0.7.2  —  세 개의 두뇌, 하나의 컨텍스트
 
   🏗️ claude ✅    ⚙️ codex ✅    🔍 gemini ✅
 
@@ -200,9 +200,13 @@ Trinity는 **Rich 라이브러리 기반의 미려한 터미널 UI(TUI)**를 제
 | `/agent <이름> on\|off` | 특정 에이전트를 즉시 활성화하거나 비활성화 |
 | `/history` | 이전 라운드의 토론 히스토리 요약 조회 |
 | `/save` | 현재 토론 세션의 전체 결과를 파일로 영구 저장 |
+| `/resume [N\|latest\|ID]` | 저장된 workflow 세션을 선택해 재개 |
 | `/help` | 사용 가능한 인라인 명령어 도움말 표시 |
 | `/quit` | Trinity 종료 및 백그라운드 리소스 정리 |
 
+TUI는 기본적으로 새 workflow 세션으로 시작한다. 이전 active workflow는
+`.trinity/workflow/history/`에 보존되며 `/resume`으로 명시적으로 재개한다.
+
 ---
 
 ## ⚙️ 설정
@@ -380,8 +384,8 @@ uv publish --token <PYPI_TOKEN>
 
 | 지표 | 수치 |
 | :--- | :--- |
-| **버전** | 0.7.1 |
-| **테스트** | 909개 테스트 통과 |
+| **버전** | 0.7.2 |
+| **테스트** | 915개 테스트 통과 |
 | **커버리지** | 약 87% |
 | **소스 파일** | 50여 개 |
 | **주요 의존성 라이브러리** | `click`, `rich`, `prompt_toolkit`, `tomli` |

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/docs/checkpoint.md

@@ -35,8 +35,8 @@
 
 ### 검증 기준선
 
-- 패키지/CLI 버전: `0.7.1`
-- `uv run pytest -q` → 909 passed, 1 warning
+- 패키지/CLI 버전: `0.7.2`
+- `uv run pytest -q` → 915 passed, 1 warning
 - 변경 파일 대상 ruff check 통과
 - 실제 WSL/tmux/provider smoke는 릴리스 전 별도 수행 필요
 

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/docs/workflow-v0.7.0-guide.md

@@ -29,7 +29,7 @@ trinity
 
 새 목표를 입력하면 Trinity는 다음 순서로 진행한다.
 
-1. active agent와 workflow session을 만든다.
+1. 새 workflow session을 만든다. 이전 active workflow는 history로 보존된다.
 2. provider readiness를 확인한다.
 3. round 기반 deliberation을 실행한다.
 4. structured consensus가 나오면 blueprint를 저장한다.
@@ -47,6 +47,7 @@ trinity
 | `/decisions` | 사용자 또는 agent가 남긴 decision ledger를 표시한다. |
 | `/packages` | blueprint에서 생성된 work package와 실행 상태를 표시한다. |
 | `/subtasks` | parent agent가 보고한 provider-internal subtask/tool 사용 결과를 표시한다. |
+| `/resume [N\|latest\|ID]` | `.trinity/workflow/history/`에 저장된 workflow를 선택해 재개한다. |
 
 ## 4. Workflow State
 

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trinity-agent"
-version = "0.7.1"
+version = "0.7.2"
 description = "Three minds, one context — Multi-agent AI orchestrator for Claude Code, Codex, and Gemini CLI."
 readme = "README.md"
 requires-python = ">=3.10"

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/src/trinity/__init__.py

@@ -1,3 +1,3 @@
 """Trinity — Three minds, one context."""
 
-__version__ = "0.7.1"
+__version__ = "0.7.2"

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/src/trinity/tui/app.py

@@ -725,6 +725,7 @@ class TrinityTUI:
             "  [cyan]/decisions[/cyan]  — Show recorded workflow decisions\n"
             "  [cyan]/packages[/cyan]   — Show workflow work packages\n"
             "  [cyan]/subtasks[/cyan]   — Show delegated subtask reports\n"
+            "  [cyan]/resume [n|latest|id][/cyan] — Resume a saved workflow session\n"
             "  [cyan]/help[/cyan]       — Show this help\n"
             "  [cyan]/quit[/cyan]       — Exit Trinity\n"
         )

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/src/trinity/tui/prompt.py

@@ -15,7 +15,8 @@ from pathlib import Path
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
-from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.completion import Completer, Completion, CompleteEvent
+from prompt_toolkit.document import Document
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.input import DummyInput
 from prompt_toolkit.output import DummyOutput
@@ -44,6 +45,7 @@ TRINITY_COMMANDS = [
     "/decisions",
     "/packages",
     "/subtasks",
+    "/resume",
     "/help",
     "/quit",
 ]
@@ -55,6 +57,27 @@ TRINITY_STYLE = Style.from_dict({
 })
 
 
+class SlashCommandCompleter(Completer):
+    """Complete Trinity commands only when the input begins with slash."""
+
+    def __init__(self, commands: list[str]):
+        self.commands = commands
+
+    def get_completions(
+        self,
+        document: Document,
+        complete_event: CompleteEvent,
+    ):
+        text = document.text_before_cursor
+        if not text.startswith("/") or any(char.isspace() for char in text):
+            return
+
+        normalized = text.lower()
+        for command in self.commands:
+            if command.lower().startswith(normalized):
+                yield Completion(command, start_position=-len(text))
+
+
 class TrinityPromptSession:
     """prompt_toolkit-backed input session with history and completion.
 
@@ -78,7 +101,7 @@ class TrinityPromptSession:
             history=FileHistory(history_path) if history_path else None,
             auto_suggest=AutoSuggestFromHistory(),
             multiline=False,
-            completer=WordCompleter(TRINITY_COMMANDS, ignore_case=True),
+            completer=SlashCommandCompleter(TRINITY_COMMANDS),
             style=TRINITY_STYLE,
         )
         try:

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/src/trinity/tui/session.py

@@ -15,6 +15,7 @@ import json
 import logging
 import shlex
 import sys
+import time
 from typing import TYPE_CHECKING
 
 from rich.console import Console
@@ -32,6 +33,7 @@ from trinity.workflow import (
     ExecutionResult,
     WorkflowEngine,
     WorkflowInputAction,
+    WorkflowPersistence,
     WorkflowState,
 )
 
@@ -62,6 +64,8 @@ class InteractiveSession:
         self.running = False
         self._history_file = config.effective_state_dir / "history" / "session_history.json"
         self._prompt_session = TrinityPromptSession(config.effective_state_dir)
+        self.workflow_persistence = WorkflowPersistence(config.effective_state_dir)
+        self._startup_archive = self.workflow_persistence.archive_active_session()
         self.workflow = WorkflowEngine(config.effective_state_dir)
         self.tui.set_workflow_session(self.workflow.session)
 
@@ -97,6 +101,11 @@ class InteractiveSession:
     def _show_welcome(self) -> None:
         """Show welcome message."""
         self.console.print(self.tui.get_welcome_text())
+        if self._startup_archive:
+            self.console.print(
+                "[dim]Previous workflow saved to history. "
+                "Use /resume to restore it.[/dim]"
+            )
         self.console.print(
             "[dim]Type a question to start deliberation, or /help for commands.[/dim]\n"
         )
@@ -156,6 +165,8 @@ class InteractiveSession:
             self._cmd_packages()
         elif cmd == "subtasks":
             self._cmd_subtasks()
+        elif cmd == "resume":
+            self._cmd_resume(args)
         else:
             self.console.print(
                 f"[yellow]Unknown command: /{cmd}. "
@@ -542,6 +553,126 @@ class InteractiveSession:
 
         self.console.print(table)
 
+    def _cmd_resume(self, args: list[str]) -> None:
+        """Resume an archived workflow session.
+
+        Usage:
+            /resume
+            /resume latest
+            /resume <index|workflow-id>
+        """
+        archives = self.workflow_persistence.list_archives()
+        if not archives:
+            self.console.print("[dim]No saved workflow sessions to resume.[/dim]")
+            return
+
+        selector = args[0] if args else ""
+        if not selector:
+            if sys.stdin.isatty() and sys.stdout.isatty():
+                labels = [
+                    self._archive_label(archive)
+                    for archive in archives
+                ]
+                selected = self._prompt_session.select_option(
+                    title="Resume Workflow",
+                    question="Select a saved workflow session.",
+                    options=labels,
+                )
+                if selected is None:
+                    self.console.print("[dim]Resume cancelled.[/dim]")
+                    return
+                selector = selected
+            else:
+                self._print_resume_table(archives)
+                self.console.print("[dim]Usage: /resume <index|latest|workflow-id>[/dim]")
+                return
+
+        archive = self._resolve_archive(archives, selector)
+        if archive is None:
+            self.console.print(f"[yellow]No matching workflow session: {selector}[/yellow]")
+            return
+
+        archived_current = self.workflow_persistence.archive_active_session()
+        self.workflow_persistence.restore_archive(archive)
+        self.workflow = WorkflowEngine(self.config.effective_state_dir)
+        self.tui.set_workflow_session(self.workflow.session)
+
+        if archived_current:
+            self.console.print(
+                f"[dim]Current workflow saved as {archived_current.session.id}.[/dim]"
+            )
+        self.console.print(
+            f"[green]Resumed workflow {self.workflow.session.id}.[/green]"
+        )
+        self._cmd_workflow()
+
+    def _print_resume_table(self, archives) -> None:
+        """Print archived workflow sessions for manual selection."""
+        from rich.table import Table
+
+        table = Table(title="Saved Workflow Sessions")
+        table.add_column("#", justify="right", style="cyan")
+        table.add_column("ID")
+        table.add_column("State")
+        table.add_column("Updated")
+        table.add_column("Goal")
+
+        for index, archive in enumerate(archives, 1):
+            session = archive.session
+            table.add_row(
+                str(index),
+                session.id,
+                session.state.value,
+                self._format_timestamp(session.updated_at),
+                self._short_goal(session.goal),
+            )
+
+        self.console.print(table)
+
+    def _resolve_archive(self, archives, selector: str):
+        """Resolve a resume selector to one archive."""
+        normalized = selector.strip().lower()
+        if normalized in {"latest", "last", "newest"}:
+            return archives[0]
+        if normalized.isdigit():
+            index = int(normalized) - 1
+            if 0 <= index < len(archives):
+                return archives[index]
+            return None
+        return next(
+            (
+                archive
+                for archive in archives
+                if archive.session.id.lower() == normalized
+            ),
+            None,
+        )
+
+    def _archive_label(self, archive) -> str:
+        """Build a concise label for interactive resume selection."""
+        session = archive.session
+        return (
+            f"{session.id} · {session.state.value} · "
+            f"{self._format_timestamp(session.updated_at)} · "
+            f"{self._short_goal(session.goal)}"
+        )
+
+    @staticmethod
+    def _format_timestamp(timestamp: float) -> str:
+        """Format a persisted Unix timestamp for the resume list."""
+        try:
+            return time.strftime("%Y-%m-%d %H:%M", time.localtime(timestamp))
+        except (OSError, ValueError):
+            return "unknown"
+
+    @staticmethod
+    def _short_goal(goal: str, limit: int = 60) -> str:
+        """Return a compact single-line workflow goal."""
+        text = " ".join((goal or "(none)").split())
+        if len(text) <= limit:
+            return text
+        return text[: limit - 3] + "..."
+
     # ─── Deliberation ──────────────────────────────────────────────────
 
     def _handle_user_text(self, text: str) -> None:

trinity_agent-0.7.2/src/trinity/workflow/persistence.py

@@ -0,0 +1,207 @@
+"""Workflow session persistence for Trinity v0.7.0."""
+
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+import time
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from trinity.workflow.models import WorkflowSession
+from trinity.workflow.models import WorkflowState
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class WorkflowArchive:
+    """A saved workflow session available for explicit resume."""
+
+    session: WorkflowSession
+    path: Path
+    events_path: Path | None = None
+
+
+class WorkflowPersistence:
+    """Serialize workflow sessions and append-only event logs."""
+
+    def __init__(
+        self,
+        state_dir: Path,
+        *,
+        state_file: Path | None = None,
+        events_file: Path | None = None,
+    ) -> None:
+        workflow_dir = state_dir / "workflow"
+        self.session_path = state_file or workflow_dir / "session.json"
+        self.events_path = events_file or workflow_dir / "events.jsonl"
+
+    @property
+    def workflow_dir(self) -> Path:
+        """Return the directory containing workflow persistence files."""
+        return self.session_path.parent
+
+    @property
+    def history_dir(self) -> Path:
+        """Return the directory containing archived workflow sessions."""
+        return self.workflow_dir / "history"
+
+    def save(self, session: WorkflowSession) -> None:
+        """Write the session to disk as JSON."""
+        self.session_path.parent.mkdir(parents=True, exist_ok=True)
+        self.session_path.write_text(
+            json.dumps(session.to_dict(), indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        logger.debug("Workflow session saved: %s", session.id)
+
+    def load(self) -> WorkflowSession | None:
+        """Load a persisted session, returning None when unavailable or invalid."""
+        if not self.session_path.exists():
+            return None
+        try:
+            data = json.loads(self.session_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                return None
+            return WorkflowSession.from_dict(data)
+        except (json.JSONDecodeError, OSError, ValueError):
+            logger.exception("Failed to load workflow session from %s", self.session_path)
+            return None
+
+    def append_event(self, event: Mapping[str, Any]) -> None:
+        """Append one event dictionary to the JSONL event log."""
+        self.events_path.parent.mkdir(parents=True, exist_ok=True)
+        with self.events_path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(dict(event), ensure_ascii=False) + "\n")
+
+    def load_events(self) -> list[dict[str, Any]]:
+        """Read event dictionaries from the JSONL event log."""
+        if not self.events_path.exists():
+            return []
+
+        events: list[dict[str, Any]] = []
+        try:
+            with self.events_path.open("r", encoding="utf-8") as fh:
+                for line in fh:
+                    stripped = line.strip()
+                    if not stripped:
+                        continue
+                    event = json.loads(stripped)
+                    if isinstance(event, dict):
+                        events.append(event)
+        except (json.JSONDecodeError, OSError):
+            logger.exception("Failed to load workflow events from %s", self.events_path)
+        return events
+
+    def clear(self) -> None:
+        """Remove persisted workflow files."""
+        for path in (self.session_path, self.events_path):
+            if path.exists():
+                path.unlink()
+
+    def archive_active_session(self, *, force: bool = False) -> WorkflowArchive | None:
+        """Move the current active session into workflow history.
+
+        Returns the archive metadata, or None when there is no meaningful active
+        session to preserve.
+        """
+        session = self.load()
+        if session is None:
+            self.clear()
+            return None
+        if not force and not self._has_meaningful_session(session):
+            self.clear()
+            return None
+
+        self.history_dir.mkdir(parents=True, exist_ok=True)
+        timestamp = int(time.time() * 1000)
+        session_id = self._safe_name(session.id or "workflow")
+        archive_path = self.history_dir / f"{timestamp}-{session_id}.json"
+        archive_events_path = self.history_dir / f"{timestamp}-{session_id}.events.jsonl"
+
+        archive_path.write_text(
+            json.dumps(session.to_dict(), indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        events_path: Path | None = None
+        if self.events_path.exists():
+            shutil.copyfile(self.events_path, archive_events_path)
+            events_path = archive_events_path
+
+        self.clear()
+        return WorkflowArchive(session=session, path=archive_path, events_path=events_path)
+
+    def list_archives(self) -> list[WorkflowArchive]:
+        """Return archived workflow sessions, newest first."""
+        if not self.history_dir.exists():
+            return []
+
+        archives: list[WorkflowArchive] = []
+        for path in self.history_dir.glob("*.json"):
+            if path.name.endswith(".events.jsonl"):
+                continue
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+                if not isinstance(data, dict):
+                    continue
+                session = WorkflowSession.from_dict(data)
+            except (json.JSONDecodeError, OSError, ValueError):
+                logger.exception("Failed to load workflow archive from %s", path)
+                continue
+
+            events_path = path.with_suffix(".events.jsonl")
+            archives.append(
+                WorkflowArchive(
+                    session=session,
+                    path=path,
+                    events_path=events_path if events_path.exists() else None,
+                )
+            )
+
+        return sorted(
+            archives,
+            key=lambda archive: archive.session.updated_at,
+            reverse=True,
+        )
+
+    def restore_archive(self, archive: WorkflowArchive) -> WorkflowSession:
+        """Restore an archive into the active workflow files."""
+        self.session_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(archive.path, self.session_path)
+        if archive.events_path and archive.events_path.exists():
+            shutil.copyfile(archive.events_path, self.events_path)
+        elif self.events_path.exists():
+            self.events_path.unlink()
+        return archive.session
+
+    @staticmethod
+    def _has_meaningful_session(session: WorkflowSession) -> bool:
+        """Return whether a session should be preserved in history."""
+        return any(
+            (
+                bool(session.goal.strip()),
+                session.state != WorkflowState.IDLE,
+                bool(session.active_agents),
+                bool(session.pending_questions),
+                bool(session.decisions),
+                bool(session.work_packages),
+                bool(session.execution_results),
+                bool(session.subtask_results),
+                bool(session.review_packages),
+            )
+        )
+
+    @staticmethod
+    def _safe_name(value: str) -> str:
+        """Return a filesystem-safe identifier fragment."""
+        cleaned = []
+        for char in value:
+            if char.isalnum() or char in {"-", "_"}:
+                cleaned.append(char)
+            else:
+                cleaned.append("-")
+        return "".join(cleaned).strip("-") or "workflow"

{trinity_agent-0.7.1 → trinity_agent-0.7.2}/tests/test_tui_prompt.py

@@ -2,6 +2,9 @@
 
 from unittest.mock import MagicMock, patch
 
+from prompt_toolkit.completion import CompleteEvent
+from prompt_toolkit.document import Document
+
 from trinity.tui.prompt import TRINITY_COMMANDS, TrinityPromptSession
 
 
@@ -46,6 +49,7 @@ class TestCommandCompletion:
             "/decisions",
             "/packages",
             "/subtasks",
+            "/resume",
             "/help",
             "/quit",
         }
@@ -56,6 +60,25 @@ class TestCommandCompletion:
         session = TrinityPromptSession(tmp_path)
         assert session.session.completer is not None
 
+    def test_completion_only_appears_for_slash_prefix(self, tmp_path):
+        session = TrinityPromptSession(tmp_path)
+        completer = session.session.completer
+
+        assert completer is not None
+        slash_matches = list(
+            completer.get_completions(Document("/sta"), CompleteEvent())
+        )
+        space_matches = list(
+            completer.get_completions(Document(" "), CompleteEvent())
+        )
+        text_matches = list(
+            completer.get_completions(Document("hello /sta"), CompleteEvent())
+        )
+
+        assert any(match.text == "/status" for match in slash_matches)
+        assert space_matches == []
+        assert text_matches == []
+
 
 class TestGetInput:
     """get_input delegates to prompt_toolkit."""