@@ -1000,6 +1000,7 @@ const larkTopicEventRejectionReasons = [
   "binding_unavailable",
   "chat_mismatch",
   "topic_mismatch",
+  "route_ambiguous",
   "self_message",
   "invalid_routing_state",
   "not_addressed",
 
@@ -87,11 +87,15 @@ function larkConnectionHealth(connection: LarkGoalConnection): { label: string;
   }
   if (
     connection.health_error_code === "lark_event_route_mismatch"
-    || ["chat_mismatch", "topic_mismatch"].includes(connection.last_event_reason ?? "")
+    || ["chat_mismatch", "topic_mismatch", "route_ambiguous"].includes(connection.last_event_reason ?? "")
   ) {
     return {
-      label: "消息未匹配当前 Goal Topic",
-      detail: "事件来自其他群聊或 Topic。请重新选择群聊并连接该 Goal，然后发送一条新的 @ 消息。",
+      label: connection.last_event_reason === "route_ambiguous"
+        ? "消息匹配多个 Goal"
+        : "消息未匹配当前 Goal Topic",
+      detail: connection.last_event_reason === "route_ambiguous"
+        ? "同一 Bot 和群聊存在多个完整群捕获连接。请让每个 Agent 使用独立 Bot，或只保留一个完整群连接。"
+        : "事件来自其他群聊或 Topic。请重新选择群聊并连接该 Goal，然后发送一条新的 @ 消息。",
       ready: false,
     };
   }
 
@@ -86,7 +86,12 @@ configuration or host state and must not enter public LoopX packets.
 `capture_scope` defaults to `addressed_only` for compatibility. Drain output
 reports `thread_complete=false` and a coverage warning for that mode. For
 `configured_chat_all`, the collector's jq filter should select the configured
-chat only; do not add a content-level `@bot` predicate.
+chat only; do not add a content-level `@bot` predicate. A Goal Topic root is
+presentation and reply context, not an additional ingress filter for
+`configured_chat_all`: new topics and replies in the same configured chat must
+remain visible to the bound Agent. When more than one chat-wide Goal route is
+eligible for the same Bot target, routing fails closed instead of choosing one
+by iteration order.
 
 Optional source-thread replies are a separate, default-off boundary. Bind an
 explicit non-default bot profile to the same local-private chat. An
@@ -297,8 +302,13 @@ and interprets the source event before deciding the durable effect or reply; the
 summary is a scheduling signal, not semantic authority.
 
 For a direct question, explicit bot mention, or verified reply to the configured
-bot, write the requested durable effect first, preview one concise source-thread
-reply, execute it, require readback, and only then ACK:
+bot, write the requested durable effect first, preview one concise reply,
+execute it, require readback, and only then ACK. New Goal Topic inbox configs use
+`reply.placement_policy=source_context`: a top-level chat request receives a new
+top-level chat response, while an event already inside a topic receives a reply
+inside that source topic. Existing configs without the field retain the legacy
+`source_thread` policy. `reply.editorial_style=bullet_points_preferred` projects
+an operator hint for structured replies; the command preserves line breaks.
 
 ```bash
 loopx lark-inbox reply \
@@ -315,10 +325,10 @@ loopx lark-inbox reply \
   --execute
 ```
 
-The command uses an idempotency key derived from the source message and reply
-text, sends with `--reply-in-thread`, and reads the created message back through
-the same configured profile. Lifecycle reactions are removed only after that
-readback succeeds. A sent reply whose reaction cleanup fails returns
+The command uses an idempotency key derived from the source message, resolved
+placement, and reply text, then reads the created message back through the same
+configured profile. Lifecycle reactions are removed only after that readback
+succeeds. A sent reply whose reaction cleanup fails returns
 `sent_verified_cleanup_pending`; retry `lark-inbox reaction-complete` before
 acknowledging the source:
 
 
@@ -21,6 +21,8 @@
 SAFE_PROFILE_PATTERN = re.compile(r"[A-Za-z0-9._-]{1,100}")
 CHAT_ID_PATTERN = re.compile(r"oc_[A-Za-z0-9_-]+")
 REACTION_EMOJI_PATTERN = re.compile(r"[A-Za-z0-9_]{1,64}")
+REPLY_PLACEMENT_POLICIES = {"source_thread", "source_context"}
+REPLY_EDITORIAL_STYLES = {"concise", "bullet_points_preferred"}
 LARK_OPERATOR_INBOX_SOURCE_CONTRACT = OperatorInboxSourceContract(
     config_schema_version=CONFIG_SCHEMA_VERSION,
     event_schema_version=EVENT_SCHEMA_VERSION,
@@ -91,6 +93,18 @@ def load_lark_event_inbox_config(
         str(reply_payload.get("bot_display_name") or "").split()
     )[:100]
     chat_id = str(reply_payload.get("chat_id") or "").strip()
+    placement_policy = str(
+        reply_payload.get("placement_policy") or "source_thread"
+    ).strip()
+    editorial_style = str(reply_payload.get("editorial_style") or "concise").strip()
+    if placement_policy not in REPLY_PLACEMENT_POLICIES:
+        raise ValueError(
+            "lark inbox placement_policy must be source_thread or source_context"
+        )
+    if editorial_style not in REPLY_EDITORIAL_STYLES:
+        raise ValueError(
+            "lark inbox editorial_style must be concise or bullet_points_preferred"
+        )
     received_reaction_emoji = str(
         reply_payload.get("received_reaction_emoji") or ""
     ).strip()
@@ -141,6 +155,8 @@ def load_lark_event_inbox_config(
             "sender_identity": sender_identity,
             "bot_display_name": bot_display_name,
             "chat_id": chat_id,
+            "placement_policy": placement_policy,
+            "editorial_style": editorial_style,
             "received_reaction_emoji": received_reaction_emoji,
             "processing_reaction_emoji": processing_reaction_emoji,
         },
@@ -384,6 +400,10 @@ def inspect_lark_event_inbox(
         "configured": True,
         "capture_scope": config["capture_scope"],
         "thread_complete": config["thread_complete"],
+        "reply_guidance": {
+            "placement_policy": config["reply"]["placement_policy"],
+            "editorial_style": config["reply"]["editorial_style"],
+        },
         "coverage_warning": (
             None
             if config["thread_complete"]
@@ -401,7 +421,8 @@ def inspect_lark_event_inbox(
             "For an actionable item, first run `loopx lark-inbox processing` for "
             "its message_id, then translate it into a todo, vision correction, PR "
             "update, or no-follow-up rationale. Send and verify any required reply "
-            "before acknowledging the message_id. If no reply is required, run "
+            "before acknowledging the message_id. Follow reply_guidance for "
+            "placement and editorial style. If no reply is required, run "
             "`loopx lark-inbox reaction-complete` before acknowledging it."
         ),
     }
 
@@ -99,6 +99,7 @@ class LarkTopicEventDecisionReason(str, Enum):
     BINDING_UNAVAILABLE = "binding_unavailable"
     CHAT_MISMATCH = "chat_mismatch"
     TOPIC_MISMATCH = "topic_mismatch"
+    ROUTE_AMBIGUOUS = "route_ambiguous"
     SELF_MESSAGE = "self_message"
     INVALID_ROUTING_STATE = "invalid_routing_state"
     NOT_ADDRESSED = "not_addressed"
@@ -825,6 +826,7 @@ def list_lark_connections(
                 "binding_unavailable",
                 "chat_mismatch",
                 "topic_mismatch",
+                "route_ambiguous",
             }
         ):
             event_blocker = "lark_event_route_mismatch"
@@ -1034,7 +1036,7 @@ def decide_lark_topic_event(
         }
     has_binding = False
     matched_chat = False
-    matched_topic = False
+    candidates: list[dict[str, Any]] = []
     for goal_id, payload in binding_payloads.items():
         binding = binding_for_goal(payload, goal_id)
         if not binding or binding.get("enabled") is not True:
@@ -1045,27 +1047,14 @@ def decide_lark_topic_event(
         if target is None:
             continue
         channel = target.get("channel") if isinstance(target.get("channel"), Mapping) else {}
+        if str(channel.get("chat_id") or "") != chat_id:
+            continue
+        matched_chat = True
         identity = target.get("identity") if isinstance(target.get("identity"), Mapping) else {}
         topic = binding.get("topic") if isinstance(binding.get("topic"), Mapping) else {}
         binding_channel = binding.get("channel") if isinstance(binding.get("channel"), Mapping) else {}
         topic_root = str(topic.get("root_message_id") or binding_channel.get("pinned_message_id") or "")
         routing = binding.get("routing") if isinstance(binding.get("routing"), Mapping) else {}
-        if str(channel.get("chat_id") or "") != chat_id:
-            continue
-        matched_chat = True
-        if topic_root != root_id:
-            continue
-        matched_topic = True
-        sender_id = str(event.get("sender_id") or "")
-        if sender_id and sender_id in {
-            str(identity.get("bot_app_id") or ""),
-            str(identity.get("bot_open_id") or ""),
-        }:
-            return {
-                "matched": False,
-                "reason": LarkTopicEventDecisionReason.SELF_MESSAGE.value,
-                "route": None,
-            }
         try:
             capture_scope = _routing_value(
                 CaptureScope,
@@ -1108,57 +1097,103 @@ def decide_lark_topic_event(
                 "reason": LarkTopicEventDecisionReason.INVALID_ROUTING_STATE.value,
                 "route": None,
             }
-        if capture_scope != "configured_chat_all" and not is_event_addressed_to_bot(
-            event, identity
-        ):
-            return {
-                "matched": False,
-                "reason": LarkTopicEventDecisionReason.NOT_ADDRESSED.value,
-                "route": None,
+        candidates.append(
+            {
+                "goal_id": goal_id,
+                "binding": binding,
+                "identity": identity,
+                "target_ref": target_ref,
+                "topic_root": topic_root,
+                "capture_scope": capture_scope,
+                "ingress_mode": ingress_mode,
+                "reply_mode": reply_mode,
+                "routing": routing,
+                "connector": connector,
             }
-        route = {
-            "app_ref": str(identity.get("sender_profile") or "default"),
-            "goal_id": goal_id,
-            "message_id": message_id,
-            "reply_mode": reply_mode,
-            "target_ref": target_ref,
-            "topic_root_message_id": topic_root,
+        )
+
+    exact_topic_candidates = [
+        candidate for candidate in candidates if candidate["topic_root"] == root_id
+    ]
+    eligible = exact_topic_candidates or [
+        candidate
+        for candidate in candidates
+        if candidate["capture_scope"] == CaptureScope.CONFIGURED_CHAT_ALL.value
+    ]
+    if len(eligible) > 1:
+        return {
+            "matched": False,
+            "reason": LarkTopicEventDecisionReason.ROUTE_AMBIGUOUS.value,
+            "route": None,
         }
-        if ingress_mode != "direct_session" or binding.get("agent_id"):
-            route.update(
-                {
-                    "agent_id": str(binding.get("agent_id") or ""),
-                    "session_id": str(binding.get("session_id") or ""),
-                    "capture_scope": capture_scope,
-                    "ingress_mode": ingress_mode,
-                    "inbox_config_ref": str(routing.get("inbox_config_ref") or ""),
-                    **(
-                        {"connector": dict(connector)}
-                        if isinstance(connector, Mapping)
-                        else {}
-                    ),
-                    **(
-                        {"event_id": str(event.get("event_id") or message_id)}
-                        if isinstance(connector, Mapping)
-                        else {}
-                    ),
-                }
-            )
+    if not eligible:
+        reason = (
+            LarkTopicEventDecisionReason.BINDING_UNAVAILABLE
+            if not has_binding
+            else LarkTopicEventDecisionReason.CHAT_MISMATCH
+            if not matched_chat
+            else LarkTopicEventDecisionReason.TOPIC_MISMATCH
+        )
+        return {"matched": False, "reason": reason.value, "route": None}
+
+    selected = eligible[0]
+    identity = selected["identity"]
+    sender_id = str(event.get("sender_id") or "")
+    if sender_id and sender_id in {
+        str(identity.get("bot_app_id") or ""),
+        str(identity.get("bot_open_id") or ""),
+    }:
+        return {
+            "matched": False,
+            "reason": LarkTopicEventDecisionReason.SELF_MESSAGE.value,
+            "route": None,
+        }
+    capture_scope = str(selected["capture_scope"])
+    if capture_scope != CaptureScope.CONFIGURED_CHAT_ALL.value and not is_event_addressed_to_bot(
+        event, identity
+    ):
         return {
-            "matched": True,
-            "reason": LarkTopicEventDecisionReason.MATCHED.value,
-            "route": route,
+            "matched": False,
+            "reason": LarkTopicEventDecisionReason.NOT_ADDRESSED.value,
+            "route": None,
         }
-    reason = (
-        LarkTopicEventDecisionReason.BINDING_UNAVAILABLE
-        if not has_binding
-        else LarkTopicEventDecisionReason.CHAT_MISMATCH
-        if not matched_chat
-        else LarkTopicEventDecisionReason.TOPIC_MISMATCH
-        if not matched_topic
-        else LarkTopicEventDecisionReason.BINDING_UNAVAILABLE
-    )
-    return {"matched": False, "reason": reason.value, "route": None}
+    binding = selected["binding"]
+    ingress_mode = str(selected["ingress_mode"])
+    routing = selected["routing"]
+    connector = selected["connector"]
+    route = {
+        "app_ref": str(identity.get("sender_profile") or "default"),
+        "goal_id": str(selected["goal_id"]),
+        "message_id": message_id,
+        "reply_mode": str(selected["reply_mode"]),
+        "target_ref": str(selected["target_ref"]),
+        "topic_root_message_id": str(selected["topic_root"]),
+    }
+    if ingress_mode != IngressMode.DIRECT_SESSION.value or binding.get("agent_id"):
+        route.update(
+            {
+                "agent_id": str(binding.get("agent_id") or ""),
+                "session_id": str(binding.get("session_id") or ""),
+                "capture_scope": capture_scope,
+                "ingress_mode": ingress_mode,
+                "inbox_config_ref": str(routing.get("inbox_config_ref") or ""),
+                **(
+                    {"connector": dict(connector)}
+                    if isinstance(connector, Mapping)
+                    else {}
+                ),
+                **(
+                    {"event_id": str(event.get("event_id") or message_id)}
+                    if isinstance(connector, Mapping)
+                    else {}
+                ),
+            }
+        )
+    return {
+        "matched": True,
+        "reason": LarkTopicEventDecisionReason.MATCHED.value,
+        "route": route,
+    }
 
 
 def route_lark_topic_event(
 
@@ -169,6 +169,23 @@ def _topic_roots_for_target(
     return roots
 
 
+def _binding_payloads_for_target(
+    binding_payloads: Mapping[str, Any], *, target_ref: str
+) -> dict[str, Mapping[str, Any]]:
+    selected: dict[str, Mapping[str, Any]] = {}
+    for goal_id, payload in binding_payloads.items():
+        if not isinstance(payload, Mapping):
+            continue
+        binding = binding_for_goal(payload, str(goal_id))
+        if (
+            binding
+            and binding.get("enabled") is True
+            and str(binding.get("target_ref") or "") == target_ref
+        ):
+            selected[str(goal_id)] = payload
+    return selected
+
+
 def _event_payloads(stdout: Any) -> list[Mapping[str, Any]]:
     events: list[Mapping[str, Any]] = []
     for line in str(stdout or "").splitlines():
@@ -266,11 +283,10 @@ def poll_lark_goal_topic_profile_once(
         try:
             event_result = process_lark_goal_topic_event(
                 target_payload=target_payload,
-                binding_payloads={
-                    str(goal_id): payload
-                    for goal_id, payload in binding_payloads.items()
-                    if isinstance(payload, Mapping)
-                },
+                binding_payloads=_binding_payloads_for_target(
+                    binding_payloads,
+                    target_ref=target_ref,
+                ),
                 event=routed_event,
                 runtime_root=runtime_root,
                 goal_contexts=(
@@ -766,6 +782,8 @@ def _inbox_config(
             "sender_identity": "bot",
             "bot_display_name": bot_display_name,
             "chat_id": chat_id,
+            "placement_policy": "source_context",
+            "editorial_style": "bullet_points_preferred",
         },
     }
     config_path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)