ai_co_discuss 0.2.70 → 0.2.72

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-host/references/manual.md

@@ -34,7 +34,7 @@
 
 ## 在线专家：协助方式与操作恢复
 
-每次请专家回答时，要求同时提供简述与完整正文；简述的写法、保存与署名遵循 discuss-participant。若原回答缺少简述，主持人可据完整原文另行整理并注明摘要归主持人，专家正文保持原样。
+请专家回答时，回答较长的同时提供简述与完整正文；简述的写法、保存与署名遵循 discuss-participant。若长回答缺少简述，主持人可据完整原文另行整理并注明摘要归主持人，专家正文保持原样。
 
 选择「用户手动复制协助」时，每轮在当前聊天给出完整、可复制的提问文本和对应安排编号，由用户发到专家原聊天并贴回完整回答；主持人不自行操作该专家网页或发送问题。用户确认送达后再记录通知，收到并核对对应回答后通过 CLI 原文代发。展示提问文本不算送达，等待用户期间不重复催促。
 

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

@@ -81,7 +81,7 @@ description: "AI CoDiscuss 的通用参与技能，所有参与者（包括主
 
 可以坚持有依据的少数意见，也可以因新证据修改判断并解释变化。主动检查关键反例与遗漏，但不为反对而反对，不以赞同人数代替证据；材料不足时说明什么证据会改变结论。需要对方回应时直接 `@专家名` 并说明具体问题；@ 只是讨论线索，不会通知。
 
-篇幅和结构由问题决定。保留关键数字、条件与失败情形；回应追问只补新论证或观点变化，旧内容用原文编号引用。简述表达主要判断或变化，完整论证与出处放正文，不再复制一遍长清单。
+篇幅和结构由问题决定。保留关键数字、条件与失败情形；回应追问只补新论证或观点变化，旧内容用原文编号引用。回答摘要按需填写（讨论与自由协作相同）：正文较长、读者需要先看结论时，用一两句写主要判断或变化及关键条件；简短回答不写，不把正文复述一遍。完整论证与出处放正文，不再复制一遍长清单。
 
 示例（只示意密度与结构，内容与篇幅按问题而定）：
 

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

@@ -6,6 +6,8 @@
 
 没有安排和阶段，不执行 `execution enter`。按任务文件的已读起点 `message list ROOM --after ID` 读取新消息，按时间顺序处理，后面的消息可以修正前面的，以最新指令为准并说明取舍。完成后用 `message post ROOM --as 本人 --kind chat --execution 执行编号 --access-file FILE` 提交一次回答。
 
+任务需要多步操作时，在关键转折处（读完材料、改定方案、验证结果）用一两句中文写出进展，不另调命令：本机接入程序会把这些中途说明显示在网页的处理中卡片，让用户知道你在做什么。只写进展与判断，不复述工具输出，不代替最终回答。
+
 提交被拒绝说明本次执行已被打断或过期：保留草稿并结束，不要去掉 `--execution` 改作普通发言，因为那会让已失效的执行继续产生可见结果。
 
 手动接入的自由成员没有执行编号：从 `room view` 的 `free.requests` 找到自己的待处理请求，回答时用 `--request 请求编号` 关闭。

package/backend/free_room.py

@@ -24,6 +24,12 @@ RECENT_REQUESTS = 100
 RECENT_EXECUTIONS = 100
 RECENT_CHANGES = 50
 MAX_CHANGED_FILES = 200
+# What a member's software last showed it doing, as reported by the runner with each renewal.
+ACTIVITY_PHASES = ("", "thinking", "command", "tool", "editing", "writing")
+# Progress notes per execution, their length, and how many one renewal may carry.
+MAX_EXECUTION_NOTES = 50
+MAX_NOTE_LENGTH = 500
+MAX_NOTES_PER_RENEW = 10
 MAX_PATH_LENGTH = 500
 ACTIVE = ("dispatched", "started")
 ACCESS_MODES = ("runner", "manual", "online")
@@ -44,10 +50,12 @@ QUEUE_ASKED = "EXISTS(SELECT 1 FROM member_requests r WHERE r.message_id={row}.m
 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")
-EXECUTION_FIELDS = ("id", "member_id", "status", "session_id", "lease_until", "created_at", "finished_at", "result")
+EXECUTION_FIELDS = ("id", "member_id", "status", "session_id", "lease_until", "created_at", "finished_at", "result",
+                    "activity", "activity_at")
 # Columns added after the first free-room tables; Python databases created by that build gain them here.
 LATER_COLUMNS = {"room_members": {"access": "TEXT NOT NULL DEFAULT 'runner'", "session_mode": "TEXT NOT NULL DEFAULT 'new'"},
-                 "member_executions": {"changes": "TEXT NOT NULL DEFAULT ''", "cwd": "TEXT NOT NULL DEFAULT ''"},
+                 "member_executions": {"changes": "TEXT NOT NULL DEFAULT ''", "cwd": "TEXT NOT NULL DEFAULT ''",
+                                       "activity": "TEXT NOT NULL DEFAULT ''", "activity_at": "INTEGER NOT NULL DEFAULT 0"},
                  "member_requests": {"chain_id": "INTEGER NOT NULL DEFAULT 0", "batch_id": "INTEGER NOT NULL DEFAULT 0",
                                      "purpose": "TEXT NOT NULL DEFAULT 'ask'", "created_by": "TEXT NOT NULL DEFAULT 'user'"}}
 
@@ -187,16 +195,30 @@ def public_execution(row):
     return {key: row[key] for key in EXECUTION_FIELDS} if row else None
 
 
+def note_count(connection, execution_id):
+    """How many progress notes an execution has; the texts are read separately so room views stay small."""
+    return connection.execute("SELECT COUNT(*) FROM execution_notes WHERE execution_id=?", (execution_id,)).fetchone()[0]
+
+
+def execution_notes(connection, room_id, execution_id):
+    """Read one execution's progress notes in order, with the same access as the room view."""
+    if not connection.execute("SELECT 1 FROM member_executions WHERE room_id=? AND id=?", (room_id, execution_id)).fetchone():
+        raise LookupError("执行不存在")
+    return {"notes": [dict(row) for row in connection.execute(
+        "SELECT seq,text,created_at FROM execution_notes WHERE execution_id=? ORDER BY seq", (execution_id,))]}
+
+
 def recent_executions(connection, room_id):
     """Return bounded public reports, including requests no longer in the recent request list."""
     rows = connection.execute("""SELECT e.*,
         (SELECT json_group_array(id) FROM member_requests WHERE execution_id=e.id) AS request_ids,
         (SELECT MAX(answer_id) FROM member_requests WHERE execution_id=e.id) AS answer_id,
-        (SELECT MIN(message_id) FROM member_requests WHERE execution_id=e.id) AS request_message_id
+        (SELECT MIN(message_id) FROM member_requests WHERE execution_id=e.id) AS request_message_id,
+        (SELECT COUNT(*) FROM execution_notes WHERE execution_id=e.id) AS note_count
         FROM member_executions e WHERE room_id=? ORDER BY id DESC LIMIT ?""", (room_id, RECENT_EXECUTIONS))
     return [{**public_execution(row), "cwd": row["cwd"], "changes": json.loads(row["changes"] or "[]"),
              "changes_recorded": bool(row["changes"]), "request_ids": json.loads(row["request_ids"]),
-             "answer_id": row["answer_id"], "request_message_id": row["request_message_id"]} for row in rows]
+             "answer_id": row["answer_id"], "request_message_id": row["request_message_id"], "notes": row["note_count"]} for row in rows]
 
 
 def possible_conflicts(connection, room_id, names):
@@ -245,6 +267,7 @@ def free_view(connection, room_id):
         member["execution"] = public_execution(latest)
         if latest and latest["status"] in ACTIVE:
             member["execution"]["stale"] = latest["lease_until"] <= now
+            member["execution"]["notes"] = note_count(connection, latest["id"])
         member["pending"] = connection.execute("SELECT COUNT(*) FROM member_requests WHERE member_id=? AND status='pending'",
                                                (row["id"],)).fetchone()[0]
         members.append(member)
@@ -336,12 +359,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)
@@ -587,12 +616,13 @@ 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 queued turns. The revision changes with any of it.
+    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 = [], "default", 0
+    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
@@ -606,22 +636,37 @@ def speaking_order(connection, room):
     else:
         kind = "turns"
         last = room["rounds"][-1] if room["rounds"] else None
-        items = [{"name": name, "state": "done"} for name in (last["speakers"] if last and not last["completed"] else [])]
         turn = room["current_turn"]
-        if turn and turn["status"] in ("pending", "notified"):
-            items.append({"name": turn["expert"], "state": "speaking"})
-        items += [{"name": item["expert"], "state": "queued"} for item in room["queued_turns"]]
+        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]], ensure_ascii=False)
-    return {"kind": kind, "message_id": target, "items": items, "movable": [item["name"] for item in items if item["state"] == movable],
+    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.
 
@@ -654,13 +699,18 @@ def reorder_speakers(connection, room, token, payload):
 
 
 def reorder_turns(connection, room_id, order):
-    """Move queued turns into the new order; ids keep the relay order, so each turn's content moves to the id at its new place."""
-    rows = [dict(row) for row in connection.execute("SELECT * FROM discussion_turns WHERE room_id=? AND status='queued' ORDER BY id", (room_id,))]
+    """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.
-    connection.execute("UPDATE discussion_turns SET submission_id=submission_id||':moving:'||id WHERE room_id=? AND status='queued'", (room_id,))
+    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"]))
@@ -772,19 +822,20 @@ def finish_execution(connection, execution_id, status, result, request_status, c
 
 
 def open_route_messages(connection, member_id, pending_only=False):
-    """Messages whose host request is still open, in order; they need a new host if this one leaves."""
+    """(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] for row in connection.execute(
-        f"SELECT message_id FROM member_requests WHERE member_id=? AND purpose='route' AND status IN ({states}) ORDER BY message_id", (member_id,))]
+    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, message_ids, departed_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 in message_ids if host else []:
+    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 (?,?,?,?,'route','user',?)""", (room_id, host["id"], message_id, message_id, int(time.time())))
+            VALUES (?,?,?,?,?,'user',?)""", (room_id, host["id"], message_id, message_id, purpose, int(time.time())))
 
 
 def stop_member_work(connection, member_id, reason, cancel_reason):
@@ -865,9 +916,26 @@ 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":
@@ -892,10 +960,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("这条消息没有智能调度推荐")
@@ -950,12 +1018,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())
 
@@ -991,6 +1060,26 @@ def changed_files(payload):
     return sorted(set(files))
 
 
+def renewed_activity(payload, row, now):
+    """Validate the runner's reported phase; its output time is kept within the execution, since the runner's clock may differ."""
+    activity, activity_at = payload.get("activity"), payload.get("activity_at")
+    if activity not in ACTIVITY_PHASES:
+        raise ValueError(f"activity 须为 {'、'.join(item for item in ACTIVITY_PHASES if item)} 或空")
+    if type(activity_at) is not int:
+        raise ValueError("activity_at 须为秒级时间戳")
+    return activity, min(max(activity_at, row["created_at"]), now)
+
+
+def renewed_notes(payload):
+    """Validate progress notes carried by a renewal; a repeated sequence number is the same note resent."""
+    notes = payload.get("notes", [])
+    if (not isinstance(notes, list) or len(notes) > MAX_NOTES_PER_RENEW or any(
+            not isinstance(note, dict) or type(note.get("seq")) is not int or not 1 <= note["seq"] <= MAX_EXECUTION_NOTES
+            or not isinstance(note.get("text"), str) or not 0 < len(note["text"]) <= MAX_NOTE_LENGTH for note in notes)):
+        raise ValueError(f"notes 须为最多 {MAX_NOTES_PER_RENEW} 条 {{seq: 1–{MAX_EXECUTION_NOTES}, text: 1–{MAX_NOTE_LENGTH} 字}}")
+    return notes
+
+
 def execution_action(connection, room_id, execution_id, token, payload):
     """Runner-side lifecycle: renew, fail, release undelivered work, or report observed file changes."""
     require_owner(connection, room_id, token)
@@ -1011,7 +1100,13 @@ def execution_action(connection, room_id, execution_id, token, payload):
         limit = row["created_at"] + execution_minutes(connection, room_id) * 60
         if row["lease_until"] <= now or limit <= now:
             raise FileExistsError("执行租约或单次时限已到，不能续租")
-        connection.execute("UPDATE member_executions SET lease_until=? WHERE id=?", (min(now + LEASE_SECONDS, limit), execution_id))
+        # Older runners renew without activity; the last reported one is kept.
+        activity, activity_at = renewed_activity(payload, row, now) if "activity" in payload else (row["activity"], row["activity_at"])
+        notes = renewed_notes(payload)
+        connection.execute("UPDATE member_executions SET lease_until=?,activity=?,activity_at=? WHERE id=?",
+                           (min(now + LEASE_SECONDS, limit), activity, activity_at, execution_id))
+        connection.executemany("INSERT OR IGNORE INTO execution_notes (execution_id,seq,room_id,text,created_at) VALUES (?,?,?,?,?)",
+                               [(execution_id, note["seq"], room_id, note["text"], now) for note in notes])
     elif action == "fail":
         finish_execution(connection, execution_id, "failed", str(payload.get("reason") or "执行失败"), "failed")
         settle_batches(connection, room_id)
@@ -1218,8 +1313,8 @@ def member_action(connection, room_id, member_id, token, payload):
             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='route' AND status='pending'", (old_host["id"],), "rerouted")
-                connection.execute("UPDATE member_requests SET status='cancelled' WHERE member_id=? AND purpose='route' AND status='pending'", (old_host["id"],))
+                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:

package/backend/schema.sql

@@ -532,8 +532,19 @@ CREATE TABLE IF NOT EXISTS member_executions (
     result TEXT NOT NULL DEFAULT '',
     changes TEXT NOT NULL DEFAULT '',
     cwd TEXT NOT NULL DEFAULT '',
+    activity TEXT NOT NULL DEFAULT '',
+    activity_at INTEGER NOT NULL DEFAULT 0,
     UNIQUE(room_id,client_id)
 );
+-- Progress notes the runner saw a member's software write between tool calls; numbered per execution so a retried renewal adds nothing.
+CREATE TABLE IF NOT EXISTS execution_notes (
+    execution_id INTEGER NOT NULL REFERENCES member_executions(id) ON DELETE CASCADE,
+    seq INTEGER NOT NULL,
+    room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    text TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    PRIMARY KEY(execution_id,seq)
+);
 -- One live execution per member: different members may run in parallel, one session never twice.
 CREATE UNIQUE INDEX IF NOT EXISTS one_member_execution ON member_executions(member_id)
     WHERE status IN ('dispatched','started');
@@ -612,6 +623,21 @@ 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 (

package/backend/server.py

@@ -26,7 +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 .free_room import execution_notes, 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,
@@ -61,7 +61,8 @@ ASSETS = {"/": ("index.html", "text/html"),
           "/markdown.js": ("markdown.js", "text/javascript"),
           "/backup.js": ("backup.js", "text/javascript"),
           "/markdown.css": ("markdown.css", "text/css"),
-          "/icons/LICENSE.txt": ("icons/LICENSE.txt", "text/plain")}
+          "/icons/LICENSE.txt": ("icons/LICENSE.txt", "text/plain"),
+          "/icons/typesafe.png": ("icons/typesafe.png", "image/png")}
 ASSETS.update({f"/icons/{name}.svg": (f"icons/{name}.svg", "image/svg+xml")
                for name in ("openai", "claude", "gemini", "deepseek", "qwen", "user")})
 ASSETS.update({"/pdfjs/" + file.relative_to(WEB_ROOT / "pdfjs").as_posix():
@@ -85,6 +86,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=?",
@@ -111,10 +114,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):
@@ -217,12 +224,14 @@ def require_room(connection, room_id):
     room["round_budget"] = dict(budget) if budget else None
     if budget:
         room["opinion_count"] = opinion_count(connection, room_id, room["experts"])
-    room["round_groups"] = budget_round_groups(connection, room_id, room["experts"], budget["base"]) if budget else room["rounds"]
+    session = connection.execute("SELECT id,goal,status,started_message_id,ended_message_id,created_at FROM discussion_sessions WHERE room_id=? ORDER BY id DESC LIMIT 1", (room_id,)).fetchone()
+    room["session"] = dict(session) if session else None
+    room["round_groups"] = budget_round_groups(connection, room_id, room["experts"], budget["base"], room["session"]) if budget else room["rounds"]
     room["runtime"] = runtime_view(connection, room_id)
     room["limits"] = limits_view(connection.execute(LIMITS_SQL, (room_id,)).fetchone(), room)
     room["mode"] = room_mode(connection, room_id)
-    session = connection.execute("SELECT id,goal,status,started_message_id,ended_message_id,created_at FROM discussion_sessions WHERE room_id=? ORDER BY id DESC LIMIT 1", (room_id,)).fetchone()
-    room["session"] = dict(session) if session else None
+    if room["mode"] == "free" and not session:
+        room["round_groups"] = []
     room["members"] = [dict(row) for row in connection.execute(
         """SELECT m.id,m.name,m.adapter,m.role,m.status,m.access,m.session_mode,COALESCE(s.session_id,'') AS reported_session,COALESCE(s.client,'') AS reported_client,
         COALESCE(r.registered_at,'') AS registered_at
@@ -320,27 +329,33 @@ def discussion_rounds(connection, room_id, experts):
     return rounds
 
 
-def budget_round_groups(connection, room_id, experts, base):
+def budget_round_groups(connection, room_id, experts, base, session):
     """Group history by the round budget's rule: every len(experts) opinions form a round, and a new segment (base) starts a new one.
 
+    Only messages of the latest discussion are grouped, numbered from 1; free collaboration before or after it has no rounds.
     `rounds` stays speaker-based because scheduling needs who still owes a turn; this view only labels history.
     """
-    if not experts:
+    if not experts or not session:
         return []
+    first, last = session["started_message_id"], session["ended_message_id"] or float("inf")
     rows = connection.execute("""SELECT messages.id,messages.author,
         COALESCE(details.kind,'opinion') AS kind FROM messages
         LEFT JOIN message_details AS details ON details.message_id=messages.id
         WHERE room_id=? ORDER BY messages.id""", (room_id,))
     groups, next_start, seen = [], None, 0
     for message in rows:
+        opinion = message["kind"] == "opinion" and message["author"] in experts
+        # base counts every opinion in the room, so opinions outside the discussion still advance seen.
+        seen += opinion
+        if not first < message["id"] <= last:
+            continue
         if next_start is None:
             next_start = message["id"]
-        if message["kind"] != "opinion" or message["author"] not in experts:
+        if not opinion:
             continue
         if not groups or groups[-1]["completed"]:
             groups.append({"number": len(groups) + 1, "start_id": next_start, "opinions": 0, "completed": False})
         current = groups[-1]
-        seen += 1
         current["opinions"] += 1
         current["completed"] = current["opinions"] >= len(experts) or seen == base
         if current["completed"]:
@@ -639,10 +654,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", "speaking_orders", "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", "execution_notes", "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,))
@@ -760,7 +775,8 @@ def start_discussion(connection, room_id, token, payload):
         raise ValueError("named_followup 须为布尔值")
     # A fresh session first, so the phase mirror follows it and not a concluded earlier one.
     if not connection.execute("SELECT 1 FROM discussion_sessions WHERE room_id=? AND status IN ('active','paused')", (room_id,)).fetchone():
-        connection.execute("INSERT INTO discussion_sessions (room_id,goal,status,created_at) VALUES (?,?,'paused',?)", (room_id, settings["goal"], utc_now()))
+        connection.execute("INSERT INTO discussion_sessions (room_id,goal,status,started_message_id,created_at) VALUES (?,?,'paused',?,?)",
+                           (room_id, settings["goal"], room["latest_id"], utc_now()))
     connection.execute("UPDATE rooms SET goal=? WHERE id=?", (settings["goal"], room_id))
     save_topic_settings(connection, room_id, settings)
     connection.execute("UPDATE room_modes SET mode='brainstorm' WHERE room_id=?", (room_id,))
@@ -1234,9 +1250,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)
@@ -1280,6 +1321,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())
 
 
@@ -1519,7 +1566,7 @@ def participation_text(params, free=False):
             "先回答真正的问题，给出理由、证据、适用条件与不确定性；区分事实、推断和建议，引用原文编号，不编造他人的回答。"
             "讨论初始阶段先独立判断，暂不读他人观点；深入讨论先理解对方主张及其最有力的依据，再说明同意、分歧或需要补的证据。"
             "可以坚持有依据的少数意见，也可因新证据修改判断并说明变化。",
-            "输出：先 1–3 句摘要，再给完整正文。",
+            "输出：完整正文；回答较长时先给 1–3 句摘要。",
             "不要操作网页表单、调用写入接口或生成发布链接。读取失败时如实报告，由用户提供复制的材料。",
             *(["自由协作：只回应点名给你的消息（编号见阅读通知），按时间顺序处理，后面的消息可以修正前面的。"] if free else []), footer]
 
@@ -1567,7 +1614,7 @@ def protocol_text(room):
         f"维护话题：POST {base}/topic；actor 加需要修改的上述字段，另可更新 phase（preparing/initial/discussing/paused/concluded）、focus。收束前先完成或取消当前安排；主持人收束还须先 GET {base}/conclusion 取得 blockers 与 revision，并把 revision 作为 conclusion 一并提交（有阻碍项或状态已变会被拒绝）。暂停保留安排；恢复阶段后再继续。",
         f"安排发言：POST {base}/turns；字段 actor、expert、question、submission_id（新 UUID）。同一话题同时只有一个未完成安排；重试沿用同一编号和问题。整轮安排改传 turns=[{{expert,question}},…]（最多 {MAX_PLAN_TURNS} 项），并须先 GET {base}/turns/roster 取得最新专家状态，把返回的 revision 作为 roster 一并提交（名单变化后需重取；须包含 waiting 中的每位专家）：第一项立即生效，其余排队（queued）；每个回答保存后自动交给下一位，最后一位答完再交回主持人。用户留言或修改目标、背景、边界、焦点后（room.held_since 非 0），当前回答完成即交回主持人；主持人处理后用 POST {base}/turns/continue（actor）按原计划继续，或直接创建新安排替换剩余排队（原排队改为 skipped）。",
         f"通知：仅把对象、问题、话题入口交给对应专家，不附背景、摘要或历史。使用已有且获准的会话通道；没有通道时交由用户协助。实际送达后 POST {base}/turns/安排编号，字段 actor、status=notified；取消用 status=cancelled。复制不算送达。",
-        f"专家观点：POST {base}/messages；author、text、submission_id、source=cli，kind=opinion；turn_id（回答的安排编号）可省略，省略时回答你当前有效的安排；可选 reply_to（本话题原文编号）。每次回答同时提供 summary（最多 {MAX_SUMMARY_LENGTH} 字），通常 1–3 句结论先行，保留关键理由、条件和不确定性；summary_by 为原作者或提交者，默认提交者。text 保留完整正文，最多 {MAX_TEXT_LENGTH} 个 Unicode 字符，请求最多 {MAX_BODY_BYTES} 字节；不截断或用摘要完成安排。旧客户端缺少 summary 时不自动生成。",
+        f"专家观点：POST {base}/messages；author、text、submission_id、source=cli，kind=opinion；turn_id（回答的安排编号）可省略，省略时回答你当前有效的安排；可选 reply_to（本话题原文编号）。回答较长时可附 summary（最多 {MAX_SUMMARY_LENGTH} 字），1–3 句结论先行，保留关键理由、条件和不确定性，简短回答不写；summary_by 为原作者或提交者，默认提交者。text 保留完整正文，最多 {MAX_TEXT_LENGTH} 个 Unicode 字符，请求最多 {MAX_BODY_BYTES} 字节；不截断或用摘要完成安排。旧客户端缺少 summary 时不自动生成。",
         f"主持发言：同一消息接口，author={room['host']}、submitted_by={room['host']}、kind=moderation、source=cli；个人观点使用 kind=opinion，不能自动视为共识。",
         f"代发只读专家观点：author 保留原专家，submitted_by={room['host']}、kind=opinion、text 为原文；须关联 turn_id，可附 reply_to。服务保存代发来源；不要冒充专家直接提交。该专家须有当前有效的安排。",
         f"整理状态：POST {base}/state；actor、text（详细状态，最多 {MAX_STATE_LENGTH} 字）、until（依据的消息截止编号）；brief（最多 {MAX_BRIEF_LENGTH} 字）为面向人的主持简报，说明结论、共识、歧义和下一步意图。进度或安排变化后更新；省略 brief 保留旧简报，空字符串清除。所有参与专家各保存一次完整观点才完成一轮；同轮重复发言只计该专家一次，主持说明、用户留言及取消安排不推进轮次。房间 rounds 按当前配置专家和完整历史生成，completed_rounds 为完成轮数，answered_turns 仅为已回答安排数。状态不覆盖原文，也不代表全体一致同意。",
@@ -1902,6 +1949,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})
@@ -2129,6 +2180,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             result = recommend_member(connection, room_id, token, self.read_payload())
         elif len(parts) == 5 and parts[3] == "recommendations" and method == "POST":
             result = adopt_recommendation(connection, room_id, token, int(parts[4]), self.read_payload())
+        elif len(parts) == 6 and parts[3] == "executions" and parts[5] == "notes" and method == "GET":
+            result = execution_notes(connection, room_id, int(parts[4]))
         elif len(parts) == 5 and parts[3] == "executions":
             execution_id = int(parts[4])
             result = (view_execution(connection, room_id, execution_id, token) if method == "GET"