ai_co_discuss 0.2.70 → 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/backend/free_room.py

@@ -336,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)
@@ -587,12 +593,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 +613,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 +676,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 +799,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 +893,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 +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("这条消息没有智能调度推荐")
@@ -950,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())
 
@@ -1218,8 +1264,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

@@ -612,6 +612,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

@@ -85,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=?",
@@ -111,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):
@@ -642,7 +648,7 @@ def delete_room_records(connection, room_id):
     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,))
@@ -1234,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)
@@ -1280,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())
 
 
@@ -1902,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})