everalgo-boundary 0.1.0__tar.gz

everalgo_boundary-0.1.0/.gitignore

@@ -0,0 +1,58 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+wheels/
+
+# Environments
+.env
+.env.local
+.venv
+env/
+venv/
+
+# uv
+.uv/
+
+# Test / coverage / cache
+.pytest_cache/
+.cache
+.coverage
+.coverage.*
+coverage.xml
+report.xml
+htmlcov/
+.tox/
+.nox/
+.hypothesis/
+
+# Type checkers / linters
+.mypy_cache/
+.dmypy.json
+.pyre/
+.pytype/
+.ruff_cache/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# IDE / OS
+.vscode/
+.idea/
+*.swp
+.DS_Store
+
+# Logs
+*.log
+
+# Project local artifacts (placed under local/ per project convention)
+local/
+
+# Claude Code session-local state (scheduled tasks, agent caches, locks)
+.claude/

everalgo_boundary-0.1.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this package are documented here. Format follows
+[Keep a Changelog 1.1.0](https://keepachangelog.com/en/1.1.0/). Versioning
+follows [Semantic Versioning 2.0](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- `detect_boundaries(messages, *, llm, tail) -> DetectionResult`: async public entry point that splits a `list[ChatMessage]` into `MemCell` slices using a single LLM call; no retry.
+- `DetectionResult` `NamedTuple`: `(cells: list[MemCell], tail: list[ChatMessage])` where `tail` is the unconsumed carry-forward window.
+- `WorkspaceMemCellExtractor`: stub extractor for Jira / Email / Confluence inputs (EXPERIMENTAL; implementation pending).
+- `count_tokens(text: str) -> int`: token count using OpenAI `o200k_base` encoding via `tiktoken`.
+- `force_split(text: str, *, max_tokens: int) -> list[str]`: token-bounded chunking for caller-side prompt fitting.
+- English and Chinese boundary detection prompts under `boundary/prompts/{en,zh}/`.
+- `BoundaryDetector` (in `everalgo-user-memory`) and `AgentBoundaryDetector` (in `everalgo-agent-memory`) are the facade classes; `detect_boundaries` is this package's low-level public primitive.
+- 81 unit tests across `test_chat.py` (boundary logic), `test_boundary_public_api.py` (public contract), and `test_tokenize.py` (token helpers).
+
+### Removed
+
+- 5-retry loop in the internal `_detect_boundaries` helper: the function now raises `ValueError` immediately on malformed LLM JSON instead of silently retrying.
+
+[Unreleased]: https://github.com/EverMind-AI/EverAlgo/compare/main...HEAD

everalgo_boundary-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EverMind
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

everalgo_boundary-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: everalgo-boundary
+Version: 0.1.0
+Summary: EverAlgo boundary: MemCell extractors (chat / workspace / agent).
+Project-URL: Homepage, https://github.com/EverMind-AI/EverAlgo
+Project-URL: Repository, https://github.com/EverMind-AI/EverAlgo
+Project-URL: Issues, https://github.com/EverMind-AI/EverAlgo/issues
+Project-URL: Documentation, https://github.com/EverMind-AI/EverAlgo/tree/main/packages/everalgo-boundary
+Project-URL: Changelog, https://github.com/EverMind-AI/EverAlgo/blob/main/packages/everalgo-boundary/CHANGELOG.md
+Author: EverMind
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: asgiref>=3.0
+Requires-Dist: everalgo-core<2.0.0,>=0.1.0
+Description-Content-Type: text/markdown
+
+# everalgo-boundary
+
+Chat boundary detection for EverAlgo — segments a flat list of `ChatMessage` objects into coherent `MemCell` slices using an LLM-based batch algorithm.
+
+See the umbrella project: [EverAlgo monorepo](../../README.md) and the architecture document at [`docs/concepts/architecture.md`](../../docs/concepts/architecture.md).
+
+## Install
+
+```bash
+pip install everalgo-boundary
+```
+
+For the user-scenario class facade, install [`everalgo-user-memory`](../everalgo-user-memory/) instead — it re-exports `BoundaryDetector` which wraps this package.
+
+## What this distribution provides
+
+| Symbol | Role |
+|---|---|
+| `detect_boundaries` | Low-level async function: `(list[ChatMessage], *, llm, is_final, ...) → DetectionResult` |
+| `DetectionResult` | `NamedTuple(cells: list[MemCell], tail: list[ChatMessage])` |
+| `WorkspaceMemCellExtractor` | Placeholder stub for Jira / Email / Confluence (raises `NotImplementedError`) |
+
+The class-style facades (`BoundaryDetector` for user-scenario chat, `AgentBoundaryDetector` for agent trajectories with tool calls) live in [`everalgo-user-memory`](../everalgo-user-memory/) and [`everalgo-agent-memory`](../everalgo-agent-memory/) respectively.
+
+## Quick start
+
+```python
+import asyncio
+import json
+
+from everalgo.boundary import detect_boundaries
+from everalgo.llm.types import ChatMessage as LLMChatMessage, ChatResponse
+from everalgo.testing.fake_llm import FakeLLMClient
+from everalgo.types import ChatMessage
+
+_BOUNDARY_JSON = json.dumps(
+    {"reasoning": "single topic", "boundaries": [], "should_wait": False}
+)
+
+async def main() -> None:
+    fake = FakeLLMClient(responses=[ChatResponse(content=_BOUNDARY_JSON, model="fake")])
+    messages = [
+        ChatMessage(id="m1", role="user",   content="Let's talk about deployment.",     timestamp=1_700_000_000_000, sender_id="u_alice"),
+        ChatMessage(id="m2", role="assistant", content="Sure — what's the target env?",  timestamp=1_700_000_001_000, sender_id="assistant"),
+        ChatMessage(id="m3", role="user",   content="K8s. Switching topic: lunch?",     timestamp=1_700_000_002_000, sender_id="u_alice"),
+    ]
+
+    # Streaming: hold `tail` between calls; pass prior tail + new messages each time.
+    result = await detect_boundaries(messages, llm=fake)
+    cells, tail = result  # NamedTuple unpacking
+
+    # End-of-session: tail is forced into the last cell.
+    result = await detect_boundaries(messages, llm=fake, is_final=True)
+    assert result.tail == []
+    for mc in result.cells:
+        print(mc.timestamp, len(mc.items))
+
+
+asyncio.run(main())
+```
+
+## The streaming state machine
+
+`detect_boundaries` deliberately holds back trailing messages as `tail` — the LLM cannot know whether a conversation continues beyond the last seen message. The caller maintains state:
+
+```python
+tail: list[ChatMessage] = []
+
+for batch in incoming_batches:
+    result = await detect_boundaries(tail + batch, llm=client)
+    await persist(result.cells)
+    tail = result.tail
+
+# Session ends — flush everything.
+final = await detect_boundaries(tail, llm=client, is_final=True)
+await persist(final.cells)
+```
+
+## Tokenizer utilities
+
+`everalgo._tokenize` (in `everalgo-core`) exposes two module-private utilities used by boundary algorithms; not part of the public surface:
+
+- `count_tokens(text: str) → int` — token count under OpenAI `o200k_base` encoding via [`tiktoken`](https://github.com/openai/tiktoken).
+- `force_split(text: str, *, max_tokens: int) → list[str]` — last-resort token-bounded chunking; no semantic awareness.
+
+## Stubs
+
+`WorkspaceMemCellExtractor` (Jira / Email / Confluence) is a placeholder in `v0.x` — all methods raise `NotImplementedError`. Implementation lands in a future minor bump when the `RawData` contract is finalised.
+
+## Related distributions
+
+- [`everalgo-user-memory`](../everalgo-user-memory/) — `BoundaryDetector` class facade for chat scenarios
+- [`everalgo-agent-memory`](../everalgo-agent-memory/) — `AgentBoundaryDetector` class facade for agent trajectories

everalgo_boundary-0.1.0/README.md

@@ -0,0 +1,93 @@
+# everalgo-boundary
+
+Chat boundary detection for EverAlgo — segments a flat list of `ChatMessage` objects into coherent `MemCell` slices using an LLM-based batch algorithm.
+
+See the umbrella project: [EverAlgo monorepo](../../README.md) and the architecture document at [`docs/concepts/architecture.md`](../../docs/concepts/architecture.md).
+
+## Install
+
+```bash
+pip install everalgo-boundary
+```
+
+For the user-scenario class facade, install [`everalgo-user-memory`](../everalgo-user-memory/) instead — it re-exports `BoundaryDetector` which wraps this package.
+
+## What this distribution provides
+
+| Symbol | Role |
+|---|---|
+| `detect_boundaries` | Low-level async function: `(list[ChatMessage], *, llm, is_final, ...) → DetectionResult` |
+| `DetectionResult` | `NamedTuple(cells: list[MemCell], tail: list[ChatMessage])` |
+| `WorkspaceMemCellExtractor` | Placeholder stub for Jira / Email / Confluence (raises `NotImplementedError`) |
+
+The class-style facades (`BoundaryDetector` for user-scenario chat, `AgentBoundaryDetector` for agent trajectories with tool calls) live in [`everalgo-user-memory`](../everalgo-user-memory/) and [`everalgo-agent-memory`](../everalgo-agent-memory/) respectively.
+
+## Quick start
+
+```python
+import asyncio
+import json
+
+from everalgo.boundary import detect_boundaries
+from everalgo.llm.types import ChatMessage as LLMChatMessage, ChatResponse
+from everalgo.testing.fake_llm import FakeLLMClient
+from everalgo.types import ChatMessage
+
+_BOUNDARY_JSON = json.dumps(
+    {"reasoning": "single topic", "boundaries": [], "should_wait": False}
+)
+
+async def main() -> None:
+    fake = FakeLLMClient(responses=[ChatResponse(content=_BOUNDARY_JSON, model="fake")])
+    messages = [
+        ChatMessage(id="m1", role="user",   content="Let's talk about deployment.",     timestamp=1_700_000_000_000, sender_id="u_alice"),
+        ChatMessage(id="m2", role="assistant", content="Sure — what's the target env?",  timestamp=1_700_000_001_000, sender_id="assistant"),
+        ChatMessage(id="m3", role="user",   content="K8s. Switching topic: lunch?",     timestamp=1_700_000_002_000, sender_id="u_alice"),
+    ]
+
+    # Streaming: hold `tail` between calls; pass prior tail + new messages each time.
+    result = await detect_boundaries(messages, llm=fake)
+    cells, tail = result  # NamedTuple unpacking
+
+    # End-of-session: tail is forced into the last cell.
+    result = await detect_boundaries(messages, llm=fake, is_final=True)
+    assert result.tail == []
+    for mc in result.cells:
+        print(mc.timestamp, len(mc.items))
+
+
+asyncio.run(main())
+```
+
+## The streaming state machine
+
+`detect_boundaries` deliberately holds back trailing messages as `tail` — the LLM cannot know whether a conversation continues beyond the last seen message. The caller maintains state:
+
+```python
+tail: list[ChatMessage] = []
+
+for batch in incoming_batches:
+    result = await detect_boundaries(tail + batch, llm=client)
+    await persist(result.cells)
+    tail = result.tail
+
+# Session ends — flush everything.
+final = await detect_boundaries(tail, llm=client, is_final=True)
+await persist(final.cells)
+```
+
+## Tokenizer utilities
+
+`everalgo._tokenize` (in `everalgo-core`) exposes two module-private utilities used by boundary algorithms; not part of the public surface:
+
+- `count_tokens(text: str) → int` — token count under OpenAI `o200k_base` encoding via [`tiktoken`](https://github.com/openai/tiktoken).
+- `force_split(text: str, *, max_tokens: int) → list[str]` — last-resort token-bounded chunking; no semantic awareness.
+
+## Stubs
+
+`WorkspaceMemCellExtractor` (Jira / Email / Confluence) is a placeholder in `v0.x` — all methods raise `NotImplementedError`. Implementation lands in a future minor bump when the `RawData` contract is finalised.
+
+## Related distributions
+
+- [`everalgo-user-memory`](../everalgo-user-memory/) — `BoundaryDetector` class facade for chat scenarios
+- [`everalgo-agent-memory`](../everalgo-agent-memory/) — `AgentBoundaryDetector` class facade for agent trajectories

everalgo_boundary-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "everalgo-boundary"
+version = "0.1.0"
+description = "EverAlgo boundary: MemCell extractors (chat / workspace / agent)."
+requires-python = ">=3.12"
+license = "MIT"
+readme = "README.md"
+authors = [{ name = "EverMind" }]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.12",
+]
+# Loose lower bound + cross-major upper bound, mirroring HuggingFace `transformers`
+# pin on `huggingface-hub`. See AGENTS.md §6 (Branching & Commits) for version strategy.
+dependencies = [
+  "asgiref>=3.0",
+  "everalgo-core>=0.1.0,<2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/EverMind-AI/EverAlgo"
+Repository = "https://github.com/EverMind-AI/EverAlgo"
+Issues = "https://github.com/EverMind-AI/EverAlgo/issues"
+Documentation = "https://github.com/EverMind-AI/EverAlgo/tree/main/packages/everalgo-boundary"
+Changelog = "https://github.com/EverMind-AI/EverAlgo/blob/main/packages/everalgo-boundary/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/everalgo"]

everalgo_boundary-0.1.0/src/everalgo/boundary/__init__.py

@@ -0,0 +1,24 @@
+"""Boundary detection — chat MemCell primitive.
+
+Public surface:
+- detect_boundaries — async function: split chat messages into MemCells
+- DetectionResult    — ``(cells, tail)`` NamedTuple returned by detect_boundaries
+- WorkspaceMemCellExtractor — Jira / Email / Confluence stub (unchanged)
+
+Facade classes (BoundaryDetector / AgentBoundaryDetector) live in everalgo-user-memory and
+everalgo-agent-memory respectively; see Stage 3-4 of the refactor.
+"""
+
+import logging
+
+from everalgo.boundary.chat import DetectionResult, detect_boundaries
+from everalgo.boundary.workspace import WorkspaceMemCellExtractor
+
+__all__ = [
+    "DetectionResult",
+    "WorkspaceMemCellExtractor",
+    "detect_boundaries",
+]
+
+# Library logging setup (ADR-013): NullHandler on each subpackage logger.
+logging.getLogger(__name__).addHandler(logging.NullHandler())

everalgo_boundary-0.1.0/src/everalgo/boundary/chat.py

@@ -0,0 +1,221 @@
+"""Low-level chat boundary detection primitive — splits a flat list of ChatMessages into MemCell slices.
+
+Facade classes for the two upstream scenarios live in ``everalgo-user-memory`` (``BoundaryDetector``)
+and ``everalgo-agent-memory`` (``AgentBoundaryDetector``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, NamedTuple, cast
+
+from everalgo._tokenize import count_tokens
+from everalgo.boundary.prompts.en.chat import CHAT_BOUNDARY_DETECT_PROMPT_EN
+from everalgo.llm.format import format_message_timestamp
+from everalgo.llm.parse import parse_llm_json_object
+from everalgo.llm.types import ChatMessage as LLMChatMessage
+from everalgo.prompts import render_prompt
+from everalgo.types import ChatMessage, ConversationItem, MemCell
+
+if TYPE_CHECKING:
+    from everalgo.llm.protocols import LLMClient
+
+
+DEFAULT_HARD_TOKEN_LIMIT = 65536
+DEFAULT_HARD_MSG_LIMIT = 500
+
+
+@dataclass(frozen=True)
+class _BatchBoundaryResult:
+    """Parsed LLM batch response."""
+
+    boundaries: list[int]
+    should_wait: bool
+
+
+class DetectionResult(NamedTuple):
+    """Return type of :func:`detect_boundaries`.
+
+    NamedTuple subclass of ``tuple`` — supports positional unpacking, named access, and index access::
+
+        cells, tail = await detect_boundaries(messages, llm=client)
+        result = await detect_boundaries(messages, llm=client)
+        result.cells  # list[MemCell]
+        result.tail  # list[ChatMessage]
+        result[0], result[1]
+
+    Attributes:
+        cells: Zero or more :class:`~everalgo.types.MemCell` instances the algorithm has confidently
+            closed.  Caller persists immediately.
+        tail: Trailing messages the algorithm did NOT close — the LLM cannot judge whether the
+            conversation continues beyond the last seen message, so the trailing segment is left as a
+            tail for the caller's state machine.  When ``is_final=True``, tail is forced into the final
+            MemCell and this field is guaranteed empty.
+    """
+
+    cells: list[MemCell]
+    tail: list[ChatMessage]
+
+
+async def detect_boundaries(
+    messages: list[ChatMessage],
+    *,
+    llm: LLMClient,
+    is_final: bool = False,
+    prompt: str | None = None,
+    hard_token_limit: int = DEFAULT_HARD_TOKEN_LIMIT,
+    hard_msg_limit: int = DEFAULT_HARD_MSG_LIMIT,
+) -> DetectionResult:
+    """Detect MemCell boundaries on a list of ChatMessages (chat-only path).
+
+    Args:
+        messages: Ordered chat messages, typically ``prior_tail + new_messages``.
+        llm: LLM client. Algorithm always requires an LLM; the caller must supply one.
+        is_final: When ``True``, forces the trailing segment into a cell so ``tail == []``.
+        prompt: Prompt override; ``None`` uses the bundled default.
+        hard_token_limit: Max tokens per cell before forced split.
+        hard_msg_limit: Max messages per cell before forced split.
+
+    Raises:
+        ValueError: If the LLM response cannot be parsed as a valid JSON object.
+        TypeError: If the ``boundaries`` field in the LLM response is not a list.
+        LLMError: Propagated from the underlying LLM client call.
+    """
+    # Phase 1 — Input validation
+    if not messages:
+        return DetectionResult(cells=[], tail=[])
+
+    # Phase 2 — Default resolution
+    prompt_template = prompt or CHAT_BOUNDARY_DETECT_PROMPT_EN
+
+    # Phase 3 — Force-split loop
+    cells: list[MemCell] = []
+    remaining: list[ChatMessage] = list(messages)
+    while len(remaining) > 1:
+        total_tokens = count_tokens(_render_for_token_count(remaining))
+        total_msgs = len(remaining)
+        if total_tokens < hard_token_limit and total_msgs < hard_msg_limit:
+            break
+        split_at = _find_force_split_point(remaining, hard_token_limit, hard_msg_limit)
+        cells.append(_make_cell(remaining[:split_at]))
+        remaining = remaining[split_at:]
+
+    # Phase 4 — LLM batch detection (single call, multi-boundary).
+    boundaries: list[int] = []
+    if remaining:
+        batch = await _detect_boundaries(remaining, llm, prompt_template)
+        boundaries = batch.boundaries
+
+    # Phase 5 — Slice by boundaries + is_final closure.
+    prev = 0
+    for b in boundaries:
+        segment = remaining[prev:b]
+        if segment:
+            cells.append(_make_cell(segment))
+        prev = b
+    tail_msgs = remaining[prev:]
+
+    if is_final and tail_msgs:
+        cells.append(_make_cell(tail_msgs))
+        tail: list[ChatMessage] = []
+    else:
+        tail = tail_msgs
+
+    return DetectionResult(cells=cells, tail=tail)
+
+
+# ---------- Module-level helpers (stateless, prefix `_`) ----------
+
+
+def _render_for_token_count(messages: list[ChatMessage]) -> str:
+    """Render messages as ``"{sender}: {content}"`` lines for token counting.
+
+    Includes the sender prefix so the count reflects the actual prompt budget.
+    """
+    lines: list[str] = []
+    for m in messages:
+        speaker = m.sender_name or m.sender_id
+        content = (
+            m.content
+            if isinstance(m.content, str)
+            else " ".join(block.text for block in m.content if hasattr(block, "text"))
+        )
+        lines.append(f"{speaker}: {content}")
+    return "\n".join(lines)
+
+
+def _format_messages_with_indices(messages: list[ChatMessage]) -> str:
+    """Render messages as ``[N] [ISO+TZ] sender_name: content`` lines (1-based N). Empty-content messages are dropped."""
+    lines: list[str] = []
+    for i, msg in enumerate(messages, start=1):
+        content = (
+            msg.content
+            if isinstance(msg.content, str)
+            else " ".join(block.text for block in msg.content if hasattr(block, "text"))
+        )
+        if not content:
+            continue
+        sender_name = msg.sender_name or msg.sender_id
+        time_str = format_message_timestamp(msg.timestamp)
+        lines.append(f"[{i}] [{time_str}] {sender_name}: {content}")
+    return "\n".join(lines)
+
+
+def _find_force_split_point(messages: list[ChatMessage], hard_token_limit: int, hard_msg_limit: int) -> int:
+    """Binary-halving search for a force-split index; floor 1 so even a single very-long message is accepted."""
+    if len(messages) <= 1:
+        return len(messages)
+    candidate = min(hard_msg_limit - 1, len(messages) - 1)
+    while candidate > 1 and count_tokens(_render_for_token_count(messages[:candidate])) >= hard_token_limit:
+        candidate = max(1, candidate // 2)
+    return candidate
+
+
+async def _detect_boundaries(
+    messages: list[ChatMessage],
+    llm: LLMClient,
+    prompt_template: str,
+) -> _BatchBoundaryResult:
+    """Call the LLM once; return parsed boundaries.
+
+    Boundary indices validated to ``1 <= b < len(messages)`` and deduplicated.
+
+    Raises:
+        ValueError: If the LLM response cannot be parsed as a valid JSON object.
+        TypeError: If the ``boundaries`` field is not a list.
+    """
+    messages_text = _format_messages_with_indices(messages)
+    rendered = render_prompt(prompt_template, None, messages=messages_text)
+
+    response = await llm.chat(
+        messages=[LLMChatMessage(role="user", content=rendered)],
+        response_format={"type": "json_object"},
+    )
+    result = _parse_batch_boundary_response(response.content)
+    valid = sorted({b for b in result.boundaries if 1 <= b < len(messages)})
+    return _BatchBoundaryResult(boundaries=valid, should_wait=result.should_wait)
+
+
+def _parse_batch_boundary_response(raw: str) -> _BatchBoundaryResult:
+    """Parse LLM batch-boundary response.
+
+    Schema: ``{"boundaries": list[int], "should_wait": bool, ...}``.
+    Non-int boundary entries are silently skipped.
+
+    Raises:
+        ValueError: If the response cannot be parsed as a valid JSON object.
+        TypeError: If ``boundaries`` is not a list.
+    """
+    data = parse_llm_json_object(raw)
+
+    raw_boundaries_val = data.get("boundaries", [])
+    if not isinstance(raw_boundaries_val, list):
+        raise TypeError("LLM boundary response 'boundaries' field is not a list")
+    boundaries: list[int] = [int(item) for item in cast("list[int | str]", raw_boundaries_val)]
+
+    return _BatchBoundaryResult(boundaries=boundaries, should_wait=bool(data.get("should_wait", False)))
+
+
+def _make_cell(slice_msgs: list[ChatMessage]) -> MemCell:
+    """Build a MemCell from a non-empty message slice."""
+    return MemCell(items=cast("list[ConversationItem]", slice_msgs), timestamp=slice_msgs[-1].timestamp)

everalgo_boundary-0.1.0/src/everalgo/boundary/prompts/__init__.py

@@ -0,0 +1,6 @@
+"""Boundary extractor prompts (en + zh).
+
+Each prompt is a module-level Python string constant per AGENTS.md §5 (Code Style) (no external .md / .yaml /
+.toml prompt stores). Algorithm authors customize via per-call ``prompt=`` argument or by
+monkey-patching the constant at startup.
+"""

everalgo_boundary-0.1.0/src/everalgo/boundary/prompts/en/__init__.py

@@ -0,0 +1 @@
+"""English boundary extractor prompts."""