@oneciel-ai/ciel-runtime 0.2.37 → 0.2.38

package/ciel_runtime_support/transcript_delta_delivery.py

@@ -15,6 +15,8 @@ import urllib.error
 import urllib.request
 
 from .remote_instructions import expand_environment_references
+from .tool_call_events import project_transcript_tool_calls
+from .web_search_result_events import project_web_search_results
 
 
 @dataclass(frozen=True, slots=True)
@@ -49,6 +51,34 @@ class TranscriptDeliverySettings:
         )
 
 
+@dataclass(frozen=True, slots=True)
+class ToolCallEventSettings:
+    enabled: bool
+    poll_interval_seconds: float
+    max_batch_bytes: int
+    start_mode: str
+    include_arguments: bool
+
+    @classmethod
+    def from_config(cls, config: dict[str, Any]) -> "ToolCallEventSettings":
+        raw = config.get("tool_call_events")
+        values = raw if isinstance(raw, dict) else {}
+        start_mode = str(values.get("start_mode") or "tail").strip().lower()
+        if start_mode not in {"tail", "beginning"}:
+            start_mode = "tail"
+        return cls(
+            enabled=bool(values.get("enabled", True)),
+            poll_interval_seconds=max(
+                0.1, min(60.0, float(values.get("poll_interval_ms") or 500) / 1000.0)
+            ),
+            max_batch_bytes=max(
+                1024, min(16_777_216, int(values.get("max_batch_bytes") or 1_048_576))
+            ),
+            start_mode=start_mode,
+            include_arguments=bool(values.get("include_arguments", True)),
+        )
+
+
 @dataclass(frozen=True, slots=True)
 class TranscriptDeliveryPorts:
     load_config: Callable[[], dict[str, Any]]
@@ -56,6 +86,8 @@ class TranscriptDeliveryPorts:
     scope: Callable[[], dict[str, Any]]
     log: Callable[[str, str], None]
     epoch: Callable[[], float] = time.time
+    event_publish: Callable[..., Any] = lambda **_kwargs: None
+    event_recent: Callable[..., list[dict[str, Any]]] = lambda **_kwargs: []
 
 
 class TranscriptDeltaDeliveryService:
@@ -153,6 +185,82 @@ class TranscriptDeltaDeliveryService:
         self._last_error = ""
         return True
 
+    def poll_tool_call_events(self) -> int:
+        settings = ToolCallEventSettings.from_config(self.ports.load_config())
+        if not settings.enabled:
+            return 0
+        path = self.ports.latest_transcript()
+        if path is None:
+            return 0
+        try:
+            path = path.resolve()
+            size = path.stat().st_size
+        except OSError:
+            return 0
+        scope = self.ports.scope()
+        runtime = str(scope.get("runtime") or "runtime")
+        session_id = str(scope.get("session_id") or path.stem)
+        source_key = hashlib.sha256(f"tool-call\0{path}".encode("utf-8")).hexdigest()
+        cursors = self._load_cursors()
+        sources = cursors.setdefault("tool_call_sources", {})
+        current = sources.get(source_key)
+        if not isinstance(current, dict):
+            offset = self._initial_tool_call_offset(settings, scope, path, size)
+            sources[source_key] = self._cursor_record(path, offset)
+            self._save_cursors(cursors)
+            if offset >= size:
+                return 0
+            current = sources[source_key]
+        offset = max(0, int(current.get("offset") or 0))
+        if size < offset:
+            offset = 0
+            current.pop("web_search_results", None)
+        payload = self._read_complete_batch(path, offset, settings.max_batch_bytes)
+        if not payload:
+            return 0
+        count = 0
+        search_state = current.setdefault("web_search_results", {})
+        for raw_line in payload.decode("utf-8", errors="replace").splitlines():
+            try:
+                record = json.loads(raw_line)
+            except (TypeError, ValueError):
+                continue
+            if not isinstance(record, dict):
+                continue
+            for result in project_web_search_results(record, runtime, search_state):
+                self.ports.event_publish(
+                    level="info", category="tool.call", message=f"{runtime} web search result URLs",
+                    source="cli-transcript", session_id=session_id, provider=runtime,
+                    data=result,
+                )
+                count += 1
+            for call in project_transcript_tool_calls(record, runtime):
+                call_id = str(call.get("call_id") or "")
+                if call_id and any(
+                    str((event.get("data") or {}).get("call_id") or "") == call_id
+                    and (event.get("data") or {}).get("phase") != "result"
+                    for event in self.ports.event_recent(limit=200, category="tool.call")
+                ):
+                    continue
+                data = dict(call)
+                if not settings.include_arguments:
+                    data.pop("arguments", None)
+                self.ports.event_publish(
+                    level="info",
+                    category="tool.call",
+                    message=f"{runtime} tool call: {call['name']}",
+                    source="cli-transcript",
+                    session_id=session_id,
+                    provider=runtime,
+                    model=str(call.get("model") or ""),
+                    data={**data, "transcript_name": path.name},
+                )
+                count += 1
+        sources[source_key] = self._cursor_record(path, offset + len(payload))
+        sources[source_key]["web_search_results"] = search_state
+        self._save_cursors(cursors)
+        return count
+
     @staticmethod
     def _initial_offset(
         settings: TranscriptDeliverySettings, scope: dict[str, Any], path: Path
@@ -175,7 +283,10 @@ class TranscriptDeltaDeliveryService:
             try:
                 config = self.ports.load_config()
                 settings = TranscriptDeliverySettings.from_config(config)
-                interval = settings.poll_interval_seconds
+                tool_settings = ToolCallEventSettings.from_config(config)
+                interval = min(settings.poll_interval_seconds, tool_settings.poll_interval_seconds)
+                if tool_settings.enabled:
+                    self.poll_tool_call_events()
                 if settings.enabled and settings.url:
                     self.poll_once()
             except Exception as exc:
@@ -191,9 +302,36 @@ class TranscriptDeltaDeliveryService:
             value = {}
         if not isinstance(value.get("destinations"), dict):
             value["destinations"] = {}
+        if not isinstance(value.get("tool_call_sources"), dict):
+            value["tool_call_sources"] = {}
         value["version"] = 1
         return value
 
+    @staticmethod
+    def _initial_tool_call_offset(
+        settings: ToolCallEventSettings,
+        scope: dict[str, Any],
+        path: Path,
+        size: int,
+    ) -> int:
+        if settings.start_mode == "beginning":
+            return 0
+        boundary_path = scope.get("turn_scan_path")
+        if boundary_path is not None:
+            try:
+                if Path(boundary_path).resolve() == path:
+                    return max(0, int(scope.get("turn_scan_offset") or 0))
+            except (OSError, TypeError, ValueError):
+                pass
+        started_at = float(scope.get("started_at") or 0)
+        if started_at > 0:
+            try:
+                if path.stat().st_mtime >= started_at - 1.0:
+                    return 0
+            except OSError:
+                pass
+        return size
+
     def _save_cursors(self, cursors: dict[str, Any]) -> None:
         self.cursor_path.parent.mkdir(parents=True, exist_ok=True)
         temporary = self.cursor_path.with_name(
@@ -330,4 +468,5 @@ __all__ = [
     "TranscriptDeliveryPorts",
     "TranscriptDeliverySettings",
     "TranscriptDeltaDeliveryService",
+    "ToolCallEventSettings",
 ]

package/ciel_runtime_support/ui_text.py

@@ -256,6 +256,7 @@ PROVIDER_NOTES = {
 
 DEFAULT_ADVISOR_MODELS: tuple[str, ...] = (
     "",
+    "claude-fable-5-1",
     "claude-fable-5",
     "claude-opus-5",
     "claude-opus-4-8",

package/ciel_runtime_support/web_search_result_events.py

@@ -0,0 +1,130 @@
+"""Extract response URLs, never search arguments or result prose, from CLI records."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any
+from urllib.parse import urlsplit
+
+
+_SEARCH_NAMES = {"WebSearch", "web_search", "web.run", "web__run", "functions.web__run"}
+_URL = re.compile(r"https?://[^\s<>\"\x00-\x1f]+")
+
+
+def _is_search_call(value: dict[str, Any]) -> bool:
+    name = value.get("name")
+    if name not in _SEARCH_NAMES:
+        return False
+    if name in {"WebSearch", "web_search"}:
+        return True
+    arguments = value.get("arguments", value.get("input"))
+    if isinstance(arguments, str):
+        try:
+            arguments = json.loads(arguments)
+        except ValueError:
+            return False
+    return isinstance(arguments, dict) and bool(arguments.get("search_query"))
+
+
+def _valid_url(value: Any) -> bool:
+    if not isinstance(value, str) or any(c.isspace() or ord(c) < 32 for c in value):
+        return False
+    try:
+        parsed = urlsplit(value)
+        return parsed.scheme in {"http", "https"} and bool(parsed.hostname) and not parsed.username and not parsed.password
+    except ValueError:
+        return False
+
+
+def _urls(value: Any, *, text: bool = False) -> list[str]:
+    if isinstance(value, list):
+        return [url for item in value for url in _urls(item, text=text)]
+    if isinstance(value, dict):
+        result = [value["url"]] if _valid_url(value.get("url")) else []
+        for key in ("sources", "results", "content", "annotations", "url_citation"):
+            result.extend(_urls(value.get(key), text=text))
+        if text and value.get("type") == "text":
+            result.extend(_urls(value.get("text"), text=True))
+        return result
+    if text and isinstance(value, str):
+        # Claude Code supplies a JSON Links list embedded in a text result.
+        match = re.search(r"(?:^|\n)Links:\s*", value)
+        if match:
+            try:
+                links, _ = json.JSONDecoder().raw_decode(value[match.end():])
+                return _urls(links)
+            except ValueError:
+                return []
+        try:
+            decoded = json.loads(value)
+        except ValueError:
+            decoded = None
+        if isinstance(decoded, (dict, list)):
+            return _urls(decoded, text=True)
+        result = []
+        for match in _URL.finditer(value):
+            url = match.group().rstrip(".,;!?'\"]}")
+            while url.endswith(")") and url.count(")") > url.count("("):
+                url = url[:-1]
+            if _valid_url(url):
+                result.append(url)
+        return result
+    return []
+
+
+def project_web_search_results(record: dict[str, Any], runtime: str, state: dict[str, Any]) -> list[dict[str, Any]]:
+    """State is persisted with the transcript offset, bounded to 512 calls/results."""
+    pending = state.setdefault("pending", {})
+    seen = state.setdefault("seen", [])
+    events = []
+
+    def emit(call_id: str, name: str, urls: list[str]) -> None:
+        urls = list(dict.fromkeys(urls))
+        if not urls:
+            return
+        digest = hashlib.sha256(json.dumps([call_id, urls], ensure_ascii=False).encode()).hexdigest()
+        if digest in seen:
+            return
+        seen.append(digest)
+        events.append({"call_id": call_id, "name": name, "runtime": runtime, "phase": "result", "urls": urls})
+
+    message = record.get("message") or {}
+    blocks = message.get("content", []) if isinstance(message, dict) else []
+    if isinstance(blocks, list):
+        for block in blocks:
+            if not isinstance(block, dict):
+                continue
+            kind = block.get("type")
+            if kind in {"tool_use", "server_tool_use"} and (record.get("type") == "assistant" or message.get("role") == "assistant") and _is_search_call(block):
+                if block.get("id"):
+                    pending[str(block["id"])] = str(block["name"])
+            elif kind in {"tool_result", "web_search_tool_result"} and not block.get("is_error"):
+                call_id = str(block.get("tool_use_id") or "")
+                name = pending.get(call_id)
+                if name or kind == "web_search_tool_result":
+                    emit(call_id, name or "web_search", _urls(block.get("content"), text=True))
+
+    payload = record.get("payload") or {}
+    if record.get("type") == "response_item" and isinstance(payload, dict):
+        kind = payload.get("type")
+        call_id = str(payload.get("call_id") or payload.get("id") or "")
+        if kind in {"function_call", "custom_tool_call"} and _is_search_call(payload) and call_id:
+            pending[call_id] = str(payload["name"])
+        elif kind in {"function_call_output", "custom_tool_call_output"} and call_id in pending:
+            emit(call_id, pending[call_id], _urls(payload.get("output"), text=True))
+        elif kind == "web_search_call" and payload.get("status") == "completed":
+            # Do not treat action.query or open_page input URLs as search results.
+            action = payload.get("action") or {}
+            sources = action.get("sources") if isinstance(action, dict) else None
+            emit(call_id, "web_search", _urls([sources, payload.get("results")]))
+        elif kind == "message" and payload.get("role") == "assistant":
+            # API-backed transcripts can retain structured URL citations.
+            for block in payload.get("content") or []:
+                if isinstance(block, dict):
+                    annotations = [a for a in block.get("annotations", []) if isinstance(a, dict) and a.get("type") == "url_citation"]
+                    emit(call_id, "web_search", _urls(annotations))
+    while len(pending) > 512:
+        del pending[next(iter(pending))]
+    del seen[:-512]
+    return events

package/ciel_runtime_support/web_ui.py

@@ -1756,6 +1756,7 @@ def render_web_chat_page(
             sender_id: 'web-user',
             recipients: ['all'],
             delivery: ['llm', 'native'],
+            input_transport: 'session_socket',
             thread_id: sessionId,
             kind: 'web_chat',
             message: outboundText,

package/ciel_runtime_support/windows_conpty.py

@@ -29,6 +29,10 @@ _CLAUDE_COLLAPSED_PASTE_PATTERN = re.compile(
     rb"\[Pasted(?:\x1b\[[0-?]*[ -/]*[@-~]|\s)+"
     rb"text(?:\x1b\[[0-?]*[ -/]*[@-~]|\s)+#"
 )
+_VT_OSC_PATTERN = re.compile(rb"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)")
+_VT_CURSOR_RIGHT_PATTERN = re.compile(rb"\x1b\[([0-9]*)(?:C|a)")
+_VT_CSI_PATTERN = re.compile(rb"\x1b\[[0-?]*[ -/]*[@-~]")
+_VT_SINGLE_ESCAPE_PATTERN = re.compile(rb"\x1b[@-_]")
 
 
 def _collapsed_paste_marker_count(output: bytes | str) -> int:
@@ -38,6 +42,21 @@ def _collapsed_paste_marker_count(output: bytes | str) -> int:
     )
 
 
+def _visible_terminal_text(output: bytes | str) -> str:
+    """Project ConPTY output to comparable visible text without mutating input."""
+
+    data = output.encode("utf-8", errors="replace") if isinstance(output, str) else bytes(output)
+    data = _VT_OSC_PATTERN.sub(b"", data)
+    data = _VT_CURSOR_RIGHT_PATTERN.sub(
+        lambda match: b" " * max(1, min(4096, int(match.group(1) or b"1"))),
+        data,
+    )
+    data = _VT_CSI_PATTERN.sub(b"", data)
+    data = _VT_SINGLE_ESCAPE_PATTERN.sub(b"", data)
+    text = data.decode("utf-8", errors="replace")
+    return " ".join(text.replace("\x00", "").split())
+
+
 def conpty_enabled(
     environment: Mapping[str, str] | None = None,
     *,
@@ -202,8 +221,9 @@ class WindowsConPtySession:
         prompt = WindowsConPtySession.normalize_prompt(str(expected_prompt or ""))
         if not prompt:
             return bool(output)
-        prefix = prompt[:48].encode("utf-8", errors="replace")
-        return bool(prefix and prefix in output) or _collapsed_paste_marker_count(output) > 0
+        prefix = _visible_terminal_text(prompt)[:48]
+        visible = _visible_terminal_text(output)
+        return bool(prefix and prefix in visible) or _collapsed_paste_marker_count(output) > 0
 
     @staticmethod
     def _prompt_rendered_since(
@@ -214,13 +234,44 @@ class WindowsConPtySession:
         if current == baseline:
             return False
         prompt = WindowsConPtySession.normalize_prompt(str(expected_prompt or ""))
-        prefix = prompt[:48]
-        if prefix and current.count(prefix) > baseline.count(prefix):
+        prefix = _visible_terminal_text(prompt)[:48]
+        current_visible = _visible_terminal_text(current)
+        baseline_visible = _visible_terminal_text(baseline)
+        if prefix and current_visible.count(prefix) > baseline_visible.count(prefix):
             return True
         if prompt and _collapsed_paste_marker_count(current) > _collapsed_paste_marker_count(baseline):
             return True
         return not prompt
 
+    def clear_unsubmitted_prompt(
+        self,
+        clear_input: bytes,
+        expected_prompt: str,
+        timeout_seconds: float = 2.0,
+    ) -> bool:
+        """Clear a draft and require a settled child redraw before it is retry-safe."""
+
+        checkpoint = self.prompt_readiness_checkpoint()
+        self.write(clear_input)
+        cursor = checkpoint
+        observed = bytearray()
+        stable_since: float | None = None
+        deadline = time.monotonic() + max(0.0, float(timeout_seconds))
+        prefix = _visible_terminal_text(self.normalize_prompt(expected_prompt))[:48]
+        while True:
+            now = time.monotonic()
+            chunk, cursor = self._output_since(cursor)
+            if chunk:
+                observed.extend(chunk)
+                del observed[: max(0, len(observed) - 64 * 1024)]
+                stable_since = now
+            if observed and stable_since is not None and now - stable_since >= 0.25:
+                visible = _visible_terminal_text(bytes(observed))
+                return bool(visible) and (not prefix or prefix not in visible)
+            if now >= deadline:
+                return False
+            time.sleep(0.02)
+
     @staticmethod
     def pending_input_events() -> None:
         return None
@@ -320,16 +371,49 @@ class WindowsConPtySession:
     def kill(self) -> None:
         self.terminate()
 
-    def resize_if_needed(self) -> None:
+    def resize_if_needed(self) -> bool:
         if not self._hpc or not self._kernel32:
-            return
+            return False
         size = self._terminal_size()
         if size == self._last_size:
-            return
+            return False
+        checkpoint = self.prompt_readiness_checkpoint()
         coord = self._coord_type(size[0], size[1])
-        result = int(self._kernel32.ResizePseudoConsole(self._hpc, coord))
+        try:
+            result = int(self._kernel32.ResizePseudoConsole(self._hpc, coord))
+        except Exception as exc:
+            self._log(
+                "ERROR",
+                "channel_windows_conpty_resize_failed "
+                f"cols={size[0]} rows={size[1]} error={type(exc).__name__}: {exc}",
+            )
+            return False
         if result == 0:
             self._last_size = size
+            redrawn = self._wait_for_output_change(checkpoint, 0.75)
+            self._log(
+                "INFO" if redrawn else "WARN",
+                "channel_windows_conpty_resize "
+                f"cols={size[0]} rows={size[1]} "
+                f"redraw={'observed' if redrawn else 'timeout'}",
+            )
+            return True
+        self._log(
+            "ERROR",
+            "channel_windows_conpty_resize_failed "
+            f"cols={size[0]} rows={size[1]} hresult=0x{result & 0xFFFFFFFF:08X}",
+        )
+        return False
+
+    def _wait_for_output_change(self, checkpoint: int, timeout_seconds: float) -> bool:
+        deadline = time.monotonic() + max(0.0, float(timeout_seconds))
+        while True:
+            chunk, _cursor = self._output_since(checkpoint)
+            if chunk:
+                return True
+            if time.monotonic() >= deadline:
+                return False
+            time.sleep(0.02)
 
     def close(self) -> None:
         if self._closed:

package/ciel_runtime_support/workspace_mcp.py

@@ -14,6 +14,8 @@ import time
 import uuid
 from typing import Any, Callable
 
+from .managed_tool_injection import select_managed_tools
+
 
 _SERVER_ID = re.compile(r"^[A-Za-z0-9_-]{1,80}$")
 _RUNTIMES = frozenset({"claude", "codex", "codex-app-server"})
@@ -247,13 +249,14 @@ class WorkspaceMcpLaunchService:
         config: dict[str, Any],
         environment: Mapping[str, str] | None = None,
         injected_servers: Mapping[str, Any] | None = None,
+        *, native: bool = False,
     ) -> WorkspaceMcpLaunch:
         if runtime not in _RUNTIMES:
             raise ValueError(f"Unsupported workspace MCP runtime: {runtime}")
         self.recover_stale()
         servers = workspace_mcp_servers(config, runtime)
         if injected_servers:
-            injected = {"workspace_mcp": {"servers": dict(injected_servers)}}
+            injected = {"workspace_mcp": {"servers": select_managed_tools(injected_servers, native=native)}}
             servers.update(workspace_mcp_servers(injected, runtime))
         if not servers:
             return WorkspaceMcpLaunch()

package/ciel_runtime_support/workspace_state.py

@@ -10,6 +10,7 @@ from pathlib import Path
 WORKSPACE_FILES = (
     "chat-messages.jsonl",
     "runtime-inputs.jsonl",
+    "runtime-input-status.jsonl",
     "channel-llm-cursor.json",
     "channel-llm-clear-floor.json",
     "channel-llm-launch-guard.json",

package/docs/Configuration.md

@@ -35,6 +35,8 @@
 | `model-registry.json` | 모델 레지스트리 |
 | `ollama-model-catalog.json` | Ollama 모델 카탈로그 캐시 (TTL: 24시간) |
 | `chat-messages.jsonl` | 채팅 메시지 (최대 20MB) |
+| `workspaces/<workspace-id>/runtime-inputs.jsonl` | TUI/세션 소켓으로 전달할 private 입력 큐 |
+| `workspaces/<workspace-id>/runtime-input-status.jsonl` | private 입력의 queued/submitted/replied/failed 상태 이력 |
 | `channel-probe-cache.json` | 채널 프로브 캐시 |
 | `launch-state.json` | 실행 상태 |
 | `tts-reference-audio/*.bin` | 업로드한 TTS reference의 private binary sidecar (`0600` 시도) |
@@ -235,6 +237,13 @@ Alibaba Model Studio Token Plan(`alitoken`)의 native Responses endpoint는 실
 10 MiB를 넘는 단일 비축약 항목은 upstream으로 보내거나 재시도하지 않고 로컬 413으로 종료한다.
 `alitoken-individual`과 다른 provider에는 이 wire 정책을 적용하지 않는다.
 
+Alibaba의 Responses session cache는 요청 header가 없으면 기본적으로 비활성화된다.
+`alims-intl`과 `alitoken`의 `openai_responses` 요청에는
+`x-dashscope-session-cache: enable`을 기본 전송한다. 이 값은 provider의
+`protocol_headers.openai_responses` 설정으로 관리되며 Chat/Anthropic wire에는 복사하지
+않는다. 이 범용 protocol header 설정은 `authorization`, API key, cookie, host,
+content-length 및 hop-by-hop header를 덮어쓸 수 없다.
+
 ---
 
 ## 원격 시스템 지침
@@ -393,20 +402,27 @@ VT 활성화가 실패한 classic/legacy console에는 escape 문자열을 raw t
 연기한다. 따라서 wake 주입 앞의 `Ctrl+U`가 사용자가 먼저 입력한 글자를 지우지
 않으며, 사용자가 Enter로 draft를 제출한 뒤 기존 polling 절차가 다시 진행된다.
 
+ConPTY prompt-render detector는 캡처된 UTF-8 출력을 기준으로 ANSI CSI/OSC/SGR을
+가시 텍스트로 투영한 뒤 원문 prefix를 비교한다. 따라서 한글 바이트와 ANSI 색상·
+cursor 이동 시퀀스가 섞여도 화면에 표시된 원문을 감지한다. 이 투영은 감지에만
+사용하며 실제 입력 원문에는 표식이나 다른 문자를 추가하지 않는다.
+
 ConPTY 생성이 불가능하거나 `CIEL_RUNTIME_WINDOWS_CONPTY=0`으로 명시적으로 끈
 경우에만 기존 Windows Console 입력 큐 호환 경로를 사용한다. 이 호환 경로에서는
 `clear → body → submit`을 각각 큐가 소비한 뒤 진행하고, 여러 줄의 외부 메시지는
 줄바꿈이 Enter 키로 해석되지 않도록 한 줄로 정규화한다. 완전한 wake prompt 전달
-확인이 반복해서 실패하면 같은 본문을 무한 재주입하지 않고 짧은 sentinel을 한 번
-제출한 뒤 실제 메시지를 request-body 경로로 전달한다.
+확인에 실패하면 `Ctrl+U`로 해당 draft 제거를 한 번 요청하고 ConPTY redraw로 제거를
+확인한다. 제거 여부와 관계없이 같은 원문을 자동 재입력하지 않으며 요청 상태를
+`failed`로 유지한다. 앞선 실패 요청은 다음 입력을 차단한다. ASCII sentinel을
+추가하거나 router request-body 전송으로 자동 변경하지 않는다.
 
 호환 경로는 실행 중 Win32 `ENABLE_MOUSE_INPUT` bit를 끄고 종료할 때 원래 입력
 mode를 복원한다. `CIEL_RUNTIME_WINDOWS_CONSOLE_MOUSE_FILTER=0`은 이 Win32 guard를,
 `CIEL_RUNTIME_TERMINAL_INPUT_MODE_RESET=0`은 안전한 VT mode reset을 각각 끈다.
 정확한 `ESC[20~`는 Microsoft VT 입력 표의 F9이므로 mouse report로 제거하지 않는다.
 
-`CIEL_RUNTIME_WINDOWS_CHANNEL_WAKE_MAX_ATTEMPTS`로 완전한 wake prompt 시도 상한을
-설정할 수 있다. 기본값은 `2`, 허용 범위는 `1`~`4`이다.
+ConPTY resize 실패는 요청 크기와 HRESULT/예외를 router 로그에 기록한다. 성공한
+resize 뒤에는 child output 발생 여부를 확인해 `redraw=observed|timeout`을 남긴다.
 
 ---