coderouter-cli 2.6.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

coderouter/state/audit_log.py

@@ -41,11 +41,22 @@ lines (no partial-line interleaving) because Python's stdlib file
 
 from __future__ import annotations
 
+import atexit
+import contextlib
 import json
 import logging
+import time
 from datetime import UTC, datetime
 from pathlib import Path
 
+# M12(2) buffering defaults. Audit lines are lower-volume than request
+# journal lines, but still fsync'd once per event pre-M12. We buffer and
+# flush on whichever comes first — a count threshold or a wall-clock
+# interval — with an unconditional flush on close()/atexit so no
+# audit-worthy event is lost on clean shutdown.
+_DEFAULT_FLUSH_EVERY_N: int = 20
+_DEFAULT_FLUSH_INTERVAL_S: float = 2.0
+
 # Events that are audit-worthy: guard state changes, chain decisions,
 # cost/budget, self-healing lifecycle, drift, probing milestones.
 _AUDIT_EVENTS: frozenset[str] = frozenset(
@@ -106,38 +117,89 @@ class AuditLogHandler(logging.Handler):
         log_path: str | Path,
         *,
         max_bytes: int = 10_485_760,
+        flush_every_n: int = _DEFAULT_FLUSH_EVERY_N,
+        flush_interval_s: float = _DEFAULT_FLUSH_INTERVAL_S,
     ) -> None:
         super().__init__(level=logging.DEBUG)
         self._log_path = Path(log_path)
         self._max_bytes = max_bytes
+        self._flush_every_n = max(1, flush_every_n)
+        self._flush_interval_s = flush_interval_s
+        self._buffer: list[str] = []
+        self._last_flush_monotonic = time.monotonic()
         self._log_path.parent.mkdir(parents=True, exist_ok=True)
         self._file = open(self._log_path, "a", encoding="utf-8")  # noqa: SIM115
+        # Guarantee a final flush even if close() is never called
+        # explicitly (e.g. an ungraceful lifespan teardown).
+        atexit.register(self._atexit_flush)
 
     def emit(self, record: logging.LogRecord) -> None:
-        """Write an audit line if the event is audit-worthy."""
+        """Buffer an audit line if the event is audit-worthy; flush lazily.
+
+        Write buffering (M12(2)): lines are flushed when either
+        ``flush_every_n`` lines have accumulated or ``flush_interval_s``
+        seconds have elapsed since the last flush. :meth:`close`
+        (registered with :mod:`atexit`) always flushes so a clean
+        shutdown never drops a buffered audit line. Pass
+        ``flush_every_n=1`` for the pre-M12 write-through behavior.
+        """
         if record.msg not in _AUDIT_EVENTS:
             return
         try:
             self.acquire()
             try:
-                line = self._format_line(record)
-                self._file.write(line)
-                self._file.flush()
-                self._maybe_rotate()
+                self._buffer.append(self._format_line(record))
+                if self._should_flush():
+                    self._flush_buffer()
             finally:
                 self.release()
         except Exception:
             self.handleError(record)
 
+    def _should_flush(self) -> bool:
+        """True when the count threshold or time interval has been reached."""
+        if len(self._buffer) >= self._flush_every_n:
+            return True
+        return (
+            time.monotonic() - self._last_flush_monotonic
+        ) >= self._flush_interval_s
+
+    def _flush_buffer(self) -> None:
+        """Write all buffered lines to disk, fsync, and maybe rotate.
+
+        Caller must hold the handler lock. No-op when the buffer is empty.
+        """
+        if not self._buffer:
+            return
+        self._file.write("".join(self._buffer))
+        self._buffer.clear()
+        self._file.flush()
+        self._last_flush_monotonic = time.monotonic()
+        self._maybe_rotate()
+
+    def _atexit_flush(self) -> None:
+        """Best-effort flush of any buffered lines at interpreter exit."""
+        try:
+            self.acquire()
+            try:
+                if self._file and not self._file.closed:
+                    self._flush_buffer()
+            finally:
+                self.release()
+        except Exception:  # pragma: no cover - defensive at shutdown
+            pass
+
     def close(self) -> None:
-        """Flush and close the underlying file."""
+        """Flush buffered lines and close the underlying file."""
         self.acquire()
         try:
             if self._file and not self._file.closed:
-                self._file.flush()
+                self._flush_buffer()
                 self._file.close()
         finally:
             self.release()
+        with contextlib.suppress(Exception):
+            atexit.unregister(self._atexit_flush)
         super().close()
 
     # ------------------------------------------------------------------

coderouter/state/request_log.py

@@ -30,14 +30,25 @@ active file exceeds ``max_bytes``, rename to ``.1`` and start fresh.
 
 from __future__ import annotations
 
+import atexit
+import contextlib
 import json
 import logging
+import time
 from datetime import UTC, datetime
 from pathlib import Path
 
 # Events to capture for the request journal.
 _JOURNAL_EVENTS: frozenset[str] = frozenset({"cache-observed"})
 
+# M12(2) buffering defaults. A request journal line is written per
+# successful request; fsync-on-every-write is wasteful under load. We
+# buffer in-process and flush on whichever comes first — a count
+# threshold or a wall-clock interval — plus an unconditional flush on
+# close()/atexit so no completed request is ever lost on clean shutdown.
+_DEFAULT_FLUSH_EVERY_N: int = 20
+_DEFAULT_FLUSH_INTERVAL_S: float = 2.0
+
 
 class RequestLogHandler(logging.Handler):
     """Append-only JSONL handler for request metadata.
@@ -45,6 +56,15 @@ class RequestLogHandler(logging.Handler):
     Each line records one successful request's metadata (provider,
     tokens, cost, streaming flag).  Failed requests are not recorded
     — only requests that produced a response.
+
+    Write buffering (M12(2))
+        Lines are buffered and flushed to disk when either
+        ``flush_every_n`` lines have accumulated or ``flush_interval_s``
+        seconds have elapsed since the last flush — whichever comes
+        first. :meth:`close` (registered with :mod:`atexit`) always
+        flushes, so a clean shutdown never drops a buffered line. Pass
+        ``flush_every_n=1`` for the pre-M12 write-through behavior (tests
+        that assert immediate on-disk visibility use this).
     """
 
     def __init__(
@@ -52,38 +72,81 @@ class RequestLogHandler(logging.Handler):
         log_path: str | Path,
         *,
         max_bytes: int = 52_428_800,  # 50 MiB default
+        flush_every_n: int = _DEFAULT_FLUSH_EVERY_N,
+        flush_interval_s: float = _DEFAULT_FLUSH_INTERVAL_S,
     ) -> None:
         super().__init__(level=logging.DEBUG)
         self._log_path = Path(log_path)
         self._max_bytes = max_bytes
+        self._flush_every_n = max(1, flush_every_n)
+        self._flush_interval_s = flush_interval_s
+        self._buffer: list[str] = []
+        self._last_flush_monotonic = time.monotonic()
         self._log_path.parent.mkdir(parents=True, exist_ok=True)
         self._file = open(self._log_path, "a", encoding="utf-8")  # noqa: SIM115
+        # Guarantee a final flush even if close() is never called
+        # explicitly (e.g. an ungraceful lifespan teardown).
+        atexit.register(self._atexit_flush)
 
     def emit(self, record: logging.LogRecord) -> None:
-        """Write a journal line for cache-observed events."""
+        """Buffer a journal line for cache-observed events; flush lazily."""
         if record.msg not in _JOURNAL_EVENTS:
             return
         try:
             self.acquire()
             try:
-                line = self._format_line(record)
-                self._file.write(line)
-                self._file.flush()
-                self._maybe_rotate()
+                self._buffer.append(self._format_line(record))
+                if self._should_flush():
+                    self._flush_buffer()
             finally:
                 self.release()
         except Exception:
             self.handleError(record)
 
+    def _should_flush(self) -> bool:
+        """True when the count threshold or time interval has been reached."""
+        if len(self._buffer) >= self._flush_every_n:
+            return True
+        return (
+            time.monotonic() - self._last_flush_monotonic
+        ) >= self._flush_interval_s
+
+    def _flush_buffer(self) -> None:
+        """Write all buffered lines to disk, fsync, and maybe rotate.
+
+        Caller must hold the handler lock. No-op when the buffer is empty.
+        """
+        if not self._buffer:
+            return
+        self._file.write("".join(self._buffer))
+        self._buffer.clear()
+        self._file.flush()
+        self._last_flush_monotonic = time.monotonic()
+        self._maybe_rotate()
+
+    def _atexit_flush(self) -> None:
+        """Best-effort flush of any buffered lines at interpreter exit."""
+        try:
+            self.acquire()
+            try:
+                if self._file and not self._file.closed:
+                    self._flush_buffer()
+            finally:
+                self.release()
+        except Exception:  # pragma: no cover - defensive at shutdown
+            pass
+
     def close(self) -> None:
-        """Flush and close the underlying file."""
+        """Flush buffered lines and close the underlying file."""
         self.acquire()
         try:
             if self._file and not self._file.closed:
-                self._file.flush()
+                self._flush_buffer()
                 self._file.close()
         finally:
             self.release()
+        with contextlib.suppress(Exception):
+            atexit.unregister(self._atexit_flush)
         super().close()
 
     # ------------------------------------------------------------------

coderouter/translation/convert.py

@@ -44,6 +44,14 @@ from coderouter.translation.tool_repair import repair_tool_calls_in_text
 # ============================================================
 
 
+# OpenAI's role=tool message has no structured error flag, so a failed
+# tool_result is conventionally surfaced by prefixing the content with an
+# "Error: " marker. We add it on the Anthropic→OpenAI leg when is_error is
+# true and detect it on the reverse leg to restore is_error, so a round-trip
+# preserves the flag without double-prefixing.
+_TOOL_ERROR_MARKER = "Error: "
+
+
 def _system_as_text(system: str | list[dict[str, Any]] | None) -> str | None:
     """Anthropic's `system` can be a string or a list of content blocks.
 
@@ -142,11 +150,20 @@ def _convert_anthropic_message(
         elif btype == "tool_use":
             tool_calls.append(_tool_use_to_openai_tool_call(block))
         elif btype == "tool_result":
+            result_str = _tool_result_content_to_str(block.get("content"))
+            # Preserve Anthropic's is_error flag: OpenAI's role=tool message
+            # has no structured error field, so mark failures with an
+            # "Error: " prefix (skip if already prefixed to avoid doubling on
+            # a round-trip) (M8).
+            if block.get("is_error") and not result_str.startswith(
+                _TOOL_ERROR_MARKER
+            ):
+                result_str = f"{_TOOL_ERROR_MARKER}{result_str}"
             tool_result_messages.append(
                 {
                     "role": "tool",
                     "tool_call_id": block.get("tool_use_id", ""),
-                    "content": _tool_result_content_to_str(block.get("content")),
+                    "content": result_str,
                 }
             )
         # Unknown block types (thinking, document, …) are skipped in v0.2.
@@ -396,8 +413,19 @@ class _StreamState:
         self.current_block_index: int = -1
         self.current_block_type: str | None = None  # "text" | "tool_use"
         # openai tool_call index (from delta.tool_calls[i].index) →
-        # anthropic content block index we allocated for it
+        # anthropic content block index we allocated for it. Note: this maps
+        # to the MOST RECENT anthropic index; a single openai tool index may
+        # be re-opened under a new anthropic index if a text delta (or another
+        # tool call) forced its block closed mid-stream (M7).
         self.tool_call_block_map: dict[int, int] = {}
+        # Original tool_use metadata (id, name) keyed by openai tool_call
+        # index. Needed to re-open a tool_use block with the correct id/name
+        # after an interleaving delta closed it — id/name arrive only on the
+        # first fragment, so placeholders are not acceptable (M7).
+        self.tool_call_meta: dict[int, tuple[str, str]] = {}
+        # The openai tool_call index whose anthropic block is currently open
+        # (None when the open block is a text block or nothing is open).
+        self.current_tool_call_index: int | None = None
         self.message_id: str = f"msg_{uuid.uuid4().hex[:24]}"
         self.model: str = "unknown"
         # Usage accounting (v0.3-C). The translator's job is to make sure
@@ -446,12 +474,14 @@ def _close_current_block(state: _StreamState) -> list[AnthropicStreamEvent]:
         {"index": state.current_block_index},
     )
     state.current_block_type = None
+    state.current_tool_call_index = None
     return [evt]
 
 
 def _open_text_block(state: _StreamState) -> list[AnthropicStreamEvent]:
     state.current_block_index += 1
     state.current_block_type = "text"
+    state.current_tool_call_index = None
     return [
         _event(
             "content_block_start",
@@ -471,6 +501,7 @@ def _open_tool_use_block(
 ) -> list[AnthropicStreamEvent]:
     state.current_block_index += 1
     state.current_block_type = "tool_use"
+    state.current_tool_call_index = openai_tc_index
     state.tool_call_block_map[openai_tc_index] = state.current_block_index
     return [
         _event(
@@ -515,21 +546,50 @@ def _handle_delta(state: _StreamState, delta: dict[str, Any]) -> list[AnthropicS
         fn = tc.get("function", {}) or {}
         args_fragment = fn.get("arguments", "") or ""
 
-        if tc_index not in state.tool_call_block_map:
-            # First time we see this tool_call — close any prior block and open a new tool_use block.
+        # Record / refresh the tool metadata (id, name) as it arrives. id and
+        # name normally ride only the first fragment for a given tool index;
+        # keep whatever non-empty values we've seen so a later re-open uses the
+        # real id/name rather than placeholders (M7).
+        prev_id, prev_name = state.tool_call_meta.get(tc_index, ("", ""))
+        tool_id = tc.get("id", "") or prev_id
+        tool_name = fn.get("name", "") or prev_name
+        state.tool_call_meta[tc_index] = (tool_id, tool_name)
+
+        first_sight = tc_index not in state.tool_call_block_map
+        if first_sight:
+            # First time we see this tool_call — close any prior block and open
+            # a new tool_use block.
             out.extend(_close_current_block(state))
             out.extend(
                 _open_tool_use_block(
                     state,
                     openai_tc_index=tc_index,
-                    tool_id=tc.get("id", ""),
-                    tool_name=fn.get("name", ""),
+                    tool_id=tool_id,
+                    tool_name=tool_name,
                 )
             )
             # Function name itself is generated output even though it rides on
             # content_block_start, not on a delta. Include it in the estimate
             # so we don't under-count tool-heavy responses.
-            state.emitted_chars += len(fn.get("name", "") or "")
+            state.emitted_chars += len(tool_name)
+        elif state.current_tool_call_index != tc_index:
+            # We've seen this tool index before, but its anthropic block is no
+            # longer the open one — an interleaving text delta or a different
+            # tool call closed it. Sending an input_json_delta to the stale
+            # (closed) index is a wire-protocol violation, so re-open the tool
+            # under a fresh anthropic index, preserving its original id/name
+            # (placeholders are not acceptable). Downstream reassembles all
+            # fragments for the same tool id, so a split block is safe (M7).
+            out.extend(_close_current_block(state))
+            out.extend(
+                _open_tool_use_block(
+                    state,
+                    openai_tc_index=tc_index,
+                    tool_id=tool_id,
+                    tool_name=tool_name,
+                )
+            )
+
         block_idx = state.tool_call_block_map[tc_index]
         if args_fragment:
             out.append(
@@ -625,6 +685,16 @@ async def stream_chat_to_anthropic_events(
             if isinstance(pt, int) and pt >= 0:
                 state.upstream_input_tokens = pt
 
+    # Empty-stream guard (H6): if the upstream iterator produced no chunks,
+    # state.started is still False and no message_start was emitted. Emitting
+    # message_delta/message_stop without a preceding message_start is a wire
+    # protocol violation that breaks the Anthropic SSE parser (Claude Code
+    # aborts). Synthesize the opening event so the terminator sequence is
+    # always framed by a valid message_start.
+    if not state.started:
+        state.started = True
+        yield _start_event(state.model, state.message_id)
+
     # Terminator sequence
     for evt in _close_current_block(state):
         yield evt
@@ -897,11 +967,19 @@ def _openai_tool_message_to_block(msg: Message) -> dict[str, Any]:
         content_str = content
     else:
         content_str = ""
-    return {
+    # Restore Anthropic's is_error flag from the OpenAI "Error: " convention
+    # (mirror of the forward leg). Strip the marker so a round-trip yields the
+    # original content plus is_error, with no marker doubling (M8).
+    block: dict[str, Any] = {
         "type": "tool_result",
         "tool_use_id": msg.tool_call_id or "",
-        "content": content_str,
     }
+    if content_str.startswith(_TOOL_ERROR_MARKER):
+        block["content"] = content_str[len(_TOOL_ERROR_MARKER) :]
+        block["is_error"] = True
+    else:
+        block["content"] = content_str
+    return block
 
 
 def _openai_tools_to_anthropic(
@@ -1289,3 +1367,28 @@ async def stream_anthropic_to_chat_chunks(
             )
 
         # Unknown event types are skipped silently (forward-compat).
+
+    # Truncated-stream guard (M9): the upstream iterator ended without a
+    # message_stop (dropped connection, truncated SSE, provider that omits the
+    # terminator). The normal terminator path returns from inside the loop, so
+    # reaching here means we never emitted a finish_reason chunk or a usage
+    # chunk. OpenAI clients that requested a stream treat the absence of a
+    # finish_reason as an incomplete/hung response, so synthesize both from the
+    # state accumulated so far. Mirrors the forward-direction terminator
+    # synthesis (H6). If we never even saw a message_start, nothing was
+    # streamed at all — still emit a clean finish so the client doesn't hang.
+    finish = _REVERSE_FINISH_REASON_MAP.get(
+        state.stop_reason_anthropic or "end_turn", "stop"
+    )
+    yield _make_chunk(state, {}, finish_reason=finish)
+    yield StreamChunk(
+        id=state.message_id,
+        created=state.created,
+        model=state.model,
+        choices=[],
+        usage={
+            "prompt_tokens": state.usage_in,
+            "completion_tokens": state.usage_out,
+            "total_tokens": state.usage_in + state.usage_out,
+        },
+    )

coderouter/translation/tool_repair.py

@@ -101,16 +101,41 @@ _FENCED_RE = re.compile(
 )
 
 
-def _extract_fenced_blocks(text: str) -> tuple[str, list[str]]:
-    """Pull ```...``` blocks out of text. Returns (text_without_fences, bodies)."""
-    bodies: list[str] = []
+def _extract_tool_call_fenced_blocks(
+    text: str,
+    allowed: set[str] | None,
+) -> tuple[str, list[dict[str, Any]]]:
+    """Pull tool-call-shaped ```...``` blocks out of text.
 
-    def _collect(match: re.Match[str]) -> str:
-        bodies.append(match.group(1))
-        return ""  # remove the fenced block from the text entirely
+    Only fenced blocks whose body parses to a recognised tool-call shape are
+    removed from the text and returned as normalised OpenAI tool_calls. Any
+    other fenced block (prose, real source code, non-tool JSON) is preserved
+    verbatim in the returned text — the removal decision and the extraction
+    decision use the exact same predicate, so a fenced block is never dropped
+    without also being surfaced as a tool call (bug H2: data loss when a
+    response mixed a code example with a tool-call block).
 
-    cleaned = _FENCED_RE.sub(_collect, text)
-    return cleaned, bodies
+    Returns (text_without_tool_fences, tool_calls).
+    """
+    tool_calls: list[dict[str, Any]] = []
+
+    def _repair(match: re.Match[str]) -> str:
+        body = match.group(1).strip()
+        if not body.startswith("{"):
+            return match.group(0)  # keep non-JSON fenced blocks (e.g. code)
+        try:
+            obj = json.loads(body)
+        except json.JSONDecodeError:
+            return match.group(0)  # keep unparseable fenced blocks
+        hit = _looks_like_tool_call(obj, allowed)
+        if hit is None:
+            return match.group(0)  # keep non-tool-call JSON blocks
+        name, args = hit
+        tool_calls.append(_normalise_to_openai_tool_call(name, args))
+        return ""  # remove only recognised tool-call blocks
+
+    cleaned = _FENCED_RE.sub(_repair, text)
+    return cleaned, tool_calls
 
 
 def _find_balanced_json_objects(text: str) -> list[tuple[int, int, str]]:
@@ -188,21 +213,12 @@ def repair_tool_calls_in_text(
 
     extracted: list[dict[str, Any]] = []
 
-    # 1. Pull fenced code blocks out first — they're the most common shape
-    #    when a chat-tuned model explains what it's doing.
-    cleaned, fenced_bodies = _extract_fenced_blocks(text)
-    for body in fenced_bodies:
-        body = body.strip()
-        if not body.startswith("{"):
-            continue
-        try:
-            obj = json.loads(body)
-        except json.JSONDecodeError:
-            continue
-        hit = _looks_like_tool_call(obj, allowed)
-        if hit is not None:
-            name, args = hit
-            extracted.append(_normalise_to_openai_tool_call(name, args))
+    # 1. Pull tool-call-shaped fenced code blocks out first — they're the most
+    #    common shape when a chat-tuned model explains what it's doing. Fenced
+    #    blocks that are NOT tool calls (prose, real source code, plain JSON
+    #    examples) are left in place so we never drop legitimate content (H2).
+    cleaned, fenced_tool_calls = _extract_tool_call_fenced_blocks(text, allowed)
+    extracted.extend(fenced_tool_calls)
 
     # 2. Scan remaining text for bare JSON objects.
     #    We walk from back to front so removals by slicing don't shift

{coderouter_cli-2.6.0.dist-info → coderouter_cli-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.6.0
+Version: 2.7.0
 Summary: Local-first, free-first, fallback-built-in LLM router. Claude Code / OpenAI compatible.
 Project-URL: Homepage, https://github.com/zephel01/CodeRouter
 Project-URL: Repository, https://github.com/zephel01/CodeRouter
@@ -161,6 +161,36 @@ ANTHROPIC_BASE_URL=http://localhost:8088 ANTHROPIC_AUTH_TOKEN=dummy claude
 | **`coderouter replay`** | provider 切替の効果を統計比較 (A/B 分析) / `--suggest-rules` でルール最適化提案 |
 | **Continuous Probe** | idle 時も定期的に backend を監視 |
 
+### 言語税トラッキング — v2.6.0
+
+日本語などの CJK テキストは、クラウドのトークナイザだと「同じ意味の英語」より多くのトークンを消費します（**実測: GPT-4o 系 o200k で平均 1.6 倍、GPT-4 系 cl100k で平均 2.0 倍**）。ローカル LLM は課金されないので、この「言語税」はクラウド利用時だけ効いてきます。CodeRouter v2.6.0 はこれを **計測・ルーティング回避・可視化** します。
+
+| 機能 | 何をしてくれるか |
+|---|---|
+| **言語税の計測** | プロバイダに `tokenizer_path`（ローカルの `tokenizer.json`）を指定すると、char/4 ヒューリスティック比の実トークン倍率と割増 USD を算出（ネットワーク不要・未設定なら無効） |
+| **`cjk_ratio_min` ルーティング** | CJK 比率が高いリクエストを自動でローカル LLM（課金ゼロ）へ。コードや英語はクラウドへ |
+| **ダッシュボード可視化** | `/dashboard` の「Cost & Language Tax」パネルで総支出・キャッシュ節約・言語税をリアルタイム表示 |
+
+```yaml
+# providers.yaml — CJK 多めのターンはローカルへ自動回避
+auto_router:
+  rules:
+    - match: { cjk_ratio_min: 0.3 }   # 日本語が3割以上 → ローカル
+      profile: local
+    - match: { has_tools: true }      # ツール使用 → クラウド
+      profile: cloud
+  default_rule_profile: cloud
+
+providers:
+  - name: cloud-sonnet
+    kind: anthropic
+    base_url: https://api.anthropic.com
+    model: claude-sonnet-4-6
+    tokenizer_path: ~/.coderouter/tokenizers/sonnet.json   # 言語税の正確計測（任意）
+```
+
+詳細 → [言語税ガイド](./docs/guides/language-tax.md)
+
 ### Launcher — llama.cpp / vllm 起動 UI
 
 `http://localhost:8088/launcher` で開けるブラウザ UI。llama.cpp や vllm を GUI で起動・管理できます。
@@ -229,6 +259,7 @@ providers:
 | 使いこなす | [利用ガイド](./docs/guides/usage-guide.md) |
 | 無料で回す | [無料枠ガイド](./docs/guides/free-tier-guide.md) |
 | llama.cpp / vllm を GUI で起動 | [Launcher ガイド](./docs/backends/launcher.md) |
+| 言語税を計測・回避する | [言語税ガイド](./docs/guides/language-tax.md) |
 | 詰まった | [トラブルシューティング](./docs/guides/troubleshooting.md) |
 | 設計を知りたい | [アーキテクチャ詳細](./docs/concepts/architecture.md) |
 | 全リリース履歴 | [CHANGELOG](./CHANGELOG.md) |