ai_co_discuss 0.3.0 → 0.3.1

package/backend/schema.sql

@@ -778,3 +778,342 @@ INSERT OR IGNORE INTO member_manual_sources(member_id,source)
 SELECT id,'web' FROM room_members WHERE access='online';
 UPDATE room_members SET access='manual' WHERE access='online';
 UPDATE room_modes SET mode='free' WHERE mode='brainstorm';
+
+-- Change revisions, so idle rooms are not read on every poll. Every write a reader could show or act on gives its room the next
+-- value of one site-wide sequence: a room's revision tells a runner or page that this room changed, and the largest revision
+-- (read through the index) tells a page that anything on the site changed. The '' row stands for directory-only changes.
+-- Triggers update or insert without conflicts, so an outer INSERT OR IGNORE cannot override them into skipping the bump.
+CREATE TABLE IF NOT EXISTS room_revisions (
+    room_id TEXT PRIMARY KEY,
+    revision INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS room_revisions_order ON room_revisions(revision);
+DROP TRIGGER IF EXISTS revision_message_insert;
+CREATE TRIGGER revision_message_insert AFTER INSERT ON messages
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_message_update;
+CREATE TRIGGER revision_message_update AFTER UPDATE ON messages
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_message_withdrawal;
+CREATE TRIGGER revision_message_withdrawal AFTER INSERT ON message_withdrawals
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=(SELECT room_id FROM messages WHERE id=NEW.message_id);
+    INSERT INTO room_revisions (room_id,revision) SELECT (SELECT room_id FROM messages WHERE id=NEW.message_id),(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=(SELECT room_id FROM messages WHERE id=NEW.message_id));
+END;
+DROP TRIGGER IF EXISTS revision_member_insert;
+CREATE TRIGGER revision_member_insert AFTER INSERT ON room_members
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_member_update;
+CREATE TRIGGER revision_member_update AFTER UPDATE ON room_members
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_registration_insert;
+CREATE TRIGGER revision_registration_insert AFTER INSERT ON member_registrations
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_registration_update;
+CREATE TRIGGER revision_registration_update AFTER UPDATE ON member_registrations
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_session_report_insert;
+CREATE TRIGGER revision_session_report_insert AFTER INSERT ON member_sessions
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_session_report_update;
+CREATE TRIGGER revision_session_report_update AFTER UPDATE ON member_sessions
+WHEN OLD.session_id IS NOT NEW.session_id OR OLD.client IS NOT NEW.client
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_request_insert;
+CREATE TRIGGER revision_request_insert AFTER INSERT ON member_requests
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_request_status;
+CREATE TRIGGER revision_request_status AFTER UPDATE OF status ON member_requests
+WHEN OLD.status IS NOT NEW.status
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_execution_insert;
+CREATE TRIGGER revision_execution_insert AFTER INSERT ON member_executions
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_execution_status;
+CREATE TRIGGER revision_execution_status AFTER UPDATE OF status ON member_executions
+WHEN OLD.status IS NOT NEW.status
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_retry_insert;
+CREATE TRIGGER revision_retry_insert AFTER INSERT ON execution_retries
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_retry_update;
+CREATE TRIGGER revision_retry_update AFTER UPDATE ON execution_retries
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_discussion_insert;
+CREATE TRIGGER revision_discussion_insert AFTER INSERT ON discussion_sessions
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_discussion_status;
+CREATE TRIGGER revision_discussion_status AFTER UPDATE OF status ON discussion_sessions
+WHEN OLD.status IS NOT NEW.status
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_plan_insert;
+CREATE TRIGGER revision_plan_insert AFTER INSERT ON session_requests
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id);
+    INSERT INTO room_revisions (room_id,revision) SELECT (SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id),(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id));
+END;
+DROP TRIGGER IF EXISTS revision_plan_status;
+CREATE TRIGGER revision_plan_status AFTER UPDATE OF status ON session_requests
+WHEN OLD.status IS NOT NEW.status
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id);
+    INSERT INTO room_revisions (room_id,revision) SELECT (SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id),(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id));
+END;
+DROP TRIGGER IF EXISTS revision_session_phase;
+CREATE TRIGGER revision_session_phase AFTER UPDATE OF phase ON session_state
+WHEN OLD.phase IS NOT NEW.phase
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id);
+    INSERT INTO room_revisions (room_id,revision) SELECT (SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id),(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id));
+END;
+DROP TRIGGER IF EXISTS revision_session_limits;
+CREATE TRIGGER revision_session_limits AFTER UPDATE ON session_limits
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id);
+    INSERT INTO room_revisions (room_id,revision) SELECT (SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id),(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=NEW.session_id));
+END;
+DROP TRIGGER IF EXISTS revision_topic_update;
+CREATE TRIGGER revision_topic_update AFTER UPDATE ON topic_settings
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_brief_insert;
+CREATE TRIGGER revision_brief_insert AFTER INSERT ON room_briefs
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_brief_update;
+CREATE TRIGGER revision_brief_update AFTER UPDATE ON room_briefs
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_user_request_insert;
+CREATE TRIGGER revision_user_request_insert AFTER INSERT ON room_user_requests
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_user_request_update;
+CREATE TRIGGER revision_user_request_update AFTER UPDATE ON room_user_requests
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_decision_insert;
+CREATE TRIGGER revision_decision_insert AFTER INSERT ON scheduler_decisions
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_recommendation_insert;
+CREATE TRIGGER revision_recommendation_insert AFTER INSERT ON member_recommendations
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_recommendation_status;
+CREATE TRIGGER revision_recommendation_status AFTER UPDATE OF status ON member_recommendations
+WHEN OLD.status IS NOT NEW.status
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_description_insert;
+CREATE TRIGGER revision_description_insert AFTER INSERT ON member_descriptions
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_description_update;
+CREATE TRIGGER revision_description_update AFTER UPDATE ON member_descriptions
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_label_insert;
+CREATE TRIGGER revision_label_insert AFTER INSERT ON member_labels
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_label_update;
+CREATE TRIGGER revision_label_update AFTER UPDATE ON member_labels
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_order_insert;
+CREATE TRIGGER revision_order_insert AFTER INSERT ON speaking_orders
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_order_update;
+CREATE TRIGGER revision_order_update AFTER UPDATE ON speaking_orders
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_free_settings_insert;
+CREATE TRIGGER revision_free_settings_insert AFTER INSERT ON free_settings
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_free_settings_update;
+CREATE TRIGGER revision_free_settings_update AFTER UPDATE ON free_settings
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.room_id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.room_id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.room_id);
+END;
+DROP TRIGGER IF EXISTS revision_room_insert;
+CREATE TRIGGER revision_room_insert AFTER INSERT ON rooms
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.id);
+END;
+DROP TRIGGER IF EXISTS revision_room_update;
+CREATE TRIGGER revision_room_update AFTER UPDATE ON rooms
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id=NEW.id;
+    INSERT INTO room_revisions (room_id,revision) SELECT NEW.id,(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id=NEW.id);
+END;
+DROP TRIGGER IF EXISTS revision_room_delete;
+CREATE TRIGGER revision_room_delete AFTER DELETE ON rooms
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id='';
+    INSERT INTO room_revisions (room_id,revision) SELECT '',(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id='');
+END;
+DROP TRIGGER IF EXISTS revision_directory_update;
+CREATE TRIGGER revision_directory_update AFTER UPDATE ON room_directory
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id='';
+    INSERT INTO room_revisions (room_id,revision) SELECT '',(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id='');
+END;
+DROP TRIGGER IF EXISTS revision_assignment_update;
+CREATE TRIGGER revision_assignment_update AFTER UPDATE ON room_folder_assignments
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id='';
+    INSERT INTO room_revisions (room_id,revision) SELECT '',(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id='');
+END;
+DROP TRIGGER IF EXISTS revision_folder_insert;
+CREATE TRIGGER revision_folder_insert AFTER INSERT ON topic_folders
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id='';
+    INSERT INTO room_revisions (room_id,revision) SELECT '',(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id='');
+END;
+DROP TRIGGER IF EXISTS revision_folder_update;
+CREATE TRIGGER revision_folder_update AFTER UPDATE ON topic_folders
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id='';
+    INSERT INTO room_revisions (room_id,revision) SELECT '',(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id='');
+END;
+DROP TRIGGER IF EXISTS revision_folder_delete;
+CREATE TRIGGER revision_folder_delete AFTER DELETE ON topic_folders
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id='';
+    INSERT INTO room_revisions (room_id,revision) SELECT '',(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id='');
+END;
+DROP TRIGGER IF EXISTS revision_directory_settings;
+CREATE TRIGGER revision_directory_settings AFTER UPDATE ON directory_settings
+BEGIN
+    UPDATE room_revisions SET revision=(SELECT MAX(revision)+1 FROM room_revisions) WHERE room_id='';
+    INSERT INTO room_revisions (room_id,revision) SELECT '',(SELECT COALESCE(MAX(revision),0)+1 FROM room_revisions)
+        WHERE NOT EXISTS (SELECT 1 FROM room_revisions WHERE room_id='');
+END;

package/backend/server.py

@@ -51,6 +51,8 @@ MAX_IMPORT_BYTES = 32 * 1024 * 1024
 MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024
 MAX_MESSAGE_ATTACHMENTS = 10
 MAX_FILENAME_LENGTH = 255
+# A revision check names at most this many rooms; a runner or page asks only for the rooms it follows.
+MAX_REVISION_ROOMS = 100
 LOCAL_LAUNCH_TIMEOUT = 60
 # Ordering and filing a channel only rearrange the shared directory, like folder edits, so they need no room credential.
 DIRECTORY_OPERATIONS = ("move", "folder")
@@ -804,6 +806,24 @@ def submission_value(value):
     return identifier
 
 
+def room_revisions(connection, params):
+    """Return the site revision and each named room's revision, so an idle room is read in full only after it changed.
+
+    Args:
+        connection: Database connection.
+        params: Query parameters; ``rooms`` is a comma-separated list of room ids.
+
+    Returns:
+        ``{"site": int, "rooms": {room_id: int}}``; a room that does not exist is left out.
+    """
+    ids = [item for item in str(params.get("rooms", "")).split(",") if item][:MAX_REVISION_ROOMS]
+    site = connection.execute("SELECT COALESCE(MAX(revision),0) AS revision FROM room_revisions").fetchone()["revision"]
+    marks = ",".join("?" * len(ids))
+    rows = connection.execute(f"""SELECT rooms.id,COALESCE(room_revisions.revision,0) AS revision FROM rooms
+        LEFT JOIN room_revisions ON room_revisions.room_id=rooms.id WHERE rooms.id IN ({marks})""", ids).fetchall() if ids else []
+    return {"site": site, "rooms": {row["id"]: row["revision"] for row in rows}}
+
+
 def list_rooms(connection, params=None):
     """Return rooms, optionally locating a single persisted creation request."""
     params = params or {}
@@ -2342,6 +2362,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             return self.respond(list_feedback_cases(connection, int(params.get("after", 0))))
         if parts[1:2] in (["machines"], ["remote-launches"]):
             return self.handle_remote_launch_api(connection, parts, method)
+        if parts == ["api", "revisions"] and method == "GET":
+            return self.respond(room_revisions(connection, params))
         if parts == ["api", "rooms"]:
             if method == "GET":
                 return self.respond({**list_rooms(connection, params), "participants": PARTICIPANTS})

package/docs/deployment.md

@@ -109,7 +109,7 @@ codiscuss health --site https://YOUR_PROJECT_NAME.pages.dev
 
 ### 实时推送（可选）
 
-未配置时网页每 12 秒轮询。需要跨实例实时推送时，先部署通知 Worker，再在私有配置中绑定：
+未配置时网页每 12 秒检查一次房间是否有变化，有变化才重新读取。需要跨实例实时推送时，先部署通知 Worker，再在私有配置中绑定：
 
 ```sh
 npx wrangler deploy --config deploy/updates.wrangler.jsonc

package/package.json

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

package/runner/discussion_adapters.mjs

@@ -256,7 +256,7 @@ function agy_project_grants(config, task, resources, user_home) {
     throw new Error('agy 草稿目录不能位于只读项目、运行目录、技能或 .gemini 配置目录中，未交付讨论任务');
   }
   const write_rule = directory => `write_file(${resolve(directory).replaceAll('\\', '/')})`;
-  // 完全放开 also runs commands outside agy's sandbox and allows MCP tools; run data stays protected at every level.
+  // 全放开 also runs commands outside agy's sandbox and allows MCP tools; run data stays protected at every level.
   const full = config.project_access === 'full';
   return { allow: [agy_rule(), write_rule(task.draft_directory),
     ...(config.project_access === 'read' ? [] : [...projects.map(write_rule), 'command(*)']), ...(full ? ['unsandboxed_command(*)'] : []),
@@ -315,7 +315,7 @@ export function remove_agy_projects(directory, user_home = homedir()) {
  */
 export function claude_permissions(config, task) {
   // A headless run cannot ask for approval: 自动 and a taken-over manual member use auto mode, as the original window
-  // does, and 完全放开 skips every check; the website commands and drafts stay pre-approved either way.
+  // does, and 全放开 skips every check; the website commands and drafts stay pre-approved either way.
   if (['own', 'auto', 'full'].includes(config.project_access)) {
     const commands = TASK_SUBCOMMANDS.flatMap(command => [`Bash(codiscuss ${command} *)`, `PowerShell(codiscuss ${command} *)`]);
     return ['--permission-mode', config.project_access === 'full' ? 'bypassPermissions' : 'auto', '--add-dir', task.directory, task.draft_directory, task.skills_directory, '--allowedTools',
@@ -640,7 +640,7 @@ async function claude_delivery(config, binding, task, spawn_process = spawn) {
 
 /** Build a per-invocation profile without inheriting a user's custom profile of the same name. */
 export function codex_permissions(config, task, platform = process.platform) {
-  // 完全放开 runs without approval or sandbox, so there is no profile to build or check.
+  // 全放开 runs without approval or sandbox, so there is no profile to build or check.
   if (config.project_access === 'full') return { name: '', args: ['--dangerously-bypass-approvals-and-sandbox'] };
   const name = `codiscuss-${randomUUID()}`;
   // A taken-over manual member writes like 可写: its own config may sandbox read-only and then could not save its answer draft.

package/runner/discussion_launch.mjs

@@ -643,7 +643,7 @@ export async function room_member_access(home, raw) {
     const profile = config.participants?.[name];
     if (!profile) throw new Error(`${name} 不由本机唤醒，项目权限由它自己的会话决定`);
     if (profile.project_access === 'own') throw new Error(`${name} 是手动接入的成员，权限沿用它自己会话的软件设置`);
-    if (!access_levels(profile.adapter).includes(project_access)) throw new Error('agy 无人值守不支持自动档，请选只读、可写或完全放开');
+    if (!access_levels(profile.adapter).includes(project_access)) throw new Error('agy 无人值守不支持自动档，请选只读、可写或全放开');
     if (!ACCESS_ADAPTERS.includes(profile.adapter)) throw new Error(profile.adapter === 'api' ? 'API 成员没有本机文件工具，项目固定只读' : `${name} 的项目权限在 App 内设置`);
     if (profile.adapter === 'antigravity_cli' && profile.session_id) throw new Error(`${name} 续接的是它自己的 agy 对话，项目权限沿用该对话所在项目，请在 agy 中设置`);
     if (project_access === 'write' && !(profile.cwd || config.cwd)) throw new Error('本房间没有指定项目目录，可写没有作用；请在新建房间时选择项目目录');

package/runner/discussion_runner.mjs

@@ -66,7 +66,7 @@ export function validate_config(input, base_directory) {
     participant.project_access = participant.project_access || config.project_access || 'read';
     // `own` is set only when the service takes over a manual member: it keeps its own session's permissions.
     if (![...PROJECT_ACCESS, 'own'].includes(participant.project_access)) throw new Error('project_access 只能为 read、write、auto 或 full');
-    if (participant.project_access !== 'own' && !access_levels(participant.adapter).includes(participant.project_access)) throw new Error('agy 无人值守不支持自动档，请选只读、可写或完全放开');
+    if (participant.project_access !== 'own' && !access_levels(participant.adapter).includes(participant.project_access)) throw new Error('agy 无人值守不支持自动档，请选只读、可写或全放开');
     if (participant.cwd && !statSync(participant.cwd).isDirectory()) throw new Error('cwd 必须是已有本机目录');
     if (!ADAPTER_NAMES.includes(participant.adapter)) throw new Error(`适配器只能为 ${ADAPTER_NAMES.join('/')}`);
     if (participant.adapter === 'antigravity' && !participant.ipc_directory) throw new Error('缺少 Antigravity Sidecar IPC 目录');

package/runner/discussion_service.mjs

@@ -15,6 +15,10 @@ import { FreeRoomRunner } from './free_runner.mjs';
 const POLL_MS = 2000;
 // A hosted site is polled less often than a local one: every request spends its database quota.
 const REMOTE_POLL_MS = 10_000;
+// A hosted site is asked this often which rooms changed; an idle room is read in full only then, or at the safety interval.
+const REVISION_POLL_MS = 3000;
+const IDLE_REMOTE_POLL_MS = 5 * 60_000;
+const REVISION_TIMEOUT_MS = 10_000;
 const UPDATE_RETRY_MS = 5000;
 const LOOPBACK = new Set(['127.0.0.1', 'localhost', '[::1]']);
 const REMOTE_SYNC_MS = 3000;
@@ -229,7 +233,8 @@ class RoomWorker {
   }
   /** A manual Claude, Codex or agy 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() {
-    const members = (await api(this.config, '')).free?.members || [];
+    // The runner has just read the room; reading it again here would double every poll.
+    const members = (this.runner.room ?? await api(this.config, '')).free?.members || [];
     for (const member of members) {
       const key = `${member.name}:${member.reported_session}`;
       // A restored room keeps its Claude Code members manual so their original window stays the only writer.
@@ -256,7 +261,9 @@ class RoomWorker {
       const result = await this.runner.tick();
       await this.adopt_manual_members();
       Object.assign(this.state, { status: TICK_STATES[result], error: '' });
+      this.idle = this.runner.idle?.() === true;
     } catch (error) {
+      this.idle = false;
       if (await this.deleted(error)) { this.removed = true; return; }
       if (error.message !== this.state.error) this.log(`${this.state.room || this.path}: ${error.message}`);
       Object.assign(this.state, { status: 'error', error: error.message });
@@ -296,7 +303,9 @@ export class DiscussionService {
     this.log = log;
     this.workers = new Map();
     // How often each room is checked without a push: a local site costs nothing, a hosted one spends its database quota.
-    this.intervals = { local: POLL_MS, remote: REMOTE_POLL_MS };
+    this.intervals = { local: POLL_MS, remote: REMOTE_POLL_MS, revisions: REVISION_POLL_MS, idle: IDLE_REMOTE_POLL_MS };
+    // Per hosted site: when its revisions were last asked, whether a check is in flight, and whether the site offers them.
+    this.revisions = new Map();
     // The resident service turns this on so a site's update stream checks its rooms at once; tests leave it off.
     this.push = false;
     this.streams = new Map();
@@ -317,6 +326,8 @@ export class DiscussionService {
       if (!worker.busy && (wait || Date.now() >= (worker.next_at ?? 0))) this.start(path, worker);
     }
     if (this.push) for (const site of new Set([...this.workers.values()].map(worker => worker.state.site).filter(Boolean))) this.watch(site);
+    const checks = this.check_revisions();
+    if (wait) await checks;
     if (wait) await Promise.all([...this.workers.values()].map(worker => worker.busy));
     this.write_status();
   }
@@ -329,11 +340,54 @@ export class DiscussionService {
       .finally(() => {
         // Counted from the end of the tick, once the room's site is known; a slow site does not poll back to back.
         const local = !worker.state.site || LOOPBACK.has(new URL(worker.state.site).hostname);
-        worker.next_at = Date.now() + (local ? this.intervals.local : this.intervals.remote);
+        // An idle hosted room waits for its revision to change; a site without revisions keeps the regular interval.
+        const watched = worker.idle && this.revisions.get(worker.state.site)?.supported !== false;
+        worker.next_at = Date.now() + (local ? this.intervals.local : watched ? this.intervals.idle : this.intervals.remote);
         worker.busy = null;
         if (worker.woken && this.workers.get(path) === worker) { worker.woken = false; this.start(path, worker); }
       });
   }
+  /**
+   * Ask each hosted site which of its rooms changed since the last check and tick those at once; one small read per site
+   * replaces a full read of every idle room. A room missing from the answer was deleted, and its next tick removes it.
+   * A site that does not answer (404 without revisions, or an error) leaves its rooms on the regular interval and is asked
+   * again after the safety interval.
+   */
+  async check_revisions() {
+    const sites = new Map();
+    for (const [path, worker] of this.workers) {
+      const site = worker.state.site;
+      if (site && worker.state.room && !LOOPBACK.has(new URL(site).hostname)) sites.set(site, [...(sites.get(site) || []), [path, worker]]);
+    }
+    const checks = [];
+    for (const [site, entries] of sites) {
+      const watch = this.revisions.get(site) ?? { at: 0, busy: false, supported: true };
+      this.revisions.set(site, watch);
+      if (this.closed || watch.busy || Date.now() - watch.at < (watch.supported ? this.intervals.revisions : this.intervals.idle)) continue;
+      Object.assign(watch, { at: Date.now(), busy: true });
+      const rooms = entries.map(([, worker]) => encodeURIComponent(worker.state.room)).join(',');
+      checks.push(fetch(`${site}/api/revisions?rooms=${rooms}`, { redirect: 'error', signal: AbortSignal.timeout(REVISION_TIMEOUT_MS) })
+        .then(async response => {
+          // Without an answer (no such route, or the site failing) the rooms fall back to the regular interval at once,
+          // instead of waiting out the safety interval for a revision that may not come.
+          if (!response.ok) {
+            if (watch.supported) for (const [, worker] of entries) worker.next_at = 0;
+            watch.supported = false;
+            return;
+          }
+          watch.supported = true;
+          const revisions = (await response.json()).rooms || {};
+          for (const [path, worker] of entries) {
+            const revision = revisions[worker.state.room] ?? null;
+            if (worker.revision !== revision) { worker.revision = revision; this.start(path, worker); }
+          }
+        })
+        // A failed check is retried at the next interval; idle rooms still get their safety tick.
+        .catch(() => {})
+        .finally(() => { watch.busy = false; }));
+    }
+    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);

package/runner/expert_prompts.mjs

@@ -45,11 +45,11 @@ export function with_expert_prompt(prompt, profile) {
 
 /**
  * Project access of a member woken on this computer: 只读, 可写 (project files and any command), 自动 (the software's own
- * automatic approval) and 完全放开 (no approval or sandbox). A manual member the service took over is `own`.
+ * automatic approval) and 全放开 (no approval or sandbox). A manual member the service took over is `own`.
  */
 export const PROJECT_ACCESS = ['read', 'write', 'auto', 'full'];
 
-const ACCESS_LABELS = { read: '只读', write: '可写', auto: '自动', full: '完全放开' };
+const ACCESS_LABELS = { read: '只读', write: '可写', auto: '自动', full: '全放开' };
 
 /** What each level does in each software, measured headless (Claude Code 2.1.312, Codex CLI 0.163, agy 1.4.10). */
 const ACCESS_HINTS = {

package/runner/free_runner.mjs

@@ -221,6 +221,7 @@ export class FreeRoomRunner {
     if (!inbox.archived) this.arrange_groups(inbox, room);
     this.room_title = room.title;
     this.room = room;
+    this.inbox = inbox;
     const active = new Map(inbox.executions.map(item => [item.id, item]));
     const present = new Set(inbox.members.map(member => member.name));
     // A member sent away or removed no longer appears; its live work was already voided on the website.
@@ -238,6 +239,17 @@ export class FreeRoomRunner {
         && !member.pending.some(request => this.routing.has(request.id))) await this.start(member, row);
     }
   }
+  /**
+   * Whether the last tick left nothing in progress: no live delivery or process, no open request for a member this
+   * runner delivers to, no pending scheduling judgement and no running discussion. An idle room changes only through its
+   * website, so the service may wait for the website to report a change before ticking it again.
+   */
+  idle() {
+    const inbox = this.inbox;
+    if (!inbox || this.routing.size || [...this.members.values()].some(children => children.size)) return false;
+    if (this.room?.session?.status === 'active' || inbox.executions.length || inbox.members.some(member => member.pending.length)) return false;
+    return !this.store.db.prepare('SELECT status FROM free_deliveries').all().some(row => LIVE.includes(row.status));
+  }
   /**
    * Smart scheduling: for each new unnamed message routed to the host, ask the provider whether another woken
    * member suits it better and apply a confident pick. The host waits for the answer (or its failure) before starting.