ai_co_discuss 0.2.87 → 0.2.89

package/backend/free_room.py

@@ -17,11 +17,47 @@ import time
 import uuid
 
 from .identity import MAX_ROOM_AGENTS, is_ai
-from .runtime import LEASE_SECONDS, begin_write, require_owner, token_hash
+from .runtime import LEASE_SECONDS, MAX_EXECUTION_SEGMENTS, begin_write, require_owner, save_segments, token_hash
 
 FREE_EXECUTION_MINUTES = 20
 RECENT_REQUESTS = 100
 RECENT_EXECUTIONS = 100
+# The timeline page reads this many recent executions of each kind; with `after` (?3) only those running or ended since.
+# Parameters: ?1 room, ?2 limit, ?3 after (0 reads all). Shared verbatim with the Worker.
+TIMELINE_EXECUTIONS = 100
+TIMELINE_STATES = {"completed": "done", "failed": "failed", "cancelled": "cancelled"}
+TIMELINE_FREE_IDS = "SELECT id FROM member_executions WHERE room_id=?1 AND (?3=0 OR finished_at=0 OR finished_at>=?3) ORDER BY id DESC LIMIT ?2"
+TIMELINE_DISCUSSION_IDS = """SELECT e.id FROM discussion_events e LEFT JOIN event_timings t ON t.event_id=e.id
+    WHERE e.room_id=?1 AND (t.dispatched_at>0 OR e.status='pending') AND (?3=0 OR COALESCE(t.finished_at,0)=0 OR t.finished_at>=?3)
+    ORDER BY e.id DESC LIMIT ?2"""
+# Besides times: the task an execution took on (its request message, or the discussion turn's question), its result
+# (the answer's summary, else the answer's opening), its latest progress note, how many files it changed (NULL when
+# unobserved) and its last output time (free executions only).
+TIMELINE_SQL = f"""SELECT x.*,(SELECT COALESCE(NULLIF(s.text,''),substr(a.text,1,200)) FROM messages a
+        LEFT JOIN message_summaries s ON s.message_id=a.id WHERE a.id=x.answer_id) AS result FROM (
+    SELECT 'free' AS source,e.id,m.name AS member,m.role,e.status,
+        COALESCE((SELECT MIN(r.created_at) FROM member_requests r WHERE r.execution_id=e.id),e.created_at) AS queued_at,
+        e.created_at AS dispatched_at,0 AS started_at,e.finished_at,
+        CASE WHEN e.status='failed' THEN e.result ELSE '' END AS reason,
+        (SELECT parent.execution_id FROM member_requests r JOIN member_requests parent ON parent.answer_id=r.message_id
+            WHERE r.execution_id=e.id AND parent.execution_id IS NOT NULL ORDER BY r.id LIMIT 1) AS parent_id,
+        e.activity_at,(SELECT MIN(r.message_id) FROM member_requests r WHERE r.execution_id=e.id) AS task_id,
+        (SELECT substr(q.text,1,160) FROM messages q WHERE q.id=(SELECT MIN(r.message_id) FROM member_requests r WHERE r.execution_id=e.id)) AS task,
+        (SELECT MAX(r.answer_id) FROM member_requests r WHERE r.execution_id=e.id) AS answer_id,
+        (SELECT n.text FROM execution_notes n WHERE n.execution_id=e.id ORDER BY n.seq DESC LIMIT 1) AS last_note,
+        CASE WHEN e.changes='' THEN NULL ELSE json_array_length(e.changes) END AS changes
+    FROM member_executions e JOIN room_members m ON m.id=e.member_id WHERE e.id IN ({TIMELINE_FREE_IDS})
+    UNION ALL SELECT 'discussion',e.id,e.participant,e.role,e.status,CAST(strftime('%s',e.created_at) AS INTEGER),
+        COALESCE(t.dispatched_at,0),e.started_at,COALESCE(t.finished_at,0),CASE WHEN e.status='failed' THEN e.result ELSE '' END,NULL,
+        0,NULL,(SELECT substr(q.question,1,160) FROM discussion_turns q WHERE q.id=e.turn_id),
+        CASE WHEN e.result LIKE 'message:%' THEN CAST(substr(e.result,9) AS INTEGER) END,NULL,NULL
+    FROM discussion_events e LEFT JOIN event_timings t ON t.event_id=e.id WHERE e.id IN ({TIMELINE_DISCUSSION_IDS})) x"""
+TIMELINE_SEGMENTS_SQL = f"""SELECT source,execution_id,phase,tool,start_ms,end_ms FROM execution_segments WHERE room_id=?1 AND (
+    (source='free' AND execution_id IN ({TIMELINE_FREE_IDS})) OR (source='discussion' AND execution_id IN ({TIMELINE_DISCUSSION_IDS})))
+    ORDER BY source,execution_id,seq"""
+# Only the times of progress notes: the texts are read when the reader hovers one.
+TIMELINE_NOTES_SQL = f"""SELECT execution_id,created_at FROM execution_notes
+    WHERE room_id=?1 AND execution_id IN ({TIMELINE_FREE_IDS}) ORDER BY execution_id,seq"""
 RECENT_CHANGES = 50
 MAX_CHANGED_FILES = 200
 # What a member's software last showed it doing, as reported by the runner with each renewal.
@@ -40,8 +76,10 @@ SCHEDULER_PROVIDERS = ("jev", "decisions")
 RECOMMEND_SECONDS = 60
 # A click sent just before the hint disappears still counts.
 RECOMMEND_GRACE_SECONDS = 5
-# AI-created requests (host dispatches and hand-offs) allowed per chain; each owner message starts a chain.
+# AI-created requests (host dispatches and hand-offs) allowed per chain by default; each owner message starts a chain.
 MAX_AUTO_HOPS = 8
+# The most an owner may allow per chain.
+MAX_AUTO_HOPS_LIMIT = 50
 # A host that left gives up the role; the first active runner member (else manual) then takes it.
 RELEASE_HOST = "UPDATE room_members SET role='member' WHERE room_id=? AND role='host' AND status<>'active'"
 ASSIGN_HOST = """UPDATE room_members SET role='host' WHERE id=(SELECT id FROM room_members WHERE room_id=? AND status='active'
@@ -237,6 +275,32 @@ def execution_notes(connection, room_id, execution_id):
         "SELECT seq,text,created_at FROM execution_notes WHERE execution_id=? ORDER BY seq", (execution_id,))]}
 
 
+def execution_timeline(connection, room_id, after=0):
+    """Read the room's recent executions of both kinds with their phase segments and note times, for the timeline page.
+
+    Times are epoch seconds and segments are millisecond offsets from `dispatched_at`. A free execution's parent is the
+    execution that wrote the message it answers; discussion executions have none. `state` is running, done, failed
+    or cancelled, so the page never interprets execution statuses itself. A positive `after` reads only executions
+    still running or ended since then, so a page following live work rereads little.
+    """
+    if not connection.execute("SELECT 1 FROM rooms WHERE id=?", (room_id,)).fetchone():
+        raise LookupError("房间不存在")
+    params = (room_id, TIMELINE_EXECUTIONS, max(0, int(after)))
+    rows = [dict(row) for row in connection.execute(TIMELINE_SQL, params)]
+    segments, notes = {}, {}
+    for row in connection.execute(TIMELINE_SEGMENTS_SQL, params):
+        segments.setdefault((row["source"], row["execution_id"]), []).append(
+            {key: row[key] for key in ("phase", "tool", "start_ms", "end_ms")})
+    for row in connection.execute(TIMELINE_NOTES_SQL, params):
+        notes.setdefault(row["execution_id"], []).append(row["created_at"])
+    for row in rows:
+        row["state"] = TIMELINE_STATES.get(row["status"], "running")
+        row["segments"] = segments.get((row["source"], row["id"]), [])
+        row["notes"] = notes.get(row["id"], []) if row["source"] == "free" else []
+    return {"now": int(time.time()), "after": params[2], "executions": rows, "execution_limit": TIMELINE_EXECUTIONS,
+            "segment_limit": MAX_EXECUTION_SEGMENTS}
+
+
 def recent_executions(connection, room_id):
     """Return bounded public reports, including requests no longer in the recent request list."""
     rows = connection.execute("""SELECT e.*,
@@ -308,7 +372,7 @@ def free_view(connection, room_id):
     chains = [dict(row) for row in connection.execute(
         "SELECT chain_id,reason FROM free_chains WHERE room_id=? ORDER BY chain_id DESC LIMIT 10", (room_id,))]
     return {"members": members, "requests": requests[::-1], "executions": recent_executions(connection, room_id), "execution_minutes": execution_minutes(connection, room_id),
-            "conflicts": possible_conflicts(connection, room_id, names), "halted_chains": chains, "max_auto_hops": MAX_AUTO_HOPS,
+            "conflicts": possible_conflicts(connection, room_id, names), "halted_chains": chains, "max_auto_hops": auto_hops(connection, room_id),
             "recommendations": recent_recommendations(connection, room_id, now)[::-1]}
 
 
@@ -436,6 +500,8 @@ def check_answer(connection, room_id, member, payload):
     """
     if payload.get("to") is not None:
         named_members(active_members(connection, room_id), payload["to"], exclude=member["name"])
+    if payload.get("handoff") not in (None, False) and (payload["handoff"] is not True or member["role"] != "host" or not payload.get("to")):
+        raise ValueError("handoff 只能由主持人与 to 一起使用，值为 true")
     if member["access"] == "online":
         raise PermissionError("在线成员只读，回答由用户代发")
     if member["access"] == "manual":
@@ -573,11 +639,29 @@ def chain_budget(connection, room_id, chain_id):
         return 0
     used = connection.execute("SELECT COUNT(*) FROM member_requests WHERE room_id=? AND chain_id=? AND created_by='host'",
                               (room_id, chain_id)).fetchone()[0]
-    return MAX_AUTO_HOPS - used
+    return auto_hops(connection, room_id) - used
+
+
+def auto_hops(connection, room_id):
+    """AI-created requests allowed per chain in this room."""
+    row = connection.execute("SELECT max_auto_hops FROM free_settings WHERE room_id=?", (room_id,)).fetchone()
+    return row[0] if row else MAX_AUTO_HOPS
 
 
-def dispatch(connection, room_id, host, message_id, names, chain_id):
-    """Queue the host's named members as one batch that hands back to the host when it ends."""
+def set_auto_hops(connection, room_id, token, payload):
+    """Owner sets the room's chain budget; it applies to chains still running and to later ones."""
+    require_owner(connection, room_id, token)
+    value = payload.get("max_auto_hops")
+    if type(value) is not int or not 1 <= value <= MAX_AUTO_HOPS_LIMIT:
+        raise ValueError(f"max_auto_hops 须为 1–{MAX_AUTO_HOPS_LIMIT} 的整数")
+    begin_write(connection)
+    connection.execute("""INSERT INTO free_settings (room_id,max_auto_hops) VALUES (?,?)
+        ON CONFLICT(room_id) DO UPDATE SET max_auto_hops=excluded.max_auto_hops""", (room_id, value))
+    return {"max_auto_hops": value}
+
+
+def dispatch(connection, room_id, host, message_id, names, chain_id, handoff=False):
+    """Queue the host's named members as one batch; several members, or one the host asked back, hand back when it ends."""
     member_ids = named_members(active_members(connection, room_id), names, exclude=host["name"])
     if not member_ids or not chain_id:
         return
@@ -588,6 +672,8 @@ def dispatch(connection, room_id, host, message_id, names, chain_id):
         insert_request(connection, room_id, member_id, message_id, chain_id, "ask", "host", batch_id=message_id)
     connection.execute("INSERT INTO free_batches (room_id,batch_id,chain_id,host_id) VALUES (?,?,?,?)",
                        (room_id, message_id, chain_id, host["id"]))
+    if handoff:
+        connection.execute("INSERT INTO free_handoffs (room_id,batch_id) VALUES (?,?)", (room_id, message_id))
 
 
 def settle_batches(connection, room_id):
@@ -601,8 +687,9 @@ def settle_batches(connection, room_id):
         host = connection.execute("SELECT * FROM room_members WHERE id=? AND status='active' AND role='host'", (batch["host_id"],)).fetchone()
         if "completed" not in statuses:
             halt_chain(connection, room_id, batch["chain_id"], "all_failed")
-        elif not host or len(statuses) < 2:
-            # One member's answer already reaches the user; only several answers need the host to put them together.
+        elif not host or len(statuses) < 2 and not connection.execute(
+                "SELECT 1 FROM free_handoffs WHERE room_id=? AND batch_id=?", (room_id, batch["batch_id"])).fetchone():
+            # One member's answer reaches the user directly unless the host asked for it back, e.g. to send it to a reviewer.
             continue
         elif chain_budget(connection, room_id, batch["chain_id"]) < 1:
             halt_chain(connection, room_id, batch["chain_id"], "budget")
@@ -784,7 +871,7 @@ def after_free_message(connection, room_id, message_id, actor, payload):
                            (message_id, execution_id))
     connection.execute("UPDATE room_members SET read_until=MAX(read_until,?) WHERE id=?", (message_id, actor["id"]))
     if actor["role"] == "host" and payload.get("to"):
-        dispatch(connection, room_id, actor, message_id, payload["to"], chain_id)
+        dispatch(connection, room_id, actor, message_id, payload["to"], chain_id, payload.get("handoff") is True)
     settle_batches(connection, room_id)
 
 
@@ -1123,6 +1210,13 @@ def execution_action(connection, room_id, execution_id, token, payload):
         if row["changes"]:
             raise FileExistsError("本次执行的改动已记录")
         connection.execute("UPDATE member_executions SET changes=? WHERE id=?", (json.dumps(changed_files(payload), ensure_ascii=False), execution_id))
+    elif action == "segments":
+        # The last segments and notes arrive after the member's answer ended the execution; such notes are dated at its end.
+        finished = 0 if row["status"] in ACTIVE else (row["finished_at"] or 1)
+        notes = renewed_notes(payload)
+        save_segments(connection, "free", room_id, execution_id, row["created_at"], finished, payload, optional=bool(notes))
+        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"], min(now, finished) if finished else now) for note in notes])
     elif row["status"] not in ACTIVE:
         raise FileExistsError("执行已结束")
     elif action == "renew":
@@ -1143,7 +1237,7 @@ def execution_action(connection, room_id, execution_id, token, payload):
         # Only for proven non-delivery: the requests return to the queue unchanged.
         finish_execution(connection, execution_id, "cancelled", str(payload.get("reason") or "未送达"), "pending")
     else:
-        raise ValueError("action 须为 renew、fail、release 或 report")
+        raise ValueError("action 须为 renew、fail、release、report 或 segments")
     return execution_detail(connection, connection.execute("SELECT * FROM member_executions WHERE id=?", (execution_id,)).fetchone())
 
 

package/backend/runtime.py

@@ -16,6 +16,13 @@ LIMITS_SQL = """SELECT limits.*,COALESCE(pauses.paused_seconds,0)+CASE WHEN COAL
     THEN MAX(0,CAST(strftime('%s','now') AS INTEGER)-pauses.paused_at) ELSE 0 END AS idle_seconds
     FROM discussion_limits AS limits LEFT JOIN discussion_pauses AS pauses USING(room_id) WHERE limits.room_id=?"""
 TIMING_ITEMS = 20
+# Phase segments the runner reports for the execution timeline: the phases, how many one execution keeps and one report
+# carries, a tool name's length, and how long after its end an execution still takes its last report.
+SEGMENT_PHASES = ("thinking", "command", "tool", "editing", "writing")
+MAX_EXECUTION_SEGMENTS = 400
+MAX_SEGMENTS_PER_REPORT = 40
+MAX_SEGMENT_TOOL = 60
+SEGMENT_GRACE_SECONDS = 600
 # Queue: created -> dispatched; wake: dispatched -> entered; work: entered -> finished. Open stages run to now.
 TIMING_SQL = """SELECT e.id,e.participant,e.role,e.cause,e.status,
     MAX(0,CASE WHEN t.dispatched_at>0 THEN t.dispatched_at ELSE ? END-CAST(strftime('%s',e.created_at) AS INTEGER)) AS queue_seconds,
@@ -32,6 +39,34 @@ def token_hash(token):
     return hashlib.sha256(token.encode()).hexdigest()
 
 
+def save_segments(connection, source, room_id, execution_id, anchor, finished, payload, optional=False):
+    """Record an execution's phase segments as millisecond offsets from its delivery at `anchor`.
+
+    The runner measures them on its own clock, so they are kept within the execution's own span; `finished` is 0 while
+    it runs. A resent segment keeps the later end, so the open segment can be reported again as it runs on. `optional`
+    allows a report with no segments, when it carries progress notes instead.
+    """
+    now = int(time.time())
+    if finished and finished + SEGMENT_GRACE_SECONDS < now:
+        raise FileExistsError("执行已结束较久，不再接收阶段记录")
+    segments = payload.get("segments", [])
+    if (not isinstance(segments, list) or len(segments) > MAX_SEGMENTS_PER_REPORT or (not segments and not optional) or any(
+            not isinstance(item, dict) or type(item.get("seq")) is not int or not 1 <= item["seq"] <= MAX_EXECUTION_SEGMENTS
+            or item.get("phase") not in SEGMENT_PHASES or not isinstance(item.get("tool", ""), str)
+            or len(item.get("tool", "")) > MAX_SEGMENT_TOOL or type(item.get("start_ms")) is not int
+            or type(item.get("end_ms")) is not int for item in segments)):
+        raise ValueError(f"segments 须为 1–{MAX_SEGMENTS_PER_REPORT} 段 {{seq: 1–{MAX_EXECUTION_SEGMENTS}, "
+                         f"phase: {'、'.join(SEGMENT_PHASES)}, tool: 最多 {MAX_SEGMENT_TOOL} 字, start_ms, end_ms}}")
+    limit = max(0, (finished or now) - anchor + 1) * 1000
+    rows = []
+    for item in segments:
+        start = min(max(item["start_ms"], 0), limit)
+        rows.append((source, execution_id, item["seq"], room_id, item["phase"], item.get("tool", ""), start,
+                     min(max(item["end_ms"], start), limit)))
+    connection.executemany("""INSERT INTO execution_segments (source,execution_id,seq,room_id,phase,tool,start_ms,end_ms)
+        VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(source,execution_id,seq) DO UPDATE SET end_ms=MAX(end_ms,excluded.end_ms)""", rows)
+
+
 def begin_write(connection):
     """Acquire the writer lock once, including when routing already acquired it."""
     if not connection.in_transaction:
@@ -325,6 +360,16 @@ def event_action(connection, room_id, event_id, token, payload):
         raise PermissionError("执行凭据无效")
     if action == "view":
         return {key: event[key] for key in PUBLIC_EVENT_FIELDS}
+    if action == "segments":
+        # A timeline report comes from the runner, also just after the execution ended or its run stopped.
+        if not controller:
+            raise PermissionError("需要本房间的运行控制凭据")
+        timing = connection.execute("SELECT dispatched_at,finished_at FROM event_timings WHERE event_id=?", (event_id,)).fetchone()
+        if not timing or not timing["dispatched_at"]:
+            raise FileExistsError("执行尚未交付")
+        finished = 0 if event["status"] in ("dispatched", "started") else (timing["finished_at"] or 1)
+        save_segments(connection, "discussion", room_id, event_id, timing["dispatched_at"], finished, payload)
+        return {key: event[key] for key in PUBLIC_EVENT_FIELDS}
     if run["status"] != "running" or 0 < run["deadline"] <= now or event["generation"] != run["generation"]:
         raise FileExistsError("本次运行已停止或执行已过期")
     if action == "reserve" and controller: