ai_co_discuss 0.2.32 → 0.2.34

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

@@ -21,6 +21,7 @@ description: "AI CoDiscuss 的主持技能，仅主持人调用，且须同时
 
 - `initial`：必要专家先独立判断。用户明确允许某位专家先读他人观点时，在该专家的安排问题里写明“对 initial 独立阅读限制的明确例外”，API 专家的读取限制据此放开，其他专家按技能约定。主持人兼任专家时也要贡献自己的观点；尽量先安排自己，避免先读他人回答再声称独立。
 - `discussing`：找出会改变结论的事实、假设、标准或偏好差异，请最相关的人回应。一轮内每位专家各回应一次，轮次以此计数；不连续安排刚发言的专家，新一轮也不先安排上一轮最后发言者。只有需要其本人澄清刚发表内容的事实或原意时才例外，并在简报中说明原因。
+- 房间的 `named_followup`（点名追问）为 false 时，首轮照常拆题出题；之后各轮不给每位专家写针对性追问，统一请专家先读上一轮回答、回应不同意或需补充的观点、可 @ 彼此提问。需要引导方向时用自己的主持说明表达，不改写成逐人点名。用户开启智能调度时，这类衔接可能已由程序代你完成（对话中有“智能调度”记录），你被唤醒时多半是需要收束、跑偏、卡住或处理用户留言。
 - `reviewing`：仅在需要时，用拟定结论请相关当事人核对原意、条件和剩余阻碍；不是让全员再赞同一次。
 - `concluded`：已有足够依据完成本次目标，或依约交付有限结论。明确哪些已确认、哪些仍有分歧、缺什么证据；到限不等于达成共识。
 
@@ -55,7 +56,7 @@ description: "AI CoDiscuss 的主持技能，仅主持人调用，且须同时
 
 收到自动任务后，按参与技能进入本次执行；若当前调用已成功进入，不重复认领。不创建原生定时，也不手动通知已配置的本地专家，通知程序负责后续交付与续租。
 
-阅读新增的相关回答、用户约束及必要原文，判断下一步是追问、补证、复核还是收束。任务带 `scheduler_suggestions` 时，那是用户开启的智能调度对未处理留言给出的分流建议（请某位专家回应、主持人处理或仅补充信息），附置信度；读原文后自行决定是否采纳，不当作用户指令或已核实的判断。不要只回复“已就绪”或只写一段摘要就退出；本次执行需要以以下一种结果交接：
+阅读新增的相关回答、用户约束及必要原文，判断下一步是追问、补证、复核还是收束。用户开启智能调度后，程序有把握时会代你完成插话分流（按原计划继续或先请某位专家回应）和无点名追问时的下一轮衔接，并在 `room view` 的 `scheduler_decisions` 留下记录；没把握时才唤醒你。任务带 `scheduler_suggestions` 时，那是它对未处理留言的判断，附置信度；读原文后自行决定是否采纳，不当作用户指令或已核实的判断。不要只回复“已就绪”或只写一段摘要就退出；本次执行需要以以下一种结果交接：
 
 | 判断 | 保存与结束边界 |
 | --- | --- |

package/backend/free_room.py

@@ -27,6 +27,9 @@ MAX_PATH_LENGTH = 500
 ACTIVE = ("dispatched", "started")
 ACCESS_MODES = ("runner", "manual", "online")
 SCHEDULER_PROVIDERS = ("jev", "decisions")
+RECOMMEND_SECONDS = 60
+# A click sent just before the hint disappears still counts.
+RECOMMEND_GRACE_SECONDS = 5
 # AI-created requests (host dispatches and hand-offs) allowed per chain; each owner message starts a chain.
 MAX_AUTO_HOPS = 8
 # A host that left gives up the role; the first active runner member (else manual) then takes it.
@@ -236,14 +239,13 @@ def free_view(connection, room_id):
         members.append(member)
     names = {row["id"]: row["name"] for row in connection.execute("SELECT id,name FROM room_members WHERE room_id=?", (room_id,))}
     requests = [{**dict(row), "member": names.get(row["member_id"], "")} for row in connection.execute(
-        """SELECT id,member_id,message_id,status,execution_id,answer_id,chain_id,batch_id,purpose,created_by,
-        (SELECT provider FROM request_schedules WHERE request_id=member_requests.id) AS schedule_provider,
-        (SELECT confidence FROM request_schedules WHERE request_id=member_requests.id) AS schedule_confidence FROM member_requests
+        """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))]
     chains = [dict(row) for row in connection.execute(
         "SELECT chain_id,reason FROM free_chains WHERE room_id=? ORDER BY chain_id DESC LIMIT 10", (room_id,))]
     return {"members": members, "requests": requests[::-1], "executions": recent_executions(connection, room_id), "execution_minutes": execution_minutes(connection, room_id),
-            "conflicts": possible_conflicts(connection, room_id, names), "halted_chains": chains, "max_auto_hops": MAX_AUTO_HOPS}
+            "conflicts": possible_conflicts(connection, room_id, names), "halted_chains": chains, "max_auto_hops": MAX_AUTO_HOPS,
+            "recommendations": recent_recommendations(connection, room_id, now)[::-1]}
 
 
 def require_member(connection, room_id, token, name=None):
@@ -557,6 +559,7 @@ def inbox(connection, room_id, token):
     require_owner(connection, room_id, token)
     begin_write(connection)
     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,)):
@@ -570,28 +573,76 @@ def inbox(connection, room_id, token):
             "execution_minutes": execution_minutes(connection, room_id)}
 
 
-def schedule_request(connection, room_id, token, request_id, payload):
-    """Smart scheduling moves one unnamed message from the host to a woken member before the host takes it."""
+def host_route_request(connection, message_id):
+    """The host's request for one unnamed owner message, if the message was routed."""
+    return connection.execute("SELECT * FROM member_requests WHERE message_id=? AND purpose='route'", (message_id,)).fetchone()
+
+
+def recommend_member(connection, room_id, token, payload):
+    """Smart scheduling suggests another member for an unnamed message; the host keeps it until the user adopts."""
     require_owner(connection, room_id, token)
     begin_write(connection)
-    if payload.get("action") != "schedule":
-        raise ValueError("只支持 action=schedule")
     confidence = payload.get("confidence")
     if payload.get("provider") not in SCHEDULER_PROVIDERS or type(confidence) not in (int, float) or not 0 <= confidence <= 1:
         raise ValueError("须提供智能调度供应商 provider 与 0–1 的置信度 confidence")
-    request = connection.execute("SELECT * FROM member_requests WHERE room_id=? AND id=?", (room_id, request_id)).fetchone()
-    if not request:
-        raise LookupError("请求不存在")
-    if request["purpose"] != "route" or request["status"] != "pending":
-        raise FileExistsError("请求已由主持人接手或已处理，不能改派")
+    message_id = payload.get("message_id")
+    route = host_route_request(connection, message_id) if type(message_id) is int else None
+    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 role<>'host'""", (room_id, payload.get("member_id"))).fetchone()
+        AND access='runner' AND id<>?""", (room_id, payload.get("member_id"), route["member_id"])).fetchone()
     if not target:
-        raise LookupError("改派对象须为在场、由本机唤醒的非主持成员")
-    connection.execute("UPDATE member_requests SET member_id=?,purpose='scheduled' WHERE id=?", (target["id"], request_id))
-    connection.execute("INSERT OR REPLACE INTO request_schedules (request_id,room_id,provider,confidence) VALUES (?,?,?,?)",
-                       (request_id, room_id, payload["provider"], float(confidence)))
-    return dict(connection.execute("SELECT * FROM member_requests WHERE id=?", (request_id,)).fetchone())
+        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))
+    return dict(connection.execute("SELECT * FROM member_recommendations WHERE message_id=?", (message_id,)).fetchone())
+
+
+def release_recommendations(connection, room_id):
+    """Ask each adopted-later member once the host's request for that message has ended in any way."""
+    for row in connection.execute("""SELECT rec.* FROM member_recommendations rec JOIN member_requests r ON r.message_id=rec.message_id AND r.purpose='route'
+        WHERE rec.room_id=? AND rec.status='waiting' AND r.status IN ('completed','cancelled','failed')""", (room_id,)).fetchall():
+        connection.execute("UPDATE member_recommendations SET status='adopted' WHERE message_id=?", (row["message_id"],))
+        if connection.execute("SELECT 1 FROM room_members WHERE id=? AND status='active'", (row["member_id"],)).fetchone():
+            connection.execute("""INSERT OR IGNORE INTO member_requests (room_id,member_id,message_id,chain_id,purpose,created_by,created_at)
+                VALUES (?,?,?,?,'ask','user',?)""", (room_id, row["member_id"], row["message_id"], row["message_id"], int(time.time())))
+
+
+def adopt_recommendation(connection, room_id, token, message_id, payload):
+    """The user adopts a recommendation before it expires: interrupt the host now, or ask the member after the host."""
+    require_owner(connection, room_id, token)
+    begin_write(connection)
+    if payload.get("action") != "adopt" or payload.get("mode") not in ("interrupt", "after"):
+        raise ValueError("采纳须为 action=adopt，mode 为 interrupt 或 after")
+    row = connection.execute("SELECT * FROM member_recommendations WHERE room_id=? AND message_id=?", (room_id, message_id)).fetchone()
+    if not row:
+        raise LookupError("这条消息没有智能调度推荐")
+    if row["status"] != "open":
+        return {"recommendation": dict(row), "duplicate": True}
+    if int(time.time()) > row["expires_at"] + RECOMMEND_GRACE_SECONDS:
+        raise FileExistsError("推荐已过期，可直接 @ 该成员")
+    if not connection.execute("SELECT 1 FROM room_members WHERE id=? AND status='active'", (row["member_id"],)).fetchone():
+        raise FileExistsError("推荐的成员已离开")
+    route = host_route_request(connection, message_id)
+    mode = payload["mode"]
+    if mode == "interrupt" and route["status"] == "delivering":
+        # The host's execution may carry other messages too; stopping it voids that whole execution.
+        finish_execution(connection, route["execution_id"], "cancelled", "用户采纳智能调度推荐，改由其他成员回答", "cancelled")
+    elif mode == "interrupt" and route["status"] == "pending":
+        connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (route["id"],))
+    connection.execute("UPDATE member_recommendations SET status='waiting',mode=? WHERE message_id=?", (mode, message_id))
+    release_recommendations(connection, room_id)
+    settle_batches(connection, room_id)
+    return {"recommendation": dict(connection.execute("SELECT * FROM member_recommendations WHERE message_id=?", (message_id,)).fetchone()),
+            "duplicate": False}
+
+
+def recent_recommendations(connection, room_id, now):
+    """Recommendations shown beside their messages, with seconds left to adopt an open one."""
+    return [{**dict(row), "expires_in": max(0, row["expires_at"] - now)} for row in connection.execute(
+        """SELECT rec.*,m.name AS member FROM member_recommendations rec JOIN room_members m ON m.id=rec.member_id
+        WHERE rec.room_id=? ORDER BY rec.message_id DESC LIMIT ?""", (room_id, RECENT_REQUESTS))]
 
 
 def reserve_execution(connection, room_id, token, payload):
@@ -790,11 +841,26 @@ def discussion_member_action(connection, room_id, member_id, token, payload):
         require_fresh_member_token(connection, room_id, payload.get("token"))
         connection.execute("UPDATE room_members SET status='active',token_hash=? WHERE id=?", (hashed, member_id))
         experts[member["name"]] = "online" if member["access"] == "online" else "cli"
+    elif action == "adopt":
+        adopt_manual_member(connection, room_id, member, payload)
+        return
     else:
-        raise ValueError("action 须为 away、active、remove 或 redo")
+        raise ValueError("action 须为 away、active、remove、redo 或 adopt")
     save_discussion_experts(connection, room_id, experts)
 
 
+def adopt_manual_member(connection, room_id, member, payload):
+    """Hand a manual expert to the local service once its CLI reported the session it runs in; the owner's service resumes that session."""
+    reported = connection.execute("SELECT session_id FROM member_sessions WHERE member_id=?", (member["id"],)).fetchone()
+    run = connection.execute("SELECT mode FROM discussion_runtime WHERE room_id=?", (room_id,)).fetchone()
+    if not reported or reported["session_id"] != payload.get("session_id") or payload.get("adapter") != "claude":
+        raise ValueError("成员尚未上报与之相符的会话，不能转为托管")
+    if member["access"] != "manual" or member["status"] != "active" or not run or run["mode"] != "automatic":
+        raise ValueError("只有全自动讨论中在场的手动专家可以转为托管")
+    connection.execute("UPDATE room_members SET access='runner',adapter='claude',session_mode='borrowed' WHERE id=?", (member["id"],))
+    connection.execute("DELETE FROM member_sessions WHERE member_id=?", (member["id"],))
+
+
 def void_latest_opinion(connection, room_id, name, phase):
     """Delete an expert's latest opinion while paused; its assignment is cancelled and the round no longer counts it."""
     if phase != "paused":

package/backend/room_import.py

@@ -137,6 +137,12 @@ def settings_statements(tables, room, maps, now):
     for row in tables.get("room_briefs", [])[:1]:
         statements.append(("INSERT INTO room_briefs (room_id,text,until,updated_at) VALUES (?,?,?,?)",
                            (room_id, remap_text(row["text"], messages), remap_until(row["until"], messages), row["updated_at"])))
+    for row in tables.get("discussion_options", [])[:1]:
+        statements.append(("INSERT INTO discussion_options (room_id,named_followup) VALUES (?,?)", (room_id, row["named_followup"])))
+    statements += [("""INSERT INTO scheduler_decisions (room_id,after_message_id,kind,label,confidence,applied,provider,created_at)
+                       VALUES (?,?,?,?,?,?,?,?)""", (room_id, messages.get(row["after_message_id"], 0), row["kind"], row["label"],
+                                                     row.get("confidence"), row["applied"], row["provider"], row["created_at"]))
+                   for row in tables.get("scheduler_decisions", [])]
     return statements
 
 
@@ -159,8 +165,11 @@ def record_statements(tables, room_id, maps):
                    for row in tables.get("member_requests", [])]
     statements += [("INSERT INTO member_suggestions (message_id,member_id) VALUES (?,?)", (messages[row["message_id"]], members[row["member_id"]]))
                    for row in tables.get("member_suggestions", [])]
-    statements += [("INSERT INTO request_schedules (request_id,room_id,provider,confidence) VALUES (?,?,?,?)",
-                    (requests[row["request_id"]], room_id, row["provider"], row["confidence"])) for row in tables.get("request_schedules", [])]
+    # Imported recommendations are history only: an open or waiting one no longer acts.
+    statements += [("""INSERT INTO member_recommendations (message_id,room_id,member_id,provider,confidence,created_at,expires_at,status,mode)
+                       VALUES (?,?,?,?,?,?,?,?,?)""", (messages[row["message_id"]], room_id, members[row["member_id"]], row["provider"], row["confidence"],
+                                                       row["created_at"], row["expires_at"], "adopted" if row["status"] == "adopted" else "open", row.get("mode", "")))
+                   for row in tables.get("member_recommendations", [])]
     return statements
 
 

package/backend/schema.sql

@@ -533,6 +533,13 @@ CREATE TABLE IF NOT EXISTS room_members (
 );
 CREATE UNIQUE INDEX IF NOT EXISTS member_name ON room_members(room_id,name) WHERE status<>'removed';
 CREATE UNIQUE INDEX IF NOT EXISTS member_credential ON room_members(room_id,token_hash);
+-- A manual member's own software session, reported by its CLI on posting; the local service uses it to take the member over.
+CREATE TABLE IF NOT EXISTS member_sessions (
+    member_id INTEGER PRIMARY KEY REFERENCES room_members(id) ON DELETE CASCADE,
+    room_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    client TEXT NOT NULL
+);
 CREATE TABLE IF NOT EXISTS member_executions (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
@@ -569,12 +576,36 @@ CREATE TABLE IF NOT EXISTS member_requests (
     UNIQUE(message_id,member_id)
 );
 CREATE INDEX IF NOT EXISTS member_requests_open ON member_requests(member_id,status);
--- Smart scheduling's decision for a request it moved from the host to a member; a separate table so D1 needs no column change.
-CREATE TABLE IF NOT EXISTS request_schedules (
-    request_id INTEGER PRIMARY KEY REFERENCES member_requests(id) ON DELETE CASCADE,
+-- Discussion options chosen at creation. A room without a row predates the option and keeps named follow-ups.
+CREATE TABLE IF NOT EXISTS discussion_options (
+    room_id TEXT PRIMARY KEY REFERENCES rooms(id) ON DELETE CASCADE,
+    named_followup INTEGER NOT NULL DEFAULT 0 CHECK(named_followup IN (0,1))
+);
+-- Visible record of each smart-scheduling decision in a discussion; it is not a message and moves no round or floor.
+CREATE TABLE IF NOT EXISTS scheduler_decisions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
     room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    after_message_id INTEGER NOT NULL DEFAULT 0,
+    kind TEXT NOT NULL CHECK(kind IN ('interjection','round')),
+    label TEXT NOT NULL,
+    confidence REAL,
+    applied INTEGER NOT NULL DEFAULT 0 CHECK(applied IN (0,1)),
     provider TEXT NOT NULL,
-    confidence REAL NOT NULL
+    created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS scheduler_decisions_room ON scheduler_decisions(room_id,id);
+-- 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 (
+    message_id INTEGER PRIMARY KEY REFERENCES messages(id) ON DELETE CASCADE,
+    room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    member_id INTEGER NOT NULL REFERENCES room_members(id) ON DELETE CASCADE,
+    provider TEXT NOT NULL,
+    confidence REAL NOT NULL,
+    created_at INTEGER NOT NULL,
+    expires_at INTEGER NOT NULL,
+    status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open','waiting','adopted')),
+    mode TEXT NOT NULL DEFAULT ''
 );
 -- Ordinary members can suggest a response without creating work or spending a chain budget.
 CREATE TABLE IF NOT EXISTS member_suggestions (

package/backend/server.py

@@ -23,7 +23,7 @@ from .free_room import (add_member, after_free_message, authorize_free_write, ch
                         inbox, interrupt_member, member_action, member_values, migrate_free_tables, proxy_member, reserve_execution,
                         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 schedule_request
+from .free_room import adopt_recommendation, recommend_member
 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,
@@ -44,6 +44,7 @@ LOCAL_LAUNCH_TIMEOUT = 60
 DIRECTORY_OPERATIONS = ("move", "folder")
 DIRECTORY_PICKER_TIMEOUT = 600  # the folder dialog waits for the person at the computer
 MAX_TEXT_LENGTH = 32000
+SESSION_ID_PATTERN = re.compile(r"[0-9A-Za-z_-]{8,128}")
 MAX_STATE_LENGTH = 4000
 MAX_BRIEF_LENGTH = 1600
 MAX_SUMMARY_LENGTH = 1000
@@ -71,11 +72,15 @@ TURN_STATUSES = {"pending": "待处理", "notified": "已通知，待回答", "a
 MAX_TOPIC_DETAIL = 4000
 MAX_QUESTION_LENGTH = 1000
 MAX_PLAN_TURNS = 10
+RECENT_DECISIONS = 100
+MAX_DECISION_LABEL = 200
+SCHEDULER_PROVIDERS = ("jev", "decisions")
 ROOM_BACKUP_QUERIES = {
     "rooms": "SELECT * FROM rooms WHERE id=?",
     **{table: f"SELECT * FROM {table} WHERE room_id=?" for table in (
         "room_directory", "room_folder_assignments", "room_creations", "room_briefs", "room_user_requests",
-        "topic_settings", "room_floor", "discussion_limits")},
+        "topic_settings", "room_floor", "discussion_limits", "discussion_options")},
+    "scheduler_decisions": "SELECT * FROM scheduler_decisions WHERE room_id=? ORDER BY id",
     "topic_folders": "SELECT * FROM topic_folders WHERE id IN (SELECT folder_id FROM room_folder_assignments WHERE room_id=?)",
     "messages": "SELECT * FROM messages WHERE room_id=? ORDER BY id",
     "attachments": "SELECT * FROM attachments WHERE room_id=? AND message_id IS NOT NULL ORDER BY message_id,position",
@@ -90,7 +95,7 @@ FREE_BACKUP_QUERIES = {
     "room_members": "SELECT id,room_id,name,adapter,role,status,read_until,created_at,access,session_mode FROM room_members WHERE room_id=? ORDER BY id",
     "member_requests": "SELECT * FROM member_requests WHERE room_id=? ORDER BY id",
     "member_suggestions": "SELECT s.* FROM member_suggestions s JOIN messages m ON m.id=s.message_id WHERE m.room_id=? ORDER BY s.message_id,s.member_id",
-    "request_schedules": "SELECT * FROM request_schedules WHERE room_id=? ORDER BY request_id",
+    "member_recommendations": "SELECT * FROM member_recommendations WHERE room_id=? ORDER BY message_id",
 }
 MESSAGE_QUERY = """SELECT messages.*, COALESCE(details.kind,'opinion') AS kind,
 COALESCE(details.submitted_by, CASE WHEN messages.source IN ('cli','api','url','user')
@@ -206,7 +211,13 @@ def require_room(connection, room_id):
     room["limits"] = limits_view(connection.execute(LIMITS_SQL, (room_id,)).fetchone(), room)
     room["mode"] = room_mode(connection, room_id)
     room["members"] = [dict(row) for row in connection.execute(
-        "SELECT id,name,adapter,role,status,access,session_mode FROM room_members WHERE room_id=? AND status<>'removed' ORDER BY id", (room_id,))]
+        """SELECT m.id,m.name,m.adapter,m.role,m.status,m.access,m.session_mode,COALESCE(s.session_id,'') AS reported_session
+        FROM room_members AS m LEFT JOIN member_sessions AS s ON s.member_id=m.id WHERE m.room_id=? AND m.status<>'removed' ORDER BY m.id""", (room_id,))]
+    option = connection.execute("SELECT named_followup FROM discussion_options WHERE room_id=?", (room_id,)).fetchone()
+    # Rooms created before the option keep the host's named follow-ups.
+    room["named_followup"] = bool(option[0]) if option else True
+    room["scheduler_decisions"] = [dict(row) for row in connection.execute(
+        "SELECT * FROM scheduler_decisions WHERE room_id=? ORDER BY id DESC LIMIT ?", (room_id, RECENT_DECISIONS))][::-1]
     parent = connection.execute("""SELECT rooms.id,rooms.title FROM room_links JOIN rooms ON rooms.id=room_links.parent_id
         WHERE room_links.room_id=?""", (room_id,)).fetchone()
     room["parent_room"] = dict(parent) if parent else None
@@ -538,7 +549,8 @@ 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 ("request_schedules", "member_requests", "member_executions", "room_members", "room_modes", "free_batches", "free_chains", "room_links"):
+    for table in ("member_recommendations", "member_requests", "member_executions", "member_sessions", "room_members", "room_modes", "free_batches", "free_chains", "room_links",
+                  "discussion_options", "scheduler_decisions"):
         connection.execute(f"DELETE FROM {table} WHERE room_id=?", (room_id,))
     connection.execute("DELETE FROM message_timings WHERE message_id IN (SELECT id FROM messages WHERE room_id=?)", (room_id,))
     connection.execute("DELETE FROM message_summaries WHERE message_id IN (SELECT id FROM messages WHERE room_id=?)", (room_id,))
@@ -578,6 +590,9 @@ def create_room(connection, payload, control_token=""):
         raise ValueError("建房须提供有效的运行模式和房主控制凭据")
     if free and (automatic or not token_hash(control_token)):
         raise ValueError("自由房间须提供房间控制凭据，且不使用讨论运行模式")
+    named_followup = payload.get("named_followup", False)
+    if type(named_followup) is not bool:
+        raise ValueError("named_followup 须为布尔值")
     parent_id = payload.get("parent_room_id")
     if parent_id is not None and (free or not isinstance(parent_id, str) or room_mode(connection, parent_id) != "free"):
         raise ValueError("只有从自由协作房间发起的讨论房间可以关联来源房间")
@@ -590,6 +605,8 @@ def create_room(connection, payload, control_token=""):
         [[member["name"], member["adapter"], member["access"], member["session_mode"], token_hash(member["token"])] for member in members], ensure_ascii=False)
     if free:
         request_text += ":free"
+    elif named_followup:
+        request_text += ":named_followup"
     if parent_id is not None:
         request_text += ":parent:" + parent_id
     if folder_id is not None:
@@ -613,6 +630,8 @@ def create_room(connection, payload, control_token=""):
                      {"mode": "free" if free else "brainstorm", "host": settings["host"], "created_at": utc_now()})
     if free:
         sync_participants(connection, room_id)
+    else:
+        connection.execute("INSERT INTO discussion_options (room_id,named_followup) VALUES (?,?)", (room_id, int(named_followup)))
     if parent_id is not None:
         connection.execute("INSERT INTO room_links (room_id,parent_id,created_at) VALUES (?,?,?)", (room_id, parent_id, utc_now()))
     if automatic:
@@ -855,6 +874,18 @@ def append_free_message(connection, room, payload, actor):
     return {"message": get_message(connection, room_id, cursor.lastrowid), "duplicate": False}
 
 
+def record_reported_session(connection, room_id, token, payload):
+    """Keep the software session a manual member posted from, so the local service can take the member over."""
+    session_id, client = payload.get("session_id"), payload.get("session_client")
+    if client != "claude" or not isinstance(session_id, str) or not SESSION_ID_PATTERN.fullmatch(session_id) or not token:
+        return
+    member = connection.execute("SELECT id FROM room_members WHERE room_id=? AND token_hash=? AND status='active' AND access='manual' AND adapter='manual'",
+                                (room_id, token_hash(token))).fetchone()
+    if member:
+        connection.execute("""INSERT INTO member_sessions (member_id,room_id,session_id,client) VALUES (?,?,?,?)
+            ON CONFLICT(member_id) DO UPDATE SET session_id=excluded.session_id,client=excluded.client""", (member["id"], room_id, session_id, client))
+
+
 def append_message(connection, room_id, payload, token="", free_actor=None):
     """Atomically append an attributed message and complete its scheduled turn."""
     author, text, submission_id, reply_to = message_values(payload)
@@ -893,6 +924,7 @@ def append_message(connection, room_id, payload, token="", free_actor=None):
         connection.execute("UPDATE attachments SET message_id=?,position=? WHERE id=?",
                            (cursor.lastrowid, position, identifier))
     record_message_timing(connection, cursor.lastrowid, token)
+    record_reported_session(connection, room_id, token, payload)
     if details["turn_id"]:
         connection.execute("UPDATE discussion_turns SET status='answered',answer_id=? WHERE id=?", (cursor.lastrowid, details["turn_id"]))
     return {"message": get_message(connection, room_id, cursor.lastrowid), "duplicate": False}
@@ -967,6 +999,23 @@ def create_turn(connection, room_id, payload):
             "queued": [get_turn(connection, room_id, turn_id) for turn_id in ids[1:]], "duplicate": False}
 
 
+def record_scheduler_decision(connection, room_id, token, payload):
+    """The dispatcher records one smart-scheduling decision so the transcript shows what it did and how sure it was."""
+    begin_write(connection)
+    require_control(connection, room_id, token)
+    kind, label, confidence = payload.get("kind"), payload.get("label"), payload.get("confidence")
+    after = payload.get("after_message_id", 0)
+    if kind not in ("interjection", "round") or not isinstance(label, str) or not 0 < len(label.strip()) <= MAX_DECISION_LABEL:
+        raise ValueError(f"决策记录须有 kind（interjection/round）与 1–{MAX_DECISION_LABEL} 字的 label")
+    if confidence is not None and (type(confidence) not in (int, float) or not 0 <= confidence <= 1):
+        raise ValueError("confidence 须为 0–1 或 null")
+    if payload.get("provider") not in SCHEDULER_PROVIDERS or type(payload.get("applied")) is not bool or type(after) is not int or after < 0:
+        raise ValueError("须提供供应商 provider、是否执行 applied 与非负的 after_message_id")
+    cursor = connection.execute("""INSERT INTO scheduler_decisions (room_id,after_message_id,kind,label,confidence,applied,provider,created_at)
+        VALUES (?,?,?,?,?,?,?,?)""", (room_id, after, kind, label.strip(), confidence, int(payload["applied"]), payload["provider"], utc_now()))
+    return dict(connection.execute("SELECT * FROM scheduler_decisions WHERE id=?", (cursor.lastrowid,)).fetchone())
+
+
 def continue_turns(connection, room_id, payload):
     """Resume the remaining round plan after the host has handled user actions or an interruption."""
     begin_write(connection)
@@ -1446,7 +1495,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
         """Forward authenticated browser requests to the shared Node entrypoint and pin their website."""
         site = self.local_request_site(method)
         route = parts[2:]
-        if method == "OPTIONS" and route in (["settings"], ["launch"], ["room-models"], ["room-member"], ["models"], ["api-key"], ["api-check"], ["pick-directory"]):
+        if method == "OPTIONS" and route in (["settings"], ["launch"], ["room-models"], ["room-member"], ["models"], ["api-key"], ["api-check"],
+                                             ["scheduler-check"], ["pick-directory"]):
             return self.respond({"ok": True})
         if route == ["settings"] and method in ("GET", "POST"):
             command = "settings"
@@ -1462,6 +1512,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             command = "api-key"
         elif route == ["api-check"] and method == "POST":
             command = "api-check"
+        elif route == ["scheduler-check"] and method == "POST":
+            command = "scheduler-check"
         elif route == ["room-member"] and method == "POST":
             command = "room-member"
         elif route == ["pick-directory"] and method == "POST":
@@ -1559,7 +1611,7 @@ class DiscussionHandler(BaseHTTPRequestHandler):
         room_id = parts[2]
         token = self.headers.get("X-Discussion-Token", "")
         free = room_mode(connection, room_id) == "free"
-        if free and parts[3:4] in (["inbox"], ["executions"], ["members"], ["suggestions"], ["requests"]):
+        if free and parts[3:4] in (["inbox"], ["executions"], ["members"], ["suggestions"], ["recommendations"]):
             return self.handle_free_api(connection, parts, method)
         if parts[3:4] == ["members"] and method == "POST" and len(parts) in (4, 5):
             if len(parts) == 4:
@@ -1571,7 +1623,7 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             return self.respond(result)
         if parts[3:4] == ["attachments"]:
             return self.handle_attachments(connection, parts, params, method)
-        if parts[3:4] in (["runtime"], ["events"]):
+        if parts[3:4] in (["runtime"], ["events"], ["scheduler-decisions"]):
             if free and method == "POST":
                 raise ValueError("自由房间不使用讨论运行控制")
             return self.handle_runtime_api(connection, parts, params, method)
@@ -1702,6 +1754,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             result = list_events(connection, room_id, token, params.get("after", 0))
         elif len(parts) == 5 and parts[3] == "events" and method == "POST":
             result = event_action(connection, room_id, int(parts[4]), token, self.read_payload())
+        elif parts[3:] == ["scheduler-decisions"] and method == "POST":
+            result = record_scheduler_decision(connection, room_id, token, self.read_payload())
         else:
             raise LookupError("地址不存在")
         connection.commit()
@@ -1717,8 +1771,10 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             result = convert_suggestion(connection, room_id, token, self.read_payload())
         elif parts[3:] == ["executions"] and method == "POST":
             result = reserve_execution(connection, room_id, token, self.read_payload())
-        elif len(parts) == 5 and parts[3] == "requests" and method == "POST":
-            result = schedule_request(connection, room_id, token, int(parts[4]), self.read_payload())
+        elif parts[3:] == ["recommendations"] and method == "POST":
+            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) == 5 and parts[3] == "executions":
             execution_id = int(parts[4])
             result = (view_execution(connection, room_id, execution_id, token) if method == "GET"

package/docs/architecture.md

@@ -215,6 +215,12 @@ Python 通过进程内条件变量唤醒订阅者，不占用数据库连接，
 
 未提供用户登录、讨论并行发言队列或跨站数据同步。自动执行保护不替代账号认证。Skill 行为、浏览器实际送达、软件原生任务启停与 API 账号的真实可用性必须通过实际环境验证；测试替身成功不能替代这些外部结果。
 
+## 讨论选项与智能调度记录
+
+- `discussion_options`：建房时的讨论选项，目前只有 `named_followup`（0/1，建房 `named_followup` 布尔值，默认 false，计入建房幂等比对）。没有记录的旧房间视为 true；房间视图返回 `named_followup`。
+- `scheduler_decisions`：讨论中每次智能调度判断的可见记录（`kind` 为 `interjection` / `round`，`label`、`confidence`、`applied`、`provider`、`after_message_id`），由接入程序用运行控制凭据 `POST scheduler-decisions` 写入，不是消息，不影响轮次、发言权与暂扣；房间视图 `scheduler_decisions` 返回最近 100 条。
+- 两表都是独立表，D1 重新应用 schema 即可；备份、导入（`after_message_id` 随消息重编号）与删除一并处理。智能调度代主持人执行的写入不新增权限，沿用该主持事件的执行凭据。
+
 ## 自动运行协议
 
 `discussion_limits` 保存房间上限及开始/收束时间。房间响应附 `limits` 的只读进度；`POST /api/rooms/:id/limits` 由声明的主持人或用户检查并执行到限处理，沿用房间凭据保护。配置通过创建房间/更新话题的 `limits` 对象写入，仅准备或暂停阶段可修改；时钟不重置。SQLite 在写事务中校验，D1 在同一批次断言参数版本、消息截止及时间边界，避免并发越界。到限处理取消未完成安排并撤销旧代次；总结需真实主持消息与阶段更新，不由服务器生成。GET 不改变阶段。请求附 `force: true` 时，用户可在进行中的讨论提前收尾：不论是否到限、到限方式为何，均按 `stop_reason=user_stop` 进入收束，由主持人在收束预留内总结；准备、暂停、收束或存档状态返回 400。
@@ -240,11 +246,11 @@ running 状态即使只有 pending 事件，也必须先暂停才能重新启动
 自由房间（`room_modes.mode='free'`）与讨论房间共用房间、成员登记、消息、附件与目录，没有发言权、安排、阶段推进和轮次。没有控制凭据登记的旧房间只供阅读，不支持通过首次运行配置认领；本次不迁移历史房间。
 
 - **凭据**：建房时由客户端提供房间控制凭据和每位成员的成员凭证，服务端只存哈希。用户身份的房间写入（发言、附件、存档、恢复、删除、打断）都须控制凭据；房间排序和归入文件夹只改共享目录，与站点级文件夹操作一样不需要凭据；无凭据、错误凭据、成员凭证或他房凭据一律只读。成员凭证只能以该成员身份发言或上传附件。声明字段（`author`、`source`、localhost）不代替凭据。
-- **成员**：`room_members` 以 `id` 为稳定主键，`access` 为 `runner`（接入程序投递）、`manual`（成员自行读写）或 `online`（只读、原文代发），`session_mode` 标记是否借用用户正在使用的会话。房主用控制凭据 `POST members` 运行中加入成员，`POST members/ID {action}` 让成员离开（`away`，作废其进行中执行与未投递请求）、请回（`active`，必须提供不同于原凭证的新凭证，旧凭证副本不再有效）或移除（`remove`，保留历史发言）。同一成员凭证不能复用于其他成员或房主；相同凭证与配置的邀请、请回重试返回已有结果。会话续接由本机接入程序负责，服务端不保存会话绑定。
+- **成员**：`room_members` 以 `id` 为稳定主键，`access` 为 `runner`（接入程序投递）、`manual`（成员自行读写）或 `online`（只读、原文代发），`session_mode` 标记是否借用用户正在使用的会话。房主用控制凭据 `POST members` 运行中加入成员，`POST members/ID {action}` 让成员离开（`away`，作废其进行中执行与未投递请求）、请回（`active`，必须提供不同于原凭证的新凭证，旧凭证副本不再有效）或移除（`remove`，保留历史发言）。同一成员凭证不能复用于其他成员或房主；相同凭证与配置的邀请、请回重试返回已有结果。会话续接由本机接入程序负责，服务端不保存会话绑定；唯一例外是手动成员上报的会话：`message post` 可带 `session_id` 与 `session_client`（CLI 读取 `CLAUDE_CODE_SESSION_ID`，目前仅 `claude`），服务端在 `member_sessions` 保存该手动成员最近上报的会话，成员视图以 `reported_session` 暴露。房主用 `POST members/ID {action:"adopt", adapter:"claude", session_id}`（须与上报一致、仅全自动讨论中在场的手动成员）把成员改为 `runner`、`borrowed` 并清除上报，本机接入程序据此接管。两套后端行为一致。
 - **请求**：用户消息按结构化接收者 `to`（成员名）为每位成员生成一条请求；省略且仅有一位在场成员时默认点名该成员，多位成员时交给主持人（`route`），只有在线成员而没有主持人时只作留言，不广播。网页只从正文中代码与引用之外的 `@成员` 生成 `to`，没有 @ 时省略 `to`。请求状态为 `pending`（待投递）→ `delivering`（处理中）→ `completed` / `cancelled` / `failed`。
 - **执行**：`member_executions` 每位成员最多一个 `dispatched/started`（部分唯一索引），不同成员可并行。接入程序用控制凭据 `GET inbox`、`POST executions {member_id, client_id}`（同一 `client_id` 返回同一执行）把成员的全部待投递请求打包；`POST executions/ID {action}` 支持 `renew`（租约 120 秒，不超过单次执行时限，默认 20 分钟）、`fail`（请求标记失败）和 `release`（仅确认未送达时退回队列）。租约过期的执行在下次读取或领取时标记失败，不自动重发。
 - **主持人与任务链**：用户是需求方，不担任主持人。只要有在场的非在线成员，房间就保持恰好一位主持人：成员变动时，离开或移出的主持人失去角色，由第一位在场的 runner 成员（没有则手动成员）接任；建房和每条房主消息前也做同样的补位，因此旧房间在下一条消息时自动获得主持人。房主用 `POST members/ID {action:"role", role:"host"}` 更换主持人（在线成员不能担任），把现任主持人改为 `member` 会被拒绝。多位成员时未点名的房主消息生成给主持人的 `route` 请求。主持人的回答可带 `to` 点名其他成员（不能点名自己），这些请求组成一个批次（`free_batches`）；批次内全部进入终态后，只要有一个完成就给主持人生成一次 `handoff` 请求，全部失败则停下该任务链。每条房主消息开启一条任务链（`chain_id` 为该消息编号），链上 AI 发起的请求（派活与回交）最多 8 次，超出即停下（`free_chains`，原因 `budget` / `all_failed`），房主发新消息开启新链。Worker 用同一批次内的集合 SQL 完成回交，回交请求按（派活消息，主持人）唯一，重复执行不会重复唤醒。
-- **智能调度改派**：接入程序用控制凭据 `POST requests/ID {action:"schedule", member_id, provider, confidence}` 把一条仍为 `pending` 的 `route` 请求改给一位在场、由本机唤醒的非主持成员，`purpose` 改为 `scheduled`，`created_by` 与 `chain_id` 不变，不消耗任务链预算；同一事务把供应商（`jev` / `decisions`）与 0–1 置信度写入 `request_schedules`（独立表，D1 重新应用 schema 即可，无需改旧表列），房间视图的请求带 `schedule_provider`、`schedule_confidence`，备份、导入与删除一并处理。请求已被主持人领取或已处理返回 409，目标不合格返回 404，供应商或置信度无效返回 400；Worker 用带条件的 `UPDATE` 与同批次 `INSERT … SELECT` 防止与主持人领取并发时丢失请求或留下孤立记录。`inbox` 的待投递项带 `purpose` 供接入程序识别。
+- **智能调度推荐**：接入程序用控制凭据 `POST recommendations {message_id, member_id, provider, confidence}` 为一条已交给主持人（`route`）的未点名消息记录推荐对象（在场、由本机唤醒、非该主持人），写入 `member_recommendations`（每条消息一条，重复提交忽略；独立表，D1 重新应用 schema 即可），有效期 60 秒，主持人的请求不受影响。房主用 `POST recommendations/MESSAGE_ID {action:"adopt", mode}` 采纳：`interrupt` 取消主持人这条请求（已投递则作废主持人本次整个执行），`after` 等主持人这条请求进入终态。两种方式都先置为 `waiting`，由 `release`（采纳时与每次 `inbox` 读取时执行）在主持人请求已终态时为推荐成员建一条 `ask` 请求（`created_by=user`、`chain_id` 为原消息），状态改为 `adopted`。过期 5 秒宽限后采纳返回 409，重复采纳返回原结果。房间视图 `free.recommendations` 带成员名、状态、方式、置信度与剩余秒数 `expires_in`；备份、导入（仅作历史，不再生效）与删除一并处理。`inbox` 的待投递项带 `purpose` 供接入程序识别。
 - **回应建议**：普通成员新发言的结构化 `to` 与正文在场成员 @ 合并保存到 `member_suggestions`（原消息编号、稳定成员编号），排除自己、代码与引用；不会创建请求。消息读取返回 `suggestions`，包含目标在场状态及已转换的请求编号。房主用 `POST suggestions {message_id,member_id}` 转换：同一事务记录用户确认消息，调用现有建请求路径，`message_id` 保留原回答、`chain_id` 使用用户确认消息编号、`created_by=user`。`UNIQUE(message_id,member_id)` 使重复或并发点击只生成一个请求及一条确认，终态不重新派发。权限、在场状态和未存档条件在写入事务内校验；Worker 使用批次断言。升级须应用包含新表的 schema；Python 重启时自动建表，D1 发布前显式执行。已有历史消息不补写建议。
 - **在线成员**：`access=online` 的成员只读，不进入 `inbox`，不能用自己的凭证发言；房主以控制凭据代发其回答（`author` 为该成员、`submitted_by` 为用户、`source=proxy`），可带 `request_ids` 关闭它的待处理请求。
 - **关联房间**：从自由房间发起的讨论房间在建房时带 `parent_room_id`，记录在 `room_links`；讨论房间视图有 `parent_room`，自由房间视图列出 `linked_rooms`。头脑风暴的轮次、时长与名单因此天然独立于自由房间。

package/docs/cli.md

@@ -35,7 +35,7 @@ Bash 对应 `export DISCUSS_URL=http://127.0.0.1:8765`，CMD 对应 `set DISCUSS
 
 建房与更新资料支持 `--user-request` / `--user-request-file`，将用户原文与 `--background` 分开保存，各限 4000 字。`room brief` 返回两者，概要和通知不自动展开原文。
 
-`room create` 必须指定 `--access-file 私有文件`，CLI 在请求前原子保存建房编号、房主和各成员凭据，确认房间后另写各本地成员的独立文件，回执只返回 `member_access_files` 路径。结果不明时沿用同一文件、编号和创建参数；不能换文件重建。后续每次写入使用对应身份的文件，不能拿房主文件冒充成员；自动讨论使用本次任务文件中的执行凭据。文件含 `site`、`room`、`token`，CLI 检查站点与房间匹配。同样内容的单行 JSON 文本可放入环境变量 `DISCUSS_ACCESS`（或 `--access-file -` 从标准输入读取），未传 `--access-file` 时使用；成员菜单的“复制凭证文本”复制的就是这段文本，含 token，只交给该成员，不要写进命令行参数或回显。`--dry-run` 不生成或写入凭据，预览会隐藏凭据字段。
+`room create` 必须指定 `--access-file 私有文件`，CLI 在请求前原子保存建房编号、房主和各成员凭据，确认房间后另写各本地成员的独立文件，回执只返回 `member_access_files` 路径。结果不明时沿用同一文件、编号和创建参数；不能换文件重建。后续每次写入使用对应身份的文件，不能拿房主文件冒充成员；自动讨论使用本次任务文件中的执行凭据。文件含 `site`、`room`、`token`，CLI 检查站点与房间匹配。同样内容的单行 JSON 文本可放入环境变量 `DISCUSS_ACCESS`（或 `--access-file -` 从标准输入读取），未传 `--access-file` 时使用；成员菜单的“复制凭证文本”复制的就是这段文本，含 token，只交给该成员，不要写进命令行参数或回显。`--dry-run` 不生成或写入凭据，预览会隐藏凭据字段。`message post` 在 Claude Code 会话中运行时自动附带 `session_id` 与 `session_client: "claude"`（取自 `CLAUDE_CODE_SESSION_ID`），服务端仅对手动成员保存，供本机服务转为托管；其他情况忽略。
 
 消息 JSON 中的 `elapsed_seconds` 为只读耗时：自动执行从交付唤醒到保存该消息的秒数，不含排队，保存后固定。用户留言、手动或代发内容及没有计时记录的旧消息返回 `null`；发布命令无需提供耗时。
 

package/docs/runner.md

@@ -29,7 +29,7 @@
 
 API 参与者不安装技能，也不靠手写的另一套规则：每次执行时，程序从包内读取与本地软件相同的 `discuss-participant`（讨论主持人另加 `discuss-host`）正文作为系统提示词，前面附一段 API 环境说明，列出 CLI 命令对应的房间工具，并说明定时任务、凭据文件、执行认领等段落不适用。技能更新后下一次执行即生效；主持人一次约多出 1 万字符输入。在线网页 AI 同样不加载技能，阅读页 `/r/房间` 末尾附有精简的在线成员守则；本地 AI 的阅读页只指引其调用技能与 `codiscuss room protocol`。
 
-每个有效任务重新读取房间与当前安排，按需读取原文。独立观点阶段不会把他人观点或主持总结送给专家；专家仅可提交本次安排，主持人可写主持说明、整理状态、调整阶段、安排整轮或收束。API 与网页专家的项目权限固定只读，只有 CLI 专家可选择只读或写入；API 配置即使残留 `project_access="write"` 或本场设置为可写，执行器也强制归一为 `read`。API 没有本机文件、浏览器、附件解析或任意 HTTP 工具，不继承 cwd 的读写权限；此权限不限制保存讨论发言及履行主持职责。模型看不到网站令牌和 API Key；房间 HTTP 请求由程序绑定身份与执行。
+每个有效任务重新读取房间与当前安排，按需读取原文。独立观点阶段不会把他人观点或主持总结送给专家；专家仅可提交本次安排，主持人可写主持说明、整理状态、调整阶段、安排整轮或收束。API 与网页专家的项目权限固定只读，只有 CLI 专家可选择只读或写入；API 配置即使残留 `project_access="write"` 或本场设置为可写，执行器也强制归一为 `read`。API 没有本机文件、浏览器、附件解析或任意 HTTP 工具，不继承 cwd 的读写权限；消息里的附件对它只是名称、大小与 ID，系统提示词要求它说明未读取、不得凭文件名猜测内容；此权限不限制保存讨论发言及履行主持职责。模型看不到网站令牌和 API Key；房间 HTTP 请求由程序绑定身份与执行。
 
 执行器在后台请求模型，主循环继续续租和处理暂停。单次模型请求超时 180 秒，每个执行最多 24 次模型请求；需显式输出上限的协议使用 8192 tokens。Responses 保留加密 reasoning items，Anthropic 保留签名块，Gemini 保留 thoughtSignature，Chat Completions 保留工具历史；这些推理内容不作为公开发言。未调用保存工具、请求失败或超限时，讨论暂停并保留错误，自由房间只结束该成员的失败执行。暂停或撤销会取消本机请求，服务端继续校验执行有效性；不把迟到回答改作普通发言。每次写入前保存原提交编号和正文，网络结果不明时停止，不换号自动重试。
 
@@ -314,18 +314,23 @@ Codex 要求 CLI 0.163.0 或更新版本，使用 permission profiles 和本地
 
 `codiscuss launch room-member` 在运行中的自由房间邀请（`add`）或请回（`rejoin`）自动成员：先用房间控制凭据核对房主身份，在登记配置中写入成员的软件配置与新凭证，再通知网站；网页通过 `member_token` 提供其已保存的新凭证，结果不明时沿用同一凭证重试。网页邀请默认项目只读，显式选择可写后通过该成员的 `participants[name].project_access` 传递，不改变其他成员；重试保留最初选择。该命令也可为手动成员生成配置旁的 `manual-成员名.access.json`，回执只含文件路径；网页手动邀请和请回则直接在网站完成。常驻服务读取更新后的配置时逐个成员核对：新成员直接采用，已绑定会话的成员若项目、cwd 或接入方式变化，只阻止该成员并报告原因，不影响其他成员。
 
-运行中的讨论同样可用 `room-member` 邀请或请回专家，但只接受由本机唤醒的成员（不接受 `access: manual`）。`participants[name].session_id` 指定已有会话时，成员标记为 `borrowed`，首次投递即续接该会话；网页仅对 Codex CLI / App 与 Claude 提供此项，agy 照旧拒绝。邀请前在本机核对会话确实存在（Codex 查 `CODEX_HOME/sessions`，Claude 查 `CLAUDE_CONFIG_DIR/projects`），填错时当场报错，不会让讨论在轮到它时暂停；Claude 会话只能在原目录续接，未指定项目时沿用原目录，项目目录不同则拒绝。Codex 会话若正被 App 持有，CLI 续接报 active writer，进度看板在暂停原因下提供“切换到 Codex App”，保存采用后可在弹窗内重启。讨论配置只新增参与者时常驻服务直接采用，讨论不暂停；已有参与者的项目、cwd 或身份变化仍须暂停后重新接入。
+运行中的讨论同样可用 `room-member` 邀请或请回专家，但只接受由本机唤醒的成员（不接受 `access: manual`）。`participants[name].session_id` 指定已有会话时，成员标记为 `borrowed`，首次投递即续接该会话；网页仅对 Codex CLI / App 与 Claude 提供此项，agy 照旧拒绝。邀请前在本机核对会话确实存在（Codex 查 `CODEX_HOME/sessions`，Claude 查 `CLAUDE_CONFIG_DIR/projects`），填错时当场报错，不会让讨论在轮到它时暂停；Claude 会话只能在原目录续接，未指定项目时沿用原目录，项目目录不同则拒绝。Codex 会话若正被 App 持有，CLI 续接报 active writer，进度看板在暂停原因下提供“切换到 Codex App”，保存采用后可在弹窗内重启。常驻服务每轮检查成员视图：手动 Claude 专家带 `reported_session` 时，`adopt_member_profile` 在本机配置登记其借用会话（会话须存在于 `CLAUDE_CONFIG_DIR/projects` 且 Claude 软件已配置），随后调用 `adopt` 把成员转为托管；任一步失败则保持手动并记录一次日志，同一会话 ID 不重试。讨论配置只新增参与者时常驻服务直接采用，讨论不暂停；已有参与者的项目、cwd 或身份变化仍须暂停后重新接入。
 
 每次检查读取 `inbox`：成员没有进行中的执行且有待投递消息时，先持久化本地 `client_id` 再领取执行，然后用原适配器续接该成员的绑定会话；任务文件列出执行编号、待处理消息和已读起点，凭据文件只含成员凭证。进程退出而网站未收到回答、软件报错或超过单次执行时限时报告失败；只有确认未送达才退回队列重试，最多 3 次。领取后、调用前中断的投递不自动重发。主持人的任务文件带 `role: "host"` 和每条请求的 `request_purposes`（`ask` / `route` / `handoff`），说明里写明如何用 `--to` 派活与何时结束。网站上执行被打断、成员离开或被移除后，只停止该成员的进程；不同成员各自投递，可以并行。成员配置了 cwd 且位于 Git 工作区时，执行前后各做一次快照，执行结束且进程退出后报告改动的文件，供网站提示可能冲突；服务重启会丢失尚未报告的快照。只能在网页创建自由房间，不支持对话入口。
 
 ### 智能调度（可选）
 
-新建房间面板在选好 AI 后可勾选“智能调度”，选择供应商（TypeSafe Jev 的 `POST /v1/systemone`，或 OpenAI Decisions 的 `POST /v1/decisions`）、模型（预设 `jev-latest` / `gpt-6-luna`）并填写密钥。密钥经 `api-key` 保存到服务目录，绑定供应商官方根地址；启动请求只带 `scheduler: {provider, model, api_key_ref}`，`validate_config` 核对密钥存在后写入私有房间配置。只在本次由本机服务启动时提供：自由房间至少有一位本机唤醒成员，讨论须勾选“创建后立即启动”。目前只能在建房时开启，已建房间不能中途开启或关闭。
+新建房间面板始终显示“智能调度”，可选供应商（TypeSafe Jev 的 `POST /v1/systemone`，或 OpenAI Decisions 的 `POST /v1/decisions`）、模型（预设 `jev-latest` / `gpt-6-luna`）并填写密钥。密钥经 `api-key` 保存到服务目录，绑定供应商官方根地址；密钥旁的闪电按钮调用 `scheduler-check`（`codiscuss launch scheduler-check`），向决策模型发一道是非题核对供应商、模型与密钥。启动请求只带 `scheduler: {provider, model, api_key_ref}`，`validate_config` 核对密钥存在后写入私有房间配置。只在本次由本机服务启动时可开启（自由房间至少有一位本机唤醒成员，讨论须勾选“创建后立即启动”），否则选项禁用并说明原因。目前只能在建房时开启，已建房间不能中途开启或关闭。
 
-`runner/scheduler.mjs` 用中立的题目（`choice` 带选项，`predicate` 为是非题）组装两家的请求，并把答案统一为 `{choice, confidence, probabilities}` 或 `{probability}`。上下文是房间标题、最近 10 条消息（每条截断到 600 字）和待处理的那条用户消息。请求 15 秒超时，错误只报 HTTP 状态，不含响应正文或密钥。
+`runner/scheduler.mjs` 用中立的题目（`choice` 带选项，`predicate` 为是非题）组装两家的请求，并把答案统一为 `{choice, confidence, probabilities}` 或 `{probability}`。上下文是房间标题、目标与用户原文、最近 10 条消息（每条截断到 600 字）和待处理的那条用户消息。把握程度取所选项的概率（缺失时才用 `confidence`；Jev 的两项选择 `confidence` 明显低于该概率，实测概率 0.82 时只有 0.64），阈值 0.8。请求 30 秒超时，错误只报 HTTP 状态，不含响应正文或密钥。
 
-- **自由房间**：每次检查先看主持人名下的 `route` 请求，每条只判断一次。选项为各位本机唤醒的非主持成员（描述为软件与项目读写权限）和“交回主持人”；只有选中成员且 `confidence ≥ 0.8` 时，才用 `POST requests/ID {action:"schedule"}` 改派（带供应商与置信度，网站记入请求），随后重读 `inbox`，本轮不再唤醒主持人。判断失败、超时、置信度不足、选择交回主持人或改派返回 409 时，请求留给主持人，行为与未开启相同。成员任务文件对 `scheduled` 请求说明“用户没有点名，由智能调度交给你”。网页在消息上显示“智能调度 → 成员”，悬停显示供应商与置信度；主持人读 `room view` 时也能看到这些字段。
-- **讨论房间**：只给建议，不改变房间。投递主持事件前，若 `held_since` 非 0，对其后的每条用户留言判断一次（请某位专家回应 / 主持人处理 / 仅补充信息），结果以 `scheduler_suggestions` 写入主持任务文件（API 主持人写入首个提示），说明仅供参考；建议在记录投递前完成，失败只少一项建议。
+- **自由房间（推荐，用户决定）**：未点名的消息照常交给主持人，判断在后台进行，不阻塞本次检查和任何投递。每条 `route` 请求只判断一次，选项为各位本机唤醒的非主持成员（描述为软件与项目读写权限）和“交回主持人”；只有选中成员且 `confidence ≥ 0.8` 时，才用 `POST recommendations` 记录推荐。网页在消息旁显示“智能调度建议让 B 回答”与 60 秒倒计时，用户可选“打断主持人，改由它回答”或“主持人答完后再回答”（主持人已答完时直接请 B 回答），过期后提示消失。判断失败、超时或置信度不足时不显示推荐，行为与未开启相同。
+- **讨论房间（有把握即执行）**：投递主持事件前先只读判断，置信度 ≥ 0.8 才执行，否则照常唤醒主持人：
+  - **插话**：`held_since` 后恰有一条用户留言时判断。仅补充信息且有排队安排 → `turns/continue`；在问某位非主持专家 → 新计划先请该专家回应这条留言（问题引用原文 300 字），原排队安排按原顺序跟在后面（最多 10 项）；改变方向、多条留言或话题修改 → 主持人。仅补充但计划已结束时，按下一条处理。
+  - **轮次衔接**：仅 `named_followup` 为 false、无排队、上一轮已完成时判断。继续 → 先请模型选出的专家（不是上一轮最后发言者），其余按房间专家顺序，统一使用 `peer_round_question`；第 1 轮后自动把阶段从 `initial` 改为 `discussing`。可收束、跑偏、重复或卡住 → 主持人。
+  - **执行方式**：有把握时 runner 领取该主持事件，以 `smart-scheduler` 会话进入，用本次执行凭据以主持人身份领取发言权、改阶段、创建或继续安排；网站的发言权、上限与凭据校验照常生效。到限、阶段不在进行中或已有进行中安排时不判断。执行中任一写入失败，把同一事件交回主持人软件并标记已进入（任务说明与 API 主持都跳过 `execution enter`）。判断失败或置信度不足时，主持任务附 `scheduler_suggestions` 供参考。
+  - **成员变化**：名单变化会作废排队安排（留下最近一次实际安排之后的 `skipped`）。本轮未完成且无排队时，runner 不调用模型，按原顺序补回仍在场专家的安排，再请本轮尚未发言的专家（如新成员）开场，不唤醒主持人。
+  - 每次判断（含交回主持人）用控制凭据写入 `POST scheduler-decisions`，`after_message_id` 取最近一条已回答安排的回答，对话中显示在这张发言卡片的末尾（“智能调度：……”）。交回主持人时写明原因：建议收束、拿不准，或“未判断：已到讨论上限 / 同时有多条留言 / 话题设置有修改 / 点名追问已开启 / 本轮还有专家未发言但没有后续安排”；主持人的开场任务不记录。
 - 每次判断与结果写入 `service.log`；阈值 0.8 未经实测校准，两家的置信度不可互相套用。面板提示：开启后房间标题与最近消息会发给所选供应商。
 - 2026-10-23 用真实 Jev 密钥核对：`/v1/systemone` 的请求与答案格式与本模块一致；4 条自由房间分派全部合理（直接派出的置信度 0.91），3 条讨论建议中 2 条符合预期，单次 0.5–1.1 秒（首次连接约 5 秒）。该密钥的 `GET /v1/models` 只列出 `jev-latest` 与 `jev-preview`，没有可锁定的版本，默认仍用 `jev-latest`；Jev 升级可能改变判断结果。OpenAI Decisions 仅按文档实现，未用真实密钥调用。