feat(chat): project the steward channel's session mode and status (#4483)

Admin-bypass merge with the temporary gate bypass the owner authorized for this lane.

Merged head: `610b9d86baf6b3b5693ce7978e9a1a344a542194`

Why the bypass is needed here: the account is the PR author, so GitHub refuses a formal self-approval and the required formal review can never be satisfied on this branch. The equivalence check was published instead as a `COMMENTED` review carrying the full bilingual review body, and the capability validated its shape and verdict (`pull_request_review_conclusion_v0`: `valid=true`, `verdict=APPROVE`, no invalid reasons).

Evidence at the merged head:

- `loopx canary premerge --from-git-diff --goal-id loopx-meta` → `passed`, 11 selected checks, 0 failures, 0 manual holds, `merge_gate_passed=true`, `self_merge_allowed=true`
- change-quality receipt `cqr_cc7041812e4ceb7c5644` → `state=valid` for scope fingerprint `cc7041812e4ceb7c5644227c131915c52a99401192c400d8d9873feddcfcb2e7` (8 changed files)
- `pytest` focused steward suite → 122 passed
- `examples/loopx-steward-channel-binding-smoke.py` → passed, including the new `mode_readback` probe
- `ruff check` clean; `examples/docs-governance-smoke.py` ok; `examples/semantic-vocabulary-drift-smoke.py` ok
- falsification: making the projector derive `managed_runtime` for a channel with no Session fails `test_a_channel_without_a_session_reads_as_unbound`

Delivery boundary recorded in the PR: the dashboard chip does not render the new fields yet, because that changes the app's first viewport and needs an owner preview.

Honest gap: the repository CI workflow was still running at merge time (12 jobs still pending after a bounded wait, 0 failing). The owner's standing instruction for this lane is not to idle on CI, so the remaining GitHub checks were not awaited; they can still be read on the merged commit.

Author: huangruiteng

docs/architecture/rfcs/harness-selection-dsh-pi-v0.md

@@ -401,7 +401,7 @@ operator-local path is recorded here.
 | Manager M2 — semantic continuation | Receiver resolution across registered running lanes; typed per-source coverage and freshness; a goal-level milestone the report can lead with instead of coverage disclaimers | Not implemented. Delegation resolves against the supplied delegation catalog, so a request whose owning lane is absent from that catalog is refused or routed to an unrelated lane; a provider read failure surfaces as raw error text instead of a typed source row; the manager context exposes deliveries and coverage but no goal-level milestone field to synthesize from |
 | Manager M3 — automatic complete exchange | A persisted answer that exceeds or violates the channel's outbound text contract is split and re-sent under a stable answer identity; an ambiguous or failed send is reconciled instead of replaced by a local notice; the return path survives a transport restart; rich markdown renders as structured text | Partially mitigated. `loopx/extensions/lark/outbound.py` fails closed on an over-limit or malformed payload, and the channel reports that local failure without re-delivering the persisted answer; one answer carries no idempotency identity, so a retry can duplicate it; structured rendering is not guaranteed |
 | Host modes M0-M1 | The channel's executor selection and its bounded one-segment execution | Selection is covered by PR #4446 and the Turn-side selection by PR #4443; bounded one-segment execution is covered by the Mode B acceptance above. The channel itself now reaches the managed host through the segment transport, so the managed host's own one-segment execution is reachable from the channel; what remains open is that the segment is not a session, so cross-turn host continuity is still not offered |
-| Host modes M2-M3 | Attached-host parity, typed unavailability, and mode-aware projection with no mode inference and no second executor | Partly shipped: the channel's managed segment transport holds one executor per binding, refuses a second start with the typed `managed_host_chat_segment_in_flight`, and discards an interrupted segment's answer instead of letting it enter visible history. Still not implemented: attached-host parity, and an external audience still degrades to `restricted`, while the channel projects neither its mode nor its session status |
+| Host modes M2-M3 | Attached-host parity, typed unavailability, and mode-aware projection with no mode inference and no second executor | Partly shipped: the channel's managed segment transport holds one executor per binding, refuses a second start with the typed `managed_host_chat_segment_in_flight`, and discards an interrupted segment's answer instead of letting it enter visible history. The channel readback also carries the mode-aware projection: it quotes the Session's own `session_mode` and `status`, reads a channel with no Session as `unbound`, and names a mode outside the closed set as `unrecognized` instead of deriving a mode from the executor it resolved. Still not implemented: attached-host parity, and an external audience still degrades to `restricted` |
 
 Two boundaries stay fixed across all five rows. The channel remains an entry point
 and projection of one manager Session: it owns no profile, no permission state, no

docs/architecture/rfcs/harness-selection-dsh-pi-v0.zh-CN.md

@@ -324,7 +324,7 @@ operator 凭据上，且管家通道自身不存在任何默认指向个人订
 | 管家 M2 — 语义续接 | 跨所有已注册运行中 lane 的接收者解析；按来源的 typed 覆盖与新鲜度；报告可以先用目标级里程碑开头，而不是先给覆盖免责声明 | 未实现。委托只按传入的委托目录解析，因此拥有该事项的 lane 不在目录中时会被拒绝或投给无关 lane；provider 读取失败以原始错误文本出现在回答里，而不是 typed 来源行；管家上下文只提供交付与覆盖，没有可综合的目标级里程碑字段 |
 | 管家 M3 — 自动完成一次交流 | 超出或违反通道出站文本契约的已保存回答，按稳定答案身份分片重发；含糊或失败的发送要协调而不是用本地提示替代；回传路径要能跨传输重启存活；富文本要渲染成结构化文本 | 部分缓解。`loopx/extensions/lark/outbound.py` 在超限或载荷不合法时 fail closed，通道只回报这个本地失败、不重新投递已保存的回答；一条回答没有幂等身份，重试可能重复发送；结构化渲染没有保证 |
 | 宿主模式 M0-M1 | 通道的执行器选型与其有界单段执行 | 选型由 PR #4446 覆盖，Turn 侧选型由 PR #4443 覆盖；有界单段执行由上面的 Mode B 验收覆盖。通道本身现在经单段传输抵达托管宿主，因此托管宿主自己的单段执行已可从通道抵达；仍未提供的是跨 turn 宿主连续性——片段不是会话 |
-| 宿主模式 M2-M3 | attached-host 对齐、typed 不可用，以及不做模式推断、不引入第二执行器的模式感知投影 | 部分已实现：通道的托管段传输为每个绑定只保留一个执行器，第二次启动以 typed `managed_host_chat_segment_in_flight` 拒绝，被中断段的回答会被丢弃而不会进入可见历史。仍未实现：attached-host 对齐；外部受众仍降级为 `restricted`，通道既不投影模式也不投影会话状态 |
+| 宿主模式 M2-M3 | attached-host 对齐、typed 不可用，以及不做模式推断、不引入第二执行器的模式感知投影 | 部分已实现：通道的托管段传输为每个绑定只保留一个执行器，第二次启动以 typed `managed_host_chat_segment_in_flight` 拒绝，被中断段的回答会被丢弃而不会进入可见历史。通道读回也带上了模式感知投影：引用 Session 自己的 `session_mode` 与 `status`，没有 Session 的通道读作 `unbound`，闭集之外的模式命名为 `unrecognized`，而不是从已解析的执行器反推模式。仍未实现：attached-host 对齐；外部受众仍降级为 `restricted` |
 
 五行的两条边界固定不变：通道始终是同一个 manager Session 的入口与投影，不拥有
 profile、权限状态、第二执行器或工作权威，因此更丰富的回答契约不得扩大通道可读或

examples/loopx-steward-channel-binding-smoke.py

@@ -23,6 +23,10 @@
     MANAGER_ENDPOINT_SOURCE_EXPLICIT_CONFIG,
     MANAGER_MODEL_SOURCE_MANAGED_PROFILE,
     MANAGER_MODEL_SOURCE_VENDOR_DEFAULT,
+    MANAGER_CHANNEL_SESSION_MODE_SOURCE_READBACK,
+    MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNBOUND,
+    MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNRECOGNIZED,
+    manager_channel_session_mode_readback,
     manager_channel_binding,
     manager_executor_endpoint_default,
     manager_model_config,
@@ -233,11 +237,51 @@ def open_session(self, **kwargs):
     return str(opened[-1]["agent_id"])
 
 
+def _assert_mode_readback_quotes_the_session() -> dict[str, object]:
+    """The channel reports the mode it serves, and derives none on its own."""
+
+    unbound = manager_channel_binding({CREDENTIAL_ENV: CREDENTIAL_VALUE})
+    _assert(
+        unbound["executor_kind"] == "managed"
+        and unbound["session_mode"] is None
+        and unbound["session_mode_source"]
+        == MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNBOUND,
+        "a ready managed endpoint is not evidence that the channel is bound",
+    )
+    attached = manager_channel_binding(
+        {CREDENTIAL_ENV: CREDENTIAL_VALUE},
+        session={"session_mode": "attached_host", "status": "busy"},
+    )
+    _assert(
+        attached["session_mode"] == "attached_host"
+        and attached["session_status"] == "busy"
+        and attached["session_mode_source"]
+        == MANAGER_CHANNEL_SESSION_MODE_SOURCE_READBACK,
+        "the channel must quote the Session's own mode, not the executor it resolved",
+    )
+    unrecognized = manager_channel_session_mode_readback(
+        {"session_mode": "hybrid_handoff", "status": "ready"}
+    )
+    _assert(
+        unrecognized["session_mode"] is None
+        and unrecognized["session_mode_source"]
+        == MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNRECOGNIZED,
+        "a mode outside the closed set must be named rather than coerced",
+    )
+    return {
+        "unbound_session_mode_source": unbound["session_mode_source"],
+        "quoted_session_mode": attached["session_mode"],
+        "quoted_session_status": attached["session_status"],
+        "unrecognized_session_mode_source": unrecognized["session_mode_source"],
+    }
+
+
 def main() -> int:
     payload = {
         "ok": True,
         "credential_default_probe": _assert_credential_decides_the_disclosed_default(),
         "explicit_selection": _assert_explicit_selection_and_managed_host_verdict(),
+        "mode_readback": _assert_mode_readback_quotes_the_session(),
         "opened_endpoint": _assert_session_opens_the_resolved_endpoint(),
     }
     print(json.dumps(payload, ensure_ascii=False, indent=2))

loopx/chat_manager.py

@@ -4,7 +4,7 @@
 
 import hashlib
 from pathlib import Path
-from typing import Any
+from typing import Any, Mapping
 
 from .control_plane.operator_credential import (
     env_text,
@@ -19,6 +19,11 @@
     MANAGED_TURN_HOST,
     managed_executor_binding,
 )
+from .chat_store import (
+    CHAT_SESSION_MODE_ATTACHED,
+    CHAT_SESSION_MODE_MANAGED,
+    RESUMABLE_SESSION_STATES,
+)
 
 MANAGER_AGENT_GOAL_ID = "loopx-manager"
 MANAGER_AGENT_OBJECTIVE = (
@@ -207,8 +212,83 @@ def manager_executor_endpoint_default(environ: dict[str, str] | None = None) ->
     return selected_manager_executor_endpoint(environ)[0]
 
 
+# The channel's readback quotes the mode and the status of the Session it is an
+# entry point to. The execution-mode RFC makes the binding, not the endpoint,
+# the transport or the audience, the unit of mode ownership, so this projection
+# never derives a mode from the executor it resolved: a channel whose managed
+# endpoint is ready and whose Session does not exist is *unbound*, not
+# `managed_runtime`. A mode outside the closed set is named as unrecognized
+# rather than coerced into a mode the host may not have chosen.
+MANAGER_CHANNEL_SESSION_MODE_SOURCE_READBACK = "session_readback"
+MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNBOUND = "unbound"
+MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNRECOGNIZED = "unrecognized"
+MANAGER_CHANNEL_SESSION_MODES = (
+    CHAT_SESSION_MODE_MANAGED,
+    CHAT_SESSION_MODE_ATTACHED,
+)
+
+
+def manager_channel_session_mode_readback(
+    session: Mapping[str, Any] | None,
+) -> dict[str, Any]:
+    """Quote the channel Session's own mode and status into the channel readback.
+
+    ``session`` is the store's public Session projection for this channel, or
+    ``None`` when the channel has none. The mode and the status are copied and
+    only the source of the mode is decided here, so a reader can tell a quoted
+    mode from an unbound channel instead of re-deriving the rule.
+    """
+
+    if session is None:
+        return {
+            "session_mode": None,
+            "session_mode_source": MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNBOUND,
+            "session_status": None,
+        }
+    session_mode = str(session.get("session_mode") or "")
+    if session_mode not in MANAGER_CHANNEL_SESSION_MODES:
+        return {
+            "session_mode": None,
+            "session_mode_source": (
+                MANAGER_CHANNEL_SESSION_MODE_SOURCE_UNRECOGNIZED
+            ),
+            "session_status": None,
+        }
+    return {
+        "session_mode": session_mode,
+        "session_mode_source": MANAGER_CHANNEL_SESSION_MODE_SOURCE_READBACK,
+        "session_status": str(session.get("status") or "") or None,
+    }
+
+
+def manager_channel_session(
+    store: Any,
+    *,
+    channel_id: str | None = None,
+    provider: str = "",
+    audience: str = "",
+) -> dict[str, Any] | None:
+    """Return the Session this channel would resume, or ``None``.
+
+    One channel is one ordered conversation, so the readback quotes its newest
+    resumable Session. The store owns which states are resumable and projects
+    the Session publicly; this function only selects, so the channel readback
+    cannot widen what a Session exposes.
+    """
+
+    selected_channel = channel_id or manager_channel(
+        provider=provider, audience=audience
+    )
+    for row in store.list_sessions(channel_id=selected_channel):
+        if str(row.get("status") or "") in RESUMABLE_SESSION_STATES:
+            return dict(row)
+    return None
+
+
 def manager_channel_binding(
     environ: dict[str, str] | None = None,
+    *,
+    session: Mapping[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Project the steward channel's resolved executor, model, and their source.
 
@@ -224,6 +304,11 @@ def manager_channel_binding(
     A managed endpoint quotes the governed Turn surface's own executor readback
     for that verdict instead of deriving a second one, so the channel can never
     advertise an executor the Turn driver would refuse.
+
+    ``session`` is the channel's public Session projection, when the caller has
+    one. Its mode and status are quoted so a frontend can show which execution
+    mode is serving the channel, and an absent Session reads as unbound rather
+    than as a mode this projection guessed.
     """
 
     endpoint, endpoint_source, default_reason = _resolve_manager_endpoint(environ)
@@ -252,6 +337,7 @@ def manager_channel_binding(
         "unavailable_reason": unavailable_reason,
         "model": model,
         "model_source": model_source,
+        **manager_channel_session_mode_readback(session),
     }
 
 

loopx/chat_server.py

@@ -32,7 +32,8 @@
 from .chat_runtime import ChatRuntimeController, TERMINAL_TURN_STATES
 from .chat_manager import (
     MANAGER_AGENT_GOAL_ID, MANAGER_AGENT_OBJECTIVE, is_manager_channel,
-    manager_channel_binding, manager_workspace, manager_model_config,
+    manager_channel_binding, manager_channel_session, manager_workspace,
+    manager_model_config,
 )
 from .chat_session_open import open_chat_session
 from .chat_ssh_source_api import SshSourceRequestMixin
@@ -1260,7 +1261,9 @@ def do_GET(self) -> None:
                 "schema_version": "loopx_chat_capabilities_v1",
                 "manager": manager_runtime_capability_projection(
                     self.server.runtime_controller, manager_model_config(),
-                    channel_binding=manager_channel_binding()),
+                    channel_binding=manager_channel_binding(
+                        session=manager_channel_session(self.server.chat_store)
+                    )),
                 "runtime_identity": release_runtime_identity(),
                 "agent_backend": "multi_adapter",
                 "sandbox": "read-only",

loopx/semantics/inventory_v0.json

@@ -904,7 +904,7 @@
     "python_closed_sets": 492,
     "python_literal_aliases": 8,
     "typescript_const_arrays": 40,
-    "named_string_constants": 2051,
+    "named_string_constants": 2054,
     "schema_version_names": 756,
     "schema_version_same_runtime_forks": 7,
     "cross_runtime_twins": 166,

tests/test_chat_server_cors.py

@@ -3,6 +3,7 @@
 import errno
 import http.client
 import json
+import tempfile
 import threading
 from pathlib import Path
 
@@ -11,6 +12,7 @@
 from loopx.chat_action_store import ChatActionStore
 from loopx.chat_actions import ChatActionService
 from loopx.chat_server import ChatHTTPServer, ChatRequestHandler
+from loopx.chat_store import ChatSessionStore
 from loopx.control_plane.effect_runtime import (
     EffectRuntimePermanentIOError,
     EffectRuntimeStartupError,
@@ -25,6 +27,9 @@ def _start_server() -> tuple[ChatHTTPServer, threading.Thread]:
     server.selected_goal_id = None
     server.registry_path = Path("/tmp/loopx-test-registry.json")
     server.runtime_root_override = None
+    # The capabilities readback quotes the steward channel's Session, so a
+    # fixture server carries the store the real startup always installs.
+    server.chat_store = ChatSessionStore(Path(tempfile.mkdtemp()) / "runtime")
     server.scan_roots = []
     server.limit = 20
     server.runtime_controller = _RuntimeController()