ai_co_discuss 0.2.63 → 0.2.65

package/backend/free_room.py

@@ -223,6 +223,11 @@ def possible_conflicts(connection, room_id, names):
     return conflicts
 
 
+# An invited manual member that has not registered counts as absent: it receives no request and is never a target.
+REGISTERED_MEMBER = """(room_members.access<>'manual' OR EXISTS(SELECT 1 FROM member_registrations r
+    WHERE r.member_id=room_members.id AND r.token_hash=room_members.token_hash))"""
+
+
 def free_view(connection, room_id):
     """Summarize members, their live execution, recent requests and possible file conflicts."""
     now = int(time.time())
@@ -230,6 +235,8 @@ def free_view(connection, room_id):
     for row in connection.execute("SELECT * FROM room_members WHERE room_id=? AND status<>'removed' ORDER BY id", (room_id,)):
         member = {key: row[key] for key in MEMBER_FIELDS}
         member["registered_at"] = registered_at(connection, row)
+        reported = connection.execute("SELECT session_id,client FROM member_sessions WHERE member_id=?", (row["id"],)).fetchone()
+        member["reported_session"], member["reported_client"] = (reported["session_id"], reported["client"]) if reported else ("", "")
         latest = connection.execute("SELECT * FROM member_executions WHERE member_id=? ORDER BY id DESC LIMIT 1",
                                     (row["id"],)).fetchone()
         member["execution"] = public_execution(latest)
@@ -240,7 +247,7 @@ 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 FROM member_requests
+        """SELECT id,member_id,message_id,status,execution_id,answer_id,chain_id,batch_id,purpose,created_by,created_at 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,))]
@@ -307,9 +314,10 @@ def authorize_free_write(connection, room_id, token, operation, payload):
     return require_member(connection, room_id, token, author)
 
 
-def active_members(connection, room_id):
-    """Map active member names to their rows."""
-    return {row["name"]: row for row in connection.execute("SELECT * FROM room_members WHERE room_id=? AND status='active'", (room_id,))}
+def active_members(connection, room_id, registered_only=True):
+    """Map active member names to their rows; unregistered manual members are left out unless a discussion start needs them pending."""
+    return {row["name"]: row for row in connection.execute(
+        f"SELECT * FROM room_members WHERE room_id=? AND status='active' AND ({REGISTERED_MEMBER} OR ?=0)", (room_id, int(registered_only)))}
 
 
 def named_members(active, names, exclude=None):
@@ -593,7 +601,7 @@ 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
+        """SELECT id,member_id,message_id,status,execution_id,answer_id,chain_id,batch_id,purpose,created_by,created_at 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)}
 
@@ -636,7 +644,7 @@ def inbox(connection, room_id, token):
     archived = connection.execute("SELECT archived FROM room_directory WHERE room_id=?", (room_id,)).fetchone()[0]
     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,)):
+    for row in connection.execute(f"SELECT * FROM room_members WHERE room_id=? AND status='active' AND {REGISTERED_MEMBER} 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 if row["access"] == "runner" else observers).append({**{key: row[key] for key in MEMBER_FIELDS}, "pending": pending})
@@ -663,8 +671,8 @@ def recommend_member(connection, room_id, token, payload):
     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 id<>?""", (room_id, payload.get("member_id"), route["member_id"])).fetchone()
+    target = connection.execute(f"""SELECT * FROM room_members WHERE room_id=? AND id=? AND status='active'
+        AND {REGISTERED_MEMBER} AND id<>?""", (room_id, payload.get("member_id"), route["member_id"])).fetchone()
     if not target:
         raise LookupError("推荐对象须为在场的其他成员")
     now = int(time.time())
@@ -698,8 +706,8 @@ def route_wide(connection, room_id, message_id, action):
     else:
         # The host keeps its row (one request per message and member) and now answers its own share, without dispatching.
         connection.execute("UPDATE member_requests SET purpose='all' WHERE id=?", (route["id"],))
-        connection.execute("""INSERT OR IGNORE INTO member_requests (room_id,member_id,message_id,chain_id,purpose,created_by,created_at)
-            SELECT room_id,id,?,?,'all','user',? FROM room_members WHERE room_id=? AND status='active' ORDER BY id""",
+        connection.execute(f"""INSERT OR IGNORE INTO member_requests (room_id,member_id,message_id,chain_id,purpose,created_by,created_at)
+            SELECT room_id,id,?,?,'all','user',? FROM room_members WHERE room_id=? AND status='active' AND {REGISTERED_MEMBER} ORDER BY id""",
                            (message_id, message_id, int(time.time()), room_id))
     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]}
@@ -982,8 +990,8 @@ def adopt_manual_member(connection, room_id, member, payload):
         raise ValueError("成员尚未注册，不能转为托管")
     if not reported or reported["session_id"] != payload.get("session_id") or payload.get("adapter") not in ADOPTABLE_ADAPTERS:
         raise ValueError("成员尚未上报与之相符的会话，不能转为托管")
-    if member["access"] != "manual" or member["status"] != "active" or not run or run["mode"] != "automatic":
-        raise ValueError("只有全自动讨论中在场的手动专家可以转为托管")
+    if member["access"] != "manual" or member["status"] != "active" or not (room_mode(connection, room_id) == "free" or (run and run["mode"] == "automatic")):
+        raise ValueError("只有自由协作或全自动讨论中在场的手动专家可以转为托管")
     connection.execute("UPDATE room_members SET access='runner',adapter=?,session_mode='borrowed' WHERE id=?", (payload["adapter"], member["id"]))
     connection.execute("DELETE FROM member_sessions WHERE member_id=?", (member["id"],))
 
@@ -1016,6 +1024,8 @@ def member_action(connection, room_id, member_id, token, payload):
             raise ValueError("只有离开的成员可以请回，且须提供新的成员凭证")
         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))
+    elif action == "adopt":
+        adopt_manual_member(connection, room_id, member, payload)
     elif action == "role":
         role = payload.get("role")
         if role not in ("host", "member") or (role == "host" and member["access"] == "online"):
@@ -1026,7 +1036,7 @@ def member_action(connection, room_id, member_id, token, payload):
             connection.execute("UPDATE room_members SET role='member' WHERE room_id=? AND role='host'", (room_id,))
         connection.execute("UPDATE room_members SET role=? WHERE id=?", (role, member_id))
     else:
-        raise ValueError("action 须为 away、active、remove 或 role")
+        raise ValueError("action 须为 away、active、remove、role 或 adopt")
     settle_batches(connection, room_id)
     sync_participants(connection, room_id)
     return free_view(connection, room_id)

package/backend/server.py

@@ -738,7 +738,7 @@ def start_discussion(connection, room_id, token, payload):
     if room["archived"]:
         raise ValueError("房间已存档；恢复后才能开启讨论")
     sync_participants(connection, room_id)
-    active = active_members(connection, room_id)
+    active = active_members(connection, room_id, registered_only=False)
     host = next((row for row in active.values() if row["role"] == "host"), None)
     if not host or host["access"] != "runner":
         raise ValueError("开启讨论需要一位由本机托管的 AI 主持人；先在成员栏指定或转为自动")
@@ -1022,7 +1022,7 @@ def record_reported_session(connection, room_id, token, payload):
     session_id, client = payload.get("session_id"), payload.get("session_client")
     if client not in ("claude", "codex", "antigravity") 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'",
+    member = connection.execute("SELECT id FROM room_members WHERE room_id=? AND token_hash=? AND status='active' AND access='manual' AND adapter IN ('manual','')",
                                 (room_id, token_hash(token))).fetchone()
     if member:
         connection.execute("""INSERT INTO member_sessions (member_id,room_id,session_id,client) VALUES (?,?,?,?)

package/docs/workflow.md

@@ -25,7 +25,9 @@
 
 自由协作房间从同一角色库选择一位或多位成员。用户是需求方而不是主持人：只要有能自行发言的成员（本机唤醒或手动接入），房间就始终有一位 AI 主持人，默认是第一位本机唤醒的成员，可点皇冠或在成员菜单中更换；主持人不能直接卸任，离开或被移出时由下一位成员接任，原先由用户主持的旧房间在下一条消息时自动指定。只有一位成员时，每条消息都交给它；有多位时，你的消息默认发给主持人；在正文中 `@成员` 才让其他成员发言（代码和引用中的 @ 不算，输入框中会生效的 @ 显示为蓝色），被点名的成员各自处理，主持人也可以 @ 其他成员派活。输入框下方的备注行显示这条消息会发给谁。只有网页 AI 成员时没有主持人，未点名的消息只作留言。输入 `@` 后，输入框上方弹出在场成员菜单，继续输入可筛选；用方向键与 Enter / Tab 或点击补全，Esc 关闭。选择只修改草稿。输入框 Enter 发送、Shift + Enter 换行；发送按钮始终用于发言，无正文或附件时禁用，成员处理中也不切换为停止按钮。自动成员空闲时，服务把它名下所有未处理的消息打包成一次执行交给原会话；执行期间再发的消息排队，下一次一起投递。手动成员自行读取自己的请求，在线成员由用户转交。成员按时间顺序处理，后面的消息可以修正前面的。
 
-运行中可在右侧成员栏邀请 AI（沿用本机软件配置和本房间工作目录），也可让成员离开、请回或移除。自动成员的项目文件权限默认只读；需要它修改项目时，在邀请前选择“项目文件可写”，权限只应用于这位成员；App 与手动成员的文件权限由其软件设置，API 与网页成员不访问项目文件。填写已有会话 ID 时续接该原会话，不新建。离开会立即停止它的工作；请回时换发新凭证并续接它原来的会话。邀请时可选“手动接入”：成员不会被自动唤醒，而是得到一份私有凭据文件，由你在它的会话中按参与技能读写。绑定你正在使用的会话的成员会标注“借用会话”：它工作时不要在原窗口继续操作。
+运行中可在右侧成员栏邀请 AI（沿用本机软件配置和本房间工作目录），也可让成员离开、请回或移除。自动成员的项目文件权限默认只读；需要它修改项目时，在邀请前选择“项目文件可写”，权限只应用于这位成员；App 与手动成员的文件权限由其软件设置，API 与网页成员不访问项目文件。填写已有会话 ID 时续接该原会话，不新建。离开会立即停止它的工作；请回时换发新凭证并续接它原来的会话。邀请时可选“手动接入”：成员不会被自动唤醒，而是得到一份私有凭据文件，由你在它的会话中按参与技能读写。自由协作房间里，手动成员执行 `member register` 之前视为不存在：不能被点名，不收请求，不进“全体各自回应”和智能调度候选；注册后与其他成员一样可被点名，其 CLI 上报会话后本机服务按软件转为托管（Claude Code、Codex、agy），此后与自动成员无异。绑定你正在使用的会话的成员会标注“借用会话”：它工作时不要在原窗口继续操作。
+
+输入 `@全体成员`（或 `@all`）等同于点名当前所有可点名成员（含主持人，不含未注册的手动成员），各自回答，主持人不汇总；成员不止一位时 @ 菜单首项提供该选项。
 
 可以把一位本机成员设为主持人。之后没有点名的消息交给主持人分配；主持人在回答中点名成员派活，只点名一位成员时，其回答直接面向用户，主持人不再被唤醒；点名多位成员时，都结束后主持人再被唤醒一次，继续汇总或安排下一步。派出的成员全部失败时不再唤醒主持人；同一条消息引出的 AI 请求最多 8 次，用完即停，成员栏会提示，发一条新消息即重新开始。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai_co_discuss",
-  "version": "0.2.63",
+  "version": "0.2.65",
   "bin": {
     "codiscuss": "runner/codiscuss.mjs"
   },

package/runner/discussion_service.mjs

@@ -266,8 +266,9 @@ class RoomWorker {
   }
   /** A manual Claude or Codex expert that has registered and whose CLI reported its session is handed to the service, which resumes that session from the next turn on. */
   async adopt_manual_members() {
-    if (this.config.mode === 'free') return;
-    for (const member of this.runner.members || []) {
+    // A discussion runner lists members itself; a free room's registered manual members come from the room view.
+    const members = this.config.mode === 'free' ? (await api(this.config, '')).free?.members || [] : this.runner.members || [];
+    for (const member of members) {
       const key = `${member.name}:${member.reported_session}`;
       if (member.access !== 'manual' || member.status !== 'active' || !member.registered_at || !member.reported_session || this.adopt_failed.has(key)) continue;
       try {

package/web/app.js

@@ -938,9 +938,9 @@ function message_payload() {
     if (online) return { author: online.name, text, reply_to: state.reply_to, kind: "chat", submitted_by: "用户",
       request_ids: state.room.free.requests.filter(item => item.member === online.name && item.status === "pending").map(item => item.id) };
     const payload = { author: "用户", text, reply_to: state.reply_to, kind: "chat", submitted_by: "用户" };
-    const active = (state.room.free?.members || []).filter(member => member.status === "active").map(member => member.name);
-    // @mentions outside code name members; without any, the server gives the message to the only member or the host.
-    const named = active.filter(name => mentioned(text, name));
+    const active = (state.room.free?.members || []).filter(member => member.status === "active" && (member.access !== "manual" || member.registered_at)).map(member => member.name);
+    // @mentions outside code name members (@全体成员 or @all names them all); without any, the server gives the message to the only member or the host.
+    const named = mentioned(text, "全体成员") || mentioned(text, "all") ? active : active.filter(name => mentioned(text, name));
     if (named.length) payload.to = named;
     return payload;
   }
@@ -989,7 +989,7 @@ function reset_create_form() {
   state.create_parent = null;
   state.launch.create = true;
   state.launch.workspace = {};
-  state.launch.scheduler = {};
+  state.launch.scheduler = default_scheduler();
   state.named_followup = false;
   state.create_discussion = false;
   state.launch.profiles = JSON.parse(JSON.stringify(state.launch.saved_profiles || {}));
@@ -1744,6 +1744,8 @@ async function load_launch_settings() {
       scheduler_providers: settings.scheduler_providers || {}, error: "",
       notice: local_connection ? "已连接本机服务，讨论保存在当前网站" : "" });
     Object.values(state.launch.profiles).forEach(fill_api_key);
+    // Settings arrive after the form was reset; only an untouched draft gets the default.
+    if (!Object.keys(state.launch.scheduler).length) state.launch.scheduler = default_scheduler();
     load_room_models();
   } catch (error) { state.launch.available = false; state.launch.room_models = null; state.launch.error = error.message; }
   finally { refresh_launch_recoveries(); render_launch_settings(); publish_view(); }
@@ -1953,6 +1955,15 @@ function write_create_discussion(value) {
   publish_view();
 }
 
+/** A fresh form turns smart scheduling on when some provider already has a saved key. */
+function default_scheduler() {
+  const providers = state.launch.scheduler_providers || {};
+  const provider = Object.keys(providers).find((name) => state.launch.api_keys?.[providers[name].base_url]);
+  if (!provider) return {};
+  const { base_url, models } = providers[provider];
+  return { enabled: true, provider, model: models[0] || "", api_key_ref: state.launch.api_keys[base_url] };
+}
+
 /** Change the smart scheduling draft; a new provider starts from its preset model and any key saved for its root. */
 function write_scheduler(field, value) {
   const scheduler = state.launch.scheduler;
@@ -2435,8 +2446,7 @@ function download_member_access(name) {
   if (!access.can_manage || !member?.available || member.access === "online") throw new Error("当前浏览器没有此成员可下载的私有配置");
   download_private_json({ site: location.origin, room: room.id, token: member_credentials(room.id)[name].token }, `member-${room.id}-${name}.json`);
   state.access_error = "";
-  state.access_notice = member.access === "runner" ? `已下载 ${name} 的持久成员配置；自动执行仍须使用本次任务凭据。`
-    : `已下载 ${name} 的私有配置；交给该成员的本地会话，下载不代表已接入。`;
+  flash_access_notice(`已下载 ${name} 的私有配置`);
 }
 
 /** Copy the same room-scoped credential as one line of text for an agent that cannot take a file. */
@@ -2445,8 +2455,19 @@ async function copy_member_access_text(name) {
   const member = access.members.find(item => item.name === name);
   if (!access.can_manage || !member?.available || member.access === "online") throw new Error("当前浏览器没有此成员可复制的凭证");
   await copy_text(JSON.stringify({ site: location.origin, room: room.id, token: member_credentials(room.id)[name].token }));
+  flash_access_notice(`已复制 ${name} 的凭证文本（含 token）`);
+}
+
+/** Confirm a copy or download briefly in the member rail; the note clears itself. */
+function flash_access_notice(message) {
   state.access_error = "";
-  state.access_notice = `已复制 ${name} 的凭证文本，含 token，仅交给该成员；用环境变量 DISCUSS_ACCESS 或 --access-file - 使用，复制不代表已接入。`;
+  state.access_notice = message;
+  clearTimeout(state.access_notice_timer);
+  state.access_notice_timer = setTimeout(() => {
+    if (state.access_notice !== message) return;
+    state.access_notice = "";
+    publish_view();
+  }, TOAST_DURATION_MS);
 }
 
 /** Copy a member-specific entry instruction; only the launch variant carries the credential, never conversation context. */
@@ -2469,11 +2490,7 @@ async function copy_member_join(name, with_credential = false) {
 ${instruction}
 房间入口：${address}
 先核对最新阶段、任务和原文编号，再按房间协议参与。${credential}`);
-  if (state.room?.id === room.id) {
-    state.access_error = "";
-    state.access_notice = with_credential ? `已复制 ${name} 的启动指令，含 token，只交给该成员；复制不代表已经送达或接入。`
-      : `已复制 ${name} 的参与说明，未包含凭据；复制不代表已经送达或接入。`;
-  }
+  if (state.room?.id === room.id) flash_access_notice(with_credential ? `已复制 ${name} 的启动指令（含 token）` : `已复制 ${name} 的参与说明`);
 }
 
 /** How a manual member learns it is its turn: free rooms are pulled by the member, discussions only on the host's assignment. */