ai_co_discuss 0.2.71 → 0.2.72

package/.agents/skills/discuss-host/references/manual.md

@@ -34,7 +34,7 @@
 
 ## 在线专家：协助方式与操作恢复
 
-每次请专家回答时，要求同时提供简述与完整正文；简述的写法、保存与署名遵循 discuss-participant。若原回答缺少简述，主持人可据完整原文另行整理并注明摘要归主持人，专家正文保持原样。
+请专家回答时，回答较长的同时提供简述与完整正文；简述的写法、保存与署名遵循 discuss-participant。若长回答缺少简述，主持人可据完整原文另行整理并注明摘要归主持人，专家正文保持原样。
 
 选择「用户手动复制协助」时，每轮在当前聊天给出完整、可复制的提问文本和对应安排编号，由用户发到专家原聊天并贴回完整回答；主持人不自行操作该专家网页或发送问题。用户确认送达后再记录通知，收到并核对对应回答后通过 CLI 原文代发。展示提问文本不算送达，等待用户期间不重复催促。
 

package/.agents/skills/discuss-participant/SKILL.md

@@ -81,7 +81,7 @@ description: "AI CoDiscuss 的通用参与技能，所有参与者（包括主
 
 可以坚持有依据的少数意见，也可以因新证据修改判断并解释变化。主动检查关键反例与遗漏，但不为反对而反对，不以赞同人数代替证据；材料不足时说明什么证据会改变结论。需要对方回应时直接 `@专家名` 并说明具体问题；@ 只是讨论线索，不会通知。
 
-篇幅和结构由问题决定。保留关键数字、条件与失败情形；回应追问只补新论证或观点变化，旧内容用原文编号引用。简述表达主要判断或变化，完整论证与出处放正文，不再复制一遍长清单。
+篇幅和结构由问题决定。保留关键数字、条件与失败情形；回应追问只补新论证或观点变化，旧内容用原文编号引用。回答摘要按需填写（讨论与自由协作相同）：正文较长、读者需要先看结论时，用一两句写主要判断或变化及关键条件；简短回答不写，不把正文复述一遍。完整论证与出处放正文，不再复制一遍长清单。
 
 示例（只示意密度与结构，内容与篇幅按问题而定）：
 

package/.agents/skills/discuss-participant/references/free.md

@@ -6,6 +6,8 @@
 
 没有安排和阶段，不执行 `execution enter`。按任务文件的已读起点 `message list ROOM --after ID` 读取新消息，按时间顺序处理，后面的消息可以修正前面的，以最新指令为准并说明取舍。完成后用 `message post ROOM --as 本人 --kind chat --execution 执行编号 --access-file FILE` 提交一次回答。
 
+任务需要多步操作时，在关键转折处（读完材料、改定方案、验证结果）用一两句中文写出进展，不另调命令：本机接入程序会把这些中途说明显示在网页的处理中卡片，让用户知道你在做什么。只写进展与判断，不复述工具输出，不代替最终回答。
+
 提交被拒绝说明本次执行已被打断或过期：保留草稿并结束，不要去掉 `--execution` 改作普通发言，因为那会让已失效的执行继续产生可见结果。
 
 手动接入的自由成员没有执行编号：从 `room view` 的 `free.requests` 找到自己的待处理请求，回答时用 `--request 请求编号` 关闭。

package/backend/free_room.py

@@ -24,6 +24,12 @@ RECENT_REQUESTS = 100
 RECENT_EXECUTIONS = 100
 RECENT_CHANGES = 50
 MAX_CHANGED_FILES = 200
+# What a member's software last showed it doing, as reported by the runner with each renewal.
+ACTIVITY_PHASES = ("", "thinking", "command", "tool", "editing", "writing")
+# Progress notes per execution, their length, and how many one renewal may carry.
+MAX_EXECUTION_NOTES = 50
+MAX_NOTE_LENGTH = 500
+MAX_NOTES_PER_RENEW = 10
 MAX_PATH_LENGTH = 500
 ACTIVE = ("dispatched", "started")
 ACCESS_MODES = ("runner", "manual", "online")
@@ -44,10 +50,12 @@ QUEUE_ASKED = "EXISTS(SELECT 1 FROM member_requests r WHERE r.message_id={row}.m
 SESSION_MODES = ("new", "borrowed")
 FREE_OPERATIONS = ("messages", "attachments", "move", "folder", "archive", "restore", "delete")
 MEMBER_FIELDS = ("id", "name", "adapter", "role", "status", "access", "session_mode", "read_until")
-EXECUTION_FIELDS = ("id", "member_id", "status", "session_id", "lease_until", "created_at", "finished_at", "result")
+EXECUTION_FIELDS = ("id", "member_id", "status", "session_id", "lease_until", "created_at", "finished_at", "result",
+                    "activity", "activity_at")
 # Columns added after the first free-room tables; Python databases created by that build gain them here.
 LATER_COLUMNS = {"room_members": {"access": "TEXT NOT NULL DEFAULT 'runner'", "session_mode": "TEXT NOT NULL DEFAULT 'new'"},
-                 "member_executions": {"changes": "TEXT NOT NULL DEFAULT ''", "cwd": "TEXT NOT NULL DEFAULT ''"},
+                 "member_executions": {"changes": "TEXT NOT NULL DEFAULT ''", "cwd": "TEXT NOT NULL DEFAULT ''",
+                                       "activity": "TEXT NOT NULL DEFAULT ''", "activity_at": "INTEGER NOT NULL DEFAULT 0"},
                  "member_requests": {"chain_id": "INTEGER NOT NULL DEFAULT 0", "batch_id": "INTEGER NOT NULL DEFAULT 0",
                                      "purpose": "TEXT NOT NULL DEFAULT 'ask'", "created_by": "TEXT NOT NULL DEFAULT 'user'"}}
 
@@ -187,16 +195,30 @@ def public_execution(row):
     return {key: row[key] for key in EXECUTION_FIELDS} if row else None
 
 
+def note_count(connection, execution_id):
+    """How many progress notes an execution has; the texts are read separately so room views stay small."""
+    return connection.execute("SELECT COUNT(*) FROM execution_notes WHERE execution_id=?", (execution_id,)).fetchone()[0]
+
+
+def execution_notes(connection, room_id, execution_id):
+    """Read one execution's progress notes in order, with the same access as the room view."""
+    if not connection.execute("SELECT 1 FROM member_executions WHERE room_id=? AND id=?", (room_id, execution_id)).fetchone():
+        raise LookupError("执行不存在")
+    return {"notes": [dict(row) for row in connection.execute(
+        "SELECT seq,text,created_at FROM execution_notes WHERE execution_id=? ORDER BY seq", (execution_id,))]}
+
+
 def recent_executions(connection, room_id):
     """Return bounded public reports, including requests no longer in the recent request list."""
     rows = connection.execute("""SELECT e.*,
         (SELECT json_group_array(id) FROM member_requests WHERE execution_id=e.id) AS request_ids,
         (SELECT MAX(answer_id) FROM member_requests WHERE execution_id=e.id) AS answer_id,
-        (SELECT MIN(message_id) FROM member_requests WHERE execution_id=e.id) AS request_message_id
+        (SELECT MIN(message_id) FROM member_requests WHERE execution_id=e.id) AS request_message_id,
+        (SELECT COUNT(*) FROM execution_notes WHERE execution_id=e.id) AS note_count
         FROM member_executions e WHERE room_id=? ORDER BY id DESC LIMIT ?""", (room_id, RECENT_EXECUTIONS))
     return [{**public_execution(row), "cwd": row["cwd"], "changes": json.loads(row["changes"] or "[]"),
              "changes_recorded": bool(row["changes"]), "request_ids": json.loads(row["request_ids"]),
-             "answer_id": row["answer_id"], "request_message_id": row["request_message_id"]} for row in rows]
+             "answer_id": row["answer_id"], "request_message_id": row["request_message_id"], "notes": row["note_count"]} for row in rows]
 
 
 def possible_conflicts(connection, room_id, names):
@@ -245,6 +267,7 @@ def free_view(connection, room_id):
         member["execution"] = public_execution(latest)
         if latest and latest["status"] in ACTIVE:
             member["execution"]["stale"] = latest["lease_until"] <= now
+            member["execution"]["notes"] = note_count(connection, latest["id"])
         member["pending"] = connection.execute("SELECT COUNT(*) FROM member_requests WHERE member_id=? AND status='pending'",
                                                (row["id"],)).fetchone()[0]
         members.append(member)
@@ -1037,6 +1060,26 @@ def changed_files(payload):
     return sorted(set(files))
 
 
+def renewed_activity(payload, row, now):
+    """Validate the runner's reported phase; its output time is kept within the execution, since the runner's clock may differ."""
+    activity, activity_at = payload.get("activity"), payload.get("activity_at")
+    if activity not in ACTIVITY_PHASES:
+        raise ValueError(f"activity 须为 {'、'.join(item for item in ACTIVITY_PHASES if item)} 或空")
+    if type(activity_at) is not int:
+        raise ValueError("activity_at 须为秒级时间戳")
+    return activity, min(max(activity_at, row["created_at"]), now)
+
+
+def renewed_notes(payload):
+    """Validate progress notes carried by a renewal; a repeated sequence number is the same note resent."""
+    notes = payload.get("notes", [])
+    if (not isinstance(notes, list) or len(notes) > MAX_NOTES_PER_RENEW or any(
+            not isinstance(note, dict) or type(note.get("seq")) is not int or not 1 <= note["seq"] <= MAX_EXECUTION_NOTES
+            or not isinstance(note.get("text"), str) or not 0 < len(note["text"]) <= MAX_NOTE_LENGTH for note in notes)):
+        raise ValueError(f"notes 须为最多 {MAX_NOTES_PER_RENEW} 条 {{seq: 1–{MAX_EXECUTION_NOTES}, text: 1–{MAX_NOTE_LENGTH} 字}}")
+    return notes
+
+
 def execution_action(connection, room_id, execution_id, token, payload):
     """Runner-side lifecycle: renew, fail, release undelivered work, or report observed file changes."""
     require_owner(connection, room_id, token)
@@ -1057,7 +1100,13 @@ def execution_action(connection, room_id, execution_id, token, payload):
         limit = row["created_at"] + execution_minutes(connection, room_id) * 60
         if row["lease_until"] <= now or limit <= now:
             raise FileExistsError("执行租约或单次时限已到，不能续租")
-        connection.execute("UPDATE member_executions SET lease_until=? WHERE id=?", (min(now + LEASE_SECONDS, limit), execution_id))
+        # Older runners renew without activity; the last reported one is kept.
+        activity, activity_at = renewed_activity(payload, row, now) if "activity" in payload else (row["activity"], row["activity_at"])
+        notes = renewed_notes(payload)
+        connection.execute("UPDATE member_executions SET lease_until=?,activity=?,activity_at=? WHERE id=?",
+                           (min(now + LEASE_SECONDS, limit), activity, activity_at, execution_id))
+        connection.executemany("INSERT OR IGNORE INTO execution_notes (execution_id,seq,room_id,text,created_at) VALUES (?,?,?,?,?)",
+                               [(execution_id, note["seq"], room_id, note["text"], now) for note in notes])
     elif action == "fail":
         finish_execution(connection, execution_id, "failed", str(payload.get("reason") or "执行失败"), "failed")
         settle_batches(connection, room_id)

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');

package/backend/server.py

@@ -26,7 +26,7 @@ from .free_room import (add_member, after_free_message, authorize_free_write, ch
                         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 +61,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 +224,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 +329,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 +654,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 +775,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 +1566,7 @@ def participation_text(params, free=False):
             "先回答真正的问题，给出理由、证据、适用条件与不确定性；区分事实、推断和建议，引用原文编号，不编造他人的回答。"
             "讨论初始阶段先独立判断，暂不读他人观点；深入讨论先理解对方主张及其最有力的依据，再说明同意、分歧或需要补的证据。"
             "可以坚持有依据的少数意见，也可因新证据修改判断并说明变化。",
-            "输出：先 1–3 句摘要，再给完整正文。",
+            "输出：完整正文；回答较长时先给 1–3 句摘要。",
             "不要操作网页表单、调用写入接口或生成发布链接。读取失败时如实报告，由用户提供复制的材料。",
             *(["自由协作：只回应点名给你的消息（编号见阅读通知），按时间顺序处理，后面的消息可以修正前面的。"] if free else []), footer]
 
@@ -1604,7 +1614,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 仅为已回答安排数。状态不覆盖原文，也不代表全体一致同意。",
@@ -2170,6 +2180,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"