ai_co_discuss 0.3.46 → 0.3.49

package/backend/goal_room.py

@@ -0,0 +1,358 @@
+"""Goal mode: a user-set objective the host keeps pursuing; when the room goes idle the runner wakes the host again."""
+
+import hashlib
+import json
+import time
+
+from .free_room import insert_request, record_cancel_reasons, require_member
+from .runtime import begin_write, require_owner
+
+OPEN_STATUSES = ("active", "paused")
+MAX_OBJECTIVE_LENGTH = 2000
+MAX_NOTE_LENGTH = 1000
+MAX_CONTINUES = 1000
+MAX_MINUTES = 7 * 24 * 60
+# The same wake-up failing this many times in a row stops the goal instead of retrying forever.
+FAILED_CONTINUATIONS = 3
+GOAL_AUTHOR = "系统"
+END_LABELS = {"complete": "Goal 已完成", "blocked": "Goal 已停止：卡住", "budget_limited": "Goal 预算已用完：请主持人收尾，总结进展、剩余工作和下一步",
+              "cleared": "Goal 已结束"}
+
+
+def open_goal(connection, room_id):
+    """The room's goal while it is active or paused."""
+    row = connection.execute("SELECT * FROM room_goals WHERE room_id=? AND status IN ('active','paused') ORDER BY id DESC LIMIT 1",
+                             (room_id,)).fetchone()
+    return dict(row) if row else None
+
+
+def goal_host(connection, room_id):
+    """The host the runner can wake; a goal has no meaning without one."""
+    row = connection.execute("SELECT * FROM room_members WHERE room_id=? AND role='host' AND status='active' AND access='runner'",
+                             (room_id,)).fetchone()
+    if not row:
+        raise ValueError("Goal 需要一位由本机唤醒的 AI 主持人")
+    return dict(row)
+
+
+def check_exclusive(connection, room_id):
+    """Goal and discussion never run at the same time."""
+    if connection.execute("SELECT 1 FROM discussion_sessions WHERE room_id=? AND status IN ('active','paused')", (room_id,)).fetchone():
+        raise FileExistsError("讨论进行中；结束讨论后才能开启 Goal")
+    if open_goal(connection, room_id):
+        raise FileExistsError("Goal 已在进行；可用 /goal pause、/goal resume、/goal clear 或 /goal edit 新目标")
+
+
+def clean_objective(value):
+    """An objective is required, single text of bounded length."""
+    objective = str(value or "").strip()
+    if not objective or len(objective) > MAX_OBJECTIVE_LENGTH:
+        raise ValueError(f"Goal 目标须为 1–{MAX_OBJECTIVE_LENGTH} 字")
+    return objective
+
+
+def clean_budget(payload, current=None):
+    """Optional budgets set by the owner: whole numbers, 0 meaning no limit."""
+    result = {}
+    for field, limit in (("max_continues", MAX_CONTINUES), ("max_minutes", MAX_MINUTES)):
+        value = payload.get(field, (current or {}).get(field, 0))
+        if type(value) is not int or not 0 <= value <= limit:
+            raise ValueError(f"{field} 须为 0–{limit} 的整数，0 表示不限")
+        result[field] = value
+    return result
+
+
+def elapsed_seconds(goal, now=None):
+    """Time spent pursuing the goal, excluding pauses."""
+    now = now or int(time.time())
+    end = goal["ended_at"] or now
+    paused = goal["paused_seconds"] + (max(0, end - goal["paused_at"]) if goal["paused_at"] else 0)
+    return max(0, end - goal["started_at"] - paused)
+
+
+def continuation_statuses(connection, goal_id, limit=FAILED_CONTINUATIONS):
+    """Statuses of the goal's latest wake-up requests, newest first."""
+    return [row[0] for row in connection.execute("""SELECT r.status FROM goal_continuations c JOIN member_requests r ON r.id=c.request_id
+        WHERE c.goal_id=? ORDER BY c.id DESC LIMIT ?""", (goal_id, limit))]
+
+
+def room_idle(connection, room_id, goal):
+    """Whether an active goal should wake the host: nothing runs, waits or is held, and the owner did not speak last."""
+    if not goal or goal["status"] != "active":
+        return False
+    busy = connection.execute("""SELECT
+        EXISTS(SELECT 1 FROM member_requests WHERE room_id=?1 AND status IN ('pending','delivering'))
+        OR EXISTS(SELECT 1 FROM member_executions WHERE room_id=?1 AND status IN ('dispatched','started'))
+        OR EXISTS(SELECT 1 FROM free_chain_holds WHERE room_id=?1 AND message_id>0)
+        OR EXISTS(SELECT 1 FROM free_queue_waiting WHERE room_id=?1)
+        OR EXISTS(SELECT 1 FROM queued_messages WHERE room_id=?1)""", (room_id,)).fetchone()[0]
+    if busy:
+        return False
+    last = connection.execute("""SELECT author FROM messages m WHERE room_id=? AND NOT EXISTS(
+        SELECT 1 FROM internal_task_messages t WHERE t.message_id=m.id) ORDER BY id DESC LIMIT 1""", (room_id,)).fetchone()
+    if last and last[0] == "用户":
+        return False
+    # A wake-up that failed did no work, so the next idle moment may try again until the failure limit stops the goal.
+    return bool(goal["armed"]) or continuation_statuses(connection, goal["id"], 1) == ["failed"]
+
+
+def goal_revision(connection, room_id, goal):
+    """Bind state-dependent goal writes to the goal row, the newest message and the room's open work."""
+    latest = connection.execute("SELECT COALESCE(MAX(id),0) FROM messages WHERE room_id=?", (room_id,)).fetchone()[0]
+    work = [list(row) for row in connection.execute(
+        "SELECT id,status FROM member_requests WHERE room_id=? AND status IN ('pending','delivering') ORDER BY id", (room_id,))]
+    session = connection.execute("SELECT id,status FROM discussion_sessions WHERE room_id=? ORDER BY id DESC LIMIT 1", (room_id,)).fetchone()
+    row = [goal[key] for key in ("id", "status", "objective", "armed", "continues", "max_continues", "max_minutes")] if goal else None
+    encoded = json.dumps([room_id, row, latest, work, list(session) if session else None], ensure_ascii=False, separators=(",", ":"))
+    return hashlib.sha256(encoded.encode()).hexdigest()[:16]
+
+
+def goal_view(connection, room_id):
+    """The room's latest goal (open or ended) with usage, idle state and the revision its writes must carry."""
+    row = connection.execute("SELECT * FROM room_goals WHERE room_id=? ORDER BY id DESC LIMIT 1", (room_id,)).fetchone()
+    goal = dict(row) if row else None
+    open_row = goal if goal and goal["status"] in OPEN_STATUSES else None
+    if goal:
+        goal["elapsed_seconds"] = elapsed_seconds(goal)
+        goal["idle"] = room_idle(connection, room_id, goal)
+    return {"goal": goal, "revision": goal_revision(connection, room_id, open_row)}
+
+
+def require_revision(connection, room_id, payload, action):
+    """State-dependent writes carry the revision read from GET goal."""
+    if payload.get("revision") is None:
+        raise ValueError(f"{action}前须先读取 Goal 状态（GET goal）并带上 revision")
+    if str(payload["revision"]) != goal_view(connection, room_id)["revision"]:
+        raise FileExistsError("Goal 或房间状态已变化，请重新读取后再提交")
+
+
+def system_message(connection, room_id, text, key):
+    """A visible goal notice in the transcript; requests created by the goal hang on it."""
+    created_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    cursor = connection.execute("INSERT INTO messages(room_id,author,text,source,submission_id,created_at) VALUES(?,?,?,?,?,?)",
+                                (room_id, GOAL_AUTHOR, text, "goal", key, created_at))
+    connection.execute("INSERT INTO message_details (message_id,kind,submitted_by) VALUES (?,?,?)", (cursor.lastrowid, "goal", GOAL_AUTHOR))
+    return cursor.lastrowid
+
+
+def create_goal(connection, room_id, objective, budget, start_request_id=None):
+    """Open a goal; callers have checked exclusivity and the host.
+
+    A goal opened from the page gets a start notice. One opened from a `/goal` command starts at that message instead:
+    the host's reply sits right under the command, so a separate notice would land after the reply.
+    """
+    now = int(time.time())
+    cursor = connection.execute("""INSERT INTO room_goals (room_id,objective,max_continues,max_minutes,start_request_id,started_at)
+        VALUES (?,?,?,?,?,?)""", (room_id, objective, budget["max_continues"], budget["max_minutes"], start_request_id, now))
+    goal_id = cursor.lastrowid
+    if start_request_id is not None:
+        message_id = connection.execute("SELECT message_id FROM member_requests WHERE id=?", (start_request_id,)).fetchone()[0]
+    else:
+        message_id = system_message(connection, room_id, f"Goal 已开启：{objective}", f"goal-{goal_id}-start")
+    connection.execute("UPDATE room_goals SET started_message_id=? WHERE id=?", (message_id, goal_id))
+    return goal_id
+
+
+def end_goal(connection, goal, status, note=""):
+    """Close the goal with its reason and leave an end notice; the owner clearing it also cancels wake-ups not yet started.
+
+    A spent budget keeps its wrap-up request, and the host ending the goal is itself answering one.
+    """
+    now = int(time.time())
+    paused = max(0, now - goal["paused_at"]) if goal["paused_at"] else 0
+    label = END_LABELS[status] + (f"：{note}" if note else "")
+    message_id = system_message(connection, goal["room_id"], label, f"goal-{goal['id']}-end")
+    connection.execute("""UPDATE room_goals SET status=?,ended_at=?,end_note=?,ended_message_id=?,paused_at=0,paused_seconds=paused_seconds+?
+        WHERE id=?""", (status, now, note, message_id, paused, goal["id"]))
+    if status == "cleared":
+        where = "status='pending' AND id IN (SELECT request_id FROM goal_continuations WHERE goal_id=?)"
+        record_cancel_reasons(connection, where, (goal["id"],), "user_stop")
+        connection.execute(f"UPDATE member_requests SET status='cancelled' WHERE {where}", (goal["id"],))
+
+
+def check_goal_command(connection, room_id, command, argument):
+    """Validate an owner's `/goal` command before its message is saved, so a refused command leaves no message behind."""
+    goal = open_goal(connection, room_id)
+    if command == "start":
+        check_exclusive(connection, room_id)
+        goal_host(connection, room_id)
+        if len(argument) > MAX_OBJECTIVE_LENGTH:
+            raise ValueError(f"Goal 目标最多 {MAX_OBJECTIVE_LENGTH} 字")
+    elif not goal:
+        raise FileExistsError("房间没有进行中的 Goal")
+    elif command == "pause" and goal["status"] != "active":
+        raise FileExistsError("Goal 已经暂停")
+    elif command == "resume" and goal["status"] != "paused":
+        raise FileExistsError("Goal 当前没有暂停")
+    elif command == "edit":
+        clean_objective(argument)
+
+
+def apply_goal_command(connection, room_id, message_id, command, argument):
+    """Run a saved `/goal` message: a start asks the host to fill in the objective, the rest act on the open goal."""
+    if command == "start":
+        host = goal_host(connection, room_id)
+        insert_request(connection, room_id, host["id"], message_id, message_id, "goal_start", "user")
+        return
+    goal = open_goal(connection, room_id)
+    if command == "edit":
+        update_goal(connection, goal, {"objective": argument})
+    else:
+        control_goal(connection, goal, command)
+
+
+def control_goal(connection, goal, action):
+    """Owner controls on the open goal: pause, resume or clear."""
+    now = int(time.time())
+    if action == "pause":
+        if goal["status"] != "active":
+            raise FileExistsError("Goal 已经暂停")
+        connection.execute("UPDATE room_goals SET status='paused',paused_at=? WHERE id=?", (now, goal["id"]))
+    elif action == "resume":
+        if goal["status"] != "paused":
+            raise FileExistsError("Goal 当前没有暂停")
+        connection.execute("""UPDATE room_goals SET status='active',armed=1,paused_seconds=paused_seconds+MAX(0,?-paused_at),paused_at=0
+            WHERE id=?""", (now, goal["id"]))
+    elif action == "clear":
+        end_goal(connection, goal, "cleared", "用户结束")
+    else:
+        raise ValueError("action 须为 start、continue、wait、done、block、pause、resume、clear 或 update")
+
+
+def update_goal(connection, goal, payload):
+    """Owner edits of the open goal's objective or budgets."""
+    objective = clean_objective(payload["objective"]) if "objective" in payload else goal["objective"]
+    budget = clean_budget(payload, goal)
+    connection.execute("UPDATE room_goals SET objective=?,max_continues=?,max_minutes=? WHERE id=?",
+                       (objective, budget["max_continues"], budget["max_minutes"], goal["id"]))
+
+
+def start_goal(connection, room_id, token, payload):
+    """Open a goal: the host completing a `/goal` start request, or the owner from the page with the revision it read."""
+    begin_write(connection)
+    objective = clean_objective(payload.get("objective"))
+    request_id = payload.get("request_id")
+    if request_id is not None:
+        member = require_member(connection, room_id, token)
+        if member["role"] != "host":
+            raise PermissionError("只有主持人能补全并开启 Goal")
+        existing = connection.execute("SELECT id FROM room_goals WHERE start_request_id=?", (request_id,)).fetchone()
+        if existing:
+            return {**goal_view(connection, room_id), "duplicate": True}
+        request = connection.execute("SELECT * FROM member_requests WHERE room_id=? AND id=?", (room_id, request_id)).fetchone()
+        if (not request or request["purpose"] != "goal_start" or request["member_id"] != member["id"]
+                or request["status"] not in ("pending", "delivering")):
+            raise FileExistsError("Goal 启动请求不存在、不属于你或已处理；只有用户的 /goal 命令能开启 Goal")
+        budget = clean_budget({})
+    else:
+        require_owner(connection, room_id, token)
+        require_revision(connection, room_id, payload, "开启 Goal")
+        budget = clean_budget(payload)
+    check_exclusive(connection, room_id)
+    host = goal_host(connection, room_id)
+    goal_id = create_goal(connection, room_id, objective, budget, request_id)
+    if request_id is None:
+        # Started from the page, nobody is working on it yet: hand it to the host right away instead of waiting for idle.
+        message_id = connection.execute("SELECT started_message_id FROM room_goals WHERE id=?", (goal_id,)).fetchone()[0]
+        insert_request(connection, room_id, host["id"], message_id, message_id, "goal_continue", "user")
+        request = connection.execute("SELECT id FROM member_requests WHERE message_id=? AND member_id=?", (message_id, host["id"])).fetchone()[0]
+        connection.execute("INSERT INTO goal_continuations (goal_id,room_id,message_id,request_id) VALUES (?,?,?,?)",
+                           (goal_id, room_id, message_id, request))
+        connection.execute("UPDATE room_goals SET armed=0 WHERE id=?", (goal_id,))
+    return {**goal_view(connection, room_id), "duplicate": False}
+
+
+def continue_goal(connection, room_id, token, payload):
+    """The runner wakes the host once for an idle room; budget and repeated failures end the goal instead."""
+    require_owner(connection, room_id, token)
+    begin_write(connection)
+    require_revision(connection, room_id, payload, "Goal 续跑")
+    goal = open_goal(connection, room_id)
+    if not goal or not room_idle(connection, room_id, goal):
+        raise FileExistsError("Goal 当前不需要续跑")
+    host = goal_host(connection, room_id)
+    if continuation_statuses(connection, goal["id"]) == ["failed"] * FAILED_CONTINUATIONS:
+        end_goal(connection, goal, "blocked", f"连续 {FAILED_CONTINUATIONS} 次续跑执行失败")
+        return goal_view(connection, room_id)
+    over = (goal["max_continues"] and goal["continues"] >= goal["max_continues"]
+            or goal["max_minutes"] and elapsed_seconds(goal) >= goal["max_minutes"] * 60)
+    number = goal["continues"] + 1
+    if over:
+        # The end notice is also where the host's one wrap-up request hangs, so the transcript shows a single card.
+        end_goal(connection, goal, "budget_limited", "")
+        message_id = connection.execute("SELECT ended_message_id FROM room_goals WHERE id=?", (goal["id"],)).fetchone()[0]
+    else:
+        message_id = system_message(connection, room_id, f"Goal 续跑 #{number}：房间已空闲，请主持人继续推进目标。",
+                                    f"goal-{goal['id']}-continue-{number}")
+    insert_request(connection, room_id, host["id"], message_id, message_id, "goal_continue", "user")
+    request_id = connection.execute("SELECT id FROM member_requests WHERE message_id=? AND member_id=?", (message_id, host["id"])).fetchone()[0]
+    connection.execute("INSERT INTO goal_continuations (goal_id,room_id,message_id,request_id,wrapup) VALUES (?,?,?,?,?)",
+                       (goal["id"], room_id, message_id, request_id, int(bool(over))))
+    if not over:
+        connection.execute("UPDATE room_goals SET continues=?,armed=0 WHERE id=?", (number, goal["id"]))
+    return goal_view(connection, room_id)
+
+
+def wait_goal(connection, room_id, token, payload):
+    """The runner's decision model judged the idle room to be waiting for the user: stand down until new work arrives.
+
+    Only an armed goal stands down; an idle moment after a failed wake-up keeps retrying toward the failure limit.
+    """
+    require_owner(connection, room_id, token)
+    begin_write(connection)
+    require_revision(connection, room_id, payload, "Goal 等待用户")
+    goal = open_goal(connection, room_id)
+    if not goal or not goal["armed"] or not room_idle(connection, room_id, goal):
+        raise FileExistsError("Goal 当前不在等待唤醒")
+    connection.execute("UPDATE room_goals SET armed=0 WHERE id=?", (goal["id"],))
+    return goal_view(connection, room_id)
+
+
+def finish_goal(connection, room_id, token, payload, status):
+    """The host declares the goal complete (verified against the current state) or blocked."""
+    begin_write(connection)
+    member = require_member(connection, room_id, token)
+    if member["role"] != "host":
+        raise PermissionError("只有主持人能宣告 Goal 完成或卡住")
+    require_revision(connection, room_id, payload, "宣告 Goal 完成" if status == "complete" else "宣告 Goal 卡住")
+    goal = open_goal(connection, room_id)
+    if not goal:
+        raise FileExistsError("房间没有进行中的 Goal")
+    note = str(payload.get("note") or "").strip()
+    if len(note) > MAX_NOTE_LENGTH or status == "blocked" and not note:
+        raise ValueError(f"说明须为 {'1' if status == 'blocked' else '0'}–{MAX_NOTE_LENGTH} 字；宣告卡住须写明阻碍")
+    if status == "complete":
+        others = [row[0] for row in connection.execute("""SELECT DISTINCT m.name FROM member_requests r JOIN room_members m ON m.id=r.member_id
+            WHERE r.room_id=? AND r.status IN ('pending','delivering') AND r.member_id<>? ORDER BY m.name""", (room_id, member["id"]))]
+        if others:
+            raise ValueError(f"仍有成员的请求未结束：{'、'.join(others)}；等它们完成或取消后再宣告完成")
+    end_goal(connection, goal, status, note)
+    return goal_view(connection, room_id)
+
+
+def goal_action(connection, room_id, token, payload):
+    """Dispatch POST /goal by action; owner controls need the room credential, the host's declarations its own."""
+    action = payload.get("action")
+    if action == "start":
+        return start_goal(connection, room_id, token, payload)
+    if action == "continue":
+        return continue_goal(connection, room_id, token, payload)
+    if action == "wait":
+        return wait_goal(connection, room_id, token, payload)
+    if action in ("done", "block"):
+        return finish_goal(connection, room_id, token, payload, "complete" if action == "done" else "blocked")
+    require_owner(connection, room_id, token)
+    begin_write(connection)
+    goal = open_goal(connection, room_id)
+    if not goal:
+        raise FileExistsError("房间没有进行中的 Goal")
+    if action == "update":
+        update_goal(connection, goal, payload)
+    else:
+        control_goal(connection, goal, action)
+    return goal_view(connection, room_id)
+
+
+def arm_goal(connection, room_id):
+    """New work (an owner message or a host dispatch) lets the next idle moment wake the host again."""
+    connection.execute("UPDATE room_goals SET armed=1 WHERE room_id=? AND status='active'", (room_id,))

package/backend/mode_room.py

@@ -0,0 +1,105 @@
+"""Room modes: the owner's `/goal` and `/discuss` commands, and one view and completion entry for whichever mode is open.
+
+A mode is a built-in way to push the room forward (goal, discussion); at most one is open. Commands are owner
+messages: a bare start asks the host to fill in the objective, subcommands act on the open mode directly.
+"""
+
+import re
+
+from . import goal_room
+from .free_room import insert_request, require_member
+from .runtime import begin_write
+from .session_room import (conclude_session_by_host, control_session, current_session, session_conclusion_view, session_room)
+
+MODE_COMMAND = re.compile(r"^/(goal|discuss)(?:\s+([\s\S]*))?$")
+SUBCOMMANDS = {"goal": ("pause", "resume", "clear", "edit"), "discuss": ("pause", "resume", "stop")}
+MAX_DISCUSSION_GOAL_LENGTH = 1000
+
+
+def parse_mode_command(text):
+    """Split an owner's `/goal …` or `/discuss …` message into (mode, subcommand, argument); None for other text."""
+    match = MODE_COMMAND.match(str(text or "").strip())
+    if not match:
+        return None
+    mode, rest = match.group(1), (match.group(2) or "").strip()
+    parts = rest.split(None, 1)
+    if parts and parts[0] in SUBCOMMANDS[mode]:
+        return mode, parts[0], parts[1].strip() if len(parts) > 1 else ""
+    return mode, "start", rest
+
+
+def check_discuss_command(connection, room_id, command, argument):
+    """Validate a `/discuss` command before its message is saved."""
+    session = current_session(connection, room_id, active_only=True)
+    if command == "start":
+        if session:
+            raise FileExistsError("讨论已在进行；可用 /discuss pause、/discuss resume 或 /discuss stop")
+        if goal_room.open_goal(connection, room_id):
+            raise FileExistsError("Goal 进行中；结束 Goal 后才能开启讨论")
+        goal_room.goal_host(connection, room_id)
+        if len(argument) > MAX_DISCUSSION_GOAL_LENGTH:
+            raise ValueError(f"讨论目标最多 {MAX_DISCUSSION_GOAL_LENGTH} 字")
+    elif not session:
+        raise FileExistsError("房间没有进行中的讨论")
+    elif command == "pause" and session["status"] != "active":
+        raise FileExistsError("讨论已经暂停")
+    elif command == "resume" and session["status"] != "paused":
+        raise FileExistsError("讨论当前没有暂停")
+
+
+def check_mode_command(connection, room_id, payload):
+    """Parse and validate an owner message that is a mode command; None when it is ordinary text."""
+    parsed = parse_mode_command(payload.get("text"))
+    if not parsed:
+        return None
+    mode, command, argument = parsed
+    if payload.get("to"):
+        raise ValueError(f"/{mode} 命令不能同时 @ 成员")
+    if mode == "goal":
+        goal_room.check_goal_command(connection, room_id, command, argument)
+    else:
+        check_discuss_command(connection, room_id, command, argument)
+    return parsed
+
+
+def apply_mode_command(connection, room_id, message_id, parsed):
+    """Run a saved mode command; the owner's message is itself the authority, so no revision is needed."""
+    mode, command, argument = parsed
+    if mode == "goal":
+        goal_room.apply_goal_command(connection, room_id, message_id, command, argument)
+    elif command == "start":
+        host = goal_room.goal_host(connection, room_id)
+        insert_request(connection, room_id, host["id"], message_id, message_id, "discuss_start", "user")
+    else:
+        # The full session view: resuming keys its host request by the session revision.
+        control_session(connection, session_room(connection, room_id)["session"], command)
+
+
+def mode_view(connection, room_id):
+    """Which mode is open and the revision its completion needs: the goal's revision, or the discussion's conclusion."""
+    goal = goal_room.goal_view(connection, room_id)
+    if goal["goal"] and goal["goal"]["status"] in goal_room.OPEN_STATUSES:
+        return {"mode": "goal", "status": goal["goal"]["status"], "revision": goal["revision"], "goal": goal["goal"]}
+    session = current_session(connection, room_id, active_only=True)
+    if session:
+        conclusion = session_conclusion_view(connection, room_id)
+        return {"mode": "discussion", "status": session["status"], "revision": conclusion["revision"],
+                "discussion": {"id": session["id"], "goal": session["goal"], **conclusion}}
+    return {"mode": None, "status": None, "revision": None}
+
+
+def finish_mode(connection, room_id, token, payload):
+    """The host completes whichever mode is open, with the revision `GET mode` returned."""
+    action = payload.get("action")
+    if action != "done":
+        raise ValueError("action 须为 done；宣告 Goal 卡住用 goal block")
+    begin_write(connection)
+    mode = mode_view(connection, room_id)
+    if mode["mode"] == "goal":
+        return goal_room.finish_goal(connection, room_id, token, payload, "complete")
+    if mode["mode"] == "discussion":
+        if require_member(connection, room_id, token)["role"] != "host":
+            raise PermissionError("只有主持人能宣告讨论完成")
+        conclude_session_by_host(connection, room_id, {"conclusion": payload.get("revision")})
+        return mode_view(connection, room_id)
+    raise FileExistsError("房间没有进行中的 Goal 或讨论")