ai_co_discuss 0.2.71 → 0.2.73

package/backend/remote_launch.py

@@ -0,0 +1,175 @@
+"""Room launches relayed through the website to a paired computer running the local service.
+
+A device without the local service (a phone, a tablet) submits the same launch request the
+connected browser would send to the local bridge; the paired computer claims it on its next
+sync, resolves the chosen project to its own directory and runs it. The Worker backend
+implements the same contract in ``worker.mjs``; both operate on ``local_machines`` and
+``remote_launches``.
+"""
+
+import hashlib
+import hmac
+import json
+import re
+
+from .admin import AdminError
+from .runtime import begin_write
+
+MACHINE_ONLINE_SECONDS = 30
+MACHINE_NAME_MAX = 60
+PROJECT_NAME_MAX = 80
+PROJECTS_MAX = 100
+CLIENTS_MAX = 40
+CLIENT_FIELD_MAX = 40
+ERROR_MAX = 2000
+MACHINE_ID = re.compile(r"[0-9a-f]{32}")
+MACHINE_TOKEN = re.compile(r"[0-9a-f]{64}")
+LAUNCH_ID = re.compile(r"[A-Za-z0-9_-]{1,80}")
+PROJECT_ID = re.compile(r"[0-9a-f]{8,32}")
+LAUNCH_STAGES = ("not_started", "unconfirmed", "created", "started")
+
+
+def token_digest(token):
+    """Hash a machine token; malformed values hash to an empty string and never match."""
+    return hashlib.sha256(token.encode()).hexdigest() if isinstance(token, str) and MACHINE_TOKEN.fullmatch(token) else ""
+
+
+def machine_view(row, now):
+    """Public machine fields: projects by name and id, and which platforms it can wake."""
+    return {"id": row["id"], "name": row["name"], "projects": json.loads(row["projects"]), "clients": json.loads(row["clients"]),
+            "seen_at": row["seen_at"], "online": now - row["seen_at"] <= MACHINE_ONLINE_SECONDS}
+
+
+def launch_view(row):
+    """Report a relayed launch without its request, which carries the room's credentials."""
+    return {"id": row["id"], "machine_id": row["machine_id"], "status": row["status"],
+            "result": json.loads(row["result"]), "error": row["error"]}
+
+
+def list_machines(connection, now):
+    """Paired computers, most recently seen first."""
+    rows = connection.execute("SELECT * FROM local_machines ORDER BY seen_at DESC, created_at DESC").fetchall()
+    return {"machines": [machine_view(row, now) for row in rows]}
+
+
+def pair_machine(connection, payload, now):
+    """Pair a computer or replace its token; called by the administrator's browser connected to that computer."""
+    machine_id, token = payload.get("id"), payload.get("token")
+    name = payload.get("name").strip() if isinstance(payload.get("name"), str) else ""
+    if not isinstance(machine_id, str) or not MACHINE_ID.fullmatch(machine_id) or not token_digest(token):
+        raise ValueError("电脑编号或凭据无效")
+    if not 1 <= len(name) <= MACHINE_NAME_MAX:
+        raise ValueError(f"电脑名称需为 1–{MACHINE_NAME_MAX} 个字符")
+    begin_write(connection)
+    connection.execute("INSERT INTO local_machines (id,name,token_hash,created_at) VALUES (?,?,?,?) "
+                       "ON CONFLICT(id) DO UPDATE SET name=excluded.name, token_hash=excluded.token_hash",
+                       (machine_id, name, token_digest(token), now))
+    return machine_view(connection.execute("SELECT * FROM local_machines WHERE id=?", (machine_id,)).fetchone(), now)
+
+
+def require_machine(connection, machine_id, token):
+    """Authenticate the computer itself by its own token."""
+    row = connection.execute("SELECT * FROM local_machines WHERE id=?", (machine_id,)).fetchone()
+    hashed = token_digest(token)
+    if not row or not hashed or not hmac.compare_digest(row["token_hash"], hashed):
+        raise AdminError("电脑凭据无效，请在这台电脑上重新连接网站", 401)
+    return row
+
+
+def valid_projects(value):
+    """Project names and ids only; directories never leave the computer."""
+    if not isinstance(value, list) or len(value) > PROJECTS_MAX:
+        raise ValueError(f"项目列表须为不超过 {PROJECTS_MAX} 项的列表")
+    projects = []
+    for item in value:
+        project_id, name = (item.get("id"), item.get("name")) if isinstance(item, dict) else (None, None)
+        if not isinstance(project_id, str) or not PROJECT_ID.fullmatch(project_id) or not isinstance(name, str) or not 1 <= len(name) <= PROJECT_NAME_MAX:
+            raise ValueError("项目须包含有效编号与名称")
+        projects.append({"id": project_id, "name": name})
+    return projects
+
+
+def valid_clients(value):
+    """Map each platform the computer can wake to its configured client type."""
+    if not isinstance(value, dict) or len(value) > CLIENTS_MAX or any(
+            not isinstance(key, str) or not isinstance(item, str) or not 0 < len(key) <= CLIENT_FIELD_MAX or not 0 < len(item) <= CLIENT_FIELD_MAX
+            for key, item in value.items()):
+        raise ValueError("软件配置须为平台到客户端类型的对象")
+    return value
+
+
+def machine_sync(connection, machine_id, token, payload, now):
+    """Record the computer's projects and clients, and hand it every launch it has not finished."""
+    require_machine(connection, machine_id, token)
+    projects, clients = valid_projects(payload.get("projects")), valid_clients(payload.get("clients"))
+    begin_write(connection)
+    connection.execute("UPDATE local_machines SET projects=?, clients=?, seen_at=? WHERE id=?",
+                       (json.dumps(projects, ensure_ascii=False), json.dumps(clients, ensure_ascii=False), now, machine_id))
+    rows = connection.execute("SELECT id,request FROM remote_launches WHERE machine_id=? AND status IN ('pending','claimed') ORDER BY created_at",
+                              (machine_id,)).fetchall()
+    return {"launches": [{"id": row["id"], "request": json.loads(row["request"])} for row in rows]}
+
+
+def machine_launch_action(connection, machine_id, launch_id, token, payload, now):
+    """Claim, finish or fail one launch; a finished or failed launch drops its request."""
+    require_machine(connection, machine_id, token)
+    begin_write(connection)
+    row = connection.execute("SELECT * FROM remote_launches WHERE id=? AND machine_id=?", (launch_id, machine_id)).fetchone()
+    if not row:
+        raise LookupError("启动请求不存在")
+    action = payload.get("action")
+    if action not in ("claim", "finish", "fail"):
+        raise ValueError("action 须为 claim、finish 或 fail")
+    if row["status"] not in ("pending", "claimed"):
+        raise FileExistsError("启动请求已结束")
+    if action == "claim":
+        connection.execute("UPDATE remote_launches SET status='claimed', updated_at=? WHERE id=?", (now, launch_id))
+    elif action == "finish":
+        room_id = payload.get("room_id")
+        if not isinstance(room_id, str) or not room_id:
+            raise ValueError("完成启动须提供 room_id")
+        result = {"room_id": room_id, "status": str(payload.get("status") or "")}
+        connection.execute("UPDATE remote_launches SET status='done', request='{}', result=?, error='', updated_at=? WHERE id=?",
+                           (json.dumps(result), now, launch_id))
+    else:
+        stage = payload.get("stage") if payload.get("stage") in LAUNCH_STAGES else "unconfirmed"
+        result = {"stage": stage, **({"room_id": payload["room_id"]} if isinstance(payload.get("room_id"), str) else {})}
+        connection.execute("UPDATE remote_launches SET status='failed', request='{}', result=?, error=?, updated_at=? WHERE id=?",
+                           (json.dumps(result), str(payload.get("error") or "启动失败")[:ERROR_MAX], now, launch_id))
+    return launch_view(connection.execute("SELECT * FROM remote_launches WHERE id=?", (launch_id,)).fetchone())
+
+
+def submit_remote_launch(connection, payload, now):
+    """Queue a room creation for the paired computer; resubmitting the same id replays only a failed launch."""
+    launch_id, machine_id, request = payload.get("id"), payload.get("machine_id"), payload.get("request")
+    if not isinstance(launch_id, str) or not LAUNCH_ID.fullmatch(launch_id):
+        raise ValueError("启动编号无效")
+    if not isinstance(request, dict) or not isinstance(request.get("room"), dict) or request["room"].get("submission_id") != launch_id:
+        raise ValueError("远程启动只用于新建房间，room.submission_id 须与启动编号一致")
+    if request.get("cwd") or request.get("access_file"):
+        raise ValueError("远程启动只能选择电脑上已配置的项目，不能指定路径")
+    begin_write(connection)
+    machine = connection.execute("SELECT * FROM local_machines WHERE id=?", (machine_id,)).fetchone()
+    if not machine:
+        raise LookupError("这台电脑尚未连接网站")
+    project_id = request.get("local_project")
+    if project_id and project_id not in {project["id"] for project in json.loads(machine["projects"])}:
+        raise FileExistsError("所选项目已在电脑上移除或更改，请重新选择")
+    row = connection.execute("SELECT * FROM remote_launches WHERE id=?", (launch_id,)).fetchone()
+    if row and row["machine_id"] != machine_id:
+        raise FileExistsError("启动编号已用于另一台电脑")
+    if not row:
+        connection.execute("INSERT INTO remote_launches (id,machine_id,request,created_at,updated_at) VALUES (?,?,?,?,?)",
+                           (launch_id, machine_id, json.dumps(request, ensure_ascii=False), now, now))
+    elif row["status"] == "failed":
+        connection.execute("UPDATE remote_launches SET status='pending', request=?, result='{}', error='', updated_at=? WHERE id=?",
+                           (json.dumps(request, ensure_ascii=False), now, launch_id))
+    return launch_view(connection.execute("SELECT * FROM remote_launches WHERE id=?", (launch_id,)).fetchone())
+
+
+def remote_launch_status(connection, launch_id):
+    """Read a relayed launch's progress."""
+    row = connection.execute("SELECT * FROM remote_launches WHERE id=?", (launch_id,)).fetchone()
+    if not row:
+        raise LookupError("启动请求不存在")
+    return launch_view(row)

package/backend/schema.sql

@@ -532,8 +532,19 @@ CREATE TABLE IF NOT EXISTS member_executions (
     result TEXT NOT NULL DEFAULT '',
     changes TEXT NOT NULL DEFAULT '',
     cwd TEXT NOT NULL DEFAULT '',
+    activity TEXT NOT NULL DEFAULT '',
+    activity_at INTEGER NOT NULL DEFAULT 0,
     UNIQUE(room_id,client_id)
 );
+-- Progress notes the runner saw a member's software write between tool calls; numbered per execution so a retried renewal adds nothing.
+CREATE TABLE IF NOT EXISTS execution_notes (
+    execution_id INTEGER NOT NULL REFERENCES member_executions(id) ON DELETE CASCADE,
+    seq INTEGER NOT NULL,
+    room_id TEXT NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    text TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    PRIMARY KEY(execution_id,seq)
+);
 -- One live execution per member: different members may run in parallel, one session never twice.
 CREATE UNIQUE INDEX IF NOT EXISTS one_member_execution ON member_executions(member_id)
     WHERE status IN ('dispatched','started');
@@ -729,3 +740,28 @@ END;
 -- The review phase behaved exactly like discussing and was retired; move rows left in it.
 UPDATE topic_settings SET phase='discussing' WHERE phase='reviewing';
 UPDATE discussion_runtime SET resume_phase='discussing' WHERE resume_phase='reviewing';
+
+-- A computer running the local service, paired by the site administrator. Only project names and ids and the
+-- configured client of each platform are published; directories and credentials stay on that computer.
+CREATE TABLE IF NOT EXISTS local_machines (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    token_hash TEXT NOT NULL,
+    projects TEXT NOT NULL DEFAULT '[]',
+    clients TEXT NOT NULL DEFAULT '{}',
+    seen_at INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL
+);
+-- A room launch submitted from a device without the local service; the paired computer claims and runs it.
+-- The request (with the room's new credentials) is cleared once the launch finishes or fails.
+CREATE TABLE IF NOT EXISTS remote_launches (
+    id TEXT PRIMARY KEY,
+    machine_id TEXT NOT NULL,
+    request TEXT NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','claimed','done','failed')),
+    result TEXT NOT NULL DEFAULT '{}',
+    error TEXT NOT NULL DEFAULT '',
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS remote_launches_machine ON remote_launches(machine_id, status);

package/backend/server.py

@@ -21,12 +21,14 @@ from pathlib import Path
 from urllib.parse import parse_qs, quote, urlsplit
 
 from .admin import AdminError, admin_status, login_admin, logout_admin, register_admin, session_valid, update_profile
+from .remote_launch import (list_machines, machine_launch_action, machine_sync, pair_machine, remote_launch_status,
+                            submit_remote_launch)
 from .free_room import (add_member, after_free_message, authorize_free_write, check_answer, check_proxy, execution_action, free_view,
                         inbox, interrupt_member, member_action, member_values, migrate_free_tables, proxy_member, reserve_execution,
                         discussion_members, room_mode, save_room_access, sync_discussion_members, view_execution)
 from .free_room import add_discussion_member, convert_suggestion, discussion_member_action, message_suggestions, save_suggestions, sync_participants
 from .free_room import active_members, adopt_recommendation, ask_members, asks_view, checked_asks, recommend_member, register_member, route_held_messages
-from .free_room import reorder_speakers, speaking_order, stop_room_work
+from .free_room import execution_notes, reorder_speakers, speaking_order, stop_room_work
 from .identity import MAX_ROOM_AGENTS, PARTICIPANTS, is_ai, is_participant
 from .room_import import import_room, imported_attachment
 from .runtime import (authorize_write, begin_write, configure_runtime, event_action,
@@ -61,7 +63,8 @@ ASSETS = {"/": ("index.html", "text/html"),
           "/markdown.js": ("markdown.js", "text/javascript"),
           "/backup.js": ("backup.js", "text/javascript"),
           "/markdown.css": ("markdown.css", "text/css"),
-          "/icons/LICENSE.txt": ("icons/LICENSE.txt", "text/plain")}
+          "/icons/LICENSE.txt": ("icons/LICENSE.txt", "text/plain"),
+          "/icons/typesafe.png": ("icons/typesafe.png", "image/png")}
 ASSETS.update({f"/icons/{name}.svg": (f"icons/{name}.svg", "image/svg+xml")
                for name in ("openai", "claude", "gemini", "deepseek", "qwen", "user")})
 ASSETS.update({"/pdfjs/" + file.relative_to(WEB_ROOT / "pdfjs").as_posix():
@@ -223,12 +226,14 @@ def require_room(connection, room_id):
     room["round_budget"] = dict(budget) if budget else None
     if budget:
         room["opinion_count"] = opinion_count(connection, room_id, room["experts"])
-    room["round_groups"] = budget_round_groups(connection, room_id, room["experts"], budget["base"]) if budget else room["rounds"]
+    session = connection.execute("SELECT id,goal,status,started_message_id,ended_message_id,created_at FROM discussion_sessions WHERE room_id=? ORDER BY id DESC LIMIT 1", (room_id,)).fetchone()
+    room["session"] = dict(session) if session else None
+    room["round_groups"] = budget_round_groups(connection, room_id, room["experts"], budget["base"], room["session"]) if budget else room["rounds"]
     room["runtime"] = runtime_view(connection, room_id)
     room["limits"] = limits_view(connection.execute(LIMITS_SQL, (room_id,)).fetchone(), room)
     room["mode"] = room_mode(connection, room_id)
-    session = connection.execute("SELECT id,goal,status,started_message_id,ended_message_id,created_at FROM discussion_sessions WHERE room_id=? ORDER BY id DESC LIMIT 1", (room_id,)).fetchone()
-    room["session"] = dict(session) if session else None
+    if room["mode"] == "free" and not session:
+        room["round_groups"] = []
     room["members"] = [dict(row) for row in connection.execute(
         """SELECT m.id,m.name,m.adapter,m.role,m.status,m.access,m.session_mode,COALESCE(s.session_id,'') AS reported_session,COALESCE(s.client,'') AS reported_client,
         COALESCE(r.registered_at,'') AS registered_at
@@ -326,27 +331,33 @@ def discussion_rounds(connection, room_id, experts):
     return rounds
 
 
-def budget_round_groups(connection, room_id, experts, base):
+def budget_round_groups(connection, room_id, experts, base, session):
     """Group history by the round budget's rule: every len(experts) opinions form a round, and a new segment (base) starts a new one.
 
+    Only messages of the latest discussion are grouped, numbered from 1; free collaboration before or after it has no rounds.
     `rounds` stays speaker-based because scheduling needs who still owes a turn; this view only labels history.
     """
-    if not experts:
+    if not experts or not session:
         return []
+    first, last = session["started_message_id"], session["ended_message_id"] or float("inf")
     rows = connection.execute("""SELECT messages.id,messages.author,
         COALESCE(details.kind,'opinion') AS kind FROM messages
         LEFT JOIN message_details AS details ON details.message_id=messages.id
         WHERE room_id=? ORDER BY messages.id""", (room_id,))
     groups, next_start, seen = [], None, 0
     for message in rows:
+        opinion = message["kind"] == "opinion" and message["author"] in experts
+        # base counts every opinion in the room, so opinions outside the discussion still advance seen.
+        seen += opinion
+        if not first < message["id"] <= last:
+            continue
         if next_start is None:
             next_start = message["id"]
-        if message["kind"] != "opinion" or message["author"] not in experts:
+        if not opinion:
             continue
         if not groups or groups[-1]["completed"]:
             groups.append({"number": len(groups) + 1, "start_id": next_start, "opinions": 0, "completed": False})
         current = groups[-1]
-        seen += 1
         current["opinions"] += 1
         current["completed"] = current["opinions"] >= len(experts) or seen == base
         if current["completed"]:
@@ -645,7 +656,7 @@ def manage_room(connection, room_id, action, payload):
 
 def delete_room_records(connection, room_id):
     """Remove a room's dependent records in the caller's transaction."""
-    for table in ("member_recommendations", "free_queue", "speaking_orders", "member_requests", "member_executions", "member_sessions", "member_registrations", "room_members", "room_modes", "free_batches", "free_chains", "room_links",
+    for table in ("member_recommendations", "free_queue", "speaking_orders", "member_requests", "execution_notes", "member_executions", "member_sessions", "member_registrations", "room_members", "room_modes", "free_batches", "free_chains", "room_links",
                   "discussion_options", "round_budgets", "scheduler_decisions", "scheduler_routing", "discussion_sessions"):
         if table == "scheduler_decisions":
             for child in ("scheduler_feedback", "scheduler_decision_context", "scheduler_decision_inputs"):
@@ -766,7 +777,8 @@ def start_discussion(connection, room_id, token, payload):
         raise ValueError("named_followup 须为布尔值")
     # A fresh session first, so the phase mirror follows it and not a concluded earlier one.
     if not connection.execute("SELECT 1 FROM discussion_sessions WHERE room_id=? AND status IN ('active','paused')", (room_id,)).fetchone():
-        connection.execute("INSERT INTO discussion_sessions (room_id,goal,status,created_at) VALUES (?,?,'paused',?)", (room_id, settings["goal"], utc_now()))
+        connection.execute("INSERT INTO discussion_sessions (room_id,goal,status,started_message_id,created_at) VALUES (?,?,'paused',?,?)",
+                           (room_id, settings["goal"], room["latest_id"], utc_now()))
     connection.execute("UPDATE rooms SET goal=? WHERE id=?", (settings["goal"], room_id))
     save_topic_settings(connection, room_id, settings)
     connection.execute("UPDATE room_modes SET mode='brainstorm' WHERE room_id=?", (room_id,))
@@ -1556,7 +1568,7 @@ def participation_text(params, free=False):
             "先回答真正的问题，给出理由、证据、适用条件与不确定性；区分事实、推断和建议，引用原文编号，不编造他人的回答。"
             "讨论初始阶段先独立判断，暂不读他人观点；深入讨论先理解对方主张及其最有力的依据，再说明同意、分歧或需要补的证据。"
             "可以坚持有依据的少数意见，也可因新证据修改判断并说明变化。",
-            "输出：先 1–3 句摘要，再给完整正文。",
+            "输出：完整正文；回答较长时先给 1–3 句摘要。",
             "不要操作网页表单、调用写入接口或生成发布链接。读取失败时如实报告，由用户提供复制的材料。",
             *(["自由协作：只回应点名给你的消息（编号见阅读通知），按时间顺序处理，后面的消息可以修正前面的。"] if free else []), footer]
 
@@ -1604,7 +1616,7 @@ def protocol_text(room):
         f"维护话题：POST {base}/topic；actor 加需要修改的上述字段，另可更新 phase（preparing/initial/discussing/paused/concluded）、focus。收束前先完成或取消当前安排；主持人收束还须先 GET {base}/conclusion 取得 blockers 与 revision，并把 revision 作为 conclusion 一并提交（有阻碍项或状态已变会被拒绝）。暂停保留安排；恢复阶段后再继续。",
         f"安排发言：POST {base}/turns；字段 actor、expert、question、submission_id（新 UUID）。同一话题同时只有一个未完成安排；重试沿用同一编号和问题。整轮安排改传 turns=[{{expert,question}},…]（最多 {MAX_PLAN_TURNS} 项），并须先 GET {base}/turns/roster 取得最新专家状态，把返回的 revision 作为 roster 一并提交（名单变化后需重取；须包含 waiting 中的每位专家）：第一项立即生效，其余排队（queued）；每个回答保存后自动交给下一位，最后一位答完再交回主持人。用户留言或修改目标、背景、边界、焦点后（room.held_since 非 0），当前回答完成即交回主持人；主持人处理后用 POST {base}/turns/continue（actor）按原计划继续，或直接创建新安排替换剩余排队（原排队改为 skipped）。",
         f"通知：仅把对象、问题、话题入口交给对应专家，不附背景、摘要或历史。使用已有且获准的会话通道；没有通道时交由用户协助。实际送达后 POST {base}/turns/安排编号，字段 actor、status=notified；取消用 status=cancelled。复制不算送达。",
-        f"专家观点：POST {base}/messages；author、text、submission_id、source=cli，kind=opinion；turn_id（回答的安排编号）可省略，省略时回答你当前有效的安排；可选 reply_to（本话题原文编号）。每次回答同时提供 summary（最多 {MAX_SUMMARY_LENGTH} 字），通常 1–3 句结论先行，保留关键理由、条件和不确定性；summary_by 为原作者或提交者，默认提交者。text 保留完整正文，最多 {MAX_TEXT_LENGTH} 个 Unicode 字符，请求最多 {MAX_BODY_BYTES} 字节；不截断或用摘要完成安排。旧客户端缺少 summary 时不自动生成。",
+        f"专家观点：POST {base}/messages；author、text、submission_id、source=cli，kind=opinion；turn_id（回答的安排编号）可省略，省略时回答你当前有效的安排；可选 reply_to（本话题原文编号）。回答较长时可附 summary（最多 {MAX_SUMMARY_LENGTH} 字），1–3 句结论先行，保留关键理由、条件和不确定性，简短回答不写；summary_by 为原作者或提交者，默认提交者。text 保留完整正文，最多 {MAX_TEXT_LENGTH} 个 Unicode 字符，请求最多 {MAX_BODY_BYTES} 字节；不截断或用摘要完成安排。旧客户端缺少 summary 时不自动生成。",
         f"主持发言：同一消息接口，author={room['host']}、submitted_by={room['host']}、kind=moderation、source=cli；个人观点使用 kind=opinion，不能自动视为共识。",
         f"代发只读专家观点：author 保留原专家，submitted_by={room['host']}、kind=opinion、text 为原文；须关联 turn_id，可附 reply_to。服务保存代发来源；不要冒充专家直接提交。该专家须有当前有效的安排。",
         f"整理状态：POST {base}/state；actor、text（详细状态，最多 {MAX_STATE_LENGTH} 字）、until（依据的消息截止编号）；brief（最多 {MAX_BRIEF_LENGTH} 字）为面向人的主持简报，说明结论、共识、歧义和下一步意图。进度或安排变化后更新；省略 brief 保留旧简报，空字符串清除。所有参与专家各保存一次完整观点才完成一轮；同轮重复发言只计该专家一次，主持说明、用户留言及取消安排不推进轮次。房间 rounds 按当前配置专家和完整历史生成，completed_rounds 为完成轮数，answered_turns 仅为已回答安排数。状态不覆盖原文，也不代表全体一致同意。",
@@ -1825,7 +1837,7 @@ class DiscussionHandler(BaseHTTPRequestHandler):
         site = self.local_request_site(method)
         route = parts[2:]
         if method == "OPTIONS" and route in (["settings"], ["launch"], ["room-models"], ["room-member"], ["models"], ["api-key"], ["api-check"],
-                                             ["scheduler-check"], ["pick-directory"]):
+                                             ["scheduler-check"], ["pick-directory"], ["projects"], ["machine-link"]):
             return self.respond({"ok": True})
         if route == ["settings"] and method in ("GET", "POST"):
             command = "settings"
@@ -1847,6 +1859,10 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             command = "room-member"
         elif route == ["pick-directory"] and method == "POST":
             command = "pick-directory"
+        elif route == ["projects"] and method == "POST":
+            command = "projects"
+        elif route == ["machine-link"] and method == "POST":
+            command = "machine-link"
         else:
             raise LookupError("本机入口不存在")
         payload = None
@@ -1857,6 +1873,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             if command in ("start", "room-config", "room-models", "room-member"):
                 payload.pop("access_file", None)
                 payload.update(site=site, entry="web")
+            if command == "machine-link":
+                payload = {"site": site}
         if command == "room-config" and "participants" in payload:
             return self.save_local_room_configuration(command, payload)
         return self.run_local_command(command, payload)
@@ -1933,6 +1951,30 @@ class DiscussionHandler(BaseHTTPRequestHandler):
         connection.commit()
         return self.respond(result, 201 if parts[2] == "register" else 200)
 
+    def handle_remote_launch_api(self, connection, parts, method):
+        """Pair computers and relay room launches; a computer authenticates with its own token, everything else as the administrator."""
+        now = int(time.time())
+        if len(parts) in (4, 5) and parts[1] == "machines" and method == "POST" and (len(parts) == 4 and parts[3] == "sync" or parts[3:4] == ["launches"]):
+            token = self.headers.get("X-Machine-Token", "")
+            result = (machine_sync(connection, parts[2], token, self.read_payload(), now) if len(parts) == 4
+                      else machine_launch_action(connection, parts[2], parts[4], token, self.read_payload(), now))
+            connection.commit()
+            return self.respond(result)
+        if not self.admin_session(connection):
+            raise AdminError("需要登录管理员账号", 401)
+        if parts == ["api", "machines"] and method == "GET":
+            return self.respond(list_machines(connection, now))
+        if parts == ["api", "machines"] and method == "POST":
+            result = pair_machine(connection, self.read_payload(), now)
+        elif parts == ["api", "remote-launches"] and method == "POST":
+            result = submit_remote_launch(connection, self.read_payload(), now)
+        elif len(parts) == 3 and parts[1] == "remote-launches" and method == "GET":
+            return self.respond(remote_launch_status(connection, parts[2]))
+        else:
+            raise LookupError("地址不存在")
+        connection.commit()
+        return self.respond(result)
+
     def handle_api(self, connection, parts, params, method):
         """Handle room, state, and message operations used by the web UI."""
         if parts == ["api", "health"] and method == "GET":
@@ -1943,6 +1985,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             if not self.admin_session(connection):
                 raise AdminError("需要登录管理员账号", 401)
             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", "rooms"]:
             if method == "GET":
                 return self.respond({**list_rooms(connection, params), "participants": PARTICIPANTS})
@@ -2170,6 +2214,8 @@ class DiscussionHandler(BaseHTTPRequestHandler):
             result = recommend_member(connection, room_id, token, self.read_payload())
         elif len(parts) == 5 and parts[3] == "recommendations" and method == "POST":
             result = adopt_recommendation(connection, room_id, token, int(parts[4]), self.read_payload())
+        elif len(parts) == 6 and parts[3] == "executions" and parts[5] == "notes" and method == "GET":
+            result = execution_notes(connection, room_id, int(parts[4]))
         elif len(parts) == 5 and parts[3] == "executions":
             execution_id = int(parts[4])
             result = (view_execution(connection, room_id, execution_id, token) if method == "GET"