ai_co_discuss 0.2.99 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (39) hide show
  1. package/.agents/skills/discuss-host/SKILL.md +3 -3
  2. package/.agents/skills/discuss-host/references/discussion.md +16 -16
  3. package/.agents/skills/discuss-host/references/launch.md +1 -3
  4. package/.agents/skills/discuss-host/references/manual.md +14 -77
  5. package/.agents/skills/discuss-participant/SKILL.md +3 -3
  6. package/.agents/skills/discuss-participant/references/discussion.md +29 -27
  7. package/.agents/skills/discuss-participant/references/free.md +2 -2
  8. package/.agents/skills/discuss-participant/references/manual.md +8 -10
  9. package/.agents/skills/discuss-participant/references/writing.md +9 -9
  10. package/.github/SECURITY.md +1 -1
  11. package/README.md +3 -3
  12. package/README.zh-CN.md +3 -3
  13. package/backend/free_room.py +360 -68
  14. package/backend/room_import.py +75 -15
  15. package/backend/runtime.py +81 -169
  16. package/backend/schema.sql +136 -244
  17. package/backend/server.py +602 -166
  18. package/backend/session_room.py +919 -0
  19. package/docs/architecture.md +3 -2
  20. package/docs/en/architecture.md +4 -3
  21. package/docs/en/runner.md +3 -1
  22. package/docs/en/workflow.md +9 -6
  23. package/docs/runner.md +3 -1
  24. package/docs/workflow.md +11 -8
  25. package/package.json +2 -2
  26. package/runner/api_participant.mjs +47 -44
  27. package/runner/discuss.py +77 -58
  28. package/runner/discussion_adapters.mjs +6 -3
  29. package/runner/discussion_launch.mjs +98 -70
  30. package/runner/discussion_runner.mjs +38 -496
  31. package/runner/discussion_service.mjs +21 -74
  32. package/runner/discussion_sidecar.mjs +4 -13
  33. package/runner/expert_prompts.mjs +29 -21
  34. package/runner/free_runner.mjs +84 -19
  35. package/runner/session_driver.mjs +175 -0
  36. package/web/app.js +193 -128
  37. package/web/backup.js +1 -1
  38. package/web/modern.css +1 -1
  39. package/web/modern.js +5482 -6646
@@ -0,0 +1,919 @@
1
+ """Request-backed discussion session state and plan operations."""
2
+
3
+ import hashlib
4
+ import json
5
+ import re
6
+ import time
7
+
8
+ from .free_room import active_members, finish_execution, require_member, require_owner
9
+ from .runtime import begin_write, enforce_session_limits, limit_values, token_hash
10
+
11
+ MAX_PLAN_TURNS = 10
12
+ MAX_QUESTION_LENGTH = 1000
13
+
14
+
15
+ def current_session(connection, room_id, active_only=False):
16
+ """Return the latest request-model session, optionally only while it is open."""
17
+ status_filter = "AND status IN ('active','paused')" if active_only else ""
18
+ row = connection.execute(f"SELECT * FROM discussion_sessions WHERE room_id=? {status_filter} ORDER BY id DESC LIMIT 1", (room_id,)).fetchone()
19
+ if not row or not connection.execute("SELECT 1 FROM session_state WHERE session_id=?", (row['id'],)).fetchone():
20
+ return None
21
+ return dict(row)
22
+
23
+
24
+ def session_room(connection, room_id):
25
+ """Read discussion control state and its revision without exposing credentials."""
26
+ if enforce_session_limits(connection, room_id):
27
+ connection.commit()
28
+ session = current_session(connection, room_id, active_only=True)
29
+ if not session:
30
+ return {"session": None, "revision": _idle_session_revision(connection, room_id)}
31
+ state = dict(connection.execute("SELECT * FROM session_state WHERE session_id=?", (session['id'],)).fetchone())
32
+ limits = dict(connection.execute("SELECT * FROM session_limits WHERE session_id=?", (session['id'],)).fetchone())
33
+ pause = dict(connection.execute("SELECT * FROM session_pauses WHERE session_id=?", (session['id'],)).fetchone())
34
+ option = connection.execute("SELECT named_followup FROM session_options WHERE session_id=?", (session['id'],)).fetchone()
35
+ if not option:
36
+ option = connection.execute("SELECT named_followup FROM discussion_options WHERE room_id=?", (room_id,)).fetchone()
37
+ counts = connection.execute("SELECT COUNT(*) FROM session_requests WHERE session_id=? AND purpose='discuss' AND status='answered'", (session['id'],)).fetchone()[0]
38
+ session.update(state)
39
+ submission = connection.execute("SELECT submission_id FROM session_start_submissions WHERE session_id=?", (session['id'],)).fetchone()
40
+ session["start_submission_id"] = submission[0] if submission else None
41
+ session["named_followup"] = bool(option[0]) if option else True
42
+ session["limits"] = limits
43
+ session["pause"] = pause
44
+ session["answered"] = counts
45
+ revision = _session_revision(connection, session)
46
+ session["revision"] = revision
47
+ return {"session": session, "revision": revision}
48
+
49
+
50
+ def _idle_session_revision(connection, room_id):
51
+ """Bind a new-session start token to the latest prior session, roster and visible history."""
52
+ latest_session = connection.execute("SELECT id,status FROM discussion_sessions WHERE room_id=? ORDER BY id DESC LIMIT 1",
53
+ (room_id,)).fetchone()
54
+ members = [list(row) for row in connection.execute("""SELECT m.id,m.name,m.role,m.access,m.status,
55
+ CASE WHEN r.token_hash=m.token_hash THEN 1 ELSE 0 END AS registered,COALESCE(source.source,'')
56
+ FROM room_members m LEFT JOIN member_registrations r ON r.member_id=m.id
57
+ LEFT JOIN member_manual_sources source ON source.member_id=m.id
58
+ WHERE m.room_id=? ORDER BY m.id""", (room_id,))]
59
+ latest_message = connection.execute("""SELECT COALESCE(MAX(id),0) FROM messages WHERE room_id=?
60
+ AND NOT EXISTS(SELECT 1 FROM task_message_sources WHERE message_id=messages.id)""", (room_id,)).fetchone()[0]
61
+ mode = connection.execute("SELECT mode FROM room_modes WHERE room_id=?", (room_id,)).fetchone()
62
+ options = connection.execute("SELECT named_followup FROM session_options WHERE session_id=?",
63
+ (latest_session["id"],)).fetchone() if latest_session else None
64
+ return _hash_revision([room_id, list(latest_session) if latest_session else None, members,
65
+ mode[0] if mode else "", list(options) if options else None, latest_message])
66
+
67
+
68
+ def _hash_revision(value):
69
+ """Create a compact version token from the complete state a write depends on."""
70
+ encoded = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
71
+ return hashlib.sha256(encoded.encode()).hexdigest()[:16]
72
+
73
+
74
+ def _session_revision(connection, session):
75
+ """Bind a control revision to this session, its roster, queue, phase and limits."""
76
+ session_id = session["id"]
77
+ state = connection.execute("SELECT phase,read_until,held_since FROM session_state WHERE session_id=?", (session_id,)).fetchone()
78
+ limits = connection.execute("SELECT max_rounds,max_minutes,execution_minutes,started_at,stop_reason FROM session_limits WHERE session_id=?", (session_id,)).fetchone()
79
+ members = [list(row) for row in connection.execute("""SELECT m.id,m.name,m.role,m.access,m.status,
80
+ CASE WHEN r.token_hash=m.token_hash THEN 1 ELSE 0 END AS registered
81
+ FROM room_members m LEFT JOIN member_registrations r ON r.member_id=m.id
82
+ WHERE m.room_id=? ORDER BY m.id""", (session["room_id"],))]
83
+ queue = [list(row) for row in connection.execute("""SELECT id,round,position,member_id,purpose,status,submission_id,question
84
+ FROM session_requests WHERE session_id=? ORDER BY round,position,id""", (session_id,))]
85
+ options = list(connection.execute("SELECT named_followup FROM session_options WHERE session_id=?", (session_id,)).fetchone())
86
+ latest = connection.execute("""SELECT COALESCE(MAX(m.id),0) FROM messages m WHERE m.room_id=?
87
+ AND NOT EXISTS (SELECT 1 FROM task_message_sources t WHERE t.message_id=m.id)""", (session["room_id"],)).fetchone()[0]
88
+ return _hash_revision([session_id, session["status"], list(state), list(limits), options, members, queue, latest])
89
+
90
+
91
+ def require_revision(view, payload, message):
92
+ """Require the exact revision read before a state-dependent session write."""
93
+ if payload.get("revision") is None:
94
+ raise ValueError(f"{message}前须先读取最新讨论状态并带上 revision")
95
+ if str(payload["revision"]) != str(view["revision"]):
96
+ raise FileExistsError("讨论状态已变化,请重新读取后再提交")
97
+
98
+
99
+ def _task_message(connection, session_id, request_id, cause):
100
+ """Create a hidden, uniquely sourced message used only as a member request anchor."""
101
+ task = connection.execute("SELECT * FROM session_requests WHERE id=? AND session_id=?", (request_id, session_id)).fetchone()
102
+ existing = connection.execute("SELECT message_id FROM task_message_sources WHERE session_request_id=?", (request_id,)).fetchone()
103
+ if existing:
104
+ return existing["message_id"]
105
+ room_id = connection.execute("SELECT room_id FROM discussion_sessions WHERE id=?", (session_id,)).fetchone()[0]
106
+ submission_id = f"session-task-{request_id}"
107
+ created_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
108
+ cursor = connection.execute("INSERT INTO messages(room_id,author,text,source,submission_id,created_at) VALUES(?,?,?,?,?,?)",
109
+ (room_id, "系统任务", task["question"], "system", submission_id, created_at))
110
+ message_id = cursor.lastrowid
111
+ connection.execute("INSERT INTO task_message_sources(message_id,session_id,session_request_id,cause_kind,cause_message_id,cause_request_id) VALUES(?,?,?,?,?,?)",
112
+ (message_id, session_id, request_id, cause["kind"], cause.get("message_id"), cause.get("request_id")))
113
+ return message_id
114
+
115
+
116
+ def _open_request(connection, session_request, cause):
117
+ """Anchor a session plan to one internal task message and create its normal member request."""
118
+ request_id = session_request["id"]
119
+ message_id = _task_message(connection, session_request["session_id"], request_id, cause)
120
+ existing = connection.execute("SELECT id FROM member_requests WHERE message_id=? AND member_id=?", (message_id, session_request["member_id"])).fetchone()
121
+ if existing:
122
+ member_request_id = existing["id"]
123
+ else:
124
+ session = connection.execute("SELECT room_id FROM discussion_sessions WHERE id=?", (session_request["session_id"],)).fetchone()
125
+ cursor = connection.execute("""INSERT INTO member_requests
126
+ (room_id,member_id,message_id,chain_id,purpose,created_by,created_at)
127
+ VALUES(?,?,?,?,?,?,?)""", (session["room_id"], session_request["member_id"],
128
+ message_id, message_id, session_request["purpose"], "host", int(time.time())))
129
+ member_request_id = cursor.lastrowid
130
+ connection.execute("UPDATE session_requests SET status='open',member_request_id=? WHERE id=?", (member_request_id, request_id))
131
+ return member_request_id
132
+
133
+
134
+ def create_host_request(connection, session_id, question, cause):
135
+ """Create one idempotent host request for a session event."""
136
+ state = connection.execute("SELECT phase FROM session_state WHERE session_id=?", (session_id,)).fetchone()
137
+ if not state:
138
+ raise LookupError("讨论会话不存在")
139
+ session = connection.execute("SELECT room_id FROM discussion_sessions WHERE id=?", (session_id,)).fetchone()
140
+ host = connection.execute("SELECT id FROM room_members WHERE room_id=? AND role='host' AND status='active'", (session["room_id"],)).fetchone()
141
+ if not host:
142
+ raise ValueError("当前讨论没有在场的 AI 主持人")
143
+ cause_kind = cause["kind"]
144
+ key = str(cause.get("key") or cause.get("message_id") or cause.get("request_id") or cause_kind)
145
+ submission_id = f"host-{session_id}-{cause_kind}-{key}"[:100]
146
+ row = connection.execute("SELECT * FROM session_requests WHERE session_id=? AND submission_id=?", (session_id, submission_id)).fetchone()
147
+ if row:
148
+ return dict(row)
149
+ position = connection.execute("SELECT COALESCE(MAX(position),0)+1 FROM session_requests WHERE session_id=? AND purpose='discuss_host'", (session_id,)).fetchone()[0]
150
+ cursor = connection.execute("INSERT INTO session_requests(session_id,round,position,member_id,purpose,question,status,submission_id,read_until,created_at) VALUES(?,0,?,?,'discuss_host',?,'open',?,NULL,?)",
151
+ (session_id, position, host["id"], question, submission_id, time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())))
152
+ row = connection.execute("SELECT * FROM session_requests WHERE id=?", (cursor.lastrowid,)).fetchone()
153
+ _open_request(connection, row, cause)
154
+ return dict(connection.execute("SELECT * FROM session_requests WHERE id=?", (cursor.lastrowid,)).fetchone())
155
+
156
+
157
+ def advance_session(connection, session_id):
158
+ """Promote the next queued discussion plan; execution reservation enforces session exclusivity."""
159
+ session = connection.execute("SELECT status FROM discussion_sessions WHERE id=?", (session_id,)).fetchone()
160
+ if not session or session["status"] != "active":
161
+ return None
162
+ active = connection.execute("SELECT id FROM session_requests WHERE session_id=? AND purpose='discuss' AND status='open'", (session_id,)).fetchone()
163
+ if active:
164
+ return dict(connection.execute("SELECT * FROM session_requests WHERE id=?", (active["id"],)).fetchone())
165
+ queued = connection.execute("SELECT * FROM session_requests WHERE session_id=? AND purpose='discuss' AND status='queued' ORDER BY round,position,id LIMIT 1", (session_id,)).fetchone()
166
+ if not queued:
167
+ return None
168
+ request = dict(queued)
169
+ _open_request(connection, request, {"kind": "scheduled_speaker"})
170
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session_id,))
171
+ return dict(connection.execute("SELECT * FROM session_requests WHERE id=?", (queued["id"],)).fetchone())
172
+
173
+
174
+ def _start_submission(connection, room_id, payload):
175
+ """Bind an optional launch replay id to the exact original start request."""
176
+ submission_id = payload.get("submission_id")
177
+ if submission_id is None:
178
+ return None
179
+ if not isinstance(submission_id, str) or not re.fullmatch(r"[A-Za-z0-9_-]{8,100}", submission_id):
180
+ raise ValueError("submission_id 须为 8–100 位字母、数字、下划线或短横线")
181
+ request_json = json.dumps({key: payload[key] for key in ("revision", "goal", "limits", "named_followup") if key in payload},
182
+ ensure_ascii=False, sort_keys=True, separators=(",", ":"))
183
+ row = connection.execute("SELECT * FROM session_start_submissions WHERE room_id=? AND submission_id=?",
184
+ (room_id, submission_id)).fetchone()
185
+ if row and row["request_json"] != request_json:
186
+ raise FileExistsError("这个 submission_id 已用于不同的开启请求;请核对原提交")
187
+ session = dict(connection.execute("SELECT * FROM discussion_sessions WHERE id=?", (row["session_id"],)).fetchone()) if row else None
188
+ return {"submission_id": submission_id, "request_json": request_json, "session": session}
189
+
190
+
191
+ def start_session(connection, room_id, token, payload, room):
192
+ """Start an in-room discussion session without changing the room's free-collaboration mode."""
193
+ require_owner(connection, room_id, token)
194
+ begin_write(connection)
195
+ current = session_room(connection, room_id)
196
+ submission = _start_submission(connection, room_id, payload)
197
+ if submission and submission["session"]:
198
+ original = submission["session"]
199
+ session = current["session"] if current["session"] and current["session"]["id"] == original["id"] else original
200
+ return {"session": {**session, "start_submission_id": submission["submission_id"]},
201
+ "revision": current["revision"], "duplicate": True}
202
+ if room["archived"]:
203
+ raise ValueError("房间已存档;恢复后才能开启讨论")
204
+ require_revision(current, payload, "开启讨论")
205
+ if current["session"]:
206
+ raise FileExistsError("房间已有进行中的讨论会话")
207
+ members = active_members(connection, room_id, registered_only=False)
208
+ host = next((member for member in members.values() if member["role"] == "host" and member["access"] == "runner"), None)
209
+ if not host:
210
+ raise ValueError("开启讨论需要一位由本机托管的 AI 主持人")
211
+ goal = str(payload.get("goal", room["goal"])).strip()
212
+ if not goal or len(goal) > 1000:
213
+ raise ValueError("讨论目标须为 1–1000 字")
214
+ limits = limit_values(payload.get("limits", {}))
215
+ named_followup = payload.get("named_followup", False)
216
+ if type(named_followup) is not bool:
217
+ raise ValueError("named_followup 须为布尔值")
218
+ latest = connection.execute("SELECT COALESCE(MAX(m.id),0) FROM messages m WHERE m.room_id=? AND NOT EXISTS (SELECT 1 FROM task_message_sources t WHERE t.message_id=m.id)", (room_id,)).fetchone()[0]
219
+ created_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
220
+ cursor = connection.execute("INSERT INTO discussion_sessions(room_id,goal,status,started_message_id,created_at) VALUES(?,?,'active',?,?)", (room_id, goal, latest, created_at))
221
+ session_id = cursor.lastrowid
222
+ if submission:
223
+ connection.execute("INSERT INTO session_start_submissions VALUES(?,?,?,?)",
224
+ (room_id, submission["submission_id"], session_id, submission["request_json"]))
225
+ connection.execute("INSERT INTO session_state(session_id,phase,revision,read_until) VALUES(?,'initial',0,?)", (session_id, latest))
226
+ connection.execute("INSERT INTO session_limits(session_id,max_rounds,max_minutes,execution_minutes,started_at) VALUES(?,?,?,?,?)",
227
+ (session_id, limits["max_rounds"], limits["max_minutes"], limits["execution_minutes"], int(time.time())))
228
+ connection.execute("INSERT INTO session_round_budgets(session_id) VALUES(?)", (session_id,))
229
+ connection.execute("INSERT INTO session_pauses(session_id) VALUES(?)", (session_id,))
230
+ connection.execute("INSERT INTO session_options(session_id,named_followup) VALUES(?,?)", (session_id, int(named_followup)))
231
+ connection.execute("UPDATE room_modes SET mode='free' WHERE room_id=?", (room_id,))
232
+ connection.execute("UPDATE rooms SET goal=? WHERE id=?", (goal, room_id))
233
+ create_host_request(connection, session_id, f"请主持讨论:{goal}。先确认目标与限制,再安排第一位专家发言。",
234
+ {"kind": "session_started", "key": "start"})
235
+ return {**session_room(connection, room_id), "duplicate": False}
236
+
237
+
238
+ def cancel_session_work(connection, session_id, reason):
239
+ """Cancel queued and open session plans together with their linked requests and executions."""
240
+ rows = connection.execute("SELECT sr.id,sr.member_request_id FROM session_requests sr WHERE sr.session_id=? AND sr.status IN ('queued','open')", (session_id,)).fetchall()
241
+ for row in rows:
242
+ if row["member_request_id"]:
243
+ request = connection.execute("SELECT execution_id,status FROM member_requests WHERE id=?", (row["member_request_id"],)).fetchone()
244
+ if request and request["status"] in ('pending','delivering'):
245
+ if request["execution_id"]:
246
+ finish_execution(connection, request["execution_id"], "cancelled", reason, "cancelled", "user_stop")
247
+ else:
248
+ connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (row["member_request_id"],))
249
+ connection.execute("UPDATE session_requests SET status='cancelled' WHERE id=?", (row["id"],))
250
+
251
+
252
+ def session_member_change(connection, room_id, member, action):
253
+ """Invalidate queued discussion work after a roster change and ask the host to re-plan."""
254
+ session = current_session(connection, room_id, active_only=True)
255
+ if not session:
256
+ return
257
+ member_rows = connection.execute("SELECT * FROM session_requests WHERE session_id=? AND member_id=? AND purpose='discuss' AND status IN ('open','queued','failed')",
258
+ (session["id"], member["id"])).fetchall() if action in ("away", "remove") else []
259
+ rows = connection.execute("SELECT * FROM session_requests WHERE session_id=? AND purpose='discuss' AND status='queued'",
260
+ (session["id"],)).fetchall()
261
+ for row in rows:
262
+ if row["member_request_id"]:
263
+ request = connection.execute("SELECT execution_id,status FROM member_requests WHERE id=?", (row["member_request_id"],)).fetchone()
264
+ if request and request["status"] == "pending":
265
+ connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (row["member_request_id"],))
266
+ connection.execute("UPDATE session_requests SET status='skipped' WHERE id=?", (row["id"],))
267
+ for row in member_rows:
268
+ if row["member_request_id"]:
269
+ request = connection.execute("SELECT execution_id,status FROM member_requests WHERE id=?", (row["member_request_id"],)).fetchone()
270
+ if request and request["status"] in ("pending", "delivering"):
271
+ if request["execution_id"]:
272
+ finish_execution(connection, request["execution_id"], "cancelled", "成员已离开", "cancelled", "member_away")
273
+ else:
274
+ connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (row["member_request_id"],))
275
+ connection.execute("UPDATE session_requests SET status='cancelled' WHERE id=? AND status='open'", (row["id"],))
276
+ connection.execute("UPDATE session_requests SET status='skipped' WHERE id=? AND status='queued'", (row["id"],))
277
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session["id"],))
278
+ state_revision = connection.execute("SELECT revision FROM session_state WHERE session_id=?", (session["id"],)).fetchone()[0]
279
+ if session["status"] == "active":
280
+ detail = ("暂离" if action == "away" else "移除" if action == "remove" else "请回")
281
+ create_host_request(connection, session["id"],
282
+ f"专家 {member['name']} 已{detail};剩余排队安排已作废,请检查当前发言并重新安排。",
283
+ {"kind": "member_change", "key": f"member-{member['id']}-{action}-{state_revision}"})
284
+
285
+
286
+ def pause_session_for_host_change(connection, room_id):
287
+ """Pause an active discussion and cancel its assignments before its host changes."""
288
+ session = current_session(connection, room_id, active_only=True)
289
+ if not session or session["status"] != "active":
290
+ return
291
+ cancel_session_work(connection, session["id"], "主持人已更换")
292
+ connection.execute("UPDATE discussion_sessions SET status='paused' WHERE id=?", (session["id"],))
293
+ connection.execute("UPDATE session_pauses SET paused_at=? WHERE session_id=?", (int(time.time()), session["id"]))
294
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session["id"],))
295
+
296
+
297
+ def end_session(connection, room_id, token, payload, reason="user_stop"):
298
+ """Conclude the active session, snapshot its state and leave the room available for free collaboration."""
299
+ require_owner(connection, room_id, token)
300
+ begin_write(connection)
301
+ current = session_room(connection, room_id)
302
+ require_revision(current, payload, "结束讨论")
303
+ session = current["session"]
304
+ if not session:
305
+ raise FileExistsError("房间没有进行中的讨论")
306
+ return _conclude_session(connection, session, reason)
307
+
308
+
309
+ def _conclude_session(connection, session, reason):
310
+ """Cancel session work, persist the conclusion snapshot and stop the session."""
311
+ room_id = session["room_id"]
312
+ session_id = session["id"]
313
+ cancel_session_work(connection, session_id, "讨论已结束")
314
+ now = int(time.time())
315
+ latest = connection.execute("SELECT COALESCE(MAX(m.id),0) FROM messages m WHERE m.room_id=? AND NOT EXISTS (SELECT 1 FROM task_message_sources t WHERE t.message_id=m.id)", (room_id,)).fetchone()[0]
316
+ connection.execute("UPDATE discussion_sessions SET status='concluded',ended_message_id=? WHERE id=?", (latest, session_id))
317
+ connection.execute("UPDATE session_limits SET stop_reason=?,revision=revision+1 WHERE session_id=?", (reason, session_id))
318
+ state = connection.execute("SELECT state_text,state_until FROM rooms WHERE id=?", (room_id,)).fetchone()
319
+ brief = connection.execute("SELECT text,until FROM room_briefs WHERE room_id=?", (room_id,)).fetchone()
320
+ started = session["started_message_id"]
321
+ limits = connection.execute("SELECT max_rounds,max_minutes FROM session_limits WHERE session_id=?", (session_id,)).fetchone()
322
+ connection.execute("INSERT OR REPLACE INTO discussion_conclusions(session_id,room_id,stop_reason,max_rounds,max_minutes,brief,state,state_until,concluded_at) VALUES(?,?,?,?,?,?,?,?,?)",
323
+ (session_id, room_id, reason, limits["max_rounds"], limits["max_minutes"],
324
+ brief["text"] if brief and brief["until"] > started else "", state["state_text"] if state["state_until"] > started else "",
325
+ state["state_until"] if state["state_until"] > started else 0,
326
+ time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(now))))
327
+ return session_room(connection, room_id)
328
+
329
+
330
+ def discussion_action(connection, room_id, token, payload, room):
331
+ """Start, pause, resume or end a session using the revision returned by GET /discussion."""
332
+ action = payload.get("action")
333
+ if action == "start":
334
+ return start_session(connection, room_id, token, payload, room)
335
+ require_owner(connection, room_id, token)
336
+ begin_write(connection)
337
+ current = session_room(connection, room_id)
338
+ require_revision(current, payload, action or "讨论控制")
339
+ session = current["session"]
340
+ if not session:
341
+ raise FileExistsError("房间没有进行中的讨论")
342
+ if action == "pause":
343
+ if session["status"] != "active":
344
+ raise FileExistsError("讨论已经暂停")
345
+ cancel_session_work(connection, session["id"], "用户暂停讨论")
346
+ connection.execute("UPDATE discussion_sessions SET status='paused' WHERE id=?", (session["id"],))
347
+ connection.execute("UPDATE session_pauses SET paused_at=? WHERE session_id=?", (int(time.time()), session["id"]))
348
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session["id"],))
349
+ elif action == "resume":
350
+ if session["status"] != "paused":
351
+ raise FileExistsError("讨论当前没有暂停")
352
+ pause = connection.execute("SELECT paused_at FROM session_pauses WHERE session_id=?", (session["id"],)).fetchone()[0]
353
+ connection.execute("UPDATE discussion_sessions SET status='active' WHERE id=?", (session["id"],))
354
+ connection.execute("UPDATE session_pauses SET paused_seconds=paused_seconds+MAX(0,?-paused_at),paused_at=0 WHERE session_id=?", (int(time.time()), session["id"]))
355
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session["id"],))
356
+ if pause:
357
+ create_host_request(connection, session["id"], "讨论已恢复,请检查队列并继续。",
358
+ {"kind": "member_change", "key": f"resume-{session['id']}-{session['revision']}"})
359
+ elif action == "end":
360
+ return end_session(connection, room_id, token, payload)
361
+ else:
362
+ raise ValueError("action 须为 start、pause、resume 或 end")
363
+ return session_room(connection, room_id)
364
+
365
+
366
+ def update_session_limits(connection, room_id, token, payload):
367
+ """Update active-session limits using the state revision returned by GET /discussion."""
368
+ require_owner(connection, room_id, token)
369
+ begin_write(connection)
370
+ current = session_room(connection, room_id)
371
+ require_revision(current, payload, "修改讨论限制")
372
+ session = current["session"]
373
+ if not session:
374
+ raise FileExistsError("房间没有进行中的讨论会话")
375
+ if session["status"] != "paused":
376
+ raise ValueError("请先暂停讨论,再修改上限参数")
377
+ values = {key: value for key, value in payload.items() if key not in ("revision", "action", "actor")}
378
+ if not values:
379
+ raise ValueError("至少提供一项讨论上限字段")
380
+ current_limits = {key: session["limits"][key] for key in ("max_rounds", "max_minutes", "execution_minutes")}
381
+ limits = limit_values(values, current_limits)
382
+ connection.execute("""UPDATE session_limits SET max_rounds=?,max_minutes=?,execution_minutes=?,revision=revision+1
383
+ WHERE session_id=?""", (limits["max_rounds"], limits["max_minutes"],
384
+ limits["execution_minutes"], session["id"]))
385
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session["id"],))
386
+ enforce_session_limits(connection, room_id)
387
+ return session_room(connection, room_id)
388
+
389
+
390
+ def session_conclusion_view(connection, room_id):
391
+ """Return conclusion blockers and a revision bound to the latest request-backed session state."""
392
+ session = current_session(connection, room_id)
393
+ if not session:
394
+ return None
395
+ held_since = connection.execute("SELECT held_since FROM session_state WHERE session_id=?", (session["id"],)).fetchone()[0]
396
+ state_until = connection.execute("SELECT state_until FROM rooms WHERE id=?", (room_id,)).fetchone()[0]
397
+ last_answer = connection.execute("""SELECT COALESCE(MAX(r.answer_id),0) FROM session_requests sr
398
+ JOIN member_requests r ON r.id=sr.member_request_id
399
+ WHERE sr.session_id=? AND sr.purpose='discuss' AND sr.status='answered'""", (session["id"],)).fetchone()[0]
400
+ active = [list(row) for row in connection.execute("""SELECT id,round,position,member_id,status FROM session_requests
401
+ WHERE session_id=? AND purpose='discuss' AND status='open' ORDER BY round,position,id""", (session["id"],))]
402
+ queued = [list(row) for row in connection.execute("""SELECT id,round,position,member_id,status FROM session_requests
403
+ WHERE session_id=? AND purpose='discuss' AND status='queued' ORDER BY round,position,id""", (session["id"],))]
404
+ latest = connection.execute("""SELECT COALESCE(MAX(id),0) FROM messages WHERE room_id=?
405
+ AND NOT EXISTS(SELECT 1 FROM task_message_sources WHERE message_id=messages.id)""", (room_id,)).fetchone()[0]
406
+ blockers = []
407
+ if held_since:
408
+ blockers.append("有未处理的用户留言或设置变更")
409
+ if state_until < last_answer:
410
+ blockers.append(f"状态整理至 #{state_until},未覆盖最新发言 #{last_answer};先更新 state 与简报")
411
+ if active:
412
+ blockers.append("仍有专家正在发言")
413
+ if queued:
414
+ blockers.append("仍有排队的发言安排")
415
+ revision = _hash_revision([_session_revision(connection, session), latest, state_until, last_answer,
416
+ held_since, active, queued])
417
+ return {"latest_id": latest, "last_opinion_id": last_answer, "state_until": state_until,
418
+ "held_since": held_since, "queued": len(queued), "active": len(active),
419
+ "blockers": blockers, "ready": not blockers, "revision": revision}
420
+
421
+
422
+ def conclude_session_by_host(connection, room_id, payload):
423
+ """Let the host finish a ready discussion after reading its conclusion revision."""
424
+ begin_write(connection)
425
+ session = current_session(connection, room_id, active_only=True)
426
+ if not session or session["status"] != "active":
427
+ raise FileExistsError("只有进行中的讨论可以由主持人收束")
428
+ view = session_conclusion_view(connection, room_id)
429
+ if payload.get("conclusion") is None:
430
+ raise ValueError("收束前须先读取收束状态(room conclusion),并带上其 revision")
431
+ if str(payload["conclusion"]) != view["revision"]:
432
+ raise FileExistsError("讨论状态已变化,请重新读取 room conclusion 后再收束")
433
+ blockers = [item for item in view["blockers"] if item != "仍有排队的发言安排"]
434
+ if blockers:
435
+ raise ValueError(f"暂不能收束:{';'.join(blockers)}")
436
+ return _conclude_session(connection, session, "goal_done")
437
+
438
+
439
+ def _session_roster(connection, session_id):
440
+ """Build active experts and their answered state for this session's current round."""
441
+ session = connection.execute("SELECT room_id,status FROM discussion_sessions WHERE id=?", (session_id,)).fetchone()
442
+ session_state = connection.execute("SELECT phase,revision,read_until,held_since FROM session_state WHERE session_id=?", (session_id,)).fetchone()
443
+ max_round = connection.execute("""SELECT MIN(round) FROM session_requests
444
+ WHERE session_id=? AND purpose='discuss' AND status IN ('queued','open')""", (session_id,)).fetchone()[0]
445
+ if max_round is None:
446
+ max_round = connection.execute("SELECT COALESCE(MAX(round),1) FROM session_requests WHERE session_id=? AND purpose='discuss'", (session_id,)).fetchone()[0]
447
+ answered = {row[0] for row in connection.execute("SELECT member_id FROM session_requests WHERE session_id=? AND purpose='discuss' AND round=? AND status='answered'", (session_id, max_round))}
448
+ members = [dict(row) for row in connection.execute("""SELECT m.id,m.name,m.role,m.access,m.status,m.token_hash,
449
+ COALESCE(r.token_hash,'') AS registration_hash,COALESCE(source.source,'') AS manual_source
450
+ FROM room_members m LEFT JOIN member_registrations r ON r.member_id=m.id
451
+ LEFT JOIN member_manual_sources source ON source.member_id=m.id
452
+ WHERE m.room_id=? AND m.status='active' ORDER BY m.id""", (session["room_id"],))]
453
+ experts = []
454
+ for member in members:
455
+ registered = (member["access"] != "manual" or member["manual_source"] == "web"
456
+ or member["registration_hash"] == member["token_hash"])
457
+ experts.append({"id": member["id"],"name":member["name"],"host":member["role"] == "host", "mode":member["access"],
458
+ "manual_source":member["manual_source"], "spoken":member["id"] in answered, "registered":registered})
459
+ experts.sort(key=lambda item: (item["host"], next(member["id"] for member in members if member["name"]==item["name"])))
460
+ waiting = [item["name"] for item in experts if not item["host"] and not item["spoken"] and item["registered"]]
461
+ unregistered = [item["name"] for item in experts if not item["registered"]]
462
+ queue = [list(row) for row in connection.execute("""SELECT id,round,position,member_id,status,submission_id
463
+ FROM session_requests WHERE session_id=? AND purpose='discuss' ORDER BY id""", (session_id,))]
464
+ limits = list(connection.execute("SELECT max_rounds,max_minutes,execution_minutes FROM session_limits WHERE session_id=?", (session_id,)).fetchone())
465
+ latest_visible = connection.execute("""SELECT COALESCE(MAX(m.id),0) FROM messages m WHERE m.room_id=?
466
+ AND NOT EXISTS (SELECT 1 FROM task_message_sources t WHERE t.message_id=m.id)""", (session["room_id"],)).fetchone()[0]
467
+ state = [session_id, session["status"], list(session_state), latest_visible, max_round,
468
+ [[item['id'], item['name'], item['host'], item['spoken'], item['registered']] for item in experts], queue, limits]
469
+ return {"experts":experts,"waiting":waiting,"unregistered":unregistered,"round":max_round,
470
+ "revision":_hash_revision(state)}
471
+
472
+
473
+ def roster_view(connection, room_id):
474
+ """Expose the current session roster and revision required by a multi-speaker plan."""
475
+ session = current_session(connection, room_id)
476
+ if not session:
477
+ raise FileExistsError("房间没有进行中的讨论会话")
478
+ return {**_session_roster(connection, session["id"]),"session_id":session["id"]}
479
+
480
+
481
+ def query_session_requests(connection, room_id, params=None):
482
+ """Read request plans for the current session with fields compatible with the legacy turns view."""
483
+ session = current_session(connection, room_id)
484
+ if not session:
485
+ return {"turns":[],"page":1,"pages":1,"total":0}
486
+ params = params or {}
487
+ page = max(1,int(params.get("page",1)))
488
+ where = "session_id=? AND purpose='discuss'"
489
+ values = [session["id"]]
490
+ if "submission_id" in params:
491
+ where += " AND submission_id=?"
492
+ values.append(str(params["submission_id"]))
493
+ total = connection.execute(f"SELECT COUNT(*) FROM session_requests WHERE {where}",values).fetchone()[0]
494
+ rows = connection.execute(f"SELECT * FROM session_requests WHERE {where} ORDER BY round,position,id LIMIT 20 OFFSET ?",[*values,(page-1)*20]).fetchall()
495
+ members = {row["id"]:row["name"] for row in connection.execute("SELECT id,name FROM room_members WHERE room_id=?",(room_id,))}
496
+ turns = []
497
+ for row in rows:
498
+ item = dict(row)
499
+ item.update(expert=members.get(item["member_id"],""),status_label=item["status"])
500
+ turns.append(item)
501
+ return {"turns":turns,"page":page,"pages":max(1,(total+19)//20),"total":total}
502
+
503
+
504
+ def get_session_request(connection, room_id, plan_id):
505
+ """Read one session plan by its durable identifier, including its member name."""
506
+ row = connection.execute("""SELECT sr.*,m.name AS expert,s.room_id FROM session_requests sr
507
+ JOIN discussion_sessions s ON s.id=sr.session_id JOIN room_members m ON m.id=sr.member_id
508
+ WHERE s.room_id=? AND sr.id=? AND sr.purpose='discuss'""", (room_id, int(plan_id))).fetchone()
509
+ if not row:
510
+ raise LookupError("讨论安排不存在")
511
+ return dict(row)
512
+
513
+
514
+ def create_plan(connection, room_id, payload, room):
515
+ """Store one speaker or an ordered round, opening only its first deliverable request."""
516
+ begin_write(connection)
517
+ session = current_session(connection, room_id, active_only=True)
518
+ if not session:
519
+ raise FileExistsError("房间没有进行中的讨论会话")
520
+ if room["archived"] or session["status"] != "active":
521
+ raise ValueError("讨论已暂停或房间已存档")
522
+ actor = payload.get("actor")
523
+ host = connection.execute("SELECT id FROM room_members WHERE room_id=? AND name=? AND role='host' AND status='active'",(room_id,actor)).fetchone()
524
+ if not host:
525
+ raise ValueError("请使用当前 AI 主持人身份安排发言")
526
+ if payload.get("roster") is None:
527
+ raise ValueError("安排发言前须先获取 turn roster 并带上 revision")
528
+ base_id, plan = _validated_plan(payload)
529
+ existing = _existing_plan(connection, session["id"], base_id)
530
+ if existing:
531
+ return _check_duplicate_plan(connection, existing, plan)
532
+ roster = _session_roster(connection, session["id"])
533
+ if payload["roster"] != roster["revision"]:
534
+ raise FileExistsError("专家状态已变化,请重新获取 turn roster 后再安排")
535
+ _validate_plan_members(connection, room_id, plan)
536
+ entries = _number_plan_entries(connection, session["id"], plan, roster)
537
+ if len(plan) > 1:
538
+ first_round_names = {item[1] for item in entries if item[3] == roster["round"]}
539
+ missing = [name for name in roster["waiting"] if name not in first_round_names]
540
+ if missing:
541
+ raise ValueError(f"整轮安排缺少本轮尚未发言的专家:{'、'.join(missing)}")
542
+ read_until = _discussion_read_cutoff(connection, session["id"])
543
+ inserted = _insert_plan_rows(connection, session["id"], entries, read_until)
544
+ # Planning is the host's completed response; close its current host request in this transaction.
545
+ _complete_host_work(connection,session['id'],host['id'],"主持人已提交发言安排")
546
+ advance_session(connection,session['id'])
547
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session['id'],))
548
+ return {"turn":dict(connection.execute("SELECT * FROM session_requests WHERE id=?",(inserted[0],)).fetchone()),
549
+ "queued":[dict(connection.execute("SELECT * FROM session_requests WHERE id=?",(item,)).fetchone()) for item in inserted[1:]],"duplicate":False}
550
+
551
+
552
+ def _validated_plan(payload):
553
+ """Validate the host's one-speaker or ordered multi-speaker plan payload."""
554
+ items = payload.get("turns")
555
+ if items is None:
556
+ items = [{"expert": payload.get("expert", ""), "question": payload.get("question", "")}]
557
+ if not isinstance(items, list) or not 1 <= len(items) <= MAX_PLAN_TURNS:
558
+ raise ValueError(f"整轮安排需要 1–{MAX_PLAN_TURNS} 项")
559
+ base_id = str(payload.get("submission_id", "")).strip()
560
+ if not 8 <= len(base_id) <= 100:
561
+ raise ValueError("submission_id 须为 8–100 字符")
562
+ plan = []
563
+ for index, item in enumerate(items):
564
+ if not isinstance(item, dict):
565
+ raise ValueError("每项安排需要 expert 和 question")
566
+ name = str(item.get("expert", "")).strip()
567
+ question = str(item.get("question", "")).strip()
568
+ if not name or not question or len(question) > MAX_QUESTION_LENGTH:
569
+ raise ValueError("请选择专家并提供不超过 1000 字的问题")
570
+ submission_id = base_id if index == 0 else f"{base_id}-q{index + 1}"
571
+ plan.append((name, question, submission_id))
572
+ return base_id, plan
573
+
574
+
575
+ def _validate_plan_members(connection, room_id, plan):
576
+ """Require each scheduled participant to be active and any manual member registered."""
577
+ for name, _, _ in plan:
578
+ member = connection.execute("""SELECT m.*,COALESCE(source.source,'') AS manual_source FROM room_members m
579
+ LEFT JOIN member_manual_sources source ON source.member_id=m.id
580
+ WHERE m.room_id=? AND m.name=? AND m.status='active'""",
581
+ (room_id, name)).fetchone()
582
+ if not member:
583
+ raise ValueError(f"安排对象 {name} 不是在场专家")
584
+ if member["access"] == "manual" and member["manual_source"] != "web" and not connection.execute(
585
+ "SELECT 1 FROM member_registrations WHERE member_id=? AND token_hash=?",
586
+ (member["id"], member["token_hash"])).fetchone():
587
+ raise ValueError(f"手动专家 {name} 尚未注册")
588
+
589
+
590
+ def _discussion_read_cutoff(connection, session_id):
591
+ """Freeze the current boundary for independent opinions; NULL allows later discussion reads."""
592
+ state = connection.execute("SELECT phase,read_until FROM session_state WHERE session_id=?", (session_id,)).fetchone()
593
+ return state["read_until"] if state["phase"] == "initial" else None
594
+
595
+
596
+ def _number_plan_entries(connection, session_id, plan, roster):
597
+ """Split a plan into rounds when a member repeats in the current queue."""
598
+ round_number = roster["round"]
599
+ answered = {item["id"] for item in roster["experts"] if item["spoken"]}
600
+ if not connection.execute("SELECT 1 FROM session_requests WHERE session_id=? AND purpose='discuss'", (session_id,)).fetchone():
601
+ round_number = 1
602
+ answered = set()
603
+ positions = {row[0]: row[1] for row in connection.execute("""SELECT round,MAX(position)
604
+ FROM session_requests WHERE session_id=? AND purpose='discuss' GROUP BY round""", (session_id,))}
605
+ members = {row["name"]: row["id"] for row in connection.execute("""SELECT id,name FROM room_members
606
+ WHERE room_id=(SELECT room_id FROM discussion_sessions WHERE id=?)""", (session_id,))}
607
+ entries = []
608
+ for name, question, submission_id in plan:
609
+ member_id = members[name]
610
+ if member_id in answered:
611
+ round_number += 1
612
+ answered = set()
613
+ positions[round_number] = positions.get(round_number, 0) + 1
614
+ entries.append((member_id, name, question, round_number, positions[round_number], submission_id))
615
+ answered.add(member_id)
616
+ return entries
617
+
618
+
619
+ def _insert_plan_rows(connection, session_id, entries, read_until):
620
+ """Persist all plan entries atomically in queue order."""
621
+ inserted = []
622
+ for member_id, _, question, round_number, position, submission_id in entries:
623
+ entry_cutoff = read_until if round_number == 1 else None
624
+ cursor = connection.execute("""INSERT INTO session_requests
625
+ (session_id,round,position,member_id,purpose,question,status,submission_id,read_until,created_at)
626
+ VALUES(?,?,?,?,'discuss',?,'queued',?,?,?)""",
627
+ (session_id, round_number, position, member_id, question, submission_id, entry_cutoff,
628
+ time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())))
629
+ inserted.append(cursor.lastrowid)
630
+ return inserted
631
+
632
+
633
+ def _existing_plan(connection, session_id, base_id):
634
+ """Find all stored entries for one base submission, including queued suffixes."""
635
+ pattern = f"{base_id}-q[0-9]*"
636
+ return [dict(row) for row in connection.execute("""SELECT * FROM session_requests
637
+ WHERE session_id=? AND (submission_id=? OR submission_id GLOB ?)
638
+ ORDER BY id""", (session_id, base_id, pattern))]
639
+
640
+
641
+ def _check_duplicate_plan(connection, existing, plan):
642
+ """Return an exact replay and reject any reuse of the base id with changed entries."""
643
+ expected_ids = [item[2] for item in plan]
644
+ actual_ids = [item["submission_id"] for item in existing]
645
+ room_id = connection.execute("SELECT room_id FROM discussion_sessions WHERE id=?", (existing[0]["session_id"],)).fetchone()[0]
646
+ members = {row["name"]: row["id"] for row in connection.execute("SELECT id,name FROM room_members WHERE room_id=?", (room_id,))}
647
+ exact = actual_ids == expected_ids
648
+ for row, (name, question, _) in zip(existing, plan):
649
+ exact = exact and row["member_id"] == members.get(name)
650
+ exact = exact and row["question"] == question
651
+ if not exact:
652
+ raise FileExistsError("这个 submission_id 已用于不同的安排内容;请核对原提交后再使用新编号")
653
+ return {"turn": existing[0], "queued": existing[1:], "duplicate": True}
654
+
655
+
656
+ def _complete_host_work(connection, session_id, host_id, result):
657
+ """Treat host planning as completion of the host's assigned request and execution."""
658
+ rows = connection.execute("""SELECT DISTINCT r.id AS request_id,r.execution_id,r.status AS request_status,e.status AS execution_status
659
+ FROM session_requests sr JOIN member_requests r ON r.id=sr.member_request_id
660
+ LEFT JOIN member_executions e ON e.id=r.execution_id WHERE sr.session_id=? AND sr.purpose='discuss_host' AND sr.member_id=?
661
+ AND sr.status='open' AND r.status IN ('pending','delivering')""", (session_id, host_id)).fetchall()
662
+ executions = {row["execution_id"] for row in rows
663
+ if row["request_status"] == "delivering" and row["execution_status"] in ("dispatched", "started")}
664
+ selected = ([row for row in rows if row["execution_id"] in executions]
665
+ if executions else [row for row in rows if row["request_status"] == "pending"])
666
+ request_ids = [row["request_id"] for row in selected]
667
+ for execution_id in executions:
668
+ finish_execution(connection, execution_id, "completed", result, "completed")
669
+ if request_ids:
670
+ placeholders = ",".join("?" for _ in request_ids)
671
+ connection.execute(f"UPDATE member_requests SET status='completed' WHERE id IN ({placeholders}) AND status='pending'",
672
+ request_ids)
673
+ connection.execute(f"UPDATE session_requests SET status='answered' WHERE member_request_id IN ({placeholders})",
674
+ request_ids)
675
+
676
+
677
+ def complete_session_requests(connection, room_id, payload, actor, message_id):
678
+ """Mark session requests covered by one free-room answer and continue the discussion plan."""
679
+ if actor == "用户" or actor is None:
680
+ return
681
+ request_ids = payload.get("request_ids", [])
682
+ if type(payload.get("execution_id")) is int:
683
+ rows = connection.execute("SELECT id FROM member_requests WHERE execution_id=?", (payload["execution_id"],)).fetchall()
684
+ request_ids = [row["id"] for row in rows]
685
+ if not request_ids:
686
+ return
687
+ placeholders = ",".join("?" for _ in request_ids)
688
+ rows = connection.execute(f"""SELECT sr.id,sr.session_id,sr.purpose,sr.member_id,sr.member_request_id,m.name
689
+ FROM member_requests r JOIN session_requests sr ON sr.member_request_id=r.id
690
+ JOIN room_members m ON m.id=sr.member_id WHERE r.id IN ({placeholders}) AND sr.status='open'""",
691
+ request_ids).fetchall()
692
+ for row in rows:
693
+ if row["purpose"] == "discuss":
694
+ connection.execute("UPDATE session_requests SET status='answered' WHERE id=?", (row["id"],))
695
+ _advance_after_answer(connection, dict(row), message_id)
696
+ else:
697
+ connection.execute("UPDATE session_requests SET status='answered' WHERE id=?", (row["id"],))
698
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (row["session_id"],))
699
+
700
+
701
+ def _advance_after_answer(connection, request, answer_id):
702
+ """Promote the next queued speaker or ask the host to choose what comes next."""
703
+ session_id = request["session_id"]
704
+ session_row = connection.execute("SELECT * FROM discussion_sessions WHERE id=?", (session_id,)).fetchone()
705
+ roster = _session_roster(connection, session_id)
706
+ _advance_initial_phase(connection, session_id)
707
+ if enforce_session_limits(connection, session_row["room_id"]):
708
+ return
709
+ if advance_session(connection, session_id):
710
+ return
711
+ if connection.execute("SELECT 1 FROM session_requests WHERE session_id=? AND purpose='discuss' AND status='queued' LIMIT 1",
712
+ (session_id,)).fetchone():
713
+ return
714
+ cause_kind = "round_complete" if not roster["waiting"] else "speaker_answered"
715
+ question = (f"专家 {request['name']} 已回答 #{answer_id},请继续安排本轮尚未发言的专家。"
716
+ if roster["waiting"] else f"第 {roster['round']} 轮已完成,请判断是否开始下一轮或收束讨论。")
717
+ create_host_request(connection, session_id, question,
718
+ {"kind": cause_kind, "message_id": answer_id, "request_id": request["member_request_id"],
719
+ "key": f"answer-{request['member_request_id']}"})
720
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (session_id,))
721
+
722
+
723
+ def _advance_initial_phase(connection, session_id):
724
+ """Switch out of independent opinions after all scheduled first-round experts answer."""
725
+ state = connection.execute("SELECT phase FROM session_state WHERE session_id=?", (session_id,)).fetchone()
726
+ if not state or state["phase"] != "initial":
727
+ return
728
+ denominator = _expert_denominator(connection, session_id, 1)
729
+ answered = connection.execute("SELECT COUNT(*) FROM session_requests WHERE session_id=? AND purpose='discuss' AND round=1 AND status='answered'", (session_id,)).fetchone()[0]
730
+ if denominator and answered >= denominator:
731
+ connection.execute("UPDATE session_state SET phase='discussing',revision=revision+1 WHERE session_id=?", (session_id,))
732
+
733
+
734
+ def _expert_denominator(connection, session_id, round_number=None):
735
+ """Count registered active experts, plus the host only if that round explicitly schedules them."""
736
+ room_id = connection.execute("SELECT room_id FROM discussion_sessions WHERE id=?", (session_id,)).fetchone()[0]
737
+ count = connection.execute("""SELECT COUNT(*) FROM room_members m LEFT JOIN member_registrations r ON r.member_id=m.id
738
+ LEFT JOIN member_manual_sources source ON source.member_id=m.id
739
+ WHERE m.room_id=? AND m.status='active' AND m.role<>'host'
740
+ AND (m.access<>'manual' OR source.source='web' OR r.token_hash=m.token_hash)""", (room_id,)).fetchone()[0]
741
+ host_sql = "SELECT 1 FROM session_requests WHERE session_id=? AND purpose='discuss' AND member_id IN (SELECT id FROM room_members WHERE room_id=? AND role='host')"
742
+ values = [session_id, room_id]
743
+ if round_number is not None:
744
+ host_sql += " AND round=?"
745
+ values.append(round_number)
746
+ if connection.execute(host_sql, values).fetchone():
747
+ count += 1
748
+ return count
749
+
750
+
751
+ def _at_round_limit(connection, session_id):
752
+ """Check answered-opinion rounds and active-time limits without waiting for full roster coverage."""
753
+ limits = connection.execute("SELECT max_rounds,max_minutes,started_at FROM session_limits WHERE session_id=?", (session_id,)).fetchone()
754
+ pause = connection.execute("SELECT paused_seconds FROM session_pauses WHERE session_id=?", (session_id,)).fetchone()[0]
755
+ denominator = _expert_denominator(connection, session_id)
756
+ answered = connection.execute("SELECT COUNT(*) FROM session_requests WHERE session_id=? AND purpose='discuss' AND status='answered'", (session_id,)).fetchone()[0]
757
+ rounds_done = denominator and limits["max_rounds"] > 0 and answered // denominator >= limits["max_rounds"]
758
+ elapsed = max(0, int(time.time()) - limits["started_at"] - pause)
759
+ time_done = limits["max_minutes"] > 0 and elapsed >= limits["max_minutes"] * 60
760
+ return rounds_done or time_done
761
+
762
+
763
+ def fail_session_request(connection, request_id, reason):
764
+ """Fail one discussion speaker request and hand its recovery decision to the host."""
765
+ row = connection.execute("""SELECT sr.id,sr.session_id,sr.member_id,m.name,s.room_id
766
+ FROM session_requests sr JOIN discussion_sessions s ON s.id=sr.session_id
767
+ JOIN room_members m ON m.id=sr.member_id WHERE sr.member_request_id=? AND sr.purpose='discuss'""",
768
+ (request_id,)).fetchone()
769
+ if not row:
770
+ return
771
+ connection.execute("UPDATE session_requests SET status='failed' WHERE id=? AND status='open'", (row["id"],))
772
+ create_host_request(connection, row["session_id"],
773
+ f"专家 {row['name']} 的讨论请求失败:{reason}。请决定跳过、重排或暂停。",
774
+ {"kind": "request_failed", "request_id": request_id, "key": f"failed-{request_id}"})
775
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?", (row["session_id"],))
776
+
777
+
778
+ def session_message_access(connection, room_id, params, token=""):
779
+ """Resolve a member's read boundary while validating any request or execution binding."""
780
+ execution_id = _optional_identifier(params, "execution_id")
781
+ request_id = _optional_identifier(params, "request_id")
782
+ if execution_id and request_id:
783
+ raise ValueError("execution_id 与 request_id 不能同时使用")
784
+ member = None
785
+ if execution_id or request_id or token:
786
+ try:
787
+ member = require_member(connection, room_id, token) if token else None
788
+ except PermissionError:
789
+ if execution_id or request_id:
790
+ raise
791
+ if (execution_id or request_id) and not member:
792
+ raise PermissionError("读取执行上下文须使用该成员的凭证")
793
+ rows = []
794
+ if execution_id:
795
+ execution = connection.execute("SELECT member_id,status,lease_until FROM member_executions WHERE room_id=? AND id=?",
796
+ (room_id, execution_id)).fetchone()
797
+ if not execution or execution["member_id"] != member["id"]:
798
+ raise PermissionError("执行编号不属于该成员")
799
+ if execution["status"] not in ("dispatched", "started") or execution["lease_until"] <= int(time.time()):
800
+ raise FileExistsError("执行已结束或过期,不能继续读取其上下文")
801
+ rows = connection.execute("""SELECT sr.* FROM member_requests r JOIN session_requests sr
802
+ ON sr.member_request_id=r.id WHERE r.execution_id=?""", (execution_id,)).fetchall()
803
+ _require_live_session_rows(connection, rows, execution["status"], "delivering")
804
+ elif request_id:
805
+ request = connection.execute("SELECT * FROM member_requests WHERE room_id=? AND id=?", (room_id, request_id)).fetchone()
806
+ if not request or request["member_id"] != member["id"]:
807
+ raise PermissionError("请求编号不属于该成员")
808
+ if request["status"] not in ("pending", "delivering"):
809
+ raise FileExistsError("请求已结束,不能继续读取其上下文")
810
+ if request["status"] == "delivering":
811
+ execution = connection.execute("SELECT status,lease_until FROM member_executions WHERE id=? AND member_id=?",
812
+ (request["execution_id"], member["id"])).fetchone() if request["execution_id"] else None
813
+ if not execution or execution["status"] not in ("dispatched", "started") or execution["lease_until"] <= int(time.time()):
814
+ raise FileExistsError("请求对应的执行已结束或过期,不能继续读取其上下文")
815
+ rows = connection.execute("SELECT * FROM session_requests WHERE member_request_id=?", (request_id,)).fetchall()
816
+ _require_live_session_rows(connection, rows, "", request["status"])
817
+ cutoffs = [row["read_until"] for row in rows
818
+ if row["purpose"] == "discuss" and row["read_until"] is not None]
819
+ cutoff = min(cutoffs) if cutoffs else None
820
+ if not rows and member and not execution_id and not request_id:
821
+ current = connection.execute("""SELECT sr.read_until FROM member_requests r
822
+ JOIN session_requests sr ON sr.member_request_id=r.id
823
+ JOIN discussion_sessions s ON s.id=sr.session_id
824
+ WHERE s.room_id=? AND s.status='active' AND sr.status='open' AND sr.purpose='discuss'
825
+ AND r.member_id=? AND r.status IN ('pending','delivering') ORDER BY sr.id LIMIT 1""",
826
+ (room_id, member["id"])).fetchone()
827
+ if current:
828
+ cutoff = current["read_until"]
829
+ if not execution_id and not request_id:
830
+ session = current_session(connection, room_id, active_only=True)
831
+ if session and connection.execute("SELECT phase FROM session_state WHERE session_id=?", (session["id"],)).fetchone()[0] == "initial":
832
+ owner_hash = connection.execute("SELECT control_hash FROM room_modes WHERE room_id=?", (room_id,)).fetchone()
833
+ is_owner = bool(token and owner_hash and token_hash(token) == owner_hash[0])
834
+ is_host = bool(member and member["role"] == "host")
835
+ if not is_owner and not is_host and cutoff is None:
836
+ cutoff = connection.execute("SELECT read_until FROM session_state WHERE session_id=?", (session["id"],)).fetchone()[0]
837
+ return cutoff
838
+
839
+
840
+ def _require_live_session_rows(connection, rows, execution_status, request_status):
841
+ """Permit session context only while its request and session are still open."""
842
+ if not rows:
843
+ return
844
+ if execution_status and execution_status not in ("dispatched", "started"):
845
+ raise FileExistsError("讨论执行已结束,不能继续读取其上下文")
846
+ if request_status not in ("pending", "delivering"):
847
+ raise FileExistsError("讨论请求已失效,不能继续读取其上下文")
848
+ for row in rows:
849
+ session = connection.execute("SELECT status FROM discussion_sessions WHERE id=?", (row["session_id"],)).fetchone()
850
+ if not session or session["status"] != "active" or row["status"] != "open":
851
+ raise FileExistsError("讨论请求已暂停、结束或取消,不能继续读取其上下文")
852
+
853
+
854
+ def _optional_identifier(params, field):
855
+ """Parse an optional positive identifier from request query parameters."""
856
+ value = params.get(field)
857
+ if value is None or value == "":
858
+ return None
859
+ try:
860
+ identifier = int(value)
861
+ except (TypeError, ValueError) as error:
862
+ raise ValueError(f"{field} 须为正整数") from error
863
+ if identifier <= 0:
864
+ raise ValueError(f"{field} 须为正整数")
865
+ return identifier
866
+
867
+
868
+ def continue_plan(connection, room_id, payload, room):
869
+ """Resume the next queued speaker after the host has reviewed the current queue."""
870
+ begin_write(connection)
871
+ session=current_session(connection,room_id,active_only=True)
872
+ if not session:
873
+ raise FileExistsError("房间没有进行中的讨论会话")
874
+ roster=_session_roster(connection,session['id'])
875
+ if payload.get("revision") is None:
876
+ raise ValueError("继续安排前须读取最新 turn roster 并带上 revision")
877
+ if payload['revision']!=roster['revision']:
878
+ raise FileExistsError("讨论队列已变化,请重新读取 turn roster")
879
+ host=connection.execute("SELECT id FROM room_members WHERE room_id=? AND name=? AND role='host' AND status='active'",(room_id,payload.get('actor'))).fetchone()
880
+ if not host:
881
+ raise ValueError("请使用当前 AI 主持人身份继续")
882
+ _complete_host_work(connection,session['id'],host['id'],"主持人已继续发言队列")
883
+ return advance_session(connection,session['id'])
884
+
885
+
886
+ def cancel_plan(connection, room_id, plan_id, payload):
887
+ """Cancel one known session plan and its linked member request/execution."""
888
+ begin_write(connection)
889
+ row=connection.execute("SELECT sr.* FROM session_requests sr JOIN discussion_sessions s ON s.id=sr.session_id WHERE s.room_id=? AND sr.id=?",(room_id,int(plan_id))).fetchone()
890
+ if not row:
891
+ raise LookupError("讨论安排不存在")
892
+ if row['status'] not in ('queued','open'):
893
+ raise FileExistsError("该讨论安排已结束,不能重复取消")
894
+ if row['member_request_id']:
895
+ request=connection.execute("SELECT execution_id,status FROM member_requests WHERE id=?",(row['member_request_id'],)).fetchone()
896
+ if request and request['status'] in ('pending','delivering'):
897
+ if request['execution_id']:
898
+ finish_execution(connection,request['execution_id'],'cancelled','用户取消讨论安排','cancelled','user_stop')
899
+ else:
900
+ connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?",(row['member_request_id'],))
901
+ connection.execute("UPDATE session_requests SET status='cancelled' WHERE id=?",(plan_id,))
902
+ session_id=row['session_id']
903
+ create_host_request(connection, session_id, f"主持人:发言安排 #{plan_id} 已取消,请决定是否重排。",
904
+ {"kind": "member_change", "request_id": row["member_request_id"], "key": f"cancel-{plan_id}"})
905
+ connection.execute("UPDATE session_state SET revision=revision+1 WHERE session_id=?",(session_id,))
906
+ return dict(connection.execute("SELECT * FROM session_requests WHERE id=?",(plan_id,)).fetchone())
907
+
908
+
909
+ def update_session_state(connection, session_id, phase=None, held_since=None):
910
+ """Persist session phase or held message boundary and advance its revision."""
911
+ fields=[]; values=[]
912
+ if phase is not None:
913
+ if phase not in ('initial','discussing'):
914
+ raise ValueError("会话阶段须为 initial 或 discussing")
915
+ fields.append("phase=?"); values.append(phase)
916
+ if held_since is not None:
917
+ fields.append("held_since=?"); values.append(held_since)
918
+ fields.append("revision=revision+1"); values.append(session_id)
919
+ connection.execute(f"UPDATE session_state SET {','.join(fields)} WHERE session_id=?",values)