@oneciel-ai/ciel-runtime 0.2.37 → 0.2.39

package/ciel_runtime_support/channel_transcript_repository.py

@@ -28,6 +28,7 @@ class ChannelTranscriptRepository:
         *,
         started_at: float | None = None,
         codex_home: Path | None = None,
+        muse_home: Path | None = None,
         cwd: Path | None = None,
         session_id: str | None = None,
     ) -> None:
@@ -40,6 +41,11 @@ class ChannelTranscriptRepository:
             if codex_home is not None
             else None
         )
+        self.scope["muse_home"] = (
+            Path(muse_home).expanduser()
+            if muse_home is not None
+            else None
+        )
         self.scope["cwd"] = Path(cwd).expanduser() if cwd is not None else None
         self.scope["session_id"] = str(session_id or "").strip()
         self.scope["bound_path"] = None
@@ -182,6 +188,13 @@ class ChannelTranscriptRepository:
             else self.home / ".codex"
         )
         codex_root = (codex_home / "sessions", "**/*.jsonl")
+        configured_muse_home = self.scope.get("muse_home")
+        muse_home = (
+            Path(configured_muse_home)
+            if isinstance(configured_muse_home, Path)
+            else self.home / ".local" / "share" / "muse"
+        )
+        muse_root = (muse_home / "sessions", "*/*/*/*/session.jsonl")
         if runtime == "codex":
             return (codex_root,)
         if runtime == "claude":
@@ -191,7 +204,9 @@ class ChannelTranscriptRepository:
                 if project_dir.is_dir():
                     return ((project_dir, "*.jsonl"),)
             return (claude_root,)
-        return claude_root, codex_root
+        if runtime == "muse":
+            return (muse_root,)
+        return claude_root, codex_root, muse_root
 
     def latest(self, ttl_seconds: float = 2.0) -> Path | None:
         now = self.now()

package/ciel_runtime_support/channel_wake_claim_repository.py

@@ -122,25 +122,6 @@ class ChannelWakeClaimRepository:
             self._write_locked(claims)
         return True
 
-    def body_fallback(self, message_id: int) -> bool:
-        if message_id <= 0:
-            return False
-        with self.file_lock():
-            claim = self._read_locked().get(str(message_id))
-        return bool(isinstance(claim, dict) and claim.get("body_fallback"))
-
-    def mark_body_fallback(self, message_id: int, reason: str) -> None:
-        if message_id <= 0:
-            return
-        with self.file_lock():
-            claims = self._read_locked()
-            claims[str(message_id)] = {
-                "claimed_at": self.now(),
-                "body_fallback": True,
-                "reason": str(reason or "windows_console_wake_failed"),
-            }
-            self._write_locked(claims)
-
     def clear(self, message_id: int) -> None:
         if message_id <= 0:
             return

package/ciel_runtime_support/channel_wake_context.py

@@ -134,9 +134,7 @@ class ChannelPendingDeliveryPorts:
     format_standard: Callable[[list[dict[str, Any]]], str]
     enter_label: Callable[[bytes], str]
     release_stale: Callable[[int, bool], None]
-    mark_delivered: Callable[[int], None]
-    record_prompts: Callable[[list[dict[str, Any]], str], None]
-    rollback: Callable[[list[dict[str, Any]], list[int]], None]
+    lifecycle: ChannelWakeDeliveryRepository
     commit_cursor: Callable[[int | None], None]
 
 
@@ -149,6 +147,7 @@ class ChannelPendingIoPorts:
     compact_clear: Callable[[], None]
     messages_path: Path
     log: Callable[[str, str], None]
+    write_session_socket: Callable[[str, list[dict[str, Any]]], bool] | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -195,12 +194,6 @@ class ChannelWakeContext:
     def clear_wake_claim(self, message_id: int) -> None:
         self.claim_repository().clear(message_id)
 
-    def wake_uses_body_fallback(self, message_id: int) -> bool:
-        return self.claim_repository().body_fallback(message_id)
-
-    def mark_wake_body_fallback(self, message_id: int, reason: str) -> None:
-        self.claim_repository().mark_body_fallback(message_id, reason)
-
     def prompt_references_message_id(
         self,
         text: str,
@@ -376,6 +369,7 @@ class ChannelWakeContext:
         *,
         started_at: float | None = None,
         codex_home: Path | None = None,
+        muse_home: Path | None = None,
         cwd: Path | None = None,
         session_id: str | None = None,
     ) -> None:
@@ -383,6 +377,7 @@ class ChannelWakeContext:
             runtime,
             started_at=started_at,
             codex_home=codex_home,
+            muse_home=muse_home,
             cwd=cwd,
             session_id=session_id,
         )
@@ -547,17 +542,15 @@ class ChannelWakeContext:
                 claim_prompt=self.claim_wake_prompt,
                 clear_claim=self.clear_wake_claim,
                 release_stale=self.pending_delivery.release_stale,
-                mark_delivered=self.pending_delivery.mark_delivered,
-                record_prompts=self.pending_delivery.record_prompts,
-                rollback=self.pending_delivery.rollback,
+                lifecycle=self.pending_delivery.lifecycle,
                 commit_cursor=self.pending_delivery.commit_cursor,
-                body_fallback=self.wake_uses_body_fallback,
             ),
             io=ChannelInjectionIO(
                 inject_lock=self.pending_io.inject_lock,
                 read_messages=self.pending_io.read_messages,
                 write_prompt=self.pending_io.write_prompt,
                 log=self.pending_io.log,
+                write_session_socket=self.pending_io.write_session_socket,
             ),
             policy=ChannelInjectionPolicy(
                 wake_batch_limit=self.pending_policy.wake_batch_limit,

package/ciel_runtime_support/channel_wake_delivery_repository.py

@@ -22,6 +22,8 @@ class ChannelWakeDeliveryRepository:
     batches: dict[int, frozenset[int]]
     clear_claim: Callable[[int], None]
     commit_cursor: Callable[[int], None]
+    failed: dict[int, str] | None = None
+    status: Any = None
     retained_limit: int = 1000
     prune_count: int = 500
 
@@ -33,15 +35,30 @@ class ChannelWakeDeliveryRepository:
         with self.lock:
             return message_id in self.delivered
 
+    def failure_reason(self, message_id: int) -> str:
+        with self.lock:
+            memory_reason = str((self.failed or {}).get(message_id) or "")
+        if memory_reason:
+            return memory_reason
+        status = self.status.get(message_id) if self.status is not None else None
+        if isinstance(status, dict) and status.get("status") == "failed":
+            return str(status.get("reason") or "submission_failed")
+        return ""
+
     def release_stale(self, message_id: int, commit_cursor: bool) -> None:
         with self.lock:
             message_ids = self._prompt_group(message_id)
+            if self.failed is None:
+                self.failed = {}
             for grouped_id in sorted(message_ids):
                 self.delivered.discard(grouped_id)
                 self.prompts.pop(grouped_id, None)
                 self.batches.pop(grouped_id, None)
+                self.failed[grouped_id] = "stale_unconfirmed"
+            self._prune(self.failed)
         for grouped_id in sorted(message_ids):
             self.clear_claim(grouped_id)
+            self._transition(grouped_id, "failed", reason="stale_unconfirmed")
         if commit_cursor:
             self.commit_cursor(max(message_ids))
 
@@ -53,6 +70,7 @@ class ChannelWakeDeliveryRepository:
                 self.batches.pop(grouped_id, None)
         for grouped_id in sorted(message_ids):
             self.clear_claim(grouped_id)
+            self._transition(grouped_id, "replied")
 
     def mark_delivered(self, message_id: int) -> bool:
         with self.lock:
@@ -74,6 +92,38 @@ class ChannelWakeDeliveryRepository:
                 self.batches[message_id] = message_ids
             self._prune(self.prompts)
             self._prune(self.batches)
+        for message_id in sorted(message_ids):
+            self._transition(message_id, "submitted")
+
+    def fail(
+        self,
+        messages: list[dict[str, Any]],
+        claimed_ids: list[int],
+        reason: str,
+    ) -> None:
+        message_ids: list[int] = []
+        with self.lock:
+            if self.failed is None:
+                self.failed = {}
+            for message in messages:
+                message_id = _message_id(message)
+                if message_id <= 0:
+                    continue
+                message_ids.append(message_id)
+                self.delivered.discard(message_id)
+                self.prompts.pop(message_id, None)
+                self.batches.pop(message_id, None)
+                self.failed[message_id] = str(reason)
+                self.clear_claim(message_id)
+            self._prune(self.failed)
+        for message_id in claimed_ids:
+            self.clear_claim(message_id)
+        for message_id in sorted(set(message_ids)):
+            self._transition(message_id, "failed", reason=reason)
+
+    def _transition(self, message_id: int, state: str, **kwargs: Any) -> None:
+        if self.status is not None:
+            self.status.transition(message_id, state, **kwargs)
 
     def rollback(
         self, messages: list[dict[str, Any]], claimed_ids: list[int]

package/ciel_runtime_support/chat_http_controller.py

@@ -16,7 +16,7 @@ from typing import Any, Callable
 
 CHAT_FILE_STREAM_CHUNK_BYTES = 1024 * 1024
 CHAT_INPUT_MODES = frozenset({"structured", "tty"})
-CHAT_INPUT_TRANSPORTS = frozenset({"tty", "router"})
+CHAT_INPUT_TRANSPORTS = frozenset({"session_socket", "tty", "router"})
 CHAT_RESPONSE_MODES = frozenset({"web_chat", "tty", "mcp"})
 MCP_HINT_FIELD_LIMITS = {"server": 160, "tool": 240, "hint": 1200}
 
@@ -46,6 +46,8 @@ class ChatHttpReadServices:
     condition: Condition
     safe_segment: Callable[[str, str], str]
     files_dir: Path
+    request_status: Callable[[int], dict[str, Any] | None] = lambda _request_id: None
+    request_statuses: Callable[..., list[dict[str, Any]]] = lambda **_kwargs: []
 
 
 @dataclass(frozen=True, slots=True)
@@ -56,6 +58,7 @@ class ChatHttpWriteServices:
     submit_message: Callable[[dict[str, Any], dict[str, Any]], dict[str, Any]] | None = None
     submit_notify: Callable[[dict[str, Any]], dict[str, Any]] | None = None
     submit_tty: Callable[..., dict[str, Any]] | None = None
+    default_input_transport: Callable[[], str] = lambda: "session_socket"
 
 
 @dataclass(frozen=True, slots=True)
@@ -85,6 +88,29 @@ class ChatHttpController:
         mode = str(value or "").strip().lower().replace("-", "_")
         return aliases.get(mode, mode)
 
+    def _raw_injection(
+        self,
+        handler: BaseHTTPRequestHandler,
+        body: dict[str, Any],
+    ) -> tuple[bool, dict[str, Any] | None]:
+        value = body.get("raw_injection")
+        if value is None:
+            value = self._first(self._params(handler), "raw_injection", "")
+        if value in (None, ""):
+            return False, None
+        if isinstance(value, bool):
+            return value, None
+        normalized = str(value).strip().lower()
+        if normalized in {"1", "true", "yes", "on"}:
+            return True, None
+        if normalized in {"0", "false", "no", "off"}:
+            return False, None
+        return False, {
+            "ok": False,
+            "error": "invalid_raw_injection",
+            "allowed": [True, False],
+        }
+
     def _message_modes(
         self,
         handler: BaseHTTPRequestHandler,
@@ -108,10 +134,16 @@ class ChatHttpController:
 
         requested_transport = body.get("input_transport")
         if requested_transport is None:
-            requested_transport = self._first(params, "input_transport", "") or "tty"
+            requested_transport = (
+                self._first(params, "input_transport", "")
+                or self.writes.default_input_transport()
+            )
         input_transport = self._normalized_mode(
             requested_transport,
             {
+                "socket": "session_socket",
+                "claude_socket": "session_socket",
+                "messaging_socket": "session_socket",
                 "llm": "router",
                 "context": "router",
                 "inband": "router",
@@ -188,10 +220,41 @@ class ChatHttpController:
                     "wait": "/ca/channel/wait" if channel_alias else "/ca/chat/wait",
                     "stream": "/ca/channel/stream" if channel_alias else "/ca/chat/stream",
                     "notify": "/ca/channel/notify",
+                    "request_status": "/ca/channel/requests/{request_id}" if channel_alias else "/ca/chat/requests/{request_id}",
+                    "request_status_events": "/ca/events/stream?category=runtime_input.status",
                     "ownership_note": "External MCP servers are configured and owned by the active CLI.",
                 },
             )
             return True
+        if path == "/ca/chat/requests":
+            params = self._params(handler)
+            try:
+                after = max(0, int(self._first(params, "after", "0") or 0))
+                limit = max(1, min(500, int(self._first(params, "limit", "100") or 100)))
+            except ValueError:
+                self.writes.write_json(handler, {"ok": False, "error": "invalid_request_status_query"}, 400)
+                return True
+            rows = self.reads.request_statuses(
+                after_request_id=after,
+                status=self._first(params, "status", ""),
+                limit=limit,
+            )
+            self.writes.write_json(handler, {"ok": True, "requests": rows})
+            return True
+        if path.startswith("/ca/chat/requests/"):
+            raw_id = path[len("/ca/chat/requests/") :]
+            try:
+                request_id = int(raw_id)
+            except ValueError:
+                self.writes.write_json(handler, {"ok": False, "error": "invalid_request_id"}, 400)
+                return True
+            status = self.reads.request_status(request_id)
+            self.writes.write_json(
+                handler,
+                {"ok": status is not None, "request": status},
+                200 if status is not None else 404,
+            )
+            return True
         if path in ("/ca/chat/messages", "/ca/chat/wait"):
             return self._messages(handler, path)
         if path == "/ca/chat/stream":
@@ -332,6 +395,10 @@ class ChatHttpController:
         if path == "/ca/chat/notify":
             return self._notify(handler, body)
         if path == "/ca/chat/messages":
+            raw_injection, raw_error = self._raw_injection(handler, body)
+            if raw_error is not None:
+                self.writes.write_json(handler, raw_error, 400)
+                return True
             input_mode, input_transport, response_mode, response_mcp, error = self._message_modes(
                 handler, body
             )
@@ -347,6 +414,7 @@ class ChatHttpController:
             meta["injection_mode"] = input_mode
             meta["input_transport"] = input_transport
             meta["response_mode"] = response_mode
+            meta["raw_injection"] = raw_injection
             if response_mode == "web_chat":
                 admitted_body.setdefault("channel", "default")
                 admitted_body.setdefault("thread_id", admitted_body["channel"])
@@ -372,7 +440,7 @@ class ChatHttpController:
                     if response_mode == "web_chat"
                     else None
                 )
-                message = (
+                runtime_message = (
                     self.writes.submit_tty(admitted_body, public_message)
                     if public_message is not None
                     else self.writes.submit_tty(admitted_body)
@@ -384,14 +452,19 @@ class ChatHttpController:
                         "input_mode": "tty",
                         "input_transport": input_transport,
                         "response_mode": response_mode,
+                        "raw_injection": raw_injection,
                         "injection_mode": "tty",
-                        "message": public_message or message,
+                        "message": public_message or runtime_message,
+                        "request_id": runtime_message.get("id"),
+                        "request": self.reads.request_status(int(runtime_message.get("id") or 0))
+                        or {"request_id": runtime_message.get("id"), "status": "queued"},
                     },
                 )
                 return True
             message = self.writes.append_message(admitted_body)
+            runtime_message = None
             if self.writes.submit_message is not None and _delivery_requests_llm(admitted_body):
-                self.writes.submit_message(message, admitted_body)
+                runtime_message = self.writes.submit_message(message, admitted_body)
             self.writes.write_json(
                 handler,
                 {
@@ -399,8 +472,18 @@ class ChatHttpController:
                     "input_mode": "structured",
                     "input_transport": input_transport,
                     "response_mode": response_mode,
+                    "raw_injection": raw_injection,
                     "injection_mode": "web_chat",
                     "message": message,
+                    **(
+                        {
+                            "request_id": runtime_message.get("id"),
+                            "request": self.reads.request_status(int(runtime_message.get("id") or 0))
+                            or {"request_id": runtime_message.get("id"), "status": "queued"},
+                        }
+                        if isinstance(runtime_message, dict)
+                        else {}
+                    ),
                 },
             )
             return True

package/ciel_runtime_support/claude_environment.py

@@ -13,6 +13,7 @@ import re
 from typing import Any, Callable
 
 from .architecture import ProviderRuntimeCompactionPolicy
+from .anthropic_model_policy import defaults_to_one_million_context
 
 
 CLAUDE_PROJECTED_ENV_KEYS = (
@@ -37,10 +38,34 @@ CLAUDE_PROJECTED_ENV_KEYS = (
     "ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTS",
     "ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTED_CAPABILITIES",
     "CLAUDE_CODE_SUBAGENT_MODEL",
+    "CLAUDE_CODE_SUBAGENT_MODEL_FORCE",
     "CIEL_RUNTIME_MODEL_ALIAS",
     "CIEL_RUNTIME_PROVIDER",
 )
 CLAUDE_AUTO_COMPACT_WINDOW_MAX = 1_000_000
+ANTHROPIC_STANDARD_CONTEXT_TOKENS = 200_000
+
+
+def anthropic_routed_mode(
+    provider: str,
+    config: dict[str, Any],
+) -> bool:
+    routed = config.get("route_through_router") is True or str(
+        config.get("route_through_router") or ""
+    ).strip().lower() in {"1", "true", "yes", "on"}
+    return provider == "anthropic" and routed
+
+
+def anthropic_routed_standard_context(
+    provider: str,
+    config: dict[str, Any],
+) -> bool:
+    model = str(config.get("current_model") or "").strip().lower()
+    return (
+        anthropic_routed_mode(provider, config)
+        and "[1m]" not in model
+        and not defaults_to_one_million_context(model)
+    )
 
 
 @dataclass(frozen=True)
@@ -89,6 +114,8 @@ class ClaudeLimitPolicy:
     ) -> ClaudeCompactionSnapshot:
         configured = self._ports.positive_int(config.get("auto_compact_window"))
         limit = self._ports.context_limit(provider, config)
+        if anthropic_routed_standard_context(provider, config):
+            limit = min(limit or ANTHROPIC_STANDARD_CONTEXT_TOKENS, ANTHROPIC_STANDARD_CONTEXT_TOKENS)
         if configured:
             window = min(
                 configured,
@@ -181,7 +208,23 @@ class ClaudeModelAliasPolicy:
         *,
         context_limit: int | None = None,
     ) -> str:
+        original_model = str(model or "")
+        original_upstream = str(upstream_model or "")
         model = self._ports.strip_context_suffix(model)
+        if anthropic_routed_mode(provider, config):
+            current_model = str(config.get("current_model") or "")
+            context_candidates = [original_model, original_upstream]
+            if upstream_model is None:
+                context_candidates.append(current_model)
+            explicit_one_million = any(
+                "[1m]" in candidate.lower() for candidate in context_candidates
+            )
+            documented_one_million = any(
+                defaults_to_one_million_context(candidate)
+                for candidate in context_candidates
+                if candidate
+            )
+            return f"{model}[1m]" if explicit_one_million or documented_one_million else model
         probe_model = upstream_model if upstream_model is not None else model
         include_current = upstream_model is None
         claims_one_million = self.claims_one_million_context(
@@ -202,6 +245,28 @@ class ClaudeModelAliasPolicy:
             return False
         return bool(re.search(rf"(?:^|[-_./]){re.escape(family)}(?:[-_./]|$)", normalized))
 
+    def routed_model_alias(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        model: str,
+        *,
+        context_limit: int | None = None,
+    ) -> str:
+        upstream = self._ports.normalize_model_id(provider, model)
+        alias = self._ports.alias_for(provider, upstream)
+        current_upstream = self._ports.normalize_model_id(
+            provider,
+            self._ports.current_upstream_model(provider, config),
+        )
+        return self.context_model_alias(
+            provider,
+            config,
+            alias,
+            None if upstream == current_upstream else upstream,
+            context_limit=context_limit,
+        )
+
     def default_model_aliases(
         self,
         provider: str,
@@ -233,7 +298,21 @@ class ClaudeModelAliasPolicy:
             if not selected and self.matches_family(current_upstream, family):
                 selected = current_upstream
             if not selected:
-                selected = next((item for item in candidates if self.matches_family(item, family)), "")
+                family_candidates = [
+                    item for item in candidates if self.matches_family(item, family)
+                ]
+                if provider == "anthropic":
+                    selected = next(
+                        (
+                            item
+                            for item in family_candidates
+                            if "[1m]" in item.lower()
+                            and defaults_to_one_million_context(item)
+                        ),
+                        "",
+                    )
+                if not selected:
+                    selected = next(iter(family_candidates), "")
             alias = self._ports.alias_for(provider, selected) if selected else current_model_alias
             result[key] = self.context_model_alias(
                 provider,
@@ -413,6 +492,17 @@ class ClaudeEnvironmentProjection:
             claude_model,
             context_limit=context_limit,
         )
+        configured_subagent = str(provider_config.get("subagent_model") or "").strip()
+        subagent_model = (
+            self._aliases.routed_model_alias(
+                provider,
+                provider_config,
+                configured_subagent,
+                context_limit=context_limit,
+            )
+            if configured_subagent
+            else claude_model
+        )
         env = {
             "CIEL_RUNTIME_PROVIDER": provider,
             "ANTHROPIC_BASE_URL": self._router_base,
@@ -423,10 +513,12 @@ class ClaudeEnvironmentProjection:
             "ANTHROPIC_DEFAULT_HAIKU_MODEL": defaults["ANTHROPIC_DEFAULT_HAIKU_MODEL"],
             "ANTHROPIC_DEFAULT_OPUS_MODEL": defaults["ANTHROPIC_DEFAULT_OPUS_MODEL"],
             "ANTHROPIC_DEFAULT_SONNET_MODEL": defaults["ANTHROPIC_DEFAULT_SONNET_MODEL"],
-            "CLAUDE_CODE_SUBAGENT_MODEL": claude_model,
+            "CLAUDE_CODE_SUBAGENT_MODEL": subagent_model,
             "CIEL_RUNTIME_MODEL_ALIAS": claude_model,
             "CIEL_RUNTIME_BYPASS_PERMISSIONS": "1",
         }
+        if configured_subagent:
+            env["CLAUDE_CODE_SUBAGENT_MODEL_FORCE"] = "1"
         auth_token = self._features.router_auth_token(provider, provider_config)
         if auth_token:
             env["ANTHROPIC_AUTH_TOKEN"] = auth_token
@@ -445,7 +537,12 @@ class ClaudeRuntimeSettingsPolicy:
         self._ports = ports
 
     def settings(self, provider: str, config: dict[str, Any]) -> dict[str, Any]:
-        return {"ultracode": True} if self._ports.ultracode_enabled(provider, config) else {}
+        settings: dict[str, Any] = {}
+        if self._ports.ultracode_enabled(provider, config):
+            settings["ultracode"] = True
+        if config.get("_ciel_session_socket_enabled") is True:
+            settings["crossSessionInbound"] = "accept"
+        return settings
 
     def append_args(
         self,

package/ciel_runtime_support/claude_launch_assembly.py

@@ -95,6 +95,8 @@ class ClaudeLaunchDeliveryPorts:
     wake_submit_delay_seconds: Callback
     wake_submit_retries: Callback
     set_transcript_scope: Callback
+    prepare_session_socket: Callback
+    configure_session_socket: Callback
 
 
 @dataclass(frozen=True, slots=True)
@@ -189,6 +191,8 @@ class ClaudeLaunchAssembly:
                 channel_wake_submit_delay_seconds=self.delivery.wake_submit_delay_seconds,
                 channel_wake_submit_retries=self.delivery.wake_submit_retries,
                 set_channel_transcript_scope=self.delivery.set_transcript_scope,
+                prepare_session_socket=self.delivery.prepare_session_socket,
+                configure_session_socket=self.delivery.configure_session_socket,
             ),
             mcp_config=runtime_launch.ClaudeLaunchMcpConfig(
                 write_duckduckgo_mcp_config=self.mcp_config.write_duckduckgo,