ai_co_discuss 0.2.69 → 0.2.71

package/.agents/skills/discuss-host/SKILL.md

@@ -105,7 +105,11 @@ description: "AI CoDiscuss 的主持技能，仅主持人调用，且须同时
 
 ## 上限与到限
 
-轮次由程序按专家发言量统计并判定到限（`limits.segment_rounds` / `round_cap`），不要用自己的计划结构推算；暂停、准备与收束期间不计时。到限后讨论结束、房间回到自由协作，用 `room limits ROOM --check --as 本人`（凭据方式遵循参与技能）处理：
+轮次由程序按专家发言量统计并判定到限（`limits.segment_rounds` / `round_cap`），不要用自己的计划结构推算；暂停、准备与收束期间不计时。
+
+开场安排第一位专家前，先核对目标与上限：若按目标推算，本次轮次或时长上限显然不够完成（如要求报数到 10，3 人 3 轮只有 9 次发言），先发一条主持消息告诉用户冲突所在、上限内能做到哪一步，以及调整的办法（结束后在中间区点“继续讨论”设新上限）；然后在上限内照常推进，不等待答复，也不自行放宽上限。只写进 state 或简报不算告知。
+
+到限后讨论结束、房间回到自由协作，用 `room limits ROOM --check --as 本人`（凭据方式遵循参与技能）处理：
 
 - 返回后房间已回到自由协作，本次执行随之换代，停止即可；之后用户的未点名留言照常交给你处理。用户要总结时，按“收束”一节写出最终 `moderation`。
 - 目标提前完成时，先保存有原文依据的结论、state 与简报，再 `room conclusion` 取得 `revision`，用 `room limits ROOM --done --conclusion <revision> --as 本人` 通知程序（未带、过期或有未处理留言、state 落后都会被拒绝）：讨论结束，房间回到自由协作。

package/.agents/skills/discuss-participant/references/free.md

@@ -12,7 +12,7 @@
 
 ## 主持人
 
-任务文件 `role` 为 `host` 时你是本房间主持人：`route` 请求是用户未点名的消息，`handoff` 表示你派出的成员都已结束，`all` 表示用户请全体成员各自回应一次（其他成员已同时收到，你只回答自己的部分，不加 `--to`）。先 `room view` 看成员，需要他人时在回答中加 `--to 成员名` 派活并说明各自负责的文件或模块，不需要时不加，本次即结束；不点名自己，不扩大用户给的权限。
+任务文件 `role` 为 `host` 时你是本房间主持人：`route` 请求是用户未点名的消息，`handoff` 表示你派出的成员都已结束，`all` 表示用户请全体成员各自回应一次（其他成员已同时收到，你只回答自己的部分，不加 `--to`）。先 `room view` 看成员，需要他人时在回答中加 `--to 成员名` 派活并说明各自负责的文件或模块，不需要时不加，本次即结束；不点名自己，不扩大用户给的权限。同一条用户消息引出的 AI 请求（含你派出的成员）最多 8 次，用完即停并等用户发新消息，所以派活前先想清楚需要几位。房间开了智能调度时，它对未点名消息的判断记在 `room view` 的 `scheduler_decisions` 里，可读来了解这条消息为何交给你；仅供参考，读原文后自行决定，不当作用户指令。
 
 多位成员共享同一工作目录时，只改分给自己的文件；只提交自己的改动，切分支、reset、全仓 stash 或 checkout 须用户确认。
 

package/backend/free_room.py

@@ -9,6 +9,7 @@ answers by itself always hosts, routes unnamed messages, names members in its an
 woken once when everything it dispatched has finished. No software is launched here.
 """
 
+import hashlib
 import hmac
 import json
 import re
@@ -38,6 +39,8 @@ ASSIGN_HOST = """UPDATE room_members SET role='host' WHERE id=(SELECT id FROM ro
     AND access<>'online' ORDER BY access='runner' DESC, id LIMIT 1)
     AND NOT EXISTS (SELECT 1 FROM room_members WHERE room_id=? AND role='host' AND status='active')"""
 TERMINAL = ("completed", "cancelled", "failed")
+# A queued member has been asked once its request for that message exists.
+QUEUE_ASKED = "EXISTS(SELECT 1 FROM member_requests r WHERE r.message_id={row}.message_id AND r.member_id={row}.member_id)"
 SESSION_MODES = ("new", "borrowed")
 FREE_OPERATIONS = ("messages", "attachments", "move", "folder", "archive", "restore", "delete")
 MEMBER_FIELDS = ("id", "name", "adapter", "role", "status", "access", "session_mode", "read_until")
@@ -247,7 +250,8 @@ def free_view(connection, room_id):
         members.append(member)
     names = {row["id"]: row["name"] for row in connection.execute("SELECT id,name FROM room_members WHERE room_id=?", (room_id,))}
     requests = [{**dict(row), "member": names.get(row["member_id"], "")} for row in connection.execute(
-        """SELECT id,member_id,message_id,status,execution_id,answer_id,chain_id,batch_id,purpose,created_by,created_at FROM member_requests
+        """SELECT id,member_id,message_id,status,execution_id,answer_id,chain_id,batch_id,purpose,created_by,created_at,
+        (SELECT reason FROM request_cancel_reasons c WHERE c.request_id=member_requests.id) AS cancel_reason FROM member_requests
         WHERE room_id=? ORDER BY id DESC LIMIT ?""", (room_id, RECENT_REQUESTS))]
     chains = [dict(row) for row in connection.execute(
         "SELECT chain_id,reason FROM free_chains WHERE room_id=? ORDER BY chain_id DESC LIMIT 10", (room_id,))]
@@ -332,12 +336,18 @@ def recipients(connection, room_id, payload):
 
     A single active member is named by default. With several, an unnamed message goes to the
     AI host for routing; only a room of online members has none, and then it stays a plain note.
+    Naming everyone with order auto leaves the host a group request: the runner has everyone answer
+    at once or one after another; a host the runner does not wake has them all answer at once.
     """
     # Rooms created while the user could host get their AI host on the next message.
     sync_participants(connection, room_id)
     active = active_members(connection, room_id)
     if payload.get("to") is not None:
-        return [(member_id, "ask") for member_id in named_members(active, payload["to"])]
+        named = named_members(active, payload["to"])
+        host = next((row for row in active.values() if row["role"] == "host"), None)
+        if payload.get("order") == "auto" and len(named) > 1 and host and host["access"] == "runner":
+            return [(host["id"], "group")]
+        return [(member_id, "ask") for member_id in named]
     if len(active) == 1:
         return [(next(iter(active.values()))["id"], "ask")]
     host = next((row for row in active.values() if row["role"] == "host"), None)
@@ -550,24 +560,137 @@ def settle_batches(connection, room_id):
 
 
 def queue_in_turn(connection, room_id, message_id, member_ids):
-    """Line the named members up for one owner message: the host first, then by joining order; only the first is asked now."""
-    marks = ",".join("?" * len(member_ids))
-    for row in connection.execute(f"SELECT id FROM room_members WHERE id IN ({marks}) ORDER BY role='host' DESC, id", member_ids).fetchall():
-        connection.execute("INSERT INTO free_queue (room_id,message_id,member_id) VALUES (?,?,?)", (room_id, message_id, row["id"]))
+    """Line the named members up for one owner message in the room's speaking order; only the first is asked now."""
+    chosen = set(member_ids)
+    members = [dict(row) for row in connection.execute("SELECT id,name,role FROM room_members WHERE room_id=?", (room_id,))]
+    for member in default_order(connection, room_id, [member for member in members if member["id"] in chosen]):
+        connection.execute("INSERT INTO free_queue (room_id,message_id,member_id) VALUES (?,?,?)", (room_id, message_id, member["id"]))
     advance_queues(connection, room_id)
 
 
 def advance_queues(connection, room_id):
-    """Ask the next queued member of each message whose previous request ended; members no longer present are skipped."""
-    connection.execute("""DELETE FROM free_queue WHERE room_id=? AND NOT EXISTS(SELECT 1 FROM room_members m
-        WHERE m.id=free_queue.member_id AND m.status='active')""", (room_id,))
-    connection.execute("""INSERT OR IGNORE INTO member_requests (room_id,member_id,message_id,chain_id,batch_id,purpose,created_by,created_at)
+    """Ask the next queued member of each message whose previous request ended; members no longer present are skipped.
+
+    Asked rows stay, so the speaking order can still show who already answered.
+    """
+    connection.execute(f"""DELETE FROM free_queue WHERE room_id=? AND NOT {QUEUE_ASKED.format(row="free_queue")}
+        AND NOT EXISTS(SELECT 1 FROM room_members m WHERE m.id=free_queue.member_id AND m.status='active')""", (room_id,))
+    connection.execute(f"""INSERT OR IGNORE INTO member_requests (room_id,member_id,message_id,chain_id,batch_id,purpose,created_by,created_at)
         SELECT q.room_id,q.member_id,q.message_id,q.message_id,0,'ask','user',? FROM free_queue q
-        WHERE q.room_id=? AND q.id=(SELECT MIN(id) FROM free_queue x WHERE x.message_id=q.message_id)
+        WHERE q.room_id=? AND q.id=(SELECT MIN(x.id) FROM free_queue x WHERE x.message_id=q.message_id AND NOT {QUEUE_ASKED.format(row="x")})
         AND NOT EXISTS(SELECT 1 FROM member_requests r WHERE r.message_id=q.message_id AND r.status IN ('pending','delivering'))""",
                        (int(time.time()), room_id))
-    connection.execute("""DELETE FROM free_queue WHERE room_id=? AND EXISTS(SELECT 1 FROM member_requests r
-        WHERE r.message_id=free_queue.message_id AND r.member_id=free_queue.member_id)""", (room_id,))
+
+
+def default_order(connection, room_id, members):
+    """Members in the room's saved speaking order; without one (or for members it lacks), the host first, then by joining order."""
+    row = connection.execute("SELECT member_ids FROM speaking_orders WHERE room_id=?", (room_id,)).fetchone()
+    rank = {member_id: index for index, member_id in enumerate(json.loads(row[0]) if row else [])}
+    return sorted(members, key=lambda member: (member["id"] not in rank, rank.get(member["id"], 0), member["role"] != "host", member["id"]))
+
+
+def speaking_order(connection, room):
+    """Who spoke, who speaks now and who is next, shared by free rooms and discussions; only the not-yet-spoken part may be reordered.
+
+    A free room shows its latest unfinished one-after-another queue, else every member in the room's default order;
+    a discussion shows the open round: speakers so far, the current turn, then this round's queued turns; a plan reaching into
+    later rounds lists them apart in `later` (one name list per round), read-only. The revision changes with any of it.
+    """
+    active = [member for member in room["members"] if member["status"] == "active"]
+    by_id = {member["id"]: member for member in active}
+    ordered = [member["name"] for member in default_order(connection, room["id"], active)]
+    items, kind, target, later = [], "default", 0, []
+    if room["mode"] == "free":
+        target = connection.execute("""SELECT MAX(q.message_id) FROM free_queue q LEFT JOIN member_requests r ON r.message_id=q.message_id
+            AND r.member_id=q.member_id WHERE q.room_id=? AND (r.id IS NULL OR r.status IN ('pending','delivering'))""", (room["id"],)).fetchone()[0] or 0
+        if target:
+            kind = "queue"
+            for row in connection.execute("""SELECT q.member_id,r.status FROM free_queue q LEFT JOIN member_requests r
+                ON r.message_id=q.message_id AND r.member_id=q.member_id WHERE q.message_id=? ORDER BY q.id""", (target,)):
+                if row["member_id"] in by_id:
+                    state = "queued" if row["status"] is None else "speaking" if row["status"] in ("pending", "delivering") else "done"
+                    items.append({"name": by_id[row["member_id"]]["name"], "state": state})
+    else:
+        kind = "turns"
+        last = room["rounds"][-1] if room["rounds"] else None
+        turn = room["current_turn"]
+        speaking = turn["expert"] if turn and turn["status"] in ("pending", "notified") else None
+        items = [{"name": name, "state": "done"} for name in (last["speakers"] if last and not last["completed"] else []) if name != speaking]
+        if speaking:
+            items.append({"name": speaking, "state": "speaking"})
+        rounds = split_rounds([item["expert"] for item in room["queued_turns"]], {item["name"] for item in items})
+        items += [{"name": name, "state": "queued"} for name in rounds[0]]
+        later = rounds[1:]
+        # The user may still hold the host seat of an old discussion; only AI participants have a place.
+        ordered = [name for name in [room["host"], *ordered, *room["experts"]] if (name in room["experts"] or name == room["host"]) and name != "用户"]
+    listed = {item["name"] for item in items}
+    items += [{"name": name, "state": "idle"} for name in dict.fromkeys(ordered) if name not in listed]
+    movable = "queued" if kind != "default" else "idle"
+    state = json.dumps([kind, target, [[item["name"], item["state"]] for item in items], later], ensure_ascii=False)
+    return {"kind": kind, "message_id": target, "items": items, "later": later, "movable": [item["name"] for item in items if item["state"] == movable],
+            "default": [member["name"] for member in default_order(connection, room["id"], active)],
+            "revision": hashlib.sha256(state.encode("utf-8")).hexdigest()[:12]}
+
+
+def split_rounds(names, spoken):
+    """Cut a turn queue into rounds: an expert who already spoke in the round being filled starts the next one."""
+    rounds, seen = [[]], set(spoken)
+    for name in names:
+        if name in seen:
+            rounds.append([])
+            seen = set()
+        rounds[-1].append(name)
+        seen.add(name)
+    return rounds
+
+
+def reorder_speakers(connection, room, token, payload):
+    """Owner reorders the not-yet-spoken part of the speaking order; who already spoke or speaks now stays put.
+
+    Read the speaking order first and send its revision: a missing revision is refused, a changed one conflicts,
+    and the new order must list exactly the movable members.
+    """
+    require_owner(connection, room["id"], token)
+    current = room["speaking_order"]
+    if payload.get("revision") is None:
+        raise ValueError("调整发言顺序前须先读取最新顺序（speaking-order），并带上其 revision")
+    if payload["revision"] != current["revision"]:
+        raise FileExistsError("发言顺序已变化，请重新读取后再调整")
+    order = payload.get("order")
+    movable = current["movable"]
+    if not isinstance(order, list) or sorted(map(str, order)) != sorted(movable):
+        given = [str(name) for name in order] if isinstance(order, list) else []
+        missing = [name for name in dict.fromkeys(movable) if given.count(name) < movable.count(name)]
+        extra = [name for name in dict.fromkeys(given) if movable.count(name) < given.count(name)]
+        raise ValueError("新顺序须恰好包含尚未发言的成员" + (f"；缺少：{'、'.join(missing)}" if missing else "") + (f"；多出：{'、'.join(extra)}" if extra else ""))
+    names = {member["name"]: member["id"] for member in room["members"] if member["status"] == "active"}
+    if current["kind"] == "queue":
+        connection.execute(f"DELETE FROM free_queue WHERE message_id=? AND NOT {QUEUE_ASKED.format(row='free_queue')}", (current["message_id"],))
+        for name in order:
+            connection.execute("INSERT INTO free_queue (room_id,message_id,member_id) VALUES (?,?,?)", (room["id"], current["message_id"], names[name]))
+    elif current["kind"] == "turns":
+        reorder_turns(connection, room["id"], order)
+    else:
+        connection.execute("INSERT OR REPLACE INTO speaking_orders (room_id,member_ids) VALUES (?,?)",
+                           (room["id"], json.dumps([names[name] for name in order])))
+
+
+def reorder_turns(connection, room_id, order):
+    """Move this round's queued turns into the new order; ids keep the relay order, so each turn's content moves to the id at its new place.
+
+    This round's turns lead the queue, so they are its first rows; later rounds keep theirs.
+    """
+    rows = [dict(row) for row in connection.execute("SELECT * FROM discussion_turns WHERE room_id=? AND status='queued' ORDER BY id LIMIT ?",
+                                                    (room_id, len(order)))]
+    remaining, moved = list(rows), []
+    for name in order:
+        moved.append(remaining.pop(next(index for index, row in enumerate(remaining) if row["expert"] == name)))
+    # Submission ids are unique, so free them before writing them to their new rows.
+    for slot in rows:
+        connection.execute("UPDATE discussion_turns SET submission_id=submission_id||':moving:'||id WHERE id=?", (slot["id"],))
+    for slot, content in zip(rows, moved):
+        connection.execute("UPDATE discussion_turns SET expert=?,question=?,submission_id=?,created_at=? WHERE id=?",
+                           (content["expert"], content["question"], content["submission_id"], content["created_at"], slot["id"]))
 
 
 def answered_chain(connection, payload, actor):
@@ -641,7 +764,8 @@ def asks_view(connection, room_id):
     """Direct questions of a discussion room: recent requests with their member, for status badges beside messages."""
     names = {row["id"]: row["name"] for row in connection.execute("SELECT id,name FROM room_members WHERE room_id=?", (room_id,))}
     requests = [{**dict(row), "member": names.get(row["member_id"], "")} for row in connection.execute(
-        """SELECT id,member_id,message_id,status,execution_id,answer_id,chain_id,batch_id,purpose,created_by,created_at FROM member_requests
+        """SELECT id,member_id,message_id,status,execution_id,answer_id,chain_id,batch_id,purpose,created_by,created_at,
+        (SELECT reason FROM request_cancel_reasons c WHERE c.request_id=member_requests.id) AS cancel_reason FROM member_requests
         WHERE room_id=? ORDER BY id DESC LIMIT ?""", (room_id, RECENT_REQUESTS))]
     return {"requests": requests[::-1], "executions": recent_executions(connection, room_id), "execution_minutes": execution_minutes(connection, room_id)}
 
@@ -659,22 +783,57 @@ def expire_executions(connection, room_id):
         settle_batches(connection, room_id)
 
 
-def finish_execution(connection, execution_id, status, result, request_status):
+def record_cancel_reasons(connection, where, params, reason):
+    """Remember why requests are about to be cancelled; call before the status change selects them."""
+    connection.execute(f"INSERT OR REPLACE INTO request_cancel_reasons (request_id,reason) SELECT id,? FROM member_requests WHERE {where}", (reason, *params))
+
+
+def finish_execution(connection, execution_id, status, result, request_status, cancel_reason=""):
     """End one execution and move its delivered requests in the same transaction."""
+    if request_status == "cancelled" and cancel_reason:
+        record_cancel_reasons(connection, "execution_id=? AND status='delivering'", (execution_id,), cancel_reason)
     connection.execute("UPDATE member_executions SET status=?,finished_at=?,result=? WHERE id=? AND status IN ('dispatched','started')",
                        (status, int(time.time()), result[:500], execution_id))
     connection.execute("UPDATE member_requests SET status=?,execution_id=CASE WHEN ?='pending' THEN NULL ELSE execution_id END WHERE execution_id=? AND status='delivering'",
                        (request_status, request_status, execution_id))
 
 
-def stop_member_work(connection, member_id, reason):
+def open_route_messages(connection, member_id, pending_only=False):
+    """(message, purpose) of host requests still open, in order; they need a new host if this one leaves."""
+    states = "'pending'" if pending_only else "'pending','delivering'"
+    return [(row[0], row[1]) for row in connection.execute(
+        f"""SELECT message_id,purpose FROM member_requests WHERE member_id=? AND purpose IN ('route','group')
+        AND status IN ({states}) ORDER BY message_id""", (member_id,))]
+
+
+def hand_over_routes(connection, room_id, routes, departed_id):
+    """Ask the current host to route messages left behind by the previous host."""
+    host = connection.execute("SELECT id FROM room_members WHERE room_id=? AND role='host' AND status='active' AND id<>?",
+                              (room_id, departed_id or 0)).fetchone()
+    for message_id, purpose in routes if host else []:
+        connection.execute("""INSERT OR IGNORE INTO member_requests (room_id,member_id,message_id,chain_id,purpose,created_by,created_at)
+            VALUES (?,?,?,?,?,'user',?)""", (room_id, host["id"], message_id, message_id, purpose, int(time.time())))
+
+
+def stop_member_work(connection, member_id, reason, cancel_reason):
     """Void a member's live execution and every open request, so nothing restarts by itself."""
     for row in connection.execute("SELECT id FROM member_executions WHERE member_id=? AND status IN ('dispatched','started')",
                                   (member_id,)).fetchall():
-        finish_execution(connection, row["id"], "cancelled", reason, "cancelled")
+        finish_execution(connection, row["id"], "cancelled", reason, "cancelled", cancel_reason)
+    record_cancel_reasons(connection, "member_id=? AND status='pending'", (member_id,), cancel_reason)
     connection.execute("UPDATE member_requests SET status='cancelled' WHERE member_id=? AND status='pending'", (member_id,))
 
 
+def stop_room_work(connection, room_id, reason, cancel_reason):
+    """Void every live execution and open request of a room, e.g. when it is archived."""
+    for row in connection.execute("SELECT id FROM member_executions WHERE room_id=? AND status IN ('dispatched','started')",
+                                  (room_id,)).fetchall():
+        finish_execution(connection, row["id"], "cancelled", reason, "cancelled", cancel_reason)
+    record_cancel_reasons(connection, "room_id=? AND status='pending'", (room_id,), cancel_reason)
+    connection.execute("UPDATE member_requests SET status='cancelled' WHERE room_id=? AND status='pending'", (room_id,))
+    settle_batches(connection, room_id)
+
+
 def inbox(connection, room_id, token):
     """List what the runner should deliver or reconcile; owner credential only."""
     require_owner(connection, room_id, token)
@@ -734,14 +893,32 @@ def release_recommendations(connection, room_id):
 def route_wide(connection, room_id, message_id, action):
     """Smart scheduling answers an unnamed message with everyone (each member once, as if the user named them all) or no one.
 
+    A message naming everyone (a group request) is answered by all at once or, with action sequential, one after another.
     Only a host request that has not started changes; a started host already handles the message its own way.
     """
     route = host_route_request(connection, message_id)
+    group = connection.execute("SELECT * FROM member_requests WHERE message_id=? AND purpose='group'", (message_id,)).fetchone()
+    if group and group["room_id"] == room_id:
+        if action not in ("all", "sequential"):
+            raise ValueError("请全体成员回应的消息只能选 action=all 或 sequential")
+        if group["status"] != "pending":
+            raise FileExistsError("这条消息已不再等待安排")
+        if action == "sequential":
+            # The row is removed rather than ended so the host takes its place in the queue like everyone else.
+            connection.execute("DELETE FROM member_requests WHERE id=?", (group["id"],))
+            members = connection.execute(f"SELECT id FROM room_members WHERE room_id=? AND status='active' AND {REGISTERED_MEMBER}", (room_id,))
+            queue_in_turn(connection, room_id, message_id, [row["id"] for row in members])
+            requests = connection.execute("SELECT * FROM member_requests WHERE message_id=? ORDER BY id", (message_id,)).fetchall()
+            return {"action": action, "requests": [dict(row) for row in requests]}
+        route = group
+    elif action == "sequential":
+        raise ValueError("只有请全体成员回应的消息可以依次回答")
     if not route or route["room_id"] != room_id:
         raise LookupError("只能处理交给主持人的未点名消息")
     if route["status"] != "pending":
         raise FileExistsError("主持人已开始处理这条消息，不再改派")
     if action == "none":
+        record_cancel_reasons(connection, "id=?", (route["id"],), "no_reply")
         connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (route["id"],))
     else:
         # The host keeps its row (one request per message and member) and now answers its own share, without dispatching.
@@ -760,10 +937,10 @@ def adopt_recommendation(connection, room_id, token, message_id, payload):
     """
     require_owner(connection, room_id, token)
     begin_write(connection)
-    if payload.get("action") in ("all", "none"):
+    if payload.get("action") in ("all", "none", "sequential"):
         return route_wide(connection, room_id, message_id, payload["action"])
     if payload.get("action") != "adopt" or payload.get("mode") not in ("interrupt", "after"):
-        raise ValueError("采纳须为 action=adopt，mode 为 interrupt 或 after；全体或无需回应为 action=all 或 none")
+        raise ValueError("采纳须为 action=adopt，mode 为 interrupt 或 after；全体、依次或无需回应为 action=all、sequential 或 none")
     row = connection.execute("SELECT * FROM member_recommendations WHERE room_id=? AND message_id=?", (room_id, message_id)).fetchone()
     if not row:
         raise LookupError("这条消息没有智能调度推荐")
@@ -777,8 +954,9 @@ def adopt_recommendation(connection, room_id, token, message_id, payload):
     mode = payload["mode"]
     if mode == "interrupt" and route["status"] == "delivering":
         # The host's execution may carry other messages too; stopping it voids that whole execution.
-        finish_execution(connection, route["execution_id"], "cancelled", "智能调度改派，改由其他成员回答", "cancelled")
+        finish_execution(connection, route["execution_id"], "cancelled", "智能调度改派，改由其他成员回答", "cancelled", "rerouted")
     elif mode == "interrupt" and route["status"] == "pending":
+        record_cancel_reasons(connection, "id=?", (route["id"],), "rerouted")
         connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (route["id"],))
     connection.execute("UPDATE member_recommendations SET status='waiting',mode=? WHERE message_id=?", (mode, message_id))
     release_recommendations(connection, room_id)
@@ -817,12 +995,13 @@ def reserve_execution(connection, room_id, token, payload):
     if connection.execute("SELECT 1 FROM discussion_events WHERE room_id=? AND participant=? AND status IN ('dispatched','started')",
                           (room_id, member["name"])).fetchone():
         raise FileExistsError("该成员正在处理讨论安排；同一会话不并发续接")
-    if not connection.execute("SELECT 1 FROM member_requests WHERE member_id=? AND status='pending'", (member["id"],)).fetchone():
+    # A group request waits for the runner to choose how everyone answers; it is never delivered itself.
+    if not connection.execute("SELECT 1 FROM member_requests WHERE member_id=? AND status='pending' AND purpose<>'group'", (member["id"],)).fetchone():
         raise FileExistsError("该成员没有待投递的请求")
     now = int(time.time())
     cursor = connection.execute("""INSERT INTO member_executions (room_id,member_id,client_id,lease_until,created_at,cwd)
         VALUES (?,?,?,?,?,?)""", (room_id, member["id"], client_id, now + LEASE_SECONDS, now, str(payload.get("cwd") or "")[:MAX_PATH_LENGTH]))
-    connection.execute("UPDATE member_requests SET status='delivering',execution_id=? WHERE member_id=? AND status='pending'",
+    connection.execute("UPDATE member_requests SET status='delivering',execution_id=? WHERE member_id=? AND status='pending' AND purpose<>'group'",
                        (cursor.lastrowid, member["id"]))
     return execution_detail(connection, connection.execute("SELECT * FROM member_executions WHERE id=?", (cursor.lastrowid,)).fetchone())
 
@@ -903,7 +1082,7 @@ def owned_member(connection, room_id, member_id, token):
 def interrupt_member(connection, room_id, member_id, token):
     """Owner stop: void the live execution and every open request."""
     owned_member(connection, room_id, member_id, token)
-    stop_member_work(connection, member_id, "用户打断")
+    stop_member_work(connection, member_id, "用户打断", "user_stop")
     settle_batches(connection, room_id)
     return free_view(connection, room_id)
 
@@ -1057,8 +1236,12 @@ def member_action(connection, room_id, member_id, token, payload):
     """
     member = owned_member(connection, room_id, member_id, token)
     action = payload.get("action")
+    routed = []
     if action in ("away", "remove"):
-        stop_member_work(connection, member_id, "成员已离开" if action == "away" else "成员已移除")
+        # Unnamed messages still waiting on a departing host move to its successor instead of being dropped.
+        routed = open_route_messages(connection, member_id)
+        stop_member_work(connection, member_id, "成员已离开" if action == "away" else "成员已移除",
+                         "member_away" if action == "away" else "member_removed")
         connection.execute("UPDATE room_members SET status=? WHERE id=?", ("away" if action == "away" else "removed", member_id))
     elif action == "active":
         hashed = token_hash(payload.get("token"))
@@ -1077,10 +1260,17 @@ def member_action(connection, room_id, member_id, token, payload):
         if role == "member" and member["role"] == "host":
             raise ValueError("自由房间须由一位 AI 主持；请指定另一位成员担任主持人")
         if role == "host":
+            # Unnamed messages the old host has not started move to the new host, which carries the host rules.
+            old_host = connection.execute("SELECT id FROM room_members WHERE room_id=? AND role='host' AND id<>?", (room_id, member_id)).fetchone()
+            if old_host:
+                routed = open_route_messages(connection, old_host["id"], pending_only=True)
+                record_cancel_reasons(connection, "member_id=? AND purpose IN ('route','group') AND status='pending'", (old_host["id"],), "rerouted")
+                connection.execute("UPDATE member_requests SET status='cancelled' WHERE member_id=? AND purpose IN ('route','group') AND status='pending'", (old_host["id"],))
             connection.execute("UPDATE room_members SET role='member' WHERE room_id=? AND role='host'", (room_id,))
         connection.execute("UPDATE room_members SET role=? WHERE id=?", (role, member_id))
     else:
         raise ValueError("action 须为 away、active、remove、role 或 adopt")
     settle_batches(connection, room_id)
     sync_participants(connection, room_id)
+    hand_over_routes(connection, room_id, routed, member_id if action in ("away", "remove") else None)
     return free_view(connection, room_id)

package/backend/schema.sql

@@ -602,11 +602,31 @@ CREATE TABLE IF NOT EXISTS scheduler_routing (
     created_at INTEGER NOT NULL,
     PRIMARY KEY (room_id, message_id)
 );
+-- Why a request was cancelled; a side table so older databases need no column change. Requests cancelled before it existed have no row.
+CREATE TABLE IF NOT EXISTS request_cancel_reasons (
+    request_id INTEGER PRIMARY KEY REFERENCES member_requests(id) ON DELETE CASCADE,
+    reason TEXT NOT NULL CHECK(reason IN ('user_stop','member_away','member_removed','rerouted','no_reply','archived'))
+);
 -- What produced a decision (model, threshold, prompt and package versions), so ratings stay comparable across versions.
 CREATE TABLE IF NOT EXISTS scheduler_decision_context (
     decision_id INTEGER PRIMARY KEY REFERENCES scheduler_decisions(id) ON DELETE CASCADE,
     context TEXT NOT NULL
 );
+-- The exact input the decision model saw (state and full questions with option descriptions); not part of backups.
+CREATE TABLE IF NOT EXISTS scheduler_decision_inputs (
+    decision_id INTEGER PRIMARY KEY REFERENCES scheduler_decisions(id) ON DELETE CASCADE,
+    input TEXT NOT NULL
+);
+-- A self-contained copy of each decision the owner currently rates bad, kept when its room is deleted so prompts can be reviewed.
+CREATE TABLE IF NOT EXISTS scheduler_feedback_cases (
+    decision_id INTEGER PRIMARY KEY,
+    room_id TEXT NOT NULL,
+    room_title TEXT NOT NULL,
+    snapshot TEXT NOT NULL,
+    should_be TEXT NOT NULL DEFAULT '',
+    note TEXT NOT NULL DEFAULT '',
+    rated_at TEXT NOT NULL
+);
 -- Smart scheduling's suggestion that another member answer an unnamed message. The host keeps the message;
 -- the user may adopt before expires_at (waiting until the host's request ends for mode 'after'), otherwise it lapses.
 CREATE TABLE IF NOT EXISTS member_recommendations (
@@ -635,13 +655,19 @@ CREATE TABLE IF NOT EXISTS free_batches (
     settled INTEGER NOT NULL DEFAULT 0,
     PRIMARY KEY (room_id,batch_id)
 );
--- Members the user named to answer one after another: each gets its request once the one before it ends (host first, then by joining order).
+-- Members the user named to answer one after another, in the room's speaking order: each gets its request once the one before
+-- it ends. Asked rows stay so the speaking order can show who already answered; the owner may reorder rows not yet asked.
 CREATE TABLE IF NOT EXISTS free_queue (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
     message_id INTEGER NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
     member_id INTEGER NOT NULL REFERENCES room_members(id) ON DELETE CASCADE
 );
+-- The owner's default speaking order (JSON list of member ids); members it lacks follow, the host first, then by joining order.
+CREATE TABLE IF NOT EXISTS speaking_orders (
+    room_id TEXT PRIMARY KEY REFERENCES rooms(id) ON DELETE CASCADE,
+    member_ids TEXT NOT NULL
+);
 -- Chains whose automatic progress stopped (budget reached or every dispatched member failed).
 CREATE TABLE IF NOT EXISTS free_chains (
     room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,

package/backend/server.py

@@ -26,6 +26,7 @@ from .free_room import (add_member, after_free_message, authorize_free_write, ch
                         discussion_members, room_mode, save_room_access, sync_discussion_members, view_execution)
 from .free_room import add_discussion_member, convert_suggestion, discussion_member_action, message_suggestions, save_suggestions, sync_participants
 from .free_room import active_members, adopt_recommendation, ask_members, asks_view, checked_asks, recommend_member, register_member, route_held_messages
+from .free_room import reorder_speakers, speaking_order, stop_room_work
 from .identity import MAX_ROOM_AGENTS, PARTICIPANTS, is_ai, is_participant
 from .room_import import import_room, imported_attachment
 from .runtime import (authorize_write, begin_write, configure_runtime, event_action,
@@ -84,6 +85,8 @@ FROM scheduler_decisions d LEFT JOIN scheduler_feedback f ON f.decision_id=d.id
 MAX_DECISION_LABEL = 200
 ROUTING_VISIBLE_SECONDS = 120
 MAX_DECISION_DETAIL = 4000
+MAX_DECISION_INPUT = 60000
+FEEDBACK_CASES_PAGE = 50
 SCHEDULER_PROVIDERS = ("jev", "decisions")
 ROOM_BACKUP_QUERIES = {
     "rooms": "SELECT * FROM rooms WHERE id=?",
@@ -110,10 +113,14 @@ FREE_BACKUP_QUERIES = {
 MESSAGE_QUERY = """SELECT messages.*, COALESCE(details.kind,'opinion') AS kind,
 COALESCE(details.submitted_by, CASE WHEN messages.source IN ('cli','api','url','user')
 THEN messages.author ELSE '用户' END) AS submitted_by, details.turn_id,
-COALESCE(summaries.text,'') AS summary, COALESCE(summaries.author,'') AS summary_by, timing.elapsed_seconds
+COALESCE(summaries.text,'') AS summary, COALESCE(summaries.author,'') AS summary_by, timing.elapsed_seconds,
+answered.execution_id, answered.request_message_id
 FROM messages LEFT JOIN message_details AS details ON details.message_id=messages.id
 LEFT JOIN message_summaries AS summaries ON summaries.message_id=messages.id
-LEFT JOIN message_timings AS timing ON timing.message_id=messages.id"""
+LEFT JOIN message_timings AS timing ON timing.message_id=messages.id
+LEFT JOIN (SELECT answer_id, MIN(execution_id) AS execution_id, MIN(message_id) AS request_message_id
+  FROM member_requests WHERE answer_id IS NOT NULL AND execution_id IS NOT NULL GROUP BY answer_id) AS answered
+  ON answered.answer_id=messages.id"""
 
 
 def room_backup(connection, room_id):
@@ -252,6 +259,7 @@ def require_room(connection, room_id):
         # Free rooms have no host hand-off: user messages go straight to the named members.
         room["held_since"] = 0
         room["free"] = free_view(connection, room_id)
+    room["speaking_order"] = speaking_order(connection, room)
     return room
 
 
@@ -621,6 +629,9 @@ def manage_room(connection, room_id, action, payload):
     elif action in ("archive", "restore"):
         if action == "archive" and room["phase"] != "concluded":
             save_topic_settings(connection, room_id, {**room, "phase": "paused"})
+        if action == "archive" and room["mode"] == "free":
+            # An archived room is read-only: nothing it still owes may be delivered or answered later.
+            stop_room_work(connection, room_id, "房间已归档", "archived")
         connection.execute("UPDATE room_directory SET archived=? WHERE room_id=?", (int(action == "archive"), room_id))
     elif action == "delete":
         if payload.get("confirm_title") != room["title"]:
@@ -634,10 +645,10 @@ def manage_room(connection, room_id, action, payload):
 
 def delete_room_records(connection, room_id):
     """Remove a room's dependent records in the caller's transaction."""
-    for table in ("member_recommendations", "free_queue", "member_requests", "member_executions", "member_sessions", "member_registrations", "room_members", "room_modes", "free_batches", "free_chains", "room_links",
+    for table in ("member_recommendations", "free_queue", "speaking_orders", "member_requests", "member_executions", "member_sessions", "member_registrations", "room_members", "room_modes", "free_batches", "free_chains", "room_links",
                   "discussion_options", "round_budgets", "scheduler_decisions", "scheduler_routing", "discussion_sessions"):
         if table == "scheduler_decisions":
-            for child in ("scheduler_feedback", "scheduler_decision_context"):
+            for child in ("scheduler_feedback", "scheduler_decision_context", "scheduler_decision_inputs"):
                 connection.execute(f"DELETE FROM {child} WHERE decision_id IN (SELECT id FROM scheduler_decisions WHERE room_id=?)", (room_id,))
             connection.execute("DELETE FROM scheduler_decision_details WHERE decision_id IN (SELECT id FROM scheduler_decisions WHERE room_id=?)", (room_id,))
         connection.execute(f"DELETE FROM {table} WHERE room_id=?", (room_id,))
@@ -1144,8 +1155,10 @@ def roster_view(room):
     last = room["rounds"][-1] if room["rounds"] else None
     spoken = set(last["speakers"]) if last and not last["completed"] else set()
     pending_registration = unregistered_experts(room)
-    experts = [{"name": name, "mode": mode, "host": name == room["host"], "spoken": name in spoken,
-                "registered": name not in pending_registration} for name, mode in room["experts"].items()]
+    # Experts follow the room's speaking order, so a round plan can take the user's preferred order from the roster.
+    rank = {item["name"]: index for index, item in enumerate(room["speaking_order"]["items"])}
+    experts = [{"name": name, "mode": room["experts"][name], "host": name == room["host"], "spoken": name in spoken,
+                "registered": name not in pending_registration} for name in sorted(room["experts"], key=lambda name: rank.get(name, len(rank)))]
     state = json.dumps([sorted(room["experts"]), sorted(spoken), sorted(pending_registration)], ensure_ascii=False)
     return {"experts": experts, "unregistered": pending_registration,
             "waiting": [item["name"] for item in experts if not item["spoken"] and not item["host"] and item["registered"]],
@@ -1227,9 +1240,34 @@ def rate_scheduler_decision(connection, room_id, decision_id, token, payload):
         connection.execute("""INSERT INTO scheduler_feedback (decision_id,rating,should_be,note,created_at) VALUES (?,?,?,?,?)
             ON CONFLICT(decision_id) DO UPDATE SET rating=excluded.rating,should_be=excluded.should_be,note=excluded.note,created_at=excluded.created_at""",
                            (decision_id, rating, should_be.strip(), note.strip(), utc_now()))
+    if rating == "bad":
+        save_feedback_case(connection, room_id, decision_id, should_be.strip(), note.strip())
+    else:
+        connection.execute("DELETE FROM scheduler_feedback_cases WHERE decision_id=?", (decision_id,))
     return {"decision_id": decision_id, "feedback": rating, "should_be": should_be.strip(), "note": note.strip()}
 
 
+def save_feedback_case(connection, room_id, decision_id, should_be, note):
+    """Copy a bad-rated decision with everything the model saw, so it outlives its room for prompt review."""
+    decision = dict(connection.execute(f"{DECISION_SELECT} WHERE d.id=?", (decision_id,)).fetchone())
+    stored = {name: connection.execute(f"SELECT {column} FROM {table} WHERE decision_id=?", (decision_id,)).fetchone()
+              for name, table, column in (("detail", "scheduler_decision_details", "detail"), ("input", "scheduler_decision_inputs", "input"))}
+    snapshot = {key: decision[key] for key in ("kind", "after_message_id", "label", "confidence", "applied", "provider", "created_at")}
+    snapshot["context"] = json.loads(decision["context"]) if decision["context"] else None
+    snapshot.update({name: json.loads(row[0]) if row else None for name, row in stored.items()})
+    title = connection.execute("SELECT title FROM rooms WHERE id=?", (room_id,)).fetchone()[0]
+    connection.execute("""INSERT OR REPLACE INTO scheduler_feedback_cases (decision_id,room_id,room_title,snapshot,should_be,note,rated_at)
+        VALUES (?,?,?,?,?,?,?)""", (decision_id, room_id, title, json.dumps(snapshot, ensure_ascii=False), should_be, note, utc_now()))
+
+
+def list_feedback_cases(connection, after):
+    """Bad-rated decision snapshots after a decision id, oldest first, for the administrator's prompt review."""
+    rows = connection.execute("SELECT * FROM scheduler_feedback_cases WHERE decision_id>? ORDER BY decision_id LIMIT ?",
+                              (after, FEEDBACK_CASES_PAGE)).fetchall()
+    cases = [{**dict(row), "snapshot": json.loads(row["snapshot"])} for row in rows]
+    return {"cases": cases, "next_after": cases[-1]["decision_id"] if len(cases) == FEEDBACK_CASES_PAGE else None}
+
+
 def mark_scheduler_routing(connection, room_id, token, payload):
     """The local service marks a message while the decision model is analysing it, and clears the mark when done."""
     begin_write(connection)
@@ -1273,6 +1311,12 @@ def record_scheduler_decision(connection, room_id, token, payload, owner=False):
         if not isinstance(detail, list) or len(detail) > 4 or len(text) > MAX_DECISION_DETAIL:
             raise ValueError(f"detail 须为最多 4 项、不超过 {MAX_DECISION_DETAIL} 字的列表")
         connection.execute("INSERT INTO scheduler_decision_details (decision_id,detail) VALUES (?,?)", (cursor.lastrowid, text))
+    model_input = payload.get("input")
+    if model_input is not None:
+        text = json.dumps(model_input, ensure_ascii=False)
+        if not isinstance(model_input, dict) or len(text) > MAX_DECISION_INPUT:
+            raise ValueError(f"input 须为不超过 {MAX_DECISION_INPUT} 字的对象")
+        connection.execute("INSERT INTO scheduler_decision_inputs (decision_id,input) VALUES (?,?)", (cursor.lastrowid, text))
     return dict(connection.execute("SELECT * FROM scheduler_decisions WHERE id=?", (cursor.lastrowid,)).fetchone())
 
 
@@ -1895,6 +1939,10 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             return self.respond({"ok": True})
         if parts[:2] == ["api", "admin"]:
             return self.handle_admin_api(connection, parts, method)
+        if parts == ["api", "scheduler-feedback"] and method == "GET":
+            if not self.admin_session(connection):
+                raise AdminError("需要登录管理员账号", 401)
+            return self.respond(list_feedback_cases(connection, int(params.get("after", 0))))
         if parts == ["api", "rooms"]:
             if method == "GET":
                 return self.respond({**list_rooms(connection, params), "participants": PARTICIPANTS})
@@ -1943,6 +1991,15 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             result = register_member(connection, room_id, token, utc_now())
             connection.commit()
             return self.respond(result)
+        if parts[3:] == ["speaking-order"]:
+            if method == "GET":
+                return self.respond(require_room(connection, room_id)["speaking_order"])
+            payload = self.read_payload()
+            begin_write(connection)
+            reorder_speakers(connection, require_room(connection, room_id), token, payload)
+            result = require_room(connection, room_id)
+            connection.commit()
+            return self.respond(result)
         free = room_mode(connection, room_id) == "free"
         # A discussion keeps the local service's inbox and per-member executions for the user's direct questions.
         if parts[3:4] in (["inbox"], ["executions"]) or (free and parts[3:4] in (["members"], ["suggestions"], ["recommendations"])):