ai_co_discuss 0.3.7 → 0.3.9

package/backend/free_room.py

@@ -462,6 +462,18 @@ REGISTERED_MEMBER = """(room_members.access<>'manual' OR EXISTS(SELECT 1 FROM me
     WHERE source.member_id=room_members.id AND source.source='web') OR EXISTS(SELECT 1 FROM member_registrations r
     WHERE r.member_id=room_members.id AND r.token_hash=room_members.token_hash))"""
 
+# One snapshot for group routing; the Worker uses the same SQL inside its atomic write assertion.
+GROUP_STATE_SQL = f"""SELECT json_object(
+    'latest_id',(SELECT COALESCE(MAX(id),0) FROM messages WHERE room_id=rooms.id),
+    'title',rooms.title,'goal',rooms.goal,
+    'archived',(SELECT archived FROM room_directory WHERE room_id=rooms.id),
+    'order',COALESCE((SELECT member_ids FROM speaking_orders WHERE room_id=rooms.id),'[]'),
+    'members',(SELECT json_group_array(json_object('id',id,'name',name,'role',role,'status',status,'access',access,
+        'registered',{REGISTERED_MEMBER},'description',COALESCE((SELECT description FROM member_descriptions d
+            WHERE d.room_id=room_members.room_id AND d.name=room_members.name),'')))
+        FROM (SELECT * FROM room_members WHERE room_id=rooms.id ORDER BY id) AS room_members)) AS state
+    FROM rooms WHERE id=?"""
+
 
 def free_view(connection, room_id):
     """Summarize members, their live execution, recent requests and possible file conflicts."""
@@ -1258,7 +1270,8 @@ def inbox(connection, room_id, token):
     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 r.id,r.message_id,r.purpose,
             sr.id AS session_request_id,sr.session_id,sr.round,sr.position,sr.read_until,sr.question AS source_question,
-            t.cause_kind,t.cause_message_id AS source_message_id,t.cause_request_id
+            t.cause_kind,t.cause_message_id AS source_message_id,t.cause_request_id,
+            (SELECT action FROM group_routes WHERE message_id=r.message_id) AS group_action
             FROM member_requests r LEFT JOIN session_requests sr ON sr.member_request_id=r.id
             LEFT JOIN task_message_sources t ON t.session_request_id=sr.id
             WHERE r.member_id=? AND r.status='pending' ORDER BY r.id""", (row["id"],))]
@@ -1309,29 +1322,74 @@ def release_recommendations(connection, room_id):
                 VALUES (?,?,?,?,'ask','user',?)""", (room_id, row["member_id"], row["message_id"], row["message_id"], int(time.time())))
 
 
-def route_wide(connection, room_id, message_id, action):
+def group_route_plan(connection, room_id, token, message_id):
+    """Read the current group, eligible members, order and revision before arranging everyone's requests."""
+    require_owner(connection, room_id, token)
+    group = connection.execute("""SELECT id,message_id,status FROM member_requests
+        WHERE room_id=? AND message_id=? AND purpose='group' ORDER BY id DESC LIMIT 1""", (room_id, message_id)).fetchone()
+    previous = connection.execute("SELECT action,request_id,message_id FROM group_routes WHERE room_id=? AND message_id=?",
+                                  (room_id, message_id)).fetchone()
+    if not group and not previous:
+        raise LookupError("这条消息没有全体待安排请求")
+    state = connection.execute(GROUP_STATE_SQL, (room_id,)).fetchone()["state"]
+    snapshot = json.loads(state)
+    members = [member for member in snapshot["members"] if member["status"] == "active" and member["registered"]]
+    rank = {member_id: index for index, member_id in enumerate(json.loads(snapshot["order"]))}
+    members.sort(key=lambda member: (member["id"] not in rank, rank.get(member["id"], 0), member["role"] != "host", member["id"]))
+    return {"message_id": message_id, "request": dict(group) if group else None, "members": members,
+            "latest_id": snapshot["latest_id"], "revision": hashlib.sha256(state.encode("utf-8")).hexdigest(),
+            "result": dict(previous) if previous else None}
+
+
+def route_group(connection, room_id, group, payload):
+    """Arrange a pending group atomically; only the single-object handback to its host needs no roster revision."""
+    action = payload["action"]
+    if action not in ("all", "sequential", "host"):
+        raise ValueError("请全体成员回应的消息只能选 action=all、sequential 或 host")
+    if group["status"] != "pending":
+        raise FileExistsError("这条消息已不再等待安排")
+    if action != "host":
+        if not payload.get("revision"):
+            raise ValueError("安排全体前须先读取 message group-plan，并带上其 revision")
+        state = connection.execute(GROUP_STATE_SQL, (room_id,)).fetchone()["state"]
+        if payload["revision"] != hashlib.sha256(state.encode("utf-8")).hexdigest():
+            raise FileExistsError("成员、顺序或消息已变化，请重新读取全体安排状态")
+    if action == "host":
+        connection.execute("UPDATE member_requests SET purpose='route' WHERE id=?", (group["id"],))
+    elif action == "sequential":
+        connection.execute("DELETE FROM member_requests WHERE id=?", (group["id"],))
+        members = connection.execute(f"SELECT id FROM room_members WHERE room_id=? AND status='active' AND {REGISTERED_MEMBER}", (room_id,))
+        queue_in_turn(connection, room_id, group["message_id"], [row["id"] for row in members])
+    else:
+        connection.execute("UPDATE member_requests SET purpose='all' WHERE id=?", (group["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""",
+                           (group["message_id"], group["chain_id"], int(time.time()), room_id))
+    connection.execute("INSERT INTO group_routes (message_id,room_id,request_id,action) VALUES (?,?,?,?)",
+                       (group["message_id"], room_id, group["id"], action))
+    return {"action": action, "request_id": group["id"], "message_id": group["message_id"]}
+
+
+def route_wide(connection, room_id, message_id, payload):
     """Smart scheduling answers an unnamed message with everyone (each member once, as if the user named them all) or no one.
 
     A message naming everyone (a group request) is answered by all at once or, with action sequential, one after another.
     Only a host request that has not started changes; a started host already handles the message its own way.
     """
+    action = payload["action"]
+    previous = connection.execute("SELECT action,request_id,message_id FROM group_routes WHERE room_id=? AND message_id=?",
+                                  (room_id, message_id)).fetchone()
+    if previous:
+        if previous["action"] != action:
+            raise FileExistsError("这条全体消息已经安排，不能改用其他动作")
+        return dict(previous)
+    group = connection.execute("""SELECT * FROM member_requests WHERE room_id=? AND message_id=? AND purpose='group'
+        ORDER BY id DESC LIMIT 1""", (room_id, message_id)).fetchone()
+    if group:
+        return route_group(connection, room_id, group, payload)
+    if action in ("sequential", "host"):
+        raise ValueError("只有请全体成员回应的消息可以依次回答或交回主持人")
     route = host_route_request(connection, message_id)
-    group = connection.execute("SELECT * FROM member_requests WHERE message_id=? AND purpose='group'", (message_id,)).fetchone()
-    if group and group["room_id"] == room_id:
-        if action not in ("all", "sequential"):
-            raise ValueError("请全体成员回应的消息只能选 action=all 或 sequential")
-        if group["status"] != "pending":
-            raise FileExistsError("这条消息已不再等待安排")
-        if action == "sequential":
-            # The row is removed rather than ended so the host takes its place in the queue like everyone else.
-            connection.execute("DELETE FROM member_requests WHERE id=?", (group["id"],))
-            members = connection.execute(f"SELECT id FROM room_members WHERE room_id=? AND status='active' AND {REGISTERED_MEMBER}", (room_id,))
-            queue_in_turn(connection, room_id, message_id, [row["id"] for row in members])
-            requests = connection.execute("SELECT * FROM member_requests WHERE message_id=? ORDER BY id", (message_id,)).fetchall()
-            return {"action": action, "requests": [dict(row) for row in requests]}
-        route = group
-    elif action == "sequential":
-        raise ValueError("只有请全体成员回应的消息可以依次回答")
     if not route or route["room_id"] != room_id:
         raise LookupError("只能处理交给主持人的未点名消息")
     if route["status"] != "pending":
@@ -1356,8 +1414,8 @@ def adopt_recommendation(connection, room_id, token, message_id, payload):
     """
     require_owner(connection, room_id, token)
     begin_write(connection)
-    if payload.get("action") in ("all", "none", "sequential"):
-        return route_wide(connection, room_id, message_id, payload["action"])
+    if payload.get("action") in ("all", "none", "sequential", "host"):
+        return route_wide(connection, room_id, message_id, payload)
     if payload.get("action") != "adopt" or payload.get("mode") not in ("interrupt", "after"):
         raise ValueError("采纳须为 action=adopt，mode 为 interrupt 或 after；全体、依次或无需回应为 action=all、sequential 或 none")
     row = connection.execute("SELECT * FROM member_recommendations WHERE room_id=? AND message_id=?", (room_id, message_id)).fetchone()

package/backend/schema.sql

@@ -434,6 +434,14 @@ 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);
+-- One durable disposition per @everyone message; also prevents a host fallback from being routed again after restart.
+-- The original group request may be deleted for a sequential queue, so request_id is a receipt, not a foreign key.
+CREATE TABLE IF NOT EXISTS group_routes (
+    message_id INTEGER PRIMARY KEY REFERENCES messages(id) ON DELETE CASCADE,
+    room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    request_id INTEGER NOT NULL,
+    action TEXT NOT NULL CHECK(action IN ('all','sequential','host'))
+);
 -- 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,

package/backend/server.py

@@ -1,6 +1,7 @@
 """AI CoDiscuss 的零依赖 HTTP / SQLite 概念验证服务。"""
 
 import argparse
+import collections
 import copy
 import hashlib
 import hmac
@@ -30,7 +31,7 @@ from .free_room import (add_member, after_free_message, authorize_free_write, ch
 from .free_room import add_discussion_member, convert_suggestion, discussion_member_action, message_suggestions, save_suggestions, sync_participants
 from .free_room import active_members, adopt_recommendation, ask_members, asks_view, checked_asks, recommend_member, register_member, route_held_messages, require_member
 from .free_room import describe_members, execution_notes, label_members, member_descriptions, member_labels, reorder_speakers, set_chain_rounds, speaking_order, stop_room_work
-from .free_room import continue_chain, execution_timeline, retract_message, rewind_plan, rewind_room, withdrawals
+from .free_room import continue_chain, execution_timeline, group_route_plan, retract_message, rewind_plan, rewind_room, withdrawals
 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, event_view,
@@ -46,6 +47,8 @@ ROOT = Path(__file__).resolve().parent.parent
 WEB_ROOT = ROOT / "web"
 DEFAULT_PORT = 8765
 UPDATE_HEARTBEAT_SECONDS = 15
+# Changes remembered for streams that fall behind; one further back is reported as a change to the whole site.
+UPDATE_LOG_SIZE = 256
 MAX_BODY_BYTES = 512 * 1024
 MAX_IMPORT_BYTES = 32 * 1024 * 1024
 MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024
@@ -1985,10 +1988,17 @@ def protocol_text(room):
     return "\n\n".join(paragraphs).replace("HOST", room["host"]).replace("BASE", base)
 
 
+def update_frame(rooms):
+    """Encode a change event; `rooms` lists the changed rooms, and without it every room may have changed."""
+    return f"event: change\ndata: {json.dumps({'rooms': rooms} if rooms else {})}\n\n".encode("utf-8")
+
+
 class DiscussionServer(ThreadingHTTPServer):
     """HTTP server carrying the configured SQLite path."""
 
     daemon_threads = True
+    # Every open page refreshes at once and the runner reads in bursts; Windows refuses connections beyond the backlog.
+    request_queue_size = 128
     allow_reuse_address = os.name != "nt"
     allow_reuse_port = False
 
@@ -1996,6 +2006,8 @@ class DiscussionServer(ThreadingHTTPServer):
         self.database = Path(database)
         self.updates = threading.Condition()
         self.update_version = 0
+        # Recent (version, room id or None) pairs, so a stream names the rooms that changed; None means the whole site.
+        self.update_log = collections.deque(maxlen=UPDATE_LOG_SIZE)
         self.updates_closed = False
         if local_launch and address[0] != "127.0.0.1":
             raise ValueError("本机启动入口须绑定 127.0.0.1")
@@ -2012,12 +2024,20 @@ class DiscussionServer(ThreadingHTTPServer):
             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
         super().server_bind()
 
-    def notify_update(self):
-        """Wake browser subscribers after a committed business write."""
+    def notify_update(self, room_id=None):
+        """Wake subscribers after a committed business write to one room, or to the site when no room is given."""
         with self.updates:
             self.update_version += 1
+            self.update_log.append((self.update_version, room_id))
             self.updates.notify_all()
 
+    def changed_rooms(self, version):
+        """Return the rooms changed after a version, or None when the site changed or the log no longer reaches it."""
+        entries = [room for number, room in self.update_log if number > version]
+        if len(entries) < self.update_version - version or None in entries:
+            return None
+        return sorted(set(entries))
+
     def server_close(self):
         """Release streaming clients when the HTTP server stops."""
         with self.updates:
@@ -2041,7 +2061,7 @@ class DiscussionHandler(BaseHTTPRequestHandler):
         quiet_renewal = (parts[3:4] == ["events"] and action == "renew") or (parts[3:4] in (["events"], ["executions"]) and action == "segments")
         if (self.command == "POST" and 200 <= status < 300 and parts[:2] in (["api", "rooms"], ["api", "folders"])
                 and not quiet_renewal):
-            self.server.notify_update()
+            self.server.notify_update(parts[2] if parts[:2] == ["api", "rooms"] and len(parts) > 3 else None)
         if content_type == "application/json":
             body = json.dumps(body, ensure_ascii=False)
         data = body.encode("utf-8") if isinstance(body, str) else body
@@ -2143,8 +2163,9 @@ class DiscussionHandler(BaseHTTPRequestHandler):
                     if self.server.updates_closed:
                         return
                     changed = self.server.update_version != version
+                    rooms = self.server.changed_rooms(version) if changed else None
                     version = self.server.update_version
-                self.wfile.write(b"event: change\ndata: {}\n\n" if changed else b": keepalive\n\n")
+                self.wfile.write(update_frame(rooms) if changed else b": keepalive\n\n")
                 self.wfile.flush()
         except OSError:
             pass
@@ -2689,6 +2710,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             result = reserve_execution(connection, room_id, token, 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 == "GET":
+            result = group_route_plan(connection, room_id, token, int(parts[4]))
         elif len(parts) == 5 and parts[3] == "recommendations" and method == "POST":
             result = adopt_recommendation(connection, room_id, token, int(parts[4]), self.read_payload())
         elif len(parts) == 6 and parts[3] == "executions" and parts[5] == "notes" and method == "GET":

package/package.json

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

package/runner/discuss.py

@@ -227,6 +227,8 @@ def message_commands(subcommands, registry):
     view = add_leaf(subcommands, registry, "message view", "读取一条精确原文与来源", True)
     view.add_argument("id", type=positive_int, help="消息编号")
     view.add_argument("--request", type=positive_int, help="手动成员：按自己的有效请求限制可读原文")
+    group = add_leaf(subcommands, registry, "message group-plan", "房主读取全体请求、成员、顺序与 revision；安排全体前先读，提交时携带该 revision", True)
+    group.add_argument("id", type=positive_int, help="全体请求的原消息编号")
     post = add_leaf(subcommands, registry, "message post", "提交观点、主持说明、协作回答或代发", True)
     add_text(post, "body")
     post.add_argument("--attachment", action="append", type=attachment_id, default=[],
@@ -488,6 +490,8 @@ def plan_room(args):
 def plan_message(args):
     """Preserve operator, original author, message role, and replay identifier."""
     base = f"/api/rooms/{args.room}/messages"
+    if args.action == "group-plan":
+        return RequestPlan(f"/api/rooms/{args.room}/recommendations/{args.id}")
     if args.action == "view":
         return RequestPlan(f"{base}/{args.id}", params=read_context_params(args))
     if args.action == "list":

package/runner/discussion_service.mjs

@@ -388,12 +388,14 @@ export class DiscussionService {
     }
     await Promise.all(checks);
   }
-  /** Check every room of a site now, as its website reported a change. */
-  wake(site) {
-    for (const [path, worker] of this.workers) if (worker.state.site === site) this.start(path, worker);
+  /** Check a site's rooms now, as its website reported a change; `rooms` limits it to the rooms that changed. */
+  wake(site, rooms = null) {
+    for (const [path, worker] of this.workers) {
+      if (worker.state.site === site && (!rooms || rooms.includes(worker.state.room))) this.start(path, worker);
+    }
   }
   /**
-   * Follow a site's `/api/updates` stream and wake its rooms on each change, so a message reaches the AI within
+   * Follow a site's `/api/updates` stream and wake the rooms each change names, so a message reaches the AI within
    * milliseconds instead of the next poll. A site without push (204) is left to polling; a dropped stream reconnects.
    */
   watch(site) {
@@ -411,7 +413,8 @@ export class DiscussionService {
             buffer += decoder.decode(chunk, { stream: true }).replaceAll('\r\n', '\n');
             for (let end = buffer.indexOf('\n\n'); end >= 0; end = buffer.indexOf('\n\n')) {
               // `ready` comes on every (re)connection, so changes missed while disconnected are picked up too.
-              if (/^event: (change|ready)$/m.test(buffer.slice(0, end))) this.wake(site);
+              const frame = buffer.slice(0, end);
+              if (/^event: (change|ready)$/m.test(frame)) this.wake(site, changed_rooms(frame));
               buffer = buffer.slice(end + 2);
             }
           }
@@ -451,6 +454,13 @@ export class DiscussionService {
   }
 }
 
+/** The rooms an update event names, or null when it names none and any room may have changed. */
+function changed_rooms(frame) {
+  const data = frame.match(/^data: (.*)$/m)?.[1];
+  try { const rooms = JSON.parse(data).rooms; return Array.isArray(rooms) && rooms.length ? rooms : null; }
+  catch { return null; }
+}
+
 /** Delete one room's local files: its answer drafts, and its launch folder when the service created it under launches/. */
 export function remove_room_files(home, config_path, data_directory) {
   const folder = dirname(resolve(config_path));

package/runner/free_runner.mjs

@@ -383,7 +383,8 @@ export class FreeRoomRunner {
     if (!adapter) return this.fail(member.name, execution.id, `未配置 ${member.name} 的本机接入`);
     if (this.context_errors.has(member.name)) return this.fail(member.name, execution.id, this.context_errors.get(member.name));
     const directory = adapter.adapter === 'api' ? undefined : adapter.cwd || this.config.cwd;
-    const before = workspace_snapshot(directory);
+    // A read-only member's software cannot write the project, so files changing meanwhile were written by someone else.
+    const before = adapter.project_access === 'read' ? null : workspace_snapshot(directory);
     if (before) this.snapshots.set(execution.id, { member: member.name, directory, before });
     const binding = this.store.binding(member.name);
     // A member whose session a rewind restarted is bound to '' and must not fall back to the session it was invited with.