@oneciel-ai/ciel-runtime 0.2.37 → 0.2.39

package/ciel_runtime_support/channel_inflight.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from typing import Any, Callable, Literal
 
 
-InflightAction = Literal["none", "completed", "unseen_retry", "stale", "waiting"]
+InflightAction = Literal["none", "completed", "failed", "waiting"]
 
 
 @dataclass(frozen=True, slots=True)
@@ -71,9 +71,9 @@ def advance_channel_inflight(
         effects.release_wake(message_id)
         effects.log(
             "WARN",
-            f"{policy.log_namespace}_unseen_retry message_id={message_id} age={age:.1f}s",
+            f"{policy.log_namespace}_unseen_failed message_id={message_id} age={age:.1f}s",
         )
-        return _reset("unseen_retry", snapshot, last_id=effects.ensure_cursor(), logged_at=snapshot.now)
+        return _reset("failed", snapshot, last_id=effects.ensure_cursor(), logged_at=snapshot.now)
     if policy.is_stale(state, snapshot.started_at, snapshot.now):
         if policy.commit_cursor_on_stale and snapshot.cursor is not None:
             effects.commit_cursor(snapshot.cursor)
@@ -83,7 +83,7 @@ def advance_channel_inflight(
             f"{policy.log_namespace}_{policy.stale_event} message_id={message_id} state={state} "
             f"age={age:.1f}s cursor={snapshot.cursor or '-'}",
         )
-        return _reset("stale", snapshot, last_id=effects.ensure_cursor(), logged_at=snapshot.now)
+        return _reset("failed", snapshot, last_id=effects.ensure_cursor(), logged_at=snapshot.now)
     if snapshot.now - snapshot.logged_at >= policy.waiting_log_interval:
         effects.log(
             "INFO",

package/ciel_runtime_support/channel_injection.py

@@ -33,6 +33,13 @@ class InputTransport(Protocol):
         expected_prompt: str | None = None,
     ) -> bool | None: ...
 
+    def clear_unsubmitted_prompt(
+        self,
+        clear_input: bytes,
+        expected_prompt: str,
+        timeout_seconds: float = 2.0,
+    ) -> bool: ...
+
 
 @dataclass(frozen=True)
 class RuntimeInjectionPolicy:
@@ -139,9 +146,16 @@ class ChannelPromptInjector:
                 policy,
             )
             if prompt_ready is False:
+                cleared = self._clear_unsubmitted_prompt(
+                    transport,
+                    policy.clear_input,
+                    prompt_text,
+                    policy.input_drain_timeout_seconds,
+                )
                 self._log(
                     "WARN",
-                    "channel_input_submit_deferred reason=prompt_render_timeout",
+                    "channel_input_submit_failed reason=prompt_render_timeout "
+                    f"draft_clear={'confirmed' if cleared else 'unverified'} retry=disabled",
                 )
                 return False
 
@@ -178,6 +192,36 @@ class ChannelPromptInjector:
         )
         return False
 
+    def _clear_unsubmitted_prompt(
+        self,
+        transport: InputTransport,
+        clear_input: bytes,
+        prompt: str,
+        timeout_seconds: float,
+    ) -> bool:
+        clear = getattr(transport, "clear_unsubmitted_prompt", None)
+        if not callable(clear):
+            self._log(
+                "WARN",
+                "channel_input_draft_clear result=unavailable retry=disabled",
+            )
+            return False
+        try:
+            cleared = bool(clear(clear_input, prompt, timeout_seconds))
+        except Exception as exc:
+            self._log(
+                "ERROR",
+                "channel_input_draft_clear result=error retry=disabled "
+                f"error={type(exc).__name__}: {exc}",
+            )
+            return False
+        self._log(
+            "INFO" if cleared else "WARN",
+            "channel_input_draft_clear "
+            f"result={'confirmed' if cleared else 'unverified'} retry=disabled",
+        )
+        return cleared
+
     def _submission_snapshot(self, transport: InputTransport) -> str | None:
         """Use the host snapshot when available, then the transport's own view."""
 
@@ -334,6 +378,17 @@ class CallableInputTransport:
             )
         )
 
+    def clear_unsubmitted_prompt(
+        self,
+        clear_input: bytes,
+        expected_prompt: str,
+        timeout_seconds: float = 2.0,
+    ) -> bool:
+        clear = getattr(self._target, "clear_unsubmitted_prompt", None)
+        if not callable(clear):
+            return False
+        return bool(clear(clear_input, expected_prompt, timeout_seconds))
+
 
 __all__ = [
     "CallableInputTransport",

package/ciel_runtime_support/channel_mcp_tools.py

@@ -20,10 +20,37 @@ class ChannelMcpToolServices:
     handle_llm_options: Callable[[str, str], tuple[list[str], bool]]
     read_runtime_inputs: Callable[..., list[dict[str, Any]]] | None = None
     telemetry_logs: Callable[[str, dict[str, Any]], dict[str, Any]] | None = None
+    submit_input: Callable[[dict[str, Any]], dict[str, Any]] | None = None
 
 
 def channel_mcp_tool_schemas() -> list[dict[str, Any]]:
     return [
+        {
+            "name": "submit_input",
+            "description": (
+                "Submit an external message to the active Ciel Runtime session. "
+                "Claude sessions use their authenticated session socket by default; "
+                "callers may explicitly select session_socket, tty, or router."
+            ),
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "message": {"type": "string"},
+                    "channel": {"type": "string"},
+                    "sender_id": {"type": "string"},
+                    "thread_id": {"type": "string"},
+                    "input_transport": {
+                        "type": "string",
+                        "enum": ["session_socket", "tty", "router"],
+                    },
+                    "response_mode": {
+                        "type": "string",
+                        "enum": ["web_chat", "tty", "mcp"],
+                    },
+                },
+                "required": ["message"],
+            },
+        },
         {
             "name": "compact_session",
             "description": (
@@ -213,6 +240,13 @@ def dispatch_channel_mcp_tool(
                 "expires_at": request.get("expires_at"),
             },
         )
+    if name == "submit_input":
+        if services.submit_input is None:
+            return channel_mcp_tool_response(request_id, "runtime input submission is unavailable", True)
+        if not str(args.get("message") or args.get("content") or args.get("text") or "").strip():
+            return channel_mcp_tool_response(request_id, "submit_input requires message", True)
+        saved = services.submit_input(args)
+        return _json_response(request_id, {"ok": True, "message": saved})
     if name == "send_message":
         return _send_message(request_id, args, services)
     if name == "send_file":

package/ciel_runtime_support/channel_message_policy.py

@@ -125,13 +125,21 @@ def web_chat_input_mode(message: dict[str, Any]) -> str:
     return "voice" if value == "voice" else "text"
 
 
+def message_raw_injection(message: dict[str, Any]) -> bool:
+    """Return whether only the exact admitted message text may reach the model."""
+
+    return _metadata(message).get("raw_injection") is True
+
+
 def message_input_transport(message: dict[str, Any]) -> str:
     """Return the per-request path used to enter the active model turn."""
 
     # Messages admitted before input_transport existed followed the router
     # delivery policy selected at launch. Preserve that persisted compatibility;
-    # the HTTP API now always stamps its explicit default (tty).
+    # current input APIs always stamp their runtime-selected transport.
     value = str(_metadata(message).get("input_transport") or "router").strip().lower().replace("-", "_")
+    if value in {"session_socket", "socket", "claude_socket", "messaging_socket"}:
+        return "session_socket"
     if value in {"router", "llm", "context", "inband", "in_band"}:
         return "router"
     return "tty"

package/ciel_runtime_support/channel_message_prompt.py

@@ -14,6 +14,7 @@ from ciel_runtime_support.channel_message_policy import (
     message_is_web_chat_request,
     message_is_external_event,
     message_meta_sources,
+    message_raw_injection,
     message_response_mcp,
     message_response_mode,
     string_list,
@@ -172,6 +173,8 @@ def _web_chat_reply_routes(
     routes: list[dict[str, str]] = []
     seen: set[tuple[str, str, str]] = set()
     for message in messages:
+        if message_raw_injection(message):
+            continue
         if not message_is_web_chat_request(message):
             continue
         if message_response_mode(message) != "web_chat":
@@ -257,6 +260,8 @@ def _mcp_reply_instruction(messages: list[dict[str, Any]]) -> str:
     instructions: list[str] = []
     seen: set[tuple[str, str, str]] = set()
     for message in messages:
+        if message_raw_injection(message):
+            continue
         if message_response_mode(message) != "mcp":
             continue
         hint = message_response_mcp(message)
@@ -321,6 +326,12 @@ def _format_cielarvis_internal_prompt(messages: list[dict[str, Any]]) -> str | N
 
 
 def format_web_chat_wake_batch_prompt(messages: list[dict[str, Any]]) -> str:
+    if len(messages) == 1 and message_raw_injection(messages[0]):
+        return str(
+            messages[0].get("message")
+            if messages[0].get("message") is not None
+            else ""
+        )
     if compact := _format_cielarvis_internal_prompt(messages):
         return compact
     if messages and all(
@@ -406,6 +417,12 @@ def wake_message_is_noise(message: dict[str, Any]) -> bool:
 
 
 def format_wake_batch_prompt(messages: list[dict[str, Any]]) -> str:
+    if len(messages) == 1 and message_raw_injection(messages[0]):
+        return str(
+            messages[0].get("message")
+            if messages[0].get("message") is not None
+            else ""
+        )
     if len(messages) == 1:
         return format_wake_prompt(messages[0])
     parts: list[str] = []
@@ -493,6 +510,12 @@ def message_llm_display_text(message: dict[str, Any]) -> str:
 
 
 def format_llm_batch_prompt(messages: list[dict[str, Any]]) -> str:
+    if len(messages) == 1 and message_raw_injection(messages[0]):
+        return str(
+            messages[0].get("message")
+            if messages[0].get("message") is not None
+            else ""
+        )
     prompt = "\n\n".join(message_llm_display_text(message) for message in messages)
     instruction = _response_instruction(messages)
     return f"{prompt}\n\n{instruction}" if instruction else prompt

package/ciel_runtime_support/channel_pending_injection.py

@@ -10,6 +10,7 @@ from ciel_runtime_support.channel_message_policy import (
     message_is_external_event,
     message_response_mcp,
     message_response_mode,
+    message_raw_injection,
     web_chat_input_mode,
 )
 
@@ -44,11 +45,8 @@ class ChannelInjectionWakeStore:
     claim_prompt: Callable[[int, str], bool]
     clear_claim: Callable[[int], Any]
     release_stale: Callable[[int, bool], Any]
-    mark_delivered: Callable[[int], bool]
-    record_prompts: Callable[[list[dict[str, Any]], str], Any]
-    rollback: Callable[[list[dict[str, Any]], list[int]], Any]
+    lifecycle: Any
     commit_cursor: Callable[[int], Any]
-    body_fallback: Callable[[int], bool] = lambda _message_id: False
 
 
 @dataclass(frozen=True, slots=True)
@@ -57,6 +55,7 @@ class ChannelInjectionIO:
     read_messages: Callable[..., list[dict[str, Any]]]
     write_prompt: Callable[..., Any]
     log: Callable[[str, str], Any]
+    write_session_socket: Callable[[str, list[dict[str, Any]]], bool] | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -103,12 +102,8 @@ def inject_pending_channel_messages(
     wake_store = services.wake_store
     io = services.io
     with io.inject_lock:
-        if state.active_tool_call():
-            io.log("INFO", f"channel_stdin_proxy_deferred cursor={last_id} reason=active_tool_call")
-            return last_id
-        if state.active_turn():
-            io.log("INFO", f"channel_stdin_proxy_deferred cursor={last_id} reason=active_turn")
-            return last_id
+        active_tool_call = state.active_tool_call()
+        active_turn = state.active_turn()
         if not web_chat_only:
             last_id = state.recover_cursor(last_id)
         pending: list[dict[str, Any]] = []
@@ -118,6 +113,7 @@ def inject_pending_channel_messages(
         batch_limit = services.policy.wake_batch_limit() if wake_for_llm_delivery else 1
         pending_batch_key: tuple[str, str, str] | None = None
         pending_uses_router = False
+        pending_uses_session_socket = False
         seen_event_keys: set[tuple[str, ...]] = set()
         for message in candidates:
             previous_last_id = last_id
@@ -126,6 +122,17 @@ def inject_pending_channel_messages(
                 continue
             last_id = max(last_id, message_id)
             channel = message.get("channel")
+            failure_reason = wake_store.lifecycle.failure_reason(message_id)
+            if failure_reason:
+                io.log(
+                    "ERROR",
+                    "channel_stdin_proxy_blocked "
+                    f"cursor={previous_last_id} message_id={message_id} "
+                    f"reason=prior_submission_failed detail={failure_reason}",
+                )
+                if pending:
+                    break
+                return previous_last_id
             if web_chat_only and not state.message_is_web_chat(message):
                 io.log("INFO", f"channel_stdin_proxy_skipped_noise message_id={message_id} channel={channel} reason=not_web_chat")
                 continue
@@ -138,11 +145,28 @@ def inject_pending_channel_messages(
                 )
                 continue
             metadata = message.get("meta") if isinstance(message.get("meta"), dict) else {}
+            input_transport = message_input_transport(message)
+            requested_session_socket = input_transport == "session_socket"
             requested_router = (
-                message_input_transport(message) == "router"
+                input_transport == "router"
                 if "input_transport" in metadata
                 else wake_for_llm_delivery
             )
+            if requested_session_socket and io.write_session_socket is None:
+                io.log(
+                    "WARN",
+                    f"channel_stdin_proxy_transport_fallback cursor={previous_last_id} "
+                    f"message_id={message_id} channel={channel} "
+                    "requested=session_socket fallback=tty "
+                    "reason=session_socket_transport_unavailable",
+                )
+                requested_session_socket = False
+            if not requested_session_socket and (active_tool_call or active_turn):
+                reason = "active_tool_call" if active_tool_call else "active_turn"
+                io.log("INFO", f"channel_stdin_proxy_deferred cursor={previous_last_id} reason={reason}")
+                if pending:
+                    break
+                return previous_last_id
             if requested_router and not wake_for_llm_delivery:
                 io.log(
                     "WARN",
@@ -153,13 +177,6 @@ def inject_pending_channel_messages(
                     break
                 return previous_last_id
             candidate_uses_router = requested_router
-            if candidate_uses_router and wake_store.body_fallback(message_id):
-                io.log(
-                    "INFO",
-                    f"channel_stdin_proxy_skipped_noise message_id={message_id} "
-                    f"channel={channel} reason=stdin_wake_body_fallback",
-                )
-                continue
             skip_reason = state.message_skip_reason(message)
             if skip_reason:
                 io.log("INFO", f"channel_stdin_proxy_skipped_noise message_id={message_id} channel={channel} reason={skip_reason}")
@@ -213,21 +230,30 @@ def inject_pending_channel_messages(
                 + ":".join(response_mcp.get(key, "") for key in ("server", "tool", "hint"))
             )
             batch_key_base = (
+                ("raw", str(message_id))
+                if message_raw_injection(message)
+                else
                 ("web_chat", web_chat_input_mode(message) + ":" + response_key)
                 if state.message_is_web_chat(message)
                 else ("external_event", str((message.get("meta") or {}).get("receiver_id") or ""))
                 if message_is_external_event(message)
                 else ("channel", "")
             )
-            batch_key = (batch_key_base[0], batch_key_base[1], "router" if candidate_uses_router else "tty")
+            transport_key = (
+                "session_socket"
+                if requested_session_socket
+                else "router" if candidate_uses_router else "tty"
+            )
+            batch_key = (batch_key_base[0], batch_key_base[1], transport_key)
             if pending and pending_batch_key != batch_key:
                 break
-            if not candidate_uses_router and not wake_store.mark_delivered(message_id):
+            if not candidate_uses_router and not wake_store.lifecycle.mark_delivered(message_id):
                 io.log("INFO", f"channel_stdin_proxy_skipped_noise message_id={message_id} channel={channel} reason=stdin_wake_delivered")
                 continue
             pending.append(message)
             pending_batch_key = batch_key
             pending_uses_router = candidate_uses_router
+            pending_uses_session_socket = requested_session_socket
             if event_key:
                 seen_event_keys.add(event_key)
             if candidate_uses_router and len(pending) == 1:
@@ -235,6 +261,11 @@ def inject_pending_channel_messages(
             last_id = message_id
             if len(pending) >= batch_limit:
                 break
+            if not candidate_uses_router:
+                # A TUI/session-socket draft carries exactly one request. This
+                # prevents a later request from being appended to an earlier,
+                # not-yet-confirmed draft.
+                break
         if not pending:
             return last_id
         if pending_uses_router:
@@ -262,17 +293,39 @@ def inject_pending_channel_messages(
                 claimed_ids.append(claim_id)
         submit_bytes = prompts.enter_bytes(enter_bytes)
         try:
-            submitted = io.write_prompt(
-                master_fd,
-                prompt,
-                submit_bytes,
-                submit_retry_count=submit_retry_count,
-                confirm_submit=confirm_submit,
-                bracketed_paste=bracketed_paste,
-                submit_delay_seconds=submit_delay_seconds,
-            )
+            if pending_uses_session_socket:
+                submitted = bool(io.write_session_socket and io.write_session_socket(prompt, pending))
+                if submitted is False and not (active_tool_call or active_turn):
+                    ids = ",".join(str(message.get("id") or "") for message in pending)
+                    io.log(
+                        "WARN",
+                        "channel_stdin_proxy_transport_fallback "
+                        f"message_ids={ids} requested=session_socket fallback=tty "
+                        "reason=session_socket_submit_failed",
+                    )
+                    submitted = io.write_prompt(
+                        master_fd,
+                        prompt,
+                        submit_bytes,
+                        submit_retry_count=submit_retry_count,
+                        confirm_submit=confirm_submit,
+                        bracketed_paste=bracketed_paste,
+                        submit_delay_seconds=submit_delay_seconds,
+                    )
+                    if submitted is not False:
+                        pending_uses_session_socket = False
+            else:
+                submitted = io.write_prompt(
+                    master_fd,
+                    prompt,
+                    submit_bytes,
+                    submit_retry_count=submit_retry_count,
+                    confirm_submit=confirm_submit,
+                    bracketed_paste=bracketed_paste,
+                    submit_delay_seconds=submit_delay_seconds,
+                )
             if submitted is False:
-                wake_store.rollback(pending, claimed_ids)
+                wake_store.lifecycle.fail(pending, claimed_ids, "prompt_not_submitted")
                 ids = ",".join(str(message.get("id") or "") for message in pending)
                 io.log(
                     "WARN",
@@ -280,9 +333,9 @@ def inject_pending_channel_messages(
                     f"message_ids={ids} reason=prompt_not_submitted",
                 )
                 return return_last_id if pending_uses_router else previous_last_id
-            wake_store.record_prompts(pending, prompt)
+            wake_store.lifecycle.record_prompts(pending, prompt)
         except Exception:
-            wake_store.rollback(pending, claimed_ids)
+            wake_store.lifecycle.fail(pending, claimed_ids, "submission_exception")
             raise
         if not web_chat_only:
             if commit_cursor:
@@ -295,6 +348,7 @@ def inject_pending_channel_messages(
             "INFO",
             f"channel_stdin_proxy_injected count={len(pending)} message_ids={ids} "
             f"channels={channels} enter={prompts.enter_label(submit_bytes)} "
+            f"transport={'session_socket' if pending_uses_session_socket else 'router' if pending_uses_router else 'tty'} "
             f"commit_cursor={commit_cursor} "
             f"display_body={bool(pending_uses_router and display_llm_delivery_body)}",
         )

package/ciel_runtime_support/channel_pending_poll.py

@@ -140,7 +140,11 @@ def poll_pending_channel_messages(
         web_chat_only=options.web_chat_only,
         wake_for_llm_delivery=options.wake_for_llm_delivery,
         display_llm_delivery_body=options.display_llm_delivery_body,
-        commit_cursor=False,
+        # A runtime without transcript confirmation (for example Muse Code)
+        # uses a single fire-and-forget TTY write. Persist its cursor in that
+        # same operation; otherwise the generic inflight verifier sees every
+        # successful delivery as "missing" and replays it.
+        commit_cursor=not options.confirm_submit,
         injected_message_ids=injected_ids,
         submit_retry_count=options.submit_retry_count,
         confirm_submit=options.confirm_submit,
@@ -148,7 +152,7 @@ def poll_pending_channel_messages(
         submit_delay_seconds=options.submit_delay_seconds,
         skip_blocking_wake_states=state.inflight_message_id is not None,
     )
-    if injected_ids:
+    if injected_ids and options.confirm_submit:
         state.inflight_message_id = injected_ids[-1]
         state.inflight.attempts += 1
         # The injector deliberately returns the cursor preceding an LLM-delivery

package/ciel_runtime_support/channel_runtime_environment.py

@@ -113,17 +113,6 @@ class ChannelRuntimeEnvironmentPolicy:
             maximum=60.0,
         )
 
-    def windows_wake_max_attempts(self) -> int:
-        """Bound full-prompt attempts before switching to request-body delivery."""
-        return self._bounded_int(
-            self.environment.get(
-                "CIEL_RUNTIME_WINDOWS_CHANNEL_WAKE_MAX_ATTEMPTS"
-            ),
-            default=2,
-            minimum=1,
-            maximum=4,
-        )
-
     @staticmethod
     def inflight_is_stale(
         state: str,

package/ciel_runtime_support/channel_terminal_context.py

@@ -42,7 +42,6 @@ class ChannelTerminalPolicyPorts:
     unseen_retry_seconds: Callable[[], float]
     inflight_is_stale: Callable[..., bool]
     log: Callable[[str, str], None]
-    windows_wake_max_attempts: Callable[[], int]
 
 
 @dataclass(frozen=True, slots=True)
@@ -55,7 +54,6 @@ class ChannelTerminalPollingPorts:
     inject_pending: Callable[..., Any]
     wake_state: Callable[[int], Any]
     inflight_effects: Callable[[], Any]
-    mark_body_fallback: Callable[[int, str], None]
     runtime_interaction: Callable[[], RuntimeInteractionEvent | None] = lambda: None
 
 
@@ -78,7 +76,6 @@ class ChannelTerminalWindowsPorts:
     startup_grace_seconds: Callable[[], float]
     reset_interval_seconds: Callable[[float], float]
     active_turn: Callable[[], bool]
-    write_body_fallback: Callable[[Any, int, bytes], None]
     sleep: Callable[[float], None]
     open_conpty: Callable[[list[str], dict[str, str], Callable[[str, str], None]], Any | None]
 
@@ -121,7 +118,6 @@ class ChannelTerminalContext:
             unseen_retry_seconds=self.policy.unseen_retry_seconds,
             inflight_is_stale=self.policy.inflight_is_stale,
             log=self.policy.log,
-            windows_wake_max_attempts=self.policy.windows_wake_max_attempts,
         )
 
     def polling_services(self) -> ChannelTerminalPolling:
@@ -134,7 +130,6 @@ class ChannelTerminalContext:
             inject_pending=self.polling.inject_pending,
             wake_state=self.polling.wake_state,
             inflight_effects=self.polling.inflight_effects,
-            mark_body_fallback=self.polling.mark_body_fallback,
             runtime_interaction=self.polling.runtime_interaction,
         )
 
@@ -165,7 +160,6 @@ class ChannelTerminalContext:
                 startup_grace_seconds=self.windows.startup_grace_seconds,
                 reset_interval_seconds=self.windows.reset_interval_seconds,
                 active_turn=self.windows.active_turn,
-                write_body_fallback=self.windows.write_body_fallback,
                 sleep=self.windows.sleep,
                 open_conpty=self.windows.open_conpty,
             ),

package/ciel_runtime_support/channel_terminal_proxy.py

@@ -62,7 +62,6 @@ class ChannelTerminalPolicy:
     unseen_retry_seconds: Callable[[], float]
     inflight_is_stale: Callable[..., bool]
     log: Callable[[str, str], None]
-    windows_wake_max_attempts: Callable[[], int]
 
 
 @dataclass(frozen=True)
@@ -75,7 +74,6 @@ class ChannelTerminalPolling:
     inject_pending: Callable[..., Any]
     wake_state: Callable[[int], Any]
     inflight_effects: Callable[[], Any]
-    mark_body_fallback: Callable[[int, str], None]
     runtime_interaction: Callable[[], RuntimeInteractionEvent | None] = lambda: None
 
     def input_busy(self) -> bool:
@@ -100,7 +98,6 @@ class ChannelWindowsConsole:
     startup_grace_seconds: Callable[[], float]
     reset_interval_seconds: Callable[[float], float]
     active_turn: Callable[[], bool]
-    write_body_fallback: Callable[[Any, int, bytes], None]
     sleep: Callable[[float], None]
     open_conpty: Callable[[list[str], dict[str, str], Callable[[str, str], None]], Any | None]
 
@@ -113,15 +110,6 @@ class ChannelWindowsServices:
     console: ChannelWindowsConsole
 
 
-def windows_wake_requires_body_fallback(
-    action: str, attempts: int, maximum_attempts: int
-) -> bool:
-    return bool(
-        action in {"unseen_retry", "stale"}
-        and attempts >= max(1, int(maximum_attempts))
-    )
-
-
 def resolve_posix_child_exit_status(
     proc: Any,
     log: Callable[[str, str], None],
@@ -400,35 +388,8 @@ def run_windows_channel_terminal_proxy(
                 pending_poll_state.last_id = inflight_update.last_id
                 if inflight_update.action == "completed":
                     pending_poll_state.inflight.attempts = 0
-                elif inflight_update.action in {"unseen_retry", "stale"}:
-                    attempts = max(1, pending_poll_state.inflight.attempts)
-                    if windows_wake_requires_body_fallback(
-                        inflight_update.action,
-                        attempts,
-                        policy.windows_wake_max_attempts(),
-                    ):
-                        polling.mark_body_fallback(
-                            inflight_message_id,
-                            f"windows_console_{inflight_update.action}",
-                        )
-                        pending_poll_state.inflight.attempts = 0
-                        policy.log(
-                            "ERROR",
-                            "channel_windows_console_body_fallback "
-                            f"message_id={inflight_message_id} attempts={attempts} "
-                            f"reason={inflight_update.action}",
-                        )
-                        try:
-                            console.write_body_fallback(
-                                writer, inflight_message_id, channel_enter_bytes
-                            )
-                        except Exception as exc:
-                            policy.log(
-                                "ERROR",
-                                "channel_windows_console_body_fallback_wake_failed "
-                                f"message_id={inflight_message_id} "
-                                f"error={type(exc).__name__}: {exc}",
-                            )
+                elif inflight_update.action == "failed":
+                    pending_poll_state.inflight.attempts = 0
             compact_poll_state = poll_pending_compaction(
                 now,
                 writer,
@@ -620,7 +581,7 @@ def run_posix_channel_terminal_proxy(
                         unseen_retry_seconds=policy.unseen_retry_seconds(),
                         waiting_log_interval=30.0,
                         is_stale=policy.inflight_is_stale,
-                        commit_cursor_on_stale=True,
+                        commit_cursor_on_stale=False,
                         log_namespace="channel_stdin_proxy",
                         stale_event="stale_inflight_skipped",
                     ),