ai_co_discuss 0.2.47 → 0.2.49

package/backend/free_room.py

@@ -553,6 +553,39 @@ def after_free_message(connection, room_id, message_id, actor, payload):
     settle_batches(connection, room_id)
 
 
+def discussion_host_handles(connection, room):
+    """A running discussion already wakes its host for every user message, so a question to the host needs no request of its own."""
+    return room["phase"] not in ("paused", "concluded") and bool(connection.execute(
+        "SELECT 1 FROM discussion_runtime WHERE room_id=? AND status='running'", (room["id"],)).fetchone())
+
+
+def checked_asks(connection, room, payload):
+    """Validate the user's direct questions to members of a discussion before the message is stored."""
+    names = payload.get("to")
+    if names is None:
+        return []
+    return named_members(active_members(connection, room["id"]), names)
+
+
+def ask_members(connection, room, message_id, member_ids):
+    """Queue one 'ask' request per named member, outside the discussion's turns, rounds and limits."""
+    host_busy = discussion_host_handles(connection, room)
+    for member_id in member_ids:
+        row = connection.execute("SELECT name FROM room_members WHERE id=?", (member_id,)).fetchone()
+        if host_busy and row["name"] == room["host"]:
+            continue
+        insert_request(connection, room["id"], member_id, message_id, message_id, "ask", "user")
+
+
+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 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)}
+
+
 def expire_executions(connection, room_id):
     """Fail executions whose lease lapsed; their requests stay visible as failed, never silently retried."""
     now = int(time.time())
@@ -589,15 +622,16 @@ def inbox(connection, room_id, token):
     expire_executions(connection, room_id)
     release_recommendations(connection, room_id)
     archived = connection.execute("SELECT archived FROM room_directory WHERE room_id=?", (room_id,)).fetchone()[0]
-    members = []
-    for row in connection.execute("SELECT * FROM room_members WHERE room_id=? AND status='active' AND access='runner' ORDER BY id", (room_id,)):
+    members, observers = [], []
+    # Manual and online members are never delivered to; the runner only reads them so smart scheduling can route to them too.
+    for row in connection.execute("SELECT * FROM room_members WHERE room_id=? AND status='active' ORDER BY id", (room_id,)):
         pending = [dict(item) for item in connection.execute(
             "SELECT id,message_id,purpose FROM member_requests WHERE member_id=? AND status='pending' ORDER BY id", (row["id"],))]
-        members.append({**{key: row[key] for key in MEMBER_FIELDS}, "pending": pending})
+        (members if row["access"] == "runner" else observers).append({**{key: row[key] for key in MEMBER_FIELDS}, "pending": pending})
     executions = [{**public_execution(row), "member": row["name"]} for row in connection.execute(
         """SELECT member_executions.*,room_members.name FROM member_executions JOIN room_members ON room_members.id=member_id
         WHERE member_executions.room_id=? AND member_executions.status IN ('dispatched','started') ORDER BY member_executions.id""", (room_id,))]
-    return {"room_id": room_id, "archived": bool(archived), "members": members, "executions": executions,
+    return {"room_id": room_id, "archived": bool(archived), "members": members, "observers": observers, "executions": executions,
             "execution_minutes": execution_minutes(connection, room_id)}
 
 
@@ -618,9 +652,9 @@ def recommend_member(connection, room_id, token, payload):
     if not route or route["room_id"] != room_id:
         raise LookupError("只能为交给主持人的未点名消息给出推荐")
     target = connection.execute("""SELECT * FROM room_members WHERE room_id=? AND id=? AND status='active'
-        AND access='runner' AND id<>?""", (room_id, payload.get("member_id"), route["member_id"])).fetchone()
+        AND id<>?""", (room_id, payload.get("member_id"), route["member_id"])).fetchone()
     if not target:
-        raise LookupError("推荐对象须为在场、由本机唤醒的其他成员")
+        raise LookupError("推荐对象须为在场的其他成员")
     now = int(time.time())
     connection.execute("""INSERT OR IGNORE INTO member_recommendations (message_id,room_id,member_id,provider,confidence,created_at,expires_at)
         VALUES (?,?,?,?,?,?,?)""", (message_id, room_id, target["id"], payload["provider"], float(confidence), now, now + RECOMMEND_SECONDS))
@@ -693,6 +727,9 @@ def reserve_execution(connection, room_id, token, payload):
     if connection.execute("SELECT 1 FROM member_executions WHERE member_id=? AND status IN ('dispatched','started')",
                           (member["id"],)).fetchone():
         raise FileExistsError("该成员已有进行中的执行；同一会话不并发续接")
+    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():
         raise FileExistsError("该成员没有待投递的请求")
     now = int(time.time())
@@ -812,45 +849,8 @@ def save_discussion_experts(connection, room_id, experts):
     connection.execute("UPDATE topic_settings SET experts=? WHERE room_id=?", (json.dumps(experts, ensure_ascii=False), room_id))
 
 
-def current_round_speakers(connection, room_id, experts):
-    """Experts who have given an opinion in the latest unfinished round (empty when it just completed)."""
-    spoken = set()
-    rows = connection.execute("""SELECT messages.author FROM messages
-        JOIN message_details AS details ON details.message_id=messages.id AND details.kind='opinion'
-        WHERE messages.room_id=? ORDER BY messages.id""", (room_id,))
-    for row in rows:
-        if row["author"] not in experts:
-            continue
-        spoken.add(row["author"])
-        if len(spoken) == len(experts):
-            spoken = set()
-    return spoken
-
-
-def place_invited_expert(connection, room_id, name):
-    """Move the just-queued newcomer to where the current round completes: after the last queued expert who
-    has not spoken this round, before the first one who would speak again. Rows keep their ids; only who and what shift."""
-    rows = connection.execute("SELECT id,expert,question FROM discussion_turns WHERE room_id=? AND status='queued' ORDER BY id", (room_id,)).fetchall()
-    if len(rows) < 2 or rows[-1]["expert"] != name:
-        return
-    _, experts, _ = discussion_roster(connection, room_id)
-    spoken = current_round_speakers(connection, room_id, experts)
-    open_turn = connection.execute("SELECT expert FROM discussion_turns WHERE room_id=? AND status IN ('pending','notified')", (room_id,)).fetchone()
-    if open_turn:
-        spoken.add(open_turn["expert"])
-    slot = len(rows) - 1
-    for index, row in enumerate(rows[:-1]):
-        if row["expert"] in spoken:
-            slot = index
-            break
-        spoken.add(row["expert"])
-    ordered = rows[:slot] + [rows[-1]] + rows[slot:-1]
-    for target, source in zip(rows, ordered):
-        connection.execute("UPDATE discussion_turns SET expert=?,question=? WHERE id=? AND status='queued'", (source["expert"], source["question"], target["id"]))
-
-
 def queue_invited_expert(connection, room_id, name, now):
-    """Queue a new expert in an existing live plan at its round-completing slot, without changing the current speaker or hold.
+    """Queue a new expert at the tail of an existing live plan, without changing the current speaker or hold.
 
     A manual expert is queued only once it has registered (the invite alone does not), and only once per invitation.
     """
@@ -865,10 +865,8 @@ def queue_invited_expert(connection, room_id, name, now):
         FROM topic_settings AS settings JOIN room_members AS member ON member.room_id=settings.room_id
         WHERE settings.room_id=? AND member.name=? AND member.status='active'
         AND settings.phase NOT IN ('paused','concluded')
-        AND NOT EXISTS (SELECT 1 FROM discussion_limits WHERE room_id=settings.room_id AND closing_at>0)
         AND EXISTS (SELECT 1 FROM discussion_turns WHERE room_id=settings.room_id AND status IN ('pending','notified','queued'))""",
         (now, room_id, name))
-    place_invited_expert(connection, room_id, name)
 
 
 def add_discussion_member(connection, room_id, token, payload, now):
@@ -899,15 +897,11 @@ def discussion_member_action(connection, room_id, member_id, token, payload):
     """Owner sends an expert away (keeping its seat), brings it back with a new credential, or removes it.
 
     Leaving cancels the expert's open assignments; the host keeps its role and cannot leave, and an
-    expert with an open assignment can only leave while the discussion is paused. While paused,
-    `redo` voids the expert's latest opinion by deleting it so the expert counts as not yet having spoken.
+    expert with an open assignment can only leave while the discussion is paused.
     """
     member = owned_member(connection, room_id, member_id, token)
     host, experts, phase = discussion_roster(connection, room_id)
     action = payload.get("action")
-    if action == "redo":
-        void_latest_opinion(connection, room_id, member["name"], phase, payload.get("latest_id"))
-        return
     if action in ("away", "remove"):
         if member["name"] == host:
             raise ValueError("主持人不能离开或移除；请先更换主持人")
@@ -934,7 +928,7 @@ def discussion_member_action(connection, room_id, member_id, token, payload):
         adopt_manual_member(connection, room_id, member, payload)
         return
     else:
-        raise ValueError("action 须为 away、active、remove、redo 或 adopt")
+        raise ValueError("action 须为 away、active、remove 或 adopt")
     save_discussion_experts(connection, room_id, experts)
 
 
@@ -955,30 +949,6 @@ def adopt_manual_member(connection, room_id, member, payload):
     connection.execute("DELETE FROM member_sessions WHERE member_id=?", (member["id"],))
 
 
-def void_latest_opinion(connection, room_id, name, phase, seen_latest_id):
-    """Delete an expert's latest opinion while paused; its assignment is cancelled and the round no longer counts it.
-
-    The caller states the latest message id it saw, so a stale page cannot void an opinion that is no longer the one on screen.
-    """
-    if phase != "paused":
-        raise ValueError("请先暂停讨论，再作废专家的发言")
-    if seen_latest_id is None:
-        raise ValueError("作废发言须带上所见的最新消息编号 latest_id")
-    if seen_latest_id != connection.execute("SELECT COALESCE(MAX(id),0) FROM messages WHERE room_id=?", (room_id,)).fetchone()[0]:
-        raise FileExistsError("房间已有新内容，请刷新后再作废")
-    row = connection.execute("""SELECT messages.id,details.turn_id FROM messages JOIN message_details AS details ON details.message_id=messages.id
-        WHERE messages.room_id=? AND messages.author=? AND details.kind='opinion' ORDER BY messages.id DESC LIMIT 1""",
-                             (room_id, name)).fetchone()
-    if not row:
-        raise LookupError(f"{name} 还没有可作废的发言")
-    message_id = row["id"]
-    connection.execute("UPDATE discussion_turns SET status='cancelled',answer_id=NULL WHERE answer_id=?", (message_id,))
-    connection.execute("UPDATE messages SET reply_to=NULL WHERE reply_to=?", (message_id,))
-    for table in ("message_timings", "message_summaries", "message_details"):
-        connection.execute(f"DELETE FROM {table} WHERE message_id=?", (message_id,))
-    connection.execute("DELETE FROM messages WHERE id=?", (message_id,))
-
-
 def require_fresh_member_token(connection, room_id, token):
     """Prevent owner or another member's credential from being reused for a new identity."""
     hashed = token_hash(token)

package/backend/room_import.py

@@ -115,7 +115,7 @@ def history_statements(tables, room_id, maps):
 
 
 def settings_statements(tables, room, maps, now):
-    """Topic, floor, limits and idle clock; an active brainstorm arrives paused because it has no run."""
+    """Topic, limits and idle clock (a backup's retired speaking floor is ignored); an active brainstorm arrives paused because it has no run."""
     room_id, messages, statements = room["id"], maps["messages"], []
     free = any(row.get("mode") == "free" for row in tables.get("room_modes", []))
     for row in tables.get("topic_settings", [])[:1]:
@@ -125,10 +125,6 @@ def settings_statements(tables, room, maps, now):
                          row["experts"], phase, remap_text(row.get("focus"), messages))),
                        ("INSERT INTO discussion_pauses (room_id,paused_at) VALUES (?,?)",
                         (room_id, 0 if phase in ACTIVE_PHASES else now))]
-    for row in tables.get("room_floor", [])[:1]:
-        statements.append(("""INSERT INTO room_floor (room_id,holder,next_speaker,revision) VALUES (?,?,?,?) ON CONFLICT(room_id)
-            DO UPDATE SET holder=excluded.holder,next_speaker=excluded.next_speaker,revision=excluded.revision""",
-                           (room_id, row.get("holder"), row["next_speaker"], row.get("revision", 0))))
     for row in tables.get("discussion_limits", [])[:1]:
         statements.append((f"UPDATE discussion_limits SET {','.join(f'{field}=?' for field in LIMIT_FIELDS)} WHERE room_id=?",
                            (*(row[field] for field in LIMIT_FIELDS), room_id)))

package/backend/runtime.py

@@ -7,8 +7,9 @@ import uuid
 
 LEASE_SECONDS = 120
 MAX_RUN_SECONDS = 86400
-LIMIT_DEFAULTS = {"max_rounds": 0, "max_minutes": 0, "execution_minutes": 0,
-                  "on_limit": "pause", "summary_minutes": 5}
+LIMIT_DEFAULTS = {"max_rounds": 0, "max_minutes": 0, "execution_minutes": 0}
+# Older clients may still send these; reaching a limit always pauses, so only the pause value is accepted and the reserve is ignored.
+LEGACY_LIMIT_FIELDS = ("on_limit", "summary_minutes")
 PUBLIC_EVENT_FIELDS = ("id", "room_id", "run_id", "generation", "cause", "participant",
                        "role", "turn_id", "status", "session_id", "lease_until", "result", "created_at")
 LIMITS_SQL = """SELECT limits.*,COALESCE(pauses.paused_seconds,0)+CASE WHEN COALESCE(pauses.paused_at,0)>0
@@ -39,18 +40,15 @@ def begin_write(connection):
 
 def limit_values(payload, current=None):
     """Validate bounded discussion settings; zero means no round/time preset."""
-    if not isinstance(payload, dict) or set(payload) - set(LIMIT_DEFAULTS):
+    if not isinstance(payload, dict) or set(payload) - set(LIMIT_DEFAULTS) - set(LEGACY_LIMIT_FIELDS):
         raise ValueError("limits 仅接受讨论上限配置字段")
+    if payload.get("on_limit", "pause") != "pause":
+        raise ValueError("到限后只会暂停；需要总结时请主持人在暂停后按你的要求写出")
     result = {key: (current or {}).get(key, value) for key, value in LIMIT_DEFAULTS.items()}
-    result.update(payload)
-    for key, minimum, maximum in (("max_rounds", 0, 100), ("max_minutes", 0, 1440),
-                                  ("execution_minutes", 0, 60), ("summary_minutes", 1, 60)):
+    result.update({key: value for key, value in payload.items() if key in LIMIT_DEFAULTS})
+    for key, minimum, maximum in (("max_rounds", 0, 100), ("max_minutes", 0, 1440), ("execution_minutes", 0, 60)):
         if type(result[key]) is not int or not minimum <= result[key] <= maximum:
             raise ValueError(f"{key} 须为 {minimum}–{maximum} 的整数")
-    if result["on_limit"] not in ("pause", "summarize"):
-        raise ValueError("on_limit 须为 pause 或 summarize")
-    if result["on_limit"] == "summarize" and result["max_minutes"] and result["summary_minutes"] >= result["max_minutes"]:
-        raise ValueError("收束预留时间必须小于讨论总时长")
     return result
 
 
@@ -63,10 +61,6 @@ def limits_view(row, room):
     if room.get("runtime", {}).get("deadline") and (room["runtime"]["status"] == "running" or result["stop_reason"]):
         runtime_deadline = room["runtime"]["deadline"]
         deadline = min(deadline or runtime_deadline, runtime_deadline)
-    if result["closing_at"]:
-        closing_deadline = result["closing_at"] + result["summary_minutes"] * 60
-        deadline = min(deadline or closing_deadline, closing_deadline)
-    cutoff = deadline - result["summary_minutes"] * 60 if deadline and result["on_limit"] == "summarize" and not result["closing_at"] else deadline
     reason = ""
     budget = room.get("round_budget")
     experts = len(room.get("experts") or {})
@@ -78,14 +72,9 @@ def limits_view(row, room):
     round_cap = (budget["cap"] or result["max_rounds"]) if budget else result["max_rounds"]
     if deadline and now >= deadline:
         reason = "time_limit"
-    elif result["closing_at"]:
-        reason = result["stop_reason"]
     elif round_cap and segment_rounds >= round_cap:
         reason = "round_limit"
-    elif cutoff and now >= cutoff:
-        reason = "summary_reserved" if result["on_limit"] == "summarize" else "time_limit"
-    result.update(deadline=deadline, cutoff=cutoff, reached=bool(reason), reason=reason,
-                  closing=bool(result["closing_at"]) and room["phase"] not in ("paused", "concluded"), completed_rounds=room["completed_rounds"],
+    result.update(deadline=deadline, reached=bool(reason), reason=reason, completed_rounds=room["completed_rounds"],
                   segment_rounds=segment_rounds, round_cap=round_cap, extra_rounds=budget["extra"] if budget else 0,
                   remaining_seconds=max(0, deadline - now) if deadline else None,
                   elapsed_seconds=max(0, now - result["started_at"] - idle) if result["started_at"] else 0)
@@ -95,7 +84,7 @@ def limits_view(row, room):
 def require_within_limits(room):
     """Stop new expert work at the configured boundary, preserving user notes."""
     if room["limits"]["reached"]:
-        raise FileExistsError("已达到讨论上限；请检查上限并暂停或由主持人总结")
+        raise FileExistsError("已达到讨论上限；请检查上限并暂停，由用户决定追加轮次或结束")
 
 
 def execution_seconds(connection, room_id):
@@ -191,12 +180,6 @@ def authorize_participant(connection, room_id, identity, operation, payload):
                                     (room_id, author)).fetchone()
         if author != actor and not (online and identity["role"] in ("owner", "host")):
             raise PermissionError("只能提交本人观点，或由房主、主持人代发在线成员原文")
-    elif operation == "floor":
-        speaker = payload.get("speaker", actor)
-        online = connection.execute("SELECT 1 FROM room_members WHERE room_id=? AND name=? AND access='online' AND status='active'",
-                                    (room_id, speaker)).fetchone()
-        if identity["role"] != "owner" and speaker != actor and not (identity["role"] == "host" and online):
-            raise PermissionError("只能操作本人发言权")
     elif operation != "attachments" and identity["role"] != "owner":
         if identity["role"] != "host" or operation not in ("topic", "state", "turns", "limits"):
             raise PermissionError("本成员没有此管理权限")
@@ -235,11 +218,14 @@ def authorize_write(connection, room_id, token, operation, payload):
     if operation == "messages":
         if payload.get("author") != actor:
             raise PermissionError("自动执行不能代发其他参与者")
-        if event["role"] == "expert" and payload.get("turn_id") != event["turn_id"]:
+        if event["role"] == "expert" and payload.get("turn_id") not in (None, event["turn_id"]):
             raise PermissionError("回答必须关联本次安排")
-    elif operation == "floor":
-        if payload.get("speaker", actor) != actor:
-            raise PermissionError("自动执行只能操作本人发言权")
+        if event["role"] == "expert" and payload.get("turn_id") is None:
+            # Without a named arrangement the answer belongs to the expert's open one, which must be this execution's.
+            open_turn = connection.execute("SELECT id FROM discussion_turns WHERE room_id=? AND expert=? AND status IN ('pending','notified')",
+                                           (room_id, actor)).fetchone()
+            if not open_turn or open_turn["id"] != event["turn_id"]:
+                raise PermissionError("回答必须关联本次安排")
     elif operation == "attachments":
         pass
     elif event["role"] != "host" or operation not in ("topic", "state", "turns", "limits"):
@@ -292,10 +278,6 @@ def validate_start(connection, room_id, payload):
     limits = connection.execute(LIMITS_SQL, (room_id,)).fetchone()
     configured = ((limits["started_at"] or int(time.time())) + limits["max_minutes"] * 60 + limits["idle_seconds"]
                   if limits["max_minutes"] else 0)
-    if limits["closing_at"]:
-        closing_deadline = limits["closing_at"] + limits["summary_minutes"] * 60
-        previous_deadline = runtime_view(connection, room_id).get("deadline", 0)
-        configured = min(value for value in (configured, closing_deadline, previous_deadline) if value)
     deadline = payload.get("deadline", configured)
     if type(deadline) is int and configured:
         deadline = min(deadline or configured, configured)
@@ -379,6 +361,10 @@ def reserve_event(connection, event, payload):
     if connection.execute("SELECT 1 FROM discussion_events WHERE room_id=? AND status IN ('dispatched','started')",
                           (event["room_id"],)).fetchone():
         raise FileExistsError("已有在途执行")
+    if connection.execute("""SELECT 1 FROM member_executions JOIN room_members ON room_members.id=member_executions.member_id
+                          WHERE member_executions.room_id=? AND room_members.name=? AND member_executions.status IN ('dispatched','started')""",
+                          (event["room_id"], event["participant"])).fetchone():
+        raise FileExistsError("该参与者正在回答用户的直接提问；同一会话不并发续接")
     connection.execute("UPDATE discussion_events SET status='dispatched',token_hash=? WHERE id=?", (hashed, event["id"]))
     if event["role"] == "host":
         connection.execute("UPDATE discussion_events SET status='completed',result=? WHERE room_id=? AND role='host' AND status='pending' AND id<?",

package/backend/schema.sql

@@ -144,27 +144,9 @@ CREATE TABLE IF NOT EXISTS room_floor (
     next_speaker TEXT NOT NULL,
     revision INTEGER NOT NULL DEFAULT 0
 );
-INSERT OR IGNORE INTO room_floor (room_id,holder,next_speaker)
-    SELECT rooms.id,CASE WHEN turns.id IS NULL THEN COALESCE(settings.host,'用户') END,
-        COALESCE(turns.expert,settings.host,'用户')
-    FROM rooms LEFT JOIN topic_settings AS settings ON settings.room_id=rooms.id
-    LEFT JOIN discussion_turns AS turns ON turns.room_id=rooms.id AND turns.status IN ('pending','notified');
-CREATE TRIGGER IF NOT EXISTS initialize_room_floor AFTER INSERT ON topic_settings
-BEGIN
-    INSERT INTO room_floor (room_id,holder,next_speaker) VALUES (NEW.room_id,NEW.host,NEW.host)
-        ON CONFLICT(room_id) DO UPDATE SET
-        holder=CASE WHEN holder='用户' THEN NEW.host ELSE holder END,
-        next_speaker=CASE WHEN next_speaker='用户' THEN NEW.host ELSE next_speaker END,
-        revision=revision+1;
-END;
-CREATE TRIGGER IF NOT EXISTS transfer_host_floor AFTER UPDATE OF host ON topic_settings
-WHEN OLD.host<>NEW.host
-BEGIN
-    UPDATE room_floor SET holder=CASE WHEN holder=OLD.host THEN NEW.host ELSE holder END,
-        next_speaker=CASE WHEN next_speaker=OLD.host THEN NEW.host ELSE next_speaker END,
-        revision=revision+1 WHERE room_id=NEW.room_id
-        AND NOT EXISTS (SELECT 1 FROM discussion_turns WHERE room_id=NEW.room_id AND status IN ('pending','notified') AND expert=OLD.host);
-END;
+-- The speaking floor is retired: the table stays only so old databases and backups load, and nothing reads or writes it.
+DROP TRIGGER IF EXISTS initialize_room_floor;
+DROP TRIGGER IF EXISTS transfer_host_floor;
 -- Site administrator account (single user) and its login sessions. Raw tokens and passwords are never stored.
 CREATE TABLE IF NOT EXISTS site_admin (
     id INTEGER PRIMARY KEY CHECK(id=1),
@@ -186,16 +168,12 @@ CREATE TABLE IF NOT EXISTS room_modes (
     mode TEXT NOT NULL CHECK(mode IN ('free','brainstorm')),
     control_hash TEXT NOT NULL DEFAULT ''
 );
--- Replaced on every start so existing databases drop the floor rule for free rooms.
+-- Replaced on every start so existing databases drop every speaking-floor rule.
 DROP TRIGGER IF EXISTS require_message_floor;
-CREATE TRIGGER require_message_floor BEFORE INSERT ON messages
-WHEN NEW.author<>'用户'
-    AND NOT EXISTS (SELECT 1 FROM messages WHERE room_id=NEW.room_id AND submission_id=NEW.submission_id)
-    AND NOT EXISTS (SELECT 1 FROM room_floor WHERE room_id=NEW.room_id AND holder=NEW.author)
-    AND NOT EXISTS (SELECT 1 FROM room_modes WHERE room_id=NEW.room_id AND mode='free')
-BEGIN
-    SELECT RAISE(ABORT, 'floor_required');
-END;
+DROP TRIGGER IF EXISTS return_message_floor;
+DROP TRIGGER IF EXISTS require_host_floor;
+DROP TRIGGER IF EXISTS nominate_expert_floor;
+DROP TRIGGER IF EXISTS cancel_turn_floor;
 CREATE TRIGGER IF NOT EXISTS require_opinion_turn BEFORE INSERT ON message_details
 WHEN NEW.kind='opinion' AND NEW.turn_id IS NULL
     AND NOT EXISTS (SELECT 1 FROM message_details WHERE message_id=NEW.message_id)
@@ -203,35 +181,6 @@ WHEN NEW.kind='opinion' AND NEW.turn_id IS NULL
 BEGIN
     SELECT RAISE(ABORT, 'floor_turn_required');
 END;
-CREATE TRIGGER IF NOT EXISTS return_message_floor AFTER INSERT ON message_details
-WHEN EXISTS (SELECT 1 FROM messages WHERE id=NEW.message_id AND author<>'用户')
-BEGIN
-    UPDATE room_floor SET holder=NULL,
-        next_speaker=COALESCE((SELECT host FROM topic_settings WHERE room_id=room_floor.room_id),'用户'),
-        revision=revision+1 WHERE room_id=(SELECT room_id FROM messages WHERE id=NEW.message_id);
-END;
-DROP TRIGGER IF EXISTS require_host_floor;
--- Queued turns of a round plan are inserted after the first one has already nominated an expert.
-CREATE TRIGGER require_host_floor BEFORE INSERT ON discussion_turns
-WHEN NEW.status<>'queued' AND NOT EXISTS (SELECT 1 FROM discussion_turns WHERE room_id=NEW.room_id AND submission_id=NEW.submission_id)
-    AND NOT EXISTS (SELECT 1 FROM room_floor WHERE room_id=NEW.room_id
-                    AND holder=COALESCE((SELECT host FROM topic_settings WHERE room_id=NEW.room_id),'用户'))
-BEGIN
-    SELECT RAISE(ABORT, 'floor_required');
-END;
-DROP TRIGGER IF EXISTS nominate_expert_floor;
-CREATE TRIGGER nominate_expert_floor AFTER INSERT ON discussion_turns
-WHEN NEW.status<>'queued'
-BEGIN
-    UPDATE room_floor SET holder=NULL,next_speaker=NEW.expert,revision=revision+1 WHERE room_id=NEW.room_id;
-END;
-CREATE TRIGGER IF NOT EXISTS cancel_turn_floor AFTER UPDATE OF status ON discussion_turns
-WHEN NEW.status='cancelled' AND OLD.status<>NEW.status
-BEGIN
-    UPDATE room_floor SET holder=NULL,
-        next_speaker=COALESCE((SELECT host FROM topic_settings WHERE room_id=NEW.room_id),'用户'),
-        revision=revision+1 WHERE room_id=NEW.room_id;
-END;
 
 -- Runtime control is opt-in. Legacy rooms have no runtime row and keep manual entry.
 CREATE TABLE IF NOT EXISTS discussion_limits (
@@ -369,7 +318,6 @@ DROP TRIGGER IF EXISTS relay_turn_promoted;
 CREATE TRIGGER relay_turn_promoted AFTER UPDATE OF status ON discussion_turns
 WHEN OLD.status='queued' AND NEW.status='pending'
 BEGIN
-    UPDATE room_floor SET holder=NULL,next_speaker=NEW.expert,revision=revision+1 WHERE room_id=NEW.room_id;
     UPDATE turn_relay SET held_since=0 WHERE room_id=NEW.room_id
         AND NOT EXISTS(SELECT 1 FROM messages m JOIN discussion_events e ON e.room_id=m.room_id AND e.role='host' AND e.status='started'
         WHERE m.room_id=NEW.room_id AND m.author='用户' AND CAST(strftime('%s',m.created_at) AS INTEGER)>e.started_at);
@@ -679,3 +627,47 @@ CREATE TABLE IF NOT EXISTS room_links (
     parent_id TEXT NOT NULL,
     created_at TEXT NOT NULL
 );
+
+-- A discussion is a switch on a room, not a room type: one thin session per started discussion. Its status mirrors the legacy
+-- topic phase until the phase machinery is retired. Free rooms have none.
+CREATE TABLE IF NOT EXISTS discussion_sessions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    goal TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'paused' CHECK(status IN ('active','paused','concluded')),
+    started_message_id INTEGER NOT NULL DEFAULT 0,
+    ended_message_id INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS one_open_session ON discussion_sessions(room_id) WHERE status IN ('active','paused');
+-- Rooms that predate sessions: every non-free room with topic settings gets one, mapped from its phase. Safe to repeat.
+INSERT INTO discussion_sessions (room_id,goal,status,started_message_id,ended_message_id,created_at)
+SELECT rooms.id,rooms.goal,
+       CASE WHEN topic_settings.phase='concluded' THEN 'concluded' WHEN topic_settings.phase IN ('preparing','paused') THEN 'paused' ELSE 'active' END,
+       0,CASE WHEN topic_settings.phase='concluded' THEN COALESCE((SELECT MAX(id) FROM messages WHERE room_id=rooms.id),0) ELSE 0 END,rooms.created_at
+FROM rooms JOIN topic_settings ON topic_settings.room_id=rooms.id
+WHERE NOT EXISTS (SELECT 1 FROM room_modes WHERE room_id=rooms.id AND mode='free')
+  AND NOT EXISTS (SELECT 1 FROM discussion_sessions WHERE room_id=rooms.id);
+DROP TRIGGER IF EXISTS session_for_new_discussion;
+CREATE TRIGGER session_for_new_discussion AFTER INSERT ON room_modes
+WHEN NEW.mode='brainstorm' AND NOT EXISTS (SELECT 1 FROM discussion_sessions WHERE room_id=NEW.room_id)
+BEGIN
+    INSERT INTO discussion_sessions (room_id,goal,status,created_at)
+    SELECT rooms.id,rooms.goal,
+           COALESCE((SELECT CASE WHEN phase='concluded' THEN 'concluded' WHEN phase IN ('preparing','paused') THEN 'paused' ELSE 'active' END
+                     FROM topic_settings WHERE room_id=rooms.id),'paused'),rooms.created_at
+    FROM rooms WHERE rooms.id=NEW.room_id;
+END;
+DROP TRIGGER IF EXISTS session_follows_phase_insert;
+CREATE TRIGGER session_follows_phase_insert AFTER INSERT ON topic_settings
+BEGIN
+    UPDATE discussion_sessions SET status=CASE WHEN NEW.phase='concluded' THEN 'concluded' WHEN NEW.phase IN ('preparing','paused') THEN 'paused' ELSE 'active' END
+    WHERE id=(SELECT MAX(id) FROM discussion_sessions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS session_follows_phase;
+CREATE TRIGGER session_follows_phase AFTER UPDATE OF phase ON topic_settings
+BEGIN
+    UPDATE discussion_sessions SET status=CASE WHEN NEW.phase='concluded' THEN 'concluded' WHEN NEW.phase IN ('preparing','paused') THEN 'paused' ELSE 'active' END,
+        ended_message_id=CASE WHEN NEW.phase='concluded' THEN COALESCE((SELECT MAX(id) FROM messages WHERE room_id=NEW.room_id),0) ELSE 0 END
+    WHERE id=(SELECT MAX(id) FROM discussion_sessions WHERE room_id=NEW.room_id);
+END;